namo 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae1731b55ec8d0de8dedfb35fc643f6fb6a68e72bb3464c4139242c1bc6bb91e
-  data.tar.gz: 161a1842a4daf8a4365a8420600f2824f5f15fd2ea3951e18d00d811eec22010
+  metadata.gz: 07d3c62244d72800b8f533d4618c8f51b4161338c37dc439ad26f67557a7315f
+  data.tar.gz: 7b8c6c808068b97555bb8f98a1d1ecb55a399e16fc51e475b61f13cbad4f0cef
 SHA512:
-  metadata.gz: 4a563c97ca83b91e578375af09e533f633d2ed2d6bca1152297d3bf4b24dc60c5f25a5679e0e87023e3031f5019b3c32e825f35f23b75b0259cee6fb765a02b5
-  data.tar.gz: 140f9b808a8f406ca1ca16611ab776544c332830353f1d9dba58d4cf3578ff746d2ff7788671fd9eda0c082d6cc3f1457f29ee38473d88ec2c1f0aa457a0dace
+  metadata.gz: 58db7e089c9a6be6e9d050a549cf5df98983227d3a3d218d0d5f61ee2684009a1af5f4069cb16376fe8211425060fe2b1d609fb5b6770236726782fa57a35b20
+  data.tar.gz: a4327a3484ffc1b30755ed38f94c2e432f0d6e338f5348a75b854c1cdebcfedebab4a742441d5e542c832d4a0aa517dc67a51f8b926462f2c0ab4ecad4a990d8

data/CHANGELOG

@@ -1,6 +1,31 @@
 CHANGELOG
 _________
 
+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,71 @@
+# Namo/Formulae.rb
+# Namo::Formulae
+
+class Namo
+  class Formulae
+    include Enumerable
+
+    def [](name)
+      @store[name]
+    end
+
+    def []=(name, callable)
+      @store[name] = callable
+    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
+  end
+end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.20.0'
+  VERSION = '0.21.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,163 @@
+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 "#[]=" 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_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.21.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: []