activerecord-auto_filter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71bbfa7f6d59232176f41f78dda56840e44b1eac
+  data.tar.gz: 98ff34b5a5e4e5a692f348375c63e13e1ffb62e2
+SHA512:
+  metadata.gz: 189141eeaeb400717550cfb6da57ea5dbe601506269c67dadb4c0c592122b94e9c9bb44906335a0bf3c0ff83975d66779bbcbf9cc1cf7025048b53693c91b88d
+  data.tar.gz: 756e51cfbdc7f272b4d1c81ebf041b9794050e3e39ba31472df7994cae4dacd6e83982ca49d3077061fecacfaeac014afc1c81862d1bc0b938af20312b14868d

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+*.lock
+.idea/

data/Gemfile

@@ -0,0 +1,24 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in blah.gemspec
+gemspec
+
+# Database Adapters
+platforms :ruby do
+  gem "mysql2"
+end
+
+platforms :jruby do
+  gem "jdbc-mysql"
+  gem "activerecord-jdbcmysql-adapter"
+end
+
+
+
+group :test do
+  gem 'test-unit'
+  gem "shoulda", '3.0.1'
+  gem "shoulda-context", '1.0.0'
+  gem "shoulda-matchers", '1.0.0'
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 kaushik
+
+MIT License
+
+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.md

@@ -0,0 +1,54 @@
+# Activerecord::AutoFilter
+
+Configuration based condition building and inclusion handling extension for ActiveRecord::Base
+
+In case of eager loading of a model and its associations, it may be required to obtain query results based on filter criteria that span across multiple associations. To achieve this, we tend to construct dynamic where clauses based on the presence of certain filter criteria. Since this happens so frequently, it causes code duplication and hence violates the DRY principle. This gem tries to address that concern. Given request param hash and query specification hash, it is capable of emitting the required associations that need to be included, and where conditions that need to applied on a given model, to achieve the desired result or even apply them to the model directly.
+
+**The primary goal of this gem is to build dynamic query conditions**. It is not limited to catering to the needs of
+eager loading like above and can also be used to build where conditions on just a model too. All that is required is 
+- request-params 
+- query-specification
+- proper association definitions(if needed).
+
+
+
+
+**Notes:** 
+
+1. See activerecord-auto_filter.gemspec for allowed ruby versions.
+
+2. Following issues will be addressed later
+
+- Currently it is mysql specific as the condition extraction is based on splitting the Arel::Table query by the word 'WHERE'.
+- Accept Procs for determining the condition for building where clause, instead of just param value presence. This gives better control for the programmer.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-auto_filter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-auto_filter
+
+## Demo
+
+Run demo.rb for usage demo. Steps are below.
+
+1. Checkout this repo
+2. Run bundle install
+3. Run ruby demo.rb
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activerecord-auto_filter.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-auto_filter/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "activerecord-auto_filter"
+  gem.version       = Activerecord::AutoFilter::VERSION
+  gem.authors       = ["kaushik"]
+  gem.email         = ["kaushikd49@gmail.com"]
+  gem.description   = %q{Configuration based condition building and inclusion handling extension for ActiveRecord::Base}
+  gem.summary       = %q{Inclusions and where-condition building extension for ActiveRecord}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = ">= 1.9.3"
+
+  gem.add_runtime_dependency "activerecord", ">= 3.1.0"
+  gem.add_development_dependency "rake"
+end

data/demo.rb

@@ -0,0 +1,81 @@
+require 'bundler/setup'
+require "logger"
+require "./lib/activerecord-auto_filter"
+require_relative "test/helpers/data_layer_setup"
+
+include DataLayerSetup
+
+QUERY_SPEC = {
+    :self =>
+        {
+            :product_id =>
+                {
+                    :filter_operator => :eq, :column => :product_id
+                }
+        },
+    :order_items =>
+        {
+            :state =>
+                {
+                    :filter_operator => :eq, :column => :state
+                }
+        },
+    :product =>
+        {
+            :vertical =>
+                {
+                    :filter_operator => :eq, :column => :vertical
+                },
+            :price_from =>
+                {
+                    :filter_operator => :gteq, :column => :selling_price
+                },
+            :price_to =>
+                {
+                    :filter_operator => :lt, :column => :selling_price
+                }
+        },
+    :order_item_units =>
+        {
+            :size =>
+                {
+                    :filter_operator => :eq, :column => :size
+                }
+        }
+}
+
+def demo
+  pretty_print("DB setups started")
+  setup_datalayer(true)
+  pretty_print("DB setups complete")
+  run_demo_with_joins
+  run_demo_with_no_joins
+end
+
+def run_demo_with_joins
+  pretty_print("Demo with joins")
+  params = {:vertical => :book, :price_from => 100, :price_to => 600, :size => 100, :state => :approved}
+  generate_demo(params)
+end
+
+def run_demo_with_no_joins
+  pretty_print("Demo without joins")
+  params = {:product_id => :f1}
+  generate_demo(params)
+end
+
+def generate_demo(params)
+  ar_with_query_builded = Order.apply_includes_and_where_clauses(params, QUERY_SPEC)
+  puts  "Params for this demo are #{params}"
+  pretty_print("Final query generated is below")
+  ar_with_query_builded.inspect
+  puts "\n"
+end
+
+def pretty_print(string)
+  num_stars = (100-string.size)/2
+  puts "\n" + "*" * num_stars + " #{string} " + "*" * num_stars + "\n"
+end
+
+
+demo()

data/lib/activerecord-auto_filter.rb

@@ -0,0 +1,134 @@
+require 'active_record'
+require "active_record/version"
+
+class ActiveRecord::Base
+
+  class << self
+
+
+    ################################# Generic where clause and inclusion builder ###########################
+    # Query specification format
+    #
+    #  Hash containing association specific query specification,
+    #  each of which will map a param field to its param metadata
+    #  needed to construct where condition. Param metadata involve
+    #  information about the table, column the param maps to and
+    #  the operator that need to applied in the query with the
+    #  table column for the given param value. The operator passed
+    #  is delegated to Arel::Table. So, all operators accepted
+    #  by it are allowed (as mentioned in the example below)
+    #
+    #    {
+    #         :self =>
+    #           {
+    #             <param_field> =>
+    #               {
+    #                 :column => <col_name_sym>
+    #                 :filter_operator => <:gt|:lt|:gteq|:lteq|:in|:not_in>,
+    #               }
+    #           }
+    #         :association1 =>
+    #           {
+    #             <param_field> =>
+    #               {
+    #                 :column => <col_name_sym>
+    #                 :filter_operator => <:gt|:lt|:gteq|:lteq|:in|:not_in>,
+    #               },
+    #             ...
+    #             :join_filter =>
+    #               {
+    #                 :table1_column => <column_name>, :table2_column => <column_name>,
+    #               },
+    #             :is_inclusion_mandatory => <true|false>
+    #           },
+    #         ...
+    #     }
+
+
+    # Applies inclusion and where conditions/clauses for the model called upon.
+    # Where conditions are generated based on the presence of a param value.
+    def apply_includes_and_where_clauses(params, query_spec)
+      model = self
+      inclusions, where_clauses = get_inclusions_and_where_clauses(params, query_spec)
+
+      active_record = model.includes(inclusions)
+      where_clauses.each { |e| active_record = active_record.where(e) }
+      active_record
+    end
+
+    # Returns association inclusions and where conditions/clauses for the model called upon.
+    # Association inclusion is based on the presence of related where conditions.
+    # Where conditions are generated based on the presence of a param value.
+    def get_inclusions_and_where_clauses(params, query_spec)
+      result = emit_inclusion_and_filter_details(params, query_spec)
+      inclusions = result.keys - [:self]
+      where_clause_filters = result.values.flatten
+
+      [inclusions, where_clause_filters]
+    end
+
+    def emit_inclusion_and_filter_details(params, query_spec)
+      exclusions = [:join_filter, :is_inclusion_mandatory]
+      query_spec.each_with_object({}) do |(association, association_filter_spec), res|
+        join_spec, is_inclusion_mandatory = association_filter_spec.values_at(*exclusions)
+        new_association_filter_spec = association_filter_spec.reject { |e| exclusions.include?(e) }
+        association_model = get_association_model(association)
+        join_filter = get_association_join_filter(join_spec, self, association_model)
+
+        where_clause_filters =
+            new_association_filter_spec.each_with_object([]) do |(param_field, filter_spec), filter_res|
+              value = params[param_field]
+              if value.present?
+                filter_res << get_where_clause_filter(filter_spec, value, association_model)
+              end
+            end
+
+        if where_clause_filters.present?
+          res[association] = where_clause_filters
+          res[association] << join_filter if join_filter.present?
+        elsif is_inclusion_mandatory
+          res[association] = (join_filter.present?) ? [join_filter] : []
+        end
+      end
+    end
+
+    # Obtain ActiveRecord model from the association
+    def get_association_model(association)
+      (association == :self) ? self : self.reflect_on_association(association.to_sym).klass
+    end
+
+    private
+    def get_association_join_filter(join_filter, table1, table2)
+      return if join_filter.blank?
+      table1_col, table2_col = join_filter.values_at(:table1_column, :table2_column)
+      get_where_clause_sql(table2.arel_table[table2_col], table1, table1_col, :eq)
+    end
+
+    def get_where_clause_filter(filter_spec, value, table)
+      # Hash filters have good equality query abstractions.
+      # So choosing them over string filters for equality operator
+      if filter_spec[:filter_operator] == :eq
+        construct_hash_filter(value, filter_spec, table)
+      else
+        construct_str_filter(value, filter_spec, table)
+      end
+    end
+
+    def construct_str_filter(arg_value, filter_spec, table)
+      operator, column = filter_spec.values_at(:filter_operator, :column)
+      get_where_clause_sql(arg_value, table, column, operator)
+    end
+
+    def get_where_clause_sql(arg_value, table, column, operator)
+      table_arel = table.arel_table
+      sql = table_arel.where(table_arel[column].send(operator, arg_value)).to_sql
+      sql.split("WHERE").last
+    end
+
+    def construct_hash_filter(arg_value, filter_spec, table)
+      column = filter_spec[:column]
+      hash_filter = {column => arg_value}
+      (table != :self) ? {table.table_name.to_sym => hash_filter} : hash_filter
+    end
+  end
+end

data/lib/activerecord-auto_filter/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module AutoFilter
+    VERSION = "0.1.0"
+  end
+end

data/test/active_record_auto_filter_test.rb

@@ -0,0 +1,110 @@
+require "rubygems"
+require "shoulda"
+require 'test/unit'
+require 'active_record'
+require_relative "helpers/data_layer_setup"
+require_relative "../lib/activerecord-auto_filter"
+
+class ActiveRecordAutoFilterTest < Test::Unit::TestCase
+  include DataLayerSetup # Arel has a dependency on db connection
+
+  def setup
+    setup_datalayer()
+  end
+
+  context "inclusions check" do
+    should "contain only expected associations for inclusions" do
+      params = {:f1 => :f1_val, :f2 => :f2_val, :f3 => 4, :f4 => 41}
+      assert_associations_are_included(params, :order_items, :product)
+
+      params = {:f1 => :f1_val, :f2 => :f2_val, :f3 => 4}
+      assert_associations_are_included(params, :order_items, :product)
+
+      params = {:f2 => :f2_val, :f3 => 4}
+      assert_associations_are_included(params, :order_items, :product)
+
+      params = {:f3 => 4}
+      assert_associations_are_included(params, :product)
+
+      params = {:f2 => :f2_val}
+      assert_associations_are_included(params, :order_items)
+    end
+  end
+
+  context "where clause filter structure check" do
+    should "contain appropriate kind filters - string or hash" do
+      table1_name = Order.table_name.to_sym
+      table2_name = OrderItem.table_name.to_sym
+      table3_name = Product.table_name.to_sym
+      params = {:f1 => :f1_val, :f2 => :f2_val, :f3 => 4}
+      query_details = Order.emit_inclusion_and_filter_details(params, get_sample_query_spec)
+
+      # Check hash filter exists and its structure
+      association_containing_hash_filter = query_details.delete(:order_items)
+      assert_equal([{table2_name => {:c2 => :f2_val}}], association_containing_hash_filter)
+
+      # Check string filter exists and its structure
+      assert(query_details.all? do |association,filter_details|
+        string_where_clause = filter_details.first
+        str_filter_format_regexps = [/#{table1_name}.*c1.*f1_val/, /#{table3_name}.*c3.*4/]
+        str_filter_format_regexps.any?{|r| string_where_clause.match(r)}
+      end)
+    end
+
+    should "contain multiple kind of filters for a given association" do
+      params = {:f1 => :f1_val, :f2 => :f2_val, :f3 => 4, :f4 => 5}
+      query_spec = get_sample_query_spec
+      query_spec[:order_items][:f4] = { :filter_operator => :eq, :column => :c4 }
+
+      result = Order.emit_inclusion_and_filter_details(params, query_spec)
+      assert_equal(2,result[:order_items].size)
+    end
+
+    should "contain join filters" do
+      table1_name = Order.table_name
+      table2_name = OrderItem.table_name
+      query_spec = get_sample_query_spec
+      params = {:f2 => :f2_val, :f3 => 4}
+
+      query_spec[:order_items][:join_filter] = { :table1_column => :col1, :table2_column => :col2 }
+      result = Order.emit_inclusion_and_filter_details(params, query_spec)
+
+      assert_equal(2,result[:order_items].size)
+      assert(result[:order_items].any? do |filter|
+          filter.class == String and filter.match(/#{table1_name}.*col1.*#{table2_name}.*col2.*/)
+      end)
+    end
+  end
+
+  def assert_associations_are_included(params, *expected_inclusions)
+    query_spec = get_sample_query_spec()
+    associations_actually_included, wh_clauses = Order.get_inclusions_and_where_clauses(params, query_spec)
+    assert_equal(expected_inclusions, associations_actually_included)
+  end
+
+  def get_sample_query_spec
+    {
+        :self =>
+            {
+                :f1 =>
+                    {
+                        :filter_operator => :lt, :column => :c1
+                    }
+            },
+        :order_items =>
+            {
+                :f2 =>
+                    {
+                        :filter_operator => :eq, :column => :c2
+                    }
+            },
+        :product =>
+            {
+                :f3 =>
+                    {
+                        :filter_operator => :gteq, :column => :c3
+                    }
+            }
+    }
+  end
+end

data/test/helpers/data_layer_setup.rb

@@ -0,0 +1,13 @@
+require_relative "./sample_model_definitions"
+require_relative "./db_setup_helper"
+
+
+module DataLayerSetup
+  include SampleModelDefinitions
+  include DbSetupHelper
+
+  def setup_datalayer(stdout_logging=false)
+    do_db_setups(stdout_logging)
+    create_tables()
+  end
+end

data/test/helpers/db_setup_helper.rb

@@ -0,0 +1,25 @@
+module DbSetupHelper
+  include SampleModelDefinitions
+
+  DATABASE = 'experiments'
+  CONNECTION_SPEC = {adapter: 'mysql2', username: 'root', password: '', host: 'localhost'}
+
+  def do_db_setups(stdout_logging=false)
+    establish_connection_with_no_db(CONNECTION_SPEC)
+    create_database(DATABASE)
+    establish_connection_with_db(DATABASE, CONNECTION_SPEC)
+    ActiveRecord::Base.logger = Logger.new(STDOUT) if stdout_logging
+  end
+
+  def create_database(database)
+    ActiveRecord::Base.connection.create_database(database) rescue nil
+  end
+
+  def establish_connection_with_no_db(connection_spec)
+    ActiveRecord::Base.establish_connection(connection_spec)
+  end
+
+  def establish_connection_with_db(database, connection_spec)
+    ActiveRecord::Base.establish_connection(connection_spec.merge(database: database))
+  end
+end

data/test/helpers/sample_model_definitions.rb

@@ -0,0 +1,46 @@
+module SampleModelDefinitions
+  class Order < ActiveRecord::Base
+    has_one :product
+    has_many :order_items
+    has_many :order_item_units, :through => :order_items
+  end
+
+  class OrderItem < ActiveRecord::Base
+    has_many :order_item_units
+  end
+
+  class OrderItemUnit < ActiveRecord::Base
+  end
+
+  class Product < ActiveRecord::Base
+  end
+
+
+  def create_tables
+    ActiveRecord::Schema.define(:version => 20140124132738) do
+      create_table :orders, :force => true do |t|
+        t.text :user
+        t.string :product_id
+        t.integer :quantity, :default => true
+      end
+
+      create_table :order_items, :force => true do |t|
+        t.string :state
+        t.integer :quantity
+        t.references :order
+      end
+
+      create_table :order_item_units, :force => true do |t|
+        t.integer :size, :default => true
+        t.references :order_item
+      end
+
+      create_table :products, :force => true do |t|
+        t.string :vertical
+        t.integer :selling_price
+        t.references :order
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-auto_filter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kaushik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Configuration based condition building and inclusion handling extension
+  for ActiveRecord::Base
+email:
+- kaushikd49@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-auto_filter.gemspec
+- demo.rb
+- lib/activerecord-auto_filter.rb
+- lib/activerecord-auto_filter/version.rb
+- test/active_record_auto_filter_test.rb
+- test/helpers/data_layer_setup.rb
+- test/helpers/db_setup_helper.rb
+- test/helpers/sample_model_definitions.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Inclusions and where-condition building extension for ActiveRecord
+test_files:
+- test/active_record_auto_filter_test.rb
+- test/helpers/data_layer_setup.rb
+- test/helpers/db_setup_helper.rb
+- test/helpers/sample_model_definitions.rb