namo 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0cb29939a05de5108211f0d9f89b8c6b3cd0826433199f3f4014f1201a28fee
-  data.tar.gz: d628a872b860561da5c9f02867123864508c34c3311e7d9962457146226d1071
+  metadata.gz: f1cf8cf203da06b319112fec69ad8fae3dddc73ef850d3f84de4d13df2c51249
+  data.tar.gz: 1e80df8ee9c7be401c3f9cbf9625eceef0a87b6136a9d8b3825379b32eecff3f
 SHA512:
-  metadata.gz: 72b7db10583b8316b0e727b4af8404c2069533049c40e83a3974841b8a1822139898922492f721e31328632b32582c8795a50fb9a53262bee04fa5bc75672713
-  data.tar.gz: b269559c27dd1999ba2c3fb638c85abc0ee22530d984ffe620b2ac9e3fa1726655ac7c7d26c96273baf1bd1396df6ff0eeaeaf7c4e71753aee588eabdb09417f
+  metadata.gz: 712227a916253708637a1ca8c1f177e1ab36daba694df13edc2918943779751ba89e71f8d0f578b44d285abf522a869d5f16c3b0f8377899fa7818bbd6009d41
+  data.tar.gz: 7c50400df852f31b3a6a12011486cd72f32c946b94c6f7e71a9d83358a50bda4eec9b8854442181112101d82b4b154e61c6159746c697d0adec192f33d99f5a3

data/CHANGELOG

@@ -1,6 +1,25 @@
 CHANGELOG
 _________
 
+20260416
+0.5.0: + row-axis set operations: intersection (&), union (|), symmetric difference (^)
+
+1. + Namo#&: Intersection. Returns rows present in both Namo objects. Requires matching dimensions.
+2. + Namo#|: Union. Returns all rows from both sides, deduplicated. Requires matching dimensions.
+3. + Namo#^: Symmetric difference. Returns rows in one side but not both. Requires matching dimensions.
+4. ~ Namo_test.rb: Add tests for #&, #|, and #^.
+5. ~ README.md: + Intersection section, + Union section, + Symmetric difference section.
+6. ~ Namo::VERSION: /0.4.0/0.5.0/
+
+20260415
+0.4.0: + concatenation (+) and row removal (-)
+
+1. + Namo#+: Concatenate two Namo instances with matching dimensions. Appends rows from the second to the first. Raises ArgumentError when dimensions differ.
+2. + Namo#-: Remove rows from the first Namo that appear exactly in the second. Whole-row set difference. Raises ArgumentError when dimensions differ.
+3. ~ Namo_test.rb: Add tests for #+ and #-.
+4. ~ README.md: + Concatenation section, + Row removal section.
+5. ~ Namo::VERSION: /0.3.0/0.4.0/
+
 20260415
 0.3.0: + contraction
 

data/README.md

@@ -153,6 +153,133 @@ sales[-:price, -:quantity, product: 'Widget']
 
 Selection, projection, and contraction always return a new Namo instance, so everything chains.
 
+### Concatenation
+
+`+` combines two Namo objects that share the same dimensions by appending the rows of the second to the first:
+
+```ruby
+q1_sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+])
+
+q2_sales = Namo.new([
+  {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+])
+
+all_sales = q1_sales + q2_sales
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+#   {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+# ]>
+```
+
+The dimensions must match — concatenating Namo objects with different dimensions raises an `ArgumentError`. Formulae carry through from the left-hand side.
+
+### Row Removal
+
+`-` removes from the first Namo any row that appears exactly in the second:
+
+```ruby
+sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+])
+
+discontinued = Namo.new([
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+])
+
+sales - discontinued
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+```
+
+Removal is exact — every dimension, every value must match. The dimensions must match; different dimensions raise an `ArgumentError`. Formulae carry through from the left-hand side.
+
+### Intersection
+
+`&` returns the rows present in both Namo objects, like `Array#&`:
+
+```ruby
+sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+])
+
+confirmed = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+])
+
+sales & confirmed
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+# ]>
+```
+
+The dimensions must match; different dimensions raise an `ArgumentError`. Formulae carry through from the left-hand side.
+
+### Union
+
+`|` returns all rows from both sides, deduplicated, like `Array#|`:
+
+```ruby
+q1_sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+])
+
+all_sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+])
+
+q1_sales | all_sales
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+#   {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+# ]>
+```
+
+The dimensions must match; different dimensions raise an `ArgumentError`. Formulae merge from both sides; the left-hand side's formulae take precedence on conflict.
+
+### Symmetric Difference
+
+`^` returns rows that appear in one side but not both:
+
+```ruby
+set_a = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+])
+
+set_b = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+])
+
+set_a ^ set_b
+# => #<Namo [
+#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+#   {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+# ]>
+```
+
+The dimensions must match; different dimensions raise an `ArgumentError`. Formulae merge from both sides; the left-hand side's formulae take precedence on conflict.
+
 ### Formulae
 
 Define computed dimensions using `[]=`:

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/namo.rb

@@ -56,6 +56,41 @@ class Namo
     @data.each{|row_data| block.call(Row.new(row_data, @formulae))}
   end
 
+  def +(other)
+    unless dimensions == other.dimensions
+      raise ArgumentError, "dimensions do not match"
+    end
+    self.class.new(@data + other.data, formulae: other.formulae.merge(@formulae))
+  end
+
+  def -(other)
+    unless dimensions == other.dimensions
+      raise ArgumentError, "dimensions do not match"
+    end
+    self.class.new(@data - other.data, formulae: @formulae.dup)
+  end
+
+  def &(other)
+    unless dimensions == other.dimensions
+      raise ArgumentError, "dimensions do not match"
+    end
+    self.class.new(@data & other.data, formulae: @formulae.dup)
+  end
+
+  def |(other)
+    unless dimensions == other.dimensions
+      raise ArgumentError, "dimensions do not match"
+    end
+    self.class.new((@data | other.data), formulae: other.formulae.merge(@formulae))
+  end
+
+  def ^(other)
+    unless dimensions == other.dimensions
+      raise ArgumentError, "dimensions do not match"
+    end
+    self.class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
+  end
+
   def to_a
     @data.map do |row|
       row.keys.each_with_object({}) do |key, hash|

data/test/Namo_test.rb

@@ -251,6 +251,221 @@ describe Namo do
     end
   end
 
+  describe "#+" do
+    let(:more_data) do
+      [
+        {product: 'Widget', quarter: 'Q3', price: 10.0, quantity: 200},
+        {product: 'Gadget', quarter: 'Q3', price: 25.0, quantity: 80}
+      ]
+    end
+
+    let(:more_sales) do
+      Namo.new(more_data)
+    end
+
+    it "concatenates rows" do
+      result = sales + more_sales
+      _(result.to_a.count).must_equal 6
+      _(result.to_a).must_equal(sample_data + more_data)
+    end
+
+    it "preserves dimensions" do
+      result = sales + more_sales
+      _(result.dimensions).must_equal [:product, :quarter, :price, :quantity]
+    end
+
+    it "carries formulae through from self" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales + more_sales
+      _(result.map{|row| row[:revenue]}).must_equal [1000.0, 1500.0, 1000.0, 1500.0, 2000.0, 2000.0]
+    end
+
+    it "merges formulae from other" do
+      more_sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales + more_sales
+      _(result.map{|row| row[:revenue]}).must_equal [1000.0, 1500.0, 1000.0, 1500.0, 2000.0, 2000.0]
+    end
+
+    it "prefers self's formulae on conflict" do
+      sales[:label] = proc{|r| "self: #{r[:product]}"}
+      more_sales[:label] = proc{|r| "other: #{r[:product]}"}
+      result = sales + more_sales
+      _(result.map{|row| row[:label]}).must_equal [
+        'self: Widget', 'self: Widget', 'self: Gadget', 'self: Gadget',
+        'self: Widget', 'self: Gadget'
+      ]
+    end
+
+    it "raises when dimensions differ" do
+      other = Namo.new([{product: 'Widget', quarter: 'Q1'}])
+      _ { sales + other }.must_raise ArgumentError
+    end
+  end
+
+  describe "#-" do
+    let(:to_remove) do
+      Namo.new([
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ])
+    end
+
+    it "removes matching rows" do
+      result = sales - to_remove
+      _(result.to_a.count).must_equal 2
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+      ]
+    end
+
+    it "preserves non-matching rows" do
+      other = Namo.new([{product: 'Thingo', quarter: 'Q4', price: 99.0, quantity: 1}])
+      result = sales - other
+      _(result.to_a).must_equal sample_data
+    end
+
+    it "carries formulae through from self" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales - to_remove
+      _(result.map{|row| row[:revenue]}).must_equal [1500.0, 1000.0]
+    end
+
+    it "raises when dimensions differ" do
+      other = Namo.new([{product: 'Widget', quarter: 'Q1'}])
+      _ { sales - other }.must_raise ArgumentError
+    end
+  end
+
+  describe "#&" do
+    let(:other) do
+      Namo.new([
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60},
+        {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      ])
+    end
+
+    it "returns rows present in both" do
+      result = sales & other
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "returns empty when nothing overlaps" do
+      other = Namo.new([{product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}])
+      result = sales & other
+      _(result.to_a).must_equal []
+    end
+
+    it "preserves dimensions" do
+      result = sales & other
+      _(result.dimensions).must_equal [:product, :quarter, :price, :quantity]
+    end
+
+    it "carries formulae through from self" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales & other
+      _(result.map{|row| row[:revenue]}).must_equal [1000.0, 1500.0]
+    end
+
+    it "raises when dimensions differ" do
+      other = Namo.new([{product: 'Widget', quarter: 'Q1'}])
+      _ { sales & other }.must_raise ArgumentError
+    end
+  end
+
+  describe "#|" do
+    let(:other) do
+      Namo.new([
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      ])
+    end
+
+    it "returns all rows deduplicated" do
+      result = sales | other
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60},
+        {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      ]
+    end
+
+    it "preserves dimensions" do
+      result = sales | other
+      _(result.dimensions).must_equal [:product, :quarter, :price, :quantity]
+    end
+
+    it "merges formulae from other" do
+      other[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales | other
+      _(result.map{|row| row[:revenue]}).must_equal [1000.0, 1500.0, 1000.0, 1500.0, 50.0]
+    end
+
+    it "prefers self's formulae on conflict" do
+      sales[:label] = proc{|r| "self: #{r[:product]}"}
+      other[:label] = proc{|r| "other: #{r[:product]}"}
+      result = sales | other
+      _(result.map{|row| row[:label]}).must_equal [
+        'self: Widget', 'self: Widget', 'self: Gadget', 'self: Gadget', 'self: Thingo'
+      ]
+    end
+
+    it "raises when dimensions differ" do
+      other = Namo.new([{product: 'Widget', quarter: 'Q1'}])
+      _ { sales | other }.must_raise ArgumentError
+    end
+  end
+
+  describe "#^" do
+    let(:other) do
+      Namo.new([
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60},
+        {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      ])
+    end
+
+    it "returns rows in one but not both" do
+      result = sales ^ other
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      ]
+    end
+
+    it "returns empty when both are identical" do
+      result = sales ^ sales
+      _(result.to_a).must_equal []
+    end
+
+    it "returns all rows when nothing overlaps" do
+      other = Namo.new([{product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}])
+      result = sales ^ other
+      _(result.to_a.count).must_equal 5
+    end
+
+    it "merges formulae with self winning on conflict" do
+      sales[:label] = proc{|r| "self: #{r[:product]}"}
+      other[:label] = proc{|r| "other: #{r[:product]}"}
+      result = sales ^ other
+      _(result.map{|row| row[:label]}).must_equal [
+        'self: Widget', 'self: Gadget', 'self: Thingo'
+      ]
+    end
+
+    it "raises when dimensions differ" do
+      other = Namo.new([{product: 'Widget', quarter: 'Q1'}])
+      _ { sales ^ other }.must_raise ArgumentError
+    end
+  end
+
   describe "#to_a" do
     it "returns the data as an array of hashes" do
       _(sales.to_a).must_equal sample_data

metadata

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