crunchr 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.12"
+  gem "mocha"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "1.2.1"
+  gem "jeweler", "~> 1.8.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.6)
+    metaclass (0.0.1)
+    mocha (0.13.1)
+      metaclass (~> 0.0.1)
+    rake (10.0.3)
+    rcov (0.9.10)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (= 1.2.1)
+  jeweler (~> 1.8.4)
+  mocha
+  rcov
+  rdoc (~> 3.12)
+  rspec (~> 2.12)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Hartog C. de Mik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,82 @@
+= crunchr
+
+  Given an ORM-model that makes snapshots with counts off your data
+  When I include Crunchr
+  Then I can do all kinds of nifty calculations
+
+== Synopsis
+
+  # Given an ORM-mode that makes snapshots
+  class Statistic < ActiveRecord::Base
+    serialize :data
+
+    def self.snapshot
+      Statistic.create(
+        data: {
+          keys: Key.count,
+          doors: Door.count,
+          rooms: {
+            count: Room.count,
+            occupied: Room.occupied.count
+          }
+        }
+      )
+    end
+
+    # When I include Crunchr
+    include Crunchr
+  end
+
+  # Then I can doo all kinds of nifty things
+  s = Statistic.last
+
+  # like, fetch data
+  s.fetch('keys')                # 10
+  s.fetch('doors')               # 8
+  s.fetch('rooms/count')         # 7
+
+  # do calculations
+  s.fetch('keys x doors')        # 80
+  s.fetch('keys - doors')        # 2 spare keys...
+  s.fetch('doors / rooms/count') # 1.1428 doors per room
+
+  # make deltas
+  delta = s.delta(Statistic.first)
+  delta.fetch('keys')           # 10 (now) - 5 (then) = 5
+  delta.fetch('keys - doors')   # 5 (see above) - 8   = -3
+  delta.fetch('rooms/occupied') # 0 (did not change)
+
+  # make tables
+  rows = Statistic.where( "created_at > ?", 1.week.ago )
+  Statistic.as_table( rows, keys: ['keys',  'doors', 'keys / doors'] )
+  # => [
+  #   [ 9, 8, 1.125 ]
+  #   [ 9, 8, 1.125 ]
+  #   [ 7, 8, 0.875 ]
+  #   [ 10, 8, 1.25 ]
+  # ]
+
+== TODO
+
+* Use created_at as a way to group data for ActiveModel (alike) includers
+
+== Contributing to crunchr
+
+* Check out the latest master to make sure the feature hasn't been
+  implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested
+  it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want
+  to have your own version, or is otherwise necessary, that is fine, but
+  please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Hartog C. de Mik. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "crunchr"
+  gem.homepage = "http://github.com/coffeeaddict/crunchr"
+  gem.license = "MIT"
+  gem.summary = %Q{Statistics crunching}
+  gem.description = %Q{Crunch statistics}
+  gem.email = "hartog@organisedminds.com"
+  gem.authors = ["Hartog C. de Mik"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+      spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "crunchr #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/crunchr.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "crunchr"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hartog C. de Mik"]
+  s.date = "2013-02-08"
+  s.description = "Crunch statistics"
+  s.email = "hartog@organisedminds.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "crunchr.gemspec",
+    "lib/crunchr.rb",
+    "lib/crunchr/active_record.rb",
+    "lib/crunchr/core_ext.rb",
+    "spec/crunchr_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/coffeeaddict/crunchr"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "Statistics crunching"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.12"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["= 1.2.1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.12"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["= 1.2.1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.12"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["= 1.2.1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/crunchr.rb

@@ -0,0 +1,246 @@
+require 'crunchr/core_ext'
+require 'bigdecimal'
+
+# Crunch statistics with fun
+#
+# @author Harotg de Mik
+#
+module Crunchr
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def zero; self.class.zero; end
+  def checked(val); self.class.checked(val); end
+
+  def delta(other)
+    return nil unless other.respond_to?(:data) && !other.data.is_a?(Hash)
+    return nil unless self.data.is_a?(Hash)
+
+    delta = self.class.new( :data => self.data.delta(other.data) )
+
+    # make it read-only
+    delta.readonly! if delta.respond_to?(:readonly!)
+
+    return delta
+  end
+
+  # Get the value from the data
+  #
+  #   # Given a data tree that looks like
+  #   { number: 1
+  #     collection: {
+  #       depth: 2
+  #     }
+  #     list: [ 1, 2, 3 ]
+  #   }
+  #
+  #   fetch("number")           # => 1
+  #   fetch("collection/depth") # => 2
+  #   fetch("n'existe pas")     # => nil
+  #   fetch("collection")       # => { depth: 2 }
+  #   fetch("list")             # => nil - NaN && !Hash
+  #
+  # When you supply a calculation to fetch, it will delegate to calculate
+  #   fetch("number : collection") # => 0.5 (1 / 2)
+  #
+  def fetch(key)
+    return calculate(key) if key =~ / [*\/:x+-] /
+
+    key = key.split(/\//).collect(&:to_sym) if key =~ /\//
+    value = nil
+
+    # fetch directly
+    if [String, Symbol].include?(key.class)
+      if self.data.has_key?(key)
+        value = self.data.fetch(key)
+      else
+        value = self.data.fetch(key.to_sym) rescue nil
+      end
+
+    else
+      value = self.data
+      key.each do |sub|
+        value = value.fetch(sub) rescue nil
+      end
+    end
+
+    if value.is_a?(Numeric) || value.is_a?(Hash)
+      return value
+    end
+
+  rescue => ex
+    if self.class.respond_to?(:logger) && !self.class.logger.nil?
+      self.class.logger.error "Error in #{self.class}.fetch(#{key}) for #{data}"
+    end
+  end
+
+  # given a string like 'keys - doors', returns the amount of spare keys
+  #
+  def calculate(key)
+    (left, op, right) = key.split(/\s/)
+
+
+    left = (
+      left =~ /[^\d.]/ ? self.fetch(left) : BigDecimal.new(left)
+    ) || zero()
+
+    right = (
+      right =~ /[^\d.]/ ? self.fetch(right) : BigDecimal.new(right)
+    ) || zero()
+
+    op = op == ":" ? "/" : op
+    op = op == "x" ? "*" : op
+
+    # make sure at least 1 hand is a float
+    left *= 1.0 if [left.class, right.class].include?(Fixnum)
+
+    value = ( left.send(op, right) ) rescue zero()
+    return checked(value)
+  end
+
+  module ClassMethods
+    # pass in a list off data-objects with and get a nice table
+    #   list = [ Object.data({ doors: 1, keys: 2}), Object.data({ doors: 1, keys: 3 }, ... ]
+    #
+    #   table = Object.as_table(list, keys: %w[doors keys])
+    #   # => [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 3, 8 ] ]
+    #
+    # Or use lists in lists
+    #   deep_list = [ list, list list ]
+    #   table = Object.as_table(deep_list, keys: %[doors keys], list_operator: delta)
+    #   # => [ [ 2, 6 ] ]  (differnece of mac and min for both doors and keys)
+    #
+    # @param [Array] list List (1d or 2d) of data objects
+    # @param [Hash] opts Options
+    # @option opts [Array] keys List of keys to fetch, may contain
+    #     calculations, eg: ['doors', 'keys', 'doors / keys']
+    # @option opts [Symbol] list_operator With a 2d list, what operator to
+    #      apply to each given list to determine the 1d value, any of
+    #      - :mean
+    #      - :stddev
+    #      - :median
+    #      - :range
+    #      - :mode
+    #      - :sum
+    #      - :min
+    #      - ;max
+    def as_table(list, opts = {})
+      keys = opts[:keys] || raise("Need keys")
+
+      table = []
+
+      list.each do |statistic|
+        iteration_keys = keys.dup
+
+        if statistic.is_a?(Array)
+          (iteration_keys, statistic) = flatten(statistic, opts)
+        end
+
+        row = []
+
+        iteration_keys.each do |key|
+          value = zero()
+
+          if key == :date
+            value = opts[:date_fmt] ?
+              statistic.created_at.strftime(opts[:date_fmt]) :
+              statistic.created_at.to_date
+
+          else
+            value = statistic.fetch(key)
+
+            if value.respond_to? :round
+              value = case opts[:round]
+                      when nil
+                        value
+                      when 0
+                        value.round rescue value
+                      else
+                        value.round(opts[:round])
+                      end
+            end
+
+            value = opts[:str_fmt] % value if opts[:str_fmt]
+
+            value = value.to_f if value.is_a?(BigDecimal)
+          end
+
+          row << checked(value)
+        end
+
+        if opts[:delta] && table.any?
+          new_row = []
+          row.each_with_index do |value, idx|
+            next unless value.kind_of?(Numeric)
+            new_row[idx] = checked(row[idx] - @prev[idx])
+          end
+
+          @prev = row.dup
+          row = new_row
+        else
+          @prev = row
+        end
+
+        table << row
+      end
+
+      return table
+    end
+
+    def flatten(array, opts)
+      keys = opts[:keys].dup
+
+      # this must be an interval period : find the mean, sum, max, whatever
+      opts[:list_operator] ||= :mean
+
+      collection = self.new( :data => {} )
+
+      keys.each_with_index do |key, idx|
+        if key == :date
+          collection.created_at = array.first.created_at
+          next
+        end
+
+        collection_key = key.to_s.gsub(/[\s*\/:x+-]+/, '_')
+        keys[idx] = collection_key if collection_key != key
+
+        array.each do |item|
+          collection.data[collection_key] ||= []
+          collection.data[collection_key] << (item.fetch(key) || 0)
+        end
+
+        # turn the collection into a single value
+        value = if opts[:list_operator] == :delta
+          collection.data[collection_key].max -
+          collection.data[collection_key].min
+
+        else
+           collection.data[collection_key].send(opts[:list_operator])
+
+        end
+
+        collection.data[collection_key] = value
+      end
+
+      collection
+      collection.readonly! if collection.respond_to?(:readonly!)
+
+      return [keys, collection]
+    end
+
+
+    def zero
+      BigDecimal.new("0.0")
+    end
+
+    def checked(value)
+      value = zero() if value.respond_to?(:nan?) && value.nan?
+      value = zero() if value.respond_to?(:infinity?) && value.infinity?
+      value = zero() if value.nil?
+      value = value.to_f if value.is_a? BigDecimal
+
+      value
+    end
+  end
+end

data/lib/crunchr/active_record.rb

@@ -0,0 +1,68 @@
+# = stuff for dealing with statistics
+#
+# monkey patches Hash, Array, ActiveRecord::Base and ActiveRecord::Relation
+#
+
+class Array
+  # return an array of arrays where each inner array represents a period of
+  # time
+  #
+  # == Synopsis
+  #   timed_interval(:week, 2)   # two week periods
+  #   timed_interval(:month, 6)  # half year periods
+  #   timed_interval(:day, 1)    # per day
+  #
+  # == Prerequisites
+  # The items in the list must respond_to interval_time and it must return
+  # something that responds to < or >
+  #
+  def timed_interval(length, amount=1)
+    list = self.sort_by(&:created_at)
+    current = list.first.interval_time(length)
+
+
+    records = []
+    period  = []
+
+    list.each do |record|
+      if record.interval_time(length) > (current + (amount - 1))
+        records << period
+        period = []
+        current = record.interval_time(length)
+      end
+
+      period << record
+    end
+
+    records
+  end
+end
+
+class ActiveRecord::Base
+  def interval_time(length)
+    self.created_at.strftime(interval_fmt(length)).to_i
+  end
+
+  def interval_fmt(length)
+    case length
+    when :hour
+      "%Y%j%H"
+    when :day
+      "%Y%j"
+    when :week
+      "%Y%W"
+    when :month
+      "%Y%m"
+    when :year
+      "%Y"
+    else
+      raise "Invalid interval length: #{length}"
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  def timed_interval(length, amount=1)
+    @records = self.to_a.timed_interval(length, amount)
+  end
+end

data/lib/crunchr/core_ext.rb

@@ -0,0 +1,57 @@
+# = stuff for dealing with statistics
+#
+# monkey patches Hash, Array, ActiveRecord::Base and ActiveRecord::Relation
+#
+
+class Hash
+  def delta(other)
+    return nil unless other.is_a?(Hash)
+
+    delta = {}
+
+    self.keys.each do |key|
+      next if !other.has_key? key
+      if self[key].is_a?(Hash)
+        delta[key] = self[key].delta(other[key])
+      else
+        delta[key] = (self[key] - other[key]) rescue nil
+      end
+    end
+
+    delta
+  end
+end
+
+class Array
+  def sum
+    self.inject(0.0) { |s, i| s += i }
+  end
+
+  def mean
+    (self.sum * 1.0) / self.count
+  end
+
+  def stddev
+    Math.sqrt(self.collect{ |i| (i - self.mean) ** 2 }.sum) / Math.sqrt(self.count - 1)
+  end
+
+  def median
+    center = (self.count + (self.count % 2)) / 2
+    list = self.sort
+
+    self.count % 2 == 0 ?
+     [ list[center - 1], list[center] ].mean :
+     list[center - 1]
+  end
+
+  def range
+    list = self.sort
+    list.last - list.first
+  end
+
+  def mode
+    counts = {}
+    self.collect { |i| counts[i] ||= 0; counts[i] += 1 }
+    counts.key(counts.values.sort.last)
+  end
+end

data/spec/crunchr_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class TestClass
+  attr_accessor :data
+  include Crunchr
+
+  def initialize(data={})
+    @data = data
+  end
+end
+
+deep_hash = {
+  users: { count: 14, active: 2},
+  loans: {
+    requested: { EUR: 781.284599, GBP: 0.65395, USD: 0.65395, AWG: 0.65395 },
+    payed: { EUR: 130.42, GBP: 145.23 }
+  },
+  orders: { count: 8, lines: 14 },
+  commission: {
+    approved: { EUR: 32.56 },
+    pending: { EUR: 0.8492, GBP: 1.3079, USD: 1.3079, AWG: 1.3079, JPY: 1.3079 }
+  },
+}
+
+def gen_table_list
+  list = []
+  prev_rabbit = rand(10)
+  3.times do
+    list << TestClass.new(
+      rabbits: prev_rabbit += rand(10), dogs: rand(20), cats: rand(40)
+    )
+  end
+  list
+end
+
+describe "Crunchr" do
+  subject {
+    TestClass.new
+  }
+
+  context "The basics" do
+    before(:each) do
+      subject.data = { doors: 10, keys: 8 }
+    end
+
+    it "fetches door" do
+      subject.fetch("doors").should == 10
+    end
+
+    it "calls calculate when a stmt is present" do
+      subject.expects(:calculate)
+      subject.fetch("keys - doors")
+    end
+
+    it "calculates the right value" do
+      subject.fetch("keys - doors").should == -2
+    end
+
+    it "returns nil for non existing" do
+      subject.fetch("n'existe pas").should be_nil
+    end
+
+    it "return nil for non-numeric/hash values" do
+      subject.data[:hash] = { :depth => 2 }
+      subject.data[:arrray] = [ 1, 2 ]
+
+      subject.fetch("hash").should == { :depth => 2 }
+      subject.fetch("array").should be_nil
+    end
+  end
+
+  context "Deep hashes" do
+    before(:each) do
+      subject.data = deep_hash
+    end
+
+    it "fetches deep keys" do
+      subject.fetch("loans/requested/GBP").should == 0.65395
+    end
+
+    it "calculates deep keys" do
+      subject.fetch("loans/requested/GBP + loans/payed/GBP").should == 0.65395 + 145.23
+    end
+  end
+
+  context "1d tables" do
+    before(:each) do
+      @list = gen_table_list
+    end
+
+    it "should make a nice table" do
+      expected = [
+        [ @list[0].data[:dogs], @list[0].data[:cats] ],
+        [ @list[1].data[:dogs], @list[1].data[:cats] ],
+        [ @list[2].data[:dogs], @list[2].data[:cats] ],
+      ]
+
+      TestClass.as_table(@list, keys: %w[dogs cats]).should == expected
+    end
+
+    it "should make a calculated table" do
+      expected = [
+        [ @list[0].data[:dogs], @list[0].data[:cats] - @list[0].data[:dogs] ],
+        [ @list[1].data[:dogs], @list[1].data[:cats] - @list[1].data[:dogs] ],
+        [ @list[2].data[:dogs], @list[2].data[:cats] - @list[2].data[:dogs] ],
+      ]
+
+      TestClass.as_table(@list, keys: ['dogs', 'cats - dogs']).should == expected
+    end
+
+    it "should make delta tables" do
+      expected = [
+        [ @list[0].data[:rabbits] ],
+        [ @list[1].data[:rabbits] - @list[0].data[:rabbits] ],
+        [ @list[2].data[:rabbits] - @list[1].data[:rabbits] ],
+      ]
+
+      TestClass.as_table(@list, keys: ['rabbits'], delta: true).should == expected
+    end
+  end
+
+  context "2d tables" do
+    before(:each) do
+      @list = []
+      3.times do
+        @list << gen_table_list
+      end
+    end
+
+    it "should flatten the list with the sum operator" do
+      res = TestClass.as_table(@list, keys: ['dogs - cats'], list_operator: :sum)
+      res.should == [
+        [ @list[0][0].data[:dogs] - @list[0][0].data[:cats] +
+          @list[0][1].data[:dogs] - @list[0][1].data[:cats] +
+          @list[0][2].data[:dogs] - @list[0][2].data[:cats]
+        ],
+        [ @list[1][0].data[:dogs] - @list[1][0].data[:cats] +
+          @list[1][1].data[:dogs] - @list[1][1].data[:cats] +
+          @list[1][2].data[:dogs] - @list[1][2].data[:cats]
+        ],
+        [ @list[2][0].data[:dogs] - @list[2][0].data[:cats] +
+          @list[2][1].data[:dogs] - @list[2][1].data[:cats] +
+          @list[2][2].data[:dogs] - @list[2][2].data[:cats]
+        ],
+      ]
+    end
+
+    it "should flatten the list with the mean operator" do
+      res = TestClass.as_table(@list, keys: ['dogs - cats'], list_operator: :mean)
+      res.should == [
+        [ ( @list[0][0].data[:dogs] - @list[0][0].data[:cats] +
+            @list[0][1].data[:dogs] - @list[0][1].data[:cats] +
+            @list[0][2].data[:dogs] - @list[0][2].data[:cats] ) / 3.0
+        ],
+        [ ( @list[1][0].data[:dogs] - @list[1][0].data[:cats] +
+            @list[1][1].data[:dogs] - @list[1][1].data[:cats] +
+            @list[1][2].data[:dogs] - @list[1][2].data[:cats] ) / 3.0
+        ],
+        [ ( @list[2][0].data[:dogs] - @list[2][0].data[:cats] +
+            @list[2][1].data[:dogs] - @list[2][1].data[:cats] +
+            @list[2][2].data[:dogs] - @list[2][2].data[:cats] ) / 3.0
+        ],
+      ]
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'crunchr'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.tty = true
+  config.mock_framework = :mocha
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: crunchr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Hartog C. de Mik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &16830960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: *16830960
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &12972500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12972500
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &12974440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *12974440
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &12969640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: *12969640
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &12977560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: *12977560
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &12997100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12997100
+description: Crunch statistics
+email: hartog@organisedminds.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- crunchr.gemspec
+- lib/crunchr.rb
+- lib/crunchr/active_record.rb
+- lib/crunchr/core_ext.rb
+- spec/crunchr_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/coffeeaddict/crunchr
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1841846266649628700
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Statistics crunching
+test_files: []