namo 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11011fc9115f460be75cc35c2f4a99f7d695a53a0ef362b714b4e564cef682ee
-  data.tar.gz: 9bf58afbf1f52f800c12cad38963253ed7cc371fd966b45f98131ca154595d98
+  metadata.gz: 6841b3921358ce7eefdbfbdba3a62eafd74857223d9df86038f9cc8087bbb947
+  data.tar.gz: bf05398ce78ea49683fbb7adb0b9989c6d6df86864a9bdf2373b156b14d8d5e7
 SHA512:
-  metadata.gz: fb32fce7accb48566f6610254315ce068111bd7b582cff01e7e890dcf8308ac12882ffd06a4fc01a889ba58df9481ebb79a1541bac6f710530cb3271d960973b
-  data.tar.gz: 3a4330c0e98f19ad5a4937ebc01ba4725658da0a6c3f330969683b3f68b54611d37a26c0a42b68761c4ac2f15db7fd362868ed28be4006167fb37964812a3665
+  metadata.gz: 2887c9dee76341b5e4ee75d50a1416475bd8c579d52117f67dcab81c9fe7c8cb1c50c08be7295db74aaf1f2d8727aa678b95d231d4c2e1d82a25b1ca050de61e
+  data.tar.gz: d5c5a35ac078d60dcd1baf43e73b5be1aa1bf02ed27a65071fd146223402a812a8b9ff9b88e6be5e4e62b5b47966460df613994d79215405439cde96c1a63278

data/CHANGELOG

@@ -1,14 +1,40 @@
 CHANGELOG
-_______
+_________
 
-2026-03-15
+20260414
+0.2.0: Include Enumerable.
+
+1. ~ Namo: include Enumerable
+2. + Namo#each: Yield Row objects wrapping each data row with formulae. Returns an Enumerator when no block is given.
+3. ~ Namo#[]: Refactor to use Enumerable#select and Row#match? instead of select_rows.
+4. - Namo#select_rows: Replaced by Row#match?.
+5. + Namo::Row#match?: Selection logic moved from Namo to Row.
+6. + Namo::Row#to_h: Return the underlying row hash.
+7. ~ namo_test.rb: Add tests for #each and Enumerable methods (map, reduce, min_by, flat_map).
+8. ~ README.md: + Enumerable section
+9. ~ Namo::VERSION: /0.1.0/0.2.0/; /module/class/ to match Namo's definition.
+
+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,194 @@ 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.
+
+### 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:
 
-# All data
-prices[]
+```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'}
+# ]>
+```
+
+Formulae carry through selection — a filtered Namo instance remembers its formulae.
+
+### Enumerable
+
+Namo includes `Enumerable`, so `each`, `reduce`, `map`, `select`, `min_by`, and all the rest work out of the box. Rows are yielded as `Row` objects, so formulae are accessible during enumeration:
+
+```ruby
+sales.reduce(0){|sum, row| sum + row[:quantity]}
+# => 350
+
+sales[product: 'Widget'].reduce(0){|sum, row| sum + row[:quantity]}
+# => 250
+
+sales[:revenue] = proc{|row| row[:price] * row[:quantity]}
+
+sales.reduce(0){|sum, row| sum + row[:revenue]}
+# => 5000.0
+
+sales[product: 'Widget'].reduce(0){|sum, row| sum + row[:revenue]}
+# => 2500.0
+
+sales.map{|row| row[:product]}
+# => ['Widget', 'Widget', 'Gadget', 'Gadget']
+
+sales.min_by{|row| row[:price]}[:product]
+# => 'Widget'
+
+sales.flat_map{|row| [row[:price]]}
+# => [10.0, 10.0, 25.0, 25.0]
 ```
 
-Selection always returns a new Namo. Omitting a dimension means "all values along that dimension."
+### 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

@@ -1,6 +1,6 @@
 # Namo/VERSION.rb
 # Namo::VERSION
 
-module Namo
-  VERSION = '0.0.1'
+class Namo
+  VERSION = '0.2.0'
 end

data/lib/namo.rb

@@ -2,6 +2,43 @@
 # Namo
 
 class Namo
+  include Enumerable
+
+  class Row
+    def [](name)
+      if @formulae.key?(name)
+        @formulae[name].call(self)
+      else
+        @row[name]
+      end
+    end
+
+    def match?(selections)
+      selections.all? do |dimension, coordinate|
+        case coordinate
+        when Array, Range
+          coordinate.include?(self[dimension])
+        else
+          self[dimension] == coordinate
+        end
+      end
+    end
+
+    def to_h
+      @row
+    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 +51,41 @@ 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
+  def [](*names, **selections)
+    rows = selections.any? ? select{|row| row.match?(selections)} : entries
+    data = (
+      if names.any?
+        rows.map do |row|
+          names.each_with_object({}){|name, hash| hash[name] = row[name]}
         end
+      else
+        rows.map(&:to_h)
       end
     )
-    self.class.new(selected)
+    self.class.new(data, formulae: @formulae.dup)
+  end
+
+  def []=(name, proc)
+    @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 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
 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,212 @@
-# 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
+      _(sales.dimensions).must_equal [:product, :quarter, :price, :quantity]
+    end
+  end
+
+  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 "#[]= 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 "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 "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 "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
 
-  describe '#dimensions' do
-    it 'infers dimensions from hash keys' do
-      _(namo.dimensions).must_equal [:date, :symbol, :close]
+    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
 
-  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 "#each" do
+    it "yields Row objects" do
+      rows = []
+      sales.each{|row| rows << row}
+      _(rows.first).must_be_kind_of Namo::Row
+      _(rows.length).must_equal 4
+    end
+
+    it "yields rows with access to data" do
+      products = sales.map{|row| row[:product]}
+      _(products).must_equal ['Widget', 'Widget', 'Gadget', 'Gadget']
+    end
+
+    it "yields rows with access to formulae" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      revenues = sales.map{|row| row[:revenue]}
+      _(revenues).must_equal [1000.0, 1500.0, 1000.0, 1500.0]
+    end
+
+    it "returns an enumerator without a block" do
+      _(sales.each).must_be_kind_of Enumerator
     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 "Enumerable" do
+    it "supports reduce" do
+      total_quantity = sales.reduce(0){|sum, row| sum + row[:quantity]}
+      _(total_quantity).must_equal 350
     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 "supports reduce with selection" do
+      widget_quantity = sales[product: 'Widget'].reduce(0){|sum, row| sum + row[:quantity]}
+      _(widget_quantity).must_equal 250
     end
 
-    it 'selects by range' do
-      result = namo[close: 42.0..43.0]
-      _(result.coordinates[:close]).must_equal [42.5]
+    it "supports reduce with formulae" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      total_revenue = sales.reduce(0){|sum, row| sum + row[:revenue]}
+      _(total_revenue).must_equal 5000.0
     end
 
-    it 'selects by array of values' do
-      result = namo[symbol: ['BHP', 'RIO']]
-      _(result.coordinates[:symbol]).must_equal ['BHP', 'RIO']
+    it "supports reduce with selection and formulae" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      widget_revenue = sales[product: 'Widget'].reduce(0){|sum, row| sum + row[:revenue]}
+      _(widget_revenue).must_equal 2500.0
     end
 
-    it 'returns a Namo' do
-      result = namo[symbol: 'BHP']
-      _(result).must_be_kind_of Namo
+    it "supports min_by" do
+      cheapest = sales.min_by{|row| row[:price]}
+      _(cheapest[:product]).must_equal 'Widget'
     end
 
-    it 'returns all data when no selections given' do
-      result = namo[]
-      _(result.coordinates).must_equal namo.coordinates
+    it "supports flat_map" do
+      prices = sales.flat_map{|row| [row[:price]]}
+      _(prices).must_equal [10.0, 10.0, 25.0, 25.0]
+    end
+  end
+
+  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.2.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.10
 specification_version: 4
 summary: Named dimensional data for Ruby.
 test_files: []