asciichem 0.31.6 → 0.31.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac2c54a74f212244c74efeb88156c34398cdfe87751de14a597833533f4ccb92
-  data.tar.gz: 8f5614c2703ae6ee1440be65fa2c7654bc3cc12d2c8b1207f43a974ab804e3f2
+  metadata.gz: 040c17f14243ee3dfa4ecb2c5db7f961aa91a10768118977cd01d48a209650a7
+  data.tar.gz: 9320019d60542569b130dd57e332b5e9afe4ff6641254d680e73f2b965977ecf
 SHA512:
-  metadata.gz: 487d422ca183453e7e9a82de50aaa1c6e671383047838ca0acab124678520bf08edbe20a115f3c416407683e45b07cc5654b46bdcb71559004ef22271989d90b
-  data.tar.gz: ae81c712c9d31ffd440b8ad49200aea40c52251f8a6017344d0ce6bbd70b3b236ac89c850e2aac57c6866f87cec986a0c26694989b5f4b40eed7ffc147c1bbdb
+  metadata.gz: 7a923467ce4e6e857f4175c5c335de6bb1116c5426c78828b328fccc6621a6c9313809ee93d82f2de1a35fc14114f1d77a1220f453e4c59af2fa3eac6e5c4aa2
+  data.tar.gz: 63b55738186c1f4b2e98bd38b71b2af97b01946ee9715d44f934c364df26b1f1b79e29d9e072c34cd264e384f475fa0b4e8ce64719a2d7844a3e9db5f8da489f

data/CHANGELOG.md

@@ -3,6 +3,42 @@
 All notable changes to AsciiChem are documented here.
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [0.31.8] - 2026-10-22
+
+### Fixed
+- The SMILES writer joins the strict structure decline (a line
+  missed in 0.31.7's staging): `to_smiles` no longer silently
+  fragments undashed text — `C1=CC=CC=C1` declines with guidance
+  like the molfile writer.
+
+## [0.31.7] - 2026-10-22
+
+### Fixed
+- **InChI engine matches the distributed binary's real contract**
+  (found by the TODO.v2/16 oracle work): `-STDIO` is not part of the
+  standard `inchi-1` interface — the engine now stages the molfile to
+  a temp file and reads the output file, the same shape as the RInChI
+  engine. Verified against the brew 1.07.5 build.
+- **Tetrahedral stereo actually reaches the oracle now**: the writer
+  emits a wedge on the stereocentre's first bond (TH1 up, TH2 down);
+  the V2000 atom-parity field alone is ignored by `inchi-1` for 2D
+  input, so the previous parity-only claim never produced stereo
+  InChIs. Enantiomers now derive distinct standard InChIs
+  (`N[C@H](C)C(=O)O` → the published L-alanine key), gated by the
+  real-binary spec (`ASCIICHEM_INCHI_BIN`).
+- **Molfile round-trip folds chirality wedges back**: a wedge/hash
+  bond on a parity-chiral atom reads as the plain single bond it was
+  written from, instead of re-entering the model as a wedge/hash
+  bond kind.
+- **Structure writers decline formula-style adjacency instead of
+  silently fragmenting**: `CCO` and undashed mixtures
+  (`C1=CC=CC=C1` — only its double bonds + one ring closure are
+  explicit) used to write disconnected graphs and garbage SMILES;
+  `Structure::Graph.build!` now declines with guidance while the
+  tolerant `build` stays available to the linter. SMILES-ingested
+  models are unaffected (their branch reconnection crosses as a
+  ring-closure digit, so the graph is connected).
+
 ## [0.31.6] - 2026-10-21
 
 ### Added

data/lib/asciichem/inchi/binary_engine.rb

@@ -6,13 +6,20 @@ module AsciiChem
   module Inchi
     # Engine that shells out to the standalone IUPAC `inchi-1`
     # binary. The binary is a documented external dependency — nothing
-    # is vendored (vendoring the InChI library requires the licence
-    # review recorded in TODO.v2 10, a maintainer decision).
+    # is vendored (TODO.v2 16 keeps it that way; the native path is a
+    # separate engine).
+    #
+    # Contract: the distributed binary's file interface
+    # (`inchi-1 input.mol output.txt [flags]`). `-STDIO` is NOT part
+    # of it — the standard distribution ignores it and prints usage
+    # (caught against the brew 1.07.5 build), so the engine stages the
+    # molfile to a temp file and reads the output file back, the same
+    # shape as the RInChI engine.
     #
     #   AsciiChem::Inchi.engine = AsciiChem::Inchi::BinaryEngine.new
     #   AsciiChem::Inchi.engine = AsciiChem::Inchi::BinaryEngine.new(bin: "/usr/local/bin/inchi-1")
     class BinaryEngine < Engine
-      DEFAULT_FLAGS = %w[-STDIO -AuxNone -NoLabels -Key].freeze
+      DEFAULT_FLAGS = %w[-AuxNone -NoLabels -Key].freeze
 
       attr_reader :bin, :flags
 
@@ -39,13 +46,21 @@ module AsciiChem
 
       private
 
-      def execute(input)
-        out, err, status = Open3.capture3(bin, *flags, stdin_data: input)
-        unless status.success?
-          raise AsciiChem::Error, "#{bin} failed (exit #{status.exitstatus}): #{(err + out).strip[0, 500]}"
-        end
+      def execute(molfile)
+        require 'tmpdir'
+        Dir.mktmpdir('asciichem-inchi') do |dir|
+          input = File.join(dir, 'structure.mol')
+          output = File.join(dir, 'structure.txt')
+          File.write(input, molfile)
+          _out, err, status = Open3.capture3(bin, input, output, *flags)
+          unless status.success?
+            raise AsciiChem::Error, "#{bin} failed (exit #{status.exitstatus}): #{err.strip[0, 500]}"
+          end
 
-        out
+          # A clean run with no output file means no structure output;
+          # the caller's InChI= regex raises the no-InChI error.
+          File.exist?(output) ? File.read(output) : ''
+        end
       rescue Errno::ENOENT
         raise EngineMissingError, "InChI engine binary #{bin.inspect} not found — #{AsciiChem::Inchi::INSTALL_GUIDE}"
       end

data/lib/asciichem/molfile/parser.rb

@@ -26,6 +26,22 @@ module AsciiChem
         bonds = parse_bonds(bond_count)
         properties = parse_properties
 
+        # A wedge/hash bond on an atom whose parity field already
+        # carries chirality is that chirality's wedge (our writer
+        # emits exactly that pair), not an independent bond kind —
+        # fold it back to its plain single bond.
+        chiral = atoms.each_with_index
+                      .select { |atom, _| atom.chirality }
+                      .map { |_, i| i }
+        bonds = bonds.map do |bond|
+          if %i[wedge hash].include?(bond[:kind]) &&
+             (chiral.include?(bond[:from]) || chiral.include?(bond[:to]))
+            bond.merge(kind: :single)
+          else
+            bond
+          end
+        end
+
         apply_legacy_charge!(atoms)
         apply_charges!(atoms, properties[:charges])
         apply_isotopes!(atoms, properties[:isotopes])

data/lib/asciichem/molfile/writer.rb

@@ -8,13 +8,14 @@ module AsciiChem
     # Structure::Graph, so positions map by index). Charges and
     # isotopes are emitted as `M  CHG` / `M  ISO` property lines.
     #
-    # Tetrahedral chirality crosses as the atom parity field
-    # (TH1 → 1 odd, TH2 → 2 even) relative to the neighbour order in
-    # the bond block, which is the model's linear order — the InChI
-    # binary consumes it when wedges or coordinates are absent.
-    # Directional bonds (`/`, `\`, E/Z) have no V2000 field: the
-    # model's Bond#direction is documented as a molfile loss rather
-    # than silently invented from geometry.
+    # Tetrahedral chirality crosses as a WEDGE on the stereocentre's
+    # first bond (TH1 → up, TH2 → down), oriented centre → neighbour:
+    # the oracle ignores the V2000 atom-parity field for 2D input
+    # (verified against inchi-1 1.07.5 — enantiomers only separate
+    # through the wedge), so the parity field alone never carries
+    # stereo. Directional bonds (`/`, `\`, E/Z) have no V2000 field:
+    # the model's Bond#direction is documented as a molfile loss
+    # rather than silently invented from geometry.
     class Writer
       BOND_TYPES = {
         single: 1, double: 2, triple: 3, aromatic: 4,
@@ -29,7 +30,7 @@ module AsciiChem
       end
 
       def write
-        atoms, edges = Structure::Graph.build(@molecule)
+        atoms, edges = Structure::Graph.build!(@molecule)
         raise ParseError, "molecule has no bonds — a formula is not a structure" if edges.empty? && atoms.length > 1
 
         lines = []
@@ -47,13 +48,18 @@ module AsciiChem
                           hcount_code(atom))
         end
 
+        wedges = wedge_bonds(atoms, edges)
         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)
+          from, to = edge.from, edge.to
+          if (wedge = wedges[edge.object_id])
+            from, to, stereo = wedge
+          end
           lines << format("%3d%3d%3d%3d  0  0  0  0  0  0  0",
-                          edge.from + 1, edge.to + 1, type, stereo)
+                          from + 1, to + 1, type, stereo)
         end
 
         lines << property_line("M  CHG", charge_pairs(atoms))
@@ -64,6 +70,28 @@ module AsciiChem
 
       private
 
+      # One wedge per chiral atom, on its first bond, oriented
+      # centre → neighbour: TH1 rises (stereo 1), TH2 falls (6).
+      # Returns { edge.object_id => [from, to, stereo] }.
+      def wedge_bonds(atoms, edges)
+        wedges = {}
+        atoms.each_with_index do |atom, index|
+          next unless CHIRALITY_PARITY.key?(atom.chirality)
+
+          edge = edges.find { |e| e.from == index || e.to == index }
+          next unless edge
+
+          stereo = atom.chirality == 'TH1' ? 1 : 6
+          wedges[edge.object_id] =
+            if edge.from == index
+              [index, edge.to, stereo]
+            else
+              [index, edge.from, stereo]
+            end
+        end
+        wedges
+      end
+
       # MDL H-count code: 0 default, 1 H0, 2 H1, 3 H2, ... — so a
       # stated count n crosses as n + 1.
       def hcount_code(atom)

data/lib/asciichem/smiles/writer.rb

@@ -34,7 +34,7 @@ module AsciiChem
       end
 
       def write
-        atoms, edges = Structure::Graph.build(@molecule)
+        atoms, edges = Structure::Graph.build!(@molecule)
         # A single-atom component is valid SMILES (water "O", ions);
         # multiple atoms with no bonds is a formula, not a structure.
         raise ParseError, 'molecule has no bonds — a formula is not a structure' if edges.empty? && atoms.length > 1

data/lib/asciichem/structure/graph.rb

@@ -9,12 +9,46 @@ module AsciiChem
       Edge = Struct.new(:from, :to, :kind, :direction, keyword_init: true)
 
       class << self
-        # Returns [atoms, edges] where atoms is the atom array in
-        # walk order and edges is an array of Edge with array indexes.
+        # Returns [atoms, edges] where atoms is the atom array in walk
+        # order and edges is an array of Edge with array indexes.
+        #
+        # Tolerant on purpose: the linter counts exactly the bonds that
+        # are written. Structure writers use `build!`, which declines
+        # formula-style adjacency (see there).
         def build(molecule)
+          atoms, edges, = build_with_adjacency(molecule)
+          [atoms, edges]
+        end
+
+        # Structure writers only. Text adjacency — atoms with no bond
+        # token between them (`CCO`, the undashed spacers in
+        # `C1=CC=CC=C1`) — is formula notation, not a bond; mixing it
+        # with explicit bonds silently fragments the graph (a benzene
+        # ring written as a disconnected C4+C2 pair), so the strict
+        # build declines when adjacency is present and the final graph
+        # is disconnected. SMILES models never trip this: their parser
+        # always bonds every continuation (branch reconnection crosses
+        # as a ring-closure digit), so the graph is connected even
+        # though the flat node list has token-less boundaries — and an
+        # explicit multi-component model (a salt written `A.B`) has no
+        # adjacency at all.
+        def build!(molecule)
+          atoms, edges, adjacency_pairs = build_with_adjacency(molecule)
+          return [atoms, edges] if adjacency_pairs.empty? || connected?(atoms.length, edges)
+
+          raise ParseError,
+                'adjacent atoms have no explicit bond token — a formula ' \
+                'is not a structure. Write explicit bonds (C-C) or ingest ' \
+                'the structure from SMILES/molfile.'
+        end
+
+        private
+
+        def build_with_adjacency(molecule)
           atoms = []
           edges = []
           index_by_object_id = {}
+          adjacency_pairs = []
           pending = nil
           last = nil
 
@@ -28,9 +62,11 @@ module AsciiChem
                 # same as the Layout walker.
                 index_by_object_id[node.object_id] = index
                 atoms << node
-                if pending && last
+                if pending
                   edges << Edge.new(from: last, to: index, kind: pending.kind,
-                                    direction: pending.direction)
+                                    direction: pending.direction) if last
+                elsif last
+                  adjacency_pairs << [last, index]
                 end
                 last = index
                 pending = nil
@@ -55,7 +91,30 @@ module AsciiChem
             edges << Edge.new(from: from, to: to, kind: kind)
           end
 
-          [atoms, edges]
+          [atoms, edges, adjacency_pairs]
+        end
+
+        def connected?(atom_count, edges)
+          return true if atom_count <= 1
+
+          neighbours = Array.new(atom_count) { [] }
+          edges.each do |edge|
+            neighbours[edge.from] << edge.to
+            neighbours[edge.to] << edge.from
+          end
+          seen = [false] * atom_count
+          seen[0] = true
+          queue = [0]
+          until queue.empty?
+            current = queue.shift
+            neighbours[current].each do |n|
+              next if seen[n]
+
+              seen[n] = true
+              queue << n
+            end
+          end
+          seen.all?
         end
       end
     end

data/lib/asciichem/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.31.6
+  version: 0.31.8
 platform: ruby
 authors:
 - Ribose Inc.