asciichem 0.31.0 → 0.31.2

data/lib/asciichem/smiles/writer.rb

@@ -21,7 +21,7 @@ module AsciiChem
       LOWERCASE_AROMATIC = %w[C N O S P B Se As].freeze
       ORGANIC = %w[B C N O P S F Cl Br I].freeze
       BOND_TOKENS = {
-        single: "-", double: "=", triple: "#", quadruple: "$", aromatic: ":"
+        single: '-', double: '=', triple: '#', quadruple: '$', aromatic: ':'
       }.freeze
       CONTINUATION_BONDS = %i[single aromatic].freeze
 
@@ -33,9 +33,7 @@ module AsciiChem
         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.
-        if edges.empty? && atoms.length > 1
-          raise ParseError, "molecule has no bonds — a formula is not a structure"
-        end
+        raise ParseError, 'molecule has no bonds — a formula is not a structure' if edges.empty? && atoms.length > 1
 
         @atoms = atoms
         build_adjacency(edges)
@@ -53,6 +51,7 @@ module AsciiChem
 
         build_tree(0, nil)
         compute_tree_size(0)
+        compute_written_orders
         emit(0, nil, nil)
 
         @units.map do |unit|
@@ -69,10 +68,60 @@ module AsciiChem
 
       def build_adjacency(edges)
         @adjacency = Array.new(@atoms.length) { {} }
+        @directions = {}
+        @model_neighbours = Array.new(@atoms.length) { [] }
         edges.each do |edge|
+          key = [edge.from, edge.to]
           @adjacency[edge.from][edge.to] = edge.kind
           @adjacency[edge.to][edge.from] = edge.kind
+          key = key.minmax
+          @directions[key] = edge.direction if edge.direction
+          # The edge array is in model node order: each atom's
+          # reference neighbours, for SMILES parity bookkeeping.
+          @model_neighbours[edge.from] << edge.to
+          @model_neighbours[edge.to] << edge.from
+        end
+      end
+
+      # The order neighbours are WRITTEN in: parent first, then ring
+      # closures, then branches (rank order), then the continuation.
+      # Tetrahedral parity flips with odd permutations of this order
+      # against the model's reference order, so the emitted @/@@ is
+      # corrected per atom. Ring-closure neighbours in the reference
+      # order are slice-3 scope (acyclic stereo is corrected here).
+      def compute_written_orders
+        @written_order = Array.new(@atoms.length)
+        walk = lambda do |index, parent|
+          order = parent ? [parent] : []
+          order += @closures[index].dup
+          # Appearance order: branches (rank order), then the
+          # continuation — emit() writes them that way.
+          ordered = @tree_children[index].sort_by { |child| continuation_rank(index, child) }
+          order += ordered[1..] + [ordered.first] unless ordered.empty?
+          @written_order[index] = order
+          @tree_children[index].each { |child| walk.call(child, index) }
+        end
+        walk.call(0, nil)
+      end
+
+      # TH1 -> TH2 flip when the written order is an odd permutation
+      # of the model's reference order (implicit hydrogens sort first
+      # on both sides).
+      def chirality_token(index)
+        chirality = @atoms[index].chirality
+        return '' unless chirality
+
+        reference = ([:h] if @atoms[index].hydrogens) || []
+        reference += @model_neighbours[index]
+        written = ([:h] if @atoms[index].hydrogens) || []
+        written += @written_order[index]
+        inversions = 0
+        written.each_with_index do |item, i|
+          written[(i + 1)..].each do |later|
+            inversions += 1 if reference.index(item) > reference.index(later)
+          end
         end
+        chirality == 'TH2' || inversions.odd? ? '@@' : '@'
       end
 
       # Post-order subtree sizes within the DFS tree.
@@ -111,9 +160,9 @@ module AsciiChem
         continuation, *branches = ordered
 
         branches.each do |child|
-          @units << [:literal, "("]
+          @units << [:literal, '(']
           emit(child, index, @adjacency[index][child])
-          @units << [:literal, ")"]
+          @units << [:literal, ')']
         end
         emit(continuation, index, @adjacency[index][continuation])
       end
@@ -125,7 +174,10 @@ module AsciiChem
       def continuation_rank(index, child)
         kind = @adjacency[index][child]
         priority = CONTINUATION_BONDS.include?(kind) ? 0 : 1
-        [priority, -@tree_size[child], atom_token(child)]
+        # The order-independent token: this rank runs inside the
+        # written-order pre-pass, where stereo tokens are not yet
+        # computable (and stereo does not affect the order).
+        [priority, -@tree_size[child], atom_token_for(child, stereo: false)]
       end
 
       def ring_digit_for(a, b)
@@ -133,7 +185,7 @@ module AsciiChem
         digit = @digit_by_edge[key]
         return digit if digit
 
-        raise ParseError, "too many ring closures for SMILES output" if @next_digit > 9
+        raise ParseError, 'too many ring closures for SMILES output' if @next_digit > 9
 
         digit = @next_digit.to_s
         @next_digit += 1
@@ -145,48 +197,61 @@ module AsciiChem
         digit
       end
 
-
       def bond_token(kind, from, to)
         token = BOND_TOKENS[kind]
         raise ParseError, "#{kind} bonds have no SMILES form (v1 subset)" unless token
 
         return token if kind != :single && kind != :aromatic
 
-        # Explicit only when the short form would change the meaning:
-        # a single bond between two aromatic atoms must be written;
-        # an aromatic bond is implicit between two aromatic atoms.
         if kind == :single
-          aromatic?(from) && aromatic?(to) ? token : ""
+          direction = @directions[[from, to].minmax]
+          return direction == :up ? '/' : '\\' if direction
+
+          return '' unless aromatic?(from) && aromatic?(to)
+
+          # Explicit only when the short form would change the meaning:
+          # a single bond between two aromatic atoms must be written.
+          token
         else
-          aromatic?(from) && aromatic?(to) ? "" : token
+          aromatic?(from) && aromatic?(to) ? '' : token
         end
       end
 
       def atom_token(index)
-        @atom_tokens ||= {}
-        @atom_tokens[index] ||= begin
-          atom = @atoms[index]
-          aromatic = atom.aromatic == true
-          lowercase = aromatic && LOWERCASE_AROMATIC.include?(atom.element)
-          needs_bracket =
-            atom.charge || atom.isotope || atom.hydrogens ||
-            (!ORGANIC.include?(atom.element) && !lowercase) ||
-            (aromatic && !lowercase)
-          unless needs_bracket
-            bare_symbol(atom, lowercase)
-          else
+        atom_token_for(index, stereo: true)
+      end
+
+      # `stereo: false` gives the order-independent form for ranking
+      # comparisons; the emitted token carries the corrected @/@@.
+      def atom_token_for(index, stereo:)
+        @plain_tokens ||= {}
+        return @plain_tokens[index] if !stereo && @plain_tokens[index]
+
+        atom = @atoms[index]
+        aromatic = atom.aromatic == true
+        lowercase = aromatic && LOWERCASE_AROMATIC.include?(atom.element)
+        needs_bracket =
+          atom.charge || atom.isotope || atom.hydrogens || atom.chirality ||
+          (!ORGANIC.include?(atom.element) && !lowercase) ||
+          (aromatic && !lowercase)
+        token =
+          if needs_bracket
             symbol = lowercase ? atom.element.downcase : atom.element
-            token = +"["
-            token << atom.isotope if atom.isotope
-            token << symbol
+            t = +'['
+            t << atom.isotope if atom.isotope
+            t << symbol
+            t << chirality_token(index) if stereo && atom.chirality
             if atom.hydrogens
-              token << "H"
-              token << atom.hydrogens.to_s if atom.hydrogens > 1
+              t << 'H'
+              t << atom.hydrogens.to_s if atom.hydrogens > 1
             end
-            token << charge_suffix(atom.charge) if atom.charge
-            token << "]"
+            t << charge_suffix(atom.charge) if atom.charge
+            t << ']'
+          else
+            bare_symbol(atom, lowercase)
           end
-        end
+        @plain_tokens[index] = token unless stereo
+        token
       end
 
       def bare_symbol(atom, lowercase)

data/lib/asciichem/structure/graph.rb

@@ -6,7 +6,7 @@ module AsciiChem
     # atoms become edges (pending-bond semantics, same as the Layout
     # walker); ring-closure digits become edges via AsciiChem::RingBonds.
     module Graph
-      Edge = Struct.new(:from, :to, :kind, keyword_init: true)
+      Edge = Struct.new(:from, :to, :kind, :direction, keyword_init: true)
 
       class << self
         # Returns [atoms, edges] where atoms is the atom array in
@@ -29,7 +29,8 @@ module AsciiChem
                 index_by_object_id[node.object_id] = index
                 atoms << node
                 if pending && last
-                  edges << Edge.new(from: last, to: index, kind: pending.kind)
+                  edges << Edge.new(from: last, to: index, kind: pending.kind,
+                                    direction: pending.direction)
                 end
                 last = index
                 pending = nil

data/lib/asciichem/structure/linearizer.rb

@@ -32,7 +32,7 @@ module AsciiChem
         @edges.each do |edge|
           first, last = [edge.from, edge.to].minmax
           if last - first == 1
-            @token_before[last] = edge.kind
+            @token_before[last] = edge
           else
             digit = allocate_digit(first, last)
             @digits_for[first] += digit
@@ -42,8 +42,11 @@ module AsciiChem
 
         result = []
         @atoms.each_with_index do |atom, index|
-          kind = @token_before[index]
-          result << AsciiChem::Model::Bond.new(kind: kind || :single) if index.positive? && kind
+          edge = @token_before[index]
+          if index.positive? && edge
+            result << AsciiChem::Model::Bond.new(kind: edge.kind || :single,
+                                                 direction: edge.direction)
+          end
           atom.ring_closures = @digits_for[index] unless @digits_for[index].empty?
           result << atom
         end

data/lib/asciichem/transform_rules.rb

@@ -62,6 +62,8 @@ module AsciiChem
   
       # -- bonds ------------------------------------------------------------
   
+      rule(direction_up: simple(:_u))   { Model::Bond.new(kind: :single, direction: :up) }
+      rule(direction_down: simple(:_d)) { Model::Bond.new(kind: :single, direction: :down) }
       rule(quadruple: simple(:_q)) { Model::Bond.new(kind: :quadruple) }
       rule(triple: simple(:_t))    { Model::Bond.new(kind: :triple) }
       rule(wedge: simple(:_w))     { Model::Bond.new(kind: :wedge) }
@@ -597,6 +599,7 @@ module AsciiChem
             lone_pairs: lewis_count(hash[:lone_pairs]),
             radical_electrons: lewis_count(hash[:radical_electrons]),
             ring_closures: ring_closures_string(hash[:ring_closures]),
+            chirality: hash[:chirality]&.to_s,
             x2: float_or_nil(hash[:x2]),
             y2: float_or_nil(hash[:y2]),
             z2: float_or_nil(hash[:z2]),
@@ -637,7 +640,7 @@ module AsciiChem
   
         def initialize(element, isotope: nil, subscript: nil, superscript: nil,
                        lone_pairs: nil, radical_electrons: nil,
-                       ring_closures: nil,
+                       ring_closures: nil, chirality: 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)
@@ -648,6 +651,7 @@ module AsciiChem
           @lone_pairs = lone_pairs
           @radical_electrons = radical_electrons
           @ring_closures = ring_closures
+          @chirality = chirality
           @x2 = x2
           @y2 = y2
           @z2 = z2
@@ -672,6 +676,7 @@ module AsciiChem
             lone_pairs: positive_int(@lone_pairs),
             radical_electrons: positive_int(@radical_electrons),
             ring_closures: @ring_closures,
+            chirality: @chirality,
             x2: @x2,
             y2: @y2,
             z2: @z2,

data/lib/asciichem/version.rb

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

data/lib/asciichem/wire/core.rb

@@ -18,6 +18,7 @@ module AsciiChem
       attribute :ring_closures, :string
       attribute :aromatic, :boolean
       attribute :hydrogens, :integer
+      attribute :chirality, :string
       json do
         map "element", to: :element
         map "isotope", to: :isotope
@@ -28,6 +29,7 @@ module AsciiChem
         map "radicalElectrons", to: :radical_electrons
         map "ringClosures", to: :ring_closures
         map "aromatic", to: :aromatic
+        map "chirality", to: :chirality
         map "hydrogens", to: :hydrogens
       end
     end
@@ -90,8 +92,10 @@ module AsciiChem
       wire_type "bond"
 
       attribute :kind, :string
+      attribute :direction, :string
       json do
         map "kind", to: :kind
+        map "direction", to: :direction
       end
     end
   end

data/lib/asciichem/wire_adapter.rb

@@ -107,7 +107,8 @@ module AsciiChem
           radical_electrons: int_or_nil(atom.radical_electrons),
           ring_closures: str_or_nil(atom.ring_closures),
           aromatic: bool_or_nil(atom.aromatic),
-          hydrogens: int_or_nil(atom.hydrogens)
+          hydrogens: int_or_nil(atom.hydrogens),
+          chirality: str_or_nil(atom.chirality)
         )
       end
 
@@ -165,7 +166,8 @@ module AsciiChem
       end
 
       def bond_to_wire(node)
-        AsciiChem::Wire::Bond.new(type: "bond", kind: node.kind.to_s)
+        AsciiChem::Wire::Bond.new(type: "bond", kind: node.kind.to_s,
+                                  direction: str_or_nil(node.direction&.to_s))
       end
 
       def identifier_to_wire(node)
@@ -302,7 +304,8 @@ module AsciiChem
           charge: wire.charge, oxidation_state: wire.oxidation_state,
           lone_pairs: wire.lone_pairs, radical_electrons: wire.radical_electrons,
           ring_closures: wire.ring_closures,
-          aromatic: wire.aromatic, hydrogens: wire.hydrogens
+          aromatic: wire.aromatic, hydrogens: wire.hydrogens,
+          chirality: wire.chirality
         )
       end
 
@@ -324,7 +327,8 @@ module AsciiChem
       end
 
       def bond_from_wire(wire)
-        AsciiChem::Model::Bond.new(kind: wire.kind.to_sym)
+        AsciiChem::Model::Bond.new(kind: wire.kind.to_sym,
+                                   direction: wire.direction&.to_sym)
       end
 
       def identifier_from_wire(wire)

data/lib/asciichem.rb

@@ -29,6 +29,8 @@ module AsciiChem
   autoload :ModelAdapter, "asciichem/model_adapter"
   autoload :Molfile, "asciichem/molfile"
   autoload :Parser, "asciichem/parser"
+  autoload :Perception,        'asciichem/perception'
+  autoload :ReactionRoles,     'asciichem/reaction_roles'
   autoload :PeriodicTable, "asciichem/periodic_table"
   autoload :Resolver, "asciichem/resolver"
   autoload :RingBonds, "asciichem/ring_bonds"

data/scripts/generate-conformance-cases

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Differential conformance (TODO.v2/13 item 5): exports the property
+# harness's generated models as wire JSON + canonical text so the
+# TypeScript and Python implementations run the SAME cases (the
+# cross-implementation differential gate). Deterministic seed; the
+# output lives in asciichem-tests and is versioned like any corpus
+# artifact.
+#
+#   bundle exec ruby scripts/generate-conformance-cases \
+#     ../asciichem-tests/corpus/generated/models.json [count]
+require "asciichem"
+require "asciichem/wire_adapter"
+require "fileutils"
+require "json"
+
+seed = 20_261_020
+count = Integer(ARGV[1] || 300)
+out_path = ARGV[0] || "../asciichem-tests/corpus/generated/models.json"
+
+rng = Random.new(seed)
+ELEMENTS = %w[H C N O F S P Cl].freeze
+BOND_KINDS = %i[single double single triple].freeze
+
+pick = ->(list) { list[rng.rand(list.length)] }
+
+cases = []
+count.times do
+  size = 2 + rng.rand(6)
+  atoms = Array.new(size) do
+    AsciiChem::Model::Atom.new(
+      element: pick.call(ELEMENTS),
+      charge: pick.call([nil, nil, nil, '2+', '-']),
+      chirality: pick.call([nil, nil, nil, nil, 'TH1', 'TH2'])
+    )
+  end
+  bonds = (1...size).map do
+    AsciiChem::Model::Bond.new(
+      kind: pick.call(BOND_KINDS),
+      direction: (pick.call([nil, nil, nil, :up, :down]) if rng.rand(6).zero?)
+    )
+  end
+  molecule = AsciiChem::Model::Molecule.new(nodes: atoms.zip(bonds).flatten.compact)
+  text = molecule.to_text
+  reparsed = AsciiChem.parse(text)
+  raise "seed #{seed} generated an unstable case: #{text.inspect}" unless reparsed.nodes.first == molecule
+
+  # The wire root is the formula document (the canonical root).
+  wire = AsciiChem::WireAdapter.to_wire(AsciiChem.parse(text))
+  # Framework serialization (lutaml-model), never hand-rolled.
+  cases << { "wire" => JSON.parse(wire.to_json), "text" => text }
+end
+
+FileUtils.mkdir_p(File.dirname(out_path))
+File.write(out_path, JSON.pretty_generate({ "seed" => seed, "cases" => cases }) + "\n")
+puts "wrote #{cases.length} cases to #{out_path}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.31.0
+  version: 0.31.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: elkrb
   requirement: !ruby/object:Gem::Requirement
@@ -265,11 +265,14 @@ files:
 - lib/asciichem/molfile/parser.rb
 - lib/asciichem/molfile/writer.rb
 - lib/asciichem/parser.rb
+- lib/asciichem/perception.rb
 - lib/asciichem/periodic_table.rb
+- lib/asciichem/reaction_roles.rb
 - lib/asciichem/resolver.rb
 - lib/asciichem/resolver/adapter.rb
 - lib/asciichem/resolver/cache.rb
 - lib/asciichem/resolver/common_chemistry.rb
+- lib/asciichem/resolver/opsin.rb
 - lib/asciichem/resolver/pubchem.rb
 - lib/asciichem/resolver/substance.rb
 - lib/asciichem/ring_bonds.rb
@@ -290,6 +293,7 @@ files:
 - lib/asciichem/wire/identity.rb
 - lib/asciichem/wire_adapter.rb
 - lib/asciichem/xml_builder.rb
+- scripts/generate-conformance-cases
 - scripts/update-model-schemas.sh
 homepage: https://www.asciichem.org
 licenses: