namo 0.31.4 → 0.31.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a5b005cb03bb42a9a9319632833f382a8ae2480ce04160f326a831f534da50a
-  data.tar.gz: f344e285a0d457af4ad633c98a33aab02cefe49fd273251ad9bdc7bdd3d98afa
+  metadata.gz: 062a5ecf9fba2666e680bc2842d7569bd07a2e00f521cb6ad583a2b13f22d5c4
+  data.tar.gz: 7333a5d541ee742f49796d09949b7b2c89ac056635449ce9f1c1e0733ef757b0
 SHA512:
-  metadata.gz: 8025bdb29748fc3076649dc59a38139075c03a9692c5c684295cb5060334e8e8c0c45dea9001dd942d68d0e3302910464c9141157a42d61af85eb751420bf0d8
-  data.tar.gz: 8fc50fc83aab71b68cb6e70dc4178e95dc8e2f3e6983480ccbcc4553915b61dde52f00cf8d2f1570988d5129df7e0534b13db8b3dc7413602d1fefc64b694613
+  metadata.gz: 705357a13d1495c3a96fbc470fb4f796f7d8eb9a40a82552708801c3969972dc2cf59255f64a8d7ad0d3479442980f3e5a6748d9b4e16992e70a5258291a787b
+  data.tar.gz: 911df517eaeafb86233af02c3d56a92dfc27afa4cc7cadc8e8b4b02e6f16e52df8ee683a79de7be57f89480f8c9420c02b2d8a8bd3b8a4e75606561d5ce3850a

data/CHANGELOG

@@ -2,6 +2,25 @@
 
 ## 20260826
 
+0.31.6: ~ Namo::Collection: a row operation yields a Namo rather than a memberless Collection.
+
+1. + Namo#return_class: the class an operation returns, protected, returning self.class. The twenty-two sites which built what they return — projection and contraction, the five set operators, the two composition operators, and the subset Enumerable methods in Namo::Enumerable — now ask for it rather than naming self.class themselves.
+2. ~ Namo::Collection#return_class: returns Namo. A Collection's kind is its members and a row operation carries none across, so what came back was a Collection with none: it answered summary with an empty Namo rather than raising, and rendered as [] beside a row count. 0.18.0 has these operations read the detail view and behave as the detail, and the detail is a Namo; this is the code meeting that sentence.
+3. ~ README.md: the four views, on what a row operation on a Collection returns.
+4. ~ ROADMAP.md: + 0.31.6.
+5. ~ Namo::VERSION: /0.31.5/0.31.6/
+
+
+0.31.5: ~ Namo::Collection#detail, #as_detail: the detail view carries the members' formulae.
+
+1. ~ Namo::Collection#detail: the returned Namo carries the members' formulae, folded in member order so that a later member wins a name collision, as a later member wins a collision of names in <<. It had been built with none, so the view documented at 0.18.0 as the lossless union of the members' rows dropped every derived dimension: group_by hands each member the source's formulae, and detail handed them back stripped.
+2. ~ Namo::Collection#as_detail: merges the detail view's formulae into the Collection's own, the Collection having become that view. Without it the round trip still lost them, as_detail having taken only the data.
+3. ~ script/demo: the collections section checks the round trip with === rather than ==, == comparing row multisets alone and so unable to see the formulae go missing, which is why this stood.
+4. ~ README.md: the four views, on which of them carries formulae and why.
+5. ~ ROADMAP.md: + 0.31.5.
+6. ~ Namo::VERSION: /0.31.4/0.31.5/
+
+
 0.31.4: ~ Namo::Collection#inspect: the members are rendered, nested under their names.
 
 1. ~ Namo::Collection#inspect: the members are rendered nested under their names rather than listed as bare labels beside a row count, the members being the substance and the data view derived from them. The Namo::INSPECTED_ROWS budget is spread across the members shown — one member renders ten of its rows, five render two apiece, ten render one each and are put on one line — and members beyond it are elided with a count, as rows are. The member list had no cap at all: 2,641 members emitted 22,704 characters on a single line, which is the failure INSPECTED_ROWS was introduced at 0.31.0 to end. A member renders nested as it renders alone, its derived values among its stored ones and its own derived: suffix naming whatever none of its rendered rows could materialise. The detail view's row count closes the block, and a Collection's own formulae are named after it, being a namespace its members cannot resolve.

data/README.md

@@ -1119,8 +1119,12 @@ gt[component: 'engine'].values(:cost)
 
 Detail is the lazy view because a Collection's rows simply *are* its members' rows; a summary is a reduction you pose against them, so it is never reached by accident — only through `summary` or `as_summary`.
 
+An inherited row-operation on a Collection — selection, projection, `select`, `sort_by`, the set and composition operators — returns a `Namo`, not a Collection. It reads the detail view and behaves as the detail, and the detail is a Namo. A Collection is defined by its members, and a row operation carries none of them across, so a Collection is not what the result is: asking one for a `summary` should say there is none to give rather than answer for no members. A subclass of `Namo` is unaffected — a projection of a `PriceData` is a `PriceData`.
+
 #### Four view methods
 
+`detail` carries the members' formulae, its rows being the members' rows — folded in member order, so a later member wins a name collision as it wins a collision of names in `<<`. A `summary`'s rows are reductions, holding neither the dimensions those formulae read nor the rows they read them from, so it carries none.
+
 The views come in a non-mutating pair and a mutating pair:
 
 - `summary(dimension = nil, by:, reducer:, &block)` and `detail(by:)` are **non-mutating** — each returns a fresh `Namo` derived from the members, leaving the Collection untouched. Use these when you want a view to keep: assign the result to a variable and operate on it independently.

data/lib/Namo/Collection.rb

@@ -42,7 +42,7 @@ class Namo
           member.data.map{|row| row.key?(by) ? row : row.merge(by => member.name)}
         end
       )
-      Namo.new(rows)
+      Namo.new(rows, formulae: member_formulae)
     end
 
     def as_summary(dimension = nil, by: :member, reducer: :sum, &block)
@@ -52,7 +52,9 @@ class Namo
 
     def as_detail(positional_by = nil, by: :member)
       by = positional_by || by
-      @data = detail(by).data
+      view = detail(by)
+      @data = view.data
+      @formulae = @formulae.merge(view.formulae)
       self
     end
 
@@ -68,8 +70,27 @@ class Namo
       "#<#{self.class}#{inspected_name} #{inspected_members} #{@data.length} rows#{inspected_derived}>"
     end
 
+    protected
+
+    # A row operation on a Collection yields a Namo: 0.18.0 has it read the detail
+    # view and behave as the detail, and the detail is a Namo.  Built as a
+    # Collection it would be one with no members, answering summary with an empty
+    # Namo rather than saying it cannot.
+    def return_class
+      Namo
+    end
+
     private
 
+    # The members' formulae, folded in member order so that a later member wins a
+    # name collision, as a later member wins a collision of names in <<.  The
+    # detail view is the members' rows, so it must be able to answer what the
+    # members can answer of them; group_by hands every member the same formulae,
+    # so only an assembled Collection can have members which disagree.
+    def member_formulae
+      @members.map(&:formulae).reduce(Formulae.new){|merged, formulae| merged.merge(formulae)}
+    end
+
     def inspected_members
       return '[]' if @members.empty?
       shown = [@members.length, INSPECTED_ROWS].min

data/lib/Namo/Enumerable.rb

@@ -11,22 +11,22 @@ class Namo
     end
 
     def select(&block)
-      self.class.new(@data.select{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
+      return_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, self))}, formulae: @formulae.dup)
+      return_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, self))}, formulae: @formulae.dup)
+      return_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)
+        return_class.new(@data.first(n), formulae: @formulae.dup)
       else
         @data.first ? Row.new(@data.first, @formulae, self) : nil
       end
@@ -34,38 +34,38 @@ class Namo
 
     def last(n = nil)
       if n
-        self.class.new(@data.last(n), formulae: @formulae.dup)
+        return_class.new(@data.last(n), formulae: @formulae.dup)
       else
         @data.last ? Row.new(@data.last, @formulae, self) : nil
       end
     end
 
     def take(n)
-      self.class.new(@data.take(n), formulae: @formulae.dup)
+      return_class.new(@data.take(n), formulae: @formulae.dup)
     end
 
     def drop(n)
-      self.class.new(@data.drop(n), formulae: @formulae.dup)
+      return_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, self))}, formulae: @formulae.dup)
+      return_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, self))}, formulae: @formulae.dup)
+      return_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, self))} : @data.uniq
-      self.class.new(rows, formulae: @formulae.dup)
+      return_class.new(rows, formulae: @formulae.dup)
     end
 
     def partition(&block)
       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),
+        return_class.new(matches, formulae: @formulae.dup),
+        return_class.new(non_matches, formulae: @formulae.dup),
       ]
     end
 
@@ -74,7 +74,7 @@ class Namo
       source = derived_dimensions.include?(dimension) ? self[*data_dimensions, dimension] : self
       members = (
         source.data.group_by{|row_data| row_data[dimension]}.map do |value, rows|
-          self.class.new(rows, formulae: source.formulae.dup, name: value)
+          return_class.new(rows, formulae: source.formulae.dup, name: value)
         end
       )
       collection << members

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.31.4'
+  VERSION = '0.31.6'
 end

data/lib/namo.rb

@@ -79,7 +79,7 @@ class Namo
       end
     )
     carried = positive.any? ? @formulae.reject{|name, _| positive.include?(name)} : @formulae.dup
-    self.class.new(projected, formulae: carried)
+    return_class.new(projected, formulae: carried)
   end
 
   def []=(name, value)
@@ -124,31 +124,31 @@ class Namo
   def +(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)
-    self.class.new(@data + other.data, formulae: other.formulae.merge(@formulae))
+    return_class.new(@data + other.data, formulae: other.formulae.merge(@formulae))
   end
 
   def -(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)
-    self.class.new(@data - other.data, formulae: @formulae.dup)
+    return_class.new(@data - other.data, formulae: @formulae.dup)
   end
 
   def &(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)
-    self.class.new(@data & other.data, formulae: @formulae.dup)
+    return_class.new(@data & other.data, formulae: @formulae.dup)
   end
 
   def |(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)
-    self.class.new((@data | other.data), formulae: other.formulae.merge(@formulae))
+    return_class.new((@data | other.data), formulae: other.formulae.merge(@formulae))
   end
 
   def ^(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)
-    self.class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
+    return_class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
   end
 
   def *(other, &block)
@@ -167,7 +167,7 @@ class Namo
         matched.each{|right_row| combined_data << left_row.merge(right_row)}
       end
     end
-    self.class.new(combined_data, formulae: other.formulae.merge(@formulae))
+    return_class.new(combined_data, formulae: other.formulae.merge(@formulae))
   end
 
   def **(other, &block)
@@ -184,7 +184,7 @@ class Namo
         other.data.each{|right_row| combined_data << left_row.merge(right_row)}
       end
     end
-    self.class.new(combined_data, formulae: other.formulae.merge(@formulae))
+    return_class.new(combined_data, formulae: other.formulae.merge(@formulae))
   end
 
   def /(other)
@@ -193,7 +193,7 @@ class Namo
     projected = @data.map do |row|
       kept.each_with_object({}){|dim, hash| hash[dim] = row[dim]}
     end
-    self.class.new(projected.uniq, formulae: @formulae.dup)
+    return_class.new(projected.uniq, formulae: @formulae.dup)
   end
 
   def ==(other)
@@ -262,6 +262,13 @@ class Namo
 
   protected
 
+  # The class an operation returns.  A subclass is its own kind of thing, so a
+  # projection of a PriceData is a PriceData; Namo::Collection is not, its kind
+  # being its members, which a row operation carries none of.
+  def return_class
+    self.class
+  end
+
   # The rendered rows, the count of those not shown, and the derived dimensions
   # none of them carries.  Shared with Collection, which renders its members' rows
   # rather than its own and must report what a member would report of itself.

data/test/Namo/Collection_test.rb

@@ -347,6 +347,102 @@ describe Namo::Collection do
     end
   end
 
+  # 0.18.0 has an inherited row-operation read the detail view and "behave as the
+  # detail", and the detail is a Namo.  Built as a Collection the result was one
+  # with no members: it answered summary with an empty Namo rather than saying it
+  # had no summary to give, and rendered as [] beside a row count.
+  describe "the class of a derived result" do
+    def grouped
+      Namo.new([
+        {station: "Melbourne", month: "2025-01", high_temp: 26.4},
+        {station: "Perth", month: "2025-01", high_temp: 32.0},
+        {station: "Perth", month: "2025-02", high_temp: 29.5}]).group_by(:month)
+    end
+
+    it "is a Namo for selection and projection" do
+      _(grouped[station: "Perth"]).must_be_instance_of Namo
+      _(grouped[:station, :high_temp]).must_be_instance_of Namo
+    end
+
+    it "is a Namo for the subset Enumerable methods" do
+      collection = grouped
+      _(collection.select{|row| row[:station] == "Perth"}).must_be_instance_of Namo
+      _(collection.sort_by{|row| row[:high_temp]}).must_be_instance_of Namo
+      _(collection.first(2)).must_be_instance_of Namo
+      _(collection.uniq).must_be_instance_of Namo
+    end
+
+    it "is a Namo for the set and composition operators" do
+      collection = grouped
+      _(collection + collection).must_be_instance_of Namo
+      _(collection - collection).must_be_instance_of Namo
+      _(collection & collection).must_be_instance_of Namo
+    end
+
+    it "carries the rows the operation selected" do
+      _(grouped[station: "Perth"].values(:high_temp)).must_equal [32.0, 29.5]
+    end
+
+    # The point of it: a summary of no members is not an empty summary.
+    it "has no summary to give, rather than an empty one" do
+      _{grouped[station: "Perth"].summary(:high_temp)}.must_raise NoMethodError
+    end
+
+    it "leaves a subclass its own kind" do
+      priced = Class.new(Namo)
+      instance = priced.new([{a: 1}, {a: 2}])
+      _(instance.select{|row| row[:a] > 1}).must_be_instance_of priced
+      _(instance[:a]).must_be_instance_of priced
+    end
+
+    it "leaves group_by returning a Collection" do
+      _(grouped).must_be_instance_of Namo::Collection
+      _(grouped.members.length).must_equal 2
+    end
+  end
+
+  describe "the detail view and its formulae" do
+    def readings
+      namo = Namo.new([
+        {station: "Melbourne", month: "2025-01", high_temp: 26.4, mean_temp: 25.9},
+        {station: "Perth", month: "2025-01", high_temp: 32.0, mean_temp: 30.0}])
+      namo[:anomaly] = proc{|row| (row[:high_temp] - row[:mean_temp]).round(1)}
+      namo
+    end
+
+    it "carries the members' formulae, the view being the members' rows" do
+      _(readings.group_by(:station).detail(:station).derived_dimensions).must_equal [:anomaly]
+    end
+
+    it "answers a derived dimension through the detail view" do
+      _(readings.group_by(:station).detail(:station).values(:anomaly)).must_equal [0.5, 2.0]
+    end
+
+    # == compares row multisets and cannot see a formula go missing, so it called
+    # the partition exact while the derived dimensions were being dropped.  === is
+    # the operator which compares the formula names too.
+    it "inverts the partition exactly, formulae and all" do
+      source = readings
+      _(source.group_by(:station).as_detail(:station)).must_be :===, source
+    end
+
+    it "folds the members' formulae, a later member winning the name" do
+      first = Namo.new([{a: 1}], name: :first)
+      first[:b] = proc{|row| :from_first}
+      second = Namo.new([{a: 2}], name: :second)
+      second[:b] = proc{|row| :from_second}
+      collection = Namo::Collection.new
+      collection << first << second
+      _(collection.detail.values(:b)).must_equal [:from_second, :from_second]
+    end
+
+    # A summary's rows are reductions, holding neither the dimensions the members'
+    # formulae read nor the rows they read them from, so it carries none.
+    it "leaves the summary without them" do
+      _(readings.group_by(:station).summary(:high_temp).derived_dimensions).must_equal []
+    end
+  end
+
   describe "#inspect" do
     def collection_of(members, rows_each)
       rows = (1..members).flat_map{|member| (1..rows_each).map{|row| {group: "g#{member}", n: row}}}

data/test/console_test.rb

@@ -4,17 +4,20 @@ require 'minitest/autorun'
 require 'minitest-spec-context'
 
 require_relative '../lib/namo'
-require_relative '../script/fixtures'
 
-# script/console exists so that a question asked at a prompt is asked of the same
-# data the demo put on the screen.  That is only true while both read
-# script/fixtures.rb, so what is worth asserting is the agreement rather than the
-# session: the names it defines, and that they hold what the fixtures say.
+# bin/console is the conventional gem prompt: irb with the library loaded and
+# nothing else.  It held the demo's fixtures until 20260826, so that a question
+# asked here was asked of the data the demo had shown — a guarantee the demo's
+# own `i` now keeps better, opening irb on the binding the run is using rather
+# than on a second process holding equal values.
+#
+# What is left to assert is that it starts, that Namo is there, and that it needs
+# nothing off the load path.
 
-describe 'script/console' do
+describe 'bin/console' do
   def console(*expressions)
     root = File.expand_path('..', __dir__)
-    IO.popen([File.join(root, 'script', 'console'), '--prompt', 'simple'],
+    IO.popen([File.join(root, 'bin', 'console'), '--prompt', 'simple'],
       'r+', chdir: root, err: [:child, :out]) do |io|
       io.puts(expressions, 'exit')
       io.close_write
@@ -22,21 +25,22 @@ describe 'script/console' do
     end
   end
 
-  it "defines the names it says it does" do
-    output = console('[readings, stations, months].map{|n| n.class}.inspect')
-    _(output).must_match(/\[Namo, Namo, Namo\]/)
+  it "starts with Namo loaded" do
+    _(console('Namo.new([{a: 1}]).dimensions.inspect')).must_match(/\[:a\]/)
   end
 
-  it "gives sales the revenue formula" do
-    _(console('readings.derived_dimensions.inspect')).must_match(/\[:anomaly\]/)
-  end
-
-  it "holds what the fixtures hold, so it cannot drift from the demo" do
-    expected = eval(Fixtures.readings)
-    _(console('readings.data == ' + expected.inspect)).must_match(/true/)
+  it "starts without echoing its own source" do
+    _(console('1')).wont_match(/IRB\.start/)
   end
 
-  it "starts without echoing its own source" do
-    _(console('1')).wont_match(/binding\.irb/)
+  it "needs nothing but the gem's own dependencies" do
+    root = File.expand_path('..', __dir__)
+    output = IO.popen({'RUBYLIB' => nil}, [File.join(root, 'bin', 'console'), '--prompt', 'simple'],
+      'r+', chdir: root, err: [:child, :out]) do |io|
+      io.puts('exit')
+      io.close_write
+      io.read
+    end
+    _(output).wont_match(/LoadError/)
   end
 end

metadata

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