chemicalml 0.2.1 → 0.3.0

data/lib/chemicalml/convention/cascade.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # The Cascade convention. A chemicalml-specific convention for CML
+    # reaction cascades — multi-step reaction networks encoded via
+    # `<reactionScheme>`, `<reactionStepList>`, `<reactionStep>`,
+    # `<reaction>`, and `<reactiveCentre>`.
+    #
+    # Upstream CML does not publish a dedicated cascade convention; the
+    # wire elements exist in the XSD but no constraints guard their
+    # well-formedness. This convention covers the gaps:
+    #
+    # - reactionScheme MUST contain at least one reactionStepList or
+    #   reaction (an empty scheme carries no cascade)
+    # - reactionStepList MUST contain at least one reactionStep
+    # - reactionStep MUST contain a reaction or explicit reactant/product
+    #   lists (an empty step is a dead-end in the cascade)
+    # - reactiveCentre atomRefs SHOULD be parseable atom references
+    #   (warning — gracefully degrades when context is missing)
+    module Cascade
+      extend Base
+
+      autoload :Constraints, 'chemicalml/convention/cascade/constraints'
+
+      QNAME = 'convention:cascade'
+      NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}cascade".freeze
+
+      def self.qname
+        QNAME
+      end
+
+      def self.namespace_uri
+        NAMESPACE_URI
+      end
+
+      register Constraints::ReactionSchemeMustHaveContent
+      register Constraints::ReactionStepListMustContainSteps
+      register Constraints::ReactionStepMustHaveReactionOrLists
+      register Constraints::ReactiveCentreAtomRefsShouldBePresent
+    end
+  end
+end

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

@@ -8,13 +8,13 @@ module Chemicalml
         # attribute (≥ 1); `dataType` MUST be integer or double;
         # MUST have `units`.
         class ArrayRules < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'CompChem `array` value-container rules: MUST have `size` attribute (≥ 1); `dataType` MUST be integer or double; MUST have `units`.'
           applies_to Chemicalml::Cml::Role::Array
           include ModulePredicates
 
           ALLOWED_TYPES = %w[xsd:integer xsd:double].freeze
 
           def check_node(node, path)
-
             violations = []
             if node.size.to_s.empty? || node.size.to_i < 1
               violations << violation(path: path.join('/'),

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

@@ -7,11 +7,11 @@ module Chemicalml
         # Co-constraint: if a calculation module is present inside a
         # job, a finalization MUST also be present.
         class CalculationRequiresFinalization < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Co-constraint: if a calculation module is present inside a job, a finalization MUST also be present.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             calculations = child_modules_with(node, 'compchem:calculation')
             finalizations = child_modules_with(node, 'compchem:finalization')
             return [] if calculations.empty?

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

@@ -7,10 +7,11 @@ module Chemicalml
         # A CompChem module MUST contain at least one jobList module
         # child per the compchem convention.
         class CompchemModuleMustContainJobList < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A CompChem module MUST contain at least one jobList module child per the compchem convention.'
           def check_node(node, path)
             return [] unless compchem_root?(node)
 
-            job_lists = node.modules.select { |m| m.dict_ref == 'compchem:jobList' }
+            job_lists = (node.modules || []).select { |m| m.dict_ref == 'compchem:jobList' }
             return [] unless job_lists.empty?
 
             [violation(path: path.join('/'),

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

@@ -7,11 +7,11 @@ module Chemicalml
         # The environment module MUST NOT contain more than one
         # propertyList child.
         class EnvironmentAtMostOnePropertyList < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The environment module MUST NOT contain more than one propertyList child.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             lists = node.property_lists || []
             return [] if lists.length <= 1
 

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

@@ -8,11 +8,11 @@ module Chemicalml
         # parameterList children directly. It MAY contain a
         # propertyList (which itself can hold parameters).
         class EnvironmentMustNotContainParameter < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The environment module MUST NOT contain parameter or parameterList children directly. It MAY contain a propertyList (which itself can hold parameters).'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             violations = []
             unless (node.parameter_lists || []).empty?
               violations << violation(path: path.join('/'),

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

@@ -7,11 +7,11 @@ module Chemicalml
         # The finalization module MUST NOT contain more than one
         # molecule child.
         class FinalizationAtMostOneMolecule < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The finalization module MUST NOT contain more than one molecule child.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             molecules = node.molecules || []
             return [] if molecules.length <= 1
 

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

@@ -7,11 +7,11 @@ module Chemicalml
         # The finalization module MUST NOT contain more than one
         # propertyList child.
         class FinalizationAtMostOnePropertyList < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The finalization module MUST NOT contain more than one propertyList child.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             lists = node.property_lists || []
             return [] if lists.length <= 1
 

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # A `finalization` module MUST contain at least one of:
+        # `molecule`, `propertyList`, or a user-defined module child.
+        # Per the compchem convention spec.
+        class FinalizationMustHaveContent < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `finalization` module MUST contain at least one of: `molecule`, `propertyList`, or a user-defined module child. Per the compchem convention spec.'
+          applies_to Chemicalml::Cml::Role::Module
+
+          def check_node(node, path)
+            return [] unless node.dict_ref == 'compchem:finalization'
+
+            has_molecule = (node.molecules || []).any?
+            has_prop_list = (node.property_lists || []).any?
+            has_user_module = user_module_count(node).positive?
+            return [] if has_molecule || has_prop_list || has_user_module
+
+            [violation(path: path.join('/'),
+                       message: 'finalization module must contain at least one of: ' \
+                                'molecule, propertyList, or user-defined module')]
+          end
+
+          private
+
+          COMPCHEM_ROLES = %w[
+            compchem:jobList compchem:job compchem:initialization
+            compchem:calculation compchem:finalization compchem:environment
+          ].freeze
+
+          def user_module_count(node)
+            (node.modules || []).count do |m|
+              dr = m.dict_ref.to_s
+              !dr.empty? && !COMPCHEM_ROLES.include?(dr)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,11 +8,11 @@ module Chemicalml
         # parameterList children directly. (Parameters belong in
         # initialization.)
         class FinalizationMustNotContainParameter < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The finalization module MUST NOT contain parameter or parameterList children directly. (Parameters belong in initialization.)'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             violations = []
             unless (node.parameter_lists || []).empty?
               violations << violation(path: path.join('/'),

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

@@ -7,11 +7,11 @@ module Chemicalml
         # The initialization module MUST NOT contain more than one
         # molecule child.
         class InitializationAtMostOneMolecule < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The initialization module MUST NOT contain more than one molecule child.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             molecules = node.molecules || []
             return [] if molecules.length <= 1
 

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

@@ -7,11 +7,11 @@ module Chemicalml
         # The initialization module MUST NOT contain more than one
         # parameterList child.
         class InitializationAtMostOneParameterList < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The initialization module MUST NOT contain more than one parameterList child.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             lists = node.parameter_lists || []
             return [] if lists.length <= 1
 

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # An `initialization` module MUST contain at least one of:
+        # `molecule`, `parameterList`, or a user-defined module child.
+        # Per the compchem convention spec.
+        class InitializationMustHaveContent < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'An `initialization` module MUST contain at least one of: `molecule`, `parameterList`, or a user-defined module child. Per the compchem convention spec.'
+          applies_to Chemicalml::Cml::Role::Module
+
+          def check_node(node, path)
+            return [] unless node.dict_ref == 'compchem:initialization'
+
+            has_molecule = molecule_count(node).positive?
+            has_param_list = parameter_list_count(node).positive?
+            has_user_module = user_module_count(node).positive?
+            return [] if has_molecule || has_param_list || has_user_module
+
+            [violation(path: path.join('/'),
+                       message: 'initialization module must contain at least one of: ' \
+                                'molecule, parameterList, or user-defined module')]
+          end
+
+          private
+
+          def molecule_count(node)
+            (node.molecules || []).size
+          end
+
+          def parameter_list_count(node)
+            (node.parameter_lists || []).size
+          end
+
+          # User-defined modules: any module child whose dict_ref is
+          # not one of the compchem-defined roles.
+          COMPCHEM_ROLES = %w[
+            compchem:jobList compchem:job compchem:initialization
+            compchem:calculation compchem:finalization compchem:environment
+          ].freeze
+
+          def user_module_count(node)
+            (node.modules || []).count do |m|
+              dr = m.dict_ref.to_s
+              !dr.empty? && !COMPCHEM_ROLES.include?(dr)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,11 +8,11 @@ module Chemicalml
         # propertyList children directly. (Properties belong in
         # finalization.)
         class InitializationMustNotContainProperty < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'The initialization module MUST NOT contain property or propertyList children directly. (Properties belong in finalization.)'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             violations = []
             unless (node.property_lists || []).empty?
               violations << violation(path: path.join('/'),

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

@@ -7,6 +7,7 @@ module Chemicalml
         # A jobList module MUST have an `id` unique within the
         # compchem module.
         class JobListModuleMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A jobList module MUST have an `id` unique within the compchem module.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 

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

@@ -6,11 +6,11 @@ module Chemicalml
       module Constraints
         # A job module MUST contain at most one environment module.
         class JobModuleAtMostOneEnvironment < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A job module MUST contain at most one environment module.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             environments = child_modules_with(node, 'compchem:environment')
             return [] if environments.length <= 1
 

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

@@ -6,11 +6,11 @@ module Chemicalml
       module Constraints
         # A job module MUST contain at most one finalization module.
         class JobModuleAtMostOneFinalization < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A job module MUST contain at most one finalization module.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 
           def check_node(node, path)
-
             finalizations = child_modules_with(node, 'compchem:finalization')
             return [] if finalizations.length <= 1
 

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

@@ -7,6 +7,7 @@ module Chemicalml
         # A job module MUST have an `id` unique within the compchem
         # module.
         class JobModuleMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A job module MUST have an `id` unique within the compchem module.'
           applies_to Chemicalml::Cml::Role::Module
           include ModulePredicates
 

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

@@ -7,6 +7,7 @@ module Chemicalml
         # A job module MUST contain exactly one initialization module
         # child per the compchem convention.
         class JobMustContainInitialization < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A job module MUST contain exactly one initialization module child per the compchem convention.'
           applies_to Chemicalml::Cml::Role::Module
           def check_node(node, path)
             return [] unless node.dict_ref == 'compchem:job'

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

@@ -8,13 +8,13 @@ module Chemicalml
         # and `columns` attributes (each ≥ 1); `dataType` MUST be
         # integer or double; MUST have `units`.
         class MatrixRules < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'CompChem `matrix` value-container rules: MUST have `rows` and `columns` attributes (each ≥ 1); `dataType` MUST be integer or double; MUST have `units`.'
           applies_to Chemicalml::Cml::Role::Matrix
           include ModulePredicates
 
           ALLOWED_TYPES = %w[xsd:integer xsd:double].freeze
 
           def check_node(node, path)
-
             violations = []
             if node.rows.to_s.empty? || node.rows.to_i < 1
               violations << violation(path: path.join('/'),

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

@@ -8,13 +8,13 @@ module Chemicalml
         # `xsd:integer` or `xsd:double` MUST have `units`; `scalar`
         # with dataType `xsd:string` MUST NOT have `units`.
         class ScalarUnits < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'CompChem value-container rules: `scalar` with dataType `xsd:integer` or `xsd:double` MUST have `units`; `scalar` with dataType `xsd:string` MUST NOT have `units`.'
           applies_to Chemicalml::Cml::Role::Scalar
           include ModulePredicates
 
           NUMERIC_TYPES = %w[xsd:integer xsd:double].freeze
 
           def check_node(node, path)
-
             data_type = node.data_type.to_s
             units = node.units.to_s
             violations = []

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

@@ -42,6 +42,10 @@ module Chemicalml
                  '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
@@ -39,6 +39,8 @@ module Chemicalml
       register Constraints::ScalarUnits
       register Constraints::ArrayRules
       register Constraints::MatrixRules
+      register Constraints::InitializationMustHaveContent
+      register Constraints::FinalizationMustHaveContent
     end
   end
 end

data/lib/chemicalml/convention/constraint.rb

@@ -15,9 +15,7 @@ module Chemicalml
       class << self
         # Returns the Role module(s) this constraint applies to, or
         # nil if it must run for every node.
-        def applies_to_roles
-          @applies_to_roles
-        end
+        attr_reader :applies_to_roles
 
         # Declare one or more Role modules this constraint handles.
         #   applies_to Chemicalml::Cml::Role::Atom
@@ -25,6 +23,28 @@ module Chemicalml
         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
@@ -38,21 +58,32 @@ module Chemicalml
 
       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
 

data/lib/chemicalml/convention/coordinator.rb

@@ -16,10 +16,10 @@ module Chemicalml
 
       def initialize(constraint_classes)
         @document_constraints = constraint_classes
-                                  .select { |c| c < Constraint::DocumentConstraint }
-                                  .map(&:new)
+                                .select { |c| c < Constraint::DocumentConstraint }
+                                .map(&:new)
         @node_constraints = constraint_constraints(constraint_classes)
-                              .map(&:new)
+                            .map(&:new)
         @always_applicable = []
         @by_role = Hash.new { |h, k| h[k] = [] }
         @node_constraints.each { |c| register(c) }
@@ -62,6 +62,7 @@ module Chemicalml
         applicable = @always_applicable
         node.class.ancestors.each do |ancestor|
           next unless ancestor.is_a?(::Module)
+
           bucket = @by_role[ancestor]
           next unless bucket
 

data/lib/chemicalml/convention/detection.rb

@@ -3,21 +3,27 @@
 module Chemicalml
   module Convention
     # Convention detection from a wire document. Reads the
-    # `convention` attribute from the root element (Document, Module,
-    # Molecule, Dictionary, UnitList, or UnitTypeList) and returns
-    # the QName string (e.g. "convention:molecular").
+    # `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::UnitTypeList,
+        Chemicalml::Cml::Role::Spectrum,
+        Chemicalml::Cml::Role::SpectrumList,
+        Chemicalml::Cml::Role::ReactionScheme,
+        Chemicalml::Cml::Role::ReactionList
       ].freeze
 
       def self.convention_of(document)

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

@@ -8,6 +8,7 @@ module Chemicalml
         # 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?

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

@@ -7,9 +7,9 @@ module Chemicalml
         # 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?('/', '#')

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

@@ -8,11 +8,11 @@ module Chemicalml
         # 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)

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

@@ -7,9 +7,9 @@ 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)
-
             entries = node.entries || []
             ids = entries.map(&:id).compact
             duplicates = ids.group_by { |x| x }.select { |_, v| v.length > 1 }.keys

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

@@ -8,6 +8,7 @@ module Chemicalml
         # 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?

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

@@ -7,9 +7,9 @@ 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)
-
             violations = []
             if node.id.to_s.empty?
               violations << violation(path: path.join('/'),

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

@@ -9,6 +9,7 @@ module Chemicalml
         # 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?