chemicalml 0.2.0 → 0.2.1

data/lib/chemicalml/cml/role/operator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Operator
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/related_entry.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module RelatedEntry
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/string.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module String
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/string_array.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module StringArray
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/tcell.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Tcell
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role/trow.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Role
+      module Trow
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/role.rb

@@ -134,6 +134,23 @@ module Chemicalml
       autoload :Xaxis, "chemicalml/cml/role/xaxis"
       autoload :Yaxis, "chemicalml/cml/role/yaxis"
       autoload :ZMatrix, "chemicalml/cml/role/z_matrix"
+      autoload :Alternative, "chemicalml/cml/role/alternative"
+      autoload :Arg, "chemicalml/cml/role/arg"
+      autoload :ComplexObject, "chemicalml/cml/role/complex_object"
+      autoload :Expression, "chemicalml/cml/role/expression"
+      autoload :Float, "chemicalml/cml/role/float"
+      autoload :FloatArray, "chemicalml/cml/role/float_array"
+      autoload :Integer, "chemicalml/cml/role/integer"
+      autoload :IntegerArray, "chemicalml/cml/role/integer_array"
+      autoload :Operator, "chemicalml/cml/role/operator"
+      autoload :RelatedEntry, "chemicalml/cml/role/related_entry"
+      autoload :String, "chemicalml/cml/role/string"
+      autoload :StringArray, "chemicalml/cml/role/string_array"
+      autoload :Tcell, "chemicalml/cml/role/tcell"
+      autoload :Trow, "chemicalml/cml/role/trow"
+      autoload :Annotation, "chemicalml/cml/role/annotation"
+      autoload :Appinfo, "chemicalml/cml/role/appinfo"
+      autoload :Enumeration, "chemicalml/cml/role/enumeration"
     end
   end
 end

data/lib/chemicalml/cml/schema24/alternative.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Alternative < Lutaml::Model::Serializable
+        include Base::Alternative
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/annotation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. `<annotation>` wraps documentation for an
+      # entry or element. Not in Schema 3.
+      class Annotation < Lutaml::Model::Serializable
+        include Base::Annotation
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/appinfo.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. `<appinfo>` carries application-specific
+      # metadata. Not in Schema 3.
+      class Appinfo < Lutaml::Model::Serializable
+        include Base::Appinfo
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/arg.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Arg < Lutaml::Model::Serializable
+        include Base::Arg
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/cml_module.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # CML <module> wire class. Schema 2.4 declares <module> in its
+      # XSD (verified against `reference-docs/schemas/schema24/`), so
+      # this class exists and is registered by `Schema24::Configuration`.
+      # See `Chemicalml::Cml::Base::Module` for the shared attribute
+      # + xml-mapping declarations.
+      class Module < Lutaml::Model::Serializable
+        include Base::Module
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/complex_object.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class ComplexObject < Lutaml::Model::Serializable
+        include Base::ComplexObject
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/configuration.rb

@@ -8,10 +8,13 @@ module Chemicalml
 
         CONTEXT_ID = :chemicalml_schema24
 
-        # Schema 2.4 lacks the generic <module> element (introduced
-        # in Schema 3) — skip its registration.
+        # Schema 2.4 lacks <anyCml> (Schema 3 only) — skip its
+        # registration. Schema 2.4 also declares three legacy
+        # elements (<annotation>, <appinfo>, <enumeration>) not in
+        # Schema 3; register those explicitly from SCHEMA24_ONLY.
         def self.register_models!
           register_elements!(except: Chemicalml::Cml::Elements::SCHEMA3_ONLY)
+          register_elements!(only: true)
         end
       end
     end

data/lib/chemicalml/cml/schema24/enumeration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. `<enumeration>` declares a closed/open set of
+      # values for a dictionary entry. Not in Schema 3 (Schema 3 uses
+      # the `enum` attribute on `<entry>`).
+      class Enumeration < Lutaml::Model::Serializable
+        include Base::Enumeration
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/expression.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Expression < Lutaml::Model::Serializable
+        include Base::Expression
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/float.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Float < Lutaml::Model::Serializable
+        include Base::Float
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/float_array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class FloatArray < Lutaml::Model::Serializable
+        include Base::FloatArray
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/integer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Integer < Lutaml::Model::Serializable
+        include Base::Integer
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/integer_array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class IntegerArray < Lutaml::Model::Serializable
+        include Base::IntegerArray
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/operator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Operator < Lutaml::Model::Serializable
+        include Base::Operator
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/related_entry.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class RelatedEntry < Lutaml::Model::Serializable
+        include Base::RelatedEntry
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/string.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class String < Lutaml::Model::Serializable
+        include Base::String
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/string_array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class StringArray < Lutaml::Model::Serializable
+        include Base::StringArray
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/tcell.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Tcell < Lutaml::Model::Serializable
+        include Base::Tcell
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24/trow.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Cml
+    module Schema24
+      # Schema 2.4 only. Not in Schema 3.
+      class Trow < Lutaml::Model::Serializable
+        include Base::Trow
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end

data/lib/chemicalml/cml/schema24.rb

@@ -7,10 +7,21 @@ module Chemicalml
     # `Base::*` mixin and `Visitable`, and `extend`s
     # `Schema24::Context` for `lutaml_default_register`.
     #
-    # NOTE: Schema 2.4 lacks the generic `<module>` element
-    # (introduced in Schema 3). `Schema24::Module` therefore does not
-    # exist — compchem-convention documents MUST be parsed as
-    # Schema 3. See `Chemicalml::Cml::Elements::SCHEMA3_ONLY`.
+    # Schema 2.4 wire classes. Same structure as Schema3 — each is a
+    # `Lutaml::Model::Serializable` subclass that includes the
+    # `Base::*` mixin and `Visitable`, and `extend`s
+    # `Schema24::Context` for `lutaml_default_register`.
+    #
+    # Schema 2.4 lacks `<anyCml>` (Schema 3 only — see
+    # `Chemicalml::Cml::Elements::SCHEMA3_ONLY`). Every other element
+    # modeled here is declared in the Schema 2.4 XSD, including
+    # `<module>`. Schema 2.4 also declares 17 legacy elements not in
+    # Schema 3 (`alternative`, `annotation`, `appinfo`, `arg`,
+    # `complexObject`, `enumeration`, `expression`, `float`,
+    # `floatArray`, `integer`, `integerArray`, `operator`,
+    # `relatedEntry`, `string`, `stringArray`, `tcell`, `trow`); all
+    # are modeled under Schema24 only and registered via
+    # `Elements::SCHEMA24_ONLY`.
     module Schema24
       extend Chemicalml::VersionedParser
 
@@ -19,7 +30,6 @@ module Chemicalml
       autoload :ActionList, "chemicalml/cml/schema24/action_list"
       autoload :Amount, "chemicalml/cml/schema24/amount"
       autoload :Angle, "chemicalml/cml/schema24/angle"
-      autoload :AnyCml, "chemicalml/cml/schema24/any_cml"
       autoload :ArrayList, "chemicalml/cml/schema24/array_list"
       autoload :AtomSet, "chemicalml/cml/schema24/atom_set"
       autoload :AtomType, "chemicalml/cml/schema24/atom_type"
@@ -121,6 +131,7 @@ module Chemicalml
       autoload :Matrix,          "chemicalml/cml/schema24/matrix"
       autoload :Metadata,        "chemicalml/cml/schema24/metadata"
       autoload :MetadataList,    "chemicalml/cml/schema24/metadata_list"
+      autoload :Module,          "chemicalml/cml/schema24/cml_module"
       autoload :Molecule,        "chemicalml/cml/schema24/molecule"
       autoload :Name,            "chemicalml/cml/schema24/name"
       autoload :Parameter,       "chemicalml/cml/schema24/parameter"
@@ -139,6 +150,23 @@ module Chemicalml
       autoload :UnitList,        "chemicalml/cml/schema24/unit_list"
       autoload :UnitType,        "chemicalml/cml/schema24/unit_type"
       autoload :UnitTypeList,    "chemicalml/cml/schema24/unit_type_list"
+      autoload :Alternative, "chemicalml/cml/schema24/alternative"
+      autoload :Arg, "chemicalml/cml/schema24/arg"
+      autoload :ComplexObject, "chemicalml/cml/schema24/complex_object"
+      autoload :Expression, "chemicalml/cml/schema24/expression"
+      autoload :Float, "chemicalml/cml/schema24/float"
+      autoload :FloatArray, "chemicalml/cml/schema24/float_array"
+      autoload :Integer, "chemicalml/cml/schema24/integer"
+      autoload :IntegerArray, "chemicalml/cml/schema24/integer_array"
+      autoload :Operator, "chemicalml/cml/schema24/operator"
+      autoload :RelatedEntry, "chemicalml/cml/schema24/related_entry"
+      autoload :String, "chemicalml/cml/schema24/string"
+      autoload :StringArray, "chemicalml/cml/schema24/string_array"
+      autoload :Tcell, "chemicalml/cml/schema24/tcell"
+      autoload :Trow, "chemicalml/cml/schema24/trow"
+      autoload :Annotation, "chemicalml/cml/schema24/annotation"
+      autoload :Appinfo, "chemicalml/cml/schema24/appinfo"
+      autoload :Enumeration, "chemicalml/cml/schema24/enumeration"
 
       def self.schema
         SCHEMA

data/lib/chemicalml/cml.rb

@@ -9,17 +9,15 @@ module Chemicalml
   module Cml
     # Structural modules (each in its own file, loaded independently).
     autoload :Base,              "chemicalml/cml/base"
-    autoload :ChildMappings,    "chemicalml/cml/child_mappings"
     autoload :Elements,          "chemicalml/cml/elements"
     autoload :Namespace,         "chemicalml/cml/namespace"
     autoload :Role,              "chemicalml/cml/role"
     autoload :Schema3,           "chemicalml/cml/schema3"
     autoload :Schema24,          "chemicalml/cml/schema24"
-    autoload :Translator,        "chemicalml/cml/translator"
     autoload :Visitable,         "chemicalml/cml/visitable"
     autoload :WireClassRegistry, "chemicalml/cml/wire_class_registry"
 
-    # Backward-compatible aliases (Cml::Foo = Schema3::Foo). All 36
+    # Backward-compatible aliases (Cml::Foo = Schema3::Foo). All 121
     # aliases load from a single file via autoload — the file loads
     # lazily when the first alias is referenced, then defines all of
     # them via const_set (aliasing existing Schema3 classes, not

data/lib/chemicalml/context_configuration.rb

@@ -40,10 +40,16 @@ module Chemicalml
     # each class on the parent (schema) module, and register it. Pass
     # `except:` to skip specific elements (used by Schema 2.4 which
     # lacks `<module>`).
-    def register_elements!(except: [])
+    def register_elements!(except: [], only: nil)
       parent = version_parent_module
       skip = except.to_set
-      Chemicalml::Cml::Elements::ALL.each do |class_name, element_id|
+      source =
+        if only
+          Chemicalml::Cml::Elements::SCHEMA24_ONLY
+        else
+          Chemicalml::Cml::Elements::ALL
+        end
+      source.each do |class_name, element_id|
         next if skip.include?(class_name)
         next unless parent.const_defined?(class_name)
 

data/lib/chemicalml/convention/base.rb

@@ -27,13 +27,20 @@ module Chemicalml
 
       def register(constraint_class)
         constraints << constraint_class unless constraints.include?(constraint_class)
+        @coordinator = nil # invalidate cached coordinator
         self
       end
 
+      # Single-pass validation via Convention::Coordinator. The
+      # coordinator builds a role-dispatch table from the declared
+      # `applies_to` on each constraint, walks the tree once, and
+      # dispatches each node only to applicable constraints.
       def validate(document)
-        constraints.flat_map do |klass|
-          klass.new.check(document)
-        end
+        coordinator.validate(document)
+      end
+
+      def validate_report(document)
+        ValidationReport.new(validate(document))
       end
 
       def constraint_count
@@ -42,6 +49,13 @@ module Chemicalml
 
       def reset_constraints!
         @constraints = []
+        @coordinator = nil
+      end
+
+      private
+
+      def coordinator
+        @coordinator ||= Coordinator.new(constraints)
       end
     end
   end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Compchem
+      module Constraints
+        # CompChem `array` value-container rules: MUST have `size`
+        # attribute (≥ 1); `dataType` MUST be integer or double;
+        # MUST have `units`.
+        class ArrayRules < Chemicalml::Convention::Constraint::NodeConstraint
+          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('/'),
+                                      message: 'array must have a size attribute (minimum 1)')
+            end
+            unless ALLOWED_TYPES.include?(node.data_type.to_s)
+              violations << violation(path: path.join('/'),
+                                      message: 'array 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: 'array must have units (even if dimensionless)')
+            end
+            violations
+          end
+
+          private
+
+          def array?(node)
+            node.is_a?(Chemicalml::Cml::Role::Array)
+          end
+        end
+      end
+    end
+  end
+end

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
+          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

@@ -10,17 +10,17 @@ module Chemicalml
           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)