yaml_exporter 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e760f89f11f40a2f5e94e6e44348da196bd2da09267ad7585070f21c3cf998da
-  data.tar.gz: 8a2261d83c43f0a9ad8be36e3cdb425984dc42088a6cf49d839a779d820e0a80
+  metadata.gz: 6c15fc079f4444a43a53ea849f8ff86162074ace88cc884ed28bef127a59afc0
+  data.tar.gz: 6b51f04b4712e71f1840c61fb323be7127b133e561afaaafcd81f9e382f7919b
 SHA512:
-  metadata.gz: 40c9ba2b0c249095bf6e88bed66cd13c4a37c6e3566c1f4d3b5308e19df475cc897215962840513b8de90d1298f675d5492c1f8315993840e27dbe77a4de204f
-  data.tar.gz: 347bb621e9f981bdb61899864b70b8659f11b65691fc67c8ccf2bc8417ae1cf0c6ae6f39a091efa1c99f3314ebc1951d650d014a217a9fb2d5970db6d579ae57
+  metadata.gz: 4beae00561aeb8d7da659b6b3b578cb9e9aa95bfcd2d266a63bc9fb0e98a6a6f1310cd73801edc03125fb3c831b6a730458165b56549067a0b5a5eb276a114a8
+  data.tar.gz: 19dfc281188c17041c1d822422b1eb07f11aea06525ba042b261f016945e664ae40ac272e10246f280fbe5c70d1b0f3633a809ec4cb9ea4363eb6563ddf2dc8e

data/CHANGELOG.md

@@ -5,6 +5,17 @@ This project follows [semantic versioning](https://semver.org).
 
 ## Unreleased
 
+## v0.2.1
+
+### Added
+
+- `of:` on `many` reference lists. Both `many :assoc, find_by: :col, of: :nested`
+  and the `through:` flavor `many :assoc, through: :join, find_by: :col, of: :nested`
+  now identify each target indirectly via a 1:[0,1] association on the target
+  (`of:`), mirroring the existing `one … find_by: of:` semantics. The YAML stays
+  a flat list of the related model's `find_by` values (e.g. user slugs) instead
+  of requiring a nested block of hashes.
+
 ## v0.2.0
 
 A ground-up rewrite of the export/import engine and its DSL. **Breaking: nothing

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yaml_exporter (0.2.0)
+    yaml_exporter (0.2.1)
       activerecord (>= 5.2)
       activesupport (>= 5.2)
 
@@ -28,27 +28,27 @@ GEM
       tzinfo (~> 2.0, >= 2.0.5)
       uri (>= 0.13.1)
     base64 (0.3.0)
-    bigdecimal (4.1.1)
-    concurrent-ruby (1.3.6)
+    bigdecimal (4.1.2)
+    concurrent-ruby (1.3.7)
     connection_pool (3.0.2)
     drb (2.2.3)
-    i18n (1.14.8)
+    i18n (1.15.2)
       concurrent-ruby (~> 1.0)
-    json (2.19.3)
+    json (2.21.1)
     logger (1.7.0)
     minitest (5.27.0)
-    rake (13.3.1)
+    rake (13.4.2)
     securerandom (0.4.1)
-    sqlite3 (2.9.2-aarch64-linux-gnu)
-    sqlite3 (2.9.2-aarch64-linux-musl)
-    sqlite3 (2.9.2-arm-linux-gnu)
-    sqlite3 (2.9.2-arm-linux-musl)
-    sqlite3 (2.9.2-arm64-darwin)
-    sqlite3 (2.9.2-x86-linux-gnu)
-    sqlite3 (2.9.2-x86-linux-musl)
-    sqlite3 (2.9.2-x86_64-darwin)
-    sqlite3 (2.9.2-x86_64-linux-gnu)
-    sqlite3 (2.9.2-x86_64-linux-musl)
+    sqlite3 (2.9.5-aarch64-linux-gnu)
+    sqlite3 (2.9.5-aarch64-linux-musl)
+    sqlite3 (2.9.5-arm-linux-gnu)
+    sqlite3 (2.9.5-arm-linux-musl)
+    sqlite3 (2.9.5-arm64-darwin)
+    sqlite3 (2.9.5-x86-linux-gnu)
+    sqlite3 (2.9.5-x86-linux-musl)
+    sqlite3 (2.9.5-x86_64-darwin)
+    sqlite3 (2.9.5-x86_64-linux-gnu)
+    sqlite3 (2.9.5-x86_64-linux-musl)
     timeout (0.6.1)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
@@ -77,30 +77,30 @@ CHECKSUMS
   activerecord (8.1.3) sha256=8003be7b2466ba0a2a670e603eeb0a61dd66058fccecfc49901e775260ac70ab
   activesupport (8.1.3) sha256=21a5e0dfbd4c3ddd9e1317ec6a4d782fa226e7867dc70b0743acda81a1dca20e
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  bigdecimal (4.1.1) sha256=1c09efab961da45203c8316b0cdaec0ff391dfadb952dd459584b63ebf8054ca
-  concurrent-ruby (1.3.6) sha256=6b56837e1e7e5292f9864f34b69c5a2cbc75c0cf5338f1ce9903d10fa762d5ab
+  bigdecimal (4.1.2) sha256=53d217666027eab4280346fba98e7d5b66baaae1b9c3c1c0ffe89d48188a3fbd
+  concurrent-ruby (1.3.7) sha256=4412caec3a5ea2e5fdc52076724c071a81f2c0593d83b2ac8cbb8ca63b3151b0
   connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a
   drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
-  i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
-  json (2.19.3) sha256=289b0bb53052a1fa8c34ab33cc750b659ba14a5c45f3fcf4b18762dc67c78646
+  i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
+  json (2.21.1) sha256=13a43df75d95641443f5702dff350f237164a9d811ff0f2c2800d4d980220583
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   minitest (5.27.0) sha256=2d3b17f8a36fe7801c1adcffdbc38233b938eb0b4966e97a6739055a45fa77d5
-  rake (13.3.1) sha256=8c9e89d09f66a26a01264e7e3480ec0607f0c497a861ef16063604b1b08eb19c
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
-  sqlite3 (2.9.2-aarch64-linux-gnu) sha256=eeb86db55645b85327ba75129e3614658d974bf4da8fdc87018a0d42c59f6e42
-  sqlite3 (2.9.2-aarch64-linux-musl) sha256=4feff91fb8c2b13688da34b5627c9d1ed9cedb3ee87a7114ec82209147f07a6d
-  sqlite3 (2.9.2-arm-linux-gnu) sha256=1ee2eb06b5301aaf5ce343a6e88d99ac932d95202d7b350f0e7b6d8d588580d7
-  sqlite3 (2.9.2-arm-linux-musl) sha256=8ca0de6aceede968de0394e22e95d549834c4d8e318f69a92a52f049878a0057
-  sqlite3 (2.9.2-arm64-darwin) sha256=d15bd9609a05f9d54930babe039585efc8cadd57517c15b64ec7dfa75158a5e9
-  sqlite3 (2.9.2-x86-linux-gnu) sha256=066bc904522f8a7072236a81237c03a4a1dfe070a25107e392de03d1e4ad0e6d
-  sqlite3 (2.9.2-x86-linux-musl) sha256=6503c76278f5e8629b12b6518ff43a9a4f6d9381de73f0b086c9fa1226db5ede
-  sqlite3 (2.9.2-x86_64-darwin) sha256=ed691b5021674d72582d03c5a38e89634b961902735fb6225273892805421d13
-  sqlite3 (2.9.2-x86_64-linux-gnu) sha256=dce83ffcb7e72f9f7aeb6e5404f15d277a45332fe18ccce8a8b3ed51e8d23aee
-  sqlite3 (2.9.2-x86_64-linux-musl) sha256=e8dd906a613f13b60f6d47ae9dda376384d9de1ab3f7e3f2fdf2fd18a871a2d7
+  sqlite3 (2.9.5-aarch64-linux-gnu) sha256=78075b6337d3d182c6d2b4691049ed45cd220826160c9ea18946bf6a1de200dc
+  sqlite3 (2.9.5-aarch64-linux-musl) sha256=18c801185deb4adc01ddb281e8f672a39e3d1729979ca91e39439cd3eac0402d
+  sqlite3 (2.9.5-arm-linux-gnu) sha256=1bdfca0c7d63998c60b0f4a8e3c8df2d33800ccc4abd2d612eddbbbc92a4c48b
+  sqlite3 (2.9.5-arm-linux-musl) sha256=bae1109d12b2e9f588455967729b008e1ff4feb7761749df695019c9079913c6
+  sqlite3 (2.9.5-arm64-darwin) sha256=d0cf444a70fc9395d513cfbcc1e6719e224aa645314e3824cb0474c721425aa2
+  sqlite3 (2.9.5-x86-linux-gnu) sha256=c94b96b16f17796be6fa099d15218b52e396f55690c4760faaaefa21ebab9dd5
+  sqlite3 (2.9.5-x86-linux-musl) sha256=063a8c13cbadfe7f29453b1706cbdf91fca4a78d244f816ff20bac4fb259f1e4
+  sqlite3 (2.9.5-x86_64-darwin) sha256=8e9caae38bd7ebb29cbeee3e7ab1d12dc2327d9a1b92c7fcf0dda05589627a81
+  sqlite3 (2.9.5-x86_64-linux-gnu) sha256=233dbcb6714148dd23bc5aeb33e8efd6eac974969564ddd5794c23d5f52b231e
+  sqlite3 (2.9.5-x86_64-linux-musl) sha256=e7d3a7474e8af0f96150c21abc203fbab5437206bfcdf11deab7741c0ca516f2
   timeout (0.6.1) sha256=78f57368a7e7bbadec56971f78a3f5ecbcfb59b7fcbb0a3ed6ddc08a5094accb
   tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
   uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
-  yaml_exporter (0.2.0)
+  yaml_exporter (0.2.1)
 
 BUNDLED WITH
   4.0.6

data/README.md

@@ -112,7 +112,9 @@ The arguments you pass determine both the YAML shape and who owns the record:
 | `many :book_parts, find_by: :slug do … end`                           | list of hashes, matched by `slug`                                                                  |
 | `many :book_parts, find_by: :slug, positioned_by: :position do … end` | list of hashes, matched by `slug`; no `position:` key — the column is derived from the array index |
 | `many :authors, find_by: :slug`                                       | list of bare strings                                                                               |
+| `many :editorial_editors, find_by: :slug, of: :user`                  | list of bare strings, each resolved via a nested association on the target                          |
 | `many :reviewers, through: :book_reviewers, find_by: :slug`           | list of bare strings (join rows managed for you; add `positioned_by:` to derive a join column from order) |
+| `many :editorial_editors, through: :editor_assignments, find_by: :slug, of: :user` | list of bare strings, each resolved via a nested association on the target        |
 | `many :reviewers, through: :book_reviewers, find_by: :slug do … end`  | list of hashes describing join-model attributes                                                    |
 
 ### Lifecycle rules
@@ -349,6 +351,13 @@ This same flavor works for `has_and_belongs_to_many` (as above) and for any `has
 * If the database has more associations than the yaml file, the extra associations are removed — for HABTM only the join rows are removed, the referenced records themselves are left untouched.
 * The order of the entries in the yaml file doesn't matter.
 
+`of:` works on reference lists too, exactly as it does for [`one`](#one-with-find_by-and-of-indirect-reference) — the YAML value is a column on a companion record (`of:`) instead of on the target. It applies to both the plain and the `through:` reference list:
+
+```ruby
+many :corporate_reviewers, find_by: :slug, of: :user
+many :editorial_editors, through: :editor_assignments, find_by: :slug, of: :user
+```
+
 ### `many` with `through:` (has_many :through with join attributes)
 
 `has_many :through` is not a separate DSL method — how you expose it depends on whether the join model carries its own attributes.
@@ -793,9 +802,9 @@ A single related record. Exactly one of `find_by:` or a block must be given:
 
 Passing both a block and `find_by:` is rejected — see the ownership reasoning in [`one` with `find_by`](#one-with-find_by-reference).
 
-### `many(name, positioned_by: nil, find_by: nil, through: nil, &block)`
+### `many(name, positioned_by: nil, find_by: nil, through: nil, of: nil, &block)`
 
-A list of related records. The flavor is picked from the combination of `positioned_by:`, `find_by:`, `through:` and a block:
+A list of related records. The flavor is picked from the combination of `positioned_by:`, `find_by:`, `through:`, `of:` and a block:
 
 | Call                                                                             | YAML shape                                      | Meaning                                                                                                         |
 | -------------------------------------------------------------------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
@@ -804,10 +813,14 @@ A list of related records. The flavor is picked from the combination of `positio
 | `many :children, find_by: :slug do … end`                                        | list of hashes containing the `slug:` key       | Children fully managed, identity by a stable column.                                                            |
 | `many :children, find_by: :slug, positioned_by: :position do … end`              | same as above, without `position:` in each hash | Like the previous row, but the named column is derived from the 1-based array index (and omitted on export).    |
 | `many :children, find_by: :slug`                                                 | list of bare strings                            | Children referenced by key, managed elsewhere (HABTM pattern).                                                  |
+| `many :children, find_by: :slug, of: :companion`                                 | list of bare strings                            | Reference list keyed indirectly: each value lives on a `companion` (1:[0,1]) association of the target.         |
 | `many :children, through: :joins, find_by: :slug do … end`                       | list of hashes containing the `slug:` key       | `has_many :through` where the block describes attributes of the **join model**.                                 |
 | `many :children, through: :joins, find_by: :slug, positioned_by: :position do …` | same as above, without `position:` in each hash | As above, with the position column derived on the **join model**.                                               |
+| `many :children, through: :joins, find_by: :slug, of: :companion`                | list of bare strings                            | Join-model reference list keyed indirectly via the target's `companion` association (`positioned_by:` optional).|
+
+`positioned_by:` requires a block – there must be an owned record to write the column onto – and therefore cannot be used with the plain reference-list flavor of `many` (it *is* allowed on the `through:` reference list, where it drives the join's position column).
 
-`positioned_by:` requires a block – there must be an owned record to write the column onto – and therefore cannot be used with the reference-list flavor of `many`.
+`of:` requires `find_by:` and cannot be combined with a block, and the `of:` association must be a 1:[0,1] relation (`belongs_to` or `has_one`) — same rules and semantics as [`one … of:`](#one-with-find_by-and-of-indirect-reference).
 
 ### Import / export
 

data/lib/yaml_exporter/builder.rb

@@ -49,7 +49,17 @@ module YamlExporter
       end
     end
 
-    def many(name, find_by: nil, through: nil, positioned_by: nil, &block)
+    def many(name, find_by: nil, through: nil, positioned_by: nil, of: nil, &block)
+      if of && !find_by
+        raise ArgumentError,
+              "`many #{name.inspect}`: of: requires find_by:."
+      end
+      if of && block
+        raise ArgumentError,
+              "`many #{name.inspect}`: of: cannot combine with a block — of: only applies to " \
+              'reference lists (no block).'
+      end
+
       if through
         unless find_by
           raise ArgumentError,
@@ -61,7 +71,7 @@ module YamlExporter
         # the YAML order). The join row itself is always managed by the DSL.
         @nodes << Nodes::ManyThrough.new(
           name: name, owner_class: klass, through: through, find_by: find_by,
-          positioned_by: positioned_by, &block
+          positioned_by: positioned_by, of: of, &block
         )
       elsif positioned_by && !block
         raise ArgumentError,
@@ -76,7 +86,7 @@ module YamlExporter
           name: name, owner_class: klass, positioned_by: positioned_by, &block
         )
       elsif find_by
-        @nodes << Nodes::ManyReference.new(name: name, owner_class: klass, find_by: find_by)
+        @nodes << Nodes::ManyReference.new(name: name, owner_class: klass, find_by: find_by, of: of)
       else
         raise ArgumentError,
               "`many #{name.inspect}`: pass either find_by: (reference list), a block (owned), " \

data/lib/yaml_exporter/nodes/many_reference.rb

@@ -7,19 +7,29 @@ module YamlExporter
     # an existing target record via `find_by`. Target records are never
     # created or mutated; only the association is updated.
     #
+    # With `of:` the value is resolved indirectly through a 1:[0,1]
+    # association on the target (see OfResolution), so the YAML lists the
+    # find_by value of a *related* model (e.g. the user slug behind each
+    # target) rather than a column on the target itself.
+    #
     # Phase: :post_save (join rows / FK need parent.id).
     class ManyReference
-      attr_reader :name, :owner_class, :find_by
+      include OfResolution
+
+      attr_reader :name, :owner_class, :find_by, :of
 
-      def initialize(name:, owner_class:, find_by:)
+      def initialize(name:, owner_class:, find_by:, of: nil)
         @name = name.to_sym
         @owner_class = owner_class
         @find_by = find_by.to_sym
+        @of = of&.to_sym
         reflection = owner_class.reflect_on_association(@name)
         unless reflection
           raise ArgumentError,
                 "`many #{name.inspect}`: #{owner_class} has no association `#{name}`"
         end
+
+        validate_of_reflection!("many #{name.inspect}") if @of
       end
 
       def phase
@@ -44,9 +54,8 @@ module YamlExporter
         end
 
         targets = values.map do |value|
-          target_class.find_by(@find_by => value) ||
-            (raise ActiveRecord::RecordNotFound,
-                   "no #{target_class} with #{@find_by}=#{value.inspect}")
+          resolve_target(value) ||
+            (raise ActiveRecord::RecordNotFound, not_found_message(value))
         end
 
         record.public_send("#{@name}=", targets)
@@ -54,17 +63,34 @@ module YamlExporter
 
       def export(record, exporter:)
         targets = Array(record.public_send(@name))
-        keys = targets.map { |t| t.public_send(@find_by) }.sort
+        keys = targets.map { |t| key_for(t) }.compact.sort
         [@name.to_s, keys]
       end
 
       def schema_fragment
-        item_type = TypeInference.schema_type_for(target_class, @find_by)
+        key_class = @of ? of_class : target_class
+        item_type = TypeInference.schema_type_for(key_class, @find_by)
         { @name => { type: 'array', items: { type: item_type } } }
       end
 
       private
 
+      def resolve_target(value)
+        @of ? resolve_target_by_of(value) : target_class.find_by(@find_by => value)
+      end
+
+      def key_for(target)
+        @of ? of_value_for(target) : target.public_send(@find_by)
+      end
+
+      def not_found_message(value)
+        if @of
+          "no #{target_class} for #{of_class} with #{@find_by}=#{value.inspect} via `#{@of}`"
+        else
+          "no #{target_class} with #{@find_by}=#{value.inspect}"
+        end
+      end
+
       def describe_path(path)
         path.empty? ? @name.to_s : "#{path}.#{@name}"
       end

data/lib/yaml_exporter/nodes/many_through.rb

@@ -16,15 +16,18 @@ module YamlExporter
     # the reference flavor: passing a block (empty or not) opts into the
     # hash-shaped entries, same as the other `many` flavors.
     class ManyThrough < ManyBase
-      attr_reader :through
+      include OfResolution
 
-      def initialize(name:, owner_class:, through:, find_by:, positioned_by: nil, &block)
+      attr_reader :through, :of
+
+      def initialize(name:, owner_class:, through:, find_by:, positioned_by: nil, of: nil, &block)
         # Whether a block was passed (even an empty one) decides the YAML
         # shape: block → hash entries, no block → bare reference list.
         @reference_list = block.nil?
         block ||= proc {}
 
         @through = through.to_sym
+        @of = of&.to_sym
         join_reflection = owner_class.reflect_on_association(@through)
         unless join_reflection
           raise ArgumentError,
@@ -33,6 +36,8 @@ module YamlExporter
 
         super(name: name, owner_class: owner_class, find_by: find_by,
               positioned_by: positioned_by, &block)
+
+        validate_of_reflection!("many #{name.inspect}") if @of
       end
 
       # No block was passed → the YAML is a flat list of find_by values
@@ -63,10 +68,9 @@ module YamlExporter
 
       def find_or_build_child(parent, entry, _index, existing:)
         key = entry[@find_by.to_s]
-        target = target_class.find_by(@find_by => key)
+        target = @of ? resolve_target_by_of(key) : target_class.find_by(@find_by => key)
         unless target
-          raise ActiveRecord::RecordNotFound,
-                "no #{target_class} with #{@find_by}=#{key.inspect}"
+          raise ActiveRecord::RecordNotFound, not_found_message(key)
         end
 
         # Match existing join rows by comparing the source association
@@ -87,7 +91,7 @@ module YamlExporter
       def default_export_order(records)
         records.sort_by do |join|
           target = join.public_send(source_association_name)
-          target.public_send(@find_by).to_s
+          key_for(target).to_s
         end
       end
 
@@ -96,7 +100,7 @@ module YamlExporter
       def export(parent, exporter:)
         records = sort_for_export(Array(parent.public_send(@through)))
         if reference_list?
-          keys = records.map { |join| join.public_send(source_association_name).public_send(@find_by) }
+          keys = records.map { |join| key_for(join.public_send(source_association_name)) }
           return [@name.to_s, keys]
         end
 
@@ -158,12 +162,27 @@ module YamlExporter
       def schema_fragment
         return super unless reference_list?
 
-        item_type = TypeInference.schema_type_for(target_class, @find_by)
+        key_class = @of ? of_class : target_class
+        item_type = TypeInference.schema_type_for(key_class, @find_by)
         { @name => { type: 'array', items: { type: item_type } } }
       end
 
       private
 
+      # The YAML value for a resolved target: with `of:` it lives on a related
+      # model; otherwise it's the find_by column on the target itself.
+      def key_for(target)
+        @of ? of_value_for(target) : target.public_send(@find_by)
+      end
+
+      def not_found_message(key)
+        if @of
+          "no #{target_class} for #{of_class} with #{@find_by}=#{key.inspect} via `#{@of}`"
+        else
+          "no #{target_class} with #{@find_by}=#{key.inspect}"
+        end
+      end
+
       def source_reflection
         @source_reflection ||= @owner_class.reflect_on_association(@name).source_reflection
       end

data/lib/yaml_exporter/nodes/of_resolution.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module YamlExporter
+  module Nodes
+    # Shared `of:` navigation for reference nodes that identify their target
+    # indirectly: the YAML value names a column on a *related* model
+    # (`of:`) reachable from the target, not on the target itself.
+    #
+    # Example: a reviewer target is a CorporateUser, and
+    # CorporateUser `belongs_to :user` (a User with a slug). Declaring
+    # `find_by: :slug, of: :user` stores the User's slug in the YAML and, on
+    # import, resolves the User first and then reverses `of:` back to the
+    # CorporateUser.
+    #
+    # Mixed into OneReferenceOf, ManyReference and ManyThrough. The host must
+    # provide `target_class` and set `@find_by` and `@of` (both symbols).
+    module OfResolution
+      # The related model that actually carries the find_by column
+      # (CorporateUser.user -> User).
+      def of_reflection
+        @of_reflection ||= target_class.reflect_on_association(@of)
+      end
+
+      # The class of the related model (CorporateUser.user -> User).
+      def of_class
+        @of_class ||= of_reflection.klass
+      end
+
+      # Resolve a single YAML value to a target record: find the related
+      # record by find_by, then reverse `of:` back to the target. Returns nil
+      # if either lookup misses.
+      def resolve_target_by_of(value)
+        related = of_class.find_by(@find_by => value)
+        return nil unless related
+
+        find_target_via(related)
+      end
+
+      # Navigate from a resolved related record back to the target.
+      #
+      # belongs_to (:user on CorporateUser): FK is on the target.
+      #   target_class.find_by(user_id: related.id)
+      # has_one (:profile on CorporateUser): FK is on the related record.
+      #   target_class.find_by(id: related.corporate_user_id)
+      def find_target_via(related)
+        if of_reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+          pk_val = related.public_send(of_reflection.association_primary_key)
+          target_class.find_by(of_reflection.foreign_key => pk_val)
+        else # has_one
+          fk_val = related.public_send(of_reflection.foreign_key)
+          target_class.find_by(of_reflection.association_primary_key => fk_val)
+        end
+      end
+
+      # The YAML value for a target: the find_by column on its `of:` relation.
+      # nil when the target has no related record (can't be represented).
+      def of_value_for(target)
+        related = target.public_send(@of)
+        related&.public_send(@find_by)
+      end
+
+      # Declaration-time check: `of:` must name a 1:[0,1] association on the
+      # target. Raises ArgumentError at class load otherwise.
+      def validate_of_reflection!(node_label)
+        of_ref = target_class.reflect_on_association(@of)
+        unless of_ref
+          raise ArgumentError,
+                "`#{node_label}, of: #{@of.inspect}`: #{target_class} has no association `#{@of}`"
+        end
+
+        return if singular_of_association?(of_ref)
+
+        raise ArgumentError,
+              "`#{node_label}, of: #{@of.inspect}`: `of:` must be a 1:[0,1] association " \
+              "(belongs_to or has_one); got #{of_ref.macro}"
+      end
+
+      def singular_of_association?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) ||
+          reflection.is_a?(ActiveRecord::Reflection::HasOneReflection)
+      end
+    end
+  end
+end

data/lib/yaml_exporter/nodes/one_reference_of.rb

@@ -16,6 +16,8 @@ module YamlExporter
     # Only 1:[0,1] `of:` associations are permitted (belongs_to or has_one).
     # Phase: :pre_save (sets the FK before record.save!).
     class OneReferenceOf
+      include OfResolution
+
       attr_reader :name, :owner_class, :find_by, :of
 
       def initialize(name:, owner_class:, find_by:, of:)
@@ -30,17 +32,7 @@ module YamlExporter
                 "`one #{name.inspect}`: #{owner_class} has no association `#{name}`"
         end
 
-        of_ref = target_class.reflect_on_association(@of)
-        unless of_ref
-          raise ArgumentError,
-                "`one #{name.inspect}, of: #{of.inspect}`: #{target_class} has no association `#{of}`"
-        end
-
-        unless singular_association?(of_ref)
-          raise ArgumentError,
-                "`one #{name.inspect}, of: #{of.inspect}`: `of:` must be a 1:[0,1] association " \
-                "(belongs_to or has_one); got #{of_ref.macro}"
-        end
+        validate_of_reflection!("one #{name.inspect}")
       end
 
       def phase
@@ -63,16 +55,16 @@ module YamlExporter
           return
         end
 
-        through = through_class.find_by(@find_by => value)
-        unless through
+        related = of_class.find_by(@find_by => value)
+        unless related
           raise ActiveRecord::RecordNotFound,
-                "no #{through_class} with #{@find_by}=#{value.inspect}"
+                "no #{of_class} with #{@find_by}=#{value.inspect}"
         end
 
-        target = find_target_via(through)
+        target = find_target_via(related)
         unless target
           raise ActiveRecord::RecordNotFound,
-                "no #{target_class} linked to #{through_class} #{@find_by}=#{value.inspect} via `#{@of}`"
+                "no #{target_class} linked to #{of_class} #{@find_by}=#{value.inspect} via `#{@of}`"
         end
 
         record.public_send("#{@name}=", target)
@@ -82,46 +74,11 @@ module YamlExporter
         target = record.public_send(@name)
         return [@name.to_s, nil] if target.nil?
 
-        through = target.public_send(@of)
-        return [@name.to_s, nil] if through.nil?
-
-        [@name.to_s, through.public_send(@find_by)]
+        [@name.to_s, of_value_for(target)]
       end
 
       def schema_fragment
-        { @name => { type: TypeInference.schema_type_for(through_class, @find_by) } }
-      end
-
-      private
-
-      def of_reflection
-        @of_reflection ||= target_class.reflect_on_association(@of)
-      end
-
-      def through_class
-        @through_class ||= of_reflection.klass
-      end
-
-      # Navigate from a resolved `through` record back to the target.
-      #
-      # belongs_to (:user on CorporateUser): FK is on the target.
-      #   target_class.find_by(user_id: through.id)
-      #
-      # has_one (:profile on CorporateUser): FK is on the through record.
-      #   target_class.find_by(id: through.corporate_user_id)
-      def find_target_via(through)
-        if of_reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-          pk_val = through.public_send(of_reflection.association_primary_key)
-          target_class.find_by(of_reflection.foreign_key => pk_val)
-        else # has_one
-          fk_val = through.public_send(of_reflection.foreign_key)
-          target_class.find_by(of_reflection.association_primary_key => fk_val)
-        end
-      end
-
-      def singular_association?(reflection)
-        reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) ||
-          reflection.is_a?(ActiveRecord::Reflection::HasOneReflection)
+        { @name => { type: TypeInference.schema_type_for(of_class, @find_by) } }
       end
     end
   end

data/lib/yaml_exporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YamlExporter
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/lib/yaml_exporter.rb

@@ -63,6 +63,7 @@ require 'yaml'
 require_relative 'yaml_exporter/structure'
 require_relative 'yaml_exporter/type_inference'
 require_relative 'yaml_exporter/nodes/attribute'
+require_relative 'yaml_exporter/nodes/of_resolution'
 require_relative 'yaml_exporter/nodes/one_owned'
 require_relative 'yaml_exporter/nodes/one_reference'
 require_relative 'yaml_exporter/nodes/one_reference_of'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml_exporter
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Anatoly Zelenin
@@ -108,6 +108,7 @@ files:
 - lib/yaml_exporter/nodes/many_positional.rb
 - lib/yaml_exporter/nodes/many_reference.rb
 - lib/yaml_exporter/nodes/many_through.rb
+- lib/yaml_exporter/nodes/of_resolution.rb
 - lib/yaml_exporter/nodes/one_owned.rb
 - lib/yaml_exporter/nodes/one_reference.rb
 - lib/yaml_exporter/nodes/one_reference_of.rb