chemicalml 0.2.0 → 0.2.1

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_id_must_match_pattern.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitType>` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*`.
+        class UnitTypeIdMustMatchPattern < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::UnitType
+          PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
+
+          def check_node(node, path)
+
+            id = node.id.to_s
+            return [] if id.empty?
+            return [] if id.match?(PATTERN)
+
+            [violation(path: path.join('/'),
+                       message: "unitType id #{id.inspect} must match [A-Za-z][A-Za-z0-9._-]*")]
+          end
+
+          private
+
+          def unit_type?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitType)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_contain_at_least_one_unit_type.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitTypeList>` MUST contain one or more `<unitType>`
+        # children.
+        class UnitTypeListMustContainAtLeastOneUnitType < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::UnitTypeList
+          def check_node(node, path)
+            return [] if (node.unit_types || []).length.positive?
+
+            [violation(path: path.join('/'),
+                       message: 'unitTypeList must contain at least one unitType child')]
+          end
+
+          private
+
+          def unit_type_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitTypeList)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_have_namespace.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitTypeList>` MUST have a `namespace` attribute (valid
+        # URI, SHOULD end with `/` or `#`).
+        class UnitTypeListMustHaveNamespace < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::UnitTypeList
+          def check_node(node, path)
+
+            violations = []
+            ns = node.namespace.to_s
+            if ns.empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'unitTypeList must have a namespace attribute')
+            elsif !ns.end_with?('/', '#')
+              violations << violation(path: path.join('/'),
+                                      message: "unitTypeList namespace #{ns.inspect} should end with / or #",
+                                      severity: :warning)
+            end
+            violations
+          end
+
+          private
+
+          def unit_type_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitTypeList)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_contain_definition.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitType>` MUST contain a single `<definition>` child
+        # with XHTML content.
+        class UnitTypeMustContainDefinition < Chemicalml::Convention::Constraint::NodeConstraint
+          applies_to Chemicalml::Cml::Role::UnitType
+          def check_node(node, path)
+            return [] unless node.definition.to_s.strip.empty?
+
+            [violation(path: path.join('/'),
+                       message: "unitType #{node.id.inspect} must contain a single definition child")]
+          end
+
+          private
+
+          def unit_type?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitType)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name.rb

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

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

@@ -5,7 +5,15 @@ module Chemicalml
     module UnitTypeDictionary
       module Constraints
         autoload :UnitTypeMustHaveIdAndName,
-                 "chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name"
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name'
+        autoload :UnitTypeIdMustMatchPattern,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_id_must_match_pattern'
+        autoload :UnitTypeMustContainDefinition,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_contain_definition'
+        autoload :UnitTypeListMustHaveNamespace,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_have_namespace'
+        autoload :UnitTypeListMustContainAtLeastOneUnitType,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_contain_at_least_one_unit_type'
       end
     end
   end

data/lib/chemicalml/convention/unit_type_dictionary.rb

@@ -22,6 +22,10 @@ module Chemicalml
       end
 
       register Constraints::UnitTypeMustHaveIdAndName
+      register Constraints::UnitTypeIdMustMatchPattern
+      register Constraints::UnitTypeMustContainDefinition
+      register Constraints::UnitTypeListMustHaveNamespace
+      register Constraints::UnitTypeListMustContainAtLeastOneUnitType
     end
   end
 end

data/lib/chemicalml/convention/validation_report.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # Value object wrapping the violations returned by `validate`.
+    # Gives callers severity-based views without losing the raw array
+    # (still exposed as `#violations`).
+    #
+    # Constructed by `Convention.validate_report` (new API) —
+    # `Convention.validate` keeps its array return shape so existing
+    # callers don't break.
+    class ValidationReport
+      attr_reader :violations
+
+      def initialize(violations)
+        @violations = violations.to_a.freeze
+      end
+
+      def errors
+        @errors ||= violations.select(&:error?).freeze
+      end
+
+      def warnings
+        @warnings ||= violations.select(&:warning?).freeze
+      end
+
+      def ok?
+        errors.empty?
+      end
+
+      def has_warnings?
+        warnings.any?
+      end
+
+      def size
+        violations.length
+      end
+
+      def +(other)
+        return other if other.nil?
+
+        unless other.is_a?(ValidationReport)
+          raise ArgumentError, "cannot combine ValidationReport with #{other.class}"
+        end
+
+        ValidationReport.new(violations + other.violations)
+      end
+
+      def ==(other)
+        other.is_a?(ValidationReport) && violations == other.violations
+      end
+      alias eql? ==
+
+      def hash
+        violations.hash
+      end
+
+      def to_s
+        "#{size} violation(s): #{errors.length} error(s), #{warnings.length} warning(s)"
+      end
+    end
+  end
+end

data/lib/chemicalml/convention.rb

@@ -19,11 +19,14 @@ module Chemicalml
     autoload :Base,                "chemicalml/convention/base"
     autoload :Compchem,            "chemicalml/convention/compchem"
     autoload :Constraint,          "chemicalml/convention/constraint"
+    autoload :Coordinator,         "chemicalml/convention/coordinator"
+    autoload :Detection,           "chemicalml/convention/detection"
     autoload :Dictionary,          "chemicalml/convention/dictionary"
     autoload :Molecular,           "chemicalml/convention/molecular"
     autoload :Registry,            "chemicalml/convention/registry"
     autoload :UnitDictionary,      "chemicalml/convention/unit_dictionary"
     autoload :UnitTypeDictionary,  "chemicalml/convention/unit_type_dictionary"
+    autoload :ValidationReport,    "chemicalml/convention/validation_report"
     autoload :Violation,           "chemicalml/convention/violation"
 
     CONVENTION_NAMESPACE = "http://www.xml-cml.org/convention/".freeze
@@ -35,5 +38,13 @@ module Chemicalml
     def self.validate(document, qname:)
       Registry.validate(document, qname: qname)
     end
+
+    def self.validate_report(document, qname:)
+      Registry.validate_report(document, qname: qname)
+    end
+
+    def self.detect_and_validate(document)
+      Registry.detect_and_validate(document)
+    end
   end
 end

data/lib/chemicalml/dictionary/entry.rb

@@ -6,7 +6,7 @@ module Chemicalml
     # The YAML shape mirrors the structure documented in
     # `TODO.cml-full/05-dictionary-layer.md`.
     class Entry
-      ID_PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/.freeze
+      ID_PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
 
       attr_reader :id, :term, :definition, :description,
                   :data_type, :unit_type, :units,
@@ -30,7 +30,7 @@ module Chemicalml
         freeze
       end
 
-      def to_h
+      def value_attributes
         h = {
           id: id,
           term: term,
@@ -40,19 +40,19 @@ module Chemicalml
         h[:data_type]   = data_type   if data_type
         h[:unit_type]   = unit_type   if unit_type
         h[:units]       = units       if units
-        h[:enum]        = enum.to_h   if enum
-        h[:links]       = links.map(&:to_h) unless links.empty?
+        h[:enum]        = enum.value_attributes if enum
+        h[:links]       = links.map(&:value_attributes) unless links.empty?
         h[:source_code] = source_code if source_code
         h
       end
 
       def eql?(other)
-        other.is_a?(Entry) && id == other.id && to_h == other.to_h
+        other.is_a?(Entry) && id == other.id && value_attributes == other.value_attributes
       end
       alias == eql?
 
       def hash
-        [id, to_h].hash
+        [id, value_attributes].hash
       end
     end
   end

data/lib/chemicalml/dictionary/enum.rb

@@ -34,7 +34,7 @@ module Chemicalml
         values.include?(value)
       end
 
-      def to_h
+      def value_attributes
         { kind: kind, values: values }
       end
 

data/lib/chemicalml/dictionary/link.rb

@@ -15,17 +15,17 @@ module Chemicalml
         freeze
       end
 
-      def to_h
+      def value_attributes
         { rel: rel, href: href, title: title }.compact
       end
 
       def eql?(other)
-        other.is_a?(Link) && to_h == other.to_h
+        other.is_a?(Link) && value_attributes == other.value_attributes
       end
       alias == eql?
 
       def hash
-        to_h.hash
+        value_attributes.hash
       end
     end
   end

data/lib/chemicalml/dictionary/loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "yaml"
+require 'yaml'
 
 module Chemicalml
   module Dictionary
@@ -17,26 +17,26 @@ module Chemicalml
 
       def self.from_hash(hash)
         Model.new(
-          namespace: hash.fetch("namespace"),
-          prefix: hash.fetch("prefix"),
-          title: hash.fetch("title"),
-          description: hash["description"],
-          entries: (hash["entries"] || []).map { |e| build_entry(e) }
+          namespace: hash.fetch('namespace'),
+          prefix: hash.fetch('prefix'),
+          title: hash.fetch('title'),
+          description: hash['description'],
+          entries: (hash['entries'] || []).map { |e| build_entry(e) }
         )
       end
 
       def self.build_entry(h)
         Entry.new(
-          id: h.fetch("id"),
-          term: h.fetch("term"),
-          definition: h.fetch("definition"),
-          description: h["description"],
-          data_type: h["data_type"],
-          unit_type: h["unit_type"],
-          units: h["units"],
-          enum: build_enum(h["enum"]),
-          links: (h["links"] || []).map { |l| build_link(l) },
-          source_code: h["source_code"]
+          id: h.fetch('id'),
+          term: h.fetch('term'),
+          definition: h.fetch('definition'),
+          description: h['description'],
+          data_type: h['data_type'],
+          unit_type: h['unit_type'],
+          units: h['units'],
+          enum: build_enum(h['enum']),
+          links: (h['links'] || []).map { |l| build_link(l) },
+          source_code: h['source_code']
         )
       end
       private_class_method :build_entry
@@ -45,14 +45,14 @@ module Chemicalml
         return nil unless h
 
         Enum.new(
-          kind: h["kind"] || :open,
-          values: h["values"] || []
+          kind: h['kind'] || :open,
+          values: h['values'] || []
         )
       end
       private_class_method :build_enum
 
       def self.build_link(h)
-        Link.new(rel: h.fetch("rel"), href: h.fetch("href"), title: h["title"])
+        Link.new(rel: h.fetch('rel'), href: h.fetch('href'), title: h['title'])
       end
       private_class_method :build_link
     end

data/lib/chemicalml/dictionary/model.rb

@@ -35,29 +35,29 @@ module Chemicalml
         entries.map(&:id)
       end
 
-      def to_h
+      def value_attributes
         {
           namespace: namespace,
           prefix: prefix,
           title: title,
           description: description,
-          entries: entries.map(&:to_h)
+          entries: entries.map(&:value_attributes)
         }
       end
 
       def eql?(other)
-        other.is_a?(Model) && namespace == other.namespace && to_h == other.to_h
+        other.is_a?(Model) && namespace == other.namespace && value_attributes == other.value_attributes
       end
       alias == eql?
 
       def hash
-        [namespace, to_h].hash
+        [namespace, value_attributes].hash
       end
 
       private
 
       def split_qname(qname)
-        qname.to_s.split(":", 2)
+        qname.to_s.split(':', 2)
       end
     end
   end

data/lib/chemicalml/dictionary/registry.rb

@@ -13,7 +13,7 @@ module Chemicalml
       @mutex = Mutex.new
 
       def self.lookup(qname)
-        prefix, id = qname.to_s.split(":", 2)
+        prefix, id = qname.to_s.split(':', 2)
         return nil unless id
 
         dict = load_by_prefix(prefix)
@@ -39,7 +39,7 @@ module Chemicalml
 
       def self.load_by_prefix(prefix)
         manifest.each do |name, info|
-          return load_builtin(name) if info["prefix"] == prefix
+          return load_builtin(name) if info['prefix'] == prefix
         end
         nil
       end
@@ -49,27 +49,27 @@ module Chemicalml
       end
 
       def self.builtin_names
-        Dir.glob(File.join(BUILTIN_DIR, "*.yaml"))
-           .reject { |p| File.basename(p).start_with?("_") }
-           .map { |p| File.basename(p, ".yaml").to_sym }
+        Dir.glob(File.join(BUILTIN_DIR, '*.yaml'))
+           .reject { |p| File.basename(p).start_with?('_') }
+           .map { |p| File.basename(p, '.yaml').to_sym }
            .sort
       end
 
       def self.manifest
         @manifest ||= begin
-          path = File.join(BUILTIN_DIR, "_index.yaml")
+          path = File.join(BUILTIN_DIR, '_index.yaml')
           if File.exist?(path)
             YAML.load_file(path) || {}
           else
-            builtin_names.each_with_object({}) do |name, h|
-              h[name.to_s] = { "prefix" => name.to_s }
+            builtin_names.to_h do |name|
+              [name.to_s, { 'prefix' => name.to_s }]
             end
           end
         end
       end
       private_class_method :manifest
 
-      require "yaml"
+      require 'yaml'
     end
   end
 end

data/lib/chemicalml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chemicalml
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/chemicalml/versioned_parser.rb

@@ -9,6 +9,24 @@ module Chemicalml
   # (Document), `<module>` (compchem Module), `<dictionary>`,
   # `<unitList>`, `<unitTypeList>`, and the legacy standalone roots
   # `<molecule>`, `<reaction>`, `<reactionList>`.
+  #
+  # ---
+  #
+  # XML processing boundary (read me):
+  #
+  # The gem uses `lutaml-model` for ALL XML parsing and serialization
+  # — 242 wire classes extend `Lutaml::Model::Serializable`, and no
+  # `lib/` file defines `to_xml`/`from_xml`/`to_h`/`from_h` on a
+  # model class. Zero Nokogiri/REXML references in `lib/`.
+  #
+  # This file has TWO pre-processing helpers — `root_element_of` and
+  # `inject_namespace` — that operate on the XML *string* before
+  # `Lutaml::Model::Serializable.from_xml` is called. They are NOT
+  # serialization: they don't construct XML nodes, don't traverse
+  # trees, don't map attributes to model fields. They are input
+  # normalization so callers can pass namespace-less XML or rely on
+  # the parser to dispatch by root element name. The actual parse
+  # happens on the `const_get(class_name).from_xml(...)` call below.
   module VersionedParser
     # Maps root element name → constant name on the schema module.
     # Adding a new root type = adding one entry here. OCP — no

data/lib/chemicalml.rb

@@ -7,7 +7,7 @@ require "lutaml/model"
 #
 # Top-level entry points:
 #   Chemicalml::Cml::Document.from_xml(xml)  # parse CML
-#   document.to_xml                       # serialize back to XML
+#   document.to_xml                          # serialize back to XML
 #
 # Each CML element is a Lutaml::Model::Serializable subclass with
 # declared attributes and an XML mapping block. Serialization is
@@ -18,7 +18,6 @@ module Chemicalml
   autoload :Convention, "chemicalml/convention"
   autoload :Dictionary, "chemicalml/dictionary"
   autoload :Error, "chemicalml/errors"
-  autoload :Model, "chemicalml/model"
   autoload :ParseError, "chemicalml/errors"
   autoload :Schema, "chemicalml/schema"
   autoload :VERSION, "chemicalml/version"