asciichem 0.20.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a77da515ac52e848a4ff0f5855a595cb81d71a36c18b4991d875d682d2c3598
-  data.tar.gz: 70c14be9ddec1e767ddddef09a1ad91a02f996f1fdd22645d0269c4de7e96020
+  metadata.gz: d1aef5e42c0840b8bff4d291220e84f76f9536a9dba1cca3445deacb696388b1
+  data.tar.gz: 92e28e623dfb7494080a9ee80d3545fa5a593d83d545775d890b7a9a5594c0bd
 SHA512:
-  metadata.gz: b71e29edd758d5d4393d750a95676dc8007c5850f830b414ca83a2d21e99c1ff39fa88f5f66b54198e442e7d29b9010639c4a55138567cd9dee8160d5b2be3dc
-  data.tar.gz: f08f835457ce6d58b70ff0b3bc502f84f4404684a13ae60ad52bbae44a790dfd66621c15bba73ed2843e0d76ba4ef47545a37e838867b54d12eb9246f11277b6
+  metadata.gz: bab5532c9007d1a5bd2079b792a66458d411f48af5ac59f04ad9e4a9150c7b53844639e67a46494dac7e6ae05f3451904a8fbe927b711803184749f00ce40e7e
+  data.tar.gz: c0a9cb7f9f01e25dcce78f69894c23c8d5fe75d2d21fd20828d2daafa133186ebeb46d2aeb09bfc4246f43f851a3b982c4691cd013c40c56085634ca54f9db01

data/CHANGELOG.md

@@ -3,6 +3,42 @@
 All notable changes to AsciiChem are documented here.
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [0.22.0] - 2026-09-12
+
+### Added
+- CLI `--from asciichem|smiles|molfile` on `convert`, plus
+  `model-json`, `smiles`, `molfile`, and `structural-svg` output
+  targets (TODO.impl 60).
+
+### Changed
+- Conformance validation uses schemas vendored in `spec/schemas`
+  (json_schemer dev dependency); the asciichem-model rubygem
+  dependency is removed — the contract repository is no longer
+  distributed as a gem (TODO.impl 59).
+
+## [0.21.0] - 2026-09-12
+
+### Added
+- Structure interchange (TODO.v2 09, TODO.impl 57): SMILES and
+  molfile (CTfile V2000) ingestion and emission as modules of the one
+  semantic model — `AsciiChem.parse_smiles` / `parse_molfile`,
+  `to_smiles` / `to_molfile`. Ingested molecules are ordinary
+  `Model::Molecule`s: graphs linearise into atoms + bond tokens +
+  ring-closure digits (`Structure::Linearizer`), so every existing
+  renderer, linter, and wire form works unchanged. The SMILES writer
+  is deterministic (DFS, single-bond continuations, order-independent
+  tie-breaks); aspirin and naphthalene round-trip exactly. v1
+  deferrals, each with an actionable `ParseError`: chirality `@`/`@@`,
+  E/Z directions `/` `\`, wildcard atoms, bonded ring closures.
+- `Model::Atom#aromatic` / `#hydrogens` and an `aromatic` bond kind
+  (asciichem-model 0.4.0 fields): lowercase SMILES atoms, bracket
+  H-counts, molfile type-4 bonds (aromatic atoms marked from bonds).
+- `AsciiChem::Structure` — shared graph walk + adjacency linearizer
+  for the interchange formats; `StructuralSvg` renders aromatic bonds
+  dashed; wire form carries the new fields both ways.
+- Corpus levels: asciichem-tests v0.3.0 `structure/smiles/*` and
+  `structure/molfile/*` fixtures at 100% (37 + 6 cases).
+
 ## [0.20.0] - 2026-09-12
 
 ### Added
@@ -363,7 +399,9 @@ This project follows [Semantic Versioning](https://semver.org/).
   `version`.
 - Comprehensive RSpec suite with round-trip conformance.
 
-[Unreleased]: https://github.com/asciichem/asciichem-ruby/compare/v0.20.0...HEAD
+[Unreleased]: https://github.com/asciichem/asciichem-ruby/compare/v0.22.0...HEAD
+[0.22.0]: https://github.com/asciichem/asciichem-ruby/compare/v0.21.0...v0.22.0
+[0.21.0]: https://github.com/asciichem/asciichem-ruby/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/asciichem/asciichem-ruby/compare/v0.19.0...v0.20.0
 [0.18.1]: https://github.com/asciichem/asciichem-ruby/compare/v0.18.0...v0.18.1
 [0.18.0]: https://github.com/asciichem/asciichem-ruby/compare/v0.17.0...v0.18.0

data/Gemfile

@@ -5,6 +5,7 @@ source "https://rubygems.org"
 gemspec
 
 group :development do
+  gem "json_schemer", "~> 2.4"
   gem "benchmark", "~> 0.4"
   gem "benchmark-ips", "~> 2.14", require: false
   gem "rake", "~> 13.2"

data/asciichem.gemspec

@@ -41,5 +41,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "plurimath", "~> 0.8"
   spec.add_dependency "thor", "~> 1.3"
 
-  spec.add_development_dependency "asciichem-model", "~> 0.3.4"
+  spec.add_development_dependency "json_schemer", "~> 2.4"
 end

data/lib/asciichem/cli.rb

@@ -10,16 +10,22 @@ module AsciiChem
     # and command banners, matching the executable name.
     package_name "asciichem"
 
-    desc "convert -i INPUT -t FORMAT", "Convert AsciiChem INPUT to FORMAT (mathml|text|html|latex|svg|cml)"
-    method_option :input, aliases: "-i", type: :string, required: true,
-                           desc: "AsciiChem source text (or '-' for stdin)"
+    desc "convert -i INPUT -t FORMAT", "Convert INPUT to FORMAT (mathml|text|html|latex|svg|structural-svg|model-json|cml|smiles|molfile)"
+    method_option :input, aliases: "-i", type: :string,
+                           desc: "Source text (or '-' for stdin)"
     method_option :file, aliases: "-f", type: :string,
-                          desc: "Read AsciiChem source from a file"
+                          desc: "Read source from a file"
+    method_option :from, type: :string, default: "asciichem",
+                        desc: "Input grammar: asciichem|smiles|molfile"
     method_option :format, aliases: "-t", type: :string, default: "mathml",
                             desc: "Output format"
     def convert
+      unless options["input"] || options["file"]
+        raise AsciiChem::ParseError, "provide -i INPUT or -f FILE"
+      end
+
       source = read_source
-      formula = AsciiChem.parse(source)
+      formula = ingest(source, options[:from])
       puts render(formula, options[:format])
     rescue AsciiChem::ParseError => e
       warn "Parse error: #{e.message}"
@@ -89,8 +95,31 @@ module AsciiChem
       options[:input]
     end
 
+    # One ingestion point per input grammar (TODO.v2 09): every
+    # grammar funnels into the same semantic model, so every output
+    # format works regardless of the input language.
+    def ingest(source, from)
+      case from.to_s
+      when "asciichem" then AsciiChem.parse(source)
+      when "smiles" then AsciiChem.parse_smiles(source)
+      when "molfile" then molfile_formula(source)
+      else
+        raise AsciiChem::ParseError, "unknown --from grammar: #{from}"
+      end
+    end
+
+    # parse_molfile returns a single Molecule; wrap it so every
+    # formatter's Formula contract holds.
+    def molfile_formula(source)
+      text = File.file?(source) ? File.read(source) : source
+      AsciiChem::Model::Formula.new(nodes: [AsciiChem.parse_molfile(text)])
+    end
+
     def render(formula, format)
       return formula.to_cml if format.to_sym == :cml
+      return formula.to_model_json if format.to_sym == :"model-json"
+      return formula.to_smiles if format.to_sym == :smiles
+      return formula.nodes.first.to_molfile if format.to_sym == :molfile
 
       AsciiChem::Formatter.render(format.to_sym, formula)
     end

data/lib/asciichem/formatter/structural_svg.rb

@@ -258,6 +258,14 @@ module AsciiChem
         RENDERERS = {
           single: ->(r) { [r.base_line] },
 
+          # Aromatic bonds render as dashed lines (the inner-ring
+          # circle is a renderer nicety left for a later iteration).
+          aromatic: lambda do |r|
+            line = r.base_line
+            line['stroke-dasharray'] = '4 2.5'
+            [line]
+          end,
+
           double: ->(r) { [-SPACING, 0, SPACING].map { |d| r.offset_line(d) }.compact },
 
           triple: ->(r) { [0, -SPACING * 1.5, SPACING * 1.5].map { |d| r.offset_line(d) }.compact },

data/lib/asciichem/model/atom.rb

@@ -34,7 +34,7 @@ module AsciiChem
       attr_accessor :element, :isotope, :subscript, :superscript,
                     :charge, :oxidation_state,
                     :lone_pairs, :radical_electrons,
-                    :ring_closures,
+                    :ring_closures, :aromatic, :hydrogens,
                     :x2, :y2, :z2, :atom_parity,
                     :spin_multiplicity, :atom_title,
                     :x_fract, :y_fract, :z_fract
@@ -58,7 +58,7 @@ module AsciiChem
       def initialize(element:, isotope: nil, subscript: nil,
                      superscript: nil, charge: nil, oxidation_state: nil,
                      lone_pairs: nil, radical_electrons: nil,
-                     ring_closures: nil,
+                     ring_closures: nil, aromatic: nil, hydrogens: nil,
                      x2: nil, y2: nil, z2: nil, atom_parity: nil,
                      spin_multiplicity: nil, atom_title: nil,
                      x_fract: nil, y_fract: nil, z_fract: nil)
@@ -71,6 +71,8 @@ module AsciiChem
         @lone_pairs = lone_pairs
         @radical_electrons = radical_electrons
         @ring_closures = ring_closures
+        @aromatic = aromatic
+        @hydrogens = hydrogens
         @x2 = x2
         @y2 = y2
         @z2 = z2
@@ -87,7 +89,8 @@ module AsciiChem
           superscript: superscript, charge: charge,
           oxidation_state: oxidation_state,
           lone_pairs: lone_pairs, radical_electrons: radical_electrons,
-          ring_closures: ring_closures,
+          ring_closures: ring_closures, aromatic: aromatic,
+          hydrogens: hydrogens,
           x2: x2, y2: y2, z2: z2, atom_parity: atom_parity,
           spin_multiplicity: spin_multiplicity, atom_title: atom_title,
           x_fract: x_fract, y_fract: y_fract, z_fract: z_fract }
@@ -108,6 +111,8 @@ module AsciiChem
         parts << "^(#{oxidation_state})" if oxidation_state
         parts << ".#{radical_electrons}" if radical_electrons
         parts << ring_closures.to_s if ring_closures
+        parts << "aromatic" if aromatic
+        parts << "H#{hydrogens}" if hydrogens
         "Atom(#{parts.join})"
       end
     end

data/lib/asciichem/model/bond.rb

@@ -14,7 +14,8 @@ module AsciiChem
         wedge:     { ascii: ">-", mathml_entity: "↑" },
         hash:      { ascii: "-<", mathml_entity: "↓" },
         dative:    { ascii: "~>", mathml_entity: "→" },
-        wavy:      { ascii: "~~", mathml_entity: "∼" }
+        wavy:      { ascii: "~~", mathml_entity: "∼" },
+        aromatic:  { ascii: ":",  mathml_entity: ":" }
       }.freeze
 
       # CML wire order codes per bond kind. Single source of truth

data/lib/asciichem/model/node.rb

@@ -70,6 +70,18 @@ module AsciiChem
         AsciiChem::WireAdapter.to_model_json(self)
       end
 
+      # Deterministic SMILES for a Molecule (or dot-joined components
+      # for a Formula). Raises for constructs with no SMILES form.
+      def to_smiles
+        AsciiChem::Smiles.write(self)
+      end
+
+      # Molfile V2000 for a Molecule. Authored coordinates win; a
+      # deterministic 2D layout is computed otherwise.
+      def to_molfile(name: nil)
+        AsciiChem::Molfile.write(self, name: name)
+      end
+
       # Subclasses override to expose the attributes that participate in
       # equality. Default: empty (so two bare Nodes are equal).
       def value_attributes

data/lib/asciichem/molfile/parser.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Molfile
+    # V2000 molfile → Model::Molecule. Fixed-format blocks: header
+    # (3 lines), counts line, atom block, bond block, property block.
+    # Charges come from `M  CHG`, isotopes from the mass-difference
+    # field or `M  ISO`, bond stereo codes 1/6 become wedge/hash.
+    class Parser
+      def initialize(text)
+        @lines = text.lines.map(&:chomp)
+      end
+
+      def parse
+        raise ParseError, "molfile too short" if @lines.length < 5
+
+        atom_field = field(3, 0, 3)
+        bond_field = field(3, 3, 3)
+        unless atom_field.match?(/\A\d+\z/) && bond_field.match?(/\A\d+\z/)
+          raise ParseError, "malformed counts line: #{@lines[3].inspect}"
+        end
+        atom_count = atom_field.to_i
+        bond_count = bond_field.to_i
+
+        atoms = parse_atoms(atom_count)
+        bonds = parse_bonds(bond_count)
+        properties = parse_properties
+
+        apply_legacy_charge!(atoms)
+        apply_charges!(atoms, properties[:charges])
+        apply_isotopes!(atoms, properties[:isotopes])
+
+        adjacency = Array.new(atoms.length) { {} }
+        bonds.each do |bond|
+          adjacency[bond[:from]][bond[:to]] = bond[:kind]
+          adjacency[bond[:to]][bond[:from]] = bond[:kind]
+        end
+
+        # V2000 carries aromaticity on bonds (type 4); the model
+        # carries it on atoms and bonds, so atoms touching an
+        # aromatic bond are marked aromatic.
+        bonds.each do |bond|
+          next unless bond[:kind] == :aromatic
+
+          atoms[bond[:from]].aromatic = true
+          atoms[bond[:to]].aromatic = true
+        end
+
+        Model::Molecule.new(
+          nodes: Structure::Linearizer.new(atoms: atoms, edges: adjacency_to_edges(adjacency)).nodes
+        )
+      end
+
+      private
+
+      def field(line_index, start, length)
+        (@lines[line_index] || "")[start, length].to_s.strip
+      end
+
+      def parse_atoms(count)
+        (1..count).map do |i|
+          line_index = 3 + i
+          line = @lines[line_index]
+          raise ParseError, "truncated atom block (expected #{count} atoms)" if line.nil?
+
+          x = line[0, 10].to_f
+          y = line[10, 10].to_f
+          z = line[20, 10].to_f
+          element = line[31, 3].to_s.strip
+          mass_diff = line[34, 2].to_i
+          raise ParseError, "atom #{i} has no element symbol" if element.empty?
+
+          Model::Atom.new(
+            element: element,
+            x2: x, y2: y, z2: z,
+            isotope: isotope_from_mass_diff(element, mass_diff)
+          )
+        end
+      end
+
+      def parse_bonds(count)
+        (1..count).map do |i|
+          line = @lines[3 + atoms_count + i]
+          raise ParseError, "truncated bond block (expected #{count} bonds)" if line.nil?
+
+          from = line[0, 3].to_i - 1
+          to = line[3, 3].to_i - 1
+          type = line[6, 3].to_i
+          stereo = line[9, 3].to_i
+          raise ParseError, "bond #{i} has out-of-range atom indexes" if from.negative? || to.negative?
+
+          { from: from, to: to, kind: bond_kind(type, stereo) }
+        end
+      end
+
+      def parse_properties
+        charges = {}
+        isotopes = {}
+        @lines.each do |line|
+          if line.start_with?("M  CHG")
+            parts = line[6..].split
+            _count = parts[0].to_i
+            parts[1..].each_slice(2) do |idx, charge|
+              charges[idx.to_i - 1] = charge.to_i if idx && charge
+            end
+          elsif line.start_with?("M  ISO")
+            parts = line[6..].split
+            parts[1..].each_slice(2) do |idx, mass|
+              isotopes[idx.to_i - 1] = mass.to_i if idx && mass
+            end
+          end
+        end
+        { charges: charges, isotopes: isotopes }
+      end
+
+      def bond_kind(type, stereo)
+        return :wedge if stereo == 1
+        return :hash if stereo == 6
+
+        { 1 => :single, 2 => :double, 3 => :triple, 4 => :aromatic }[type] ||
+          raise(ParseError, "unsupported molfile bond type #{type}")
+      end
+
+      # Pre-CHG charge column (0-based 36, 3): nonzero values 1..4
+      # mean +1..+4, 5..7 mean -1..-3. `M  CHG` overrides.
+      def apply_legacy_charge!(atoms)
+        (1..field(3, 0, 3).to_i).each do |i|
+          code = field(3 + i, 36, 3).to_i
+          next if code.zero?
+
+          charge = code <= 4 ? code : 4 - code
+          sign = charge.negative? ? "-" : "+"
+          atoms[i - 1].charge = charge.abs == 1 ? sign : "#{charge.abs}#{sign}"
+        end
+      end
+
+      def apply_charges!(atoms, charges)
+        charges.each do |index, value|
+          sign = value.negative? ? "-" : "+"
+          atoms[index].charge = value.abs == 1 ? sign : "#{value.abs}#{sign}"
+        end
+      end
+
+      def apply_isotopes!(atoms, isotopes)
+        isotopes.each do |index, mass|
+          atoms[index].isotope = mass.to_s
+        end
+      end
+
+      # Mass difference encodes isotopes relative to the rounded
+      # average mass; mapping it unambiguously requires isotope
+      # tables, so v1 defers isotopes to the explicit `M  ISO` block.
+      def isotope_from_mass_diff(_element, mass_diff)
+        nil
+      end
+      def atoms_count
+        field(3, 0, 3).to_i
+      end
+
+      def adjacency_to_edges(adjacency)
+        edges = []
+        adjacency.each_with_index do |neighbors, index|
+          neighbors.each { |to, kind| edges << Structure::Graph::Edge.new(from: index, to: to, kind: kind) if to > index }
+        end
+        edges
+      end
+    end
+  end
+end

data/lib/asciichem/molfile/writer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  module Molfile
+    # Model molecule → V2000 molfile. Authored x2/y2 coordinates are
+    # used when present; otherwise a deterministic 2D layout is
+    # computed (Layout walks atoms in the same order as
+    # Structure::Graph, so positions map by index). Charges and
+    # isotopes are emitted as `M  CHG` / `M  ISO` property lines.
+    class Writer
+      BOND_TYPES = {
+        single: 1, double: 2, triple: 3, aromatic: 4,
+        wedge: 1, hash: 1
+      }.freeze
+      BOND_STEREO = { wedge: 1, hash: 6 }.freeze
+
+      def initialize(molecule, name: nil)
+        @molecule = molecule
+        @name = name
+      end
+
+      def write
+        atoms, edges = Structure::Graph.build(@molecule)
+        raise ParseError, "molecule has no bonds — a formula is not a structure" if edges.empty?
+
+        lines = []
+        lines << @name.to_s
+        lines << "  AsciiChem"
+        lines << ""
+        lines << format("%3d%3d  0  0  0  0  0  0  0  0999 V2000", atoms.length, edges.length)
+
+        layout = nil
+        atoms.each_with_index do |atom, index|
+          x, y = coordinates(atom, index, atoms)
+          lines << format("%10.4f%10.4f%10.4f %-3s 0  0  0  0  0  0  0  0  0  0  0  0",
+                          x, y, atom.z2 || 0.0, atom.element)
+        end
+
+        edges.each do |edge|
+          type = BOND_TYPES.fetch(edge.kind) do
+            raise ParseError, "#{edge.kind} bonds have no molfile V2000 type"
+          end
+          stereo = BOND_STEREO.fetch(edge.kind, 0)
+          lines << format("%3d%3d%3d%3d  0  0  0  0  0  0  0",
+                          edge.from + 1, edge.to + 1, type, stereo)
+        end
+
+        lines << property_line("M  CHG", charge_pairs(atoms))
+        lines << property_line("M  ISO", isotope_pairs(atoms))
+        lines << "M  END"
+        lines.compact.join("\n") << "\n"
+      end
+
+      private
+
+      # Authored coordinates win; otherwise positions from the
+      # deterministic 2D layout (same walk order as the graph).
+      def coordinates(atom, index, atoms)
+        return [atom.x2, atom.y2] if atom.x2 && atom.y2
+
+        @layout ||= AsciiChem::Layout.layout(@molecule)
+        placed = @layout.atoms[index]
+        placed ? [placed.x, placed.y] : [0.0, 0.0]
+      end
+
+      def charge_pairs(atoms)
+        atoms.each_with_index
+             .filter_map { |atom, i| [i + 1, charge_value(atom.charge)] if atom.charge }
+      end
+
+      def isotope_pairs(atoms)
+        atoms.each_with_index
+             .filter_map { |atom, i| [i + 1, atom.isotope.to_i] if atom.isotope }
+      end
+
+      # The model's number-then-sign charge ("2+") → signed integer.
+      def charge_value(charge)
+        count = charge[/\A\d+/]&.to_i || 1
+        charge.end_with?("-") ? -count : count
+      end
+
+      def property_line(prefix, pairs)
+        return nil if pairs.empty?
+
+        pairs.reduce(+"#{prefix}%3d" % pairs.length) do |line, (idx, value)|
+          line << format("%4d%4d", idx, value)
+        end
+      end
+    end
+  end
+end

data/lib/asciichem/molfile.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AsciiChem
+  # Molfile (CTfile V2000) ingestion and emission (TODO.v2 09;
+  # TODO.impl 57). Molfile is the highest-fidelity structure path:
+  # atom coordinates are preserved on the model (x2/y2/z2), charges
+  # via the CHG property block, isotopes via mass difference or the
+  # ISO block, bond stereo codes 1/6 map to wedge/hash bonds.
+  module Molfile
+    autoload :Parser, "asciichem/molfile/parser"
+    autoload :Writer, "asciichem/molfile/writer"
+
+    class << self
+      # Parses a V2000 molfile into a Model::Molecule.
+      def parse(text)
+        Parser.new(text).parse
+      end
+
+      # Emits a V2000 molfile. Uses authored x2/y2 coordinates;
+      # computes a 2D layout otherwise.
+      def write(molecule, name: nil)
+        Writer.new(molecule, name: name).write
+      end
+    end
+  end
+end