chemicalml 0.2.0 → 0.3.0

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

@@ -4,10 +4,48 @@ module Chemicalml
   module Convention
     module Compchem
       module Constraints
+        autoload :ModulePredicates,
+                 'chemicalml/convention/compchem/constraints/module_predicates'
         autoload :CompchemModuleMustContainJobList,
-                 "chemicalml/convention/compchem/constraints/compchem_module_must_contain_job_list"
+                 'chemicalml/convention/compchem/constraints/compchem_module_must_contain_job_list'
         autoload :JobMustContainInitialization,
-                 "chemicalml/convention/compchem/constraints/job_must_contain_initialization"
+                 'chemicalml/convention/compchem/constraints/job_must_contain_initialization'
+        autoload :JobListModuleMustHaveId,
+                 'chemicalml/convention/compchem/constraints/job_list_module_must_have_id'
+        autoload :JobModuleMustHaveId,
+                 'chemicalml/convention/compchem/constraints/job_module_must_have_id'
+        autoload :JobModuleAtMostOneFinalization,
+                 'chemicalml/convention/compchem/constraints/job_module_at_most_one_finalization'
+        autoload :JobModuleAtMostOneEnvironment,
+                 'chemicalml/convention/compchem/constraints/job_module_at_most_one_environment'
+        autoload :CalculationRequiresFinalization,
+                 'chemicalml/convention/compchem/constraints/calculation_requires_finalization'
+        autoload :InitializationAtMostOneMolecule,
+                 'chemicalml/convention/compchem/constraints/initialization_at_most_one_molecule'
+        autoload :InitializationAtMostOneParameterList,
+                 'chemicalml/convention/compchem/constraints/initialization_at_most_one_parameter_list'
+        autoload :InitializationMustNotContainProperty,
+                 'chemicalml/convention/compchem/constraints/initialization_must_not_contain_property'
+        autoload :FinalizationAtMostOneMolecule,
+                 'chemicalml/convention/compchem/constraints/finalization_at_most_one_molecule'
+        autoload :FinalizationAtMostOnePropertyList,
+                 'chemicalml/convention/compchem/constraints/finalization_at_most_one_property_list'
+        autoload :FinalizationMustNotContainParameter,
+                 'chemicalml/convention/compchem/constraints/finalization_must_not_contain_parameter'
+        autoload :EnvironmentAtMostOnePropertyList,
+                 'chemicalml/convention/compchem/constraints/environment_at_most_one_property_list'
+        autoload :EnvironmentMustNotContainParameter,
+                 'chemicalml/convention/compchem/constraints/environment_must_not_contain_parameter'
+        autoload :ScalarUnits,
+                 'chemicalml/convention/compchem/constraints/scalar_units'
+        autoload :ArrayRules,
+                 'chemicalml/convention/compchem/constraints/array_rules'
+        autoload :MatrixRules,
+                 'chemicalml/convention/compchem/constraints/matrix_rules'
+        autoload :InitializationMustHaveContent,
+                 'chemicalml/convention/compchem/constraints/initialization_must_have_content'
+        autoload :FinalizationMustHaveContent,
+                 'chemicalml/convention/compchem/constraints/finalization_must_have_content'
       end
     end
   end

data/lib/chemicalml/convention/compchem.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module Compchem
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/compchem/constraints"
+      autoload :Constraints, 'chemicalml/convention/compchem/constraints'
 
-      QNAME = "convention:compchem".freeze
+      QNAME = 'convention:compchem'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}compchem".freeze
 
       def self.qname
@@ -23,6 +23,24 @@ module Chemicalml
 
       register Constraints::CompchemModuleMustContainJobList
       register Constraints::JobMustContainInitialization
+      register Constraints::JobListModuleMustHaveId
+      register Constraints::JobModuleMustHaveId
+      register Constraints::JobModuleAtMostOneFinalization
+      register Constraints::JobModuleAtMostOneEnvironment
+      register Constraints::CalculationRequiresFinalization
+      register Constraints::InitializationAtMostOneMolecule
+      register Constraints::InitializationAtMostOneParameterList
+      register Constraints::InitializationMustNotContainProperty
+      register Constraints::FinalizationAtMostOneMolecule
+      register Constraints::FinalizationAtMostOnePropertyList
+      register Constraints::FinalizationMustNotContainParameter
+      register Constraints::EnvironmentAtMostOnePropertyList
+      register Constraints::EnvironmentMustNotContainParameter
+      register Constraints::ScalarUnits
+      register Constraints::ArrayRules
+      register Constraints::MatrixRules
+      register Constraints::InitializationMustHaveContent
+      register Constraints::FinalizationMustHaveContent
     end
   end
 end

data/lib/chemicalml/convention/constraint.rb

@@ -3,45 +3,87 @@
 module Chemicalml
   module Convention
     # Abstract base class for a single constraint. Subclasses implement
-    # `check_node` (one node at a time) or `check_document` (whole
-    # document at once). The base class provides traversal and
-    # collection plumbing.
+    # `check_node` (one node at a time) or `check` (whole document).
     #
-    # To add a new constraint:
-    #
-    #   1. Subclass `Constraint::NodeConstraint` or
-    #      `Constraint::DocumentConstraint`
-    #   2. Implement `check_node` / `check_document`
-    #   3. Register it on the convention: `register(MyConstraint)`
-    #
-    # No framework code changes.
+    # A constraint subclass MAY declare `applies_to` — one or more
+    # `Cml::Role::*` modules. When it does, the Coordinator only
+    # invokes `check_node` for nodes matching that role. Without
+    # `applies_to`, the constraint receives every node (legacy
+    # behaviour). Declaring `applies_to` is the fast path: the
+    # dispatch is O(node.ancestors) per node, not O(constraint_count).
     class Constraint
-      def self.name_for_display
-        to_s.split("::").last
+      class << self
+        # Returns the Role module(s) this constraint applies to, or
+        # nil if it must run for every node.
+        attr_reader :applies_to_roles
+
+        # Declare one or more Role modules this constraint handles.
+        #   applies_to Chemicalml::Cml::Role::Atom
+        #   applies_to Chemicalml::Cml::Role::Bond, Chemicalml::Cml::Role::AtomParity
+        def applies_to(*roles)
+          @applies_to_roles = roles.flatten.freeze
+        end
+
+        # Human-readable description of the rule this constraint
+        # enforces. Subclasses MAY override. Falls back to the class
+        # name. Used by `chemicalml constraints` and the auto-generated
+        # constraint docs.
+        #
+        # @return [String]
+        def description
+          @description || name.split('::').last
+        end
+
+        # Set the description (DSL for subclasses).
+        #   description "A <bond> must have an order attribute"
+        attr_writer :description
+
+        # Severity this constraint emits. Subclasses MAY override.
+        # Default `:error` — warning subclasses override to `:warning`.
+        #
+        # @return [Symbol] `:error` or `:warning`.
+        def default_severity
+          :error
+        end
+      end
+
+      def initialize
+        freeze
       end
 
       def check(_document)
         raise NotImplementedError,
-              "#{self.class.name_for_display} must implement #check(document)"
+              "#{self.class} must implement #check(document)"
       end
 
       protected
 
-      def violation(path:, message:, severity: :error)
+      def violation(path:, message:, severity: :error, value: nil)
         Violation.new(path: path, message: message,
-                      severity: severity, constraint: self.class)
+                      severity: severity, constraint: self.class,
+                      value: value)
       end
 
       # Walk every wire node reachable from `node`. Yields (node, path)
       # pairs. Path is a slash-joined breadcrumb. Nodes that don't
       # include `Chemicalml::Cml::Visitable` are skipped.
-      def walk_nodes(node, path = [], &block)
+      #
+      # Iterative (worklist) implementation — does not recurse, so
+      # deeply-nested documents cannot overflow the stack. Traversal
+      # order is DFS pre-order, matching the prior recursive walker.
+      def walk_nodes(node, path = [])
         return unless node
         return unless visitable?(node)
 
-        yield(node, path)
-        node.wire_children.each do |child|
-          walk_nodes(child, path + [describe(child)], &block)
+        worklist = [[node, path]]
+        until worklist.empty?
+          current, current_path = worklist.shift
+          yield(current, current_path)
+          current.wire_children.reverse_each do |child|
+            next unless visitable?(child)
+
+            worklist.unshift([child, current_path + [describe(child)]])
+          end
         end
       end
 
@@ -54,8 +96,9 @@ module Chemicalml
         id_value ? "#{node.element_name}[#{id_value}]" : node.element_name
       end
 
-      # Constraint that walks the document tree once per node and calls
-      # `check_node(node, path)`. Subclasses get traversal for free.
+      # NodeConstraint: walks the document tree once per node and
+      # calls `check_node(node, path)`. Subclasses get traversal for
+      # free plus declarative role dispatch via `applies_to`.
       class NodeConstraint < Constraint
         def check(document)
           violations = []
@@ -70,8 +113,9 @@ module Chemicalml
         end
       end
 
-      # Constraint that operates on the whole document at once — used
-      # for cross-cutting rules like "atom ids unique within molecule".
+      # DocumentConstraint: operates on the whole document at once —
+      # used for cross-cutting rules like "atom ids unique within
+      # molecule". Walks the tree itself; not subject to dispatch.
       class DocumentConstraint < Constraint
       end
     end

data/lib/chemicalml/convention/coordinator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # Single-pass constraint dispatcher. Replaces the previous
+    # O(N*C) walk (every constraint walked the whole tree) with
+    # O(N + total_applicable) — one tree walk per validation, with
+    # each node dispatched only to constraints that declared
+    # `applies_to` matching one of the node's ancestors.
+    #
+    # Constraints that don't declare `applies_to` fall into a
+    # default "all nodes" bucket and run for every visited node,
+    # preserving backward compatibility.
+    class Coordinator
+      attr_reader :document_constraints, :node_constraints
+
+      def initialize(constraint_classes)
+        @document_constraints = constraint_classes
+                                .select { |c| c < Constraint::DocumentConstraint }
+                                .map(&:new)
+        @node_constraints = constraint_constraints(constraint_classes)
+                            .map(&:new)
+        @always_applicable = []
+        @by_role = Hash.new { |h, k| h[k] = [] }
+        @node_constraints.each { |c| register(c) }
+      end
+
+      def validate(document)
+        violations = @document_constraints.flat_map do |constraint|
+          Array(constraint.check(document))
+        end
+        return violations unless visitable?(document)
+
+        walk(document) do |node, path|
+          applicable_for(node).each do |constraint|
+            violations.concat(Array(constraint.check_node(node, path)))
+          end
+        end
+        violations
+      end
+
+      private
+
+      def constraint_constraints(classes)
+        classes.select { |c| c < Constraint::NodeConstraint }
+      end
+
+      def register(constraint)
+        roles = constraint.class.applies_to_roles
+        if roles.nil? || roles.empty?
+          @always_applicable << constraint
+        else
+          roles.each { |role| @by_role[role] << constraint }
+        end
+      end
+
+      def visitable?(node)
+        node.is_a?(Chemicalml::Cml::Visitable)
+      end
+
+      def applicable_for(node)
+        applicable = @always_applicable
+        node.class.ancestors.each do |ancestor|
+          next unless ancestor.is_a?(::Module)
+
+          bucket = @by_role[ancestor]
+          next unless bucket
+
+          applicable += bucket
+        end
+        applicable
+      end
+
+      def walk(node, path = [], &block)
+        return unless node
+        return unless visitable?(node)
+
+        yield(node, path)
+        node.wire_children.each do |child|
+          walk(child, path + [describe(child)], &block)
+        end
+      end
+
+      def describe(node)
+        id_value = node.node_id
+        id_value ? "#{node.element_name}[#{id_value}]" : node.element_name
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/detection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # Convention detection from a wire document. Reads the
+    # `convention` attribute from the root element and returns the
+    # QName string (e.g. "convention:molecular").
+    #
+    # Used by `Registry.detect_and_validate` and reusable by callers
+    # that want to know which convention a document declares without
+    # running validation.
+    module Detection
+      # Wire roles that may carry a top-level convention attribute.
+      # Adding a new convention whose root is a new element type =
+      # adding one role here. OCP — no existing code changes.
+      CONVENTION_ROOTS = [
+        Chemicalml::Cml::Role::Document,
+        Chemicalml::Cml::Role::Module,
+        Chemicalml::Cml::Role::Molecule,
+        Chemicalml::Cml::Role::Dictionary,
+        Chemicalml::Cml::Role::UnitList,
+        Chemicalml::Cml::Role::UnitTypeList,
+        Chemicalml::Cml::Role::Spectrum,
+        Chemicalml::Cml::Role::SpectrumList,
+        Chemicalml::Cml::Role::ReactionScheme,
+        Chemicalml::Cml::Role::ReactionList
+      ].freeze
+
+      def self.convention_of(document)
+        CONVENTION_ROOTS.each do |role|
+          next unless document.is_a?(role)
+
+          return document.convention if document.convention
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/dictionary_must_have_namespace.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # A `<dictionary>` element MUST have a `namespace` attribute
+        # whose value is a valid URI defining the scope within which
+        # the entry terms are unique.
+        class DictionaryMustHaveNamespace < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<dictionary>` element MUST have a `namespace` attribute whose value is a valid URI defining the scope within which the entry terms are unique.'
+          applies_to Chemicalml::Cml::Role::Dictionary
+          def check_node(node, path)
+            return [] unless node.namespace.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'dictionary must have a namespace attribute')]
+          end
+
+          private
+
+          def dictionary?(node)
+            node.is_a?(Chemicalml::Cml::Role::Dictionary)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/dictionary_namespace_should_end_with_slash_or_hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # The `namespace` URI SHOULD end with `/` or `#` so terms can
+        # be referenced by appending them to the URI. Warning level.
+        class DictionaryNamespaceShouldEndWithSlashOrHash < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The `namespace` URI SHOULD end with `/` or `#` so terms can be referenced by appending them to the URI. Warning level.'
+          applies_to Chemicalml::Cml::Role::Dictionary
+          def check_node(node, path)
+            ns = node.namespace.to_s
+            return [] if ns.empty?
+            return [] if ns.end_with?('/', '#')
+
+            [violation(path: path.join('/'),
+                       message: "dictionary namespace #{ns.inspect} should end with / or # " \
+                                'so terms can be referenced by appending',
+                       severity: :warning)]
+          end
+
+          private
+
+          def dictionary?(node)
+            node.is_a?(Chemicalml::Cml::Role::Dictionary)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/entry_id_must_match_pattern.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # An `<entry>` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*` —
+        # start with a letter, followed by letters/digits/dot/hyphen/
+        # underscore. Mirrors the upstream IdStartChar / IdChar BNF.
+        class EntryIdMustMatchPattern < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'An `<entry>` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*` — start with a letter, followed by letters/digits/dot/hyphen/ underscore. Mirrors the upstream IdStartChar / IdChar BNF.'
+          applies_to Chemicalml::Cml::Role::DictionaryEntry
+          PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
+
+          def check_node(node, path)
+            id = node.id.to_s
+            return [] if id.empty?
+            return [] if id.match?(PATTERN)
+
+            [violation(path: path.join('/'),
+                       message: "entry id #{id.inspect} must match [A-Za-z][A-Za-z0-9._-]*")]
+          end
+
+          private
+
+          def entry?(node)
+            node.is_a?(Chemicalml::Cml::Role::DictionaryEntry)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/entry_ids_unique_within_dictionary.rb

@@ -7,16 +7,16 @@ module Chemicalml
         # Entry ids MUST be unique within the parent dictionary per
         # the dictionary convention.
         class EntryIdsUniqueWithinDictionary < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Entry ids MUST be unique within the parent dictionary per the dictionary convention.'
+          applies_to Chemicalml::Cml::Role::Dictionary
           def check_node(node, path)
-            return [] unless dictionary?(node)
-
             entries = node.entries || []
-            ids = entries.map { |e| e.id }.compact
+            ids = entries.map(&:id).compact
             duplicates = ids.group_by { |x| x }.select { |_, v| v.length > 1 }.keys
             return [] if duplicates.empty?
 
             duplicates.map do |dup|
-              violation(path: path.join("/"),
+              violation(path: path.join('/'),
                         message: "duplicate entry id #{dup.inspect} within dictionary")
             end
           end

data/lib/chemicalml/convention/dictionary/constraints/entry_must_contain_definition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # An `<entry>` MUST contain a single `definition` child
+        # element. The schema allows it as a string; this constraint
+        # enforces presence.
+        class EntryMustContainDefinition < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'An `<entry>` MUST contain a single `definition` child element. The schema allows it as a string; this constraint enforces presence.'
+          applies_to Chemicalml::Cml::Role::DictionaryEntry
+          def check_node(node, path)
+            return [] unless node.definition.to_s.strip.empty?
+
+            [violation(path: path.join('/'),
+                       message: "entry #{node.id.inspect} must contain a single definition child")]
+          end
+
+          private
+
+          def entry?(node)
+            node.is_a?(Chemicalml::Cml::Role::DictionaryEntry)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/entry_must_have_id_and_term.rb

@@ -7,17 +7,17 @@ module Chemicalml
         # Every entry MUST have an `id` and a `term` attribute per the
         # dictionary convention.
         class EntryMustHaveIdAndTerm < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Every entry MUST have an `id` and a `term` attribute per the dictionary convention.'
+          applies_to Chemicalml::Cml::Role::DictionaryEntry
           def check_node(node, path)
-            return [] unless entry?(node)
-
             violations = []
             if node.id.to_s.empty?
-              violations << violation(path: path.join("/"),
-                                      message: "entry must have an id attribute")
+              violations << violation(path: path.join('/'),
+                                      message: 'entry must have an id attribute')
             end
             if node.term.to_s.empty?
-              violations << violation(path: path.join("/"),
-                                      message: "entry must have a term attribute")
+              violations << violation(path: path.join('/'),
+                                      message: 'entry must have a term attribute')
             end
             violations
           end

data/lib/chemicalml/convention/dictionary/constraints/entry_must_have_unit_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # An `<entry>` MUST have a `unitType` attribute. Entries
+        # describing concepts that should not have units (e.g. name
+        # of a program) should reference `none` in the standard CML
+        # unitType dictionary.
+        class EntryMustHaveUnitType < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'An `<entry>` MUST have a `unitType` attribute. Entries describing concepts that should not have units (e.g. name of a program) should reference `none` in the standard CML'
+          applies_to Chemicalml::Cml::Role::DictionaryEntry
+          def check_node(node, path)
+            return [] unless node.unit_type.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: "entry #{node.id.inspect} must have a unitType attribute " \
+                                "(use 'none' for concepts without units)")]
+          end
+
+          private
+
+          def entry?(node)
+            node.is_a?(Chemicalml::Cml::Role::DictionaryEntry)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/dictionary/constraints/entry_units_co_constraints.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Dictionary
+      module Constraints
+        # Co-constraint between `unitType` and `units`:
+        #
+        # - If `unitType` is `unknown`, `units` MUST NOT be present.
+        # - If `unitType` is `none`, `units` MUST be present and point
+        #   to `http://www.xml-cml.org/unit/si#none`.
+        class EntryUnitsCoConstraints < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Co-constraint between `unitType` and `units`: - If `unitType` is `unknown`, `units` MUST NOT be present. - If `unitType` is `none`, `units` MUST be present and point'
+          applies_to Chemicalml::Cml::Role::DictionaryEntry
+          NONE_UNITS = 'http://www.xml-cml.org/unit/si#none'
+
+          def check_node(node, path)
+            unit_type = node.unit_type.to_s
+            units = node.units.to_s
+            violations = []
+
+            if unit_type == 'unknown' && !units.empty?
+              violations << violation(path: path.join('/'),
+                                      message: "entry #{node.id.inspect} has unitType 'unknown' " \
+                                               'and therefore must not have units')
+            end
+            if unit_type == 'none' && units != NONE_UNITS
+              violations << violation(path: path.join('/'),
+                                      message: "entry #{node.id.inspect} has unitType 'none' — " \
+                                               "units must be #{NONE_UNITS.inspect}")
+            end
+            violations
+          end
+
+          private
+
+          def entry?(node)
+            node.is_a?(Chemicalml::Cml::Role::DictionaryEntry)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,21 @@ module Chemicalml
     module Dictionary
       module Constraints
         autoload :EntryMustHaveIdAndTerm,
-                 "chemicalml/convention/dictionary/constraints/entry_must_have_id_and_term"
+                 'chemicalml/convention/dictionary/constraints/entry_must_have_id_and_term'
         autoload :EntryIdsUniqueWithinDictionary,
-                 "chemicalml/convention/dictionary/constraints/entry_ids_unique_within_dictionary"
+                 'chemicalml/convention/dictionary/constraints/entry_ids_unique_within_dictionary'
+        autoload :DictionaryMustHaveNamespace,
+                 'chemicalml/convention/dictionary/constraints/dictionary_must_have_namespace'
+        autoload :DictionaryNamespaceShouldEndWithSlashOrHash,
+                 'chemicalml/convention/dictionary/constraints/dictionary_namespace_should_end_with_slash_or_hash'
+        autoload :EntryMustContainDefinition,
+                 'chemicalml/convention/dictionary/constraints/entry_must_contain_definition'
+        autoload :EntryIdMustMatchPattern,
+                 'chemicalml/convention/dictionary/constraints/entry_id_must_match_pattern'
+        autoload :EntryMustHaveUnitType,
+                 'chemicalml/convention/dictionary/constraints/entry_must_have_unit_type'
+        autoload :EntryUnitsCoConstraints,
+                 'chemicalml/convention/dictionary/constraints/entry_units_co_constraints'
       end
     end
   end

data/lib/chemicalml/convention/dictionary.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module Dictionary
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/dictionary/constraints"
+      autoload :Constraints, 'chemicalml/convention/dictionary/constraints'
 
-      QNAME = "convention:dictionary".freeze
+      QNAME = 'convention:dictionary'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}dictionary".freeze
 
       def self.qname
@@ -23,6 +23,12 @@ module Chemicalml
 
       register Constraints::EntryMustHaveIdAndTerm
       register Constraints::EntryIdsUniqueWithinDictionary
+      register Constraints::DictionaryMustHaveNamespace
+      register Constraints::DictionaryNamespaceShouldEndWithSlashOrHash
+      register Constraints::EntryMustContainDefinition
+      register Constraints::EntryIdMustMatchPattern
+      register Constraints::EntryMustHaveUnitType
+      register Constraints::EntryUnitsCoConstraints
     end
   end
 end