namo 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0aa48a727f9cc67fae8eea94dcfa8227c66a34aa8918ac65e30b33b7685c82b
-  data.tar.gz: c8f634b5c41f35337fb843d286edf80cbdabef951b076dd36533f5a2531c3715
+  metadata.gz: 86f572755292e2bac9808f09adb3169cec06066a5687ec2ea6bd9354f97d592a
+  data.tar.gz: edafcc183a1a9e5fb1212bb66a8b6906b94bf8e37a7375d3f9d304e5632ddba3
 SHA512:
-  metadata.gz: 9b196446a0d02dc61790a25ea416bfebdd591020cfd6ef89430f5e8b9d8bd1239cc265bca83f0cd6dde4d42ce3c3927074ac69e1d4e79ae88db667b95caeadf3
-  data.tar.gz: 3680f44daa8e1e78921d1d286c7f436947b6e436c9308d62038c17a1f9658ae4ccc23196afb2eb44e6b3efb41398ab1b39d8cf3bf813f87c24df12c7cb975586
+  metadata.gz: 2b2fad7c20e6cc9909b6d770a94627a071626de5cec9b402074ccda919295781dd18c38411604e5d0adf3d2f5e80833de830be37892a8e0a5cea5323bcef1a66
+  data.tar.gz: d0e9d4ae5bbe7a4dfc217614f0fb1442750313e9db734b622b831b15873e1ce6a3a5d2e91b01c450ab795476f00b94e29aae12be0dea4aad3d37e46369b5628e

data/CHANGELOG

@@ -1,6 +1,18 @@
 CHANGELOG
 _________
 
+20260521
+0.8.0: + proc and regex-based selection
+
+1. ~ Namo::Row#match?: + `when Proc` branch — calls the proc with the dimension value; truthy result selects the row. Predicate receives nil for missing or nil-valued dimensions and decides.
+2. ~ Namo::Row#match?: + `when Regexp` branch — matches against row[dimension].to_s. nil becomes "" (matches //, not /./); Integer/Float/Date/Symbol coerce via to_s.
+3. ~ test/Namo/Row_test.rb: + Proc-predicate tests (true/false/nil/truthy non-boolean returns, nil dimension values, composition with exact/array/range/regex, multiple proc predicates across dimensions, carry-through to formula-defined dimensions). + Regexp-predicate tests (match/no-match/case-insensitive on Strings, to_s coercion of Integer/Float/Date/Symbol/nil, composition with exact/array/range/proc, multiple regex predicates across dimensions, carry-through to formula-defined dimensions).
+4. ~ test/namo_test.rb: + End-to-end tests for proc selection, regex selection, and mixed proc/regex selection, including composition with projection and contraction in a single call and selection on formula-defined dimensions.
+5. ~ README.md: + Proc and regex examples in the Selection section; + paragraphs on proc semantics (truthy/nil-aware, composes with everything) and regex semantics (.to_s coercion across nil/String/Symbol/Integer/Float/Date).
+6. ~ ROADMAP.md: Promote 0.8.0 from upcoming to shipped under "Current state: 0.8.0"; revise Summary to include proc/regex in the selection vocabulary and point "next phase" at 0.9.0+.
+7. ~ CHANGELOG: Update with 0.8.0's changes and retroactively log the 0.7.0 changes to README (+ Coordinates and values section), COMPARISON.md, and EXAMPLES.md (2 sections relocated from EXAMPLES.md to COMPARISON.md).
+8. ~ Namo::VERSION: /0.7.0/0.8.0/
+
 20260520
 0.7.0: + derived-dimension surfacing, lazy single-column access, live views
 
@@ -14,8 +26,12 @@ _________
 8. ~ Namo#canonical_data: Sorts by data_dimensions to preserve 0.6.0 row-equality semantics under the broader dimensions definition.
 9. /raise_unless_matching_dimensions/raise_unless_matching_data_dimensions/: Private helper renamed to reflect what it actually compares.
 10. ~ test/namo_test.rb: + Tests for #data_dimensions, #derived_dimensions, the no-arg/single-arg/multi-arg forms of #values and #coordinates, derived-dimension surfacing in #dimensions, #to_h, the coordinates(dim) == values(dim).uniq consistency property, and live-view semantics (added rows / formulae reflected on next call).
-11. ~ Rakefile: + -V mainfont=Charter -V monofont=Menlo on pandoc invocation in docs:md2pdf, for a cleaner serif body font and so code spans containing Unicode math glyphs (e.g. ∅) render correctly under xelatex.
-12. ~ Namo::VERSION: /0.6.0/0.7.0/
+11. ~ README.md: + Coordinates and values section covering #values, #coordinates(*dims), #data_dimensions, #derived_dimensions, and #to_h.
+12. ~ COMPARISON.md: + "Worked example: comparing yesterday's screen to today's" under the set-operators section; + "Schema dispatch on incoming data feeds" under the equality/=== section. Date bumped to 20260520.
+13. ~ EXAMPLES.md: - "Schema dispatch on incoming data feeds", - "Comparing yesterday's screen to today's" — both relocated to COMPARISON.md as worked examples under the matching feature sections. Date bumped to 20260520.
+14. ~ ROADMAP.md: Promote 0.7.0 from upcoming to shipped under "Current state: 0.7.0"; point "next phase" at 0.8.0+.
+15. ~ Rakefile: + -V mainfont=Charter -V monofont=Menlo on pandoc invocation in docs:md2pdf, for a cleaner serif body font and so code spans containing Unicode math glyphs (e.g. ∅) render correctly under xelatex.
+16. ~ Namo::VERSION: /0.6.0/0.7.0/
 
 20260511
 0.6.0: + equality, pattern-match, and subset/superset operators

data/README.md

@@ -79,8 +79,41 @@ sales[quarter: ['Q1']]
 #   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
 #   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
 # ]>
+
+# Proc predicate
+sales[price: ->(v){v < 20.0}]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+
+# Regex predicate
+sales[product: /^W/]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+```
+
+Procs receive the dimension value and select the row when they return truthy. They handle arbitrary predicates — multi-condition tests, nil-aware checks, anything Ruby can express — and compose with everything else:
+
+```ruby
+sales[price: ->(v){v < 20.0}, quantity: ->(v){v > 100}]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
 ```
 
+Regexes match against the dimension value coerced with `to_s`, so they work against strings, symbols, numbers, dates, or anything else with a sensible string form. `nil` becomes `""` — `//` matches it, `/./` doesn't.
+
+```ruby
+sales[product: /widget/i]                          # case-insensitive
+sales[product: /Widget|Gadget/]                    # alternation
+sales[product: /^W/, quarter: 'Q1']                # mixed with exact
+```
+
+Procs and regexes mix freely with exact values, arrays, ranges, projection, and contraction in the same `[]` call.
+
 ### Projection
 
 Project to specific dimensions:

data/lib/Namo/Row.rb

@@ -16,6 +16,10 @@ class Namo
         case coordinate
         when Array, Range
           coordinate.include?(self[dimension])
+        when Proc
+          coordinate.call(self[dimension])
+        when Regexp
+          coordinate.match?(self[dimension].to_s)
         else
           self[dimension] == coordinate
         end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/test/Namo/Row_test.rb

@@ -1,3 +1,4 @@
+require 'date'
 require 'minitest/autorun'
 require 'minitest-spec-context'
 
@@ -59,6 +60,154 @@ describe Namo::Row do
       _(row.match?(product: 'Widget', quarter: 'Q1')).must_equal true
       _(row.match?(product: 'Widget', quarter: 'Q2')).must_equal false
     end
+
+    describe "Proc predicates" do
+      it "matches when the proc returns true" do
+        _(row.match?(price: ->(v){v < 15.0})).must_equal true
+      end
+
+      it "doesn't match when the proc returns false" do
+        _(row.match?(price: ->(v){v > 100.0})).must_equal false
+      end
+
+      it "doesn't match when the proc returns nil" do
+        _(row.match?(price: ->(v){nil})).must_equal false
+      end
+
+      it "matches when the proc returns a truthy non-boolean" do
+        _(row.match?(price: ->(v){"truthy"})).must_equal true
+      end
+
+      it "passes nil to the proc when the dimension is missing" do
+        seen = nil
+        row.match?(missing: ->(v){seen = v; true})
+        _(seen).must_be_nil
+      end
+
+      it "lets the proc decide what to do with a nil value" do
+        _(row.match?(missing: ->(v){v.nil?})).must_equal true
+        _(row.match?(missing: ->(v){!v.nil?})).must_equal false
+      end
+
+      it "composes with an exact value on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: 'Widget')).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: 'Gadget')).must_equal false
+      end
+
+      it "composes with an array on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: ['Widget', 'Gadget'])).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: ['Gadget'])).must_equal false
+      end
+
+      it "composes with a range on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, quantity: 50..150)).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, quantity: 200..300)).must_equal false
+      end
+
+      it "composes with a regex on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: /^W/)).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: /^G/)).must_equal false
+      end
+
+      it "composes multiple proc predicates across dimensions" do
+        _(row.match?(
+          price: ->(v){v < 15.0},
+          quantity: ->(v){v >= 100}
+        )).must_equal true
+        _(row.match?(
+          price: ->(v){v < 15.0},
+          quantity: ->(v){v >= 200}
+        )).must_equal false
+      end
+
+      it "carries through to a formula-defined dimension" do
+        formulae[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        _(row.match?(revenue: ->(v){v == 1000.0})).must_equal true
+        _(row.match?(revenue: ->(v){v > 5000.0})).must_equal false
+      end
+    end
+
+    describe "Regexp predicates" do
+      it "matches against a String value" do
+        _(row.match?(product: /Widget/)).must_equal true
+      end
+
+      it "doesn't match when the regex doesn't apply" do
+        _(row.match?(product: /Gadget/)).must_equal false
+      end
+
+      it "supports case-insensitive matching" do
+        _(row.match?(product: /widget/i)).must_equal true
+        _(row.match?(product: /widget/)).must_equal false
+      end
+
+      it "supports anchored patterns" do
+        _(row.match?(product: /^Wid/)).must_equal true
+        _(row.match?(product: /^Gad/)).must_equal false
+      end
+
+      it "coerces Integer values via to_s" do
+        _(row.match?(quantity: /100/)).must_equal true
+        _(row.match?(quantity: /^1/)).must_equal true
+        _(row.match?(quantity: /^9/)).must_equal false
+      end
+
+      it "coerces Float values via to_s" do
+        _(row.match?(price: /^10\./)).must_equal true
+        _(row.match?(price: /\.0$/)).must_equal true
+        _(row.match?(price: /^99/)).must_equal false
+      end
+
+      it "coerces Date values via to_s" do
+        row_data[:date] = Date.new(2026, 5, 21)
+        _(row.match?(date: /^2026/)).must_equal true
+        _(row.match?(date: /-05-/)).must_equal true
+        _(row.match?(date: /^2025/)).must_equal false
+      end
+
+      it "coerces Symbol values via to_s" do
+        row_data[:tag] = :priority
+        _(row.match?(tag: /priority/)).must_equal true
+        _(row.match?(tag: /^pri/)).must_equal true
+        _(row.match?(tag: /xyz/)).must_equal false
+      end
+
+      it "coerces nil to an empty string" do
+        _(row.match?(missing: //)).must_equal true
+        _(row.match?(missing: /./)).must_equal false
+      end
+
+      it "composes with an exact value on another dimension" do
+        _(row.match?(product: /^W/, quarter: 'Q1')).must_equal true
+        _(row.match?(product: /^W/, quarter: 'Q2')).must_equal false
+      end
+
+      it "composes with an array on another dimension" do
+        _(row.match?(product: /^W/, quarter: ['Q1', 'Q2'])).must_equal true
+        _(row.match?(product: /^W/, quarter: ['Q3'])).must_equal false
+      end
+
+      it "composes with a range on another dimension" do
+        _(row.match?(product: /^W/, price: 5.0..15.0)).must_equal true
+        _(row.match?(product: /^W/, price: 20.0..30.0)).must_equal false
+      end
+
+      it "composes with a proc on another dimension" do
+        _(row.match?(product: /^W/, quantity: ->(v){v >= 100})).must_equal true
+        _(row.match?(product: /^W/, quantity: ->(v){v >= 200})).must_equal false
+      end
+
+      it "composes multiple regex predicates across dimensions" do
+        _(row.match?(product: /^W/, quarter: /^Q/)).must_equal true
+        _(row.match?(product: /^W/, quarter: /^X/)).must_equal false
+      end
+
+      it "carries through to a formula-defined dimension" do
+        formulae[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+        _(row.match?(label: /Widget-Q1/)).must_equal true
+        _(row.match?(label: /Gadget/)).must_equal false
+      end
+    end
   end
 
   describe "#to_h" do

data/test/namo_test.rb

@@ -272,6 +272,110 @@ describe Namo do
         ]
       end
     end
+
+    context "proc selection" do
+      it "selects rows where the proc returns truthy" do
+        result = sales[price: ->(v){v < 15.0}]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "selects on multiple proc dimensions" do
+        result = sales[price: ->(v){v < 30.0}, quantity: ->(v){v > 50}]
+        _(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: 'Q2', price: 25.0, quantity: 60}
+        ]
+      end
+
+      it "composes with projection in a single call" do
+        result = sales[:product, :price, price: ->(v){v < 15.0}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', price: 10.0},
+          {product: 'Widget', price: 10.0}
+        ]
+      end
+
+      it "composes with contraction in a single call" do
+        result = sales[-:quantity, price: ->(v){v < 15.0}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1', price: 10.0},
+          {product: 'Widget', quarter: 'Q2', price: 10.0}
+        ]
+      end
+
+      it "selects on a formula-defined dimension" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        result = sales[revenue: ->(v){v >= 1500.0}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+          {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+        ]
+      end
+    end
+
+    context "regex selection" do
+      it "selects by regex against String values" do
+        result = sales[product: /^W/]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "supports case-insensitive matching" do
+        result = sales[product: /widget/i]
+        _(result.to_a.count).must_equal 2
+      end
+
+      it "supports alternation" do
+        result = sales[product: /Widget|Gadget/]
+        _(result.to_a.count).must_equal 4
+      end
+
+      it "coerces non-String values via to_s" do
+        result = sales[quantity: /^1/]
+        _(result.to_a.map{|row| row[:quantity]}).must_equal [100, 150]
+      end
+
+      it "composes with an exact value on another dimension" do
+        result = sales[product: /^W/, quarter: 'Q1']
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}
+        ]
+      end
+
+      it "composes with projection in a single call" do
+        result = sales[:product, :quarter, product: /^W/]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1'},
+          {product: 'Widget', quarter: 'Q2'}
+        ]
+      end
+
+      it "composes with contraction in a single call" do
+        result = sales[-:price, -:quantity, product: /^W/]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1'},
+          {product: 'Widget', quarter: 'Q2'}
+        ]
+      end
+
+      it "selects on a formula-defined dimension" do
+        sales[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+        result = sales[label: /Widget/]
+        _(result.to_a.count).must_equal 2
+        _(result.map{|row| row[:label]}).must_equal ['Widget-Q1', 'Widget-Q2']
+      end
+    end
+
+    context "mixed proc and regex selection" do
+      it "combines a proc and a regex across dimensions" do
+        result = sales[product: /^W/, quantity: ->(v){v > 100}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+        ]
+      end
+    end
   end
 
   describe "#[]= formulae" do

metadata

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