chemicalml 0.2.0 → 0.2.1

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The environment module MUST NOT contain more than one
+        # propertyList child.
+        class EnvironmentAtMostOnePropertyList < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            lists = node.property_lists || []
+            return [] if lists.length <= 1
+
+            [violation(path: path.join('/'),
+                       message: 'environment module must not contain more than ' \
+                                "one propertyList (found #{lists.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The environment module MUST NOT contain parameter or
+        # parameterList children directly. It MAY contain a
+        # propertyList (which itself can hold parameters).
+        class EnvironmentMustNotContainParameter < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            violations = []
+            unless (node.parameter_lists || []).empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'environment module must not contain parameterList children ' \
+                                               '(use propertyList instead)')
+            end
+            violations
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The finalization module MUST NOT contain more than one
+        # molecule child.
+        class FinalizationAtMostOneMolecule < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            molecules = node.molecules || []
+            return [] if molecules.length <= 1
+
+            [violation(path: path.join('/'),
+                       message: 'finalization module must not contain more than ' \
+                                "one molecule (found #{molecules.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The finalization module MUST NOT contain more than one
+        # propertyList child.
+        class FinalizationAtMostOnePropertyList < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            lists = node.property_lists || []
+            return [] if lists.length <= 1
+
+            [violation(path: path.join('/'),
+                       message: 'finalization module must not contain more than ' \
+                                "one propertyList (found #{lists.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The finalization module MUST NOT contain parameter or
+        # parameterList children directly. (Parameters belong in
+        # initialization.)
+        class FinalizationMustNotContainParameter < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            violations = []
+            unless (node.parameter_lists || []).empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'finalization module must not contain parameterList children')
+            end
+            violations
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The initialization module MUST NOT contain more than one
+        # molecule child.
+        class InitializationAtMostOneMolecule < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            molecules = node.molecules || []
+            return [] if molecules.length <= 1
+
+            [violation(path: path.join('/'),
+                       message: 'initialization module must not contain more than ' \
+                                "one molecule (found #{molecules.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The initialization module MUST NOT contain more than one
+        # parameterList child.
+        class InitializationAtMostOneParameterList < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            lists = node.parameter_lists || []
+            return [] if lists.length <= 1
+
+            [violation(path: path.join('/'),
+                       message: 'initialization module must not contain more than ' \
+                                "one parameterList (found #{lists.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # The initialization module MUST NOT contain property or
+        # propertyList children directly. (Properties belong in
+        # finalization.)
+        class InitializationMustNotContainProperty < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+
+            violations = []
+            unless (node.property_lists || []).empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'initialization module must not contain propertyList children ' \
+                                               '(properties belong in finalization)')
+            end
+            violations
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # A jobList module MUST have an `id` unique within the
+        # compchem module.
+        class JobListModuleMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+            return [] unless node.dict_ref == 'compchem:jobList'
+            return [] unless node.id.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'jobList module must have an id unique within the compchem module')]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # A job module MUST contain at most one environment module.
+        class JobModuleAtMostOneEnvironment < Chemicalml::Convention::Constraint::NodeConstraint
+          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
+
+            [violation(path: path.join('/'),
+                       message: 'job module must contain at most one environment ' \
+                                "(found #{environments.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # A job module MUST contain at most one finalization module.
+        class JobModuleAtMostOneFinalization < Chemicalml::Convention::Constraint::NodeConstraint
+          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
+
+            [violation(path: path.join('/'),
+                       message: 'job module must contain at most one finalization ' \
+                                "(found #{finalizations.length})")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # A job module MUST have an `id` unique within the compchem
+        # module.
+        class JobModuleMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
+          include ModulePredicates
+
+          def check_node(node, path)
+            return [] unless node.dict_ref == 'compchem:job'
+            return [] unless node.id.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'job module must have an id unique within the compchem module')]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,29 +7,26 @@ module Chemicalml
         # A job module MUST contain exactly one initialization module
         # child per the compchem convention.
         class JobMustContainInitialization < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::Module
           def check_node(node, path)
-            return [] unless job_module?(node)
+            return [] unless node.dict_ref == 'compchem:job'
 
             modules = node.modules || []
-            inits = modules.select { |m| m.dict_ref == "compchem:initialization" }
+            inits = modules.select { |m| m.dict_ref == 'compchem:initialization' }
             return [] if inits.length == 1
 
             message = if inits.empty?
-                        "job module must contain exactly one initialization module (found 0)"
+                        'job module must contain exactly one initialization module (found 0)'
                       else
                         "job module must contain exactly one initialization module (found #{inits.length})"
                       end
-            [violation(path: path.join("/"), message: message)]
+            [violation(path: path.join('/'), message: message)]
           end
 
           private
 
           def job_module?(node)
-            module?(node) && node.dict_ref == "compchem:job"
-          end
-
-          def module?(node)
-            node.is_a?(Chemicalml::Cml::Role::Module)
+            node.is_a?(Chemicalml::Cml::Role::Module) && node.dict_ref == 'compchem:job'
           end
         end
       end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # CompChem `matrix` value-container rules: MUST have `rows`
+        # and `columns` attributes (each ≥ 1); `dataType` MUST be
+        # integer or double; MUST have `units`.
+        class MatrixRules < Chemicalml::Convention::Constraint::NodeConstraint
+          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('/'),
+                                      message: 'matrix must have a rows attribute (minimum 1)')
+            end
+            if node.columns.to_s.empty? || node.columns.to_i < 1
+              violations << violation(path: path.join('/'),
+                                      message: 'matrix must have a columns attribute (minimum 1)')
+            end
+            unless ALLOWED_TYPES.include?(node.data_type.to_s)
+              violations << violation(path: path.join('/'),
+                                      message: 'matrix dataType must be xsd:integer or xsd:double ' \
+                                               "(got #{node.data_type.inspect})")
+            end
+            if node.units.to_s.empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'matrix must have units (even if dimensionless)')
+            end
+            violations
+          end
+
+          private
+
+          def matrix?(node)
+            node.is_a?(Chemicalml::Cml::Role::Matrix)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # Internal: helpers shared by every compchem constraint. Mixed
+        # into each constraint class so the role + dictRef checks
+        # live in one place (DRY).
+        module ModulePredicates
+          def cml_module?(node)
+            node.is_a?(Chemicalml::Cml::Role::Module)
+          end
+
+          def compchem_root?(node)
+            cml_module?(node) && node.convention == 'convention:compchem'
+          end
+
+          def job_list_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:jobList'
+          end
+
+          def job_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:job'
+          end
+
+          def initialization_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:initialization'
+          end
+
+          def calculation_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:calculation'
+          end
+
+          def finalization_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:finalization'
+          end
+
+          def environment_module?(node)
+            cml_module?(node) && node.dict_ref == 'compchem:environment'
+          end
+
+          def child_modules_with(node, dict_ref)
+            (node.modules || []).select { |m| m.dict_ref == dict_ref }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # CompChem value-container rules: `scalar` with dataType
+        # `xsd:integer` or `xsd:double` MUST have `units`; `scalar`
+        # with dataType `xsd:string` MUST NOT have `units`.
+        class ScalarUnits < Chemicalml::Convention::Constraint::NodeConstraint
+          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 = []
+
+            if NUMERIC_TYPES.include?(data_type) && units.empty?
+              violations << violation(path: path.join('/'),
+                                      message: "scalar with dataType #{data_type.inspect} must have units")
+            end
+            if data_type == 'xsd:string' && !units.empty?
+              violations << violation(path: path.join('/'),
+                                      message: "scalar with dataType 'xsd:string' must not have units")
+            end
+            violations
+          end
+
+          private
+
+          def scalar?(node)
+            node.is_a?(Chemicalml::Cml::Role::Scalar)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,10 +4,44 @@ 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'
       end
     end
   end

data/lib/chemicalml/convention/compchem.rb

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

data/lib/chemicalml/convention/constraint.rb

@@ -3,26 +3,37 @@
 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.
+        def applies_to_roles
+          @applies_to_roles
+        end
+
+        # 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
+      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
@@ -54,8 +65,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 +82,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