aggrobot 0.0.2 → 0.1.0

data/lib/aggrobot/query_planner/group_limit_query_planner.rb

@@ -3,21 +3,30 @@ module Aggrobot
     class GroupLimitQueryPlanner < DefaultQueryPlanner
 
       def initialize(collection, group, opts)
-        ParametersValidator.validate_options(opts, [:limit_to, :sort_by], [:always_include, :other_group, :order])
+        required_params = [:limit_to, :sort_by]
+        optional_params = [:always_include, :other_group, :order]
+        validate_options(opts, required_params, optional_params)
         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)
+      def sub_query(group_value)
+        group_value == @other_group ? @collection.where.not(@top_groups_conditions) : @collection.where(group_condition(group_value))
       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 = if @group.is_a? Array
+          columns = @group + [SQLFunctions.count] + extra_cols
+          results_query.where(@top_groups_conditions).pluck(*columns).collect do |result_row|
+            [result_row[0..(@group.count - 1)]] + result_row[@group.count..-1]
+          end
+        else
+          columns = [@group, SQLFunctions.count] + extra_cols
+          results_query.where(@top_groups_conditions).pluck(*columns)
+        end
         top_group_results + other_group_results(columns)
       end
 
@@ -25,7 +34,7 @@ module Aggrobot
 
       def other_group_results(columns)
         if @other_group
-          columns[0] = SqlFunctions.sanitize(@other_group)
+          columns[0] = SQLFunctions.sanitize(@other_group)
           @collection.where.not(@top_groups_conditions).group(columns[0]).pluck(*columns)
         else
           []
@@ -36,21 +45,32 @@ module Aggrobot
         @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
+      def get_top_groups(opts)
+        @collection.group(@group).order("#{opts[:sort_by]} #{opts[:order]}").limit(opts[:limit_to]).pluck(*@group)
       end
 
       def process_top_groups_options(opts)
         opts[:order] ||= 'desc'
-        top_groups = calculate_top_groups(opts)
+        top_groups = get_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}
+        calculate_top_groups_conditions(top_groups)
         @other_group = opts[:other_group]
       end
 
+      def calculate_top_groups_conditions(top_groups)
+        if @group.is_a?(Array)
+          @top_groups_conditions = {}
+          @group.each_with_index do |group, idx|
+            @top_groups_conditions[group] = top_groups.collect{|v| v[idx]}
+          end
+        else
+          @top_groups_conditions = {@group => top_groups}
+        end
+      end
+
     end
   end
 end

data/lib/aggrobot/query_planner/parameters_validator.rb

@@ -0,0 +1,33 @@
+module Aggrobot
+  module QueryPlanner
+    module ParametersValidator
+      def validate_and_extract_relation(collection)
+        if !collection.is_a?(ActiveRecord::Relation) && (collection < ActiveRecord::Base rescue false)
+          collection.unscoped
+        elsif collection.is_a?(ActiveRecord::Relation)
+          collection
+        else
+          raise ArgumentError.new 'Only ActiveRecord Models and Relations can be used in Aggrobot'
+        end
+      end
+
+      def validate_options(opts, required_parameters, optional_parameters)
+        params = opts.keys
+        # raise errors for required parameters
+        raise_opts_error(opts, required_parameters, optional_parameters) unless (required_parameters - params).empty?
+        # raise errors if any extra arguments given
+        raise_opts_error(opts, required_parameters, optional_parameters) unless (params - required_parameters - optional_parameters).empty?
+      end
+
+      private
+
+      def raise_opts_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
+end

data/lib/aggrobot/sql_functions.rb

@@ -1,54 +1,27 @@
-module Aggrobot
-  module SqlFunctions
-
-    extend self
-
-    def sanitize(attr)
-      "'#{attr}'"
-    end
+require_relative './sql_functions/common'
 
-    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})"
+module Aggrobot
+  module SQLFunctions
+
+    autoload :MySQL,  File.expand_path('../sql_functions/mysql', __FILE__)
+    autoload :PgSQL, File.expand_path('../sql_functions/pgsql', __FILE__)
+    autoload :SQLite, File.expand_path('../sql_functions/sqlite', __FILE__)
+
+    POSTGRES_ADAPTER_NAME = 'PostgreSQL'
+    SQLITE_ADAPTER_NAME = 'SQLite'
+    MYSQL_ADAPTER_NAME = 'Mysql2'
+
+    def self.setup(precision = 2, adapter = ActiveRecord::Base.connection.adapter_name)
+      extend Common
+      self.precision = precision
+      adapter_module = case adapter
+                         when POSTGRES_ADAPTER_NAME then PgSQL
+                         when MYSQL_ADAPTER_NAME then MySQL
+                         when SQLITE_ADAPTER_NAME then SQLite
+                    else
+                      raise Exception.new "Database adaptor not supported: #{ActiveRecord::Base.connection.adapter_name}"
+                    end
+      extend adapter_module
     end
 
   end

data/lib/aggrobot/sql_functions/common.rb

@@ -0,0 +1,65 @@
+module Aggrobot
+  module SQLFunctions
+    module Common
+      delegate :sanitize, to: ActiveRecord::Base
+      mattr_accessor :precision
+
+      def desc(attr)
+        "#{attr} desc"
+      end
+
+      def asc(attr)
+        "#{attr} asc"
+      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
+
+      # returns ROUNDED average of attr, with precision(ROUNDING DIGITS)
+      def avg(attr, rounding = self.precision)
+        "ROUND(AVG(#{attr}), #{rounding})"
+      end
+
+      alias average avg
+
+      # GROUP_CONCAT: A SQL function which returns a concatenated string
+      # group_collect returns concatenated string of distinct attr
+      def group_collect(attr)
+        "GROUP_CONCAT(DISTINCT #{attr})"
+      end
+
+      # returns percentage based on ROUND SQL function, with precision(ROUNDING DIGITS)
+      def percent(total, attr = count, rounding = self.precision)
+        total == 0 ? "0" : "ROUND((#{attr}*100.0)/#{total}, #{rounding})"
+      end
+
+      # returns ROUND of multipliers, with precision(self.precision)
+      def multiply(attr, multiplier, rounding = self.precision)
+        "ROUND(#{attr}*#{multiplier}, #{rounding})"
+      end
+
+      # returns ROUND of attr/divider, with precision(self.precision)
+      def divide(attr, divider, rounding = self.precision)
+        "ROUND(#{attr}/#{divider}, #{rounding})"
+      end
+
+    end
+  end
+end

data/lib/aggrobot/sql_functions/mysql.rb

@@ -0,0 +1,6 @@
+module Aggrobot
+  module SQLFunctions
+    module MySQL
+    end
+  end
+end

data/lib/aggrobot/sql_functions/pgsql.rb

@@ -0,0 +1,6 @@
+module Aggrobot
+  module SQLFunctions
+    module PgSQL
+    end
+  end
+end

data/lib/aggrobot/sql_functions/sqlite.rb

@@ -0,0 +1,6 @@
+module Aggrobot
+  module SQLFunctions
+    module SQLite
+    end
+  end
+end

data/lib/aggrobot/version.rb

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

data/pbcopy

@@ -0,0 +1 @@
+a

data/spec/factories/users.rb

@@ -0,0 +1,4 @@
+FactoryGirl.define do
+  factory :users, :class => 'User' do
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 # Notice there is a .rspec file in the root folder. It defines rspec arguments
 
+# Set Rails environment as test
+ENV['RAILS_ENV'] = 'test'
+
 # Ruby 1.9 uses simplecov. The ENV['COVERAGE'] is set when rake coverage is run in ruby 1.9
 if ENV['COVERAGE']
   require 'simplecov'
@@ -7,12 +10,11 @@ if ENV['COVERAGE']
     # 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')
-
+    coverage_dir(ENV['COVERAGE'] == 'integration' ? 'coverage/integration' : 'coverage/unit')
   end
 end
 
-# Modify load path so you can require 'mckinsey_external_ad' directly.
+# Modify load path so you can require 'aggrobot' directly.
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'rubygems'
@@ -24,20 +26,60 @@ require 'bundler/setup'
 Bundler.require(:default, :test)
 
 require 'aggrobot'
-
+require 'database_cleaner'
 # 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'
-
+begin
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3',
+                                          :database => ':memory:',
+                                          :min_messages => 'warning')
+  connection = ActiveRecord::Base.connection
+  connection.execute("SELECT 1")
+rescue
+  at_exit do
+    puts "-" * 80
+    puts "Unable to connect to database. Make sure you the the necessary libraries for sqlite installed"
+    puts "-" * 80
+  end
+  raise $!
+end
 
 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
 
+  config.include FactoryGirl::Syntax::Methods
+
+  connection = ActiveRecord::Base.connection
+
+  config.after(:all) do
+    User.delete_all
+  end
+
+  config.before(:suite) do
+  begin
+
+    connection.create_table :users do |t|
+      t.text    :name
+      t.text    :country
+      t.integer :age
+      t.text    :gender
+      t.date    :dob
+      t.integer :score
+    end
+
+  end
+    Aggrobot::SQLFunctions.setup
+
+  end
+
+  config.after(:suite) do
+    #connection.drop_table :users
+  end
+
   # 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.

data/spec/support/factory_robot/distribution_evaluator.rb

@@ -0,0 +1,44 @@
+class DistributionEvaluator
+  attr_reader :count, :value
+
+  def initialize(value = nil, &block)
+    @count = 0
+    @value = value || block
+    @evaluator_name = evaluator_name(@value)
+  end
+
+  def next_value
+    current_val = send @evaluator_name
+    @count += 1
+    current_val
+  end
+
+  private
+
+  def evaluator_name(value)
+    case
+      when value.is_a?(Array)
+        :array_dist_value
+      when value.is_a?(Hash)
+        :hash_dist_value
+      when value.respond_to?(:call)
+        :block_dist_value
+      else
+        :value
+    end
+  end
+
+  def array_dist_value
+    value[@count % value.size]
+  end
+
+  def block_dist_value
+    value.call(@count)
+  end
+
+  def hash_dist_value
+    idx = value[:rest] ? @count : @count % value.keys.last
+    matching_value = value.find{|k, _| k.is_a?(Integer) && k > idx }
+    (matching_value && matching_value.last) || value[:rest]
+  end
+end

data/spec/support/factory_robot/factory_robot.rb

@@ -0,0 +1,108 @@
+require_relative './distribution_evaluator'
+require 'rails'
+require 'factory_girl'
+
+class FactoryRobot
+  FactoryGirl.find_definitions
+  attr_reader :factory_name
+  attr_writer :distribution, :count
+
+  def self.start(factory, opts = {}, &block)
+    original_block_context = eval "self", block.binding
+    raise 'Block required for create factory method' unless block_given?
+    factory = new(factory, original_block_context, opts)
+    factory.instance_eval &block
+    factory.finalize
+  end
+
+  def initialize(factory, caller_context, opts = {} )
+    @factory_name = factory
+    @factory = FactoryGirl.factory_by_name(@factory_name)
+    raise 'Factory not found for #{@factory_name}' unless @factory
+    @caller_context = caller_context
+    @distributions = {}
+    @foreach_blocks = []
+    create_factory_methods
+    opts = {
+        count: 1
+    }.merge(opts)
+    opts.each do |k,v|
+      send(k, v)
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    @caller_context.send method, *args, &block
+  end
+
+  def finalize
+    records = []
+    @count.times do
+      record = FactoryGirl.create(factory_name)
+      distribute_values(record)
+      execute_foreach_blocks(record)
+      records << record
+      record.save
+    end
+    records
+  end
+
+  def evaluate(*args, &block)
+    instance_exec(*args, &block)
+  end
+
+  private
+
+  def create(*args, &block)
+    self.class.start(*args, &block)
+  end
+
+  def create_factory_methods
+    factory_cols.each do |method_name|
+      method_name = method_name.to_s
+      class_eval <<-__CODE__, __FILE__, __LINE__
+        def #{method_name}(val = nil)
+          if val
+            distribute :#{method_name}, val
+          else
+            @distributions[:#{method_name}] && @distributions[:#{method_name}][:src]
+          end
+        end
+      __CODE__
+    end
+  end
+
+  def count(val)
+    @count = val
+  end
+
+  def each_record(&block)
+    raise 'Block required for foreach method' unless block_given?
+    @foreach_blocks << block
+  end
+
+  def distribute(attr, vals = nil, &block)
+    raise 'Values (array/hash/object) or block required for attribute #{attr}' if vals.nil? && !block_given?
+    @distributions[attr] = {:src => vals, :value => block_given? ? DistributionEvaluator.new(vals, &block) : DistributionEvaluator.new(vals)}
+  end
+
+  def factory_cols
+    cols = @factory.build_class.column_names.clone
+    cols.delete(@factory.build_class.primary_key)
+    cols.concat(@factory.build_class.reflect_on_all_associations.collect(&:name))
+  end
+
+  def execute_foreach_blocks(record)
+    if @foreach_blocks
+      @foreach_blocks.each do |block|
+        instance_exec(record, &block)
+      end
+    end
+  end
+
+  def distribute_values(record)
+    @distributions.each do |attr, distribution|
+      record.send("#{attr}=", distribution[:value].next_value)
+    end
+  end
+end