Namespaces is not preserved or compared for enum values

[vessd]

Enum values that include a namespace prefix (e.g. tns:Sender) are currently treated as literal strings during serialization/deserialization.

https://www.w3.org/2003/05/soap-envelope/soap-envelope.xsd

  <xs:simpleType name="faultcodeEnum">
    <xs:restriction base="xs:QName">
      <xs:enumeration value="tns:DataEncodingUnknown"/>
      <xs:enumeration value="tns:MustUnderstand"/>
      <xs:enumeration value="tns:Receiver"/>
      <xs:enumeration value="tns:Sender"/>
      <xs:enumeration value="tns:VersionMismatch"/>
    </xs:restriction>
  </xs:simpleType>

Code gen for quick-xml

#[derive(Debug)]
pub enum FaultcodeEnum {
    TnsDataEncodingUnknown,
    TnsMustUnderstand,
    TnsReceiver,
    TnsSender,
    TnsVersionMismatch,
}
impl SerializeBytes for FaultcodeEnum {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::TnsDataEncodingUnknown => Ok(Some(Cow::Borrowed("tns:DataEncodingUnknown"))),
            Self::TnsMustUnderstand => Ok(Some(Cow::Borrowed("tns:MustUnderstand"))),
            Self::TnsReceiver => Ok(Some(Cow::Borrowed("tns:Receiver"))),
            Self::TnsSender => Ok(Some(Cow::Borrowed("tns:Sender"))),
            Self::TnsVersionMismatch => Ok(Some(Cow::Borrowed("tns:VersionMismatch"))),
        }
    }
}
impl DeserializeBytes for FaultcodeEnum {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"tns:DataEncodingUnknown" => Ok(Self::TnsDataEncodingUnknown),
            b"tns:MustUnderstand" => Ok(Self::TnsMustUnderstand),
            b"tns:Receiver" => Ok(Self::TnsReceiver),
            b"tns:Sender" => Ok(Self::TnsSender),
            b"tns:VersionMismatch" => Ok(Self::TnsVersionMismatch),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}

[Bergmann89]

Hey @vessd,

this is a special case, because your enum is based on xs:QName. In general enums are just strings, to keep the generator as flexible and general as possible. I'm not sure if and how we should add support for this to xsd-parser. We can check if xs:QName is a base type of the enum, to enable namespace resolving for it, but then we only have special support for xs:QName and any other special values will still fail.

May you already have a suggestion on how to solve this, otherwise I'll work out a possible solution that supports different enum base types in general.

[vessd]

I didn’t realize this was a special case and haven’t really thought about a solution yet. Looking at my XSD files, QNames appear very rarely.

The main problem with the current code generation is that it’s technically incorrect, but full support might not even be worth it. I would personally prefer to just treat it as a string instead of an enum.

To come up with a good solution, I’d need a better sense of what other variants are possible. Looking at this enum, I might imagine something like:

struct QName<T> {
    prefix: NamespacePrefix,
    namespace: Namespace,
    content: T,
}

…but again, it’s hard to judge how viable this would be in the general case.

[Bergmann89]

I didn't talk about QName only. I meant enum types that has a different base type then just xs:string. My current idea is to resolve the base type of the enum to a simple type (QName, string, integer, ...) and then let the type definition of that type generate suitable constants, than can then be used in the match or an if-else-list.

Like so:

pub enum FaultcodeEnum {
    DataEncodingUnknown,
    MustUnderstand,
    Receiver,
    Sender,
    VersionMismatch,
}

impl FaultcodeEnum  {
    pub const DATA_ENCODING_UNKNOWN: QName = QName::new_const("DataEncodingUnknown", "http://test-namespace");
    pub const MUST_UNDERSTAND: QName = QName::new_const("MustUnderstand", "http://test-namespace");
    pub const RECEIVER: QName = QName::new_const("Receiver", "http://test-namespace");
    pub const SENDER: QName = QName::new_const("Sender", "http://test-namespace");
    pub const VERSION_MISMATCH: QName = QName::new_const("VersionMismatch", "http://test-namespace");
}

impl SerializeBytes for FaultcodeEnum {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::DataEncodingUnknown => Self::DATA_ENCODING_UNKNOWN.serialize_bytes(helper),
            Self::MustUnderstand => Self::MUST_UNDERSTAND.serialize_bytes(helper),
            Self::Receiver => Self::RECEIVER.serialize_bytes(helper),
            Self::Sender => Self::SENDER.serialize_bytes(helper),
            Self::VersionMismatch => Self::VERSION_MISMATCH.serialize_bytes(helper),
        }
    }
}

impl DeserializeBytes for FaultcodeEnum {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        let value = QName::deserialize_bytes(helper)?;

        if value == Self::DATA_ENCODING_UNKNOWN {
            Ok(Self::DataEncodingUnknown)
        } else if value == Self::MUST_UNDERSTAND {
            Ok(Self::MustUnderstand)
        } else if value == Self::RECEIVER {
            Ok(Self::Receiver)
        } else if value == Self::SENDER {
            Ok(Self::Sender)
        } else if value == Self::VERSION_MISMATCH {
            Ok(Self::VersionMismatch)
        } else {
            Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(bytes),
            )))
        }
    }
}

But I need to have a look if this really fits into the current code base.

[Bergmann89]

Hey @vessd,

I had some time to have a look into this issue again and implemented a suitable solution according to the example provided above in #241. Feel free to have a look into the related unit tests for details about the usage. Let me know if there is anything missing 😊

[vessd]

Sorry for the delayed response. I’ve tried the new functionality and ran into a couple of issues.

With EnumConstants, this enum generates both a variant H264 and a constant H264, which ultimately leads to conflicts in the SerializeBytes implementation:

<xs:simpleType name="VideoEncoding">
	<xs:restriction base="xs:string">
		<xs:enumeration value="JPEG"/>
		<xs:enumeration value="MPEG4"/>
		<xs:enumeration value="H264"/>
	</xs:restriction>
</xs:simpleType>

#[derive(Clone, Debug, PartialEq)]
pub enum VideoEncoding {
    Jpeg,
    Mpeg4,
    H264,
}
impl VideoEncoding {
    pub const JPEG: &str = "JPEG";
    pub const MPEG_4: &str = "MPEG4";
    pub const H264: &str = "H264";
}
impl SerializeBytes for VideoEncoding {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Jpeg => Ok(Some(Cow::Borrowed(Self::JPEG))),
            Self::Mpeg4 => Ok(Some(Cow::Borrowed(Self::MPEG_4))),
            Self::H264 => Ok(Some(Cow::Borrowed(Self::H264))),
        }
    }
}

With the with_qname_type option enabled, the interpreter seems to stumble over the following definition:

<xsd:simpleType name="SimpleTopicExpression">
  <xsd:restriction base="xsd:QName">
    <xsd:annotation>
      <xsd:documentation>
The pattern allows strings matching the following EBNF:
RootTopic            ::=   QName  
                    
      </xsd:documentation>
    </xsd:annotation>
  </xsd:restriction>
</xsd:simpleType>

I’m not entirely sure about this one, though — here are the logs.

Build log

     INFO xsd_parser: Interpret Schema
      at /home/sergey/.cargo/git/checkouts/xsd-parser-71060526679bbdb6/45b00d6/xsd-parser/src/lib.rs:205 on main ThreadId(1)
      in xsd_parser::exec_interpreter_with_ident_cache with config: InterpreterConfig { types: [(IdentQuadruple { ns: Some(Prefix(NamespacePrefix(b"xs"))), schema: None, name: "duration", type_: Type }, MetaType { variant: Custom(CustomType { name: "Duration", include: Some("crate::types::Duration"), default: false, namespaces: [], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] }), (IdentQuadruple { ns: Some(Prefix(NamespacePrefix(b"xs"))), schema: None, name: "dateTime", type_: Type }, MetaType { variant: Custom(CustomType { name: "DateTime", include: Some("crate::types::DateTime"), default: false, namespaces: [], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] }), (IdentQuadruple { ns: Some(Namespace(Namespace(b"http://www.w3.org/2001/XMLSchema"))), schema: None, name: "QName", type_: Type }, MetaType { variant: Custom(CustomType { name: "QName", include: Some("::xsd_parser_types::xml::QName"), default: true, namespaces: [Namespace(Namespace(b"http://www.w3.org/2001/XMLSchema"))], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] })], flags: InterpreterFlags(BUILDIN_TYPES | DEFAULT_TYPEDEFS | WITH_XS_ANY_TYPE | WITH_NUM_BIG_INT | NONZERO_TYPEDEFS | WITH_XS_ANY_SIMPLE_TYPE), debug_output: None, naming: None }

    ERROR xsd_parser::pipeline::interpreter::state::generate_types::variant_processor: unreachable: Unexpected type: Some(
      Custom(
          CustomType {
              name: "QName",
              include: Some(
                  "::xsd_parser_types::xml::QName",
              ),
              default: true,
              namespaces: [
                  Namespace(
                      Namespace(b"http://www.w3.org/2001/XMLSchema"),
                  ),
              ],
              allow_any: false,
          },
      ),
  )
      at /home/sergey/.cargo/git/checkouts/xsd-parser-71060526679bbdb6/45b00d6/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs:440 on main ThreadId(1)
      in xsd_parser::pipeline::interpreter::state::generate_types::variant_processor::apply_simple_type_restriction with ty: Restriction { id: None, base: Some(QName { raw: b"xsd:QName", ns: Some(Namespace(b"http://www.w3.org/2001/XMLSchema")) }), content: [Annotation(Annotation { id: None, content: [Documentation(Element { name: "xsd:documentation", values: [Text("\x0A  The pattern allows strings matching the following EBNF:\x0A    RootTopic            ::=   QName  \x0A                        \x0A        ")], attributes: Attributes({}), namespaces: Namespaces({Key("xsd"): Value("http://www.w3.org/2001/XMLSchema"), Key("wstop"): Value("http://docs.oasis-open.org/wsn/t-1")}) })] })] }
      in xsd_parser::pipeline::interpreter::state::generate_types::variant_processor::apply_simple_type with ty: SimpleBaseType { id: None, final_: None, name: Some("SimpleTopicExpression"), content: [Restriction(Restriction { id: None, base: Some(QName { raw: b"xsd:QName", ns: Some(Namespace(b"http://www.w3.org/2001/XMLSchema")) }), content: [Annotation(Annotation { id: None, content: [Documentation(Element { name: "xsd:documentation", values: [Text("\x0A  The pattern allows strings matching the following EBNF:\x0A    RootTopic            ::=   QName  \x0A                        \x0A        ")], attributes: Attributes({}), namespaces: Namespaces({Key("xsd"): Value("http://www.w3.org/2001/XMLSchema"), Key("wstop"): Value("http://docs.oasis-open.org/wsn/t-1")}) })] })] })] }
      in xsd_parser::pipeline::interpreter::finish
      in xsd_parser::exec_interpreter_with_ident_cache with config: InterpreterConfig { types: [(IdentQuadruple { ns: Some(Prefix(NamespacePrefix(b"xs"))), schema: None, name: "duration", type_: Type }, MetaType { variant: Custom(CustomType { name: "Duration", include: Some("crate::types::Duration"), default: false, namespaces: [], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] }), (IdentQuadruple { ns: Some(Prefix(NamespacePrefix(b"xs"))), schema: None, name: "dateTime", type_: Type }, MetaType { variant: Custom(CustomType { name: "DateTime", include: Some("crate::types::DateTime"), default: false, namespaces: [], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] }), (IdentQuadruple { ns: Some(Namespace(Namespace(b"http://www.w3.org/2001/XMLSchema"))), schema: None, name: "QName", type_: Type }, MetaType { variant: Custom(CustomType { name: "QName", include: Some("::xsd_parser_types::xml::QName"), default: true, namespaces: [Namespace(Namespace(b"http://www.w3.org/2001/XMLSchema"))], allow_any: false }), form: None, schema: None, display_name: None, redefined_base: None, documentation: [] })], flags: InterpreterFlags(BUILDIN_TYPES | DEFAULT_TYPEDEFS | WITH_XS_ANY_TYPE | WITH_NUM_BIG_INT | NONZERO_TYPEDEFS | WITH_XS_ANY_SIMPLE_TYPE), debug_output: None, naming: None }


  --- stderr

  thread 'main' (16655) panicked at /home/sergey/.cargo/git/checkouts/xsd-parser-71060526679bbdb6/45b00d6/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs:440:22:
  internal error: entered unreachable code: Unexpected type: Some(
      Custom(
          CustomType {
              name: "QName",
              include: Some(
                  "::xsd_parser_types::xml::QName",
              ),
              default: true,
              namespaces: [
                  Namespace(
                      Namespace(b"http://www.w3.org/2001/XMLSchema"),
                  ),
              ],
              allow_any: false,
          },
      ),
  )
  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

[Bergmann89]

Hey @vessd,

Thanks for testing. I had a short look and patched the two issues you had in #243. Feel free to have a look and test again 😊