index_query_builder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8af5c5d595d2eadb2940a4f1aaea38103970502e
+  data.tar.gz: a7a3cec53023cfab0ca2fb6b3fd0f37d1c81a910
+SHA512:
+  metadata.gz: ca1644edcd841d1acd9b393538959bab3c5df58eababc66db5d8780ec32c4edf60c1b25cd4ae2f89d5e364af75a568b09b8c5c026c46d2deef7b1f06d8a27506
+  data.tar.gz: 559fa403af8cf4f64845f49d0c8f858bd4ab10746a5297272344f0bbcf8eb4e95dcb5990d8cae03baba79eeee11f9c928a572d40deb4f7096e3f391188a39f9a

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in index_query_builder.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    index_query_builder (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.13)
+      activesupport (= 4.0.13)
+      builder (~> 3.1.0)
+    activerecord (4.0.13)
+      activemodel (= 4.0.13)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.13)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.4)
+    activesupport (4.0.13)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.2)
+    builder (3.1.4)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    minitest (4.7.5)
+    multi_json (1.12.1)
+    pg (0.18.1)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    thread_safe (0.3.5)
+    tzinfo (0.3.50)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 4.0.0)
+  activesupport (~> 4.0.0)
+  bundler (~> 1.7)
+  index_query_builder!
+  pg (~> 0.18.1)
+  rake (~> 10.0)
+  rspec (~> 3.3.0)
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,37 @@
+# IndexQueryBuilder
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'index_query_builder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install index_query_builder
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Running tests
+
+    $ cd bounded_contexts/index_query_builder
+    $ rake db:test:setup
+    $ rspec
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/index_query_builder/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,53 @@
+require "bundler/gem_tasks"
+require 'active_record'
+require 'pg'
+
+require 'index_query_builder'
+
+namespace 'db:test' do
+
+  desc 'Drop and create new test db and load schema'
+  task :setup => [:drop, :create, :load_schema]
+
+  task :drop do
+    pg_connection = create_pg_connection
+    pg_connection.query("DROP DATABASE IF EXISTS #{db_config[:database]}")
+    pg_connection.close
+  end
+
+  task :create do
+    pg_connection = create_pg_connection
+    pg_connection.query("CREATE DATABASE #{db_config[:database]}")
+    pg_connection.close
+  end
+
+  task :load_schema do
+    ActiveRecord::Base.establish_connection(db_config)
+    ActiveRecord::Schema.define do
+      create_table :posts, force: true do |t|
+        t.text :title
+        t.integer :view_count
+      end
+
+      create_table :comments, force: true do |t|
+        t.integer :post_id
+        t.text :text
+        t.integer :likes
+      end
+
+      create_table :authors, force: true do |t|
+        t.integer :comment_id
+      end
+    end
+  end
+
+  def create_pg_connection
+    PG::Connection.open(
+      host: db_config[:host], user: db_config[:username], password: db_config[:password], dbname: 'postgres'
+    )
+  end
+
+  def db_config
+   @db_config ||= IndexQueryBuilder.symbolize_keys(YAML.load_file('config/database.yml'))
+  end
+end

data/config/database.yml

@@ -0,0 +1,3 @@
+adapter: postgresql
+host: localhost
+database: index_query_builder_test

data/index_query_builder.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "index_query_builder/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "index_query_builder"
+  spec.version       = IndexQueryBuilder::VERSION
+  spec.authors       = ["Arturo Pie"]
+  spec.email         = ["arturop@nulogy.com"]
+  spec.summary       = %q{DSL for getting data for index pages.}
+  spec.description   = %q{This gem provides a DSL on top of ActiveRecord to get collection of models for index pages with filters.}
+  spec.homepage      = "https://github.com/arturopie/index_query_builder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "rspec", "~> 3.3", ">= 3.3.0"
+
+  spec.add_development_dependency "activerecord", "~> 4.0", ">= 4.0.0"
+  spec.add_development_dependency "activesupport", "~> 4.0", ">= 4.0.0"
+
+  spec.add_development_dependency "pg", "~> 0.18.1"
+end

data/lib/index_query_builder.rb

@@ -0,0 +1,103 @@
+require "active_support/core_ext/string"
+
+require "index_query_builder/query_definition"
+require "index_query_builder/query_builder"
+require "index_query_builder/version"
+
+# Simple DSL for building queries using filters.
+#
+#   This module makes it easy to fetch records from the database, specially
+#   for showing and filtering records in an index page
+#
+module IndexQueryBuilder
+
+  # Builds a query by calling arel methods on base_scope
+  #
+  # @param base_scope [Arel] used to build query on top of this scope
+  # @param options [Hash]
+  # @option :with [Hash] filters used to build query. Key is filter name, value is value for the filter
+  # @param &block yield to build query using IndexQueryBuilder's DSL
+  # @return [Arel] returns arel object to make it easy to extend query (e.g. add pagination, etc)
+  #
+  # ==== Example
+  #
+  # receive_orders = IndexQueryBuilder.query ReceiveOrder.where(:site_id => site.id), with: { sku_code: 'ABC' } do |query|
+  #   query.filter_field :received
+  #   query.filter_field :reference, contains: :reference
+  #   query.filter_field :expected_delivery_at,
+  #     greater_than_or_equal_to: :from_expected_delivery_at, less_than: :to_expected_delivery_at
+  #   query.filter_field [:receive_order_items, :sku, :code], equal_to: :sku_code
+  #
+  #   query.order_by "expected_delivery_at DESC, receive_orders.id DESC"
+  # end
+  #
+  def self.query(base_scope, options={}, &block)
+    query_definition = QueryDefinition.new
+    block.call(query_definition)
+
+    QueryBuilder.apply(base_scope, query_definition, filters(options))
+  end
+
+  # Builds a query by calling arel methods on base_scope, but it returns children of base scope.
+  # Use this method when using same filters as when querying the parent, but want to get back all children instead.
+  # This way, you can reuse same query definition you used for IndexQueryBuilder.query.
+  #
+  # @param child_association [Symbol] children's association name
+  # @param base_scope [Arel] used to build query on top of this scope
+  # @param options [Hash]
+  # @option options [Hash] :with filters used to build query. Key is filter name, value is value for the filter
+  # @param &block yield to build query using IndexQueryBuilder's DSL
+  # @return [Arel] returns arel object to make it easy to extend query (e.g. add pagination, etc)
+  #
+  # ==== Example
+  #
+  # receive_order_items = IndexQueryBuilder.query_children :receive_order_items, ReceiveOrder.scoped_by(site), with: filters do |query|
+  #   query.filter_field :received
+  #   query.filter_field :reference, contains: :reference
+  #   query.filter_field :expected_delivery_at,
+  #     greater_than_or_equal_to: :from_expected_delivery_at, less_than: :to_expected_delivery_at
+  #   query.filter_field [:receive_order_items, :sku, :code], equal_to: :sku_code
+  #
+  #   query.order_by "expected_delivery_at DESC, receive_orders.id DESC"
+  # end
+  #
+  def self.query_children(child_association, base_scope, options={}, &block)
+    parents = query(base_scope.eager_load(child_association), options, &block)
+
+    children_of(parents, child_association, base_scope)
+  end
+
+  # Exception raised when using Unknown Operator in query definition.
+  #
+  # ==== Example
+  #
+  # IndexQueryBuilder.query Post.where(nil) do |query|
+  #   query.filter_field :view_count, unkown_operator: :view_count
+  # end
+  #
+  # will raise this exception.
+  #
+  class UnknownOperator < ArgumentError; end
+
+  private
+
+  def self.filters(params)
+    symbolize_keys(params.fetch(:with) { {} })
+  end
+
+  def self.symbolize_keys(params)
+    Hash[params.map { |key, value| [key.to_sym, value] }]
+  end
+
+  def self.children_of(parents, child_association, base_scope)
+    initialize_parent_association(child_association, base_scope, parents).flat_map(&child_association)
+  end
+
+  def self.initialize_parent_association(child_association, base_scope, parents)
+    parents.each do |parent|
+      parent.public_send(child_association).each do |child|
+        child.public_send("#{base_scope.name.underscore}=", parent)
+      end
+    end
+  end
+end

data/lib/index_query_builder/query_builder.rb

@@ -0,0 +1,40 @@
+module IndexQueryBuilder
+  class QueryBuilder
+    def self.apply(base_scope, query_definition, filters)
+      new(query_definition, filters).apply(base_scope)
+    end
+
+    attr_reader :query_definition, :filters
+
+    def initialize(query_definition, filters)
+      @query_definition = query_definition
+      @filters = filters
+    end
+
+    def apply(base_scope)
+      apply_filters(apply_order_by(base_scope))
+    end
+
+    private
+
+    def apply_order_by(arel)
+      query_definition.arel_ordering.reduce(arel) do |arel, ordering|
+        ordering.call(arel)
+      end
+    end
+
+    def apply_filters(arel)
+      filters.reduce(arel) do |arel, (filter_name, filter_value)|
+        apply_predicates_for_filter(arel, filter_name, filter_value)
+      end
+    end
+
+    def apply_predicates_for_filter(arel, filter_name, filter_value)
+      arel_predicates(filter_name).reduce(arel) { |arel, predicate| predicate.call(arel, filter_value) }
+    end
+
+    def arel_predicates(filter_name)
+      query_definition.arel_filters.fetch(filter_name) { [] }
+    end
+  end
+end

data/lib/index_query_builder/query_definition.rb

@@ -0,0 +1,130 @@
+module IndexQueryBuilder
+
+  # Provides a DSL to build a query definition
+  class QueryDefinition
+    attr_reader :arel_filters, :arel_ordering
+
+    def initialize
+      @arel_filters = {}
+      @arel_ordering = []
+    end
+
+    # Specifies how to filter a field
+    #
+    # @param field_name [Symbol | [Symbol]] database field name (if one element) or
+    #        table names to join plus database field name (if an array of more than 1 element)
+    # @param predicates [Hash] of the form operator => filter_name. filter_name should match the key in filters hash
+    #        that is passed to IndexQueryBuilder.query methods
+    #
+    # ==== Operators
+    #
+    # Operators will apply where clauses to query *only if* the filter_name is present in filters hash.
+    #
+    # [:equal_to]
+    #   Applies field_name = filter_value
+    # [:contains]
+    #   Applies substring (ILIKE '%filter_value%')
+    # [:greater_than_or_equal_to]
+    #   Applies field_name >= filter_value
+    # [:less_than]
+    #   Applies field_name < filter_value
+    # [:present_if]
+    #   Applies
+    #     field_name IS NOT NULL if filter_value
+    #     field_name IS NULL if filter_value
+    #
+    # === Examples
+    #
+    # <tt>query.filter_field :received</tt>
+    # <tt>query.filter_field :reference, contains: :reference</tt>
+    # <tt>query.filter_field [:vendor, :name], equal_to: :vendor_name</tt>
+    # <tt>query.filter_field [:receive_order_items, :sku, :code], equal_to: :sku_code</tt>
+    # <tt>query.filter_field :expected_delivery_at, greater_than_or_equal_to: :from_expected_delivery_at, less_than: :to_expected_delivery_at</tt>
+    # <tt>query.filter_field :expected_delivery_at, less_than_or_equal_to: :to_expected_delivery_at</tt>
+    # <tt>query.filter_field :outbound_trailer_id, present_if: :has_trailer</tt>
+    #
+    def filter_field(field_name, predicates={equal_to: field_name})
+      predicates.each do |operator, filter|
+        @arel_filters[filter] = []
+
+        if operator == :contains
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            arel.where("#{table_name}.#{field} ILIKE ?", "%#{value}%")
+          end
+        elsif operator == :equal_to
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            arel.where(table_name => {field => value})
+          end
+        elsif operator == :greater_than_or_equal_to
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            arel.where("#{table_name}.#{field} >= ?", value)
+          end
+        elsif operator == :less_than
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            arel.where("#{table_name}.#{field} < ?", value)
+          end
+        elsif operator == :less_than_or_equal_to
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            arel.where("#{table_name}.#{field} <= ?", value)
+          end
+        elsif operator == :present_if
+          @arel_filters[filter] << ->(arel, value) do
+            table_name, field = apply_joins(arel, field_name, filter)
+            if value
+              arel.where("#{table_name}.#{field} IS NOT NULL")
+            else
+              arel.where("#{table_name}.#{field} IS NULL")
+            end
+          end
+        else
+          raise UnknownOperator.new("Unknown operator #{operator}.")
+        end
+      end
+    end
+
+    # Specifies how to order the result.
+    # Uses same syntax as Arel#order (http://guides.rubyonrails.org/active_record_querying.html#ordering)
+    #
+    # === Examples
+    #
+    # <tt>query.order_by "expected_delivery_at DESC, receive_orders.id DESC"</tt>
+    #
+    def order_by(*args)
+      @arel_ordering << ->(arel) do
+        arel.order(*args)
+      end
+    end
+
+    def filter_names
+      arel_filters.keys
+    end
+
+    private
+
+    def apply_joins(arel, qualified_field_name, filter)
+      # IQB_TODO: refactor this
+      if qualified_field_name.is_a?(Array)
+        association_hash, field, table_name = transform(qualified_field_name)
+        @arel_filters[filter] << ->(arel, _) { arel.joins(association_hash) }
+      else
+        table_name = arel.table_name
+        field = qualified_field_name
+      end
+
+      return table_name.to_s.pluralize, field
+    end
+
+    def transform(qualified_field_name)
+      field = qualified_field_name[-1]
+      association_path = qualified_field_name[0..-2]
+      table_name = association_path[-1]
+      association_hash = association_path[0..-2].reverse.inject(association_path[-1]) { |memo, e| {e => memo} }
+      return association_hash, field, table_name
+    end
+  end
+end

data/lib/index_query_builder/version.rb

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

data/spec/index_query_builder_spec.rb

@@ -0,0 +1,224 @@
+require 'rspec'
+require 'integration_spec_helper'
+
+RSpec.describe IndexQueryBuilder do
+  describe 'operator :contains' do
+    it 'returns records containing filter value' do
+      Post.create!(title: "Using Rubymine because it's awesome")
+      Post.create!(title: "VIM is useless")
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { title: 'Rubymine' } do |query|
+        query.filter_field :title, contains: :title
+      end
+
+      expect(posts.length).to eq(1)
+      expect(posts[0].title).to eq("Using Rubymine because it's awesome")
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(text: "This post is amazing.")])
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { comment_text: 'amazing' } do |query|
+        query.filter_field [:comments, :text], contains: :comment_text
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  describe 'operator :equal_to' do
+    it 'returns records equal to filter value' do
+      Post.create!(title: "Using Rubymine because it's awesome")
+      Post.create!(title: "VIM is useless")
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { title: "Using Rubymine because it's awesome" } do |query|
+        query.filter_field :title, equal_to: :title
+      end
+
+      expect(posts.length).to eq(1)
+      expect(posts[0].title).to eq("Using Rubymine because it's awesome")
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(text: "This post is amazing.")])
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { comment_text: "This post is amazing." } do |query|
+        query.filter_field [:comments, :text], equal_to: :comment_text
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  describe 'operator :greater_than_or_equal_to' do
+    it 'returns records greater than or equal to filter value' do
+      Post.create!(view_count: 10)
+      Post.create!(view_count: 1)
+      Post.create!(view_count: 5)
+
+      result = IndexQueryBuilder.query Post.where(nil), with: { view_count: 5 } do |query|
+        query.filter_field :view_count, greater_than_or_equal_to: :view_count
+      end
+
+      posts = result.sort_by(&:view_count)
+      expect(posts.length).to eq(2)
+      expect(posts[0].view_count).to eq(5)
+      expect(posts[1].view_count).to eq(10)
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(likes: 5)])
+      posts = IndexQueryBuilder.query Post.where(nil), with: { likes: 3 } do |query|
+        query.filter_field [:comments, :likes], greater_than_or_equal_to: :likes
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  describe 'operator :less_than' do
+    it 'returns records less than filter value' do
+      Post.create!(view_count: 10)
+      Post.create!(view_count: 1)
+      Post.create!(view_count: 5)
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { view_count: 5 } do |query|
+        query.filter_field :view_count, less_than: :view_count
+      end
+
+      expect(posts.length).to eq(1)
+      expect(posts[0].view_count).to eq(1)
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(likes: 5)])
+      posts = IndexQueryBuilder.query Post.where(nil), with: { likes: 6 } do |query|
+        query.filter_field [:comments, :likes], less_than: :likes
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  describe 'operator :less_than_or_equal_to' do
+    it 'returns records less than or equal to the filter value' do
+      Post.create!(view_count: 10)
+      Post.create!(view_count: 1)
+      Post.create!(view_count: 5)
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { view_count: 5 } do |query|
+        query.filter_field :view_count, less_than_or_equal_to: :view_count
+      end
+
+      expect(posts.length).to eq(2)
+      expect(posts[0].view_count).to eq(1)
+      expect(posts[1].view_count).to eq(5)
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(likes: 5)])
+      posts = IndexQueryBuilder.query Post.where(nil), with: { likes: 5  } do |query|
+        query.filter_field [:comments, :likes], less_than_or_equal_to: :likes
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  describe 'operator :present_if' do
+    it 'returns records where field is not null' do
+      hit = Post.create!(view_count: 0)
+      Post.create!(view_count: nil)
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { has_view_count: true } do |query|
+        query.filter_field :view_count, present_if: :has_view_count
+      end
+
+      expect(posts.length).to eq(1)
+      expect(posts[0]).to eq(hit)
+    end
+
+    it 'returns records where field is null' do
+      hit = Post.create!(view_count: nil)
+      Post.create!(view_count: 0)
+
+      posts = IndexQueryBuilder.query Post.where(nil), with: { has_view_count: false } do |query|
+        query.filter_field :view_count, present_if: :has_view_count
+      end
+
+      expect(posts.length).to eq(1)
+      expect(posts[0]).to eq(hit)
+    end
+
+    it 'filters using association' do
+      Post.create!(comments: [Comment.create!(likes: nil)])
+      posts = IndexQueryBuilder.query Post.where(nil), with: { has_comment_likes: false } do |query|
+        query.filter_field [:comments, :likes], present_if: :has_comment_likes
+      end
+
+      expect(posts.length).to eq(1)
+    end
+  end
+
+  it "raises UnknownOperator when passed operator is not supported" do
+    expect do
+      IndexQueryBuilder.query Post.where(nil) do |query|
+        query.filter_field :view_count, unkown_operator: :view_count
+      end
+    end.to raise_error(IndexQueryBuilder::UnknownOperator, /unkown_operator/)
+  end
+
+  it "does not error when passing unknown filter name" do
+    IndexQueryBuilder.query(Post.where(nil), with: {unknown_filter: "aaa"}) { |_| }
+  end
+
+  it "order_by works" do
+    Post.create(view_count: 5)
+    Post.create(view_count: 1)
+    Post.create(view_count: 10)
+
+    posts = IndexQueryBuilder.query Post.where(nil) do |query|
+      query.order_by "view_count DESC"
+    end
+
+    expect(posts.length).to eq(3)
+    expect(posts[0].view_count).to eq(10)
+    expect(posts[1].view_count).to eq(5)
+    expect(posts[2].view_count).to eq(1)
+  end
+
+  it "returns arel object" do
+    Post.create!(view_count: 10)
+
+    result = IndexQueryBuilder.query(Post.where(nil)) { |_| }
+
+    posts = result.where(view_count: 10)
+    expect(posts.length).to eq(1)
+    expect(posts[0].view_count).to eq(10)
+  end
+
+  it "works with filter names as string" do
+    Post.create!(view_count: 1)
+
+    posts = IndexQueryBuilder.query Post.where(nil), with: { "view_count" => 5 } do |query|
+      query.filter_field :view_count
+    end
+
+    expect(posts.length).to eq(0)
+  end
+
+  describe ".query_children" do
+    # IQB_TODO: write tests for number of queries
+    it "works" do
+      Post.create!(comments: [Comment.create!(likes: 5)])
+      Post.create!(comments: [Comment.create!(likes: 10)])
+
+      comments = IndexQueryBuilder.query_children(:comments, Post.where(nil), with: { likes: 10 }) do |query|
+        query.filter_field [:comments, :likes], equal_to: :likes
+      end
+
+      expect(comments.length).to eq(1)
+      expect(comments[0].likes).to eq(10)
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'index_query_builder'
+require 'active_record'
+
+class Post < ActiveRecord::Base
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  has_one :author
+end
+
+class Author < ActiveRecord::Base
+  belongs_to :post
+end
+
+ActiveRecord::Base.establish_connection(YAML.load_file('config/database.yml'))
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Post.delete_all
+    Comment.delete_all
+    Author.delete_all
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  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.
+  #     --seed 1234
+  config.order = :random
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: index_query_builder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Arturo Pie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+description: This gem provides a DSL on top of ActiveRecord to get collection of models
+  for index pages with filters.
+email:
+- arturop@nulogy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- config/database.yml
+- index_query_builder.gemspec
+- lib/index_query_builder.rb
+- lib/index_query_builder/query_builder.rb
+- lib/index_query_builder/query_definition.rb
+- lib/index_query_builder/version.rb
+- spec/index_query_builder_spec.rb
+- spec/integration_spec_helper.rb
+- spec/spec_helper.rb
+homepage: https://github.com/arturopie/index_query_builder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: DSL for getting data for index pages.
+test_files:
+- spec/index_query_builder_spec.rb
+- spec/integration_spec_helper.rb
+- spec/spec_helper.rb