chemicalml 0.2.0 → 0.2.1

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondMustHaveAtomRefs2 < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Bond
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
 
             return [] unless node.atom_refs2.to_s.strip.empty?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
-                       message: "bond must have an atomRefs2 attribute")]
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
+                       message: 'bond must have an atomRefs2 attribute')]
           end
         end
       end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondMustHaveOrder < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Bond
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
 
             return [] unless node.order.to_s.strip.empty?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
-                       message: "bond must have an order attribute")]
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
+                       message: 'bond must have an order attribute')]
           end
         end
       end

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

@@ -18,7 +18,7 @@ module Chemicalml
                 next if missing.empty?
 
                 violations << violation(
-                  path: path.empty? ? "molecule[#{node.id}]" : path.join("/"),
+                  path: path.empty? ? "molecule[#{node.id}]" : path.join('/'),
                   message: "bond #{bond.id.inspect} references atoms not in the same molecule: #{missing.inspect}"
                 )
               end
@@ -35,7 +35,7 @@ module Chemicalml
           def atom_ids_within(molecule)
             return [] unless molecule.atom_array
 
-            (molecule.atom_array.atoms || []).map { |a| a.id }
+            (molecule.atom_array.atoms || []).map(&:id)
           end
 
           def bonds_within(molecule)
@@ -45,7 +45,7 @@ module Chemicalml
           end
 
           def atom_refs_of(bond)
-            bond.atom_refs2.to_s.split(" ")
+            bond.atom_refs2.to_s.split
           end
         end
       end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bond>` with `order="other"` MUST
+        # have a `dictRef` pointing to the dictionary that defines
+        # the order semantics. The warning-level "should not be
+        # numeric" rule is separate; this is the hard error.
+        class BondOrderOtherMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Bond
+          def check_node(node, path)
+            return [] unless node.order.to_s.downcase == 'other'
+            return [] unless node.dict_ref.to_s.empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "bond order 'other' must have a dictRef " \
+                       'identifying the dictionary entry that defines it'
+            )]
+          end
+
+          private
+
+          def bond?(node)
+            node.is_a?(Chemicalml::Cml::Role::Bond)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,17 +5,17 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondOrderShouldNotBeNumeric < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Bond
           VALID_ORDERS = %w[S D T Q A other].freeze
 
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
 
             order = node.order.to_s
             return [] if order.empty?
 
             return [] if VALID_ORDERS.include?(order) || node.dict_ref.to_s.size.positive?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
                        message: "bond order #{order.inspect} is not recommended " \
                                 "(use S/D/T/Q/A or 'other' with dictRef)",
                        severity: :warning)]

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` value C (cis) or T
+        # (trans) MUST have `atomRefs4` and MUST NOT have `atomRefs2`.
+        class BondStereoCisTransMustHaveAtomRefs4 < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::BondStereo
+          CIS_TRANS_VALUES = %w[C T].freeze
+
+          def check_node(node, path)
+
+            value = node.content.to_s.upcase
+            return [] unless CIS_TRANS_VALUES.include?(value)
+
+            violations = []
+            if node.atom_refs4.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must have atomRefs4 " \
+                         '(four atom ids; two must match the parent bond)'
+              )
+            end
+            unless node.atom_refs2.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must not have atomRefs2 " \
+                         '(only W/H wedge/hatch values use atomRefs2)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` with value `other`
+        # MUST have a `dictRef` pointing to the convention that
+        # defines the stereo semantics.
+        class BondStereoOtherMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::BondStereo
+          def check_node(node, path)
+            return [] unless node.content.to_s.downcase == 'other'
+            return [] unless node.dict_ref.to_s.empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "bondStereo value 'other' must have a dictRef " \
+                       'identifying the convention that defines it'
+            )]
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` value W (wedge) or H
+        # (hatch) MUST have `atomRefs2` and MUST NOT have `atomRefs4`.
+        class BondStereoWedgeHashMustHaveAtomRefs2 < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::BondStereo
+          WEDGE_HASH_VALUES = %w[W H].freeze
+
+          def check_node(node, path)
+
+            value = node.content.to_s.upcase
+            return [] unless WEDGE_HASH_VALUES.include?(value)
+
+            violations = []
+            if node.atom_refs2.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must have atomRefs2 " \
+                         '(first atom = sharp end, second = blunt end)'
+              )
+            end
+            unless node.atom_refs4.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must not have atomRefs4 " \
+                         '(only C/T cis-trans values use atomRefs4)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: a `<molecule>` MAY hold an `atomArray`
+        # OR child `<molecule>` elements, but not both. The two are
+        # mutually exclusive ways of describing composition.
+        class MoleculeAtomArrayMutuallyExclusiveWithChildren < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Molecule
+          def check_node(node, path)
+            return [] if node.atom_array.nil?
+            return [] if (node.molecules || []).empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "molecule #{node.id.inspect} has both an atomArray " \
+                       'and child molecule elements — these are mutually exclusive'
+            )]
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: a `<molecule>` MAY hold a `bondArray`
+        # OR child `<molecule>` elements, but not both.
+        class MoleculeBondArrayMutuallyExclusiveWithChildren < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Molecule
+          def check_node(node, path)
+            return [] if node.bond_array.nil?
+            return [] if (node.molecules || []).empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "molecule #{node.id.inspect} has both a bondArray " \
+                       'and child molecule elements — these are mutually exclusive'
+            )]
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `count` MUST NOT appear on top-level
+        # molecules (direct children of `<cml>`). It is REQUIRED on
+        # molecules nested inside another `<molecule>`.
+        class MoleculeCountMustNotAppearOnTopLevel < Chemicalml::Convention::Constraint::DocumentConstraint
+          def check(document)
+            violations = []
+            top_level_molecules(document).each do |mol, path|
+              next if mol.count.to_s.empty?
+
+              violations << violation(
+                path: (path + [describe(mol)]).join('/'),
+                message: "top-level molecule #{mol.id.inspect} must not have " \
+                         'a count attribute (only nested molecules may carry count)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def top_level_molecules(document)
+            (document.molecules || []).map { |m| [m, []] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class MoleculeMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Molecule
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Molecule)
 
             return [] unless node.id.to_s.empty?
 
-            [violation(path: path.empty? ? "molecule" : path.join("/"),
-                       message: "molecule must have an id attribute")]
+            [violation(path: path.empty? ? 'molecule' : path.join('/'),
+                       message: 'molecule must have an id attribute')]
           end
         end
       end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class PropertyMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Property
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Property)
 
             return [] unless node.dict_ref.to_s.empty?
 
-            [violation(path: path.empty? ? "property" : path.join("/"),
-                       message: "property must have a dictRef attribute")]
+            [violation(path: path.empty? ? 'property' : path.join('/'),
+                       message: 'property must have a dictRef attribute')]
           end
         end
       end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class ScalarMustHaveDataType < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Scalar
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Scalar)
 
             return [] unless node.data_type.to_s.empty?
 
-            [violation(path: path.empty? ? "scalar" : path.join("/"),
-                       message: "scalar must have a dataType attribute")]
+            [violation(path: path.empty? ? 'scalar' : path.join('/'),
+                       message: 'scalar must have a dataType attribute')]
           end
         end
       end

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

@@ -30,6 +30,26 @@ module Chemicalml
                  "chemicalml/convention/molecular/constraints/bond_order_should_not_be_numeric"
         autoload :AtomIdMustMatchPattern,
                  "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"
       end
     end
   end

data/lib/chemicalml/convention/molecular.rb

@@ -34,6 +34,16 @@ 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
     end
   end
 end

data/lib/chemicalml/convention/registry.rb

@@ -23,6 +23,23 @@ 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

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

@@ -0,0 +1,28 @@
+# 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
+          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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unitList>` element MUST have a `namespace` attribute
+        # whose value is a valid URI defining the scope within which
+        # the unit ids are unique. SHOULD end with `/` or `#`.
+        class UnitListMustHaveNamespace < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::UnitList
+          def check_node(node, path)
+
+            violations = []
+            ns = node.namespace.to_s
+            if ns.empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'unitList must have a namespace attribute')
+            elsif !ns.end_with?('/', '#')
+              violations << violation(path: path.join('/'),
+                                      message: "unitList namespace #{ns.inspect} should end with / or #",
+                                      severity: :warning)
+            end
+            violations
+          end
+
+          private
+
+          def unit_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitList)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST contain a single `<definition>`
+        # child element with XHTML content.
+        class UnitMustContainDefinition < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Unit
+          def check_node(node, path)
+            return [] unless node.definition.to_s.strip.empty?
+
+            [violation(path: path.join('/'),
+                       message: "unit #{node.id.inspect} must contain a single definition child")]
+          end
+
+          private
+
+          def unit?(node)
+            node.is_a?(Chemicalml::Cml::Role::Unit)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST have an `id` attribute, unique
+        # within the unitList.
+        class UnitMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Unit
+          def check_node(node, path)
+            return [] unless node.id.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'unit must have an id attribute unique within the unitList')]
+          end
+
+          private
+
+          def unit?(node)
+            node.is_a?(Chemicalml::Cml::Role::Unit)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,22 +8,22 @@ module Chemicalml
         # at least one of `multiplierToSI`/`constantToSI`, and
         # `unitType` per the unit-dictionary convention.
         class UnitMustHaveSymbolAndUnitType < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Unit
           REQUIRED = %i[title symbol parent_si unit_type].freeze
 
           def check_node(node, path)
-            return [] unless unit?(node)
 
             violations = []
             REQUIRED.each do |attr|
               val = node.public_send(attr)
               next unless val.to_s.empty?
 
-              violations << violation(path: path.join("/"),
+              violations << violation(path: path.join('/'),
                                       message: "unit must have #{attr} (id=#{node.id.inspect})")
             end
 
             unless has_si_conversion?(node)
-              violations << violation(path: path.join("/"),
+              violations << violation(path: path.join('/'),
                                       message: "unit must have multiplierToSI or constantToSI (id=#{node.id.inspect})")
             end
 

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

@@ -5,7 +5,15 @@ module Chemicalml
     module UnitDictionary
       module Constraints
         autoload :UnitMustHaveSymbolAndUnitType,
-                 "chemicalml/convention/unit_dictionary/constraints/unit_must_have_symbol_and_unit_type"
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_symbol_and_unit_type'
+        autoload :UnitMustHaveId,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_id'
+        autoload :UnitMustContainDefinition,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_contain_definition'
+        autoload :UnitListMustHaveNamespace,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_list_must_have_namespace'
+        autoload :UnitListMustContainAtLeastOneUnit,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_list_must_contain_at_least_one_unit'
       end
     end
   end

data/lib/chemicalml/convention/unit_dictionary.rb

@@ -22,6 +22,10 @@ module Chemicalml
       end
 
       register Constraints::UnitMustHaveSymbolAndUnitType
+      register Constraints::UnitMustHaveId
+      register Constraints::UnitMustContainDefinition
+      register Constraints::UnitListMustHaveNamespace
+      register Constraints::UnitListMustContainAtLeastOneUnit
     end
   end
 end