asciichem 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f9929cd67fc49ac37896dce9ebc173306615fb08b704fd96ddfa14c09189afd
-  data.tar.gz: dc7bc12b0914610807bdd168f18b2e4b1e281519bbd5698a5c7e08d660b49d83
+  metadata.gz: f025579767518b2551359a0817e2019c19bec299f0a7c77c16264dd98342df25
+  data.tar.gz: c092bfffa44620c0bb2ef20abdba849732eaaaa01ae2f0039bf8c22a4d57baad
 SHA512:
-  metadata.gz: 13f7ec97ce27c022cfac8e9df9944ae9860c949d8bb8569995b113f846a4fb5a0052bf0d6def2374fcaa11b140187d5c38c73e8afb66b0ca77ff3f558f1a994a
-  data.tar.gz: 161b22b36e6eaeb599b7bbae7666c45574d2a17b4abf5127cdbc4fe9e3c8a558b8e8de00d0149c45a58bf4c062368fb79526ef70cdd9f10ad50a6d6cdd169982
+  metadata.gz: 63957c098bb2df1785ce770d6e375c1f54c771e847f01f7de5b03cfd88a4321cf9c6abd6d93c5a5b6f43b1239887f1da80ec48d46d62351071ab25632bfd766f
+  data.tar.gz: 82f5b7dda4a1f9461e5fe68dfc8566328ab2a4541101b33605582620be59651b61f358a7053e3361b5022587d3dc83be4ad1039615673076a492167025321fa0

data/asciichem.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "chemicalml", "0.2.0"
+  spec.add_dependency "chemicalml", "~> 0.2.1"
   spec.add_dependency "elkrb", "~> 1.0"
   spec.add_dependency "nokogiri", "~> 1.16"
   spec.add_dependency "parslet", "~> 2.0"

data/lib/asciichem/cml/extensions.rb

@@ -158,7 +158,7 @@ module AsciiChem
       # then reaction reactants+products, then cascade reactions.
       def self.flatten_canonical_atoms(canonical_doc)
         atoms = []
-        canonical_doc.molecules.each { |m| atoms.concat(m.atoms) }
+        canonical_doc.molecules.each { |m| atoms.concat((m.atom_array&.atoms || [])) }
         canonical_doc.reactions.each do |reaction|
           atoms.concat(flatten_reaction_atoms(reaction))
         end
@@ -172,8 +172,8 @@ module AsciiChem
         atoms = []
         reactants = reaction.reactant_list
         products = reaction.product_list
-        reactants&.reactants&.each { |r| atoms.concat(r.substance.molecule.atoms) }
-        products&.products&.each { |p| atoms.concat(p.substance.molecule.atoms) }
+        reactants&.reactants&.each { |r| atoms.concat(r.substance.molecule.atom_array&.atoms || []) }
+        products&.products&.each { |p| atoms.concat(p.substance.molecule.atom_array&.atoms || []) }
         atoms
       end
       private_class_method :flatten_reaction_atoms

data/lib/asciichem/cml/translator.rb

@@ -4,62 +4,74 @@ require "chemicalml"
 
 module AsciiChem
   module Cml
-    # Thin composition of the AsciiChem <-> canonical adapter
-    # (`AsciiChem::ModelAdapter`) and the canonical <-> CML adapter
-    # (`Chemicalml::Cml::Translator`). Owns no chemistry logic — just
-    # wiring, the schema-registration dance that chemicalml requires
-    # on first use, and the aci: extension namespace side-channel
-    # that carries AsciiChem-specific fields through CML round-trip.
+    # Thin adapter between AsciiChem::Model and Chemicalml::Cml wire
+    # classes. chemicalml 0.2.1+ merged the canonical Model into the
+    # wire classes — Schema3::Atom, Schema3::Molecule, etc. handle both
+    # serialization and semantics. This class:
+    #
+    # 1. Builds a Chemicalml::Cml::Document from AsciiChem::Model::Formula
+    # 2. Serializes to XML (optionally enriching with aci: extensions)
+    # 3. Parses CML XML back into AsciiChem::Model::Formula
+    #
+    # The aci: extension namespace (oxidation state, Lewis markers, ring
+    # closures, groups, electron config, math, text, metadata) is handled
+    # by post-processing the XML via Extensions and GroupExtensions.
     class Translator
       class << self
-        # AsciiChem::Model::Formula -> CML XML string.
         def from_asciichem(formula)
           ensure_schema_registered!
           translation = AsciiChem::ModelAdapter.to_canonical_with_mapping(formula)
-          wire_doc = Chemicalml::Cml::Translator.from_canonical(translation.document)
-          xml = wire_doc.to_xml
+          xml = translation.document.to_xml
           xml = inject_atom_extensions(xml, translation.atom_mapping)
-          xml = inject_group_extensions(xml, translation.groups)
-          inject_top_level_extensions(xml, formula)
+          inject_molecule_extensions(xml, formula, translation)
         end
 
-        # CML XML string -> AsciiChem::Model::Formula.
         def to_asciichem(xml)
           ensure_schema_registered!
           top_level = Extensions.extract_top_level(xml)
           atom_extensions = Extensions.extract(xml)
           group_extensions = GroupExtensions.extract(xml)
           wire_doc = Chemicalml::Cml::Document.from_xml(xml)
-          canonical = Chemicalml::Cml::Translator.to_canonical(wire_doc)
-          formula = AsciiChem::ModelAdapter.from_canonical(canonical)
-          Extensions.restore(formula, canonical, atom_extensions)
-          GroupExtensions.restore(formula, canonical, group_extensions)
+          formula = AsciiChem::ModelAdapter.from_canonical(wire_doc)
+          Extensions.restore(formula, wire_doc, atom_extensions)
+          GroupExtensions.restore(formula, wire_doc, group_extensions)
           Extensions.restore_top_level(formula, top_level)
           formula
         end
 
         private
 
+        def build_wire_document(document)
+          molecules = document.molecules.map { |m| m }
+          reactions = document.reactions.map { |r| r }
+          reaction_lists = document.reaction_lists.map { |l| l }
+          Chemicalml::Cml::Document.new(
+            molecules: molecules,
+            reactions: reactions,
+            reaction_lists: reaction_lists
+          )
+        end
+
         def inject_atom_extensions(xml, atom_mapping)
           extensions = Extensions.collect(atom_mapping)
           Extensions.inject(xml, extensions)
         end
 
-        def inject_group_extensions(xml, groups_by_molecule)
-          collected = GroupExtensions.collect(groups_by_molecule)
-          GroupExtensions.inject(xml, collected)
+        def inject_molecule_extensions(xml, formula, translation)
+          xml = inject_groups(xml, formula, translation)
+          inject_top_level(xml, formula)
+        end
+
+        def inject_groups(xml, formula, translation)
+          groups = translation.respond_to?(:groups) ? translation.groups : {}
+          GroupExtensions.inject(xml, GroupExtensions.collect(groups))
         end
 
-        def inject_top_level_extensions(xml, formula)
+        def inject_top_level(xml, formula)
           top_level = Extensions.collect_top_level(formula)
           Extensions.inject_top_level(xml, top_level)
         end
 
-        # chemicalml registers wire classes into a lutaml-model
-        # TypeRegistry on first use. The registry call is idempotent
-        # (guarded by `@models_registered`) but must run before any
-        # `from_xml` so element types like `molecule` and `atom` are
-        # resolvable.
         def ensure_schema_registered!
           Chemicalml::Cml::Schema3.ensure_registered!
         end

data/lib/asciichem/model_adapter/from_canonical.rb

@@ -10,18 +10,18 @@ module AsciiChem
     #
     # Mapping rules:
     #
-    # - `Chemicalml::Model::Document`     -> `Formula`.
-    # - `Chemicalml::Model::Molecule`     -> `Molecule`. Atoms become
+    # - `Chemicalml::Cml::Document`     -> `Formula`.
+    # - `Chemicalml::Cml::Molecule`     -> `Molecule`. Atoms become
     #                                        AsciiChem atoms with
     #                                        subscript=count. Bonds
     #                                        re-insert between their
     #                                        endpoint positions.
-    # - `Chemicalml::Model::Atom`         -> `Atom` (element, isotope,
+    # - `Chemicalml::Cml::Atom`         -> `Atom` (element, isotope,
     #                                        charge, lone pairs,
     #                                        radical electrons).
-    # - `Chemicalml::Model::Bond`         -> `Bond` (kind enum).
-    # - `Chemicalml::Model::Reaction`     -> `Reaction`.
-    # - `Chemicalml::Model::ReactionList` -> `ReactionCascade`.
+    # - `Chemicalml::Cml::Bond`         -> `Bond` (kind enum).
+    # - `Chemicalml::Cml::Reaction`     -> `Reaction`.
+    # - `Chemicalml::Cml::ReactionList` -> `ReactionCascade`.
     #
     # Round-trip note: the canonical model is richer than AsciiChem's
     # (3D coordinates, metadata, etc.). Those fields are dropped on the
@@ -113,7 +113,7 @@ module AsciiChem
 
       def extract_scalar_value(value)
         return nil if value.nil?
-        return value.value if value.is_a?(Chemicalml::Model::Scalar)
+        return value.value if value.is_a?(Chemicalml::Cml::Scalar)
 
         value.to_s
       end
@@ -136,11 +136,21 @@ module AsciiChem
         AsciiChem::Model::Reaction.new(
           reactants: reactants_from_canonical(reaction.reactant_list),
           products: products_from_canonical(reaction.product_list),
-          arrow: reaction.arrow,
+          arrow: arrow_from_wire(reaction),
           conditions: conditions_from_canonical(reaction)
         )
       end
 
+      def arrow_from_wire(reaction)
+        type = reaction.type || reaction.title
+        case type.to_s
+        when 'reverse' then :reverse
+        when 'equilibrium' then :equilibrium
+        when 'resonance' then :resonance
+        else :forward
+        end
+      end
+
       def reaction_list_from_canonical(list)
         AsciiChem::Model::ReactionCascade.new(
           steps: list.reactions.map { |r| reaction_from_canonical(r) }
@@ -159,12 +169,8 @@ module AsciiChem
         list.products.map { |p| molecule_from_canonical(p.substance.molecule) }
       end
 
-      def conditions_from_canonical(reaction)
-        above = reaction.conditions_above
-        below = reaction.conditions_below
-        return nil unless above || below
-
-        AsciiChem::Model::Reaction::Conditions.new(above: above, below: below)
+      def conditions_from_canonical(_reaction)
+        nil
       end
 
       # Rebuilds an AsciiChem::Model::Molecule's node list from a
@@ -180,7 +186,7 @@ module AsciiChem
         def initialize(molecule)
           @molecule = molecule
           @position_by_atom_id = {}
-          molecule.atoms.each_with_index do |atom, idx|
+          wire_atoms(molecule).each_with_index do |atom, idx|
             @position_by_atom_id[atom.id] = idx
           end
           @nodes = build_nodes
@@ -189,20 +195,26 @@ module AsciiChem
         private
 
         def build_nodes
-          atoms = @molecule.atoms.map { |a| atom_from_canonical(a) }
-          return atoms if @molecule.bonds.empty?
+          atoms = wire_atoms(@molecule).map { |a| atom_from_canonical(a) }
+          return atoms if wire_bonds(@molecule).empty?
 
           insert_bonds(atoms)
         end
 
+        def wire_atoms(molecule)
+          molecule.atom_array&.atoms || []
+        end
+
+        def wire_bonds(molecule)
+          molecule.bond_array&.bonds || []
+        end
+
         def atom_from_canonical(atom)
           AsciiChem::Model::Atom.new(
-            element: atom.element,
+            element: atom.element_type,
             isotope: atom.isotope,
             subscript: subscript_from_count(atom.count),
             charge: atom.formal_charge,
-            lone_pairs: atom.lone_pairs,
-            radical_electrons: atom.radical_electrons,
             **extract_coordinates(atom)
           )
         end
@@ -230,14 +242,14 @@ module AsciiChem
           result = atoms.dup
           # Insert in descending position order so earlier insertions
           # don't shift the indices of pending ones.
-          bonds_with_pos = @molecule.bonds.map { |b| [b, later_position(b)] }
+          bonds_with_pos = wire_bonds(@molecule).map { |b| [b, later_position(b)] }
           bonds_with_pos.sort_by { |(_, pos)| -pos }.each do |bond, pos|
             # Ring bonds connect non-adjacent atoms. They're represented
             # by the ring_closures digit carried via aci: extension on
             # the atoms, not as a positional bond in the node list.
             next if ring_bond?(bond)
 
-            result.insert(pos, AsciiChem::Model::Bond.new(kind: bond.kind))
+            result.insert(pos, AsciiChem::Model::Bond.new(kind: bond_kind_from_order(bond.order)))
           end
           result
         end
@@ -245,7 +257,7 @@ module AsciiChem
         # Position of the later endpoint of the bond — i.e. where the
         # bond marker should sit in the rebuilt linear sequence.
         def later_position(bond)
-          positions = bond.atom_refs.map { |id| @position_by_atom_id[id] }.compact
+          positions = bond.atom_refs2.to_s.split.map { |id| @position_by_atom_id[id] }.compact
           return 0 if positions.empty?
 
           positions.max
@@ -255,16 +267,26 @@ module AsciiChem
         # adjacent — its endpoints span a gap. Such bonds are
         # represented by ring_closures digits, not positional markers.
         def ring_bond?(bond)
-          positions = bond.atom_refs.map { |id| @position_by_atom_id[id] }.compact
+          positions = bond.atom_refs2.to_s.split.map { |id| @position_by_atom_id[id] }.compact
           return false if positions.length < 2
 
           positions.max - positions.min > 1
         end
 
         def first_position(bond)
-          positions = bond.atom_refs.map { |id| @position_by_atom_id[id] }.compact
+          positions = bond.atom_refs2.to_s.split.map { |id| @position_by_atom_id[id] }.compact
           positions.min || 0
         end
+
+        ORDER_TO_KIND = {
+          'S' => :single, 'D' => :double, 'T' => :triple,
+          'Q' => :quadruple, 'W' => :wedge, 'H' => :hash,
+          'A' => :dative, 'V' => :wavy
+        }.freeze
+
+        def bond_kind_from_order(order)
+          ORDER_TO_KIND.fetch(order.to_s, :single)
+        end
       end
       private_constant :MoleculeRebuilder
     end

data/lib/asciichem/model_adapter/to_canonical.rb

@@ -9,17 +9,17 @@ module AsciiChem
     #
     # Mapping rules:
     #
-    # - `Formula`           -> `Chemicalml::Model::Document`.
-    # - `Molecule`          -> `Chemicalml::Model::Molecule`. Inner atoms
+    # - `Formula`           -> `Chemicalml::Cml::Document`.
+    # - `Molecule`          -> `Chemicalml::Cml::Molecule`. Inner atoms
     #                         collect IDs; bonds reference consecutive
     #                         IDs. Groups flatten with their multiplicity
     #                         applied to each contained atom's count.
-    # - `Atom`              -> `Chemicalml::Model::Atom` (element,
+    # - `Atom`              -> `Chemicalml::Cml::Atom` (element,
     #                         isotope, charge, count, lone pairs,
     #                         radical electrons).
-    # - `Bond`              -> `Chemicalml::Model::Bond` (kind, refs).
-    # - `Reaction`          -> `Chemicalml::Model::Reaction`.
-    # - `ReactionCascade`   -> `Chemicalml::Model::ReactionList`.
+    # - `Bond`              -> `Chemicalml::Cml::Bond` (kind, refs).
+    # - `Reaction`          -> `Chemicalml::Cml::Reaction`.
+    # - `ReactionCascade`   -> `Chemicalml::Cml::ReactionList`.
     # - `ElectronConfiguration`, `EmbeddedMath`, `Text` -> skipped
     #   (no canonical representation yet; a future extension can carry
     #   them as namespaced metadata).
@@ -52,7 +52,7 @@ module AsciiChem
             reaction_lists << reaction_cascade_to_canonical(node)
           end
         end
-        Chemicalml::Model::Document.new(
+        Chemicalml::Cml::Document.new(
           molecules: molecules,
           reactions: reactions,
           reaction_lists: reaction_lists
@@ -67,10 +67,10 @@ module AsciiChem
         walker = MoleculeWalker.new(@ids)
         atoms, bonds = walker.walk(molecule)
         @atom_mapping.merge!(walker.atom_mapping)
-        canonical_molecule = Chemicalml::Model::Molecule.new(
+        canonical_molecule = Chemicalml::Cml::Molecule.new(
           id: @ids.next(:molecule),
-          atoms: atoms,
-          bonds: bonds,
+          atom_array: atoms.empty? ? nil : Chemicalml::Cml::AtomArray.new(atoms: atoms),
+          bond_array: bonds.empty? ? nil : Chemicalml::Cml::BondArray.new(bonds: bonds),
           count: molecule.coefficient,
           formal_charge: total_formal_charge(atoms),
           names: map_names(molecule.names),
@@ -88,7 +88,7 @@ module AsciiChem
         return [] if names.nil? || names.empty?
 
         names.map do |n|
-          Chemicalml::Model::Name.new(
+          Chemicalml::Cml::Name.new(
             content: n.content,
             convention: n.convention,
             dict_ref: n.dict_ref
@@ -100,7 +100,7 @@ module AsciiChem
         return [] if identifiers.nil? || identifiers.empty?
 
         identifiers.map do |i|
-          Chemicalml::Model::Identifier.new(
+          Chemicalml::Cml::Identifier.new(
             value: i.value,
             convention: i.convention,
             dict_ref: i.dict_ref
@@ -112,7 +112,7 @@ module AsciiChem
         return [] if formulas.nil? || formulas.empty?
 
         formulas.map do |f|
-          Chemicalml::Model::Formula.new(
+          Chemicalml::Cml::Formula.new(
             concise: f[:concise],
             inline: f[:inline],
             formal_charge: f[:formal_charge],
@@ -128,7 +128,7 @@ module AsciiChem
         return [] if properties.nil? || properties.empty?
 
         properties.map do |p|
-          Chemicalml::Model::Property.new(
+          Chemicalml::Cml::Property.new(
             title: p[:title],
             value: build_scalar(p[:value]),
             dict_ref: p[:dict_ref],
@@ -140,7 +140,7 @@ module AsciiChem
       def build_scalar(value)
         return nil if value.nil?
 
-        Chemicalml::Model::Scalar.new(
+        Chemicalml::Cml::Scalar.new(
           value: value.to_s,
           dict_ref: nil
         )
@@ -150,7 +150,7 @@ module AsciiChem
         return [] if labels.nil? || labels.empty?
 
         labels.map do |l|
-          Chemicalml::Model::Label.new(
+          Chemicalml::Cml::Label.new(
             value: l[:value],
             dict_ref: l[:dict_ref],
             convention: l[:convention]
@@ -180,7 +180,7 @@ module AsciiChem
       # -- Reactions --------------------------------------------------
 
       def reaction_to_canonical(reaction)
-        Chemicalml::Model::Reaction.new(
+        Chemicalml::Cml::Reaction.new(
           id: @ids.next(:reaction),
           reactant_list: reactant_list_to_canonical(reaction.reactants),
           product_list: product_list_to_canonical(reaction.products),
@@ -193,26 +193,26 @@ module AsciiChem
       end
 
       def reaction_cascade_to_canonical(cascade)
-        Chemicalml::Model::ReactionList.new(
+        Chemicalml::Cml::ReactionList.new(
           reactions: cascade.steps.map { |s| reaction_to_canonical(s) }
         )
       end
 
       def reactant_list_to_canonical(reactants)
-        Chemicalml::Model::ReactantList.new(
+        Chemicalml::Cml::ReactantList.new(
           reactants: reactants.map { |m| participant_to_canonical(m, :reactant) }
         )
       end
 
       def product_list_to_canonical(products)
-        Chemicalml::Model::ProductList.new(
+        Chemicalml::Cml::ProductList.new(
           products: products.map { |m| participant_to_canonical(m, :product) }
         )
       end
 
       def participant_to_canonical(molecule, role)
-        Chemicalml::Model::Reactant.new(
-          substance: Chemicalml::Model::Substance.new(
+        Chemicalml::Cml::Reactant.new(
+          substance: Chemicalml::Cml::Substance.new(
             molecule: molecule_to_canonical(molecule),
             role: role
           )
@@ -264,7 +264,7 @@ module AsciiChem
         # into canonical atom IDs. Skips pairs that already have a
         # positional bond between them (degenerate case like `C1-C1`).
         def emit_ring_bonds(molecule)
-          existing_pair_keys = @bonds.map { |b| pair_key(b.atom_refs) }.to_set
+          existing_pair_keys = @bonds.map { |b| pair_key(b.atom_refs2.to_s.split) }.to_set
           AsciiChem::RingBonds.each_in(molecule) do |ring_bond|
             from_id = @atom_id_by_object_id[ring_bond.from_atom.object_id]
             to_id = @atom_id_by_object_id[ring_bond.to_atom.object_id]
@@ -273,10 +273,10 @@ module AsciiChem
             key = pair_key([from_id, to_id])
             next if existing_pair_keys.include?(key)
 
-            @bonds << Chemicalml::Model::Bond.new(
+            @bonds << Chemicalml::Cml::Bond.new(
               id: @ids.next(:bond),
-              atom_refs: [from_id, to_id],
-              kind: :single
+              atom_refs2: "#{from_id} #{to_id}",
+              order: "S"
             )
             existing_pair_keys << key
           end
@@ -325,7 +325,7 @@ module AsciiChem
           @group_stack.each { |record| record.atom_ids << id }
           attrs = {
             id: id,
-            element: atom.element,
+            element_type: atom.element,
             isotope: atom.isotope,
             formal_charge: atom.charge,
             count: effective_count(atom, multiplier),
@@ -333,17 +333,17 @@ module AsciiChem
             radical_electrons: atom.radical_electrons
           }
           merge_coordinates(attrs, atom)
-          @atoms << Chemicalml::Model::Atom.new(**attrs)
+          @atoms << Chemicalml::Cml::Atom.new(**attrs)
           emit_pending_bond(id) if @pending_bond_kind && @last_atom_id
           @last_atom_id = id
           @pending_bond_kind = nil
         end
 
         def emit_pending_bond(next_atom_id)
-          @bonds << Chemicalml::Model::Bond.new(
+          @bonds << Chemicalml::Cml::Bond.new(
             id: @ids.next(:bond),
-            atom_refs: [@last_atom_id, next_atom_id],
-            kind: @pending_bond_kind,
+            atom_refs2: "#{@last_atom_id} #{next_atom_id}",
+            order: BOND_ORDER_CODES.fetch(@pending_bond_kind, "S"),
             bond_stereo: bond_stereo_for(@pending_bond_kind)
           )
         end
@@ -351,13 +351,16 @@ module AsciiChem
         # CML bondStereo codes for stereo bonds. Wedge (coming out of
         # page) → "W"; hash (going into page) → "H". Other bond kinds
         # have no stereo meaning.
+        BOND_ORDER_CODES = { single: "S", double: "D", triple: "T",
+                              quadruple: "Q", wedge: "W", hash: "H",
+                              dative: "A", wavy: "V" }.freeze
         BOND_STEREO_CODES = { wedge: "W", hash: "H" }.freeze
 
         def bond_stereo_for(kind)
           code = BOND_STEREO_CODES[kind]
           return nil unless code
 
-          Chemicalml::Model::BondStereo.new(value: code)
+          Chemicalml::Cml::BondStereo.new(value: code)
         end
 
         def effective_count(atom, multiplier)

data/lib/asciichem/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -13,16 +13,16 @@ dependencies:
   name: chemicalml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: elkrb
   requirement: !ruby/object:Gem::Requirement