namo.rb 0.31.7

data/Rakefile

@@ -0,0 +1,42 @@
+# Rakefile
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+namespace :docs do
+  SOURCE_DOCS = %w{COMPARISON EXAMPLES README ROADMAP}
+
+  desc "Strip syntax highlighting from code blocks for printing"
+  task :md4print do
+    SOURCE_DOCS.each do |name|
+      sh "script/md4print #{name}.md"
+      sh "mv #{name}.print.md docs/"
+    end
+  end
+
+  desc "Render print-ready markdown to PDF"
+  task :md2pdf => :md4print do
+    Dir.glob('docs/*.print.md').each do |f|
+      pdf = f.sub(/\.md$/, '.pdf')
+      sh "pandoc #{f} --pdf-engine=xelatex --include-in-header script/print.preamble.tex -V geometry:margin=1in -V mainfont=Charter -V monofont=Menlo -o #{pdf}"
+    end
+  end
+
+  desc "Remove intermediate .print.md files"
+  task :clean do
+    rm_f Dir.glob('docs/*.print.md')
+  end
+
+  desc "Remove all generated docs (intermediates and PDFs)"
+  task :clobber => :clean do
+    rm_f Dir.glob('docs/*.print.pdf')
+  end
+
+  desc "Regenerate all derived docs"
+  task :gen => [:md2pdf, :clean]
+end
+
+task default: :test

data/lib/Namo/Collection.rb

@@ -0,0 +1,130 @@
+# Namo/Collection.rb
+# Namo::Collection
+
+class Namo
+  class Collection < Namo
+    attr_reader :members
+
+    def <<(*constituents)
+      constituents.flatten.each do |constituent|
+        case constituent
+        when Namo then add_member(constituent)
+        when Module then attach(constituent)
+        when Hash, Row
+          raise ArgumentError, "a Collection's rows come from its members; add a member (a named Namo), not a loose row"
+        else raise TypeError, "can't append #{constituent.class} to a Collection"
+        end
+      end
+      @data = detail.data
+      self
+    end
+
+    def find(name)
+      @members.find{|member| member.name == name} unless name.nil?
+    end
+
+    def summary(dimension = nil, by: :member, reducer: :sum, &block)
+      raise ArgumentError, "summary needs a dimension or a block" unless dimension || block
+      rows = (
+        if block
+          @members.map{|member| block.call(member).merge(by => member.name)}
+        else
+          @members.map{|member| {by => member.name, dimension => member.values(dimension).send(reducer)}}
+        end
+      )
+      Namo.new(rows)
+    end
+
+    def detail(positional_by = nil, by: :member)
+      by = positional_by || by
+      rows = (
+        @members.flat_map do |member|
+          member.data.map{|row| row.key?(by) ? row : row.merge(by => member.name)}
+        end
+      )
+      Namo.new(rows, formulae: member_formulae)
+    end
+
+    def as_summary(dimension = nil, by: :member, reducer: :sum, &block)
+      @data = summary(dimension, by: by, reducer: reducer, &block).data
+      self
+    end
+
+    def as_detail(positional_by = nil, by: :member)
+      by = positional_by || by
+      view = detail(by)
+      @data = view.data
+      @formulae = @formulae.merge(view.formulae)
+      self
+    end
+
+    # The members are the substance, so they are what is rendered.  A list of names
+    # and a row count described the derived view and called it the object, and the
+    # list was unbounded besides: 2,641 members emitted 22,704 characters on one
+    # line, which is the failure INSPECTED_ROWS was introduced to end.
+    #
+    # That budget is now spread across the members shown rather than spent on one
+    # member's rows: one member renders ten of its rows, ten members render one
+    # apiece, five render two.
+    def inspect
+      "#<#{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
+      each = [INSPECTED_ROWS / shown, 1].max
+      rendered = @members.first(shown).map{|member| "  #{member.name.inspect} => #{inspected_member(member, each)}"}.join(",\n")
+      rendered += "\n  ... #{@members.length - shown} more members" if @members.length > shown
+      "[\n#{rendered}\n]"
+    end
+
+    # A member showing a single row is rendered on one line: three lines of brackets
+    # to carry one row is the shape a Collection of many members lands in, and it
+    # cost more than the rows did.  On what is rendered rather than on the limit,
+    # so a member holding one row of a larger allowance reads the same way.
+    def inspected_member(member, limit)
+      rows, remainder, unshown = member.inspected_data(limit)
+      elided = remainder > 0
+      suffix = inspected_derived_names(unshown)
+      if rows.length == 1
+        "[#{rows.join}#{elided ? ", ... #{remainder} more rows" : ''}]#{suffix}"
+      else
+        body = rows.map{|row| "    #{row}"}.join(",\n")
+        body += "\n    ... #{remainder} more rows" if elided
+        "[\n#{body}\n  ]#{suffix}"
+      end
+    end
+
+    def initialize(positional_data = nil, data: [], formulae: {}, name: nil)
+      @members = []
+      super
+    end
+
+    def add_member(member)
+      @members.reject!{|existing| existing.name == member.name} unless member.name.nil?
+      @members << member
+    end
+  end
+end

data/lib/Namo/Enumerable.rb

@@ -0,0 +1,83 @@
+# 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, self))}
+    end
+
+    def select(&block)
+      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)
+      return_class.new(@data.reject{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
+    end
+
+    def sort_by(&block)
+      return_class.new(@data.sort_by{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
+    end
+
+    def first(n = nil)
+      if n
+        return_class.new(@data.first(n), formulae: @formulae.dup)
+      else
+        @data.first ? Row.new(@data.first, @formulae, self) : nil
+      end
+    end
+
+    def last(n = nil)
+      if n
+        return_class.new(@data.last(n), formulae: @formulae.dup)
+      else
+        @data.last ? Row.new(@data.last, @formulae, self) : nil
+      end
+    end
+
+    def take(n)
+      return_class.new(@data.take(n), formulae: @formulae.dup)
+    end
+
+    def drop(n)
+      return_class.new(@data.drop(n), formulae: @formulae.dup)
+    end
+
+    def take_while(&block)
+      return_class.new(@data.take_while{|row| block.call(Row.new(row, @formulae, self))}, formulae: @formulae.dup)
+    end
+
+    def drop_while(&block)
+      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
+      return_class.new(rows, formulae: @formulae.dup)
+    end
+
+    def partition(&block)
+      matches, non_matches = @data.partition{|row| block.call(Row.new(row, @formulae, self))}
+      [
+        return_class.new(matches, formulae: @formulae.dup),
+        return_class.new(non_matches, formulae: @formulae.dup),
+      ]
+    end
+
+    def group_by(dimension)
+      collection = Collection.new
+      source = derived_dimensions.include?(dimension) ? self[*data_dimensions, dimension] : self
+      members = (
+        source.data.group_by{|row_data| row_data[dimension]}.map do |value, rows|
+          return_class.new(rows, formulae: source.formulae.dup, name: value)
+        end
+      )
+      collection << members
+    end
+  end
+end

data/lib/Namo/Formulae.rb

@@ -0,0 +1,137 @@
+# Namo/Formulae.rb
+# Namo::Formulae
+
+class Namo
+  class Formulae
+    include Enumerable
+
+    def [](name)
+      @store[name]
+    end
+
+    def []=(name, callable)
+      @store[name] = callable
+    end
+
+    def attach(modul)
+      raise_unless_formulary(modul)
+      modul.public_instance_methods(false).each{|name| bind(name, modul)}
+      self
+    end
+    alias_method :<<, :attach
+
+    def detach(constituent)
+      case constituent
+      when Symbol
+        @store.delete(constituent)
+      when Module
+        raise_unless_formulary(constituent)
+        constituent.public_instance_methods(false).each{|name| @store.delete(name)}
+      else
+        raise TypeError, "can't detach #{constituent.class} from a Formulae; expected a Symbol or a Module (formulary)"
+      end
+      self
+    end
+
+    def derive(name, row, namo, *arguments)
+      formula = self[name]
+      if collection_scoped?(name)
+        raise_unless_namo_context(name, namo)
+        formula.call(row, namo, *arguments)
+      else
+        formula.call(row)
+      end
+    end
+
+    def required_parameter_count(name)
+      formula = self[name]
+      formula.arity >= 0 ? formula.arity : -formula.arity - 1
+    end
+
+    def keys
+      @store.keys
+    end
+
+    def key?(name)
+      @store.key?(name)
+    end
+
+    def empty?
+      @store.empty?
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      @store.each(&block)
+    end
+
+    def delete(name)
+      @store.delete(name)
+    end
+
+    def merge(other)
+      self.class.new(@store.merge(other.to_h))
+    end
+
+    def reject(&block)
+      self.class.new(@store.reject(&block))
+    end
+
+    def dup
+      self.class.new(@store.dup)
+    end
+
+    def to_h
+      @store.dup
+    end
+
+    def ==(other)
+      other.is_a?(Formulae) && keys.sort == other.keys.sort
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      keys.sort.hash
+    end
+
+    def inspect
+      "#<#{self.class} #{@store.keys.inspect}>"
+    end
+
+    private
+
+    def initialize(store = {})
+      @store = store
+    end
+
+    def host
+      @host ||= Object.new
+    end
+
+    def bind(name, modul)
+      raise_unless_formulary(modul)
+      host.extend(modul)
+      self[name] = modul.instance_method(name).bind(host)
+      self
+    end
+
+    def raise_unless_formulary(modul)
+      unless modul.include?(Namo::Formulary)
+        raise ArgumentError, "not a Namo::Formulary: #{modul}"
+      end
+    end
+
+    def collection_scoped?(name)
+      required_parameter_count(name) >= 2
+    end
+
+    def raise_unless_namo_context(name, namo)
+      unless namo
+        raise ArgumentError, "collection-scoped formula #{name.inspect} requires a Namo context, but this Row has none"
+      end
+    end
+  end
+end

data/lib/Namo/Formulary.rb

@@ -0,0 +1,6 @@
+# Namo/Formulary.rb
+# Namo::Formulary
+
+class Namo
+  module Formulary; end
+end

data/lib/Namo/NegatedDimension.rb

@@ -0,0 +1,14 @@
+# Namo/NegatedDimension.rb
+# Namo::NegatedDimension
+
+class Namo
+  class NegatedDimension
+    attr_reader :name
+
+    private
+
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/Namo/Row.rb

@@ -0,0 +1,93 @@
+# Namo/Row.rb
+# Namo::Row
+
+class Namo
+  class Row
+    def [](name, *arguments)
+      raise_unless_expected_arguments(name, arguments)
+      if @formulae.key?(name)
+        @formulae.derive(name, self, @namo, *arguments)
+      else
+        @row[name]
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Row) && @row == other.to_h
+    end
+
+    def eql?(other)
+      other.is_a?(Row) && @row.eql?(other.to_h)
+    end
+
+    def hash
+      @row.hash
+    end
+
+    def match?(selections)
+      selections.all? do |dimension, coordinate|
+        case coordinate
+        when Array, Range
+          coordinate.include?(self[dimension])
+        when Proc
+          coordinate.call(self[dimension])
+        when Regexp
+          coordinate.match?(self[dimension].to_s)
+        else
+          self[dimension] == coordinate
+        end
+      end
+    end
+
+    def to_h
+      @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
+      @namo = namo
+    end
+
+    def expected_argument_counts(name)
+      return [0, 0] unless @formulae.key?(name)
+      count = @formulae.required_parameter_count(name)
+      return [0, 0] unless count >= 2
+      minimum = count - 2
+      maximum = @formulae[name].arity >= 0 ? minimum : nil
+      [minimum, maximum]
+    end
+
+    def raise_unless_expected_arguments(name, arguments)
+      minimum, maximum = expected_argument_counts(name)
+      return if arguments.length >= minimum && (maximum.nil? || arguments.length <= maximum)
+      expected = maximum.nil? ? "#{minimum}+" : minimum.to_s
+      raise ArgumentError, "wrong number of arguments for #{name.inspect} (given #{arguments.length}, expected #{expected})"
+    end
+  end
+end

data/lib/Namo/VERSION.rb

@@ -0,0 +1,6 @@
+# Namo/VERSION.rb
+# Namo::VERSION
+
+class Namo
+  VERSION = '0.31.7'
+end

data/lib/Symbol.rb

@@ -0,0 +1,8 @@
+# Symbol.rb
+# Symbol#-@
+
+class Symbol
+  def -@
+    Namo::NegatedDimension.new(self)
+  end
+end