namo 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1cf8cf203da06b319112fec69ad8fae3dddc73ef850d3f84de4d13df2c51249
-  data.tar.gz: 1e80df8ee9c7be401c3f9cbf9625eceef0a87b6136a9d8b3825379b32eecff3f
+  metadata.gz: c0aa48a727f9cc67fae8eea94dcfa8227c66a34aa8918ac65e30b33b7685c82b
+  data.tar.gz: c8f634b5c41f35337fb843d286edf80cbdabef951b076dd36533f5a2531c3715
 SHA512:
-  metadata.gz: 712227a916253708637a1ca8c1f177e1ab36daba694df13edc2918943779751ba89e71f8d0f578b44d285abf522a869d5f16c3b0f8377899fa7818bbd6009d41
-  data.tar.gz: 7c50400df852f31b3a6a12011486cd72f32c946b94c6f7e71a9d83358a50bda4eec9b8854442181112101d82b4b154e61c6159746c697d0adec192f33d99f5a3
+  metadata.gz: 9b196446a0d02dc61790a25ea416bfebdd591020cfd6ef89430f5e8b9d8bd1239cc265bca83f0cd6dde4d42ce3c3927074ac69e1d4e79ae88db667b95caeadf3
+  data.tar.gz: 3680f44daa8e1e78921d1d286c7f436947b6e436c9308d62038c17a1f9658ae4ccc23196afb2eb44e6b3efb41398ab1b39d8cf3bf813f87c24df12c7cb975586

data/CHANGELOG

@@ -1,6 +1,37 @@
 CHANGELOG
 _________
 
+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. ~ 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/
+
+20260511
+0.6.0: + equality, pattern-match, and subset/superset operators
+
+1. + Namo#==: Multiset equality on row data, ignoring class and formulae.
+2. + Namo#===: Analytical identity match — true iff other has the same dimensions and same formula names as self, ignoring rows and proc bodies. Returns false for non-Namo operands.
+3. + Namo#eql?: Strict equality requiring class match, multiset-equal data, and formula name match.
+4. + Namo#hash: Content-based hash, consistent with eql?.
+5. + Namo#<, #<=, #>, #>=: Multiset subset/superset relations on rows. Raise ArgumentError on mismatched dimensions, TypeError on non-Namo operand.
+6. ~ Namo#+, #-, #&, #|, #^: Error message on dimension mismatch updated to "dimensions don't match: X vs Y". Non-Namo operand now raises TypeError ("can't compare Namo with X") instead of NoMethodError.
+7. ~ lib/namo.rb, namo.gemspec: Minor cleanup (./-prefixed requires; gemspec whitespace).
+8. ~ test/namo_test.rb: Add tests for ==, ===, eql?, hash, <, <=, >, >=, equal?, and the new error message.
+9. ~ README.md: + Equality section, + Subset and superset section, + design-philosophy paragraph in the opening and one-line principle callouts in the dimensions, formulae, set-operator, and equality sections.
+10. + script/md4print, ~ Rakefile: + rake docs:print, docs:pdf, docs:all for regenerating docs/*.print.md and docs/*.print.pdf.
+11. ~ Namo::VERSION: /0.5.0/0.6.0/
+
 20260416
 0.5.0: + row-axis set operations: intersection (&), union (|), symmetric difference (^)
 

data/README.md

@@ -4,6 +4,8 @@ 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 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
 
 ```
@@ -44,6 +46,8 @@ sales.coordinates[:quarter]
 # => ['Q1', 'Q2']
 ```
 
+Every key is a dimension; every value is a coordinate. There's no schema declaration and no choosing which column is "the index" — `price` and `quantity` are no less first-class than `product` and `quarter`.
+
 ### Selection
 
 Select by named dimension using keyword arguments:
@@ -155,6 +159,8 @@ Selection, projection, and contraction always return a new Namo instance, so eve
 
 ### Concatenation
 
+`+` is the first of Namo's binary operators: it takes a Namo on each side and returns a Namo. The same shape holds for `-`, `&`, `|`, `^`, `==`, `===`, `<`, `<=`, `>`, `>=` and (later) the composition operators — Namo in, Namo (or boolean) out — so analytical pipelines stay queryable end-to-end.
+
 `+` combines two Namo objects that share the same dimensions by appending the rows of the second to the first:
 
 ```ruby
@@ -280,6 +286,87 @@ set_a ^ set_b
 
 The dimensions must match; different dimensions raise an `ArgumentError`. Formulae merge from both sides; the left-hand side's formulae take precedence on conflict.
 
+### Equality
+
+Comparison on Namos is **multiset-theoretic on rows**: row order is ignored (it's an accident of ingestion, not data), but row multiplicities count (they *are* data). The same stance carries across the equality, pattern-match, and subset/superset operators below.
+
+`==` is multiset equality on rows. Class and formulae are ignored; row order is ignored; row multiplicities are not.
+
+```ruby
+a = Namo.new([{x: 1}, {x: 2}])
+b = Namo.new([{x: 2}, {x: 1}])
+
+a == b
+# => true
+
+a == Namo.new([{x: 1}, {x: 1}, {x: 2}])
+# => false
+```
+
+`eql?` is stricter: it also requires the class to match and the formula names to match. Like `===`, it ignores proc bodies — proc identity isn't a meaningful equivalence in Ruby (`proc{...} == proc{...}` is false), so neither `===` nor `eql?` uses it.
+
+`hash` is consistent with `eql?` and is content-based, so equal Namos hash equally and can be used as Hash keys:
+
+```ruby
+h = {a => 'first'}
+h[b]
+# => 'first'
+```
+
+`equal?` is unchanged from Ruby's default — it tests object identity.
+
+`===` answers a different question: does the candidate have the same dimensions and the same formula names? Row data is ignored, and so are the proc bodies themselves — only the names matter. This is the `===` semantics that case statements use, so Namos can serve as templates for analytical shape:
+
+```ruby
+sales_shape = Namo.new([{product: 'X', quarter: 'Q1', price: 0.0, quantity: 0}])
+sales_shape[:revenue] = proc{|row| row[:price] * row[:quantity]}
+
+q1 = Namo.new([{product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}])
+q1[:revenue] = proc{|row| row[:price] * row[:quantity]}
+
+sales_shape === q1
+# => true (same dimensions, same formula name)
+
+sales_shape == q1
+# => false (different rows)
+```
+
+The two `:revenue` procs are independently-written and not the same object — `proc{...} == proc{...}` is false in Ruby. But `===` doesn't compare proc identity; it asks "do these Namos have the same analytical shape?" and the shape is the set of dimensions plus the set of formula names.
+
+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.
+
+### Subset and Superset
+
+`<`, `<=`, `>`, `>=` are multiset subset and superset relations on rows.
+
+```ruby
+small = Namo.new([{x: 1}, {x: 2}])
+large = Namo.new([{x: 1}, {x: 2}, {x: 3}])
+
+small <= large
+# => true
+
+small < large
+# => true
+
+large > small
+# => true
+```
+
+Equal sets are `<=` and `>=` each other, but neither `<` nor `>`. Disjoint sets are none of the above — unless one side is empty, in which case it is a subset of (and disjoint with) the other.
+
+Multiplicity matters: a single `{x: 1}` is a proper subset of two `{x: 1}`s.
+
+```ruby
+one = Namo.new([{x: 1}])
+two = Namo.new([{x: 1}, {x: 1}])
+
+one < two
+# => true
+```
+
+The dimensions must match; different dimensions raise an `ArgumentError`. Comparing against a non-Namo raises a `TypeError`.
+
 ### Formulae
 
 Define computed dimensions using `[]=`:
@@ -296,6 +383,8 @@ sales[:product, :quarter, :revenue]
 # ]>
 ```
 
+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:
 
 ```ruby
@@ -323,6 +412,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:
@@ -354,7 +515,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
@@ -366,6 +527,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

@@ -6,4 +6,37 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
+namespace :docs do
+  SOURCE_DOCS = %w{COMPARISON EXAMPLES README ROADMAP}
+
+  desc "Strip syntax highlighting from code blocks for printing"
+  task :md4print do
+    SOURCE_DOCS.each do |name|
+      sh "script/md4print #{name}.md"
+      sh "mv #{name}.print.md docs/"
+    end
+  end
+
+  desc "Render print-ready markdown to PDF"
+  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 -V mainfont=Charter -V monofont=Menlo -o #{pdf}"
+    end
+  end
+
+  desc "Remove intermediate .print.md files"
+  task :clean do
+    rm_f Dir.glob('docs/*.print.md')
+  end
+
+  desc "Remove all generated docs (intermediates and PDFs)"
+  task :clobber => :clean do
+    rm_f Dir.glob('docs/*.print.pdf')
+  end
+
+  desc "Regenerate all derived docs"
+  task :gen => [:md2pdf, :clean]
+end
+
 task default: :test

data/lib/Namo/VERSION.rb

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

data/lib/namo.rb

@@ -1,9 +1,9 @@
 # namo.rb
 # Namo
 
-require_relative 'Namo/NegatedDimension'
-require_relative 'Namo/Row'
-require_relative 'Symbol'
+require_relative './Namo/NegatedDimension'
+require_relative './Namo/Row'
+require_relative './Symbol'
 
 class Namo
   include Enumerable
@@ -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
@@ -57,40 +81,80 @@ class Namo
   end
 
   def +(other)
-    unless dimensions == other.dimensions
-      raise ArgumentError, "dimensions do not match"
-    end
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
     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
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new(@data - other.data, formulae: @formulae.dup)
   end
 
   def &(other)
-    unless dimensions == other.dimensions
-      raise ArgumentError, "dimensions do not match"
-    end
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new(@data & other.data, formulae: @formulae.dup)
   end
 
   def |(other)
-    unless dimensions == other.dimensions
-      raise ArgumentError, "dimensions do not match"
-    end
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
     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
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
     self.class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
   end
 
+  def ==(other)
+    return false unless other.is_a?(Namo)
+    canonical_data == other.canonical_data
+  end
+
+  def ===(other)
+    return false unless other.is_a?(Namo)
+    dimensions.sort == other.dimensions.sort &&
+      @formulae.keys.sort == other.formulae.keys.sort
+  end
+
+  def eql?(other)
+    self.class == other.class &&
+      canonical_data == other.canonical_data &&
+      @formulae.keys.sort == other.formulae.keys.sort
+  end
+
+  def hash
+    [self.class, canonical_data, @formulae.keys.sort].hash
+  end
+
+  def <(other)
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
+    proper_subset_of_rows?(other)
+  end
+
+  def <=(other)
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
+    subset_of_rows?(other)
+  end
+
+  def >(other)
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
+    other.proper_subset_of_rows?(self)
+  end
+
+  def >=(other)
+    raise_unless_namo(other)
+    raise_unless_matching_data_dimensions(other)
+    other.subset_of_rows?(self)
+  end
+
   def to_a
     @data.map do |row|
       row.keys.each_with_object({}) do |key, hash|
@@ -99,8 +163,44 @@ class Namo
     end
   end
 
+  protected
+
+  def canonical_data
+    @data.sort_by{|row| row.values_at(*data_dimensions.sort)}
+  end
+
+  def subset_of_rows?(other)
+    self_counts = canonical_data.tally
+    other_counts = other.canonical_data.tally
+    self_counts.all?{|row, count| (other_counts[row] || 0) >= count}
+  end
+
+  def proper_subset_of_rows?(other)
+    subset_of_rows?(other) && self != other
+  end
+
   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_data_dimensions(other)
+    unless data_dimensions == other.data_dimensions
+      raise ArgumentError, "dimensions don't match: #{data_dimensions} vs #{other.data_dimensions}"
+    end
+  end
+
   def initialize(data = nil, formulae: {})
     @data = data
     @formulae = formulae

data/namo.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
   spec.license = 'MIT'
 
   spec.required_ruby_version = '>= 2.7'
-
   spec.require_paths = ['lib']
 
   spec.files = [

data/test/{Namo_test.rb → 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
@@ -466,6 +606,282 @@ describe Namo do
     end
   end
 
+  describe "#==" do
+    it "is true for same data, same order" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 1}, {x: 2}])
+      _(a == b).must_equal true
+    end
+
+    it "is true for same data, different order" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 2}, {x: 1}])
+      _(a == b).must_equal true
+    end
+
+    it "is false for different data" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 1}, {x: 3}])
+      _(a == b).must_equal false
+    end
+
+    it "is multiset-aware: duplicates count" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{x: 1}, {x: 1}])
+      _(a == b).must_equal false
+    end
+
+    it "is true across subclasses with same data" do
+      subclass = Class.new(Namo)
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = subclass.new([{x: 1}, {x: 2}])
+      _(a == b).must_equal true
+    end
+
+    it "ignores formulae" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 1}, {x: 2}])
+      b[:y] = proc{|row| row[:x] * 2}
+      _(a == b).must_equal true
+    end
+
+    it "is false against a non-Namo" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      _(a == [{x: 1}, {x: 2}]).must_equal false
+      _(a == 'string').must_equal false
+      _(a == nil).must_equal false
+    end
+  end
+
+  describe "#===" do
+    it "is true when dimensions and formulae match, ignoring rows" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{x: 2}, {x: 3}])
+      _(a === b).must_equal true
+    end
+
+    it "is false when formulae differ" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{x: 1}])
+      b[:doubled] = proc{|row| row[:x] * 2}
+      _(a === b).must_equal false
+    end
+
+    it "is true when formulae have the same names, regardless of proc identity" do
+      a = Namo.new([{x: 1}])
+      a[:doubled] = proc{|row| row[:x] * 2}
+      b = Namo.new([{x: 1}])
+      b[:doubled] = proc{|row| row[:x] * 2}
+      _(a === b).must_equal true
+    end
+
+    it "is false when dimensions differ" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{y: 1}])
+      _(a === b).must_equal false
+    end
+
+    it "is true when dimensions are in different order" do
+      a = Namo.new([{x: 1, y: 2}])
+      b = Namo.new([{y: 9, x: 8}])
+      _(a === b).must_equal true
+    end
+
+    it "is false for a non-Namo and does not raise" do
+      a = Namo.new([{x: 1}])
+      _(a === [{x: 1}]).must_equal false
+      _(a === 'string').must_equal false
+      _(a === nil).must_equal false
+    end
+
+    it "drives case statement dispatch on analytical type" do
+      template = Namo.new([{x: 0}])
+      candidate = Namo.new([{x: 5}, {x: 6}])
+      result = case candidate
+               when template; :matched
+               else; :not_matched
+               end
+      _(result).must_equal :matched
+    end
+  end
+
+  describe "#eql?" do
+    it "is true for same class, same data, no formulae" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 1}, {x: 2}])
+      _(a.eql?(b)).must_equal true
+    end
+
+    it "is true for same class, same data, different order" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 2}, {x: 1}])
+      _(a.eql?(b)).must_equal true
+    end
+
+    it "is true when formula names match, regardless of proc identity" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      a[:y] = proc{|row| row[:x] * 2}
+      b = Namo.new([{x: 1}, {x: 2}])
+      b[:y] = proc{|row| row[:x] * 2}
+      _(a.eql?(b)).must_equal true
+    end
+
+    it "is false when formula names differ" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      a[:doubled] = proc{|row| row[:x] * 2}
+      b = Namo.new([{x: 1}, {x: 2}])
+      b[:tripled] = proc{|row| row[:x] * 3}
+      _(a.eql?(b)).must_equal false
+    end
+
+    it "is false across different classes" do
+      subclass = Class.new(Namo)
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = subclass.new([{x: 1}, {x: 2}])
+      _(a.eql?(b)).must_equal false
+    end
+  end
+
+  describe "#hash" do
+    it "is equal for set-equal Namos" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 2}, {x: 1}])
+      _(a.hash).must_equal b.hash
+    end
+
+    it "differs when formula names differ" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 1}, {x: 2}])
+      b[:y] = proc{|row| row[:x] * 2}
+      _(a.hash).wont_equal b.hash
+    end
+
+    it "is equal when formula names match, regardless of proc identity" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      a[:y] = proc{|row| row[:x] * 2}
+      b = Namo.new([{x: 1}, {x: 2}])
+      b[:y] = proc{|row| row[:x] * 2}
+      _(a.hash).must_equal b.hash
+    end
+
+    it "differs across classes" do
+      subclass = Class.new(Namo)
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = subclass.new([{x: 1}, {x: 2}])
+      _(a.hash).wont_equal b.hash
+    end
+
+    it "makes Namos usable as Hash keys" do
+      a = Namo.new([{x: 1}, {x: 2}])
+      b = Namo.new([{x: 2}, {x: 1}])
+      h = {a => 'first'}
+      _(h[b]).must_equal 'first'
+    end
+  end
+
+  describe "#<, #<=, #>, #>=" do
+    let(:small) { Namo.new([{x: 1}, {x: 2}]) }
+    let(:large) { Namo.new([{x: 1}, {x: 2}, {x: 3}]) }
+    let(:disjoint) { Namo.new([{x: 4}, {x: 5}]) }
+
+    it "recognises proper subset" do
+      _(small < large).must_equal true
+      _(small <= large).must_equal true
+      _(large > small).must_equal true
+      _(large >= small).must_equal true
+    end
+
+    it "treats equal sets as <= and >= but not < or >" do
+      copy = Namo.new([{x: 2}, {x: 1}])
+      _(small <= copy).must_equal true
+      _(small >= copy).must_equal true
+      _(small < copy).must_equal false
+      _(small > copy).must_equal false
+    end
+
+    it "treats disjoint sets as neither subset nor superset" do
+      _(small <= disjoint).must_equal false
+      _(small >= disjoint).must_equal false
+      _(small < disjoint).must_equal false
+      _(small > disjoint).must_equal false
+    end
+
+    it "is multiset-aware: a single row is a proper subset of two of the same row" do
+      one = Namo.new([{x: 1}])
+      two = Namo.new([{x: 1}, {x: 1}])
+      _(one < two).must_equal true
+      _(one <= two).must_equal true
+      _(two <= one).must_equal false
+      _(two < one).must_equal false
+    end
+
+    it "raises ArgumentError on mismatched dimensions" do
+      other = Namo.new([{y: 1}])
+      _ { small < other }.must_raise ArgumentError
+      _ { small <= other }.must_raise ArgumentError
+      _ { small > other }.must_raise ArgumentError
+      _ { small >= other }.must_raise ArgumentError
+    end
+
+    it "raises TypeError on non-Namo" do
+      _ { small < [{x: 1}] }.must_raise TypeError
+      _ { small <= 'string' }.must_raise TypeError
+      _ { small > nil }.must_raise TypeError
+      _ { small >= 42 }.must_raise TypeError
+    end
+  end
+
+  describe "#equal?" do
+    it "is false for distinct objects" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{x: 1}])
+      _(a.equal?(b)).must_equal false
+    end
+
+    it "is true for the same object" do
+      a = Namo.new([{x: 1}])
+      _(a.equal?(a)).must_equal true
+    end
+  end
+
+  describe "dimension-mismatch error message" do
+    it "names both dimension lists" do
+      a = Namo.new([{x: 1}])
+      b = Namo.new([{y: 1}])
+      err = _ { a + b }.must_raise ArgumentError
+      _(err.message).must_match(/dimensions don't match/)
+      _(err.message).must_match(/\[:x\]/)
+      _(err.message).must_match(/\[:y\]/)
+    end
+  end
+
+  describe "non-Namo comparison error message" do
+    it "names the offending class" do
+      a = Namo.new([{x: 1}])
+      err = _ { a < 'string' }.must_raise TypeError
+      _(err.message).must_match(/can't compare Namo with/)
+      _(err.message).must_match(/String/)
+    end
+  end
+
+  describe "non-Namo set operation error message" do
+    it "raises TypeError on non-Namo for #+, #-, #&, #|, #^" do
+      a = Namo.new([{x: 1}])
+      _ { a + [{x: 1}] }.must_raise TypeError
+      _ { a - 'string' }.must_raise TypeError
+      _ { a & nil }.must_raise TypeError
+      _ { a | 42 }.must_raise TypeError
+      _ { a ^ :symbol }.must_raise TypeError
+    end
+
+    it "names the offending class" do
+      a = Namo.new([{x: 1}])
+      err = _ { a + 'string' }.must_raise TypeError
+      _(err.message).must_match(/can't compare Namo with/)
+      _(err.message).must_match(/String/)
+    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.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - thoran
@@ -72,8 +72,8 @@ files:
 - namo.gemspec
 - test/Namo/NegatedDimension_test.rb
 - test/Namo/Row_test.rb
-- test/Namo_test.rb
 - test/Symbol_test.rb
+- test/namo_test.rb
 homepage: https://github.com/thoran/namo
 licenses:
 - MIT
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.11
 specification_version: 4
 summary: Named dimensional data for Ruby.
 test_files: []