chemicalml 0.2.0 → 0.3.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # 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?
+            return [] unless finalizations.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'job module has a calculation but no finalization ' \
+                                '(finalization MUST be present when calculation is)')]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,20 +7,21 @@ 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("/"),
-                       message: "compchem module must contain at least one jobList module")]
+            [violation(path: path.join('/'),
+                       message: 'compchem module must contain at least one jobList module')]
           end
 
           private
 
           def compchem_root?(node)
-            module?(node) && node.convention == "convention:compchem"
+            module?(node) && node.convention == 'convention:compchem'
           end
 
           def module?(node)

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
+          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
+
+            [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
+          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('/'),
+                                      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
+          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
+
+            [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
+          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
+
+            [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_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

@@ -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
+          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('/'),
+                                      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
+          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
+
+            [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
+          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
+
+            [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_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

@@ -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
+          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('/'),
+                                      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,25 @@
+# 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
+          self.description = 'A jobList module MUST have an `id` unique within the compchem module.'
+          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
+          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
+
+            [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
+          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
+
+            [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,25 @@
+# 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
+          self.description = 'A job module MUST have an `id` unique within the compchem module.'
+          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,27 @@ 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 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
+          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('/'),
+                                      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
+          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 = []
+
+            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