namo 0.30.1 → 0.31.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11155d79565895733cba5947380c1995003ab8e3916dcc2a5b22a55053d804a7
-  data.tar.gz: 5e983ddf2f3881195692df604fa9d61005f817cec18c87c960b837353fc094be
+  metadata.gz: e5235177577fcae1dd01a8a3172fc3933e77a5483f123ba6f436bd58a6eca68e
+  data.tar.gz: b2c023063fa95cca3f6ec38f324a116bf013339003d4051338a7c84b57251944
 SHA512:
-  metadata.gz: 2143589ce12079aab10ee8e84bf2c77e94db8459bace1c2c1d45e71c538e8328fd088c3b8ae08490d292968890fec3b8e16d5384173374b3668b1acbeeb4ca49
-  data.tar.gz: 2113f5063b2ae16863e4672bf8ec69bdc99d33ad561000068c19099950d7a25a3f4aecabbfed68f444dfe14677d61076793ed13754f8c48180e56f32ec8d56c5
+  metadata.gz: 3278fdcba0888a5899930abb399c3cc3b1aff49d7bb27ceefc223524c4247cb4c85ca0274ba58254965229e9cec131c014a544fce61444e8d6e34221896047e5
+  data.tar.gz: 94cdb60c0bc852b456ded744a63f8e7fda0dbf884d2ff085b0908cfb80d26f48588b4254b7d389cb68b4bce0f668d3a528ce5eeba22bd80ea4a50331c6ccb2e8

data/CHANGELOG

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## 20260824
+
+0.31.1: ~ Namo#inspect, Namo::Row#inspect: derived dimensions render their values.
+
+1. ~ Namo#inspect: a derived dimension renders with its value, in among the stored ones, rather than being named only. Where there is no value to show it is omitted and the derived: suffix names it alone: a formula which raises, and a parameterised one which cannot be materialised without its arguments.
+2. ~ Namo::Row#inspect: the same.
+3. ~ README.md: the Inspection output section rewritten, and the two blocks whose rendering changes.
+4. ~ ROADMAP.md: + 0.31.1.
+5. ~ Namo::VERSION: /0.31.0/0.31.1/
+
+
+## 20260822
+
+0.31.0: + Namo#inspect, Namo::Collection#inspect, Namo::Row#inspect, and Namo::Formulae#inspect.
+
+1. + Namo#inspect: the class, the name where there is one, the stored rows, and the derived dimension names — the form the README has shown since 0.0.0 and the code has never produced. Rows beyond Namo::INSPECTED_ROWS are elided with a count of what is left, so the output no longer grows with the data.
+2. + Namo::Row#inspect: the row and its formula names. It had been rendering @namo, so asking a 1,000-row Namo for one row emitted more output than inspecting the whole Namo.
+3. + Namo::Collection#inspect: the member names and the row count, the members being the substance and the data view derived from them.
+4. + Namo::Formulae#inspect: the formula names, never the callables.
+5. + README.md: an Inspection output section, covering the rendered form, the naming of derived dimensions, and the row cap.
+6. ~ README.md: the inspect-output blocks requoted from single to double quotes, as Hash#inspect emits, and the two projections that carry formulae given their derived: suffix. The blocks had been hand-written before there was an inspect to copy from.
+7. ~ Namo::VERSION: /0.30.1/0.31.0/
+
+
 ## 20260819
 
 0.30.1: ~ namo.gemspec: spec.files reordered, the globs first.

data/README.md

@@ -66,42 +66,42 @@ Select by named dimension using keyword arguments:
 # Single value
 sales[product: 'Widget']
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 
 # Multiple dimensions
 sales[product: 'Widget', quarter: 'Q1']
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100}
 # ]>
 
 # Range
 sales[price: 10.0..20.0]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 
 # Array of values
 sales[quarter: ['Q1']]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Gadget", quarter: "Q1", price: 25.0, quantity: 40}
 # ]>
 
 # Proc predicate
 sales[price: ->(v){v < 20.0}]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 
 # Regex predicate
 sales[product: /^W/]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 ```
 
@@ -110,7 +110,7 @@ Procs receive the dimension value and select the row when they return truthy. Th
 ```ruby
 sales[price: ->(v){v < 20.0}, quantity: ->(v){v > 100}]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 ```
 
@@ -131,10 +131,10 @@ Project to specific dimensions:
 ```ruby
 sales[:product, :price]
 # => #<Namo [
-#   {product: 'Widget', price: 10.0},
-#   {product: 'Widget', price: 10.0},
-#   {product: 'Gadget', price: 25.0},
-#   {product: 'Gadget', price: 25.0}
+#   {product: "Widget", price: 10.0},
+#   {product: "Widget", price: 10.0},
+#   {product: "Gadget", price: 25.0},
+#   {product: "Gadget", price: 25.0}
 # ]>
 ```
 
@@ -143,8 +143,8 @@ Selection and projection can be chained:
 ```ruby
 sales[product: 'Widget'][:quarter, :price]
 # => #<Namo [
-#   {quarter: 'Q1', price: 10.0},
-#   {quarter: 'Q2', price: 10.0}
+#   {quarter: "Q1", price: 10.0},
+#   {quarter: "Q2", price: 10.0}
 # ]>
 ```
 
@@ -153,8 +153,8 @@ Or combined in a single call (names before selectors):
 ```ruby
 sales[:quarter, :price, product: 'Widget']
 # => #<Namo [
-#   {quarter: 'Q1', price: 10.0},
-#   {quarter: 'Q2', price: 10.0}
+#   {quarter: "Q1", price: 10.0},
+#   {quarter: "Q2", price: 10.0}
 # ]>
 ```
 
@@ -165,10 +165,10 @@ Contraction is the complement of projection. Projection says "keep these dimensi
 ```ruby
 sales[-:price, -:quantity]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1'},
-#   {product: 'Widget', quarter: 'Q2'},
-#   {product: 'Gadget', quarter: 'Q1'},
-#   {product: 'Gadget', quarter: 'Q2'}
+#   {product: "Widget", quarter: "Q1"},
+#   {product: "Widget", quarter: "Q2"},
+#   {product: "Gadget", quarter: "Q1"},
+#   {product: "Gadget", quarter: "Q2"}
 # ]>
 ```
 
@@ -183,8 +183,8 @@ Selection and contraction can be chained:
 ```ruby
 sales[product: 'Widget'][-:price, -:quantity]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1'},
-#   {product: 'Widget', quarter: 'Q2'}
+#   {product: "Widget", quarter: "Q1"},
+#   {product: "Widget", quarter: "Q2"}
 # ]>
 ```
 
@@ -193,8 +193,8 @@ Or combined in a single call (names before selectors):
 ```ruby
 sales[-:price, -:quantity, product: 'Widget']
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1'},
-#   {product: 'Widget', quarter: 'Q2'}
+#   {product: "Widget", quarter: "Q1"},
+#   {product: "Widget", quarter: "Q2"}
 # ]>
 ```
 
@@ -219,10 +219,10 @@ q2_sales = Namo.new([
 
 all_sales = q1_sales + q2_sales
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
-#   {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Gadget", quarter: "Q1", price: 25.0, quantity: 40},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150},
+#   {product: "Gadget", quarter: "Q2", price: 25.0, quantity: 60}
 # ]>
 ```
 
@@ -247,8 +247,8 @@ discontinued = Namo.new([
 
 sales - discontinued
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150}
 # ]>
 ```
 
@@ -273,8 +273,8 @@ confirmed = Namo.new([
 
 sales & confirmed
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Gadget", quarter: "Q2", price: 25.0, quantity: 60}
 # ]>
 ```
 
@@ -297,9 +297,9 @@ all_sales = Namo.new([
 
 q1_sales | all_sales
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
-#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
-#   {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100},
+#   {product: "Gadget", quarter: "Q1", price: 25.0, quantity: 40},
+#   {product: "Thingo", quarter: "Q3", price: 5.0, quantity: 10}
 # ]>
 ```
 
@@ -322,8 +322,8 @@ set_b = Namo.new([
 
 set_a ^ set_b
 # => #<Namo [
-#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
-#   {product: 'Thingo', quarter: 'Q3', price: 5.0, quantity: 10}
+#   {product: "Gadget", quarter: "Q1", price: 25.0, quantity: 40},
+#   {product: "Thingo", quarter: "Q3", price: 5.0, quantity: 10}
 # ]>
 ```
 
@@ -346,8 +346,8 @@ fundamentals = Namo.new([
 
 ohlcv * fundamentals
 # => #<Namo [
-#   {symbol: 'BHP', date: '2025-01-01', close: 42.5, pe: 14.5},
-#   {symbol: 'RIO', date: '2025-01-01', close: 118.3, pe: 9.2}
+#   {symbol: "BHP", date: "2025-01-01", close: 42.5, pe: 14.5},
+#   {symbol: "RIO", date: "2025-01-01", close: 118.3, pe: 9.2}
 # ]>
 ```
 
@@ -376,8 +376,8 @@ prices.*(quarterly) do |row, candidates|
   candidates[quarter_end: ->(qe){qe <= row[:date]}].sort_by{|f| f[:quarter_end]}.last(1)
 end
 # => #<Namo [
-#   {symbol: 'BHP', date: '2025-02-15', close: 42.5, quarter_end: '2024-12-31', eps: 1.0},
-#   {symbol: 'BHP', date: '2025-05-20', close: 44.0, quarter_end: '2025-03-31', eps: 1.2}
+#   {symbol: "BHP", date: "2025-02-15", close: 42.5, quarter_end: "2024-12-31", eps: 1.0},
+#   {symbol: "BHP", date: "2025-05-20", close: 44.0, quarter_end: "2025-03-31", eps: 1.2}
 # ]>
 ```
 
@@ -395,10 +395,10 @@ quarters = Namo.new([{quarter: 'Q1'}, {quarter: 'Q2'}])
 
 products ** quarters
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1'},
-#   {product: 'Widget', quarter: 'Q2'},
-#   {product: 'Gadget', quarter: 'Q1'},
-#   {product: 'Gadget', quarter: 'Q2'}
+#   {product: "Widget", quarter: "Q1"},
+#   {product: "Widget", quarter: "Q2"},
+#   {product: "Gadget", quarter: "Q1"},
+#   {product: "Gadget", quarter: "Q2"}
 # ]>
 ```
 
@@ -429,9 +429,9 @@ orders.**(tiers) do |row, candidates|
   candidates[max_weight: ->(w){w >= row[:weight]}]
 end
 # => #<Namo [
-#   {order: 'A', weight: 5, tier: 'light', max_weight: 10},
-#   {order: 'A', weight: 5, tier: 'heavy', max_weight: 20},
-#   {order: 'B', weight: 15, tier: 'heavy', max_weight: 20}
+#   {order: "A", weight: 5, tier: "light", max_weight: 10},
+#   {order: "A", weight: 5, tier: "heavy", max_weight: 20},
+#   {order: "B", weight: 15, tier: "heavy", max_weight: 20}
 # ]>
 ```
 
@@ -454,8 +454,8 @@ fundamentals = Namo.new([
 
 combined / fundamentals
 # => #<Namo [
-#   {date: '2025-01-01', close: 42.5},
-#   {date: '2025-01-01', close: 118.3}
+#   {date: "2025-01-01", close: 42.5},
+#   {date: "2025-01-01", close: 118.3}
 # ]>
 ```
 
@@ -616,10 +616,10 @@ sales[:revenue] = proc{|row| row[:price] * row[:quantity]}
 
 sales[:product, :quarter, :revenue]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', revenue: 1000.0},
-#   {product: 'Widget', quarter: 'Q2', revenue: 1500.0},
-#   {product: 'Gadget', quarter: 'Q1', revenue: 1000.0},
-#   {product: 'Gadget', quarter: 'Q2', revenue: 1500.0}
+#   {product: "Widget", quarter: "Q1", revenue: 1000.0},
+#   {product: "Widget", quarter: "Q2", revenue: 1500.0},
+#   {product: "Gadget", quarter: "Q1", revenue: 1000.0},
+#   {product: "Gadget", quarter: "Q2", revenue: 1500.0}
 # ]>
 ```
 
@@ -633,11 +633,11 @@ sales[:profit] = proc{|row| row[:revenue] - row[:cost]}
 
 sales[:product, :quarter, :profit]
 # => #<Namo [
-#   {product: 'Widget', quarter: 'Q1', profit: 600.0},
-#   {product: 'Widget', quarter: 'Q2', profit: 900.0},
-#   {product: 'Gadget', quarter: 'Q1', profit: 840.0},
-#   {product: 'Gadget', quarter: 'Q2', profit: 1260.0}
-# ]>
+#   {product: "Widget", quarter: "Q1", profit: 600.0},
+#   {product: "Widget", quarter: "Q2", profit: 900.0},
+#   {product: "Gadget", quarter: "Q1", profit: 840.0},
+#   {product: "Gadget", quarter: "Q2", profit: 1260.0}
+# ] derived: [:revenue, :cost]>
 ```
 
 Formulae work with selection and projection:
@@ -645,9 +645,9 @@ Formulae work with selection and projection:
 ```ruby
 sales[product: 'Widget'][:revenue, :quarter]
 # => #<Namo [
-#   {revenue: 1000.0, quarter: 'Q1'},
-#   {revenue: 1500.0, quarter: 'Q2'}
-# ]>
+#   {revenue: 1000.0, quarter: "Q1"},
+#   {revenue: 1500.0, quarter: "Q2"}
+# ] derived: [:cost, :profit]>
 ```
 
 Formulae carry through selection — a filtered Namo instance remembers its formulae.
@@ -970,6 +970,38 @@ sales[:product, :quarter, :revenue].to_h
 # }
 ```
 
+### Inspection output
+
+`inspect` renders the class, the stored rows with any derived dimensions among them, and the names of those derived dimensions:
+
+```ruby
+sales.inspect
+# => #<Namo [
+#   {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100, revenue: 1000.0},
+#   {product: "Widget", quarter: "Q2", price: 10.0, quantity: 150, revenue: 1500.0},
+#   {product: "Gadget", quarter: "Q1", price: 25.0, quantity: 40, revenue: 1000.0},
+#   {product: "Gadget", quarter: "Q2", price: 25.0, quantity: 60, revenue: 1500.0}
+# ] derived: [:revenue]>
+```
+
+A name, where the Namo carries one, follows the class: `#<Namo :sales [`. A subclass reports its own name in place of `Namo`.
+
+A derived dimension shows its value, in among the stored ones, and the `derived:` suffix names which of the keys are computed. Where there is no value to show it is omitted rather than the rendering failing: a formula which raises, and a parameterised one which cannot be materialised without its arguments, each render nothing and are named by the suffix alone.
+
+Evaluation is bounded by the row cap rather than by the data — at most ten rows are rendered, so at most ten evaluations per formula. A collection-scoped formula makes each of those a pass over the Namo, so inspecting a large one that carries such a formula is not free.
+
+Rows beyond `Namo::INSPECTED_ROWS` — ten — are elided with a count of the remainder, so the output stays bounded however large the data: a thousand-row Namo renders its first ten rows and then `... 990 more rows`.
+
+A `Row` renders itself, its derived values and its formula names, never the Namo it came from. A `Collection` renders its member names and its row count, the members being its substance and the data view derived from them.
+
+```ruby
+sales.first
+# => #<Namo::Row {product: "Widget", quarter: "Q1", price: 10.0, quantity: 100, revenue: 1000.0} derived: [:revenue]>
+
+sales.group_by(:quarter)
+# => #<Namo::Collection members: ["Q1", "Q2"], 4 rows>
+```
+
 ### Named Namos
 
 A Namo can carry a name, passed by the `name:` keyword and read or set through the `name` accessor:

data/lib/Namo/Collection.rb

@@ -53,6 +53,10 @@ class Namo
       self
     end
 
+    def inspect
+      "#<#{self.class}#{inspected_name} members: #{@members.map(&:name).inspect}, #{@data.length} rows#{inspected_derived}>"
+    end
+
     private
 
     def initialize(positional_data = nil, data: [], formulae: {}, name: nil)

data/lib/Namo/Formulae.rb

@@ -97,6 +97,10 @@ class Namo
       keys.sort.hash
     end
 
+    def inspect
+      "#<#{self.class} #{@store.keys.inspect}>"
+    end
+
     private
 
     def initialize(store = {})

data/lib/Namo/Row.rb

@@ -43,8 +43,31 @@ class Namo
       @row
     end
 
+    def inspect
+      "#<#{self.class} #{inspected_row}#{inspected_derived}>"
+    end
+
     private
 
+    def inspected_row
+      @row.merge(inspected_derivations).inspect
+    end
+
+    # As Namo#inspected_derivations: the value where there is one to show, and
+    # the derived list to name it either way.
+    def inspected_derivations
+      @formulae.keys.each_with_object({}) do |dimension, derived|
+        next if @formulae.required_parameter_count(dimension) > 2
+        derived[dimension] = self[dimension]
+      rescue StandardError
+        next
+      end
+    end
+
+    def inspected_derived
+      @formulae.keys.empty? ? '' : " derived: #{@formulae.keys.inspect}"
+    end
+
     def initialize(row, formulae, namo = nil)
       @row = row
       @formulae = formulae

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.30.1'
+  VERSION = '0.31.1'
 end

data/lib/namo.rb

@@ -17,6 +17,8 @@ class Namo
   attr_accessor :formulae
   attr_accessor :name
 
+  INSPECTED_ROWS = 10
+
   def dimensions
     data_dimensions + derived_dimensions
   end
@@ -247,6 +249,10 @@ class Namo
     end
   end
 
+  def inspect
+    "#<#{self.class}#{inspected_name}#{inspected_rows}#{inspected_derived}>"
+  end
+
   protected
 
   def row_multiset
@@ -265,6 +271,41 @@ class Namo
 
   private
 
+  def inspected_name
+    @name.nil? ? '' : " #{@name.inspect}"
+  end
+
+  # The rows as they are stored, never the derived values: inspect is called
+  # for every result in a console, and evaluating a formula there would cost a
+  # pass over the data per access and raise whatever the formula raises.
+  def inspected_rows
+    return ' []' if @data.empty?
+    shown = @data.first(INSPECTED_ROWS).map{|row| "  #{inspected_row(row)}"}.join(",\n")
+    shown += "\n  ... #{@data.length - INSPECTED_ROWS} more rows" if @data.length > INSPECTED_ROWS
+    " [\n#{shown}\n]"
+  end
+
+  def inspected_row(row)
+    row.merge(inspected_derivations(row)).inspect
+  end
+
+  # A derived dimension is shown with its value, in among the stored ones.  A
+  # formula wanting arguments has no value to show without them, and one which
+  # raises has none to show either; the derived list still names both.
+  def inspected_derivations(row)
+    subject = Row.new(row, @formulae, self)
+    derived_dimensions.each_with_object({}) do |dimension, derived|
+      next if @formulae.required_parameter_count(dimension) > 2
+      derived[dimension] = subject[dimension]
+    rescue StandardError
+      next
+    end
+  end
+
+  def inspected_derived
+    derived_dimensions.empty? ? '' : " derived: #{derived_dimensions.inspect}"
+  end
+
   def initialize(positional_data = nil, data: [], formulae: {}, name: nil)
     @data = positional_data || data
     @formulae = formulae.is_a?(Formulae) ? formulae : Formulae.new(formulae)

data/test/Namo/Collection_test.rb

@@ -346,4 +346,17 @@ describe Namo::Collection do
       _(car.detail.values(:assembly)).must_equal [:powertrain, :powertrain, :chassis, :body]
     end
   end
+
+  describe "#inspect" do
+    it "renders the member names and the row count" do
+      collection = Namo::Collection.new
+      collection << Namo.new([{a: 1}], name: :first) << Namo.new([{a: 2}], name: :second)
+      _(collection.inspect).must_equal "#<Namo::Collection members: [:first, :second], 2 rows>"
+    end
+
+    it "renders an empty Collection" do
+      _(Namo::Collection.new.inspect).must_equal "#<Namo::Collection members: [], 0 rows>"
+    end
+  end
+
 end

data/test/Namo/Formulae_test.rb

@@ -440,4 +440,19 @@ describe Namo::Formulae do
       end
     end
   end
+
+  describe "#inspect" do
+    it "renders the formula names" do
+      formulae = Namo::Formulae.new
+      formulae[:revenue] = proc{|row| row[:price]}
+      _(formulae.inspect).must_equal "#<Namo::Formulae [:revenue]>"
+    end
+
+    it "does not render the callables" do
+      formulae = Namo::Formulae.new
+      formulae[:revenue] = proc{|row| row[:price]}
+      _(formulae.inspect).wont_match(/Proc/)
+    end
+  end
+
 end

data/test/Namo/Row_test.rb

@@ -459,4 +459,29 @@ describe Namo::Row do
       _([a, b, duplicate_of_a].uniq.length).must_equal 2
     end
   end
+
+  describe "#inspect" do
+    it "renders the row data" do
+      _(Namo::Row.new({a: 1}, Namo::Formulae.new).inspect).must_equal "#<Namo::Row {a: 1}>"
+    end
+
+    it "shows a derived dimension with its value, in among the stored ones" do
+      formulae = Namo::Formulae.new
+      formulae[:b] = proc{|row| row[:a] + 1}
+      _(Namo::Row.new({a: 1}, formulae).inspect).must_equal "#<Namo::Row {a: 1, b: 2} derived: [:b]>"
+    end
+
+    it "names a derived dimension whose formula raises, without a value" do
+      formulae = Namo::Formulae.new
+      formulae[:b] = proc{|row| raise 'no value to show'}
+      _(Namo::Row.new({a: 1}, formulae).inspect).must_equal "#<Namo::Row {a: 1} derived: [:b]>"
+    end
+
+    it "does not render the Namo the row came from" do
+      namo = Namo.new((1..1000).map{|i| {a: i}})
+      _(namo.first.inspect).wont_match(/\{a: 2\}/)
+      _(namo.first.inspect.length).must_be :<, 100
+    end
+  end
+
 end

data/test/console_test.rb

@@ -0,0 +1,42 @@
+# test/console_test.rb
+
+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.
+
+describe 'script/console' do
+  def console(*expressions)
+    root = File.expand_path('..', __dir__)
+    IO.popen([File.join(root, 'script', 'console'), '--prompt', 'simple'],
+      'r+', chdir: root, err: [:child, :out]) do |io|
+      io.puts(expressions, 'exit')
+      io.close_write
+      io.read
+    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\]/)
+  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.to_a == ' + expected.inspect)).must_match(/true/)
+  end
+
+  it "starts without echoing its own source" do
+    _(console('1')).wont_match(/binding\.irb/)
+  end
+end

data/test/demo_test.rb

@@ -0,0 +1,88 @@
+# test/demo_test.rb
+
+require 'minitest/autorun'
+require 'minitest-spec-context'
+
+require_relative '../lib/namo'
+
+# script/demo is 300-odd lines exercising selection, projection, formulae,
+# group_by, summary, the operators and inspect, and nothing else runs it.  These
+# assert only that each section completes, which is the difference between a
+# demonstration which rots quietly and one which fails the suite when the library
+# moves under it.
+#
+# A process apiece, since the script is a program rather than a library and its
+# sections share a binding within a run.
+
+describe 'script/demo' do
+  def demo(*sections)
+    root = File.expand_path('..', __dir__)
+    IO.popen([File.join(root, 'script', 'demo'), *sections],
+      chdir: root, err: [:child, :out]){|io| io.read}
+  end
+
+  def sections
+    @sections ||= demo('--help').scan(/^  [* ] ([a-z_]+)$/).flatten
+  end
+
+  def cut
+    @cut ||= demo('--help').scan(/^  \* ([a-z_]+)$/).flatten
+  end
+
+  it "lists its sections" do
+    _(sections).wont_be_empty
+    _(sections).must_include 'ingestion'
+  end
+
+  it "runs every section without raising" do
+    failed = sections.reject do |section|
+      demo(section)
+      $?.success?
+    end
+    _(failed).must_be_empty
+  end
+
+  it "has a talk cut, and it is a subset of the sections" do
+    _(cut).wont_be_empty
+    _(cut - sections).must_be_empty
+  end
+
+  it "runs the talk cut" do
+    demo('talk')
+    _($?.success?).must_equal true
+  end
+
+  # The padding is what holds a section title in one place on the screen, and it
+  # can only pad down to the constants.  A section grown past them would silently
+  # start pushing the next one about.  Rows rather than lines, since a line wider
+  # than the window costs more than one of them.
+  #
+  # The cut rather than every section: those are the ones which have to fit on the
+  # day, and the rest are reference, free to run long and be scrolled.
+  it "has no section in the talk cut taller than the slide height" do
+    source = File.read(File.join(File.expand_path('..', __dir__), 'script', 'demo'))
+    height, width = %w[SLIDE_HEIGHT SLIDE_WIDTH].map{|name| source[/^#{name} = (\d+)$/, 1].to_i}
+    _([height, width].min).must_be :>, 0
+    overlong = cut.select do |section|
+      demo(section).lines.sum{|line| [(line.chomp.size / width.to_f).ceil, 1].max} > height
+    end
+    _(overlong).must_be_empty
+  end
+
+  it "runs the whole script" do
+    demo
+    _($?.success?).must_equal true
+  end
+
+  it "refuses a section it does not have" do
+    demo('nonexistent')
+    _($?.success?).must_equal false
+  end
+
+  it "needs nothing but the gem's own dependencies" do
+    root = File.expand_path('..', __dir__)
+    output = IO.popen({'RUBYLIB' => nil}, [File.join(root, 'script', 'demo'), 'ingestion'],
+      chdir: root, err: [:child, :out]){|io| io.read}
+    _(output).wont_match(/LoadError/)
+  end
+end

data/test/namo_test.rb

@@ -3221,4 +3221,67 @@ describe Namo do
       end
     end
   end
+
+  describe "#inspect" do
+    it "renders the class and the rows" do
+      _(Namo.new([{a: 1}]).inspect).must_equal "#<Namo [\n  {a: 1}\n]>"
+    end
+
+    it "renders an empty Namo without a row block" do
+      _(Namo.new([]).inspect).must_equal "#<Namo []>"
+    end
+
+    it "shows a derived dimension with its value, in among the stored ones" do
+      namo = Namo.new([{a: 1}])
+      namo[:b] = proc{|row| row[:a] + 1}
+      _(namo.inspect).must_equal "#<Namo [\n  {a: 1, b: 2}\n] derived: [:b]>"
+    end
+
+    it "shows a collection-scoped derived value" do
+      namo = Namo.new([{a: 1}, {a: 2}])
+      namo[:total] = proc{|row, namo| namo.values(:a).sum}
+      _(namo.inspect).must_equal "#<Namo [\n  {a: 1, total: 3},\n  {a: 2, total: 3}\n] derived: [:total]>"
+    end
+
+    it "names a derived dimension whose formula raises, without a value" do
+      namo = Namo.new([{a: 1}])
+      namo[:b] = proc{|row| raise 'no value to show'}
+      _(namo.inspect).must_equal "#<Namo [\n  {a: 1}\n] derived: [:b]>"
+    end
+
+    it "names a derived dimension whose formula wants arguments, without a value" do
+      namo = Namo.new([{a: 1}])
+      namo[:b] = proc{|row, namo, factor| row[:a] * factor}
+      _(namo.inspect).must_equal "#<Namo [\n  {a: 1}\n] derived: [:b]>"
+    end
+
+    it "includes the name when there is one" do
+      _(Namo.new([{a: 1}], name: :sales).inspect).must_match(/\A#<Namo :sales \[/)
+    end
+
+    it "omits the name when there is none" do
+      _(Namo.new([{a: 1}]).inspect).must_match(/\A#<Namo \[/)
+    end
+
+    it "truncates beyond INSPECTED_ROWS and says how many are left" do
+      namo = Namo.new((1..25).map{|i| {a: i}})
+      _(namo.inspect.scan(/\{a: \d+\}/).length).must_equal Namo::INSPECTED_ROWS
+      _(namo.inspect).must_match(/\.\.\. 15 more rows/)
+    end
+
+    it "does not truncate at exactly INSPECTED_ROWS" do
+      namo = Namo.new((1..Namo::INSPECTED_ROWS).map{|i| {a: i}})
+      _(namo.inspect).wont_match(/more rows/)
+    end
+
+    it "reports the subclass rather than Namo" do
+      Object.const_set(:InspectedSubAssembly, Class.new(Namo)) unless defined?(InspectedSubAssembly)
+      _(InspectedSubAssembly.new([{a: 1}]).inspect).must_match(/\A#<InspectedSubAssembly \[/)
+    end
+
+    it "does not grow with the data beyond the truncation point" do
+      _(Namo.new((1..10_000).map{|i| {a: i}}).inspect.length).must_be :<, 500
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.30.1
+  version: 0.31.1
 platform: ruby
 authors:
 - thoran
@@ -79,6 +79,8 @@ files:
 - test/Namo/NegatedDimension_test.rb
 - test/Namo/Row_test.rb
 - test/Symbol_test.rb
+- test/console_test.rb
+- test/demo_test.rb
 - test/namo_test.rb
 homepage: https://github.com/thoran/namo
 licenses: