totalr 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in totalr.gemspec
+gemspec
+gem 'rspec'
+gem 'active_support'

data/README

@@ -0,0 +1,24 @@
+Totalr is a ruby library which gives a dsl that lets you do aggregations in your model declaratively.
+It is inspired by the statistical capabilities of R. Currently it does not even do 1 % of what R does.
+
+But it still lets you do aggregations like totaling, percentage, grouping in your model easily:
+
+class Team
+  total :players, using: :goals, by: :age
+end
+
+This creates a dynamic method total_player_goals_by_age which takes an age param.
+
+class Team
+  percentage :total_player_goals, of: :total_player_attempts, as: :goals_to_attempts
+end
+
+This creates a method which calculates percentage of goals:attempts for all players in the model.
+
+Totalr does not serve to replace any aggregation mechanism already provided by ORM or Enumerable.
+It only complements them by generating methods like this.
+
+You can give custom names to generated methods using :as key
+For documentation/features look at spec/totalr_spec.rb
+
+More features like mean, variance are still under development.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/totalr/version.rb

@@ -0,0 +1,3 @@
+module Totalr
+  VERSION = "0.0.1"
+end

data/lib/totalr.rb

@@ -0,0 +1,72 @@
+require 'active_support/inflector'
+
+module Totalr
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def total(coll_name, options = {})
+      attribute = options[:using]
+      group_by = options[:by]
+      method_name = options[:as]
+      method_name ||= "total_#{ActiveSupport::Inflector.singularize(coll_name.to_s)}_#{attribute}_for_#{group_by}" if attribute and group_by
+      method_name ||= "total_#{ActiveSupport::Inflector.singularize(coll_name.to_s)}_#{attribute}" if attribute
+      method_name ||= "total_#{coll_name}_for_#{group_by}" if group_by
+      method_name ||= "total_#{coll_name}"
+
+      method_body = if group_by
+                      if attribute
+                        lambda do |group_value|
+                          coll = send(coll_name)
+                          coll.select {|e| e.send(group_by) == group_value}.map {|e| e.send(attribute)}.inject(:+)
+                        end
+                      else
+                        lambda do |group_value|
+                          coll = send(coll_name)
+                          coll.select {|e| e.send(group_by) == group_value}.length
+                        end
+                      end
+
+                    else
+                      if attribute
+                        lambda do
+                          coll = send(coll_name)
+                          coll.map {|e| e.send(attribute)}.inject(:+)
+                        end
+                      else
+                        lambda do
+                          coll = send(coll_name)
+                          coll.length
+                        end
+                      end
+                    end
+      define_method method_name, method_body
+    end
+
+    def percentage(part_count_method, options = {})
+      total_count_method = options[:of]
+      part_by = options[:by]
+      total_by = options[:total_by]
+
+      method_name = options[:as]
+      method_name ||= "percentage_#{part_count_method}_in_#{total_by}" if total_by
+      method_name ||= "percentage_#{part_count_method}"
+
+      if total_by and total_by != part_by
+        define_method method_name do |part_by_value, total_by_value|
+          part_count = send(part_count_method, part_by_value)
+          total_count = total_by ? send(total_count_method, total_by_value) : send(total_count_method)
+          part_count * 100.00 / total_count
+        end
+
+      else
+        define_method method_name do |part_by_value|
+          part_count = send(part_count_method, part_by_value)
+          total_count = total_by ? send(total_count_method, part_by_value) : send(total_count_method)
+          part_count * 100.00 / total_count
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'totalr'

data/spec/totalr_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+
+describe Totalr do
+
+  class Team
+    include Totalr
+    attr_accessor :players
+
+    def initialize(params)
+      @name = params[:name]
+      @players = []
+    end
+  end
+
+  class Player
+    attr_reader :goals
+    attr_reader :attempts
+    attr_reader :age
+    attr_reader :region
+    def initialize(params)
+      @name = params[:name]
+      @goals = params[:goals]
+      @attempts = params[:attempts]
+      @age = params[:age]
+      @region = params[:region]
+    end
+
+  end
+
+  describe "total" do
+
+    class Team
+      total :players
+    end
+
+    it "should total collection" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo')
+      real_madrid.players << Player.new(name: 'Beckham')
+
+      real_madrid.total_players.should == 2
+    end
+
+    class Team
+      total :players, as: :player_count
+    end
+
+    it "should total collection with custom name" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo')
+      real_madrid.players << Player.new(name: 'Beckham')
+
+      real_madrid.player_count.should == 2
+    end
+
+    class Team
+      total :players, using: :goals
+    end
+
+    it "should total collection using attribute" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 25)
+      real_madrid.players << Player.new(name: 'Beckham', goals: 15)
+
+      real_madrid.total_player_goals.should == 40
+    end
+
+    class Team
+      total :players, using: :goals, as: :number_of_goals
+    end
+
+    it "should total collection using attribute with custom name" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 25)
+      real_madrid.players << Player.new(name: 'Beckham', goals: 15)
+
+      real_madrid.number_of_goals.should == 40
+    end
+
+    class Team
+      total :players, by: :age
+    end
+
+    it "should total collection grouping by attribute" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', age: 25)
+      real_madrid.players << Player.new(name: 'Figo', age: 30)
+
+      real_madrid.total_players_for_age(25).should == 2
+      real_madrid.total_players_for_age(30).should == 1
+    end
+
+    class Team
+      total :players, using: :goals, by: :age
+    end
+
+    it "should total collection mapping by attribute and grouping by attribute" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 25, age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', goals: 15, age: 25)
+      real_madrid.players << Player.new(name: 'Figo', goals: 10, age: 30)
+
+      real_madrid.total_player_goals_for_age(25).should == 40
+      real_madrid.total_player_goals_for_age(30).should == 10
+    end
+
+  end
+
+  describe "percentage" do
+    class Team
+      total :players
+      total :players, by: :age
+      percentage :total_players_for_age, by: :age, of: :total_players
+    end
+
+    it "should calculate percentage of total" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', age: 25)
+      real_madrid.players << Player.new(name: 'Figo', age: 30)
+
+      real_madrid.percentage_total_players_for_age(25).round(2).should == 66.67
+      real_madrid.percentage_total_players_for_age(30).round(2).should == 33.33
+    end
+
+    class Team
+      percentage :total_players_for_age, by: :age, of: :total_players, as: :distribution_by_age
+    end
+
+    it "should calculate percentage of total with custom name" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', age: 25)
+      real_madrid.players << Player.new(name: 'Figo', age: 30)
+
+      real_madrid.distribution_by_age(25).round(2).should == 66.67
+      real_madrid.distribution_by_age(30).round(2).should == 33.33
+    end
+
+    class Team
+      percentage :total_player_goals_for_age, by: :age, of: :total_player_goals, as: :percentage_goals_by_age
+    end
+
+    it "should calculate percentage of total using attribute" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 25, age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', goals: 15, age: 25)
+      real_madrid.players << Player.new(name: 'Figo', goals: 10, age: 30)
+
+      real_madrid.percentage_goals_by_age(25).should == 80.00
+      real_madrid.percentage_goals_by_age(30).should == 20.00
+    end
+
+    class Team
+      total :players, using: :goals, by: :region
+      percentage :total_player_goals_for_age, by: :age,
+                    of: :total_player_goals_for_region, total_by: :region
+    end
+
+    it "should calculate percentage totaling by attribute" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 25, age: 28, region: 'southamerica')
+      real_madrid.players << Player.new(name: 'Beckham', goals: 20, age: 25, region: 'europe')
+      real_madrid.players << Player.new(name: 'Carlos', goals: 10, age: 28, region: 'southamerica')
+      real_madrid.players << Player.new(name: 'Figo', goals: 12, age: 30, region: 'europe')
+      real_madrid.players << Player.new(name: 'Zidane', goals: 18, age: 30, region: 'europe')
+
+      real_madrid.percentage_total_player_goals_for_age_in_region(30, 'europe').should == 60.00
+      real_madrid.percentage_total_player_goals_for_age_in_region(25, 'europe').should == 40.00
+    end
+
+    class Team
+      total :players, using: :goals, by: :age
+      total :players, using: :attempts, by: :age
+      percentage :total_player_goals_for_age, by: :age,
+                    of: :total_player_attempts_for_age, total_by: :age,
+                    as: :goal_to_attempts
+
+    end
+
+    it "should calculate percentage totaling by same attribute as percentage" do
+      real_madrid = Team.new(name: 'Real Madrid')
+      real_madrid.players << Player.new(name: 'Ronaldo', goals: 21, attempts: 30, age: 25)
+      real_madrid.players << Player.new(name: 'Beckham', goals: 15, attempts: 20, age: 25)
+      real_madrid.players << Player.new(name: 'Figo', goals: 10, attempts: 15, age: 30)
+
+      real_madrid.goal_to_attempts(25).should == 72.00
+    end
+  end
+
+end

data/totalr.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "totalr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "totalr"
+  s.version     = Totalr::VERSION
+  s.authors     = ["Sathish"]
+  s.email       = ["sathish316@gmail.com"]
+  s.homepage    = "http://www.github.com/sathish316/totalr"
+  s.summary     = %q{Totalr is a lib which provides a simple dsl to do aggregation in models, like totals, percentage, grouping, mean, variance et
+c}
+  s.description = %q{Totalr is a lib which provides a simple dsl to do aggregation in models, like totals, percentage, grouping, mean, variance et
+c}
+  s.rubyforge_project = "totalr"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: totalr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sathish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-05 00:00:00.000000000Z
+dependencies: []
+description: ! 'Totalr is a lib which provides a simple dsl to do aggregation in models,
+  like totals, percentage, grouping, mean, variance et
+
+  c'
+email:
+- sathish316@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/totalr.rb
+- lib/totalr/version.rb
+- spec/spec_helper.rb
+- spec/totalr_spec.rb
+- totalr.gemspec
+homepage: http://www.github.com/sathish316/totalr
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: totalr
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Totalr is a lib which provides a simple dsl to do aggregation in models,
+  like totals, percentage, grouping, mean, variance et c
+test_files: []