asciichem 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1272affa5aa88924aaa06424dbc59bb115255963b675f596b58fd9588cd94fdc
-  data.tar.gz: bc6e6da1096c7a1c4e404d23036ec9513eae0f2866feeff9bd54a31c04540473
+  metadata.gz: 1edf476bb3d979641172de761d1b2ac906cb4eaf8565e56b0e083e146c09eb1d
+  data.tar.gz: b3394a0709a475df222d6369eac92a1cc6d02fc756a7d3a45ca038c5d6f5155c
 SHA512:
-  metadata.gz: f1fb3e8ae50d397af66fa526f4351b6876f2c28c76c13604d8bd4c488abbff0b10eace074df3d48b1ff6b12b86a81f6f88ddabf07a6bf1588c63540ef0ad0113
-  data.tar.gz: c0c694ec1edf82c9d7dfc57adaa8853cf37c1d94dca7a1288e0587f669776e5d68275345ebcc89717628b12711acd88feb3adcc885aeb945b53bf4d7f8f08d42
+  metadata.gz: 5a1ce9a990e507a6f70c91939841766e228b02ae674af39c5fa356b4911f20d0ef3b5aa2f2ec4799663d21da54752ed9b68c6660db23e1b2da9cacd4cc50b2ad
+  data.tar.gz: 6d68778aca7042fce958026033e990e51b87290c24ed3028cf224aa34bd5e03418ef6209b72072d06a14ab3352e2d20290c939b4002a82fdcdbe5c267a17d087

data/lib/asciichem/cml/extensions.rb

@@ -245,9 +245,40 @@ module AsciiChem
         TopLevelHandler.new(
           node_class: AsciiChem::Model::Text,
           element_name: 'text',
-          # Text formatter emits `"content"` (with quotes). Re-parsing
-          # that yields the original Text node — round-trip-safe by
-          # construction.
+          serialize: ->(node) { text_render(node) },
+          deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
+        ),
+        # -- beyond-formulas constructs (Phase 1-5) -------------------
+        # Each carries its text representation inside an aci: element.
+        # On parse, the text is re-parsed to rebuild the construct.
+        # DRY: all five share the same serialize/deserialize pattern.
+        TopLevelHandler.new(
+          node_class: AsciiChem::Model::Crystal,
+          element_name: 'crystal',
+          serialize: ->(node) { text_render(node) },
+          deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
+        ),
+        TopLevelHandler.new(
+          node_class: AsciiChem::Model::Spectrum,
+          element_name: 'spectrum',
+          serialize: ->(node) { text_render(node) },
+          deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
+        ),
+        TopLevelHandler.new(
+          node_class: AsciiChem::Model::Calculation,
+          element_name: 'calculation',
+          serialize: ->(node) { text_render(node) },
+          deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
+        ),
+        TopLevelHandler.new(
+          node_class: AsciiChem::Model::ZMatrix,
+          element_name: 'zmatrix',
+          serialize: ->(node) { text_render(node) },
+          deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
+        ),
+        TopLevelHandler.new(
+          node_class: AsciiChem::Model::Mechanism,
+          element_name: 'mechanism',
           serialize: ->(node) { text_render(node) },
           deserialize: ->(content) { AsciiChem.parse(content).nodes.first }
         )

data/lib/asciichem/formatter/text.rb

@@ -158,7 +158,47 @@ module AsciiChem
         parts.join
       end
 
-      private
+      def visit_calculation(calc)
+        parts = ["calc"]
+        params = []
+        params << calc.method if calc.method
+        params << calc.basis if calc.basis
+        parts << "(#{params.join('/')})" unless params.empty?
+        unless calc.properties.empty?
+          lines = calc.properties.map do |p|
+            line = "#{p[:title]}: #{p[:value]}"
+            line += " #{p[:units]}" if p[:units]
+            line
+          end
+          parts << "{\n  #{lines.join("\n  ")}\n}"
+        end
+        parts.join
+      end
+
+      def visit_z_matrix(zm)
+        parts = ["zmatrix"]
+        unless zm.rows.empty?
+          lines = zm.rows.map do |row|
+            tokens = [row.atom]
+            tokens << row.ref1 << row.distance if row.ref1
+            tokens << row.ref2 << row.angle if row.ref2
+            tokens << row.ref3 << row.dihedral if row.ref3
+            tokens.compact.join("  ")
+          end
+          parts << "{\n  #{lines.join("\n  ")}\n}"
+        end
+        parts.join
+      end
+
+      def visit_mechanism(mech)
+        parts = ["mechanism"]
+        unless mech.steps.empty? && mech.spectators.empty?
+          lines = mech.steps.map { |s| "#{s[:label]}: #{s[:reaction]}" }
+          mech.spectators.each { |sp| lines << "spectator: #{sp}" }
+          parts << "{\n  #{lines.join("\n  ")}\n}"
+        end
+        parts.join
+      end
 
       def render_node(node)
         node.accept(self)

data/lib/asciichem/grammar.rb

@@ -27,7 +27,7 @@ module AsciiChem
 
     rule(:nodes) { node >> (spaces? >> node).repeat }
 
-    rule(:node)  { reaction_cascade | reaction | electron_config | crystal | spectrum | annotated_molecule | molecule | embedded_math | text_run.as(:text_run) }
+    rule(:node)  { reaction_cascade | reaction | electron_config | crystal | spectrum | calculation | zmatrix | mechanism | annotated_molecule | molecule | embedded_math | text_run.as(:text_run) }
 
     # -- crystallography -------------------------------------------------
 
@@ -73,6 +73,45 @@ module AsciiChem
       str('{') >> (str('}').absent? >> any).repeat.as(:spectrum_body) >> str('}')
     end
 
+    # -- computational chemistry ----------------------------------------
+
+    # calc(method/basis){key: value units}
+    rule(:calculation) do
+      (str('calc') >>
+        calc_params.maybe >>
+        calc_body.maybe).as(:calc_node)
+    end
+
+    rule(:calc_params) do
+      str('(') >> (str(')').absent? >> any).repeat.as(:calc_params) >> str(')')
+    end
+
+    rule(:calc_body) do
+      str('{') >> (str('}').absent? >> any).repeat.as(:calc_body) >> str('}')
+    end
+
+    # -- Z-Matrix -------------------------------------------------------
+
+    rule(:zmatrix) do
+      (str('zmatrix') >>
+        zmatrix_body.maybe).as(:zmatrix_node)
+    end
+
+    rule(:zmatrix_body) do
+      str('{') >> (str('}').absent? >> any).repeat.as(:zmatrix_body) >> str('}')
+    end
+
+    # -- reaction mechanisms --------------------------------------------
+
+    rule(:mechanism) do
+      (str('mechanism') >>
+        mechanism_body.maybe).as(:mechanism_node)
+    end
+
+    rule(:mechanism_body) do
+      str('{') >> (str('}').absent? >> any).repeat.as(:mechanism_body) >> str('}')
+    end
+
     # Annotated molecule: a molecule followed by one or more
     # `@key("value")` annotations for CML metadata (names,
     # identifiers, title, formula, labels).

data/lib/asciichem/model/calculation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Model
+    # A computational chemistry calculation result.
+    #
+    # Syntax:
+    #   calc(b3lyp/6-31G*){
+    #     energy: -234.5 Hartree
+    #     dipole: [0.1, 0.2, 0.3] Debye
+    #   }
+    class Calculation < Node
+      attr_accessor :method, :basis, :properties
+
+      def initialize(method: nil, basis: nil, properties: [])
+        @method = method
+        @basis = basis
+        @properties = properties
+      end
+
+      def value_attributes
+        { method: method, basis: basis, properties: properties }
+      end
+
+      def children
+        []
+      end
+
+      def diagnostic_label
+        "Calculation(#{method}/#{basis})"
+      end
+    end
+  end
+end

data/lib/asciichem/model/mechanism.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Model
+    # A reaction mechanism: multi-step pathway with spectators.
+    #
+    # Syntax:
+    #   mechanism{
+    #     step1: A + B -> C
+    #     step2: C -> D + E
+    #     spectator: Na+
+    #   }
+    class Mechanism < Node
+      attr_accessor :steps, :spectators
+
+      def initialize(steps: [], spectators: [])
+        @steps = steps
+        @spectators = spectators
+      end
+
+      def value_attributes
+        { steps: steps, spectators: spectators }
+      end
+
+      def children
+        []
+      end
+
+      def diagnostic_label
+        "Mechanism(#{steps.length} steps)"
+      end
+    end
+  end
+end

data/lib/asciichem/model/zmatrix.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Model
+    # A Z-Matrix: internal coordinates (bond lengths, angles, torsions).
+    #
+    # Syntax:
+    #   zmatrix{
+    #     C1
+    #     H2  C1  1.09
+    #     H3  C1  1.09  H2  109.5
+    #     H4  C1  1.09  H2  109.5  H3  120.0
+    #   }
+    class ZMatrix < Node
+      ZRow = Struct.new(:atom, :ref1, :distance, :ref2, :angle, :ref3, :dihedral, keyword_init: true)
+
+      attr_accessor :rows
+
+      def initialize(rows: [])
+        @rows = rows
+      end
+
+      def value_attributes
+        { rows: rows }
+      end
+
+      def children
+        []
+      end
+
+      def diagnostic_label
+        "ZMatrix(#{rows.length} rows)"
+      end
+    end
+  end
+end

data/lib/asciichem/model.rb

@@ -8,12 +8,14 @@ module AsciiChem
   module Model
     autoload :Atom, "asciichem/model/atom"
     autoload :Bond, "asciichem/model/bond"
+    autoload :Calculation, "asciichem/model/calculation"
     autoload :Crystal, "asciichem/model/crystal"
     autoload :ElectronConfiguration, "asciichem/model/electron_configuration"
     autoload :EmbeddedMath, "asciichem/model/embedded_math"
     autoload :Formula, "asciichem/model/formula"
     autoload :Group, "asciichem/model/group"
     autoload :Identifier, "asciichem/model/identifier"
+    autoload :Mechanism, "asciichem/model/mechanism"
     autoload :Molecule, "asciichem/model/molecule"
     autoload :Name, "asciichem/model/name"
     autoload :Node, "asciichem/model/node"
@@ -21,5 +23,6 @@ module AsciiChem
     autoload :ReactionCascade, "asciichem/model/reaction_cascade"
     autoload :Spectrum, "asciichem/model/spectrum"
     autoload :Text, "asciichem/model/text"
+    autoload :ZMatrix, "asciichem/model/zmatrix"
   end
 end

data/lib/asciichem/transform.rb

@@ -171,6 +171,27 @@ module AsciiChem
       ).build
     end
 
+    # -- computational chemistry ----------------------------------------
+
+    rule(calc_node: subtree(:data)) do
+      hash = data.is_a?(Hash) ? data : {}
+      CalculationBuilder.new(hash[:calc_params], hash[:calc_body]).build
+    end
+
+    # -- Z-Matrix -------------------------------------------------------
+
+    rule(zmatrix_node: subtree(:data)) do
+      hash = data.is_a?(Hash) ? data : {}
+      ZMatrixBuilder.new(hash[:zmatrix_body]).build
+    end
+
+    # -- reaction mechanisms --------------------------------------------
+
+    rule(mechanism_node: subtree(:data)) do
+      hash = data.is_a?(Hash) ? data : {}
+      MechanismBuilder.new(hash[:mechanism_body]).build
+    end
+
     # -- internal helpers ------------------------------------------------
 
     # Builds a Crystal from parsed grammar captures. The grammar
@@ -292,6 +313,141 @@ module AsciiChem
       end
     end
 
+    # Builds a Calculation from grammar captures.
+    # Params: "method/basis" string. Body: key-value lines.
+    class CalculationBuilder
+      def initialize(params_str, body_str)
+        @params_str = strip_value(params_str)
+        @body_str = strip_value(body_str)
+      end
+
+      def build
+        method, basis = parse_method_basis(@params_str)
+        Model::Calculation.new(
+          method: method,
+          basis: basis,
+          properties: parse_properties(@body_str)
+        )
+      end
+
+      private
+
+      def strip_value(value)
+        return nil if value.nil?
+
+        s = value.to_s.strip
+        s.empty? ? nil : s
+      end
+
+      def parse_method_basis(str)
+        return [nil, nil] unless str
+
+        parts = str.split('/', 2)
+        [parts[0]&.strip, parts[1]&.strip]
+      end
+
+      def parse_properties(str)
+        return [] unless str
+
+        str.split("\n").filter_map do |line|
+          line = line.strip
+          next nil if line.empty?
+
+          key, rest = line.split(':', 2)
+          next nil unless key
+
+          tokens = rest&.strip&.split(/\s+/) || []
+          { title: key.strip, value: tokens[0], units: tokens[1] }
+        end
+      end
+    end
+
+    # Builds a ZMatrix from grammar captures.
+    # Each body line: atom [ref1 distance] [ref2 angle] [ref3 dihedral]
+    class ZMatrixBuilder
+      def initialize(body_str)
+        @body_str = strip_value(body_str)
+      end
+
+      def build
+        Model::ZMatrix.new(rows: parse_rows(@body_str))
+      end
+
+      private
+
+      def strip_value(value)
+        return nil if value.nil?
+
+        s = value.to_s.strip
+        s.empty? ? nil : s
+      end
+
+      def parse_rows(str)
+        return [] unless str
+
+        str.split("\n").filter_map { |line| parse_row(line.strip) }
+      end
+
+      def parse_row(line)
+        return nil if line.empty?
+
+        tokens = line.split(/\s+/)
+        Model::ZMatrix::ZRow.new(
+          atom: tokens[0],
+          ref1: tokens[1],
+          distance: tokens[2],
+          ref2: tokens[3],
+          angle: tokens[4],
+          ref3: tokens[5],
+          dihedral: tokens[6]
+        )
+      end
+    end
+
+    # Builds a Mechanism from grammar captures.
+    # Each body line: key: value (step1: reaction, spectator: ion)
+    class MechanismBuilder
+      def initialize(body_str)
+        @body_str = strip_value(body_str)
+      end
+
+      def build
+        steps = []
+        spectators = []
+        parse_entries(@body_str).each do |key, value|
+          if key == 'spectator'
+            spectators.concat(value.split(/\s+/).map(&:strip))
+          else
+            steps << { label: key, reaction: value }
+          end
+        end
+        Model::Mechanism.new(steps: steps, spectators: spectators)
+      end
+
+      private
+
+      def strip_value(value)
+        return nil if value.nil?
+
+        s = value.to_s.strip
+        s.empty? ? nil : s
+      end
+
+      def parse_entries(str)
+        return [] unless str
+
+        str.split("\n").filter_map do |line|
+          line = line.strip
+          next nil if line.empty?
+
+          key, val = line.split(':', 2)
+          next nil unless key && val
+
+          [key.strip, val.strip]
+        end
+      end
+    end
+
     # Strips the surrounding `"..."` quotes from a quoted text match.
     # Used by both `text_run` and `group_text_run` rules so the
     # model never carries the delimiters — the formatter re-adds them

data/lib/asciichem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AsciiChem
-  VERSION = "0.4.1"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -155,12 +155,14 @@ files:
 - lib/asciichem/model.rb
 - lib/asciichem/model/atom.rb
 - lib/asciichem/model/bond.rb
+- lib/asciichem/model/calculation.rb
 - lib/asciichem/model/crystal.rb
 - lib/asciichem/model/electron_configuration.rb
 - lib/asciichem/model/embedded_math.rb
 - lib/asciichem/model/formula.rb
 - lib/asciichem/model/group.rb
 - lib/asciichem/model/identifier.rb
+- lib/asciichem/model/mechanism.rb
 - lib/asciichem/model/molecule.rb
 - lib/asciichem/model/name.rb
 - lib/asciichem/model/node.rb
@@ -168,6 +170,7 @@ files:
 - lib/asciichem/model/reaction_cascade.rb
 - lib/asciichem/model/spectrum.rb
 - lib/asciichem/model/text.rb
+- lib/asciichem/model/zmatrix.rb
 - lib/asciichem/model_adapter.rb
 - lib/asciichem/model_adapter/from_canonical.rb
 - lib/asciichem/model_adapter/to_canonical.rb