namo 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78880ca991afa35b970cc09625c4ca632db3a3ff69e7b4c69fda2fa3b536bd08
-  data.tar.gz: b85bfe8ef28cf45880e8ebda997d209e7a4f6d545710bad52ec4f6e5c790e30f
+  metadata.gz: dcb7aafe4522ff115c12464016fef1a6909047975829523b095105f601a7ae60
+  data.tar.gz: 81f150f5f370f836734908a30e1ecd600b856f90c0151a698fa25bd117530d92
 SHA512:
-  metadata.gz: c61419caff79be760cc24d3cd67eb008107061a65041853bd5108e51c70bf0fb100e50c899241b2ae45de59d92c9f7bcd6173eb2af279543c9057c186c3ec4ba
-  data.tar.gz: 5b9fe7311512c5a59f6528d70a82724f35323769267a804784d14a83351da08cb62000feb6f676e396ecd45c79397413f754cb09c599e5204f28212e95caa872
+  metadata.gz: 6fd5a96f0fdf85e6ffb8a3cfa2d1a560d5da1d118072e95cd549af43149ff2a4c963de122b9026c29c0817e33fcfbd2ba3ece969ee1f6f5d92738c3d7f38b73a
+  data.tar.gz: 78ba07312d7e4f4d4ac85a6ca572852964ed7055d48687361d8a86f9cb998122f421e75418ba67bc978bf78d7b0cc22315ebb800ca734e8ade07817bae886736

data/CHANGELOG

@@ -1,6 +1,86 @@
 CHANGELOG
 _________
 
+20260612
+0.16.0: ~ data/formula exclusivity — projection drops the formulae it materialises; * and ** raise on a data/formula name collision.
+
+1. ~ lib/namo.rb: Namo#[]'s positive-projection branch carries @formulae minus the projected
+   derived names — naming a derived dimension materialises it (stored values, computed against
+   the yielding Namo, windowed over any same-call selection) and drops the formula; omitted
+   formulae carry live and recompute from the result's own rows. Contraction and selection-only
+   calls are unchanged. The projection list is the materialise/live selector.
+2. ~ lib/namo.rb: Namo#* and Namo#** raise ArgumentError via the new private
+   raise_unless_data_formula_exclusivity when one operand's data dimension is the other's
+   derived dimension, block and no-block forms alike. Formula-vs-formula stays left-wins; the
+   set operators need no guard (matching-data-dimensions blocks the asymmetric case); the
+   constructor stays unguarded.
+3. ~ test/namo_test.rb: + "data/formula exclusivity" describe — access-path agreement on a
+   materialised dimension, dimension-listing, dependent-formula carry, omitted-formula
+   liveness, live-without-inputs caveat, two-arity windowing at materialisation,
+   contraction/selection unchanged, subclass type, composition collision raises (both
+   directions, both operators, block forms), left-wins formula merge, contraction-first
+   resolution.
+4. ~ test/namo_test.rb: + "range selection" context under #[] — basic range, beginless and
+   endless forms, range composed with projection, range on a formula-defined dimension
+   (Row_test holds the predicate matrix; these pin the Namo-level wiring).
+5. ~ README.md: + Projection of derived dimensions subsection under Formulae (naming
+   materialises, omitting carries live); data/formula collision sentences under Composition
+   and Cartesian product.
+6. ~ ROADMAP.md: Promote 0.16.0 to shipped; Current state -> 0.16.0; Summary folds in
+   exclusivity; next phase -> 0.17.0. window.length -> window.count and n.length -> n.count
+   in the remaining future-release examples (0.17.0, 2.x, 4.x) — Namo has no #length,
+   extending the 0.15.0 correction.
+7. ~ COMPARISON.md: Repoint the pre-renumbering planned markers to what shipped — proc-based,
+   regex-based, and mixed selection -> shipped (0.8.0); Enumerable methods return Namos ->
+   shipped (0.11.0), with the entry summary's parity sentence and the Sorting entry's
+   "as of 0.14.0" corrected to 0.11.0; values and to_h -> shipped (0.7.0). Aspect classes ->
+   not planned, the entry rewritten to record 0.7.0's plain-return-types decision (Namo#===
+   and subclassing cover case dispatch; a Matcher factory can serve a finer split later).
+   Aggregation repointed from 2.x to group_by returning a Namo::Collection at 0.19.0 (gated
+   on Collection at 0.18.0), with summary/members examples; bare names stay 2.x. Parameterised
+   formulae stays planned (0.17.0), its example's window.length -> window.count.
+8. ~ EXAMPLES.md: + Epidemiology / public health section — a cross-row (two-arity) rolling
+   weekly average in the four-stage format (Polars, then Namo 1.x/2.x/3.x), with the
+   (row, namo) window over the yielding Namo and a one-arity formula referencing the
+   two-arity one. window.length -> window.count in the finance 1.x and 2.x stages. Date
+   bumped to 20260612.
+9. ~ Namo::VERSION: /0.15.0/0.16.0/
+
+20260612
+0.15.0: + two-arity formulae — procs with arity 2 receive (row, namo) for cross-row computation.
+
+1. ~ lib/Namo/Row.rb: Row's constructor gains an optional third parameter, namo (default nil),
+   stored in @namo — the Namo that yielded the Row; the two-argument form keeps working.
+   Row#[] dispatches on formula arity: exactly 2 calls formula.call(self, @namo), raising
+   ArgumentError via the new private raise_unless_namo_context when @namo is nil; every
+   other arity (0, 1, negative) keeps the existing formula.call(self) unchanged.
+2. ~ lib/Namo/Enumerable.rb: every Row construction (each, select and its aliases, reject,
+   sort_by, first, last, take_while, drop_while, uniq's block form, partition) passes self
+   as the Row's namo, so two-arity formulae resolve during enumeration and predicate
+   evaluation, with the yielding Namo as the window.
+3. ~ lib/namo.rb: values_for's derived branch and the * and ** block paths pass self as the
+   Row's namo — values/coordinates/to_h resolve two-arity dimensions, and composition-block
+   rows can resolve self's two-arity formulae (extension of the 0.14.0 block contract; the
+   (Row, Namo) -> Namo contract and result-formulae rule are unchanged).
+4. ~ test/Namo/Row_test.rb: + constructor third-argument and backward-compatibility tests,
+   arity-dispatch tests (1, 2, 0, negative), the nil-namo ArgumentError, and match? on a
+   two-arity derived dimension.
+5. ~ test/namo_test.rb: + "#[]= two-arity formulae" describe — SMA cross-row resolution via
+   values/coordinates/to_h, selection and subset-predicate resolution, first/last Rows,
+   yielding-Namo (filtered-window) semantics, liveness, operator carry-through, composition-
+   block resolution, mixed-arity chains, and the empty-Namo case.
+6. ~ README.md: + Cross-row formulae subsection under Formulae, with the SMA example, the
+   yielding-Namo semantic, and the no-context error.
+7. ~ ROADMAP.md: Promote 0.15.0 to shipped; Current state -> 0.15.0; Summary folds in
+   two-arity formulae; the example's window.length corrected to window.count (Namo has
+   no length); "Live computation objects" phrasing updated. + upcoming 0.16.0 section,
+   Data/formula exclusivity — projection drops the formulae it materialises, * and **
+   raise on a data/formula name collision — with parameterised formulae renumbered to
+   0.17.0, Namo::Collection to 0.18.0, and group_by to 0.19.0; next phase -> 0.16.0.
+8. ~ COMPARISON.md: Two-arity formulae -> shipped (0.15.0) with the same window.count
+   correction; Parameterised formulae repointed to planned (0.17.0). Date bumped.
+9. ~ Namo::VERSION: /0.14.0/0.15.0/
+
 20260608
 0.14.0: + blocks on the composition operators (*, **) for custom match refinement.
 

data/README.md

@@ -353,7 +353,7 @@ ohlcv * fundamentals
 
 Inner-join semantics: unmatched rows from either side are dropped. Output dimensions are `self.data_dimensions` followed by `other.data_dimensions` exclusive to other. Duplicates on shared coordinates are preserved multiplicatively — output multiplicity is the product of input multiplicities on each matching key.
 
-The two Namos must have at least one shared data dimension. No overlap raises an `ArgumentError` — the asymmetry with `**` is deliberate, and falling through to a Cartesian product would silently turn a logic error into a large pile of nonsense rows. Formulae merge from both sides; the left-hand side wins on conflict.
+The two Namos must have at least one shared data dimension. No overlap raises an `ArgumentError` — the asymmetry with `**` is deliberate, and falling through to a Cartesian product would silently turn a logic error into a large pile of nonsense rows. Formulae merge from both sides; the left-hand side wins on conflict. A name that is data on one side and a formula on the other also raises an `ArgumentError` — the operands disagree about what the name means, with no last-write order to appeal to — so resolve before composing: `audited[-:margin] * modelled`.
 
 #### Conditional join
 
@@ -404,7 +404,7 @@ products ** quarters
 
 Output has `self.data.length * other.data.length` rows. Output dimensions are `self.data_dimensions + other.data_dimensions`, in operand order. Duplicates are preserved multiplicatively.
 
-The two Namos must have **no** shared data dimensions — the precondition is the mirror image of `*`. Any overlap raises an `ArgumentError`; allowing it would produce rows with the same dimension named twice. Formulae merge from both sides; the left-hand side wins on conflict.
+The two Namos must have **no** shared data dimensions — the precondition is the mirror image of `*`. Any overlap raises an `ArgumentError`; allowing it would produce rows with the same dimension named twice. Formulae merge from both sides; the left-hand side wins on conflict, and a data/formula name collision between the operands raises, as for `*`.
 
 The visual relationship is intentional: `*` is the filtered version, `**` is the explosive version — more sigil, more output.
 
@@ -644,6 +644,48 @@ sales[product: 'Widget'][:revenue, :quarter]
 
 Formulae carry through selection — a filtered Namo instance remembers its formulae.
 
+#### Projection of derived dimensions
+
+Naming a derived dimension in a projection asks for its values: they are computed against the source and stored in the result's rows, and the formula is dropped — the name is a data dimension of the result. Omitting it carries the formula live, recomputing from the result's own rows on every access:
+
+```ruby
+sales[:price, :quantity, :revenue].derived_dimensions
+# => [] — :revenue is stored values, a snapshot taken at projection
+
+sales[:price, :quantity].derived_dimensions
+# => [:revenue] — :revenue recomputes from the projected rows on every access
+```
+
+The projection list is the selector: name a derived dimension for a snapshot, omit it to keep it as computation. A carried formula whose inputs the projection dropped breaks on access — the same caveat as contracting away a formula's inputs.
+
+#### Cross-row formulae
+
+A formula's arity selects its calling convention. A proc with **one** parameter receives the row, as above. A proc with **two** parameters receives `(row, namo)`, where `namo` is the Namo the row belongs to — so the formula can reach beyond the current row to the rest of the collection. That's what cross-row computation needs: moving windows, ranks, running totals, anything whose value depends on the row's neighbours.
+
+A simple moving average reads the surrounding rows through `namo`:
+
+```ruby
+prices = Namo.new([
+  {symbol: 'AAA', date: 1, close: 10.0},
+  {symbol: 'AAA', date: 2, close: 20.0},
+  {symbol: 'AAA', date: 3, close: 30.0}
+])
+
+prices[:sma] = proc{|row, namo|
+  window = namo[symbol: row[:symbol], date: ->(d){d <= row[:date]}]
+  window.values(:close).sum / window.count.to_f
+}
+
+prices.values(:sma)
+# => [10.0, 15.0, 20.0]
+```
+
+`namo` is the Namo that yielded the row, live — so the window always reflects the current state of the object you ask through. A filtered Namo's rows window over the filtered rows; an operator result's rows window over the result. Appending a row changes every cross-row value on the next access, with no caching.
+
+One-arity formulae are unchanged, and the two forms mix freely — a one-arity formula can reference a two-arity one, and a two-arity formula can reference a one-arity one, by name.
+
+Resolving a two-arity formula needs a Namo to window over. A `Row` constructed directly, without one, raises an `ArgumentError` naming the formula rather than letting the missing context surface as an unrelated error.
+
 ### Polymorphic `[]=`
 
 `[]=` dispatches on the type of the value assigned. A proc registers a formula, as above. Anything else broadcasts the value to every row:

data/lib/Namo/Enumerable.rb

@@ -7,28 +7,28 @@ class Namo
 
     def each(&block)
       return enum_for(:each) unless block_given?
-      @data.each{|row_data| block.call(Row.new(row_data, @formulae))}
+      @data.each{|row_data| block.call(Row.new(row_data, @formulae, self))}
     end
 
     def select(&block)
-      self.class.new(@data.select{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+      self.class.new(@data.select{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
     end
     alias_method :filter, :select
     alias_method :find_all, :select
 
     def reject(&block)
-      self.class.new(@data.reject{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+      self.class.new(@data.reject{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
     end
 
     def sort_by(&block)
-      self.class.new(@data.sort_by{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+      self.class.new(@data.sort_by{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
     end
 
     def first(n = nil)
       if n
         self.class.new(@data.first(n), formulae: @formulae.dup)
       else
-        @data.first ? Row.new(@data.first, @formulae) : nil
+        @data.first ? Row.new(@data.first, @formulae, self) : nil
       end
     end
 
@@ -36,7 +36,7 @@ class Namo
       if n
         self.class.new(@data.last(n), formulae: @formulae.dup)
       else
-        @data.last ? Row.new(@data.last, @formulae) : nil
+        @data.last ? Row.new(@data.last, @formulae, self) : nil
       end
     end
 
@@ -49,20 +49,20 @@ class Namo
     end
 
     def take_while(&block)
-      self.class.new(@data.take_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+      self.class.new(@data.take_while{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
     end
 
     def drop_while(&block)
-      self.class.new(@data.drop_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+      self.class.new(@data.drop_while{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
     end
 
     def uniq(&block)
-      rows = block ? @data.uniq{|row| block.call(Row.new(row, @formulae))} : @data.uniq
+      rows = block ? @data.uniq{|row| block.call(Row.new(row, @formulae, self))} : @data.uniq
       self.class.new(rows, formulae: @formulae.dup)
     end
 
     def partition(&block)
-      matches, non_matches = @data.partition{|row| block.call(Row.new(row, @formulae))}
+      matches, non_matches = @data.partition{|row| block.call(Row.new(row, @formulae, self))}
       [
         self.class.new(matches, formulae: @formulae.dup),
         self.class.new(non_matches, formulae: @formulae.dup),

data/lib/Namo/Row.rb

@@ -5,7 +5,13 @@ class Namo
   class Row
     def [](name)
       if @formulae.key?(name)
-        @formulae[name].call(self)
+        case @formulae[name].arity
+        when 2
+          raise_unless_namo_context(name)
+          @formulae[name].call(self, @namo)
+        else
+          @formulae[name].call(self)
+        end
       else
         @row[name]
       end
@@ -44,9 +50,16 @@ class Namo
 
     private
 
-    def initialize(row, formulae)
+    def initialize(row, formulae, namo = nil)
       @row = row
       @formulae = formulae
+      @namo = namo
+    end
+
+    def raise_unless_namo_context(name)
+      unless @namo
+        raise ArgumentError, "two-arity formula #{name.inspect} requires a Namo context, but this Row has none"
+      end
     end
   end
 end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.14.0'
+  VERSION = '0.16.0'
 end

data/lib/namo.rb

@@ -71,7 +71,8 @@ class Namo
         rows.map(&:to_h)
       end
     )
-    self.class.new(projected, formulae: @formulae.dup)
+    carried = positive.any? ? @formulae.reject{|name, _| positive.include?(name)} : @formulae.dup
+    self.class.new(projected, formulae: carried)
   end
 
   def []=(name, value)
@@ -118,13 +119,14 @@ class Namo
   def *(other, &block)
     raise_unless_namo(other)
     raise_unless_shared_data_dimensions(other)
+    raise_unless_data_formula_exclusivity(other)
     shared = data_dimensions & other.data_dimensions
     combined_data = []
     @data.each do |left_row|
       matched = other.data.select{|right_row| shared.all?{|dim| left_row[dim] == right_row[dim]}}
       if block
         candidates = other.class.new(matched, formulae: other.formulae.dup)
-        chosen = block.call(Row.new(left_row, @formulae), candidates)
+        chosen = block.call(Row.new(left_row, @formulae, self), candidates)
         chosen.data.each{|right_row| combined_data << left_row.merge(right_row)}
       else
         matched.each{|right_row| combined_data << left_row.merge(right_row)}
@@ -136,11 +138,12 @@ class Namo
   def **(other, &block)
     raise_unless_namo(other)
     raise_unless_disjoint_data_dimensions(other)
+    raise_unless_data_formula_exclusivity(other)
     combined_data = []
     @data.each do |left_row|
       if block
         candidates = other.class.new(other.data, formulae: other.formulae.dup)
-        chosen = block.call(Row.new(left_row, @formulae), candidates)
+        chosen = block.call(Row.new(left_row, @formulae, self), candidates)
         chosen.data.each{|right_row| combined_data << left_row.merge(right_row)}
       else
         other.data.each{|right_row| combined_data << left_row.merge(right_row)}
@@ -229,11 +232,17 @@ class Namo
 
   private
 
+  def initialize(positional_data = nil, data: [], formulae: {}, name: nil)
+    @data = positional_data || data
+    @formulae = formulae
+    @name = name
+  end
+
   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]}
+      @data.map{|row_data| Row.new(row_data, @formulae, self)[dim]}
     end
   end
 
@@ -261,9 +270,10 @@ class Namo
     end
   end
 
-  def initialize(positional_data = nil, data: [], formulae: {}, name: nil)
-    @data = positional_data || data
-    @formulae = formulae
-    @name = name
+  def raise_unless_data_formula_exclusivity(other)
+    collisions = (data_dimensions & other.derived_dimensions) | (derived_dimensions & other.data_dimensions)
+    if collisions.any?
+      raise ArgumentError, "name collision between data and formulae: #{collisions.inspect}"
+    end
   end
 end

data/test/Namo/Row_test.rb

@@ -40,6 +40,60 @@ describe Namo::Row do
     end
   end
 
+  describe "constructor" do
+    it "constructs from the two-argument form (namo defaults nil)" do
+      _(Namo::Row.new(row_data, formulae)).must_be_kind_of Namo::Row
+    end
+
+    it "accepts a third namo argument" do
+      namo = Namo.new([row_data])
+      _(Namo::Row.new(row_data, formulae, namo)).must_be_kind_of Namo::Row
+    end
+  end
+
+  describe "#[] arity dispatch" do
+    it "calls an arity-1 formula with the Row only" do
+      seen = nil
+      formulae[:dim] = ->(r){seen = r; 1}
+      row[:dim]
+      _(seen).must_be_same_as row
+    end
+
+    it "calls an arity-2 formula with the Row and the yielding Namo" do
+      namo = Namo.new([row_data])
+      row = Namo::Row.new(row_data, formulae, namo)
+      seen_row = nil
+      seen_namo = nil
+      formulae[:dim] = ->(r, n){seen_row = r; seen_namo = n; 1}
+      row[:dim]
+      _(seen_row).must_be_same_as row
+      _(seen_namo.equal?(namo)).must_equal true
+    end
+
+    it "takes the one-arity path for an arity-0 proc" do
+      formulae[:dim] = proc{42}
+      _(row[:dim]).must_equal 42
+    end
+
+    it "takes the one-arity path for a negative-arity proc" do
+      seen_rest = nil
+      formulae[:dim] = proc{|r, *rest| seen_rest = rest; 1}
+      row[:dim]
+      _(seen_rest).must_equal []
+    end
+
+    it "raises ArgumentError naming the formula when an arity-2 formula has no Namo context" do
+      formulae[:sma] = ->(r, n){n.count}
+      error = _(proc{row[:sma]}).must_raise ArgumentError
+      _(error.message).must_match(/sma/)
+    end
+
+    it "resolves an arity-1 formula on a Row with no Namo context" do
+      formulae[:revenue] = ->(r){r[:price] * r[:quantity]}
+      _(row[:revenue]).must_equal 1000.0
+    end
+  end
+
   describe "#match?" do
     it "matches a single value" do
       _(row.match?(product: 'Widget')).must_equal true
@@ -61,6 +115,14 @@ describe Namo::Row do
       _(row.match?(product: 'Widget', quarter: 'Q2')).must_equal false
     end
 
+    it "resolves a two-arity derived dimension when the Row carries a Namo" do
+      namo = Namo.new([row_data])
+      formulae[:row_count] = ->(r, n){n.count}
+      row = Namo::Row.new(row_data, formulae, namo)
+      _(row.match?(row_count: 1)).must_equal true
+      _(row.match?(row_count: 2)).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

data/test/namo_test.rb

@@ -491,6 +491,36 @@ describe Namo do
       end
     end
 
+    context "range selection" do
+      it "selects rows whose value falls within the range" do
+        result = sales[price: 5.0..15.0]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "supports beginless and endless ranges" do
+        _(sales[price: ..15.0].to_a.count).must_equal 2
+        _(sales[quantity: 100..].to_a.count).must_equal 2
+      end
+
+      it "composes with projection in a single call" do
+        result = sales[:product, :quantity, quantity: 50..120]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quantity: 100},
+          {product: 'Gadget', quantity: 60}
+        ]
+      end
+
+      it "selects on a formula-defined dimension" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        result = sales[revenue: 1200.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 "mixed proc and regex selection" do
       it "combines a proc and a regex across dimensions" do
         result = sales[product: /^W/, quantity: ->(v){v > 100}]
@@ -647,6 +677,296 @@ describe Namo do
     end
   end
 
+  describe "#[]= two-arity formulae" do
+    let(:price_data) do
+      [
+        {symbol: 'AAA', date: 1, close: 10.0},
+        {symbol: 'AAA', date: 2, close: 20.0},
+        {symbol: 'AAA', date: 3, close: 30.0},
+      ]
+    end
+
+    let(:prices) do
+      Namo.new(price_data)
+    end
+
+    # A simple moving average: the mean close over the rows of the same symbol
+    # up to and including the current row's date, computed against the Namo the
+    # row belongs to.
+    let(:sma) do
+      ->(row, namo){
+        window = namo[symbol: row[:symbol], date: ->(d){d <= row[:date]}]
+        window.values(:close).sum / window.count.to_f
+      }
+    end
+
+    it "resolves a cross-row SMA via values" do
+      prices[:sma] = sma
+      _(prices.values(:sma)).must_equal [10.0, 15.0, 20.0]
+    end
+
+    it "resolves through coordinates" do
+      prices[:sma] = sma
+      _(prices.coordinates(:sma)).must_equal [10.0, 15.0, 20.0]
+    end
+
+    it "resolves through the no-arg to_h" do
+      prices[:sma] = sma
+      _(prices.to_h[:sma]).must_equal [10.0, 15.0, 20.0]
+    end
+
+    it "selects on the two-arity dimension" do
+      prices[:sma] = sma
+      _(prices[sma: ->(v){v > 12.0}].values(:date)).must_equal [2, 3]
+    end
+
+    it "resolves a two-arity dimension in a subset-method predicate" do
+      prices[:sma] = sma
+      result = prices.select{|row| row[:sma] > 12.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:date)).must_equal [2, 3]
+    end
+
+    it "resolves the two-arity formula on the no-arg first Row" do
+      prices[:sma] = sma
+      _(prices.first[:sma]).must_equal 10.0
+    end
+
+    it "resolves the two-arity formula on the no-arg last Row" do
+      prices[:sma] = sma
+      _(prices.last[:sma]).must_equal 20.0
+    end
+
+    it "windows over the yielding Namo — a filtered Namo computes over the filtered rows only" do
+      prices[:sma] = sma
+      filtered = prices.select{|row| row[:date] >= 2}
+      # On the full Namo the date-2 SMA averages dates 1 and 2 (15.0); on the
+      # filtered Namo it sees only date 2, so the value differs.
+      _(prices.values(:sma)).must_equal [10.0, 15.0, 20.0]
+      _(filtered.values(:sma)).must_equal [20.0, 25.0]
+    end
+
+    it "is live: appending a row changes the two-arity result on next access" do
+      prices[:sma] = sma
+      _(prices.last[:sma]).must_equal 20.0
+      prices.data << {symbol: 'AAA', date: 4, close: 40.0}
+      _(prices.last[:sma]).must_equal 25.0
+    end
+
+    it "carries a two-arity formula through a set-operator result, windowing over the combined rows" do
+      a = Namo.new([{symbol: 'AAA', date: 1}, {symbol: 'AAA', date: 2}])
+      b = Namo.new([{symbol: 'AAA', date: 3}])
+      a[:peers] = ->(row, namo){namo.count}
+      _((a + b).values(:peers)).must_equal [3, 3, 3]
+    end
+
+    it "carries a merged two-arity formula through a composition result, windowing over the joined rows" do
+      left = Namo.new([{symbol: 'AAA', date: 1}, {symbol: 'AAA', date: 2}])
+      right = Namo.new([{symbol: 'AAA', sector: 'tech'}])
+      left[:peers] = ->(row, namo){namo.count}
+      result = left * right
+      _(result.values(:peers)).must_equal [2, 2]
+    end
+
+    it "resolves a two-arity formula of self inside a composition block" do
+      left = Namo.new([{symbol: 'AAA', date: 1}, {symbol: 'AAA', date: 2}])
+      right = Namo.new([{symbol: 'AAA', sector: 'tech'}])
+      left[:peers] = ->(row, namo){namo.count}
+      seen = nil
+      left.*(right){|row, candidates| seen = row[:peers]; candidates}
+      _(seen).must_equal 2
+    end
+
+    it "lets a one-arity formula reference a two-arity formula by name" do
+      prices[:sma] = sma
+      prices[:double_sma] = ->(row){row[:sma] * 2}
+      _(prices.values(:double_sma)).must_equal [20.0, 30.0, 40.0]
+    end
+
+    it "lets a two-arity formula reference a one-arity formula by name" do
+      prices[:tenth] = ->(row){row[:close] / 10.0}
+      prices[:tenth_plus_count] = ->(row, namo){row[:tenth] + namo.count}
+      _(prices.values(:tenth_plus_count)).must_equal [4.0, 5.0, 6.0]
+    end
+
+    it "returns [] for a two-arity dimension on an empty Namo without invoking the formula" do
+      invoked = false
+      empty = Namo.new([], formulae: {sma: ->(row, namo){invoked = true; 0}})
+      _(empty.values(:sma)).must_equal []
+      _(invoked).must_equal false
+    end
+  end
+
+  describe "data/formula exclusivity" do
+    context "projection" do
+      let(:price_data) do
+        [
+          {symbol: 'AAA', date: 1, close: 10.0},
+          {symbol: 'AAA', date: 2, close: 20.0},
+          {symbol: 'AAA', date: 3, close: 30.0},
+        ]
+      end
+
+      let(:prices) do
+        Namo.new(price_data)
+      end
+
+      let(:sma) do
+        ->(row, namo){
+          window = namo[symbol: row[:symbol], date: ->(d){d <= row[:date]}]
+          window.values(:close).sum / window.count.to_f
+        }
+      end
+
+      it "agrees across all access paths on a materialised dimension" do
+        prices[:sma] = sma
+        projected = prices[:date, :sma]
+        _(projected.values(:sma)).must_equal [10.0, 15.0, 20.0]
+        _(projected.first[:sma]).must_equal projected.values(:sma).first
+        _(projected[sma: ->(v){v > 12.0}].values(:date)).must_equal [2, 3]
+      end
+
+      it "lists a materialised dimension as data, not derived, exactly once" do
+        prices[:sma] = sma
+        projected = prices[:date, :sma]
+        _(projected.data_dimensions).must_include :sma
+        _(projected.derived_dimensions).wont_include :sma
+        _(projected.dimensions.count(:sma)).must_equal 1
+      end
+
+      it "carries a dependent formula not named in the projection, resolving off the materialised column" do
+        prices[:sma] = sma
+        prices[:double_sma] = ->(row){row[:sma] * 2}
+        projected = prices[:date, :sma]
+        _(projected.derived_dimensions).must_equal [:double_sma]
+        _(projected.values(:double_sma)).must_equal [20.0, 30.0, 40.0]
+      end
+
+      it "carries an omitted formula live, recomputing from the result's own rows" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        projected = sales[:price, :quantity]
+        _(projected.derived_dimensions).must_equal [:revenue]
+        _(projected.values(:revenue)).must_equal [1000.0, 1500.0, 1000.0, 1500.0]
+        projected.data.first[:quantity] = 200
+        _(projected.values(:revenue).first).must_equal 2000.0
+      end
+
+      it "breaks on access when a carried formula's inputs were dropped (caveat emptor)" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        projected = sales[:product]
+        _(projected.derived_dimensions).must_equal [:revenue]
+        _ { projected.values(:revenue) }.must_raise NoMethodError
+      end
+
+      it "materialises a two-arity formula windowed over the yielding Namo" do
+        prices[:sma] = sma
+        _(prices[:date, :sma].values(:sma)).must_equal [10.0, 15.0, 20.0]
+      end
+
+      it "windows a two-arity materialisation over a same-call selection" do
+        prices[:sma] = sma
+        projected = prices[:date, :sma, date: 2..3]
+        _(projected.values(:sma)).must_equal [20.0, 25.0]
+      end
+
+      it "carries all formulae through a selection-only call" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        result = sales[price: ..15.0]
+        _(result.derived_dimensions).must_equal [:revenue]
+        _(result.values(:revenue)).must_equal [1000.0, 1500.0]
+      end
+
+      it "carries all formulae through contraction" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        result = sales[-:quarter]
+        _(result.derived_dimensions).must_equal [:revenue]
+        _(result.values(:revenue)).must_equal [1000.0, 1500.0, 1000.0, 1500.0]
+      end
+
+      it "returns pure materialised values and empty formulae when only derived names are projected" do
+        prices[:sma] = sma
+        projected = prices[:sma]
+        _(projected.to_a).must_equal [{sma: 10.0}, {sma: 15.0}, {sma: 20.0}]
+        _(projected.formulae).must_equal({})
+      end
+
+      it "returns an instance of self's class" do
+        subclass = Class.new(Namo)
+        namo = subclass.new([{x: 1}])
+        namo[:double] = ->(row){row[:x] * 2}
+        _(namo[:double].class).must_equal subclass
+      end
+    end
+
+    context "composition" do
+      let(:audited) do
+        Namo.new([
+          {symbol: 'BHP', margin: 0.3},
+          {symbol: 'RIO', margin: 0.25}
+        ])
+      end
+
+      let(:modelled) do
+        namo = Namo.new([
+          {symbol: 'BHP', price: 10.0, cost: 6.0},
+          {symbol: 'RIO', price: 20.0, cost: 16.0}
+        ])
+        namo[:margin] = proc{|r| (r[:price] - r[:cost]) / r[:price]}
+        namo
+      end
+
+      let(:audited_orders) do
+        Namo.new([{order: 'A', margin: 0.3}])
+      end
+
+      let(:modelled_tiers) do
+        namo = Namo.new([{tier: 'light', price: 10.0, cost: 6.0}])
+        namo[:margin] = proc{|r| (r[:price] - r[:cost]) / r[:price]}
+        namo
+      end
+
+      it "raises on * when self's data dimension is other's derived dimension" do
+        _ { audited * modelled }.must_raise ArgumentError
+      end
+
+      it "raises on * when self's derived dimension is other's data dimension" do
+        _ { modelled * audited }.must_raise ArgumentError
+      end
+
+      it "raises on ** when self's data dimension is other's derived dimension" do
+        _ { audited_orders ** modelled_tiers }.must_raise ArgumentError
+      end
+
+      it "raises on ** when self's derived dimension is other's data dimension" do
+        _ { modelled_tiers ** audited_orders }.must_raise ArgumentError
+      end
+
+      it "raises in the block forms of both operators" do
+        _ { audited.*(modelled){|row, candidates| candidates} }.must_raise ArgumentError
+        _ { audited_orders.**(modelled_tiers){|row, candidates| candidates} }.must_raise ArgumentError
+      end
+
+      it "names the colliding dimensions in the message" do
+        err = _ { audited * modelled }.must_raise ArgumentError
+        _(err.message).must_match(/name collision between data and formulae/)
+        _(err.message).must_include ':margin'
+      end
+
+      it "does not raise on a formula-vs-formula collision — left wins" do
+        left = Namo.new([{symbol: 'BHP', close: 42.5}])
+        right = Namo.new([{symbol: 'BHP', pe: 14.5}])
+        left[:margin] = proc{|r| :left}
+        right[:margin] = proc{|r| :right}
+        _((left * right).values(:margin)).must_equal [:left]
+      end
+
+      it "composes after explicit resolution by contraction" do
+        result = audited[-:margin] * modelled
+        _(result.values(:margin)).must_equal [0.4, 0.2]
+      end
+    end
+  end
+
   describe "#each" do
     it "yields Row objects" do
       rows = []

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.16.0
 platform: ruby
 authors:
 - thoran
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Named dimensional data for Ruby.
 test_files: []