asciichem 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d401ee7215f54961b4126b1da5451a2e71ac316c05e3864d199c5482e28d366
-  data.tar.gz: c132a8c376dd7485bf0319f8d971d89cb952c27d9f2466c0f3af4af945b0ca4b
+  metadata.gz: 9d87f933cf6baef0a8a1f5c8e189948ba3a2f49ea9adea77b5af22854e2ccb1c
+  data.tar.gz: afb6ab79bf85415caa65fe9315a7cbc76913562cb969aa5e5947a6c7eaede38b
 SHA512:
-  metadata.gz: ab9ee8f2410f46c659cc97426a7272c511e983b601cbf043809c5b657621f0d7a48e79f17c2c4f79707cfebaf265e963077a5f636d8e03c87be2942e4fddc27e
-  data.tar.gz: 1cf4d97ef6459a29b9d7f05ddbd8b8b1db0ca512f547cb48badd7ebb5abc42f9c70c98cdade086af9dedf48f2e16c96ddd199097ee90c3e2ba56984e66a91aa7
+  metadata.gz: 912c55ba11516ed11b613ac538ee6c90d792f95b86b3337d1348e04bf50531c5f08bead8e1781155dea56b8a8cfdd66506e885ccbac713b5384acb9e982f52c2
+  data.tar.gz: c044eecacf93ae9c80a8f6ddebc66f8be38820b8157a6410d20f9bfc60428ea7377e39e8271343b4645bffa371dd67b179d3f74183c754778f0fd333984afc0a

data/lib/asciichem/formatter/text.rb

@@ -140,7 +140,65 @@ module AsciiChem
         parts.join
       end
 
-      private
+      def visit_spectrum(spectrum)
+        parts = ["spectrum"]
+        parts << "[#{spectrum.type}]" if spectrum.type
+        params = spectrum.params.map { |k, v| "#{k}=#{v}" }.join(',')
+        parts << "(#{params})" unless params.empty?
+        peak_lines = spectrum.peaks.map do |peak|
+          line = "#{peak[:position]}: #{peak[:intensity]}"
+          line += " #{peak[:multiplicity]}" if peak[:multiplicity]
+          line += %( "#{peak[:assignment]}") if peak[:assignment]
+          line
+        end
+        unless peak_lines.empty?
+          body = peak_lines.join("\n  ")
+          parts << "{\n  #{body}\n}"
+        end
+        parts.join
+      end
+
+      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,16 +27,16 @@ module AsciiChem
 
     rule(:nodes) { node >> (spaces? >> node).repeat }
 
-    rule(:node)  { reaction_cascade | reaction | electron_config | crystal | 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 -------------------------------------------------
 
     # crystal[Name](a=X,b=Y,...,sg=SG){atoms with @f(x,y,z)}
     rule(:crystal) do
-      str('crystal') >>
+      (str('crystal') >>
         crystal_name.maybe >>
         crystal_params.maybe >>
-        crystal_body.maybe
+        crystal_body.maybe).as(:crystal_node)
     end
 
     rule(:crystal_name) do
@@ -51,6 +51,67 @@ module AsciiChem
       str('{') >> (str('}').absent? >> any).repeat.as(:crystal_body) >> str('}')
     end
 
+    # -- spectroscopy ---------------------------------------------------
+
+    # spectrum[type](params){peak data}
+    rule(:spectrum) do
+        (str('spectrum') >>
+        spectrum_type.maybe >>
+        spectrum_params.maybe >>
+        spectrum_body.maybe).as(:spectrum_node)
+    end
+
+    rule(:spectrum_type) do
+      str('[') >> (str(']').absent? >> any).repeat.as(:spectrum_type) >> str(']')
+    end
+
+    rule(:spectrum_params) do
+      str('(') >> (str(')').absent? >> any).repeat.as(:spectrum_params) >> str(')')
+    end
+
+    rule(:spectrum_body) do
+      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/spectrum.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Model
+    # A spectroscopy result: NMR, IR, MS, UV-Vis peaks.
+    #
+    # Syntax:
+    #   spectrum[nmr](type=1H,solvent=CDCl3){
+    #     1.2: 3H s "CH3"
+    #     7.2: 5H m "C6H5"
+    #   }
+    #
+    #   spectrum[ir]{
+    #     3300: broad "O-H stretch"
+    #   }
+    #
+    #   spectrum[ms]{
+    #     18: 100% "M+"
+    #   }
+    class Spectrum < Node
+      attr_accessor :type, :params, :peaks
+
+      def initialize(type: nil, params: {}, peaks: [])
+        @type = type
+        @params = params
+        @peaks = peaks
+      end
+
+      def value_attributes
+        { type: type, params: params, peaks: peaks }
+      end
+
+      def children
+        []
+      end
+
+      def diagnostic_label
+        "Spectrum(#{type || 'unknown'})"
+      end
+
+      def to_s
+        "spectrum[#{type}](#{params.map { |k, v| "#{k}=#{v}" }.join(',')})"
+      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,17 +8,21 @@ 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"
     autoload :Reaction, "asciichem/model/reaction"
     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

@@ -151,10 +151,45 @@ module AsciiChem
     # Grammar captures crystal_name, crystal_params, and crystal_body
     # as optional strings. CrystalBuilder parses them into the model.
 
-    rule(crystal_name: subtree(:name),
-         crystal_params: subtree(:params),
-         crystal_body: subtree(:body)) do
-      CrystalBuilder.new(name, params, body).build
+    rule(crystal_node: subtree(:data)) do
+      hash = data.is_a?(Hash) ? data : {}
+      CrystalBuilder.new(
+        hash[:crystal_name],
+        hash[:crystal_params],
+        hash[:crystal_body]
+      ).build
+    end
+
+    # -- spectra --------------------------------------------------------
+
+    rule(spectrum_node: subtree(:data)) do
+      hash = data.is_a?(Hash) ? data : {}
+      SpectrumBuilder.new(
+        hash[:spectrum_type],
+        hash[:spectrum_params],
+        hash[:spectrum_body]
+      ).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 ------------------------------------------------
@@ -215,6 +250,204 @@ module AsciiChem
       end
     end
 
+    # Builds a Spectrum from parsed grammar captures. Parses peak
+    # lines from the body string.
+    class SpectrumBuilder
+      def initialize(type_str, params_str, body_str)
+        @type = strip_value(type_str)
+        @params_str = strip_value(params_str)
+        @body_str = strip_value(body_str)
+      end
+
+      def build
+        Model::Spectrum.new(
+          type: @type,
+          params: parse_params(@params_str),
+          peaks: parse_peaks(@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_params(str)
+        return {} unless str
+
+        str.split(',').each_with_object({}) do |pair, memo|
+          key, val = pair.strip.split('=', 2)
+          memo[key] = val&.strip if key
+        end
+      end
+
+      def parse_peaks(str)
+        return [] unless str
+
+        str.split("\n").filter_map { |line| parse_peak(line.strip) }
+      end
+
+      def parse_peak(line)
+        return nil if line.empty?
+
+        assignment = nil
+        match = line.match(/"([^"]*)"/)
+        if match
+          assignment = match[1]
+          line = line.sub(/"[^"]*"/, '').strip
+        end
+
+        pos, rest = line.split(':', 2)
+        tokens = rest&.strip&.split(/\s+/) || []
+
+        {
+          position: pos&.strip,
+          intensity: tokens[0],
+          multiplicity: tokens[1],
+          assignment: assignment
+        }
+      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.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -155,18 +155,22 @@ 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
 - lib/asciichem/model/reaction.rb
 - 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