namo 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d29843b2d9895ba401fa013ea83753f548458bc09bcd8e61218400f81950e33
-  data.tar.gz: 6b8772e13cd773d41ae4cabddb019bddb533cbc9a24ece7729977543e462a30c
+  metadata.gz: 86f572755292e2bac9808f09adb3169cec06066a5687ec2ea6bd9354f97d592a
+  data.tar.gz: edafcc183a1a9e5fb1212bb66a8b6906b94bf8e37a7375d3f9d304e5632ddba3
 SHA512:
-  metadata.gz: 22c4c03943617b1ec56e45ace4722019e6d54bb12f9b30fb3e2b85eebce132477a380ccde5529ea65782be03f060abd7507ebbfbe8b06d3c8ad10d7b90319061
-  data.tar.gz: 17e0163a3353024bec9826d5fc95773893d8195dbb7efe87ff7e814da7c74ca1391f168ca10025a6deb9fcd44e7ecae8fc3a10c44f29f9ef1e2018a0de96aa97
+  metadata.gz: 2b2fad7c20e6cc9909b6d770a94627a071626de5cec9b402074ccda919295781dd18c38411604e5d0adf3d2f5e80833de830be37892a8e0a5cea5323bcef1a66
+  data.tar.gz: d0e9d4ae5bbe7a4dfc217614f0fb1442750313e9db734b622b831b15873e1ce6a3a5d2e91b01c450ab795476f00b94e29aae12be0dea4aad3d37e46369b5628e

data/CHANGELOG

@@ -1,6 +1,38 @@
 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
+
+1. + Namo#data_dimensions: Returns the storage dimensions as a plain Array (keys of the first row).
+2. + Namo#derived_dimensions: Returns the formula names as a plain Array.
+3. + Namo#values(*dims): Per-dimension full sequences (duplicates preserved, in row order). With no args, returns a Hash {dim => sequence} across the queryable namespace. With one arg, lazily computes and returns just that column as an Array. With multiple args, returns a subset Hash containing each requested dimension. Unknown dimensions propagate as nil per row, matching Row#[] and Namo#[] selection conventions — values(:unknown) returns an Array of nils; values(:known, :unknown) returns {known: [...], unknown: [nil, ...]}.
+4. + Namo#coordinates(*dims): Per-dimension unique-value sets. Same argument shape as #values; coordinates(dim) == values(dim).uniq. Unknown dimensions therefore appear as [nil].
+5. + Namo#to_h: Alias for the full values Hash.
+6. ~ Namo#dimensions: Now covers the queryable namespace (storage + derived) instead of storage-only. Return type stays a plain Array. Memoisation removed: every call recomputes from current state (live view).
+7. ~ Namo#coordinates: Memoisation removed (was @coordinates ||= ...). Now covers the queryable namespace; coordinates(:derived_dim) and coordinates[:derived_dim] work, evaluating the formula across all rows. New positional-args API supports lazy single-column access.
+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. ~ 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

@@ -4,7 +4,7 @@ Named dimensional data for Ruby.
 
 Namo is a Ruby library for working with multi-dimensional data using named dimensions. It infers dimensions and coordinates from plain arrays of hashes — the same shape you get from databases, CSV files, JSON, and YAML — so there's no reshaping step.
 
-The design rests on a few stances: every hash key is a dimension and none is privileged; formulae attach to a Namo alongside stored data and re-evaluate on each access; the operators that combine Namos all take Namos and return Namos, so analytical pipelines close; and the formula mechanism is type-agnostic — strings, dates, booleans, and arbitrary Ruby objects work as readily as numbers.
+The design rests on a few stances: every hash key is a dimension and none is privileged as a coordinate or value; formulae attach to a Namo alongside data and re-evaluate on each access, appearing as derived dimensions alongside the data dimensions; operators that combine Namos all take Namos and return Namos, so analytical pipelines close; and the formula mechanism is type-agnostic — strings, dates, booleans, and arbitrary Ruby objects work as readily as numbers.
 
 ## Installation
 
@@ -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:
@@ -383,7 +416,7 @@ sales[:product, :quarter, :revenue]
 # ]>
 ```
 
-Formulae aren't materialised into stored columns — they re-evaluate on every access. A `:revenue` value reflects the current `:price` and `:quantity` at the moment you ask for it, so derived values stay in sync with whatever the underlying data is doing.
+Formulae aren't materialised into row data — they re-evaluate on every access. A `:revenue` value reflects the current `:price` and `:quantity` at the moment you ask for it, so derived values stay in sync with whatever the underlying data is doing.
 
 Formulae compose:
 
@@ -412,6 +445,78 @@ sales[product: 'Widget'][:revenue, :quarter]
 
 Formulae carry through selection — a filtered Namo instance remembers its formulae.
 
+### Coordinates and values
+
+`dimensions` covers the *queryable namespace* — every name you can ask for, whether it lives in the row data or is computed by a formula. Once formulae are defined, they appear alongside data dimensions:
+
+```ruby
+sales[:revenue] = proc{|row| row[:price] * row[:quantity]}
+
+sales.dimensions
+# => [:product, :quarter, :price, :quantity, :revenue]
+
+sales.data_dimensions
+# => [:product, :quarter, :price, :quantity]
+
+sales.derived_dimensions
+# => [:revenue]
+```
+
+`coordinates` gives the unique values per dimension, including derived ones:
+
+```ruby
+sales.coordinates[:product]
+# => ['Widget', 'Gadget']
+
+sales.coordinates[:revenue]
+# => [1000.0, 1500.0]
+```
+
+`values` gives the full per-row sequence — duplicates preserved, row order preserved:
+
+```ruby
+sales.values[:product]
+# => ['Widget', 'Widget', 'Gadget', 'Gadget']
+
+sales.values[:revenue]
+# => [1000.0, 1500.0, 1000.0, 1500.0]
+```
+
+Both `coordinates` and `values` accept positional arguments. With no args they return a Hash across the queryable namespace; with one arg they lazily compute and return just that column as an Array; with multiple args they return a subset Hash containing just the requested columns:
+
+```ruby
+sales.values(:product)
+# => ['Widget', 'Widget', 'Gadget', 'Gadget']
+
+sales.values(:product, :quarter)
+# => {
+#   product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+#   quarter: ['Q1', 'Q2', 'Q1', 'Q2']
+# }
+
+sales.coordinates(:revenue)
+# => [1000.0, 1500.0]
+```
+
+Single-arg access is lazy: `sales.values(:revenue)` evaluates the formula only across the rows of `:revenue`, without materialising the other columns. The bracket form (`sales.values[:revenue]`) still works through ordinary Hash lookup but pays for the full materialisation up front.
+
+`coordinates` is `values` with `.uniq` applied per column — `coordinates(dim) == values(dim).uniq` holds for every dimension.
+
+`to_h` is the Ruby-conventional alias for the full `values` Hash:
+
+```ruby
+sales.to_h
+# => {
+#   product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+#   quarter: ['Q1', 'Q2', 'Q1', 'Q2'],
+#   price: [10.0, 10.0, 25.0, 25.0],
+#   quantity: [100, 150, 40, 60],
+#   revenue: [1000.0, 1500.0, 1000.0, 1500.0]
+# }
+```
+
+Unknown dimensions propagate `nil` per row — `values(:missing)` returns `[nil, nil, ...]` rather than raising or returning a sentinel, matching the convention used by `Row#[]` and `[]` selection. Use `dimensions.include?(:dim)` if you need to check membership directly.
+
 ### Enumerable
 
 Namo includes `Enumerable`, so `each`, `reduce`, `map`, `select`, `min_by`, and all the rest work out of the box. Rows are yielded as `Row` objects, so formulae are accessible during enumeration:
@@ -443,7 +548,7 @@ sales.flat_map{|row| [row[:price]]}
 
 ### Extracting data
 
-`to_a` returns an array of hashes:
+`to_a` returns an array of hashes — the row-oriented form:
 
 ```ruby
 sales[:product, :quarter, :revenue].to_a
@@ -455,6 +560,17 @@ sales[:product, :quarter, :revenue].to_a
 # ]
 ```
 
+`to_h` returns a hash of arrays — the columnar form (see [Coordinates and values](#coordinates-and-values) above):
+
+```ruby
+sales[:product, :quarter, :revenue].to_h
+# => {
+#   product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+#   quarter: ['Q1', 'Q2', 'Q1', 'Q2'],
+#   revenue: [1000.0, 1500.0, 1000.0, 1500.0]
+# }
+```
+
 ## Why?
 
 Every other multi-dimensional array library requires you to pre-shape your data before you can work with it. Namo takes it in the form it likely already comes in.

data/Rakefile

@@ -21,7 +21,7 @@ namespace :docs do
   task :md2pdf => :md4print do
     Dir.glob('docs/*.print.md').each do |f|
       pdf = f.sub(/\.md$/, '.pdf')
-      sh "pandoc #{f} --pdf-engine=xelatex -V geometry:margin=1in -o #{pdf}"
+      sh "pandoc #{f} --pdf-engine=xelatex -V geometry:margin=1in -V mainfont=Charter -V monofont=Menlo -o #{pdf}"
     end
   end
 

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.6.0'
+  VERSION = '0.8.0'
 end

data/lib/namo.rb

@@ -12,15 +12,39 @@ class Namo
   attr_accessor :formulae
 
   def dimensions
-    @dimensions ||= @data.first.keys
+    @data.first.keys + @formulae.keys
   end
 
-  def coordinates
-    @coordinates ||= (
-      dimensions.each_with_object({}) do |dimension, hash|
-        hash[dimension] = @data.map{|row| row[dimension]}.uniq
-      end
-    )
+  def data_dimensions
+    @data.first.keys
+  end
+
+  def derived_dimensions
+    @formulae.keys
+  end
+
+  def values(*dims)
+    if dims.empty?
+      dimensions.each_with_object({}){|dim, hash| hash[dim] = values_for(dim)}
+    elsif dims.length == 1
+      values_for(dims.first)
+    else
+      dims.each_with_object({}){|dim, hash| hash[dim] = values_for(dim)}
+    end
+  end
+
+  def coordinates(*dims)
+    if dims.empty?
+      values.transform_values(&:uniq)
+    elsif dims.length == 1
+      values(dims.first).uniq
+    else
+      dims.each_with_object({}){|dim, hash| hash[dim] = values(dim).uniq}
+    end
+  end
+
+  def to_h
+    values
   end
 
   def [](*names, **selections)
@@ -32,7 +56,7 @@ class Namo
     projected = (
       if negated.any?
         excluded = negated.map(&:name)
-        kept = dimensions - excluded
+        kept = data_dimensions - excluded
         rows.map do |row|
           kept.each_with_object({}){|name, hash| hash[name] = row[name]}
         end
@@ -58,31 +82,31 @@ class Namo
 
   def +(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new(@data + other.data, formulae: other.formulae.merge(@formulae))
   end
 
   def -(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new(@data - other.data, formulae: @formulae.dup)
   end
 
   def &(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new(@data & other.data, formulae: @formulae.dup)
   end
 
   def |(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new((@data | other.data), formulae: other.formulae.merge(@formulae))
   end
 
   def ^(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
   end
 
@@ -109,25 +133,25 @@ class Namo
 
   def <(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     proper_subset_of_rows?(other)
   end
 
   def <=(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     subset_of_rows?(other)
   end
 
   def >(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     other.proper_subset_of_rows?(self)
   end
 
   def >=(other)
     raise_unless_namo(other)
-    raise_unless_matching_dimensions(other)
+    raise_unless_matching_data_dimensions(other)
     other.subset_of_rows?(self)
   end
 
@@ -142,7 +166,7 @@ class Namo
   protected
 
   def canonical_data
-    @data.sort_by{|row| row.values_at(*dimensions.sort)}
+    @data.sort_by{|row| row.values_at(*data_dimensions.sort)}
   end
 
   def subset_of_rows?(other)
@@ -157,15 +181,23 @@ class Namo
 
   private
 
+  def values_for(dim)
+    if data_dimensions.include?(dim)
+      @data.map{|row_data| row_data[dim]}
+    else
+      @data.map{|row_data| Row.new(row_data, @formulae)[dim]}
+    end
+  end
+
   def raise_unless_namo(other)
     unless other.is_a?(Namo)
       raise TypeError, "can't compare Namo with #{other.class}"
     end
   end
 
-  def raise_unless_matching_dimensions(other)
-    unless dimensions == other.dimensions
-      raise ArgumentError, "dimensions don't match: #{dimensions} vs #{other.dimensions}"
+  def raise_unless_matching_data_dimensions(other)
+    unless data_dimensions == other.data_dimensions
+      raise ArgumentError, "dimensions don't match: #{data_dimensions} vs #{other.data_dimensions}"
     end
   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

@@ -21,19 +21,159 @@ describe Namo do
     it "infers dimensions from hash keys" do
       _(sales.dimensions).must_equal [:product, :quarter, :price, :quantity]
     end
+
+    it "includes derived dimensions after storage dimensions" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      sales[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+      _(sales.dimensions).must_equal [:product, :quarter, :price, :quantity, :revenue, :label]
+    end
+
+    it "reflects mutation on the next call" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.dimensions).must_include :revenue
+      sales.formulae.delete(:revenue)
+      _(sales.dimensions).wont_include :revenue
+    end
+  end
+
+  describe "#data_dimensions" do
+    it "returns only the storage keys" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.data_dimensions).must_equal [:product, :quarter, :price, :quantity]
+    end
+  end
+
+  describe "#derived_dimensions" do
+    it "returns only the formula keys" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.derived_dimensions).must_equal [:revenue]
+    end
+
+    it "is empty when no formulae are defined" do
+      _(sales.derived_dimensions).must_equal []
+    end
   end
 
   describe "#coordinates" do
-    it "extracts unique values for each dimension" do
+    it "with no args returns a Hash of unique values for each dimension" do
       _(sales.coordinates).must_equal ({
         product: ['Widget', 'Gadget'],
         quarter: ['Q1', 'Q2'],
         price: [10.0, 25.0],
         quantity: [100, 150, 40, 60]
       })
+    end
+
+    it "0.6.0-style indexing still works" do
       _(sales.coordinates[:product]).must_equal ['Widget', 'Gadget']
       _(sales.coordinates[:quarter]).must_equal ['Q1', 'Q2']
     end
+
+    it "with one arg returns just that column's unique values as an Array" do
+      _(sales.coordinates(:product)).must_equal ['Widget', 'Gadget']
+    end
+
+    it "with one arg returns [nil] for an unknown dimension (nil values uniqued)" do
+      _(sales.coordinates(:missing)).must_equal [nil]
+    end
+
+    it "with one arg evaluates a derived dimension" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.coordinates(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "with multiple args returns a subset Hash" do
+      _(sales.coordinates(:product, :quarter)).must_equal({
+        product: ['Widget', 'Gadget'],
+        quarter: ['Q1', 'Q2']
+      })
+    end
+
+    it "with multiple args includes unknown dimensions as [nil]" do
+      _(sales.coordinates(:product, :missing)).must_equal({
+        product: ['Widget', 'Gadget'],
+        missing: [nil]
+      })
+    end
+
+    it "covers derived dimensions in the no-arg form" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.coordinates[:revenue]).must_equal [1000.0, 1500.0]
+    end
+  end
+
+  describe "#values" do
+    it "with no args returns a Hash of full sequences for each dimension" do
+      _(sales.values).must_equal({
+        product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+        quarter: ['Q1', 'Q2', 'Q1', 'Q2'],
+        price: [10.0, 10.0, 25.0, 25.0],
+        quantity: [100, 150, 40, 60]
+      })
+    end
+
+    it "with one arg returns just that column as an Array, preserving duplicates and order" do
+      _(sales.values(:product)).must_equal ['Widget', 'Widget', 'Gadget', 'Gadget']
+      _(sales.values(:price)).must_equal [10.0, 10.0, 25.0, 25.0]
+    end
+
+    it "with one arg returns an Array of nils for an unknown dimension (one nil per row)" do
+      _(sales.values(:missing)).must_equal [nil, nil, nil, nil]
+    end
+
+    it "with one arg evaluates a derived dimension across all rows" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.values(:revenue)).must_equal [1000.0, 1500.0, 1000.0, 1500.0]
+    end
+
+    it "with multiple args returns a subset Hash" do
+      _(sales.values(:product, :quarter)).must_equal({
+        product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+        quarter: ['Q1', 'Q2', 'Q1', 'Q2']
+      })
+    end
+
+    it "with multiple args includes unknown dimensions as Arrays of nils" do
+      _(sales.values(:product, :missing)).must_equal({
+        product: ['Widget', 'Widget', 'Gadget', 'Gadget'],
+        missing: [nil, nil, nil, nil]
+      })
+    end
+
+    it "covers derived dimensions in the no-arg form" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.values[:revenue]).must_equal [1000.0, 1500.0, 1000.0, 1500.0]
+    end
+  end
+
+  describe "#to_h" do
+    it "returns the full values Hash" do
+      _(sales.to_h).must_equal sales.values
+    end
+  end
+
+  describe "aspect consistency" do
+    it "satisfies coordinates(dim) == values(dim).uniq for each dimension" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      sales.dimensions.each do |dim|
+        _(sales.coordinates(dim)).must_equal sales.values(dim).uniq
+      end
+    end
+  end
+
+  describe "live-view semantics" do
+    it "reflects added rows on next call" do
+      _(sales.values(:product)).must_equal ['Widget', 'Widget', 'Gadget', 'Gadget']
+      sales.data << {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+      _(sales.values(:product)).must_equal ['Widget', 'Widget', 'Gadget', 'Gadget', 'Thingo']
+    end
+
+    it "reflects added formulae on next call" do
+      _(sales.derived_dimensions).must_equal []
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.derived_dimensions).must_equal [:revenue]
+      _(sales.coordinates(:revenue)).must_equal [1000.0, 1500.0]
+    end
   end
 
   describe "#[]" do
@@ -132,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.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - thoran