namo 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11011fc9115f460be75cc35c2f4a99f7d695a53a0ef362b714b4e564cef682ee
-  data.tar.gz: 9bf58afbf1f52f800c12cad38963253ed7cc371fd966b45f98131ca154595d98
+  metadata.gz: b1bc0f90c2517b809ed9929ffcdf2fbc1e538974bc30320a3b603d93582f5200
+  data.tar.gz: 70247c7e8fa7b48ac0192400016351c323f5abcd9ee1095653cc58d6edc524e4
 SHA512:
-  metadata.gz: fb32fce7accb48566f6610254315ce068111bd7b582cff01e7e890dcf8308ac12882ffd06a4fc01a889ba58df9481ebb79a1541bac6f710530cb3271d960973b
-  data.tar.gz: 3a4330c0e98f19ad5a4937ebc01ba4725658da0a6c3f330969683b3f68b54611d37a26c0a42b68761c4ac2f15db7fd362868ed28be4006167fb37964812a3665
+  metadata.gz: b7162863da3b04b989dd6206234094b160b0f32d36fee58f948608b85a3cd1c2dc09691c6e2c2c74d598942a0c15e44760f6b498a7bddbb1cc4bb2366b2996ac
+  data.tar.gz: 5dd204de47dc6979753a0b7113765093222f5fab870bacd4034aada2f93288af6e872781f357704951b75d1e17ea9c6aefc8a625530ca2e6f253f695c5456fc2

data/CHANGELOG

@@ -1,14 +1,27 @@
 CHANGELOG
-_______
+_________
 
-2026-03-15
+20260328
+0.1.0: Add formulae via []=. Formulae are procs which receive a Row object, compose via named references, and carry through selection.
+
+1. ~ Namo#[]: Refactor to accept *names for projection alongside **selections. Always returns a Namo instance.
+2. + Namo#[]=: Define named formulae as procs.
+3. + Namo#to_a: Extract data as an array of hashes.
+4. + Namo::Row: Resolve names against row data or formulae.
+5. ~ Namo#initialize: Accept optional formulae: keyword argument.
+6. + attr_accessor :data, :formulae
+7. ~ README.md: + Projection section, + Formulae section, + Extracting data section
+8. ~ namo_test.rb: Add tests for projection, formulae, composition, chained and single-call selection with projection.
+9. ~ Namo::VERSION: /0.0.1/0.1.0/
+
+20260315
 0.0.1: Fix README.md and CHANGELOG.
 
 1. ~ README.md: Fix Contributing secton.
 2. ~ CHANGELOG: Use the same description in the summary as in the commit message.
 3. ~ Namo::VERSION: /0.0.0/0.0.1/
 
-2026-03-15
+20260315
 0.0.0: The initial release has instantiation from hashes, automatic inferral of dimension names and co-ordinates, and selection of data by a single value, an array, or a range.
 
 1. + Namo

data/README.md

@@ -18,60 +18,165 @@ gem 'namo'
 
 ## Usage
 
-Create a Namo from an array of hashes:
+Create a Namo instance from an array of hashes:
 
 ```ruby
 require 'namo'
 
-prices = Namo.new([
-  {date: '2025-01-01', symbol: 'BHP', close: 42.5},
-  {date: '2025-01-01', symbol: 'RIO', close: 118.3},
-  {date: '2025-01-02', symbol: 'BHP', close: 43.1},
-  {date: '2025-01-02', symbol: 'RIO', close: 117.8}
+sales = Namo.new([
+  {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+  {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+  {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+  {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
 ])
 ```
 
 Dimensions and coordinates are inferred:
 
 ```ruby
-prices.dimensions
-# => [:date, :symbol, :close]
+sales.dimensions
+# => [:product, :quarter, :price, :quantity]
 
-prices.coordinates[:date]
-# => ['2025-01-01', '2025-01-02']
+sales.coordinates[:product]
+# => ['Widget', 'Gadget']
 
-prices.coordinates[:symbol]
-# => ['BHP', 'RIO']
+sales.coordinates[:quarter]
+# => ['Q1', 'Q2']
 ```
 
+### Selection
+
 Select by named dimension using keyword arguments:
 
 ```ruby
 # Single value
-prices[symbol: 'BHP']
+sales[product: 'Widget']
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
 
 # Multiple dimensions
-prices[date: '2025-01-01', symbol: 'BHP']
+sales[product: 'Widget', quarter: 'Q1']
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}
+# ]>
 
 # Range
-prices[close: 42.0..43.0]
+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}
+# ]>
 
 # Array of values
-prices[symbol: ['BHP', 'RIO']]
+sales[quarter: ['Q1']]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
+# ]>
+```
+
+### Projection
+
+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}
+# ]>
+```
+
+Selection and projection can be chained:
+
+```ruby
+sales[product: 'Widget'][:quarter, :price]
+# => #<Namo [
+#   {quarter: 'Q1', price: 10.0},
+#   {quarter: 'Q2', price: 10.0}
+# ]>
+```
+
+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}
+# ]>
+```
+
+Selection and projection always return a new Namo instance, so everything chains.
 
-# All data
-prices[]
+### Formulae
+
+Define computed dimensions using `[]=`:
+
+```ruby
+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}
+# ]>
+```
+
+Formulae compose:
+
+```ruby
+sales[:cost] = proc{|row| row[:quantity] * 4.0}
+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}
+# ]>
+```
+
+Formulae work with selection and projection:
+
+```ruby
+sales[product: 'Widget'][:revenue, :quarter]
+# => #<Namo [
+#   {revenue: 1000.0, quarter: 'Q1'},
+#   {revenue: 1500.0, quarter: 'Q2'}
+# ]>
 ```
 
-Selection always returns a new Namo. Omitting a dimension means "all values along that dimension."
+Formulae carry through selection — a filtered Namo instance remembers its formulae.
+
+### Extracting data
+
+`to_a` returns an array of hashes:
+
+```ruby
+sales[:product, :quarter, :revenue].to_a
+# => [
+#   {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}
+# ]
+```
 
 ## Why?
 
-Every other multi-dimensional array library requires you to pre-shape your data before you can work with it. Namo takes it in the form it already comes in.
+Every other multi-dimensional array library requires you to pre-shape your data before you can work with it. Namo takes it in the form it likely already comes in.
 
 ## Name
 
-Namo: na(med) (di)m(ensi)o(ns). A companion to Numo (numeric arrays for Ruby).
+Namo: nam(ed) (dimensi)o(ns). A companion to Numo (numeric arrays for Ruby). And in Aussie culture 'o' gets added to the end of names.
 
 ## Contributing
 

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 module Namo
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/namo.rb

@@ -2,6 +2,26 @@
 # Namo
 
 class Namo
+  class Row
+    def [](name)
+      if @formulae.key?(name)
+        @formulae[name].call(self)
+      else
+        @row[name]
+      end
+    end
+
+    private
+
+    def initialize(row, formulae)
+      @row = row
+      @formulae = formulae
+    end
+  end
+
+  attr_accessor :data
+  attr_accessor :formulae
+
   def dimensions
     @dimensions ||= @data.first.keys
   end
@@ -14,25 +34,46 @@ class Namo
     )
   end
 
-  def [](**selections)
-    selected = (
-      @data.select do |row|
-        selections.all? do |dimension, coordinate|
-          case coordinate
-          when Array, Range
-            coordinate.include?(row[dimension])
-          else
-            coordinate == row[dimension]
-          end
-        end
+  def [](*names, **selections)
+    data = selections.any? ? select_rows(selections) : @data
+    if names.any?
+      data = data.map do |row_data|
+        row = Row.new(row_data, @formulae)
+        names.each_with_object({}){|name, hash| hash[name] = row[name]}
       end
-    )
-    self.class.new(selected)
+    end
+    self.class.new(data, formulae: @formulae.dup)
+  end
+
+  def []=(name, proc)
+    @formulae[name] = proc
+  end
+
+  def to_a
+    @data.map do |row|
+      row.keys.each_with_object({}) do |key, hash|
+        hash[key] = row[key]
+      end
+    end
   end
 
   private
 
-  def initialize(data)
+  def initialize(data = nil, formulae: {})
     @data = data
+    @formulae = formulae
+  end
+
+  def select_rows(selections)
+    @data.select do |row|
+      selections.all? do |dimension, coordinate|
+        case coordinate
+        when Array, Range
+          coordinate.include?(row[dimension])
+        else
+          row[dimension] == coordinate
+        end
+      end
+    end
   end
 end

data/namo.gemspec

@@ -2,7 +2,6 @@ require_relative './lib/Namo/VERSION'
 
 Gem::Specification.new do |spec|
   spec.name = 'namo'
-  spec.date = '2026-03-15'
   spec.version = Namo::VERSION
 
   spec.summary = "Named dimensional data for Ruby."
@@ -28,5 +27,6 @@ Gem::Specification.new do |spec|
   ].flatten
 
   spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-spec-context'
   spec.add_development_dependency 'rake'
 end

data/test/namo_test.rb

@@ -1,70 +1,154 @@
-# namo_test.rb
-
-# 20260314
-# 0.0.0
-
 require 'minitest/autorun'
+require 'minitest-spec-context'
+
 require_relative '../lib/namo'
 
 describe Namo do
   let(:sample_data) do
     [
-      {date: '2025-01-01', symbol: 'BHP', close: 42.5},
-      {date: '2025-01-01', symbol: 'RIO', close: 118.3},
-      {date: '2025-01-02', symbol: 'BHP', close: 43.1},
-      {date: '2025-01-02', symbol: 'RIO', close: 117.8}
+      {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+      {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+      {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+      {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
     ]
   end
 
-  let(:namo){ Namo.new(sample_data) }
+  let(:sales) do
+    Namo.new(sample_data)
+  end
 
-  describe '#dimensions' do
-    it 'infers dimensions from hash keys' do
-      _(namo.dimensions).must_equal [:date, :symbol, :close]
+  describe "#dimensions" do
+    it "infers dimensions from hash keys" do
+      _(sales.dimensions).must_equal [:product, :quarter, :price, :quantity]
     end
   end
 
-  describe '#coordinates' do
-    it 'extracts unique values per dimension' do
-      _(namo.coordinates[:date]).must_equal ['2025-01-01', '2025-01-02']
-      _(namo.coordinates[:symbol]).must_equal ['BHP', 'RIO']
-      _(namo.coordinates[:close]).must_equal [42.5, 118.3, 43.1, 117.8]
+  describe "#coordinates" do
+    it "extracts unique values for each dimension" do
+      _(sales.coordinates).must_equal ({
+        product: ['Widget', 'Gadget'],
+        quarter: ['Q1', 'Q2'],
+        price: [10.0, 25.0],
+        quantity: [100, 150, 40, 60]
+      })
+      _(sales.coordinates[:product]).must_equal ['Widget', 'Gadget']
+      _(sales.coordinates[:quarter]).must_equal ['Q1', 'Q2']
+    end
+  end
+
+  describe "#[]" do
+    context "selection" do
+      it "selects by single coordinate" do
+        result = sales[product: 'Widget']
+        _(result.coordinates[:product]).must_equal ['Widget']
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "selects by array of coordinates" do
+        result = sales[quarter: ['Q1']]
+        _(result.coordinates[:quarter]).must_equal ['Q1']
+        _(result.to_a.count).must_equal 2
+      end
+
+      it "selects by multiple dimensions" do
+        result = sales[product: 'Widget', quarter: 'Q1']
+        _(result.to_a.count).must_equal 1
+        _(result.to_a).must_equal [{product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}]
+      end
+
+      it "returns a Namo instance" do
+        result = sales[product: 'Widget']
+        _(result.coordinates[:product]).must_equal ['Widget']
+      end
+    end
+
+    context "projection" do
+      it "projects to named dimensions" do
+        result = sales[:product, :price]
+        _(result.dimensions).must_equal [:product, :price]
+        _(result.coordinates[:product]).must_equal ['Widget', 'Gadget']
+        _(result.to_a.count).must_equal 4
+      end
+    end
+
+    context "selection and projection" do
+      it "can use them together" do
+        result = sales[:price, product: 'Widget']
+        _(result.to_a.count).must_equal 2
+        _(result.to_a).must_equal [{price: 10.0}, {price: 10.0}]
+      end
+
+      it "can chain them" do
+        result = sales[product: 'Widget'][:price]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a).must_equal [{price: 10.0}, {price: 10.0}]
+      end
     end
   end
 
-  describe '#[]' do
-    it 'selects by single value' do
-      result = namo[symbol: 'BHP']
-      _(result.coordinates[:date]).must_equal ['2025-01-01', '2025-01-02']
-      _(result.coordinates[:symbol]).must_equal ['BHP']
-      _(result.coordinates[:close]).must_equal [42.5, 43.1]
+  describe "#[]= formulae" do
+    it "defines a formula" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales[:product, :quarter, :revenue].to_a).must_equal [
+        {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}
+      ]
+    end
+
+    it "composes formulae" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      sales[:cost] = proc{|r| r[:quantity] * 4.0}
+      sales[:profit] = proc{|r| r[:revenue] - r[:cost]}
+      _(sales[:product, :quarter, :profit].to_a).must_equal [
+        {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}
+      ]
     end
 
-    it 'selects by multiple dimensions' do
-      result = namo[date: '2025-01-01', symbol: 'BHP']
-      _(result.coordinates[:date]).must_equal ['2025-01-01']
-      _(result.coordinates[:symbol]).must_equal ['BHP']
-      _(result.coordinates[:close]).must_equal [42.5]
+    it "works with chained selection and projection" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales[product: 'Widget'][:product, :quarter, :revenue]
+      _(result.to_a).must_equal [
+        {product: "Widget", quarter: "Q1", revenue: 1000.0},
+        {product: "Widget", quarter: "Q2", revenue: 1500.0}
+      ]
     end
 
-    it 'selects by range' do
-      result = namo[close: 42.0..43.0]
-      _(result.coordinates[:close]).must_equal [42.5]
+    it "works with single-call selection and projection" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales[:product, :revenue, product: 'Widget']
+      _(result.to_a).must_equal [
+        {product: "Widget", revenue: 1000.0},
+        {product: "Widget", revenue: 1500.0}
+      ]
     end
 
-    it 'selects by array of values' do
-      result = namo[symbol: ['BHP', 'RIO']]
-      _(result.coordinates[:symbol]).must_equal ['BHP', 'RIO']
+    it "carries formulae through selection" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      widgets = sales[product: 'Widget']
+      _(widgets[:revenue].to_a).must_equal [{revenue: 1000.0}, {revenue: 1500.0}]
     end
 
-    it 'returns a Namo' do
-      result = namo[symbol: 'BHP']
-      _(result).must_be_kind_of Namo
+    it "projects formula with context dimensions" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales[:product, :quarter, :revenue]
+      _(result.to_a).must_equal [
+        {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}
+      ]
     end
+  end
 
-    it 'returns all data when no selections given' do
-      result = namo[]
-      _(result.coordinates).must_equal namo.coordinates
+  describe "#to_a" do
+    it "returns the data as an array of hashes" do
+      _(sales.to_a).must_equal sample_data
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - thoran
 bindir: bin
 cert_chain: []
-date: 2026-03-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-spec-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.7
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Named dimensional data for Ruby.
 test_files: []