namo 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07d3c62244d72800b8f533d4618c8f51b4161338c37dc439ad26f67557a7315f
-  data.tar.gz: 7b8c6c808068b97555bb8f98a1d1ecb55a399e16fc51e475b61f13cbad4f0cef
+  metadata.gz: e6342f1cab3b5811a97d92be8ef7ba34a81191bd97a6ee2c606f8adc7d9a0d47
+  data.tar.gz: ce7db23d2907e33a80d1e263b4b9987645a6c1c47979b7f3311bf519d8f9e738
 SHA512:
-  metadata.gz: 58db7e089c9a6be6e9d050a549cf5df98983227d3a3d218d0d5f61ee2684009a1af5f4069cb16376fe8211425060fe2b1d609fb5b6770236726782fa57a35b20
-  data.tar.gz: a4327a3484ffc1b30755ed38f94c2e432f0d6e338f5348a75b854c1cdebcfedebab4a742441d5e542c832d4a0aa517dc67a51f8b926462f2c0ab4ecad4a990d8
+  metadata.gz: 5c6c26eda0a637af215eef9cab0fe369769af3e945b3a1cf980788bd34be97abeefb3cf29fb208012556c5df9e46c212c9476dc222b0f3917404c7db3003f21a
+  data.tar.gz: f71fd3ed7b8e8068b55fbb8379cd361c91c84ca1cb4fe823ff72af9fe1c9b8e1247468fb9fd818aa865cac709aa2d22e63f2c866030cacee22bf25c5930e7758

data/CHANGELOG

@@ -1,6 +1,32 @@
 CHANGELOG
 _________
 
+20260626
+0.22.0: + Formulae#derive — move formula invocation out of Row#[] and into Formulae. [] keeps its meaning (the stored callable, as at 0.21.0); the new derive(name, row, namo, *arguments) resolves a named formula to its value. derive over call: the receiver is the collection, not the callable, so the verb says the collection derives a value via the named rule rather than borrowing Proc#call's "invoke the receiver"; and the result is whatever the proc returns, not necessarily numeric, which a neutral verb leaves open. Indexing a Formulae is storage access, not a Namo operation, so [] returning the callable carries no inconsistency with the dimension-value [] of Namo and Row — different domains, same spelling. Behaviour-preserving at the usage level: row[:revenue], namo[:x] = formula, values, and selections are unchanged.
+
+1. ~ lib/Namo/Formulae.rb: + derive(name, row, namo, *arguments), the formula resolver —
+   invocation mechanics lifted whole from Row's formula branch (collection-scoped formulae
+   are called (row, namo, *arguments), row-only formulae (row)). + required_parameter_count(name),
+   public, a property of the stored callable. collection_scoped? and raise_unless_namo_context
+   move in as private; the latter takes namo as a parameter rather than closing over Row's
+   @namo. [] and []= are untouched — [] still returns the stored callable.
+2. ~ lib/Namo/Row.rb: #[] delegates formula resolution to
+   @formulae.derive(name, self, @namo, *arguments); Row keeps only the fail-fast argument
+   guard, the formula-vs-data dispatch (@formulae.key?), and the data fallback (@row[name]).
+   collection_scoped?, required_parameter_count, and raise_unless_namo_context are gone
+   (now Formulae's). expected_argument_counts sources the count from
+   @formulae.required_parameter_count and the fixed-vs-variadic check from
+   @formulae[name].arity.
+3. + test/Namo/Formulae_test.rb: + #derive tests (row-only to value, collection-scoped with
+   namo context, missing-namo-context raise, parameterised with arguments) and +
+   #required_parameter_count tests (row-only, collection-scoped, parameterised, variadic).
+   The #[] and #[]= blocks are unchanged — [] still returns the callable.
+4. ~ test/Namo/Row_test.rb: the formulae fixture is a Namo::Formulae, not a bare {} — Row
+   now delegates formula resolution to its collaborator (call, required_parameter_count),
+   which production always wraps (lib/namo.rb initialize). The data-only equality/match
+   tests keep their {} literals: they never resolve a formula, so Hash#key? alone answers.
+5. ~ Namo::VERSION: /0.21.0/0.22.0/
+
 20260625
 0.21.0: + Namo::Formulae; @formulae: /Hash/Namo::Formulae/. Behaviour-preserving: no new capability, just an object for the formula collection to accrete behaviour onto later, mirroring the 0.1.0 extraction of Row.
 

data/lib/Namo/Formulae.rb

@@ -13,6 +13,21 @@ class Namo
       @store[name] = callable
     end
 
+    def derive(name, row, namo, *arguments)
+      formula = self[name]
+      if collection_scoped?(name)
+        raise_unless_namo_context(name, namo)
+        formula.call(row, namo, *arguments)
+      else
+        formula.call(row)
+      end
+    end
+
+    def required_parameter_count(name)
+      formula = self[name]
+      formula.arity >= 0 ? formula.arity : -formula.arity - 1
+    end
+
     def keys
       @store.keys
     end
@@ -67,5 +82,15 @@ class Namo
     def initialize(store = {})
       @store = store
     end
+
+    def collection_scoped?(name)
+      required_parameter_count(name) >= 2
+    end
+
+    def raise_unless_namo_context(name, namo)
+      unless namo
+        raise ArgumentError, "collection-scoped formula #{name.inspect} requires a Namo context, but this Row has none"
+      end
+    end
   end
 end

data/lib/Namo/Row.rb

@@ -6,13 +6,7 @@ class Namo
     def [](name, *arguments)
       raise_unless_expected_arguments(name, arguments)
       if @formulae.key?(name)
-        formula = @formulae[name]
-        if collection_scoped?(formula)
-          raise_unless_namo_context(name)
-          formula.call(self, @namo, *arguments)
-        else
-          formula.call(self)
-        end
+        @formulae.derive(name, self, @namo, *arguments)
       else
         @row[name]
       end
@@ -57,19 +51,12 @@ class Namo
       @namo = namo
     end
 
-    def collection_scoped?(formula)
-      required_parameter_count(formula) >= 2
-    end
-
-    def required_parameter_count(formula)
-      formula.arity >= 0 ? formula.arity : -formula.arity - 1
-    end
-
     def expected_argument_counts(name)
-      formula = @formulae[name]
-      return [0, 0] unless formula && collection_scoped?(formula)
-      minimum = required_parameter_count(formula) - 2
-      maximum = formula.arity >= 0 ? minimum : nil
+      return [0, 0] unless @formulae.key?(name)
+      count = @formulae.required_parameter_count(name)
+      return [0, 0] unless count >= 2
+      minimum = count - 2
+      maximum = @formulae[name].arity >= 0 ? minimum : nil
       [minimum, maximum]
     end
 
@@ -79,11 +66,5 @@ class Namo
       expected = maximum.nil? ? "#{minimum}+" : minimum.to_s
       raise ArgumentError, "wrong number of arguments for #{name.inspect} (given #{arguments.length}, expected #{expected})"
     end
-
-    def raise_unless_namo_context(name)
-      unless @namo
-        raise ArgumentError, "collection-scoped formula #{name.inspect} requires a Namo context, but this Row has none"
-      end
-    end
   end
 end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.21.0'
+  VERSION = '0.22.0'
 end

data/test/Namo/Formulae_test.rb

@@ -26,6 +26,54 @@ describe Namo::Formulae do
     end
   end
 
+  describe "#derive" do
+    let(:row) do
+      {price: 10.0, quantity: 100}
+    end
+
+    it "resolves a row-only formula to its value" do
+      _(formulae.derive(:revenue, row, nil)).must_equal 1000.0
+    end
+
+    it "resolves a collection-scoped formula with the namo context" do
+      namo = Object.new
+      formulae[:context] = ->(r, n){n}
+      _(formulae.derive(:context, row, namo)).must_be_same_as namo
+    end
+
+    it "raises ArgumentError naming the formula when a collection-scoped formula has no namo context" do
+      formulae[:context] = ->(r, n){n}
+      error = _(proc{formulae.derive(:context, row, nil)}).must_raise ArgumentError
+      _(error.message).must_match(/context/)
+    end
+
+    it "resolves a parameterised formula with arguments" do
+      formulae[:scaled] = ->(r, n, factor){r[:price] * factor}
+      _(formulae.derive(:scaled, row, Object.new, 3)).must_equal 30.0
+    end
+  end
+
+  describe "#required_parameter_count" do
+    it "counts a row-only formula" do
+      _(formulae.required_parameter_count(:revenue)).must_equal 1
+    end
+
+    it "counts a collection-scoped formula" do
+      formulae[:context] = ->(r, n){n}
+      _(formulae.required_parameter_count(:context)).must_equal 2
+    end
+
+    it "counts a parameterised formula" do
+      formulae[:scaled] = ->(r, n, factor){r[:price] * factor}
+      _(formulae.required_parameter_count(:scaled)).must_equal 3
+    end
+
+    it "excludes the splat when counting a variadic formula" do
+      formulae[:variadic] = ->(r, n, *rest){rest}
+      _(formulae.required_parameter_count(:variadic)).must_equal 2
+    end
+  end
+
   describe "#[]=" do
     it "stores a callable under a name" do
       formulae[:cost] = cost

data/test/Namo/Row_test.rb

@@ -10,7 +10,7 @@ describe Namo::Row do
   end
 
   let(:formulae) do
-    {}
+    Namo::Formulae.new
   end
 
   let(:row) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - thoran