aggrobot 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTYyNjYxMGE2OGY1MjU4ZWNmM2NiNmQwZDIwMWM2MjkzYjc4N2RmMw==
+    YjhjNWE3NWU3M2IxOWQxZWIxMjIwYTVjMmQ5Mjc5ZDFmYTRhZTI5Yg==
   data.tar.gz: !binary |-
-    YjBlM2MxNTRlNjk1OGY3YjMyMmVjMTM4YTU1YjRkM2RhNzE4ODFiZA==
+    OTc4YjYzNjlmMjdlMjIzNzY4MTcwZTA5YWUwNjk2MTkyMzM4M2Q5MQ==
 SHA512:
   metadata.gz: !binary |-
-    NDQ4ODhiYzNkODRjZDdjM2Y5NGRiZDMyNThkMTE1YzRjZTJjNzgxNTA3YWFk
-    M2M1Njk4NjJlMzA0NDBjNmE5NjI2MzNjNWVjZjFlYTYwYzgxYmJmM2MyMjE2
-    NzEwMTJiOTg2OGQ0NjExMjQyMGNmYzUzZGY1YjA2NDI5NWNlYjM=
+    ODk4NjY1NGJjZTIxMWZjMWZhODk4OTI4YTBhYmFiMzRjMDM1NjkzOTM4YTJi
+    OTdkYTA1MjEwNTBhODk2OGQwODU0NDIyNzA5YzI5OWQ3OTJlN2I4MWI4ZjMw
+    NzczYjY1OWRlYzY4ZDI5ZjE1MDcwMmZkZTdkYTYyMzAwYzgyNTE=
   data.tar.gz: !binary |-
-    MTA5NDYxMTMxZTNlZWNmMGUwZDAxZGMzYmUzOWYyMjEzZjhjMGRmNzQ0MzEw
-    ZjkwNTU0OTQ5MjQ0NGVmN2MzMzg1ZGFkNzNmM2Y5YTg5OGVjMzZiMzY2NDMw
-    Nzg2YzBkMTJjNThiZGE3MGM2YWMxNmRlZDVhYTBjNGE3NjRmYjI=
+    YTA2MjhlMzI0ZjU1YzY4NWRlYWE3Y2VhMjRiOGJlNzA5YjljMWJhYWM1MGY4
+    MjZmZTA0MjEwOGNkNmZiMDc4ZWJmMmIwOWNjNTZkMjQ5MTgxYTFkMWRmZTcx
+    NjZjNDA1YzcxODgzYTRkZmY2N2VkZjU4OGJlMDI3YTU3YWI4ZTM=

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+
+env:
+  - "RAILS_VERSION=4.0"
+  - "RAILS_VERSION=3.2"
+  - "RAILS_VERSION=3.1"
+  - "RAILS_VERSION=3.0"
+
+script: bundle exec rspec

data/Gemfile

@@ -2,3 +2,9 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in aggrobot.gemspec
 gemspec
+
+group :test do
+  gem 'guard-rspec', require: false
+  gem 'growl', require: false
+  gem 'simplecov', require: false
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/Rakefile

@@ -1 +1,69 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+# Add default task. When you type just rake command this would run. Travis CI runs this. Making this run spec
+desc 'Default: run specs.'
+task :default => [:spec]
+
+desc 'Spec: Runs both unit and integration tests'
+task :spec => ['spec:unit', 'spec:integration']
+
+namespace :spec do
+
+  desc 'Run unit specs'
+  RSpec::Core::RakeTask.new('unit') do |spec|
+    spec.pattern = FileList['spec/unit/**/*_spec.rb']
+  end
+
+  desc 'Run integration specs'
+  RSpec::Core::RakeTask.new('integration') do |spec|
+    spec.pattern = 'spec/integration/**/*_spec.rb'
+  end
+
+end
+
+# Run the rdoc task to generate rdocs for this gem
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  require 'aggrobot/version'
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "aggrobot #{Aggrobot::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Spec: Runs both unit and integration tests'
+task :coverage => ['coverage:pre', 'coverage:unit', 'coverage:integration']
+namespace :coverage do
+  task :pre do
+    require 'fileutils'
+    coverage_folder = File.expand_path('../coverage', __FILE__)
+    FileUtils.mkdir_p coverage_folder
+
+    coverage_html = <<-HTML
+      <html><body>
+        <ul style="list-style:none">
+          <li>Aggrobot - Code Coverage</li>
+          <li><a href="integration/index.html">Integration Tests</a></li>
+          <li><a href="unit/index.html">Unit Tests</a></li>
+        </ul>
+      </body></html>
+    HTML
+    File.open(File.join(coverage_folder, 'index.html'), 'w') { |f| f << coverage_html }
+  end
+
+
+  # Ruby 1.9+ using simplecov
+  desc "Code coverage unit"
+  task :unit do
+    ENV['COVERAGE'] = "unit"
+    Rake::Task['spec:unit'].execute
+  end
+
+  desc "Code coverage integration"
+  task :integration do
+    ENV['COVERAGE'] = "integration"
+    Rake::Task['spec:integration'].execute
+  end
+
+end

data/aggrobot.gemspec

@@ -4,20 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'aggrobot/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "aggrobot"
+  spec.name          = 'aggrobot'
   spec.version       = Aggrobot::VERSION
-  spec.authors       = ["Shadab Ahmed"]
-  spec.email         = ["shadab.ansari@gmail.com"]
+  spec.authors       = ['Shadab Ahmed']
+  spec.email         = ['shadab.ansari@gmail.com']
   spec.description   = %q{Easy and performant aggregation for rails}
   spec.summary       = %q{Rails aggregation library}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.homepage      = ''
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency 'rails', '~> 4.0'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency('rspec', ['~> 2.14.1'])
+  spec.add_development_dependency('rdoc')
 end

data/lib/aggrobot.rb

@@ -1,5 +1,36 @@
-require "aggrobot/version"
+require 'aggrobot/railtie'
+require 'active_support/core_ext/module/delegation.rb'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'aggrobot/version'
+require 'aggrobot/aggrobot_error'
+require 'aggrobot/helper'
+require 'aggrobot/sql_functions'
+require 'aggrobot/query_planner'
+require 'aggrobot/aggregator'
+require 'aggrobot/aggrobot'
+
 
 module Aggrobot
-  # Your code goes here...
-end
+
+  DEFAULT_GROUP_BY = SqlFunctions.sanitize('aggrobot_default_group')
+
+  def self.start(collection = nil, block_arg = nil, block_opts = nil, &block)
+    block_opts ||= block_arg if block
+    block = block_arg if block_arg && block_arg.respond_to?(:call)
+    raise 'Block parameter required' unless block
+    original_block_context = eval "self", block.binding
+    attrs = if block.arity > 0
+              block_opts.is_a?(Hash) ? block_opts : {count: collection.count}
+            end
+    Aggrobot.new(original_block_context, collection).instance_exec(attrs, &block)
+  end
+
+  def self.block(&block)
+    block
+  end
+
+  def self.setup(app)
+    SqlFunctions.const_set(:ROUNDING_DIGITS, app.config.aggrobot.percent_precision || 2)
+  end
+
+end

data/lib/aggrobot/aggregator.rb

@@ -0,0 +1,93 @@
+module Aggrobot
+  class Aggregator
+
+    include Helper
+
+    def initialize(collection)
+      @collection = collection
+      @group_name_attribute, @count_attribute = :name, :count
+      @group_labels_map = {}
+      @attribute_mapping = {}
+      self.collection(collection) if collection
+    end
+
+
+    def group_labels(map = nil, &block)
+      if map || block
+        if map.is_a?(Hash)
+          @group_labels_map = ActiveSupport::HashWithIndifferentAccess.new(map)
+        elsif map.respond_to?(:call) || block
+          @group_labels_map = block || map
+        end
+      else
+        @group_labels_map
+      end
+    end
+
+    def collection(values = nil)
+      if values
+        raise_error 'Collection should be an ActiveRecord::Relation or ActiveRecord::Base' unless
+            [ActiveRecord::Relation, ActiveRecord::Base].any?{|m| values.is_a?(m) }
+        @collection = values
+      else
+        @collection
+      end
+    end
+
+    def group_by(group, opts = nil)
+      raise_error "Group_by takes only symbol or a string as argument" unless group.is_a?(Symbol) or group.is_a?(String)
+      @query_planner = QueryPlanner.create(@collection, group, opts)
+    end
+
+    def override(attr, override_attr = false)
+      case attr
+        when :name
+          @group_name_attribute = override_attr
+        when :count
+          @count_attribute = override_attr
+        when Hash
+          attr.each { |k, v| override(k, v) }
+      end
+    end
+
+    def set(name = nil, opts)
+      if opts.is_a? Hash
+        @attribute_mapping.merge!(opts)
+      elsif name && opts
+        @attribute_mapping[name] = opts
+      end
+    end
+
+    def query_planner
+      @query_planner ||= QueryPlanner.create(@collection, DEFAULT_GROUP_BY)
+    end
+
+    def yield_results
+      # yield on actual query results
+      query_planner.query_results(extra_columns).each do |real_group_name, count, *rest|
+        mapped_group_name = @group_labels_map[real_group_name] || real_group_name
+        relation = @query_planner.sub_query(real_group_name)
+        yield(mapped_attributes(mapped_group_name, count, rest), mapped_group_name, relation)
+      end
+    end
+
+    private
+
+    def extra_columns
+      @attribute_mapping.values
+    end
+
+    def extra_attributes
+      @attribute_mapping.keys
+    end
+
+    def mapped_attributes(group_name, count, result_row)
+      ActiveSupport::HashWithIndifferentAccess.new.tap do |attributes|
+        attributes.merge!(Hash[extra_attributes.zip(result_row)]) unless result_row.empty?
+        attributes[@count_attribute] = count if @count_attribute
+        attributes[@group_name_attribute] = group_name if @group_name_attribute
+      end
+    end
+
+  end
+end

data/lib/aggrobot/aggrobot.rb

@@ -0,0 +1,115 @@
+module Aggrobot
+  class Aggrobot
+
+    include SqlFunctions
+    include Helper
+
+    delegate :collection, :group_by, :default_groups, :override, :set, :group_labels, :to => :@aggregator
+
+    def run(block)
+      instance_eval(&block)
+    end
+
+    def initialize(caller_context, collection = nil)
+      @caller_context = caller_context
+      @aggregator = Aggregator.new(collection)
+    end
+
+    def method_missing(method, *args, &block)
+      @caller_context.send method, *args, &block
+    end
+
+    def hash(collection = nil, opts = {}, &block)
+      self.collection(collection) if collection
+      @top_level_object = ActiveSupport::HashWithIndifferentAccess.new
+      proceed(block, opts)
+    end
+
+    def list(collection = nil, opts = {}, &block)
+      self.collection(collection) if collection
+      @top_level_object = []
+      proceed(block, opts)
+    end
+
+    def default(default_val = nil, &block)
+      block = block_from_args(default_val, block, false)
+      default_val = ::Aggrobot.start(collection, &block) if block
+      @top_level_object = default_val
+    end
+
+    alias set_current_value default
+
+    def default_group_attrs(opts = nil)
+      if opts
+        raise_error 'Arguments must be  a hash' unless opts.is_a?(Hash)
+        @default_group_attrs = ActiveSupport::HashWithIndifferentAccess.new(opts)
+      else
+        @default_group_attrs
+      end
+    end
+
+    def current_value
+      @top_level_object
+    end
+
+    def attr(attribute, value = nil, &block)
+      block = block_from_args(value, block, false)
+      raise_error 'attr can only be used with a hash type' unless @top_level_object.is_a?(Hash)
+      raise_error 'attribute should be a symbol or a string' unless attribute.is_a?(Symbol) || attribute.is_a?(String)
+      raise_error 'attr should receive a block or a value' if value.nil? && block.nil?
+      value = ::Aggrobot.start(collection, &block) if block
+      @top_level_object[attribute] = value
+    end
+
+    def get_attr(attribute)
+      @top_level_object[attribute]
+    end
+
+    def collect_each_group_attributes
+      each_group do |attr|
+        attr
+      end
+    end
+
+    def each_group(block_arg = nil, &block)
+      block = block_from_args(block_arg, block)
+      @aggregator.yield_results do |attrs, group_name, sub_collection|
+        attrs = @default_group_attrs.merge(attrs) if @default_group_attrs
+        block_value = ::Aggrobot.start(sub_collection) do
+          instance_exec(attrs, &block)
+        end
+        update_top_level_obj(group_name, block_value)
+      end
+    end
+
+    def evaluate(block_arg = nil, &block)
+      block = block_from_args(block_arg, block)
+      list(&block).first
+    end
+
+    private
+
+    def evaluate_opts(opts)
+      opts.each do |method_name, arg|
+        send(method_name, arg)
+      end
+    end
+
+    def update_top_level_obj(group, val)
+      if @top_level_object.is_a? Hash
+        @top_level_object[group] = val
+      elsif @top_level_object.is_a? Array
+        @top_level_object << val
+      end
+    end
+
+    def proceed(block, opts)
+      raise_error "no block given for api" unless block
+      evaluate_opts(opts)
+      instance_eval(&block)
+      @top_level_object
+    end
+
+  end
+end
+

data/lib/aggrobot/aggrobot_error.rb

@@ -0,0 +1,6 @@
+module Aggrobot
+  class AggrobotError < StandardError
+  end
+end
+
+

data/lib/aggrobot/helper.rb

@@ -0,0 +1,14 @@
+module Aggrobot
+  module Helper
+
+    def block_from_args(block_arg, block, required = true)
+      block = block_arg if block_arg && block_arg.respond_to?(:call)
+      raise ArgumentError.new 'Block parameter required' if required && !block
+      block
+    end
+
+    def raise_error(msg)
+      raise AggrobotError.new(msg)
+    end
+  end
+end

data/lib/aggrobot/query_planner.rb

@@ -0,0 +1,36 @@
+require 'aggrobot/query_planner/default_query_planner'
+require 'aggrobot/query_planner/group_limit_query_planner'
+require 'aggrobot/query_planner/bucketed_groups_query_planner'
+
+module Aggrobot::QueryPlanner
+
+  def self.create(collection, group_by, opts = nil)
+    case
+    when opts.nil?
+      DefaultQueryPlanner.new(collection, group_by)
+    when opts.key?(:limit_to)
+      GroupLimitQueryPlanner.new(collection, group_by, opts)
+    when opts.key?(:buckets)
+      BucketedGroupsQueryPlanner.new(collection, group_by, opts)
+    end
+  end
+
+  module ParametersValidator
+    def self.validate_options(opts, required_parameters, optional_parameters)
+      params = opts.keys
+      # raise errors for required parameters
+      raise_argument_error(opts, required_parameters, optional_parameters) unless (required_parameters - params).empty?
+      # raise errors if any extra arguments given
+      raise_argument_error(opts, required_parameters, optional_parameters) unless (params - required_parameters - optional_parameters).empty?
+    end
+
+    def self.raise_argument_error(opts, required_parameters, optional_parameters)
+      raise ArgumentError, <<-ERR
+          Wrong arguments given - #{opts}
+          Required parameters are #{required_parameters}
+          Optional parameters are #{optional_parameters}
+      ERR
+    end
+  end
+
+end

data/lib/aggrobot/query_planner/bucketed_groups_query_planner.rb

@@ -0,0 +1,50 @@
+module Aggrobot
+  module QueryPlanner
+    class BucketedGroupsQueryPlanner < DefaultQueryPlanner
+
+      def initialize(collection, group, opts = {})
+        ParametersValidator.validate_options(opts, [:buckets], [:keep_empty])
+        raise_error 'Need to set group first' unless group
+        super(collection, group)
+        create_query_map(opts[:buckets])
+        @keep_empty = opts[:keep_empty]
+      end
+
+      def sub_query(group_name)
+        @query_map[group_name]
+      end
+
+      def query_results(extra_cols = [])
+        return empty_default_groups if collection_is_none?
+        results = collect_query_results(extra_cols)
+        results.reject! { |r| r[1] == 0 } unless @keep_empty
+        results
+      end
+
+      private
+
+      def collect_query_results(extra_cols)
+        columns = ['', SqlFunctions.count] + extra_cols
+        @query_map.collect do |group_name, query|
+          sanitized_group_name = SqlFunctions.sanitize(group_name)
+          columns[0] = sanitized_group_name
+          results = query.group(sanitized_group_name).limit(1).pluck(*columns).first
+          @query_map[group_name] = @query_map[group_name].none unless results
+          results || [group_name, 0]
+        end
+      end
+
+      def empty_default_groups
+        @keep_empty ? @query_map.keys.collect { |k| [k, 0] } : []
+      end
+
+      def create_query_map(groups)
+        @query_map = {}
+        groups.each do |group|
+          @query_map[group.to_s] = @collection.where(@group => group)
+        end
+      end
+
+    end
+  end
+end

data/lib/aggrobot/query_planner/default_query_planner.rb

@@ -0,0 +1,31 @@
+module Aggrobot
+  module QueryPlanner
+    class DefaultQueryPlanner
+      include Aggrobot::Helper
+
+      def initialize(collection, group)
+        @collection, @group = collection, group
+      end
+
+      def sub_query(group_name)
+        @group == DEFAULT_GROUP_BY ? @collection : @collection.where(@group => group_name)
+      end
+
+      def query_results(extra_cols = [])
+        return [] if collection_is_none?
+        columns = [@group, SqlFunctions.count] + extra_cols
+        results_query.pluck(*columns)
+      end
+
+      protected
+      def results_query
+        @result_query ||= @collection.group(@group)
+      end
+
+      def collection_is_none?
+        @collection.extending_values.include?(ActiveRecord::NullRelation)
+      end
+
+    end
+  end
+end

data/lib/aggrobot/query_planner/group_limit_query_planner.rb

@@ -0,0 +1,56 @@
+module Aggrobot
+  module QueryPlanner
+    class GroupLimitQueryPlanner < DefaultQueryPlanner
+
+      def initialize(collection, group, opts)
+        ParametersValidator.validate_options(opts, [:limit_to, :sort_by], [:always_include, :other_group, :order])
+        raise_error 'limit_to has to be a number' unless opts[:limit_to].is_a?(Fixnum)
+        super(collection, group)
+        @query_map = {}
+        process_top_groups_options(opts)
+      end
+
+      def sub_query(group_name)
+        group_name == @other_group ? @collection.where.not(@top_groups_conditions) : @collection.where(@group => group_name)
+      end
+
+      def query_results(extra_cols = [])
+        return [] if collection_is_none?
+        columns = [@group, SqlFunctions.count] + extra_cols
+        top_group_results = results_query.where(@top_groups_conditions).pluck(*columns)
+        top_group_results + other_group_results(columns)
+      end
+
+      protected
+
+      def other_group_results(columns)
+        if @other_group
+          columns[0] = SqlFunctions.sanitize(@other_group)
+          @collection.where.not(@top_groups_conditions).group(columns[0]).pluck(*columns)
+        else
+          []
+        end
+      end
+
+      def results_query
+        @results_query ||= @collection.group(@group)
+      end
+
+      def calculate_top_groups(opts)
+        @collection.group(@group).order("#{opts[:sort_by]} #{opts[:order]}").limit(opts[:limit_to]).pluck(@group).flatten
+      end
+
+      def process_top_groups_options(opts)
+        opts[:order] ||= 'desc'
+        top_groups = calculate_top_groups(opts)
+        if opts[:always_include] && !top_groups.include?(opts[:always_include])
+          top_groups.pop
+          top_groups << opts[:always_include]
+        end
+        @top_groups_conditions = {@group => top_groups}
+        @other_group = opts[:other_group]
+      end
+
+    end
+  end
+end

data/lib/aggrobot/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails/railtie'
+
+module LogStasher
+  class Railtie < Rails::Railtie
+    config.aggrobot = ActiveSupport::OrderedOptions.new
+
+    initializer :aggrobot do |app|
+      Aggrobot.setup(app)
+    end
+  end
+end

data/lib/aggrobot/sql_functions.rb

@@ -0,0 +1,55 @@
+module Aggrobot
+  module SqlFunctions
+
+    extend self
+
+    def sanitize(attr)
+      "'#{attr}'"
+    end
+
+    def desc(attr)
+      "#{attr} desc"
+    end
+
+    def count(attr = '*')
+      "COUNT(#{attr})"
+    end
+
+    def unique_count(attr = '*')
+      "COUNT(DISTINCT #{attr})"
+    end
+
+    def max(attr)
+      "MAX(#{attr})"
+    end
+
+    def min(attr)
+      "MIN(#{attr})"
+    end
+
+    def sum(attr = count)
+      "SUM(#{attr})"
+    end
+
+    def avg(attr, rounding = ROUNDING_DIGITS)
+      "ROUND(AVG(#{attr}), #{rounding})"
+    end
+
+    def group_collect(attr)
+      "GROUP_CONCAT(DISTINCT #{attr})"
+    end
+
+    def percent(total, attr = count, rounding = ROUNDING_DIGITS)
+      total == 0 ? "0" : "ROUND((#{attr}*100.0)/#{total}, #{rounding})"
+    end
+
+    def multiply(attr, multiplier, rounding = ROUNDING_DIGITS)
+      "ROUND(#{attr}*#{multiplier}, #{rounding})"
+    end
+
+    def divide(attr, divider, rounding = ROUNDING_DIGITS)
+      "ROUND(#{attr}/#{divider}, #{rounding})"
+    end
+
+  end
+end

data/lib/aggrobot/version.rb

@@ -1,3 +1,3 @@
 module Aggrobot
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+# Notice there is a .rspec file in the root folder. It defines rspec arguments
+
+# Ruby 1.9 uses simplecov. The ENV['COVERAGE'] is set when rake coverage is run in ruby 1.9
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    # Remove the spec folder from coverage. By default all code files are included. For more config options see
+    # https://github.com/colszowka/simplecov
+    add_filter File.expand_path('../../spec/', __FILE__)
+    coverage_dir(ENV['COVERAGE'] == 'integration' ? 'coverage/integration' :'coverage/unit')
+
+  end
+end
+
+# Modify load path so you can require 'mckinsey_external_ad' directly.
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+# Loads bundler setup tasks. Now if I run spec without installing gems then it would say gem not installed and
+# do bundle install instead of ugly load error on require.
+require 'bundler/setup'
+
+# This will require me all the gems automatically for the groups.
+Bundler.require(:default, :test)
+
+require 'aggrobot'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
+
+# Set Rails environment as test
+ENV['RAILS_ENV'] = 'test'
+
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+

data/spec/support/chain_query.rb

@@ -0,0 +1,20 @@
+def add_expectations(obj, method, params)
+  if params.is_a?(Array)
+    obj.should_receive(method).with(*params)
+  elsif params.nil?
+    obj.should_receive(method)
+  else
+    obj.should_receive(method).with(params)
+  end
+end
+
+def should_receive_queries(obj, method_chain)
+  method_chain.each_with_index do |(method, params), idx|
+    if (idx + 1) == method_chain.size
+      return add_expectations(obj, method, params)
+    else
+      proxy = add_expectations(obj, method, params)
+      proxy.and_return(obj)
+    end
+  end
+end

data/spec/unit/aggrobot/query_planners/bucketed_groups_query_planner_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module Aggrobot
+  module QueryPlanner
+
+    describe BucketedGroupsQueryPlanner do
+
+      let(:collection) { double }
+      let(:group) { 'group_col' }
+      let(:buckets) { [1..2, [3, 4, 5], 8, 9] }
+      subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: buckets) }
+
+      describe '#sub_query' do
+        before do
+          collection.stub(:where).with('group_col' => 1..2).and_return('collection for 1..2')
+          collection.stub(:where).with('group_col' => [3,4,5]).and_return('collection for 3,4,5')
+          collection.stub(:where).with('group_col' => 8).and_return('collection for 8')
+          collection.stub(:where).with('group_col' => 9).and_return('collection for 9')
+        end
+
+        it 'returns the correct subquery' do
+          expect(query_planner.sub_query((1..2).to_s)).to eq 'collection for 1..2'
+          expect(query_planner.sub_query([3,4,5].to_s)).to eq 'collection for 3,4,5'
+          expect(query_planner.sub_query(8.to_s)).to eq 'collection for 8'
+          expect(query_planner.sub_query(9.to_s)).to eq 'collection for 9'
+        end
+      end
+
+      describe '#query_results' do
+        let(:bucketed_relation) { double }
+        before do
+          collection.stub(:where).and_return(bucketed_relation)
+        end
+
+        context 'collection is none' do
+          before do
+            query_planner.stub(:collection_is_none? => true, :empty_default_groups => [])
+          end
+          it 'returns empty result set' do
+            expect(query_planner.query_results).to be_empty
+          end
+        end
+
+        context 'collection is not none' do
+          before do
+            query_planner.stub(:collection_is_none? => false)
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize((1..2).to_s), limit: 1,
+                pluck: [SqlFunctions.sanitize((1..2).to_s), SqlFunctions.count, :col1, :col2])
+                .and_return(['results for 1..2'])
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize([3,4,5].to_s), limit: 1,
+                                   pluck: [SqlFunctions.sanitize([3,4,5].to_s), SqlFunctions.count, :col1, :col2])
+            .and_return(['results for 3,4,5'])
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(8.to_s), limit: 1,
+                                   pluck: [SqlFunctions.sanitize(8.to_s), SqlFunctions.count, :col1, :col2])
+            .and_return(['results for 8'])
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(9.to_s), limit: 1,
+                                   pluck: [SqlFunctions.sanitize(9.to_s), SqlFunctions.count, :col1, :col2])
+            .and_return(['results for 9'])
+          end
+          it 'returns empty result set' do
+            expect(query_planner.query_results([:col1, :col2])).to eq ["results for 1..2", "results for 3,4,5",
+                                                                       "results for 8", "results for 9"]
+          end
+        end
+
+        context 'empty buckets' do
+          before do
+            query_planner.stub(:collection_is_none? => false)
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(:populated.to_s), limit: 1,
+                                   pluck: [SqlFunctions.sanitize(:populated.to_s), SqlFunctions.count, :col1, :col2])
+            .and_return(['results for populated group'])
+
+            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(:empty.to_s), limit: 1,
+                                   pluck: [SqlFunctions.sanitize(:empty.to_s), SqlFunctions.count, :col1, :col2])
+            .and_return([])
+            bucketed_relation.stub(:none)
+          end
+          context 'without keep_empty option' do
+            subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: [:populated, :empty]) }
+            it 'returns only populated result set' do
+              expect(query_planner.query_results([:col1, :col2])).to eq ["results for populated group"]
+            end
+          end
+
+          context 'with keep_empty option' do
+            subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: [:populated, :empty], keep_empty: true) }
+            it 'returns both empty and populated result sets' do
+              expect(query_planner.query_results([:col1, :col2])).to eq ["results for populated group", ["empty", 0]]
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/aggrobot/query_planners/default_query_planner_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Aggrobot
+  module QueryPlanner
+
+    describe DefaultQueryPlanner do
+      let(:collection) { double }
+      let(:group) { 'group_col' }
+      subject(:query_planner) { DefaultQueryPlanner.new(collection, group) }
+
+      describe '#sub_query' do
+        context 'when group was specified' do
+          before do
+            collection.should_receive(:where).with('group_col' => 'group').and_return('collection')
+          end
+          it 'returns the correct subquery' do
+            expect(query_planner.sub_query('group')).to eq 'collection'
+          end
+        end
+
+        context 'when default group' do
+          let(:query_planner) { DefaultQueryPlanner.new(collection, DEFAULT_GROUP_BY) }
+          it 'returns the correct subquery' do
+            expect(query_planner.sub_query('group')).to eq collection
+          end
+        end
+      end
+
+      describe '#query_results' do
+        context 'collection is none' do
+          before { query_planner.stub(:collection_is_none? => true) }
+          it { expect(query_planner.query_results).to be_empty }
+        end
+
+        context 'collection is not none' do
+          let(:grouped_relation) { double }
+          before do
+            query_planner.stub(:collection_is_none? => false)
+
+            collection.should_receive(:group).with('group_col').and_return(grouped_relation)
+            grouped_relation.should_receive(:pluck)
+            .with('group_col', SqlFunctions.count, 'extra_col1', 'extra_col2')
+            .and_return(:results)
+          end
+          it 'returns results for columns' do
+            expect(query_planner.query_results(['extra_col1', 'extra_col2'])).to eq :results
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/aggrobot/query_planners/group_limit_query_planner_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+module Aggrobot
+  module QueryPlanner
+    describe GroupLimitQueryPlanner do
+      let(:collection) { double }
+      let(:group) { 'group_col' }
+
+      context 'initialization' do
+        before do
+          GroupLimitQueryPlanner.any_instance.stub(:process_top_groups_options)
+        end
+        it 'requires explicit parameters' do
+          expect { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2) }.to raise_error
+          expect { GroupLimitQueryPlanner.new(collection, group, :sort_by => 2) }.to raise_error
+          expect { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2, :sort_by => 2) }.to_not raise_error
+        end
+      end
+
+      describe '#sub_query' do
+
+        context 'with only default options' do
+          before do
+            should_receive_queries(collection, :group => group, :order => 'order_col desc',
+                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
+          end
+          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
+                                                               :sort_by => :order_col, :other_group => 'others') }
+          context 'for one of the top groups' do
+            it 'gives query with only that group in condition' do
+              should_receive_queries(collection, :where => {'group_col' => 'group1'}).and_return(:sub_query1)
+              expect(query_planner.sub_query('group1')).to eq :sub_query1
+            end
+          end
+
+          context 'for others group' do
+            it 'gives query with only that group in condition' do
+              should_receive_queries(collection, :where => nil, not: {'group_col' => ['group1', 'group2']}).and_return(:sub_query_other)
+              expect(query_planner.sub_query('others')).to eq :sub_query_other
+            end
+          end
+        end
+
+        context 'with always include option' do
+          before do
+            should_receive_queries(collection, :group => group, :order => 'order_col desc',
+                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
+          end
+          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
+                                                               :sort_by => :order_col, :other_group => 'others', :always_include => 'always') }
+          context 'for one of the top groups' do
+            it 'gives query with only that group in condition' do
+              should_receive_queries(collection, :where => {'group_col' => 'always'}).and_return(:sub_query_always)
+              expect(query_planner.sub_query('always')).to eq :sub_query_always
+            end
+          end
+        end
+
+      end
+
+      describe '#query_results' do
+        let(:columns) { ['group_col', 'COUNT(*)', 'col1', 'col2'] }
+        let(:other_columns) { ["'others'", 'COUNT(*)', 'col1', 'col2'] }
+        subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
+                                                             :sort_by => :order_col, :other_group => 'others') }
+
+
+        context 'when collection is none' do
+          before do
+            should_receive_queries(collection, :group => group, :order => 'order_col desc',
+                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
+            query_planner.stub(:collection_is_none? => true)
+          end
+          it 'returns empty result' do
+            expect(query_planner.query_results).to be_empty
+          end
+        end
+
+        context 'with reverse sort order' do
+          let(:conditions) { {'group_col' => ['group2', 'group1']} }
+          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2, :order => 'asc',
+                                                               :sort_by => :order_col, :other_group => 'others') }
+          before do
+            should_receive_queries(collection, :group => group, :order => 'order_col asc',
+                                   :limit => 2, :pluck => group).and_return(['group2', 'group1'])
+            should_receive_queries(collection, :where => conditions,
+                                   :group => group, :pluck => columns).and_return([:group2_results, :group1_results])
+            should_receive_queries(collection, :where => nil, :not => conditions,
+                                   :group => "'others'", :pluck => other_columns).and_return([:others])
+            query_planner.stub(:collection_is_none? => false)
+          end
+
+          it 'returns results for reverse order' do
+            expect(query_planner.query_results(['col1', 'col2'])).to eq [:group2_results, :group1_results, :others]
+          end
+        end
+
+        context 'when collection is not none and default sort order' do
+          let(:conditions) { {'group_col' => ['group1', 'group2']} }
+
+          before do
+            should_receive_queries(collection, :group => group, :order => 'order_col desc',
+                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
+            query_planner.stub(:collection_is_none? => false)
+          end
+
+          context 'with default options' do
+            it 'returns top group results' do
+              should_receive_queries(collection, :group => group, :where => conditions, :pluck => columns).and_return([:group1_results, :group2_results])
+              should_receive_queries(collection, :where => nil, :not => conditions,
+                                     :group => "'others'", :pluck => other_columns).and_return([:others])
+              expect(query_planner.query_results(['col1', 'col2'])).to eq [:group1_results, :group2_results, :others]
+            end
+          end
+
+
+          context 'with always_include option added' do
+            subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
+                                                                 :sort_by => :order_col, :always_include => 'always', :other_group => 'others') }
+            let(:conditions) { {'group_col' => ['group1', 'always']} }
+            before do
+              query_planner.stub(:collection_is_none? => false)
+            end
+            it 'returns top group results inlcuding the always_include group' do
+              should_receive_queries(collection, :group => group, :where => conditions, :pluck => columns).and_return([:group1_results, :group2_results])
+              should_receive_queries(collection, :where => nil, :not => conditions,
+                                     :group => "'others'", :pluck => other_columns).and_return([:others])
+              expect(query_planner.query_results(['col1', 'col2'])).to eq [:group1_results, :group2_results, :others]
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/unit/aggrobot/sql_functions_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'aggrobot/sql_functions'
+
+module Aggrobot
+
+  describe SqlFunctions do
+    before do
+      module SqlFunctions
+        ROUNDING_DIGITS = 2
+      end
+    end
+
+    describe '.sql_attr' do
+      it 'returns an escaped sql attribute' do
+        expect(SqlFunctions.desc('attr')).to eq 'attr desc'
+      end
+    end
+
+    describe '.count' do
+      it 'get SQL Sum' do
+        expect(SqlFunctions.count('attr')).to eq 'COUNT(attr)'
+      end
+    end
+
+    describe '.unique_count' do
+      it 'gets distinct COUNT' do
+        expect(SqlFunctions.unique_count('attr')).to eq 'COUNT(DISTINCT attr)'
+      end
+    end
+
+    describe '.max' do
+      it 'gets max' do
+        expect(SqlFunctions.max('attr')).to eq 'MAX(attr)'
+      end
+    end
+
+    describe '.max' do
+      it 'gets min' do
+        expect(SqlFunctions.min('attr')).to eq 'MIN(attr)'
+      end
+    end
+
+    describe '.sum' do
+      it 'gets sum' do
+        expect(SqlFunctions.sum('attr')).to eq 'SUM(attr)'
+      end
+    end
+
+    describe '.avg' do
+      it 'gets avg' do
+        expect(SqlFunctions.avg('attr')).to eq "ROUND(AVG(attr), #{SqlFunctions::ROUNDING_DIGITS})"
+      end
+    end
+
+    describe '.group_collect' do
+      it 'does group concat' do
+        expect(SqlFunctions.group_collect('attr')).to eq 'GROUP_CONCAT(DISTINCT attr)'
+      end
+    end
+
+    describe '.percent' do
+      it 'calculate percent' do
+        expect(SqlFunctions.percent('attr', 100)).to eq "ROUND((100*100.0)/attr, #{SqlFunctions::ROUNDING_DIGITS})"
+      end
+
+      it 'calculate percent with default params' do
+        expect(SqlFunctions.percent('attr')).to eq "ROUND((COUNT(*)*100.0)/attr, #{SqlFunctions::ROUNDING_DIGITS})"
+      end
+    end
+
+    describe '.mysql' do
+      it 'multiplies' do
+        expect(SqlFunctions.multiply('attr', 100, 2)).to eq 'ROUND(attr*100, 2)'
+      end
+    end
+
+    describe '.divide' do
+      it 'divides' do
+        expect(SqlFunctions.divide('attr', 100, 2)).to eq 'ROUND(attr/100, 2)'
+      end
+    end
+
+  end
+end

data/spec/unit/aggrobot_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Aggrobot do
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: aggrobot
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Shadab Ahmed
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-03 00:00:00.000000000 Z
+date: 2013-12-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,34 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  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'
 description: Easy and performant aggregation for rails
 email:
 - shadab.ansari@gmail.com
@@ -46,13 +88,33 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - aggrobot.gemspec
 - lib/aggrobot.rb
+- lib/aggrobot/aggregator.rb
+- lib/aggrobot/aggrobot.rb
+- lib/aggrobot/aggrobot_error.rb
+- lib/aggrobot/helper.rb
+- lib/aggrobot/query_planner.rb
+- lib/aggrobot/query_planner/bucketed_groups_query_planner.rb
+- lib/aggrobot/query_planner/default_query_planner.rb
+- lib/aggrobot/query_planner/group_limit_query_planner.rb
+- lib/aggrobot/railtie.rb
+- lib/aggrobot/sql_functions.rb
 - lib/aggrobot/version.rb
+- spec/spec_helper.rb
+- spec/support/chain_query.rb
+- spec/unit/aggrobot/query_planners/bucketed_groups_query_planner_spec.rb
+- spec/unit/aggrobot/query_planners/default_query_planner_spec.rb
+- spec/unit/aggrobot/query_planners/group_limit_query_planner_spec.rb
+- spec/unit/aggrobot/sql_functions_spec.rb
+- spec/unit/aggrobot_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -77,4 +139,11 @@ rubygems_version: 2.1.4
 signing_key: 
 specification_version: 4
 summary: Rails aggregation library
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/support/chain_query.rb
+- spec/unit/aggrobot/query_planners/bucketed_groups_query_planner_spec.rb
+- spec/unit/aggrobot/query_planners/default_query_planner_spec.rb
+- spec/unit/aggrobot/query_planners/group_limit_query_planner_spec.rb
+- spec/unit/aggrobot/sql_functions_spec.rb
+- spec/unit/aggrobot_spec.rb