namo 0.20.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae1731b55ec8d0de8dedfb35fc643f6fb6a68e72bb3464c4139242c1bc6bb91e
-  data.tar.gz: 161a1842a4daf8a4365a8420600f2824f5f15fd2ea3951e18d00d811eec22010
+  metadata.gz: e6342f1cab3b5811a97d92be8ef7ba34a81191bd97a6ee2c606f8adc7d9a0d47
+  data.tar.gz: ce7db23d2907e33a80d1e263b4b9987645a6c1c47979b7f3311bf519d8f9e738
 SHA512:
-  metadata.gz: 4a563c97ca83b91e578375af09e533f633d2ed2d6bca1152297d3bf4b24dc60c5f25a5679e0e87023e3031f5019b3c32e825f35f23b75b0259cee6fb765a02b5
-  data.tar.gz: 140f9b808a8f406ca1ca16611ab776544c332830353f1d9dba58d4cf3578ff746d2ff7788671fd9eda0c082d6cc3f1457f29ee38473d88ec2c1f0aa457a0dace
+  metadata.gz: 5c6c26eda0a637af215eef9cab0fe369769af3e945b3a1cf980788bd34be97abeefb3cf29fb208012556c5df9e46c212c9476dc222b0f3917404c7db3003f21a
+  data.tar.gz: f71fd3ed7b8e8068b55fbb8379cd361c91c84ca1cb4fe823ff72af9fe1c9b8e1247468fb9fd818aa865cac709aa2d22e63f2c866030cacee22bf25c5930e7758

data/CHANGELOG

@@ -1,6 +1,57 @@
 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.
+
+1. + lib/Namo/Formulae.rb: + Namo::Formulae, a thin class wrapping a Hash @store.
+   Responds to exactly the subset of Hash that lib/namo.rb and Row send the formula
+   collection: [], []=, keys, key?, empty?, each, delete, merge, reject, dup; includes
+   Enumerable (each yields [name, callable] pairs, giving map/select/etc. for free).
+   Three deliberate choices: to_h returns a copy (@store.dup) so callers cannot mutate
+   internals; ==/eql?/hash are names-only (keys.sort), matching Namo's own formula
+   equality where two sets with the same names but different proc objects are equivalent;
+   merge/reject/dup return a Formulae, not a Hash.
+2. ~ lib/namo.rb: + the require; initialize now normalises the incoming formulae to a
+   Formulae (Formulae.new(formulae) unless already one). This is the single behavioural
+   seam — every existing internal construction passes a Hash and is wrapped, while
+   operator results that now pass a Formulae (merge/dup return Formulae) pass through.
+   No other call site changed: each sends a message Formulae answers.
+3. ~ test/namo_test.rb: the two assertions comparing the public #formulae accessor to a
+   literal {} now assert emptiness (must_be_empty). The accessor returns a Formulae, not a
+   Hash; the formula set being empty is the unchanged behaviour these tests pin. + two
+   construction tests pinning the normalisation seam: a Hash given by keyword is wrapped in
+   a Formulae, and a Formulae given by keyword passes through unchanged (same object).
+4. + test/Namo/Formulae_test.rb: + unit test pinning the three deliberate choices (to_h
+   copy, names-only ==/eql?/hash, the Hash-compatible surface plus Enumerable map/select).
+5. ~ Namo::VERSION: /0.20.0/0.21.0/
+
 20260615
 0.20.0: + group_by(dimension) — splits a Namo into a Namo::Collection, one member per distinct value, completing the Enumerable coherence pass begun at 0.11.0.
 

data/lib/Namo/Formulae.rb

@@ -0,0 +1,96 @@
+# Namo/Formulae.rb
+# Namo::Formulae
+
+class Namo
+  class Formulae
+    include Enumerable
+
+    def [](name)
+      @store[name]
+    end
+
+    def []=(name, callable)
+      @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
+
+    def key?(name)
+      @store.key?(name)
+    end
+
+    def empty?
+      @store.empty?
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      @store.each(&block)
+    end
+
+    def delete(name)
+      @store.delete(name)
+    end
+
+    def merge(other)
+      self.class.new(@store.merge(other.to_h))
+    end
+
+    def reject(&block)
+      self.class.new(@store.reject(&block))
+    end
+
+    def dup
+      self.class.new(@store.dup)
+    end
+
+    def to_h
+      @store.dup
+    end
+
+    def ==(other)
+      other.is_a?(Formulae) && keys.sort == other.keys.sort
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      keys.sort.hash
+    end
+
+    private
+
+    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.20.0'
+  VERSION = '0.22.0'
 end

data/lib/namo.rb

@@ -2,6 +2,7 @@
 # Namo
 
 require_relative './Namo/NegatedDimension'
+require_relative './Namo/Formulae'
 require_relative './Namo/Row'
 require_relative './Namo/Collection'
 require_relative './Namo/Enumerable'
@@ -235,7 +236,7 @@ class Namo
 
   def initialize(positional_data = nil, data: [], formulae: {}, name: nil)
     @data = positional_data || data
-    @formulae = formulae
+    @formulae = formulae.is_a?(Formulae) ? formulae : Formulae.new(formulae)
     @name = name
   end
 

data/test/Namo/Formulae_test.rb

@@ -0,0 +1,211 @@
+require 'minitest/autorun'
+require 'minitest-spec-context'
+
+require_relative '../../lib/namo'
+
+describe Namo::Formulae do
+  let(:revenue) do
+    proc{|r| r[:price] * r[:quantity]}
+  end
+
+  let(:cost) do
+    proc{|r| r[:quantity] * 4.0}
+  end
+
+  let(:formulae) do
+    Namo::Formulae.new({revenue: revenue})
+  end
+
+  describe "#[]" do
+    it "returns the callable stored under a name" do
+      _(formulae[:revenue]).must_be_same_as revenue
+    end
+
+    it "returns nil for an absent name" do
+      _(formulae[:missing]).must_be_nil
+    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
+      _(formulae[:cost]).must_be_same_as cost
+    end
+  end
+
+  describe "#keys" do
+    it "returns the stored names" do
+      _(formulae.keys).must_equal [:revenue]
+    end
+  end
+
+  describe "#key?" do
+    it "is true for a stored name" do
+      _(formulae.key?(:revenue)).must_equal true
+    end
+
+    it "is false for an absent name" do
+      _(formulae.key?(:missing)).must_equal false
+    end
+  end
+
+  describe "#empty?" do
+    it "is true with no formulae" do
+      _(Namo::Formulae.new).must_be_empty
+    end
+
+    it "is false with formulae" do
+      _(formulae.empty?).must_equal false
+    end
+  end
+
+  describe "#each" do
+    it "yields name/callable pairs" do
+      yielded = {}
+      formulae.each{|name, callable| yielded[name] = callable}
+      _(yielded).must_equal({revenue: revenue})
+    end
+
+    it "returns an enumerator with no block" do
+      _(formulae.each).must_be_kind_of Enumerator
+    end
+  end
+
+  describe "#delete" do
+    it "removes a name" do
+      formulae.delete(:revenue)
+      _(formulae.key?(:revenue)).must_equal false
+    end
+  end
+
+  describe "#merge" do
+    it "returns a Formulae combining both sets" do
+      merged = formulae.merge(Namo::Formulae.new({cost: cost}))
+      _(merged).must_be_kind_of Namo::Formulae
+      _(merged.keys.sort).must_equal [:cost, :revenue]
+    end
+
+    it "lets the argument win on a name conflict" do
+      other = proc{|r| 0}
+      merged = formulae.merge(Namo::Formulae.new({revenue: other}))
+      _(merged[:revenue]).must_be_same_as other
+    end
+
+    it "does not mutate the receiver" do
+      formulae.merge(Namo::Formulae.new({cost: cost}))
+      _(formulae.keys).must_equal [:revenue]
+    end
+  end
+
+  describe "#reject" do
+    it "returns a Formulae without the rejected names" do
+      formulae[:cost] = cost
+      rejected = formulae.reject{|name, _| name == :cost}
+      _(rejected).must_be_kind_of Namo::Formulae
+      _(rejected.keys).must_equal [:revenue]
+    end
+  end
+
+  describe "#dup" do
+    it "returns an independent Formulae" do
+      copy = formulae.dup
+      copy[:cost] = cost
+      _(formulae.key?(:cost)).must_equal false
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a copy, not the live store" do
+      hash = formulae.to_h
+      hash[:cost] = cost
+      _(formulae.key?(:cost)).must_equal false
+    end
+  end
+
+  describe "Enumerable" do
+    it "supports map over name/callable pairs" do
+      _(formulae.map{|name, _| name}).must_equal [:revenue]
+    end
+
+    it "supports select returning name/callable pairs" do
+      formulae[:cost] = cost
+      _(formulae.select{|name, _| name == :cost}).must_equal [[:cost, cost]]
+    end
+  end
+
+  describe "value semantics" do
+    it "is == when names match, regardless of proc objects" do
+      _(Namo::Formulae.new({revenue: revenue})).must_equal Namo::Formulae.new({revenue: proc{|r| 0}})
+    end
+
+    it "is not == when names differ" do
+      _(formulae).wont_equal Namo::Formulae.new({cost: cost})
+    end
+
+    it "is not == to a bare Hash" do
+      _(formulae).wont_equal({revenue: revenue})
+    end
+
+    it "is eql? on matching names with differing procs" do
+      _(Namo::Formulae.new({revenue: revenue}).eql?(Namo::Formulae.new({revenue: proc{|r| 0}}))).must_equal true
+    end
+
+    it "hashes equal on matching names with differing procs" do
+      _(Namo::Formulae.new({revenue: revenue}).hash).must_equal Namo::Formulae.new({revenue: proc{|r| 0}}).hash
+    end
+  end
+
+  describe "constructor" do
+    it "defaults to an empty store" do
+      _(Namo::Formulae.new.keys).must_equal []
+    end
+  end
+end

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

data/test/namo_test.rb

@@ -47,7 +47,7 @@ describe Namo do
     it "produces an empty Namo with no arguments" do
       namo = Namo.new
       _(namo.data).must_equal []
-      _(namo.formulae).must_equal({})
+      _(namo.formulae).must_be_empty
     end
 
     it "accepts keyword formulae with no data" do
@@ -56,6 +56,17 @@ describe Namo do
       _(namo.derived_dimensions).must_equal [:y]
     end
 
+    it "wraps keyword formulae given as a Hash in a Formulae" do
+      namo = Namo.new(formulae: {y: proc{|r| r[:x] * 2}})
+      _(namo.formulae).must_be_kind_of Namo::Formulae
+      _(namo.formulae.keys).must_equal [:y]
+    end
+
+    it "passes keyword formulae already given as a Formulae through unchanged" do
+      formulae = Namo::Formulae.new({y: proc{|r| r[:x] * 2}})
+      _(Namo.new(formulae: formulae).formulae).must_be_same_as formulae
+    end
+
     it "honours an explicit empty positional array over the nil sentinel" do
       _(Namo.new([]).data).must_equal []
     end
@@ -1010,7 +1021,7 @@ describe Namo do
         prices[:sma] = sma
         projected = prices[:sma]
         _(projected.to_a).must_equal [{sma: 10.0}, {sma: 15.0}, {sma: 20.0}]
-        _(projected.formulae).must_equal({})
+        _(projected.formulae).must_be_empty
       end
 
       it "returns an instance of self's class" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.22.0
 platform: ruby
 authors:
 - thoran
@@ -66,6 +66,7 @@ files:
 - Rakefile
 - lib/Namo/Collection.rb
 - lib/Namo/Enumerable.rb
+- lib/Namo/Formulae.rb
 - lib/Namo/NegatedDimension.rb
 - lib/Namo/Row.rb
 - lib/Namo/VERSION.rb
@@ -73,6 +74,7 @@ files:
 - lib/namo.rb
 - namo.gemspec
 - test/Namo/Collection_test.rb
+- test/Namo/Formulae_test.rb
 - test/Namo/NegatedDimension_test.rb
 - test/Namo/Row_test.rb
 - test/Symbol_test.rb
@@ -95,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Named dimensional data for Ruby.
 test_files: []