chemicalml 0.2.0 → 0.3.0

data/lib/chemicalml/convention/molecular/constraints.rb

@@ -5,31 +5,77 @@ module Chemicalml
     module Molecular
       module Constraints
         autoload :AtomArrayMustContainAtoms,
-                 "chemicalml/convention/molecular/constraints/atom_array_must_contain_atoms"
+                 'chemicalml/convention/molecular/constraints/atom_array_must_contain_atoms'
         autoload :AtomIdsUniqueWithinMolecule,
-                 "chemicalml/convention/molecular/constraints/atom_ids_unique_within_molecule"
+                 'chemicalml/convention/molecular/constraints/atom_ids_unique_within_molecule'
         autoload :BondMustReferenceAtomsInSameMolecule,
-                 "chemicalml/convention/molecular/constraints/bond_must_reference_atoms_in_same_molecule"
+                 'chemicalml/convention/molecular/constraints/bond_must_reference_atoms_in_same_molecule'
         autoload :AtomMustHaveId,
-                 "chemicalml/convention/molecular/constraints/atom_must_have_id"
+                 'chemicalml/convention/molecular/constraints/atom_must_have_id'
         autoload :AtomMustHaveElementType,
-                 "chemicalml/convention/molecular/constraints/atom_must_have_element_type"
+                 'chemicalml/convention/molecular/constraints/atom_must_have_element_type'
         autoload :BondMustHaveAtomRefs2,
-                 "chemicalml/convention/molecular/constraints/bond_must_have_atom_refs2"
+                 'chemicalml/convention/molecular/constraints/bond_must_have_atom_refs2'
         autoload :BondMustHaveOrder,
-                 "chemicalml/convention/molecular/constraints/bond_must_have_order"
+                 'chemicalml/convention/molecular/constraints/bond_must_have_order'
         autoload :MoleculeMustHaveId,
-                 "chemicalml/convention/molecular/constraints/molecule_must_have_id"
+                 'chemicalml/convention/molecular/constraints/molecule_must_have_id'
         autoload :AtomCoordinatesMustBePaired,
-                 "chemicalml/convention/molecular/constraints/atom_coordinates_must_be_paired"
+                 'chemicalml/convention/molecular/constraints/atom_coordinates_must_be_paired'
         autoload :PropertyMustHaveDictRef,
-                 "chemicalml/convention/molecular/constraints/property_must_have_dict_ref"
+                 'chemicalml/convention/molecular/constraints/property_must_have_dict_ref'
         autoload :ScalarMustHaveDataType,
-                 "chemicalml/convention/molecular/constraints/scalar_must_have_data_type"
+                 'chemicalml/convention/molecular/constraints/scalar_must_have_data_type'
         autoload :BondOrderShouldNotBeNumeric,
-                 "chemicalml/convention/molecular/constraints/bond_order_should_not_be_numeric"
+                 'chemicalml/convention/molecular/constraints/bond_order_should_not_be_numeric'
         autoload :AtomIdMustMatchPattern,
-                 "chemicalml/convention/molecular/constraints/atom_id_must_match_pattern"
+                 'chemicalml/convention/molecular/constraints/atom_id_must_match_pattern'
+        autoload :MoleculeCountMustNotAppearOnTopLevel,
+                 'chemicalml/convention/molecular/constraints/molecule_count_must_not_appear_on_top_level'
+        autoload :MoleculeAtomArrayMutuallyExclusiveWithChildren,
+                 'chemicalml/convention/molecular/constraints/molecule_atom_array_mutually_exclusive_with_children'
+        autoload :MoleculeBondArrayMutuallyExclusiveWithChildren,
+                 'chemicalml/convention/molecular/constraints/molecule_bond_array_mutually_exclusive_with_children'
+        autoload :BondStereoWedgeHashMustHaveAtomRefs2,
+                 'chemicalml/convention/molecular/constraints/bond_stereo_wedge_hash_must_have_atom_refs2'
+        autoload :BondStereoCisTransMustHaveAtomRefs4,
+                 'chemicalml/convention/molecular/constraints/bond_stereo_cis_trans_must_have_atom_refs4'
+        autoload :BondStereoOtherMustHaveDictRef,
+                 'chemicalml/convention/molecular/constraints/bond_stereo_other_must_have_dict_ref'
+        autoload :BondIdsUniqueWithinMolecule,
+                 'chemicalml/convention/molecular/constraints/bond_ids_unique_within_molecule'
+        autoload :BondOrderOtherMustHaveDictRef,
+                 'chemicalml/convention/molecular/constraints/bond_order_other_must_have_dict_ref'
+        autoload :AtomArrayMustBeChildOfMoleculeOrFormula,
+                 'chemicalml/convention/molecular/constraints/atom_array_must_be_child_of_molecule_or_formula'
+        autoload :BondArrayMustBeChildOfMolecule,
+                 'chemicalml/convention/molecular/constraints/bond_array_must_be_child_of_molecule'
+        autoload :BondOrderShouldBeInEnum,
+                 'chemicalml/convention/molecular/constraints/bond_order_should_be_in_enum'
+        autoload :BondStereoShouldBeInEnum,
+                 'chemicalml/convention/molecular/constraints/bond_stereo_should_be_in_enum'
+        autoload :MoleculeChiralityShouldBeInEnum,
+                 'chemicalml/convention/molecular/constraints/molecule_chirality_should_be_in_enum'
+        autoload :BondAtomRefs2ShouldBeDistinct,
+                 'chemicalml/convention/molecular/constraints/bond_atom_refs2_should_be_distinct'
+        autoload :ReferencesShouldResolve,
+                 'chemicalml/convention/molecular/constraints/references_should_resolve'
+        autoload :BondStereoAtomRefs4ShouldBeDistinct,
+                 'chemicalml/convention/molecular/constraints/bond_stereo_atom_refs4_should_be_distinct'
+        autoload :AtomParityAtomRefs4ShouldBeDistinct,
+                 'chemicalml/convention/molecular/constraints/atom_parity_atom_refs4_should_be_distinct'
+        autoload :AtomElementTypeShouldBeInPeriodicTable,
+                 'chemicalml/convention/molecular/constraints/atom_element_type_should_be_in_periodic_table'
+        autoload :DictRefShouldResolve,
+                 'chemicalml/convention/molecular/constraints/dict_ref_should_resolve'
+        autoload :MoleculeIdShouldMatchPattern,
+                 'chemicalml/convention/molecular/constraints/molecule_id_should_match_pattern'
+        autoload :BondIdShouldMatchPattern,
+                 'chemicalml/convention/molecular/constraints/bond_id_should_match_pattern'
+        autoload :AtomParityShouldIncludeParentAtom,
+                 'chemicalml/convention/molecular/constraints/atom_parity_should_include_parent_atom'
+        autoload :PropertyScalarDataTypeMatchesDictionary,
+                 'chemicalml/convention/molecular/constraints/property_scalar_data_type_matches_dictionary'
       end
     end
   end

data/lib/chemicalml/convention/molecular.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module Molecular
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/molecular/constraints"
+      autoload :Constraints, 'chemicalml/convention/molecular/constraints'
 
-      QNAME = "convention:molecular".freeze
+      QNAME = 'convention:molecular'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}molecular".freeze
 
       def self.qname
@@ -34,6 +34,29 @@ module Chemicalml
       register Constraints::ScalarMustHaveDataType
       register Constraints::BondOrderShouldNotBeNumeric
       register Constraints::AtomIdMustMatchPattern
+      register Constraints::MoleculeCountMustNotAppearOnTopLevel
+      register Constraints::MoleculeAtomArrayMutuallyExclusiveWithChildren
+      register Constraints::MoleculeBondArrayMutuallyExclusiveWithChildren
+      register Constraints::BondStereoWedgeHashMustHaveAtomRefs2
+      register Constraints::BondStereoCisTransMustHaveAtomRefs4
+      register Constraints::BondStereoOtherMustHaveDictRef
+      register Constraints::BondIdsUniqueWithinMolecule
+      register Constraints::BondOrderOtherMustHaveDictRef
+      register Constraints::AtomArrayMustBeChildOfMoleculeOrFormula
+      register Constraints::BondArrayMustBeChildOfMolecule
+      register Constraints::BondOrderShouldBeInEnum
+      register Constraints::BondStereoShouldBeInEnum
+      register Constraints::MoleculeChiralityShouldBeInEnum
+      register Constraints::BondAtomRefs2ShouldBeDistinct
+      register Constraints::ReferencesShouldResolve
+      register Constraints::BondStereoAtomRefs4ShouldBeDistinct
+      register Constraints::AtomParityAtomRefs4ShouldBeDistinct
+      register Constraints::AtomElementTypeShouldBeInPeriodicTable
+      register Constraints::DictRefShouldResolve
+      register Constraints::MoleculeIdShouldMatchPattern
+      register Constraints::BondIdShouldMatchPattern
+      register Constraints::AtomParityShouldIncludeParentAtom
+      register Constraints::PropertyScalarDataTypeMatchesDictionary
     end
   end
 end

data/lib/chemicalml/convention/registry.rb

@@ -23,25 +23,110 @@ module Chemicalml
         convention.validate(document)
       end
 
+      def self.validate_report(document, qname:)
+        convention = lookup(qname)
+        raise ArgumentError, "unknown convention: #{qname.inspect}" unless convention
+
+        convention.validate_report(document)
+      end
+
+      # Detect the convention from the document's root `convention`
+      # attribute and validate. Raises ArgumentError if the document
+      # declares no convention or an unknown one.
+      def self.detect_and_validate(document)
+        qname = Convention::Detection.convention_of(document)
+        raise ArgumentError, 'document declares no convention attribute' unless qname
+
+        validate_report(document, qname: qname)
+      end
+
       def self.builtin_qnames
         load_cache.keys.sort
       end
 
+      # Iterate every registered convention. Yields the convention
+      # module. Enumerable-style: returns an Enumerator if no block.
+      #
+      # @yield [Module] each convention module.
+      # @return [Array<Module>, Enumerator] the conventions if a
+      #   block is given; otherwise an Enumerator.
+      def self.each(&)
+        return to_enum(:each) unless block_given?
+
+        load_cache.values.sort_by(&:qname).each(&)
+      end
+
+      # Iterate every constraint across every convention. Yields
+      # (convention, constraint_class) pairs. Useful for documentation
+      # generation and code introspection.
+      #
+      # @yieldparam convention [Module] the convention module.
+      # @yieldparam constraint [Class] the constraint class.
+      # @return [Enumerator, Integer] count if block given; otherwise
+      #   an Enumerator.
+      def self.each_constraint(&)
+        return to_enum(:each_constraint) unless block_given?
+
+        count = 0
+        each do |conv|
+          conv.constraints.each do |constraint|
+            yield(conv, constraint)
+            count += 1
+          end
+        end
+        count
+      end
+
+      # Total count of registered constraints across all conventions.
+      def self.total_constraint_count
+        each.sum(&:constraint_count)
+      end
+
+      # True if a document with the given Role could carry a
+      # convention attribute that Detection would recognise.
+      #
+      # @param role [Module] a Role::* module.
+      # @return [Boolean]
+      def self.convention_root?(role)
+        Detection::CONVENTION_ROOTS.any? { |r| role <= r }
+      rescue StandardError
+        Detection::CONVENTION_ROOTS.include?(role)
+      end
+
+      # Register a custom convention at runtime. The convention module
+      # must extend `Chemicalml::Convention::Base` and implement
+      # `qname` and `namespace_uri`.
+      #
+      # @param mod [Module] the convention module (must `extend Base`).
+      # @return [Module] the registered module.
+      # @raise [ArgumentError] if `mod.qname` is nil/empty.
+      def self.register_custom(mod)
+        qname = mod.qname
+        raise ArgumentError, 'convention module must return a non-empty qname' if qname.nil? || qname.to_s.empty?
+
+        # Force load_cache to populate (acquires/releases mutex internally),
+        # then mutate directly without re-entering the mutex.
+        cache = load_cache
+        cache[qname.to_s] = mod
+        mod
+      end
+
       def self.reset!
-        @mutex.synchronize { @cache = nil }
+        @mutex.synchronize { @load_cache = nil }
       end
 
       def self.load_cache
         @mutex.synchronize do
-          @cache ||= begin
-            {
-              Molecular.qname            => Molecular,
-              Compchem.qname             => Compchem,
-              Dictionary.qname           => Dictionary,
-              UnitDictionary.qname       => UnitDictionary,
-              UnitTypeDictionary.qname   => UnitTypeDictionary
-            }
-          end
+          @load_cache ||= {
+            Molecular.qname => Molecular,
+            Compchem.qname => Compchem,
+            Dictionary.qname => Dictionary,
+            UnitDictionary.qname => UnitDictionary,
+            UnitTypeDictionary.qname => UnitTypeDictionary,
+            Spectroscopy.qname => Spectroscopy,
+            Cascade.qname => Cascade,
+            SimpleUnit.qname => SimpleUnit
+          }
         end
       end
       private_class_method :load_cache

data/lib/chemicalml/convention/simple_unit/constraints/root_must_be_unit_list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module SimpleUnit
+      module Constraints
+        # The root of a simpleUnit document MUST be a `<unitList>`
+        # declaring `convention="convention:simpleUnit"`. Any other
+        # root shape is rejected.
+        class RootMustBeUnitList < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = 'The root of a simpleUnit document MUST be a `<unitList>` declaring `convention="convention:simpleUnit"`. Any other root shape is rejected.'
+          def check(document)
+            return [] if document.is_a?(Chemicalml::Cml::Role::UnitList) &&
+                         document.convention == 'convention:simpleUnit'
+
+            [violation(path: '/',
+                       message: 'simpleUnit root must be <unitList> declaring ' \
+                                'convention="convention:simpleUnit"')]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/simple_unit/constraints/unit_must_have_power.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module SimpleUnit
+      module Constraints
+        # A `<unit>` under simpleUnit MUST declare a `power` attribute
+        # (integer). Without a power the unit's exponent is undefined.
+        class UnitMustHavePower < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<unit>` under simpleUnit MUST declare a `power` attribute (integer). Without a power the unit's exponent is undefined."
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            power = node.power.to_s.strip
+            return [] unless power.empty?
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} must declare a power attribute",
+                       value: node.power)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/simple_unit/constraints/unit_must_have_symbol.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module SimpleUnit
+      module Constraints
+        # A `<unit>` under simpleUnit MUST declare a non-empty
+        # `symbol` attribute. Without a symbol the unit cannot be
+        # rendered in formulae.
+        class UnitMustHaveSymbol < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` under simpleUnit MUST declare a non-empty `symbol` attribute. Without a symbol the unit cannot be rendered in formulae.'
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            return [] unless node.symbol.to_s.strip.empty?
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} must declare a non-empty symbol attribute")]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/simple_unit/constraints.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module SimpleUnit
+      module Constraints
+        autoload :RootMustBeUnitList,
+                 'chemicalml/convention/simple_unit/constraints/root_must_be_unit_list'
+        autoload :UnitMustHavePower,
+                 'chemicalml/convention/simple_unit/constraints/unit_must_have_power'
+        autoload :UnitMustHaveSymbol,
+                 'chemicalml/convention/simple_unit/constraints/unit_must_have_symbol'
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/simple_unit.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # The simpleUnit convention — the worked example from the CMLLite
+    # paper. A toy convention demonstrating the convention framework.
+    #
+    # Namespace: http://www.xml-cml.org/convention/simpleUnit
+    #
+    # Constraints:
+    #
+    # - the root MUST be a `<unitList>` declaring
+    #   `convention="convention:simpleUnit"`
+    # - each `<unit>` MUST have a `power` attribute (integer)
+    # - each `<unit>` MUST have a non-empty `symbol` attribute
+    module SimpleUnit
+      extend Base
+
+      autoload :Constraints, 'chemicalml/convention/simple_unit/constraints'
+
+      QNAME = 'convention:simpleUnit'
+      NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}simpleUnit".freeze
+
+      def self.qname
+        QNAME
+      end
+
+      def self.namespace_uri
+        NAMESPACE_URI
+      end
+
+      register Constraints::UnitMustHavePower
+      register Constraints::UnitMustHaveSymbol
+      register Constraints::RootMustBeUnitList
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints/peak_list_must_contain_peaks.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        # A `<peakList>` MUST contain at least one `<peak>` or
+        # `<peakGroup>` child. An empty peakList carries no data.
+        class PeakListMustContainPeaks < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<peakList>` MUST contain at least one `<peak>` or `<peakGroup>` child. An empty peakList carries no data.'
+          applies_to Chemicalml::Cml::Role::PeakList
+
+          def check_node(node, _path)
+            peaks = (node.peaks || []) + (node.peak_groups || [])
+            return [] unless peaks.empty?
+
+            [violation(path: yield_path(node),
+                       message: 'peakList must contain at least one peak or peakGroup')]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "peakList[#{id}]" : 'peakList'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints/peak_should_have_values.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        # A `<peak>` SHOULD declare at least one of `xValue` or
+        # `yValue`. A peak with neither carries no position
+        # information. Warning severity — there are edge cases
+        # (e.g. group-references) where this is intentional.
+        class PeakShouldHaveValues < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<peak>` SHOULD declare at least one of `xValue` or `yValue`. A peak with neither carries no position information. Warning severity — there are edge cases'
+          applies_to Chemicalml::Cml::Role::Peak
+
+          def check_node(node, _path)
+            return [] unless node.xValue.to_s.empty? && node.yValue.to_s.empty?
+
+            [violation(path: yield_path(node),
+                       message: "peak #{node.id.inspect} should have at least one of xValue or yValue",
+                       severity: :warning,
+                       value: { xValue: node.xValue, yValue: node.yValue }.freeze)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "peak[#{id}]" : 'peak'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints/spectrum_must_have_content.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        # A `<spectrum>` MUST contain at least one of: `<xaxis>`,
+        # `<yaxis>`, `<peakList>`. An empty spectrum carries no data.
+        class SpectrumMustHaveContent < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<spectrum>` MUST contain at least one of: `<xaxis>`, `<yaxis>`, `<peakList>`. An empty spectrum carries no data.'
+          applies_to Chemicalml::Cml::Role::Spectrum
+
+          def check_node(node, _path)
+            return [] if node.xaxis || node.yaxis || node.peak_list
+
+            [violation(path: yield_path(node),
+                       message: "spectrum #{node.id.inspect} must contain at least one of " \
+                                'xaxis, yaxis, or peakList')]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "spectrum[#{id}]" : 'spectrum'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints/spectrum_must_have_convention.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        # A `<spectrum>` MUST declare its own convention attribute so
+        # consumers know how to interpret its format and peaks. Per
+        # the molecular convention: "spectrum — any number, each MUST
+        # specify its own convention".
+        class SpectrumMustHaveConvention < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<spectrum>` MUST declare its own convention attribute so consumers know how to interpret its format and peaks. Per the molecular convention: "spectrum — any number, each MUST'
+          applies_to Chemicalml::Cml::Role::Spectrum
+
+          def check_node(node, _path)
+            return [] unless node.convention.to_s.empty?
+
+            [violation(path: yield_path(node),
+                       message: "spectrum #{node.id.inspect} must declare its own convention attribute")]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "spectrum[#{id}]" : 'spectrum'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints/spectrum_must_have_format.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        # A `<spectrum>` MUST have a `format` attribute (e.g. "mass",
+        # "ir", "nmr", "uv") so consumers know the measurement type.
+        class SpectrumMustHaveFormat < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<spectrum>` MUST have a `format` attribute (e.g. "mass", "ir", "nmr", "uv") so consumers know the measurement type.'
+          applies_to Chemicalml::Cml::Role::Spectrum
+
+          def check_node(node, _path)
+            return [] unless node.format.to_s.empty?
+
+            [violation(path: yield_path(node),
+                       message: "spectrum #{node.id.inspect} must have a format attribute " \
+                                "(e.g. 'mass', 'ir', 'nmr', 'uv')")]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "spectrum[#{id}]" : 'spectrum'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy/constraints.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Spectroscopy
+      module Constraints
+        autoload :SpectrumMustHaveConvention,
+                 'chemicalml/convention/spectroscopy/constraints/spectrum_must_have_convention'
+        autoload :SpectrumMustHaveFormat,
+                 'chemicalml/convention/spectroscopy/constraints/spectrum_must_have_format'
+        autoload :SpectrumMustHaveContent,
+                 'chemicalml/convention/spectroscopy/constraints/spectrum_must_have_content'
+        autoload :PeakListMustContainPeaks,
+                 'chemicalml/convention/spectroscopy/constraints/peak_list_must_contain_peaks'
+        autoload :PeakShouldHaveValues,
+                 'chemicalml/convention/spectroscopy/constraints/peak_should_have_values'
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/spectroscopy.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # The Spectroscopy convention. A chemicalml-specific convention for
+    # CML spectroscopy data (`<spectrum>`, `<peakList>`, `<peak>`).
+    #
+    # Upstream CML does not define a spectroscopy convention; the wire
+    # elements exist in the XSD but no constraints guard their
+    # well-formedness. This convention covers the gaps:
+    #
+    # - spectra MUST declare their own convention (per the molecular
+    #   convention's "each spectrum MUST specify its own convention")
+    # - spectra MUST have a format (e.g. "mass", "ir", "nmr")
+    # - spectra MUST contain at least one of xaxis/yaxis/peakList
+    # - peakList MUST contain at least one peak/peakGroup
+    # - peaks SHOULD have at least one of xValue/yValue (warning)
+    module Spectroscopy
+      extend Base
+
+      autoload :Constraints, 'chemicalml/convention/spectroscopy/constraints'
+
+      QNAME = 'convention:spectroscopy'
+      NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}spectroscopy".freeze
+
+      def self.qname
+        QNAME
+      end
+
+      def self.namespace_uri
+        NAMESPACE_URI
+      end
+
+      register Constraints::SpectrumMustHaveConvention
+      register Constraints::SpectrumMustHaveFormat
+      register Constraints::SpectrumMustHaveContent
+      register Constraints::PeakListMustContainPeaks
+      register Constraints::PeakShouldHaveValues
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_list_must_contain_at_least_one_unit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unitList>` element MUST contain one or more `<unit>`
+        # children, and MUST NOT contain any other CML-namespace
+        # child elements.
+        class UnitListMustContainAtLeastOneUnit < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitList>` element MUST contain one or more `<unit>` children, and MUST NOT contain any other CML-namespace child elements.'
+          applies_to Chemicalml::Cml::Role::UnitList
+          def check_node(node, path)
+            return [] if (node.units || []).length.positive?
+
+            [violation(path: path.join('/'),
+                       message: 'unitList must contain at least one unit child')]
+          end
+
+          private
+
+          def unit_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitList)
+          end
+        end
+      end
+    end
+  end
+end