chemicalml 0.2.0 → 0.3.0

data/lib/chemicalml/cml/elements.rb

@@ -9,137 +9,181 @@ module Chemicalml
     module Elements
       ALL = {
         # Originally modeled elements
-        Array:             :array,
-        Atom:              :atom,
-        AtomArray:         :atomArray,
-        AtomParity:        :atomParity,
-        Bond:              :bond,
-        BondArray:         :bondArray,
-        BondStereo:        :bondStereo,
-        Dictionary:        :dictionary,
-        DictionaryEntry:   :entry,
-        Document:          :document,
-        Formula:           :formula,
-        Identifier:        :identifier,
-        Label:             :label,
-        List:              :list,
-        Matrix:            :matrix,
-        Metadata:          :metadata,
-        MetadataList:      :metadataList,
-        Module:            :module,
-        Molecule:          :molecule,
-        Name:              :name,
-        Parameter:         :parameter,
-        ParameterList:     :parameterList,
-        Product:           :product,
-        ProductList:       :productList,
-        Property:          :property,
-        PropertyList:      :propertyList,
-        Reaction:          :reaction,
-        ReactionList:      :reactionList,
-        Reactant:          :reactant,
-        ReactantList:      :reactantList,
-        Scalar:            :scalar,
-        Substance:         :substance,
-        Unit:              :unit,
-        UnitList:          :unitList,
-        UnitType:          :unitType,
-        UnitTypeList:      :unitTypeList,
+        Array: :array,
+        Atom: :atom,
+        AtomArray: :atomArray,
+        AtomParity: :atomParity,
+        Bond: :bond,
+        BondArray: :bondArray,
+        BondStereo: :bondStereo,
+        Dictionary: :dictionary,
+        DictionaryEntry: :entry,
+        Document: :document,
+        Formula: :formula,
+        Identifier: :identifier,
+        Label: :label,
+        List: :list,
+        Matrix: :matrix,
+        Metadata: :metadata,
+        MetadataList: :metadataList,
+        Module: :module,
+        Molecule: :molecule,
+        Name: :name,
+        Parameter: :parameter,
+        ParameterList: :parameterList,
+        Product: :product,
+        ProductList: :productList,
+        Property: :property,
+        PropertyList: :propertyList,
+        Reaction: :reaction,
+        ReactionList: :reactionList,
+        Reactant: :reactant,
+        ReactantList: :reactantList,
+        Scalar: :scalar,
+        Substance: :substance,
+        Unit: :unit,
+        UnitList: :unitList,
+        UnitType: :unitType,
+        UnitTypeList: :unitTypeList,
         # Full schema coverage — every CML element from the XSD
-        Abundance:           :abundance,
-        Action:              :action,
-        ActionList:          :actionList,
-        Amount:              :amount,
-        Angle:               :angle,
-        AnyCml:              :anyCml,
-        ArrayList:           :arrayList,
-        AtomSet:             :atomSet,
-        AtomType:            :atomType,
-        AtomTypeList:        :atomTypeList,
+        Abundance: :abundance,
+        Action: :action,
+        ActionList: :actionList,
+        Amount: :amount,
+        Angle: :angle,
+        AnyCml: :anyCml,
+        ArrayList: :arrayList,
+        AtomSet: :atomSet,
+        AtomType: :atomType,
+        AtomTypeList: :atomTypeList,
         AtomicBasisFunction: :atomicBasisFunction,
-        Band:                :band,
-        BandList:            :bandList,
-        BasisSet:            :basisSet,
-        BondSet:             :bondSet,
-        BondType:            :bondType,
-        BondTypeList:        :bondTypeList,
-        CellParameter:       :cellParameter,
-        ConditionList:       :conditionList,
-        Crystal:             :crystal,
-        Definition:          :definition,
-        Description:         :description,
-        Dimension:           :dimension,
-        Documentation:       :documentation,
-        Eigen:               :eigen,
-        Electron:            :electron,
-        Fragment:            :fragment,
-        FragmentList:        :fragmentList,
-        Gradient:            :gradient,
-        Isotope:             :isotope,
-        IsotopeList:         :isotopeList,
-        Join:                :join,
-        Kpoint:              :kpoint,
-        KpointList:          :kpointList,
-        Lattice:             :lattice,
-        LatticeVector:       :latticeVector,
-        Length:              :length,
-        Line3:               :line3,
-        Link:                :link,
-        Map:                 :map,
-        Mechanism:           :mechanism,
-        MechanismComponent:  :mechanismComponent,
-        MoleculeList:        :moleculeList,
-        Object:              :object,
-        Observation:         :observation,
-        Particle:            :particle,
-        Peak:                :peak,
-        PeakGroup:           :peakGroup,
-        PeakList:            :peakList,
-        PeakStructure:       :peakStructure,
-        Plane3:              :plane3,
-        Point3:              :point3,
-        Potential:           :potential,
-        PotentialForm:       :potentialForm,
-        PotentialList:       :potentialList,
-        ReactionScheme:      :reactionScheme,
-        ReactionStep:        :reactionStep,
-        ReactionStepList:    :reactionStepList,
-        ReactiveCentre:      :reactiveCentre,
-        Region:              :region,
-        Sample:              :sample,
-        Spectator:           :spectator,
-        SpectatorList:       :spectatorList,
-        Spectrum:            :spectrum,
-        SpectrumData:        :spectrumData,
-        SpectrumList:        :spectrumList,
-        Sphere3:             :sphere3,
-        Stmml:               :stmml,
-        SubstanceList:       :substanceList,
-        Symmetry:            :symmetry,
-        System:              :system,
-        Table:               :table,
-        TableCell:           :tableCell,
-        TableContent:        :tableContent,
-        TableHeader:         :tableHeader,
-        TableHeaderCell:     :tableHeaderCell,
-        TableRow:            :tableRow,
-        TableRowList:        :tableRowList,
-        Torsion:             :torsion,
-        Transform3:          :transform3,
-        TransitionState:     :transitionState,
-        Vector3:             :vector3,
-        Xaxis:               :xaxis,
-        Yaxis:               :yaxis,
-        ZMatrix:             :zMatrix,
+        Band: :band,
+        BandList: :bandList,
+        BasisSet: :basisSet,
+        BondSet: :bondSet,
+        BondType: :bondType,
+        BondTypeList: :bondTypeList,
+        CellParameter: :cellParameter,
+        ConditionList: :conditionList,
+        Crystal: :crystal,
+        Definition: :definition,
+        Description: :description,
+        Dimension: :dimension,
+        Documentation: :documentation,
+        Eigen: :eigen,
+        Electron: :electron,
+        Fragment: :fragment,
+        FragmentList: :fragmentList,
+        Gradient: :gradient,
+        Isotope: :isotope,
+        IsotopeList: :isotopeList,
+        Join: :join,
+        Kpoint: :kpoint,
+        KpointList: :kpointList,
+        Lattice: :lattice,
+        LatticeVector: :latticeVector,
+        Length: :length,
+        Line3: :line3,
+        Link: :link,
+        Map: :map,
+        Mechanism: :mechanism,
+        MechanismComponent: :mechanismComponent,
+        MoleculeList: :moleculeList,
+        Object: :object,
+        Observation: :observation,
+        Particle: :particle,
+        Peak: :peak,
+        PeakGroup: :peakGroup,
+        PeakList: :peakList,
+        PeakStructure: :peakStructure,
+        Plane3: :plane3,
+        Point3: :point3,
+        Potential: :potential,
+        PotentialForm: :potentialForm,
+        PotentialList: :potentialList,
+        ReactionScheme: :reactionScheme,
+        ReactionStep: :reactionStep,
+        ReactionStepList: :reactionStepList,
+        ReactiveCentre: :reactiveCentre,
+        Region: :region,
+        Sample: :sample,
+        Spectator: :spectator,
+        SpectatorList: :spectatorList,
+        Spectrum: :spectrum,
+        SpectrumData: :spectrumData,
+        SpectrumList: :spectrumList,
+        Sphere3: :sphere3,
+        Stmml: :stmml,
+        SubstanceList: :substanceList,
+        Symmetry: :symmetry,
+        System: :system,
+        Table: :table,
+        TableCell: :tableCell,
+        TableContent: :tableContent,
+        TableHeader: :tableHeader,
+        TableHeaderCell: :tableHeaderCell,
+        TableRow: :tableRow,
+        TableRowList: :tableRowList,
+        Torsion: :torsion,
+        Transform3: :transform3,
+        TransitionState: :transitionState,
+        Vector3: :vector3,
+        Xaxis: :xaxis,
+        Yaxis: :yaxis,
+        ZMatrix: :zMatrix
       }.freeze
 
-      # Elements that exist in Schema 3 but NOT in Schema 2.4.
-      SCHEMA3_ONLY = %i[Module].freeze
+      # Elements declared in the Schema 3 XSD but absent from the
+      # Schema 2.4 XSD. Verified by diffing the actual XSDs in
+      # `reference-docs/schemas/`: Schema 3 declares `<anyCml>` while
+      # Schema 2.4 does not. Conversely, Schema 2.4 declares 17 legacy
+      # elements (`alternative`, `annotation`, `appinfo`, `arg`,
+      # `complexObject`, `enumeration`, `expression`, `float`,
+      # `floatArray`, `integer`, `integerArray`, `operator`,
+      # `relatedEntry`, `string`, `stringArray`, `tcell`, `trow`) that
+      # are either redundant with Schema 3's unified types or outside
+      # the gem's scope.
+      SCHEMA3_ONLY = %i[AnyCml].freeze
+
+      # Subset of the Schema-2.4-only legacy elements that the gem
+      # explicitly models. Maps Ruby class name → XML element id so
+      # `Schema24::Configuration` can register them without polluting
+      # `Elements::ALL` (which mirrors Schema 3's element set).
+      SCHEMA24_ONLY = {
+        Alternative: :alternative,
+        Annotation: :annotation,
+        Appinfo: :appinfo,
+        Arg: :arg,
+        ComplexObject: :complexObject,
+        Enumeration: :enumeration,
+        Expression: :expression,
+        Float: :float,
+        FloatArray: :floatArray,
+        Integer: :integer,
+        IntegerArray: :integerArray,
+        Operator: :operator,
+        RelatedEntry: :relatedEntry,
+        String: :string,
+        StringArray: :stringArray,
+        Tcell: :tcell,
+        Trow: :trow
+      }.freeze
+
+      # Schema24-only elements whose XML element id collides with a
+      # lutaml-model primitive type name (`:string`, `:integer`,
+      # `:float`). Registering them as types would shadow the
+      # primitive, breaking every `attribute :foo, :string` cast.
+      # They remain defined as wire classes and parseable as roots,
+      # but `register_elements!` skips registering them in the
+      # schema24 type context.
+      SCHEMA24_TYPE_COLLISIONS = %i[Float Integer String].freeze
 
       # Reverse index: XML element name (String) → Ruby class name
       # (Symbol). O(1) lookup for VersionedParser root detection.
-      XML_TO_CLASS = ALL.each_with_object({}) do |(cls, xml_id), h|
-        h[xml_id.to_s] = cls
+      # Includes both Schema 3 elements and the modeled Schema 2.4
+      # legacy elements.
+      XML_TO_CLASS = [ALL, SCHEMA24_ONLY].each_with_object({}) do |src, h|
+        src.each { |cls, xml_id| h[xml_id.to_s] = cls }
       end.freeze
     end
   end

data/lib/chemicalml/cml/enums.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    # Canonical Ruby source of truth for every XSD simpleType that
+    # restricts to an enumeration. Generated from
+    # `reference-docs/schemas/schema3/schema.xsd`. Constants are
+    # frozen Sets — adding a new value means changing the XSD, then
+    # regenerating this file.
+    #
+    # Naming: XSD `fooType` → Ruby `FOO_VALUES`. The `Type` suffix is
+    # stripped before uppercasing. Constants ending in `_VALUES` are
+    # Sets of allowed string values for the corresponding attribute.
+    module Enums
+      ACTIONORDER_VALUES = Set.new(%w[sequential parallel]).freeze
+      # All 120 element type codes from XSD elementTypeType, including
+      # the special "Du" (dummy) and "R" (undefined/group placeholder).
+      # Use this to validate atom.elementType values.
+      ELEMENT_TYPE_VALUES = Set.new(%w[Ac Al Ag Am Ar As At Au B Ba Bh Bi Be Bk Br C Ca Cd Ce Cf Cl Cm Co Cr Cs Cu Db
+                                       Dy Er Es Eu F Fe Fm Fr Ga Gd Ge H He Hf Hg Ho Hs I In Ir K Kr La Li Lr Lu Md Mg Mn Mo Mt N Na Nb Nd Ne Ni No Np O Os P Pa Pb Pd Pm Po Pr Pt Pu Ra Rb Re Rf Rh Rn Ru S Sb Sc Se Sg Si Sm Sn Sr Ta Tb Tc Te Th Ti Tl Tm U Uun Uuu Uub Uut Uuq Uup Uuh Uus Uuo V W Xe Y Yb Zn Zr Du R]).freeze
+      ANGLEUNITS_VALUES = Set.new(%w[degrees radians]).freeze
+      CELLPARAMETER_VALUES = Set.new(%w[length angle]).freeze
+      CHIRALITY_VALUES = Set.new(%w[enantiomer racemate unknown other]).freeze
+      DIMENSION_VALUES = Set.new(%w[mass length time current amount luminosity temperature dimensionless angle]).freeze
+      EIGENORIENTATION_VALUES = Set.new(%w[columnVectors rowVectors other]).freeze
+      ERRORBASIS_VALUES = Set.new(%w[observedRange observedStandardDeviation observedStandardError
+                                     estimatedStandardDeviation estimatedStandardError other]).freeze
+      FORMAT_VALUES = Set.new(%w[1D 2Dsymm 2Dasymm other]).freeze
+      FT_VALUES = Set.new(%w[raw transformed none other]).freeze
+      INHERIT_VALUES = Set.new(%w[merge replace delete]).freeze
+      LATTICE_VALUES = Set.new(%w[primitive full aCentred other]).freeze
+      LINKTYPE_VALUES = Set.new(%w[extended locator arc]).freeze
+      LM_VALUES = Set.new(%w[s p px py pz d dxy dyz dxz dx2y2 dz2 f g]).freeze
+      MATRIX_VALUES = Set.new(%w[rectangular square squareSymmetric squareSymmetricLT squareSymmetricUT
+                                 squareAntisymmetric squareAntisymmetricLT squareAntisymmetricUT diagonal upperTriangular upperTriangularUT lowerTriangular lowerTriangularLT unit unitary rowEigenvectors rotation22 rotationTranslation32 homogeneous33 rotation33 rotationTranslation43 homogeneous44 other]).freeze
+      MEASUREMENT_VALUES = Set.new(%w[transmittance absorbance other]).freeze
+      ORDER_VALUES = Set.new(%w[S 1 D 2 T 3 A unknown other]).freeze
+      PEAKMULTIPLICITY_VALUES = Set.new(%w[singlet doublet triplet quartet quintet sextuplet multiplet other]).freeze
+      PEAKSHAPE_VALUES = Set.new(%w[sharp broad shoulder other]).freeze
+      PEAKSTRUCTURETYPE_VALUES = Set.new(%w[coupling splitting other]).freeze
+      REACTIONFORMAT_VALUES = Set.new(%w[reactantProduct cmlSnap other]).freeze
+      REACTIONROLE_VALUES = Set.new(%w[complete overall rateDeterminingStep step steps other]).freeze
+      REACTIONSTEPLISTTYPE_VALUES = Set.new(%w[unknown consecutive choice simultaneous other]).freeze
+      REACTIONTYPE_VALUES = Set.new(%w[chainReaction initiation termination reversible other]).freeze
+      SCHEME_VALUES = Set.new(%w[unknown sequence choice and other]).freeze
+      SHAPE_VALUES = Set.new(%w[rectangular triangularDecreasing. triangularIncreasing. irregular other]).freeze
+      SPACE_VALUES = Set.new(%w[real k-space Fourier reciprocal other]).freeze
+      SPECTRUMTYPE_VALUES = Set.new(%w[infrared massSpectrum NMR UV/VIS other]).freeze
+      STATE_VALUES = Set.new(%w[aqueous gas glass liquid nematic smectic solid solidSolution solution other]).freeze
+      STEREO_VALUES = Set.new(%w[C T W H undefined other]).freeze
+      SUBSTANCELISTTYPE_VALUES = Set.new(%w[solution mixture other]).freeze
+      TABLETYPE_VALUES = Set.new(%w[rowBased arrayBased contentBased other]).freeze
+    end
+  end
+end

data/lib/chemicalml/cml/namespace.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Chemicalml
   module Cml
     # The default CML XML namespace. CML itself doesn't actually
@@ -9,8 +8,8 @@ module Chemicalml
     # future schema-validation work and so consumers can request
     # namespaced output via the `namespace:` serialisation option.
     class Namespace < Lutaml::Xml::W3c::XmlNamespace
-      uri "http://www.xml-cml.org/schema"
-      prefix_default "cml"
+      uri 'http://www.xml-cml.org/schema'
+      prefix_default 'cml'
       element_form_default :unqualified
     end
   end

data/lib/chemicalml/cml/patterns.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    # Canonical Ruby source of truth for every XSD simpleType that
+    # restricts by `xsd:pattern`. Generated from
+    # `reference-docs/schemas/schema3/schema.xsd`. Constants are
+    # frozen Regexp objects — adding a new pattern means changing
+    # the XSD, then regenerating this file.
+    #
+    # Naming: XSD `fooType` → Ruby `FOO_PATTERN`. The `Type` suffix
+    # is stripped before uppercasing.
+    module Patterns
+      ATOM_ID_PATTERN = /[A-Za-z_][A-Za-z0-9_-]*(:[A-Za-z0-9_-]+)?/
+      BOND_REF_PATTERN = /[A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)?/
+      DELIMITER_PATTERN = %r{[!%\^*@~;#,|/]}
+      DICTIONARY_PREFIX_PATTERN = /[A-Za-z][A-Za-z0-9_.-]*/
+      # formulaType pattern from the XSD. Allows concise formula
+      # notation like "C 2 H 6 O 1".
+      FORMULA_PATTERN = /\s*([A-Z][a-z]?\s+(([0-9]+(\.[0-9]*)?)|(\.[0-9]*))?\s*)+(\s+-?[0-9]+)?\s*/
+      HEAD_PATTERN = /[A-Za-z][A-Za-z0-9_]*/
+      ID_PATTERN = /[A-Za-z][A-Za-z0-9.\-_]*/
+      ISOTOPIC_SPIN_PATTERN = /\d{1,}(\d+)?/
+      MOLECULE_ID_PATTERN = /[A-Za-z_][A-Za-z0-9_-]*(:[A-Za-z0-9_-]+)?/
+      NAMESPACE_REF_PATTERN = /[A-Za-z][A-Za-z0-9_]*:[A-Za-z][A-Za-z0-9_.-]*/
+      NAMESPACE_PATTERN = %r{http://[A-Za-z][A-Za-z0-9_.-]*(/[A-Za-z0-9_.-]+)+[/#]?}
+      REF_PATTERN = /([A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*/
+      REPEAT_PATTERN = /[A-Za-z]+ [A-Za-z0-9_\-+]+ [A-Za-z0-9_\-+]+/
+      TAIL_PATTERN = /[A-Za-z][A-Za-z0-9_]*/
+      VERSION_PATTERN = /[0-9]+(\.[0-9]+[A-Za-z0-9.\-_]*)*/
+    end
+  end
+end

data/lib/chemicalml/cml/reference_resolver.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    # Walks a CML document and resolves id-based references to the
+    # actual target wire instances. Useful for callers that need to
+    # follow CML references programmatically (e.g. bond → atoms,
+    # atomParity → atoms, map → molecules).
+    #
+    # References are attribute values like `atomRefs2="a1 a2"`,
+    # `atomRefs4="a1 a2 a3 a4"`, `bondRefs="b1 b2"`, `ref="m1"`.
+    # The values are whitespace-separated lists of ids.
+    #
+    # The resolver is opt-in: it does not modify the wire tree. Callers
+    # use it to perform lookups; unresolved refs are reported in a
+    # list (a constraint turns this list into warnings).
+    class ReferenceResolver
+      attr_reader :document
+
+      # @param document [Lutaml::Model::Serializable] the CML document
+      #   to walk. Must include `Chemicalml::Cml::Visitable` (the
+      #   standard wire classes do).
+      def initialize(document)
+        @document = document
+        @atom_index = nil
+        @bond_index = nil
+      end
+
+      # Lazily-built {id => Atom} index. Speeds up `find_atom` and
+      # reference-resolution lookups from O(n) to O(1).
+      def atom_index
+        @atom_index ||= begin
+          hash = {}
+          document.each_atom { |a| hash[a.id] = a if a.id }
+          hash
+        end
+      end
+
+      # Lazily-built {id => Bond} index.
+      def bond_index
+        @bond_index ||= begin
+          hash = {}
+          document.each_bond { |b| hash[b.id] = b if b.id }
+          hash
+        end
+      end
+
+      # Returns the Atom with the given id within the given molecule,
+      # or nil if not found.
+      def find_atom(_molecule, atom_id)
+        return nil unless atom_id
+
+        atom_index[atom_id]
+      end
+
+      # Returns the Bond with the given id within the given molecule,
+      # or nil if not found.
+      def find_bond(_molecule, bond_id)
+        return nil unless bond_id
+
+        bond_index[bond_id]
+      end
+
+      # Resolves `bond.atom_refs2` to a pair of [Atom, Atom]. Returns
+      # nils for missing atoms so callers can detect partial misses.
+      def resolve_atom_refs2(bond, molecule = containing_molecule(bond))
+        ids = parse_refs(bond&.atom_refs2)
+        return [] if ids.empty?
+        return [nil, nil] if ids.size != 2
+
+        ids.map { |id| find_atom(molecule, id) }
+      end
+
+      # Walks the whole document and reports every reference attribute
+      # whose target id is missing. Returns a list of hashes:
+      #
+      #   { node: <Bond>, attr: :atom_refs2, missing: ["a99"] }
+      def unresolved_refs
+        results = []
+        visit(@document) do |node|
+          results.concat(unresolved_for(node))
+        end
+        results
+      end
+
+      private
+
+      def visit(node, &block)
+        return unless node.is_a?(Lutaml::Model::Serializable)
+
+        yield(node)
+        return unless node.is_a?(Chemicalml::Cml::Visitable)
+
+        node.wire_children.each { |child| visit(child, &block) }
+      end
+
+      # Returns all molecules in the document (top-level + nested)
+      def all_molecules
+        result = []
+        visit(@document) do |node|
+          result << node if node.is_a?(Chemicalml::Cml::Role::Molecule)
+        end
+        result
+      end
+
+      def containing_molecule(node)
+        # The constraint walker doesn't track parents. For now, return
+        # the first molecule in document order — the common case is
+        # that bond atoms live in the same parent molecule.
+        all_molecules.find { |m| m.bond_array && (m.bond_array.bonds || []).include?(node) }
+      end
+
+      def parse_refs(value)
+        return [] if value.nil?
+
+        value.to_s.split(/\s+/).reject(&:empty?)
+      end
+
+      def unresolved_for(node)
+        return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
+
+        ids = parse_refs(node.atom_refs2)
+        return [] if ids.empty?
+
+        # Use the global atom_index (O(1) per lookup) — the
+        # `containing_molecule` indirection is unnecessary for
+        # reference resolution at the document level. CML semantics
+        # already enforce that bond refs live in the parent molecule
+        # (caught by `BondMustReferenceAtomsInSameMolecule`).
+        missing = ids.reject { |id| atom_index[id] }
+        return [] if missing.empty?
+
+        [{ node: node, attr: :atom_refs2, missing: missing }]
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/alternative.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Alternative
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/annotation.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Annotation
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/appinfo.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Appinfo
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/arg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Arg
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/cml_module.rb

@@ -4,9 +4,8 @@ module Chemicalml
   module Cml
     module Role
       # Type marker for any wire class implementing the CML
-      # <module> element. Included by Schema3::Module.
-      # (Schema24::Module does not exist - schema 2.4 lacks the
-      # generic <module> element.)
+      # <module> element. Included by both Schema3::Module and
+      # Schema24::Module.
       module Module
       end
     end

data/lib/chemicalml/cml/role/complex_object.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module ComplexObject
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/enumeration.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Enumeration
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/expression.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Expression
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/float.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Float
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/float_array.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module FloatArray
+      end
+    end
+  end
+end