namo 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff324711fe932145ecc01cedadee6453f80fe6610d162783a7dea053d2f35fc0
-  data.tar.gz: ec993e96d3ac5f1053eaa0f6c933347914209ed84423e78e3c4e5a4843c22915
+  metadata.gz: ad4994109308fd955b2f508afe1f07251bc4287406ed7f27eb8a484a61dfabcf
+  data.tar.gz: 04be0a1d0e8f97b86932a3e5e8953bfe3b0e51fe16bcb80b5dec9a5a73aecd36
 SHA512:
-  metadata.gz: 863aa8aeb8432d3fed7da33218ce14790a24a5e4a4b1c70a09b44aa495ef7ebe1bba36954622a1629990ff61cd892904725ee2293613e63c51ca48e0e6d05c18
-  data.tar.gz: 343949804d61f4dd93a636a961d6c097f9f1c20f7010044d67fbab34aaba75f1b3c9b33cd42f2f74f1ce189fd9324e6a18398b7b595fda11ca2fc44cfbcfc1c0
+  metadata.gz: 507a77ecfc3d23fe1ad4ef14783b2e4f86ff44b58431cb93b8e4aa41c12bf4778f03c7a3bdca7f8958620b3d2e3bba3292cdfbcd5636c8286661aed100398b30
+  data.tar.gz: fa6acfcf416108a871e0697ae998cef8701263446abee9089c62e1cfb24c102d22f002e643f89890a7c40ad2ccedca3dd7d58ebf04125fb4a87d17f58a908abd

data/CHANGELOG

@@ -1,6 +1,28 @@
 CHANGELOG
 _________
 
+20260601
+0.11.1: Extract the subset Enumerable methods into a Namo::Enumerable module.
+
+1. + lib/Namo/Enumerable.rb: New module Namo::Enumerable holding each and the subset-returning Enumerable methods (select plus its filter/find_all aliases, reject, sort_by, first, last, take, drop, take_while, drop_while, uniq, partition), moved verbatim from Namo. The module does `include ::Enumerable` — the leading :: is required, because under the nested `class Namo; module Enumerable` scope a bare `Enumerable` resolves to Namo::Enumerable itself and raises a cyclic-include error.
+2. ~ lib/namo.rb: Remove the inline each and the eleven subset methods; remove `include Enumerable`; + `require_relative './Namo/Enumerable'` and `include Namo::Enumerable` (which transitively brings stdlib Enumerable into the ancestor chain below the module, so the overrides win and map/reduce/etc. still fall through). Pure reorganisation — no behaviour change.
+3. ~ test/namo_test.rb: + Namo::Enumerable module tests — it is a Module, Namo includes it and stdlib Enumerable, and it precedes ::Enumerable in Namo.ancestors so the overrides resolve first. The existing Enumerable subset tests are unchanged and remain green, evidencing the move is behaviour-preserving.
+4. ~ ROADMAP.md: + note in the 0.11.0 section that, as of 0.11.1, these methods live in the Namo::Enumerable module; bump Date to 20260601.
+5. ~ Namo::VERSION: /0.11.0/0.11.1/
+
+20260531
+0.11.0: ~ Subset Enumerable methods (select, reject, sort_by, first, last, take, drop, take_while, drop_while, uniq, partition) return Namos
+
+1. + Namo#select, Namo#reject, Namo#sort_by, Namo#take_while, Namo#drop_while: Predicate and ordering subset methods that wrap the @data Array result in `self.class.new(..., formulae: @formulae.dup)`, shadowing Enumerable's Array-returning defaults. Blocks receive a Row, so formulae resolve inside the predicate, and formulae carry through to the returned Namo. Namo#select is aliased as filter and find_all (the only overridden method with Enumerable aliases), so the aliases return Namos too.
+2. + Namo#first, Namo#last: With an argument, return a Namo of the first/last n rows. Without an argument, return a single Row (or nil on an empty Namo), per Ruby's Enumerable#first / Array#last convention. first(0) returns an empty Namo (n is truthy). last(n) reads @data.last(n) directly — the efficient path, no Enumerable materialise-then-slice fall-through.
+3. + Namo#take, Namo#drop: Leading subset and its complement, wrapping @data.take(n) / @data.drop(n).
+4. + Namo#uniq: Full-row dedupe. The no-block path dedupes raw @data hashes via Array#uniq, which uses eql?/hash — matching Row#eql?/Row#hash from 0.10.0, so numeric types stay distinct ({n: 1} and {n: 1.0} are both kept) and Row allocations are avoided. With a block, dedupes on the block's return value, per Enumerable#uniq.
+5. + Namo#partition: Returns [Namo, Namo] — matches and non-matches — each wrapped via self.class.new with duped formulae. map, flat_map, reduce, sum, min_by, max_by, count, and each are deliberately left unchanged (transformed values, scalars, or already-correct). group_by is structurally blocked — it needs Namo::Collection (0.17.0) and lands at 0.18.0.
+6. ~ test/namo_test.rb: + describe blocks for each new method — return-as-Namo, formula references in blocks, formula carry-through, empty-Namo edges, n=0 and n>length boundaries, uniq full-row dedupe plus numeric strictness plus block form, partition summing to the original, and subclass type preservation via Class.new(Namo). + Tests that select's filter and find_all aliases return Namos. + Guard tests that map/flat_map/reduce keep their original return types.
+7. ~ README.md: + Note in the Enumerable section that the subset-returning methods return Namos, with a chaining example and a first/last/uniq semantics paragraph. ~ Overview design-stance sentence to fold the Enumerable subset methods into "Namos in, Namos out".
+8. ~ ROADMAP.md: Promote 0.11.0 from upcoming to shipped under "Current state: 0.11.0"; fold the subset Enumerable methods into the Summary's completed vocabulary and point "next phase" at 0.12.0+; bump Date to 20260531.
+9. ~ Namo::VERSION: /0.10.0/0.11.0/
+
 20260528
 0.10.0: + Row value semantics: ==, eql?, hash
 

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 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.
+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 — as do the subset-returning Enumerable methods (`select`, `reject`, `sort_by`, `uniq`, and the rest) — so analytical pipelines close; and the formula mechanism is type-agnostic — strings, dates, booleans, and arbitrary Ruby objects work as readily as numbers.
 
 ## Installation
 
@@ -676,6 +676,20 @@ sales.flat_map{|row| [row[:price]]}
 # => [10.0, 10.0, 25.0, 25.0]
 ```
 
+The subset-returning Enumerable methods — `select`, `reject`, `sort_by`, `first(n)`, `last(n)`, `take`, `drop`, `take_while`, `drop_while`, `uniq`, and `partition` — return Namos rather than Arrays (`partition` returns `[Namo, Namo]`), carrying formulae through. This keeps the analytical chain closed: the result of a filter is still selectable, projectable, and operable, exactly like the operators that combine Namos:
+
+```ruby
+sales.select{|row| row[:price] < 20.0}.values(:price).sum
+# => 20.0
+
+sales.select{|row| row[:price] < 20.0}[product: 'Widget'][:quarter, :revenue].to_a
+# => [{quarter: 'Q1', revenue: 1000.0}, {quarter: 'Q2', revenue: 1500.0}]
+```
+
+Without an argument, `first` and `last` return a single `Row` (or `nil` on an empty Namo), following Ruby's convention; with an argument they return a Namo of that many rows. `uniq` dedupes on full-row equality (`Row#==`), or on a block's return value when given one. `select`'s aliases `filter` and `find_all` follow the override and return Namos too.
+
+The transforming and reducing methods are deliberately left as Enumerable's defaults, because their results aren't row-shaped and so can't be a Namo: `map`/`collect` and `flat_map` return Arrays of whatever the block produces; `reduce`/`inject`, `sum`, `count`, `min_by`, and `max_by` return scalars. `each` is unchanged — it yields Rows, or returns an Enumerator with no block.
+
 ### Extracting data
 
 `to_a` returns an array of hashes — the row-oriented form:

data/lib/Namo/Enumerable.rb

@@ -0,0 +1,72 @@
+# Namo/Enumerable.rb
+# Namo::Enumerable
+
+class Namo
+  module Enumerable
+    include ::Enumerable
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      @data.each{|row_data| block.call(Row.new(row_data, @formulae))}
+    end
+
+    def select(&block)
+      self.class.new(@data.select{|row| block.call(Row.new(row, @formulae))}, 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)
+    end
+
+    def sort_by(&block)
+      self.class.new(@data.sort_by{|row| block.call(Row.new(row, @formulae))}, 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
+      end
+    end
+
+    def last(n = nil)
+      if n
+        self.class.new(@data.last(n), formulae: @formulae.dup)
+      else
+        @data.last ? Row.new(@data.last, @formulae) : nil
+      end
+    end
+
+    def take(n)
+      self.class.new(@data.take(n), formulae: @formulae.dup)
+    end
+
+    def drop(n)
+      self.class.new(@data.drop(n), formulae: @formulae.dup)
+    end
+
+    def take_while(&block)
+      self.class.new(@data.take_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+    end
+
+    def drop_while(&block)
+      self.class.new(@data.drop_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+    end
+
+    def uniq(&block)
+      rows = block ? @data.uniq{|row| block.call(Row.new(row, @formulae))} : @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))}
+      [
+        self.class.new(matches, formulae: @formulae.dup),
+        self.class.new(non_matches, formulae: @formulae.dup),
+      ]
+    end
+  end
+end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.10.0'
+  VERSION = '0.11.1'
 end

data/lib/namo.rb

@@ -3,11 +3,12 @@
 
 require_relative './Namo/NegatedDimension'
 require_relative './Namo/Row'
+require_relative './Namo/Enumerable'
 require_relative './Namo/VERSION'
 require_relative './Symbol'
 
 class Namo
-  include Enumerable
+  include Namo::Enumerable
 
   attr_accessor :data
   attr_accessor :formulae
@@ -76,11 +77,6 @@ class Namo
     @formulae[name] = proc
   end
 
-  def each(&block)
-    return enum_for(:each) unless block_given?
-    @data.each{|row_data| block.call(Row.new(row_data, @formulae))}
-  end
-
   def +(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)

data/test/namo_test.rb

@@ -511,6 +511,424 @@ describe Namo do
     end
   end
 
+  describe "#select" do
+    it "returns a Namo of matching rows" do
+      result = sales.select{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+    end
+
+    it "selects using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.select{|row| row[:revenue] >= 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
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.select{|row| row[:price] < 20.0}
+      _(result.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an empty Namo when nothing matches" do
+      result = sales.select{|row| row[:price] > 1000.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).select{|row| row[:price] < 20.0}
+      _(result.class).must_equal subclass
+    end
+
+    it "is aliased as filter, returning a Namo" do
+      result = sales.filter{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+
+    it "is aliased as find_all, returning a Namo" do
+      result = sales.find_all{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+  end
+
+  describe "#reject" do
+    it "returns the complement of select" do
+      result = sales.reject{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "together with select sums to the original" do
+      selected = sales.select{|row| row[:price] < 20.0}
+      rejected = sales.reject{|row| row[:price] < 20.0}
+      _((selected.to_a + rejected.to_a).length).must_equal sample_data.length
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.reject{|row| row[:price] < 20.0}
+      _(result.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).reject{|row| row[:price] < 20.0}
+      _(result.class).must_equal subclass
+    end
+  end
+
+  describe "#sort_by" do
+    it "returns rows in the specified order" do
+      result = sales.sort_by{|row| row[:quantity]}
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [40, 60, 100, 150]
+    end
+
+    it "sorts using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.sort_by{|row| row[:revenue]}
+      _(result.values(:revenue)).must_equal [1000.0, 1000.0, 1500.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).sort_by{|row| row[:quantity]}
+      _(result.class).must_equal subclass
+    end
+  end
+
+  describe "#first" do
+    it "with an argument returns a Namo of the first n rows" do
+      result = sales.first(2)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+    end
+
+    it "with an argument of 0 returns an empty Namo" do
+      result = sales.first(0)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "without an argument returns a Row" do
+      result = sales.first
+      _(result).must_be_kind_of Namo::Row
+      _(result[:product]).must_equal 'Widget'
+    end
+
+    it "without an argument on an empty Namo returns nil" do
+      _(Namo.new.first).must_be_nil
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.first(2).values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class with an argument" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).first(2).class).must_equal subclass
+    end
+  end
+
+  describe "#last" do
+    it "with an argument returns a Namo of the last n rows" do
+      result = sales.last(2)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "with an argument of 0 returns an empty Namo" do
+      result = sales.last(0)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "without an argument returns a Row" do
+      result = sales.last
+      _(result).must_be_kind_of Namo::Row
+      _(result[:product]).must_equal 'Gadget'
+      _(result[:quarter]).must_equal 'Q2'
+    end
+
+    it "without an argument on an empty Namo returns nil" do
+      _(Namo.new.last).must_be_nil
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.last(2).values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class with an argument" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).last(2).class).must_equal subclass
+    end
+  end
+
+  describe "#take" do
+    it "returns a Namo of the first n rows" do
+      result = sales.take(2)
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [100, 150]
+    end
+
+    it "returns an empty Namo for n of 0" do
+      _(sales.take(0).to_a).must_equal []
+    end
+
+    it "returns all rows when n exceeds the length" do
+      _(sales.take(10).to_a).must_equal sample_data
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).take(2).class).must_equal subclass
+    end
+  end
+
+  describe "#drop" do
+    it "returns a Namo of all rows past the first n" do
+      result = sales.drop(2)
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [40, 60]
+    end
+
+    it "returns all rows for n of 0" do
+      _(sales.drop(0).to_a).must_equal sample_data
+    end
+
+    it "returns an empty Namo when n exceeds the length" do
+      _(sales.drop(10).to_a).must_equal []
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).drop(2).class).must_equal subclass
+    end
+  end
+
+  describe "#take_while" do
+    it "returns a Namo of leading rows while the predicate holds" do
+      result = sales.take_while{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+
+    it "evaluates the predicate against formula references" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.take_while{|row| row[:revenue] < 1500.0}
+      _(result.values(:revenue)).must_equal [1000.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).take_while{|row| row[:price] < 20.0}.class).must_equal subclass
+    end
+  end
+
+  describe "#drop_while" do
+    it "returns a Namo of rows from the first predicate failure" do
+      result = sales.drop_while{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Gadget', 'Gadget']
+    end
+
+    it "evaluates the predicate against formula references" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.drop_while{|row| row[:revenue] < 1500.0}
+      _(result.values(:revenue)).must_equal [1500.0, 1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).drop_while{|row| row[:price] < 20.0}.class).must_equal subclass
+    end
+  end
+
+  describe "#uniq" do
+    let(:dup_data) do
+      [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q2'}
+      ]
+    end
+
+    it "without a block dedupes rows on full-row equality" do
+      result = Namo.new(dup_data).uniq
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q2'}
+      ]
+    end
+
+    it "distinguishes numeric types, matching Row#eql? semantics" do
+      result = Namo.new([{n: 1}, {n: 1.0}]).uniq
+      _(result.to_a).must_equal [{n: 1}, {n: 1.0}]
+    end
+
+    it "with a block dedupes on the block's return value" do
+      result = Namo.new(dup_data).uniq{|row| row[:product]}
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'}
+      ]
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      namo = Namo.new(dup_data)
+      namo[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+      result = namo.uniq
+      _(result.values(:label)).must_equal ['Widget-Q1', 'Gadget-Q1', 'Widget-Q2']
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(dup_data).uniq.class).must_equal subclass
+    end
+  end
+
+  describe "#partition" do
+    it "returns a two-element Array of Namos" do
+      result = sales.partition{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 2
+      _(result[0]).must_be_kind_of Namo
+      _(result[1]).must_be_kind_of Namo
+    end
+
+    it "splits into matches and non-matches summing to the original" do
+      matches, non_matches = sales.partition{|row| row[:price] < 20.0}
+      _(matches.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+      _(non_matches.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+      _((matches.to_a + non_matches.to_a).length).must_equal sample_data.length
+    end
+
+    it "partitions using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      matches, non_matches = sales.partition{|row| row[:revenue] >= 1500.0}
+      _(matches.values(:revenue)).must_equal [1500.0, 1500.0]
+      _(non_matches.values(:revenue)).must_equal [1000.0, 1000.0]
+    end
+
+    it "preserves formulae through to both returned Namos" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      matches, non_matches = sales.partition{|row| row[:price] < 20.0}
+      _(matches.values(:revenue)).must_equal [1000.0, 1500.0]
+      _(non_matches.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns instances of self's class" do
+      subclass = Class.new(Namo)
+      matches, non_matches = subclass.new(sample_data).partition{|row| row[:price] < 20.0}
+      _(matches.class).must_equal subclass
+      _(non_matches.class).must_equal subclass
+    end
+  end
+
+  describe "subset methods on an empty Namo" do
+    let(:empty) { Namo.new }
+
+    it "select returns an empty Namo" do
+      _(empty.select{|row| true}.to_a).must_equal []
+    end
+
+    it "reject returns an empty Namo" do
+      _(empty.reject{|row| true}.to_a).must_equal []
+    end
+
+    it "sort_by returns an empty Namo" do
+      _(empty.sort_by{|row| row[:x]}.to_a).must_equal []
+    end
+
+    it "first(n) returns an empty Namo" do
+      _(empty.first(2).to_a).must_equal []
+    end
+
+    it "last(n) returns an empty Namo" do
+      _(empty.last(2).to_a).must_equal []
+    end
+
+    it "take and drop return empty Namos" do
+      _(empty.take(2).to_a).must_equal []
+      _(empty.drop(2).to_a).must_equal []
+    end
+
+    it "take_while and drop_while return empty Namos" do
+      _(empty.take_while{|row| true}.to_a).must_equal []
+      _(empty.drop_while{|row| true}.to_a).must_equal []
+    end
+
+    it "uniq returns an empty Namo" do
+      _(empty.uniq.to_a).must_equal []
+    end
+
+    it "partition returns two empty Namos" do
+      matches, non_matches = empty.partition{|row| true}
+      _(matches.to_a).must_equal []
+      _(non_matches.to_a).must_equal []
+    end
+  end
+
+  describe "unchanged Enumerable methods" do
+    it "map still returns an Array" do
+      _(sales.map{|row| row[:product]}).must_be_kind_of Array
+    end
+
+    it "flat_map still returns an Array" do
+      _(sales.flat_map{|row| [row[:price]]}).must_be_kind_of Array
+    end
+
+    it "reduce still returns a scalar" do
+      _(sales.reduce(0){|sum, row| sum + row[:quantity]}).must_equal 350
+    end
+  end
+
+  describe "Namo::Enumerable module" do
+    it "is a Module supplying the subset methods" do
+      _(Namo::Enumerable).must_be_kind_of Module
+    end
+
+    it "is included in Namo, transitively including stdlib Enumerable" do
+      _(Namo.include?(Namo::Enumerable)).must_equal true
+      _(Namo.include?(Enumerable)).must_equal true
+    end
+
+    it "sits above stdlib Enumerable so its overrides win" do
+      ancestors = Namo.ancestors
+      _(ancestors.index(Namo::Enumerable) < ancestors.index(::Enumerable)).must_equal true
+    end
+  end
+
   describe "#+" do
     let(:more_data) do
       [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - thoran
@@ -64,6 +64,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/Namo/Enumerable.rb
 - lib/Namo/NegatedDimension.rb
 - lib/Namo/Row.rb
 - lib/Namo/VERSION.rb