chemicalml 0.1.0 → 0.2.0

data/lib/chemicalml/model/molecule.rb

@@ -3,34 +3,41 @@
 module Chemicalml
   module Model
     # A molecule: ordered atom list + optional bond list + optional
-    # names and identifiers + optional count (multiplicity in a
-    # larger context).
+    # names, identifiers, formulas, properties, labels + optional
+    # count (multiplicity in a larger context).
     class Molecule < Node
       attr_accessor :id, :atoms, :bonds, :names, :identifiers,
+                    :formulas, :properties, :labels,
                     :count, :formal_charge, :title
 
       def initialize(id: nil, atoms: [], bonds: [], names: [],
-                     identifiers: [], count: nil, formal_charge: nil,
+                     identifiers: [], formulas: [], properties: [],
+                     labels: [], count: nil, formal_charge: nil,
                      title: nil)
         @id = id
         @atoms = atoms
         @bonds = bonds
         @names = names
         @identifiers = identifiers
+        @formulas = formulas
+        @properties = properties
+        @labels = labels
         @count = count
         @formal_charge = formal_charge
         @title = title
       end
 
       def children
-        atoms + bonds + names + identifiers
+        atoms + bonds + names + identifiers +
+          formulas + properties + labels
       end
 
       def value_attributes
         {
           id: id, atoms: atoms, bonds: bonds, names: names,
-          identifiers: identifiers, count: count,
-          formal_charge: formal_charge, title: title
+          identifiers: identifiers, formulas: formulas,
+          properties: properties, labels: labels,
+          count: count, formal_charge: formal_charge, title: title
         }
       end
     end

data/lib/chemicalml/model.rb

@@ -10,7 +10,9 @@ module Chemicalml
   module Model
     autoload :Array, "chemicalml/model/cml_array"
     autoload :Atom, "chemicalml/model/atom"
+    autoload :AtomParity, "chemicalml/model/atom_parity"
     autoload :Bond, "chemicalml/model/bond"
+    autoload :BondStereo, "chemicalml/model/bond_stereo"
     autoload :Document, "chemicalml/model/document"
     autoload :Formula, "chemicalml/model/formula"
     autoload :Identifier, "chemicalml/model/identifier"

data/lib/chemicalml/version.rb

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

data/lib/chemicalml/versioned_parser.rb

@@ -2,17 +2,48 @@
 
 module Chemicalml
   # Shared parse entrypoint for versioned schema modules. Each schema
-  # module (`Cml::Schema3`, `Cml::Schema24`) extends this; it provides
-  # `.parse(xml)` that ensures the schema's wire classes are
-  # registered with `Lutaml::Model::GlobalContext`, then delegates to
-  # `Document.from_xml(xml, register: context_id)`.
+  # module (`Cml::Schema3`, `Cml::Schema24`) extends this.
   #
-  # Mirrors `Mml::VersionedParser`.
+  # Polymorphic: detects the XML root element and dispatches to the
+  # right wire class's `from_xml`. Supported roots include `<cml>`
+  # (Document), `<module>` (compchem Module), `<dictionary>`,
+  # `<unitList>`, `<unitTypeList>`, and the legacy standalone roots
+  # `<molecule>`, `<reaction>`, `<reactionList>`.
   module VersionedParser
+    # Maps root element name → constant name on the schema module.
+    # Adding a new root type = adding one entry here. OCP — no
+    # existing code changes.
+    KNOWN_ROOTS = {
+      "cml"          => :Document,
+      "molecule"     => :Molecule,
+      "reaction"     => :Reaction,
+      "reactionList" => :ReactionList,
+      "module"       => :Module,
+      "dictionary"   => :Dictionary,
+      "unitList"     => :UnitList,
+      "unitTypeList" => :UnitTypeList,
+    }.freeze
+
     def parse(xml, namespace_exist: true)
       configuration.ensure_registered!
-      document_class.from_xml(
-        xml_input(xml, namespace_exist),
+      root = root_element_of(xml)
+
+      # Resolve the wire class for this root element via O(1) hash
+      # lookup. KNOWN_ROOTS provides explicit overrides; the reverse
+      # index of Elements::ALL covers everything else.
+      class_name = KNOWN_ROOTS[root] || Chemicalml::Cml::Elements::XML_TO_CLASS[root]
+      unless class_name
+        raise ArgumentError,
+              "unsupported CML root element <#{root}>"
+      end
+      unless const_defined?(class_name, false)
+        raise ArgumentError,
+              "#{name} does not define #{class_name} " \
+              "(not all root elements exist in every schema version)"
+      end
+
+      const_get(class_name).from_xml(
+        xml_input(xml, namespace_exist, root),
         register: configuration.context_id
       )
     end
@@ -27,16 +58,26 @@ module Chemicalml
 
     private
 
-    def xml_input(xml, namespace_exist)
+    # Peek the XML string for the first element name. Skips the XML
+    # declaration (`<?xml ?>`) and any comments / processing
+    # instructions. Returns the local name (no namespace prefix).
+    def root_element_of(xml)
+      match = xml.match(/<([a-zA-Z][\w.-]*)(?::[a-zA-Z][\w.-]*)?/)
+      return match[1] if match
+
+      raise ArgumentError, "could not detect root element in XML"
+    end
+
+    def xml_input(xml, namespace_exist, root)
       return xml if namespace_exist
 
       namespace_uri = Chemicalml::Cml::Namespace.uri
-      inject_namespace(xml, namespace_uri)
+      inject_namespace(xml, namespace_uri, root)
     end
 
-    def inject_namespace(xml_string, namespace_uri)
-      xml_string.sub(/<cml([\s>])/) do
-        "<cml xmlns=\"#{namespace_uri}\"#{Regexp.last_match(1)}"
+    def inject_namespace(xml_string, namespace_uri, root)
+      xml_string.sub(/<#{root}([\s>])/) do
+        "<#{root} xmlns=\"#{namespace_uri}\"#{Regexp.last_match(1)}"
       end
     end
   end

data/lib/chemicalml.rb

@@ -14,7 +14,6 @@ require "lutaml/model"
 # framework-backed — no hand-rolled XML in this library.
 module Chemicalml
   autoload :Cml, "chemicalml/cml"
-  autoload :Configuration, "chemicalml/configuration"
   autoload :ContextConfiguration, "chemicalml/context_configuration"
   autoload :Convention, "chemicalml/convention"
   autoload :Dictionary, "chemicalml/dictionary"
@@ -28,6 +27,9 @@ module Chemicalml
   module_function
 
   def parse(xml, schema: :schema3, namespace_exist: true)
+    raise ArgumentError, "xml must not be nil" if xml.nil?
+    raise ArgumentError, "xml must not be empty" if xml.to_s.strip.empty?
+
     parser_for(schema).parse(xml, namespace_exist: namespace_exist)
   end