namo 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2959666eaa2d603b1877d42863ddadae9e021aceb753a60009579a2dbe2d7aa4
-  data.tar.gz: ac865863705a2ca58c815eed073227a39ebb479358fea0590e4f76a5f6b0813c
+  metadata.gz: ff324711fe932145ecc01cedadee6453f80fe6610d162783a7dea053d2f35fc0
+  data.tar.gz: ec993e96d3ac5f1053eaa0f6c933347914209ed84423e78e3c4e5a4843c22915
 SHA512:
-  metadata.gz: '09cc42eba9f306b4316a70140bb9642dc025c39d4bc3a502b21bee28058709b8b55609093d9979e27e2799d1bdad1efd60d829a71931502abc8e7cde71f1a1c7'
-  data.tar.gz: 3952f6470d2f5dc8aeb733034d8c7cbf6214b909453f3b26e7ac29480388b79d345efba1ff925ce4617c64c7a9c2f1e578f2e8938f2e51def0d378109f65d276
+  metadata.gz: 863aa8aeb8432d3fed7da33218ce14790a24a5e4a4b1c70a09b44aa495ef7ebe1bba36954622a1629990ff61cd892904725ee2293613e63c51ca48e0e6d05c18
+  data.tar.gz: 343949804d61f4dd93a636a961d6c097f9f1c20f7010044d67fbab34aaba75f1b3c9b33cd42f2f74f1ce189fd9324e6a18398b7b595fda11ca2fc44cfbcfc1c0

data/CHANGELOG

@@ -1,6 +1,17 @@
 CHANGELOG
 _________
 
+20260528
+0.10.0: + Row value semantics: ==, eql?, hash
+
+1. + Namo::Row#==: Data equality. Two Rows are equal iff the other is a Row and their `@row` hashes are `==`. Class identity not gated (Row has no subclass hierarchy with included modules); formulae ignored (a formula is a property of the surrounding Namo, not of the row's identity). Mirrors `Namo#==` one level down.
+2. + Namo::Row#eql?: Strict data equality. Same shape as `==` but uses `Hash#eql?` on `@row`, matching Ruby's numeric-type-strict convention (`{n: 1}` Row is `eql?` to another `{n: 1}` Row, but not to a `{n: 1.0}` Row, just as `1.eql?(1.0)` is false).
+3. + Namo::Row#hash: Returns `@row.hash`. Consistent with `eql?` — Rows that are `eql?` produce equal hashes, so Rows participate correctly in Hash keys, Set members, and Array#uniq.
+4. ~ test/Namo/Row_test.rb: + `#==` tests (equal/different `@row`, non-Row operand, formulae ignored). + `#eql?` tests (equal `@row`, non-Row operand, `Hash#eql?` numeric-type strictness vs `==`, formulae ignored). + `#hash` tests (hash equality for `eql?` Rows, Rows as Hash keys, Rows as Set members deduplicating equal Rows).
+5. ~ README.md: + Note in the Equality section that Row participates in value semantics (`==`, `eql?`, `hash`) on the same data-only basis as `Namo#==`, ignoring formulae.
+6. ~ ROADMAP.md: Promote 0.10.0 from upcoming to shipped under "Current state: 0.10.0"; revise Summary to point "next phase" at 0.11.0+ and note Row value semantics among the algebra-completing pieces.
+7. ~ Namo::VERSION: /0.9.2/0.10.0/
+
 20260525
 0.9.2: ~ Auto-load Namo::VERSION
 

data/README.md

@@ -486,6 +486,18 @@ The two `:revenue` procs are independently-written and not the same object — `
 
 Each comparison operator answers a distinct question: `eql?` is strictest (class + data + formula names); `==` is data identity; `===` is analytical identity; the subset operators are data containment.
 
+Rows participate in value semantics on the same data-only basis. `Row#==`, `Row#eql?`, and `Row#hash` compare the underlying row hash and ignore the surrounding Namo's formulae — two Rows with the same data are equal regardless of which Namo yielded them. This makes Rows usable as Hash keys and Set members, and underwrites whole-row deduplication on the Enumerable side:
+
+```ruby
+a = Namo.new([{x: 1}]).first
+b = Namo.new([{x: 1}]).first
+a == b           # => true
+a.eql?(b)        # => true
+{a => :found}[b] # => :found
+```
+
+The omission of `Row#===` and Row-level `<`/`<=`/`>`/`>=` is deliberate: a Row is a record, not a collection, so the set-theoretic operators don't translate. The value-semantics trio (`==`, `eql?`, `hash`) is what a hash-shaped value needs to behave correctly in Ruby's collection machinery; that's the whole Row-comparison story.
+
 ### Subset and Superset
 
 `<`, `<=`, `>`, `>=` are multiset subset and superset relations on rows.

data/lib/Namo/Row.rb

@@ -11,6 +11,18 @@ class Namo
       end
     end
 
+    def ==(other)
+      other.is_a?(Row) && @row == other.to_h
+    end
+
+    def eql?(other)
+      other.is_a?(Row) && @row.eql?(other.to_h)
+    end
+
+    def hash
+      @row.hash
+    end
+
     def match?(selections)
       selections.all? do |dimension, coordinate|
         case coordinate

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.9.2'
+  VERSION = '0.10.0'
 end

data/test/Namo/Row_test.rb

@@ -215,4 +215,81 @@ describe Namo::Row do
       _(row.to_h).must_equal row_data
     end
   end
+
+  describe "#==" do
+    it "is true for two Rows with equal @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a == b).must_equal true
+    end
+
+    it "is false for two Rows with different @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Gadget', price: 10.0}, {})
+      _(a == b).must_equal false
+    end
+
+    it "is false for a non-Row operand" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      _(a == {product: 'Widget'}).must_equal false
+      _(a == 'Widget').must_equal false
+      _(a == nil).must_equal false
+    end
+
+    it "ignores formulae" do
+      a = Namo::Row.new({price: 10.0, quantity: 100}, {})
+      b = Namo::Row.new({price: 10.0, quantity: 100}, {revenue: proc{|r| r[:price] * r[:quantity]}})
+      _(a == b).must_equal true
+    end
+  end
+
+  describe "#eql?" do
+    it "is true for two Rows with eql? @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a.eql?(b)).must_equal true
+    end
+
+    it "is false for a non-Row operand" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      _(a.eql?({product: 'Widget'})).must_equal false
+      _(a.eql?(nil)).must_equal false
+    end
+
+    it "distinguishes numeric types the way Hash#eql? does" do
+      a = Namo::Row.new({n: 1}, {})
+      b = Namo::Row.new({n: 1.0}, {})
+      _(a == b).must_equal true
+      _(a.eql?(b)).must_equal false
+    end
+
+    it "ignores formulae" do
+      a = Namo::Row.new({price: 10.0, quantity: 100}, {})
+      b = Namo::Row.new({price: 10.0, quantity: 100}, {revenue: proc{|r| r[:price] * r[:quantity]}})
+      _(a.eql?(b)).must_equal true
+    end
+  end
+
+  describe "#hash" do
+    it "is equal for two Rows that are eql?" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a.hash).must_equal b.hash
+    end
+
+    it "lets Rows work as Hash keys" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      b = Namo::Row.new({product: 'Gadget'}, {})
+      lookup = Namo::Row.new({product: 'Widget'}, {})
+      h = {a => :x, b => :y}
+      _(h[lookup]).must_equal :x
+    end
+
+    it "lets Array#uniq dedupe equal Rows" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      b = Namo::Row.new({product: 'Gadget'}, {})
+      duplicate_of_a = Namo::Row.new({product: 'Widget'}, {})
+      _([a, b, duplicate_of_a].uniq.length).must_equal 2
+    end
+  end
 end

metadata

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