queryko 1.2.1.beta2 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4cc16bfe7fdeda3c044386b045f40c265b94ad50d314ec2b2ccdc8d475ba31a
-  data.tar.gz: 583c6bc540793947a739f57eaeb7c8a748d9263dc76967925bc8b85c0401fbbe
+  metadata.gz: 2a59be1cc920578cfddb7246f18fe1435ed9ef7517610bf3ec2f41fe0c5a5556
+  data.tar.gz: 14adefec70cd53df2224961010a3118dd5703aa6d094c150ae54622718d81f6d
 SHA512:
-  metadata.gz: 5a894d289e142ca9748a330a625750840bc417eb16ce92e92e583d2b1a24c390a8b6f9388dadabc067c99f7cff70185a4a8b2e6b92609ae33b622d63e0d3156b
-  data.tar.gz: e07d2ca540665d7695f5aae81e0809388531fe8ac80b05462e4f7391d76c7ba268f2c60f35fd7080b4e2e831fdcef883253eef2dd40cbc065556fa0d055baa3d
+  metadata.gz: ad6636ad9562467fd758633f97972a885c377b405038f03ed95e9d263e3285ae68dfd07687c22357d2b477187537837a476c9dc0ca303b16e50cef6f53ffff7c
+  data.tar.gz: fa822897bea178f2a853b18e86afb0266c5427b97894895aa926ac1e61fe97b8bac025bf34a08902403e7e9a5c2850c375a59833f2ebb9a7bfdba07534c98474

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    queryko (1.2.1.beta)
+    queryko (1.2.2)
       activerecord (>= 4.0)
       activesupport (>= 4.0)
 

data/README.md

@@ -3,6 +3,7 @@
 This gem provides additional functionality on your query objects. It will filter and paginate your query by supplying arguments directly from controller params
 
 ## Installation
+
 ```ruby
 # Pagination
 gem 'kaminari'
@@ -22,33 +23,38 @@ Or install it yourself as:
     $ gem install queryko
 
 ## Usage
+
 ### Create a query object
+
 ``` ruby
 class ProductsQuery < Queryko::QueryObject
-  add_range_attributes :created_at, :price
-  add_searchables :name, :vendor
-
-  table_name 'my_products' # optional
-
-  def initialize params={}, relation = Product.all
-    super(params, relation)
-  end
+  feature :created_at, :min
+  feature :created_at, :max
+  feature :price, :min
+  feature :price, :max
+  feature :name, :search, as: :name
+  feature :vendor, :search, as: :vendor
 end
 ```
 
 ### Using your query object
-Filter your query by appending `_min` or `_max` on your defined attributes. You can also filter searc3h by attribute.
-As long as you defined it in your query object definition.
+Filter your query by appending `_min` or `_max` on your defined attributes. You can also filter results by attribute with your defined feature.
+
 ``` ruby
 # Collection
 products = ProductsQuery.new(price_min: 100, price_max: 150, name: 'Milk').call
 products = ProductsQuery.new(since_id: 26).call
 
-# Count
+# Count - Counts items on current page. Default page is 1
 products = ProductsQuery.new(created_at_min: 'Jan 1, 2019').count
 products = ProductsQuery.new(name: 'Bag').count
+
+# Total Count - Counts all items matching defined conditions
+products = ProductsQuery.new(created_at_min: 'Jan 1, 2019').total_count
+products = ProductsQuery.new(name: 'Bag').total_count
 ```
 
+
 #### Object Methods
 - **count** - Returns the filtered count including pagination filter or the size of return object.
 - **total_count** - Returns the overall count of the filtered total records.
@@ -62,19 +68,71 @@ query = ProductsQuery.new(page: 5, limit: 5)
 query.count           # 1
 query.total_count     # 21
 ```
+### Pagination
+Override these methods to customize pagination limits
+
+``` ruby
+...
+
+def upper_limit
+  20 # default is 100
+end
+
+def lower_limit
+  5 # default is 10
+end
+
+def default_limit
+  10 # default is 50
+end
+
+...
+```
+
+### Custom Filters
+Create a custom filter class using `Queryko::Filters::Base`
+
+``` ruby
+class CustomFilters::CoolSearch < Queryko::Filters::Base
+
+  # Optional.
+  # Some `options` keys are reserved for basic functionality
+  # Use `options` to get data from feature definition
+  def intialize(options = {}, feature)
+    super options, feature
+  end
+
+  # Required. This method is called by query object. Always return the result of
+  # the collection
+  def perform(collection, token)
+    collection.where("#{table_name}.#{column_name} < ?", "Cool-#{token}")
+  end
+end
+```
+
+Then add the filter class to your Queryko::Base object
+``` ruby
+class QueryObject < Queryko::Base
+  filter_class :cool_search, CustomFilters::CoolSearch
+  # or
+  filter_class :cool_search, "CustomFilters::CoolSearch"
+
+
+  feature :name, :cool_search
+  # the :name will be scoped using params[:name_cool_search]
+end
+```
 
 ### Other available options
 | Option   | description                  |
 |:---------|:-----------------------------|
 | since_id | retrieves records after `id` |
 | page     | page to retrieve             |
-| limit    | number of records per page   |
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/neume/queryko. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/queryko/able.rb

@@ -3,10 +3,10 @@ module Queryko
     def self.included(base)
       base.extend(ClassMethods)
       base.class_eval do
-        class_attribute :filters, default: {}, instance_writer: false
+        class_attribute :defined_filters, default: {}, instance_writer: false
         class_attribute :features, default: {}, instance_writer: false
         class_attribute :fields, default: {}, instance_writer: false
-        self.filters = {}
+        self.defined_filters = {}
         self.features = {}
         self.fields = {}
 
@@ -18,11 +18,11 @@ module Queryko
       def feature(feature_name, filter, options = {})
         # returns the feature if it exists
         feat = self.features[feature_name.to_sym] ||= Queryko::Feature.new feature_name, self
-        self.filters[filter] ||= Array.new
+        self.defined_filters[filter] ||= Array.new
 
         # creates a filter
-        filt = feat.create_filter filter, options
-        self.filters[filter].push(filt)
+        filt = feat.add_filter filter, options
+        self.defined_filters[filter].push(filt)
 
         # appends new field
         self.fields[filt.field.to_sym] ||= Array.new

data/lib/queryko/base.rb

@@ -0,0 +1,127 @@
+require "active_support/core_ext/class/attribute"
+require "queryko/range_attributes"
+require "queryko/searchables"
+require "queryko/after_attributes"
+require "queryko/naming"
+require "queryko/able"
+require "queryko/filterer"
+require "queryko/filter_classes"
+
+module Queryko
+  class Base
+    attr_reader :countable_resource
+    include Queryko::FilterClasses
+    include Queryko::Naming
+    include Queryko::RangeAttributes
+    include Queryko::Searchables
+    include Queryko::Able
+    include Queryko::Filterer
+    # include AfterAttributes
+
+    def self.inherited(subclass)
+      # It should not be executed when using anonymous class
+      subclass.table_name inferred_from_class_name(subclass) if subclass.name
+    end
+
+    def initialize(params = {}, rel)
+      @relation = @original_relation = rel || inferred_model.all
+      @params = params
+    end
+
+    def call
+      perform
+      self.relation = paginate if config[:paginate]
+      return relation
+    end
+
+    def perform
+      return if @performed
+
+      @performed = true
+      pre_filter
+      filter
+      filter_by_filters
+      @countable_resource = relation
+    end
+
+
+    def total_count
+      perform
+      countable_resource.count
+    end
+
+    def count
+      call.to_a.count
+    end
+
+    private
+
+    attr_reader :params, :relation
+    attr_writer :relation
+
+    def config
+      @config ||= {
+        paginate: true,
+        since_id: true,
+        ids: true
+      }
+    end
+
+    def pre_filter
+      self.relation = by_ids if config[:ids] && params[:ids]
+      self.relation = since_id if config[:since_id] && params[:since_id]
+    end
+
+    def filter
+    end
+
+    def paginate
+      if defined?(WillPaginate)
+        relation.paginate(page: page, per_page: limit)
+      elsif defined?(Kaminari)
+        relation.page(page).per(limit)
+      else
+        raise 'Only kaminari and wil_paginate are supported'
+      end
+    end
+
+    def page
+      params[:page] || 1
+    end
+
+    def limit
+      @limit ||= get_limit
+    end
+
+    def get_limit
+       lim = (params[:limit] || default_limit).to_i
+       if lower_limit > lim
+         lower_limit
+       elsif lim > upper_limit
+         upper_limit
+       else
+         lim
+       end
+    end
+
+    def upper_limit
+      100
+    end
+
+    def default_limit
+      50
+    end
+
+    def lower_limit
+      10
+    end
+
+    def by_ids
+      relation.where(id: params[:ids].split(','))
+    end
+
+    def since_id
+      relation.where("#{defined_table_name}.id > ?", params[:since_id])
+    end
+  end
+end

data/lib/queryko/feature.rb

@@ -1,28 +1,25 @@
 class Queryko::Feature
-  attr_reader :name, :filters, :query_object
+  attr_reader :name, :filter_names, :query_object
   def initialize(name, query_object)
     @name = name
     @query_object = query_object
-    @filters = {}
+    @filter_names = {}
   end
 
   def add_filter(filter_name, options = {})
-    self.filters[filter_name] << create_filter(name, options)
+    self.filter_names[filter_name] = create_filter(filter_name, options)
   end
 
   def create_filter(filter_name, options = {})
-    case filter_name
-    when :after
-      result = filters[:after] ||= Queryko::Filters::After.new(options, self)
-    when :before
-      result = filters[:before] ||= Queryko::Filters::Before.new(options, self)
-    when :min
-      result = filters[:min] ||= Queryko::Filters::Min.new(options, self)
-    when :max
-      result = filters[:max] ||= Queryko::Filters::Max.new(options, self)
-    when :search
-      result = filters[:search] ||= Queryko::Filters::Search.new(options, self)
+    if filter_class = filter_class_for(filter_name)
+      result = filter_class.new(options, self)
+    else
+      raise "Filter class for #{filter_name} not found"
     end
     result
- end
+  end
+
+  def filter_class_for(filter_name)
+    self.query_object.filters.fetch(filter_name.to_sym)
+  end
 end

data/lib/queryko/filter_classes.rb

@@ -0,0 +1,41 @@
+require "queryko/filters/base"
+require "queryko/filters/after"
+require "queryko/filters/before"
+require "queryko/filters/min"
+require "queryko/filters/max"
+require "queryko/filters/search"
+
+module Queryko
+  module FilterClasses
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          class_attribute :filters, default: {}
+          load_defaults
+        end
+      end
+
+      module ClassMethods
+        def load_defaults
+          self.filters = {
+            after: Queryko::Filters::After,
+            before: Queryko::Filters::Before,
+            min: Queryko::Filters::Min,
+            max: Queryko::Filters::Max,
+            search: Queryko::Filters::Search
+          }
+        end
+
+        def filter_class(symbol, klass)
+          filters[symbol.to_sym] = constantize_class(klass)
+        end
+
+        private
+
+        def constantize_class(klass)
+          return klass unless klass.class == String
+          klass.constantize
+        end
+      end
+  end
+end

data/lib/queryko/query_object.rb

@@ -1,125 +1,9 @@
-require "active_support/core_ext/class/attribute"
-require "queryko/range_attributes"
-require "queryko/searchables"
-require "queryko/after_attributes"
-require "queryko/naming"
-require "queryko/able"
-require "queryko/filterer"
-
-module Queryko
-  class QueryObject
-    attr_reader :countable_resource
-    include Queryko::Naming
-    include Queryko::RangeAttributes
-    include Queryko::Searchables
-    include Queryko::Able
-    include Queryko::Filterer
-    # include AfterAttributes
-
-    def self.inherited(subclass)
-      # It should not be executed when using anonymous class
-      subclass.table_name inferred_from_class_name(subclass) if subclass.name
-    end
-
-    def initialize(params = {}, rel)
-      @relation = @original_relation = rel || inferred_model.all
-      @params = params
-    end
-
-    def call
-      perform
-      self.relation = paginate if config[:paginate]
-      return relation
-    end
-
-    def perform
-      return if @performed
-
-      @performed = true
-      pre_filter
-      filter
-      filter_by_filters
-      @countable_resource = relation
-    end
-
-
-    def total_count
-      perform
-      countable_resource.count
-    end
-
-    def count
-      call.to_a.count
-    end
-
-    private
-
-    attr_reader :params, :relation
-    attr_writer :relation
-
-    def config
-      @config ||= {
-        paginate: true,
-        since_id: true,
-        ids: true
-      }
-    end
-
-    def pre_filter
-      self.relation = by_ids if config[:ids] && params[:ids]
-      self.relation = since_id if config[:since_id] && params[:since_id]
-    end
-
-    def filter
-    end
-
-    def paginate
-      if defined?(WillPaginate)
-        relation.paginate(page: page, per_page: limit)
-      elsif defined?(Kaminari)
-        relation.page(page).per(limit)
-      else
-        raise 'Only kaminari and wil_paginate are supported'
-      end
-    end
-
-    def page
-      params[:page] || 1
-    end
-
-    def limit
-      @limit ||= get_limit
-    end
-
-    def get_limit
-       lim = (params[:limit] || default_limit).to_i
-       if lower_limit > lim
-         lower_limit
-       elsif lim > upper_limit
-         upper_limit
-       else
-         lim
-       end
-    end
-
-    def upper_limit
-      100
-    end
-
-    def default_limit
-      50
-    end
-
-    def lower_limit
-      10
-    end
-
-    def by_ids
-      relation.where(id: params[:ids].split(','))
-    end
-
-    def since_id
-      relation.where("#{defined_table_name}.id > ?", params[:since_id])
-    end
-  end
-end
+require "queryko/base"
+Queryko::QueryObject = Queryko::Base
+
+message = [
+  "[DEPRECATION] Inheriting from 'Queryko::QueryObject' is depcrecated",
+  "and will be removed on next major release.",
+  "Inherit form 'Queryko::Base' instead."
+]
+warn message.join(' ')

data/lib/queryko/range_attributes.rb

@@ -11,6 +11,7 @@ module Queryko
           feature arg.to_sym, :min
           feature arg.to_sym, :max
           suggestion << "feature :#{arg}, :min"
+          suggestion << "feature :#{arg}, :max"
         end
         warn "[DEPRECATION] `add_range_attributes` is deprecated. Please use `feature` instead.\nExample:\n#{suggestion.join("\n")}"
       end

data/lib/queryko/searchables.rb

@@ -9,7 +9,7 @@ module Queryko
         suggestion = []
         args.each do |arg|
           feature arg.to_sym, :search, as: arg.to_sym
-          suggestion << "feature :#{arg}, :search, as: #{arg}"
+          suggestion << "feature :#{arg}, :search, as: :#{arg}"
         end
         warn "[DEPRECATION] `add_searchables` is deprecated. Please use `feature` instead.\nExample:\n#{suggestion.join("\n")}"
       end

data/lib/queryko/version.rb

@@ -1,3 +1,3 @@
 module Queryko
-  VERSION = "1.2.1.beta2"
+  VERSION = "1.2.2"
 end

data/lib/queryko.rb

@@ -1,14 +1,10 @@
 require "queryko/version"
 require "queryko/query_object"
-require "queryko/filters/base"
-require "queryko/filters/after"
-require "queryko/filters/before"
-require "queryko/filters/min"
-require "queryko/filters/max"
-require "queryko/filters/search"
+require "queryko/base"
 require "queryko/feature"
 require "queryko/able"
 require "queryko/filterer"
+require "queryko/filter_classes"
 module Queryko
   # Your code goes here...
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: queryko
 version: !ruby/object:Gem::Version
-  version: 1.2.1.beta2
+  version: 1.2.2
 platform: ruby
 authors:
 - Joseph Nelson Valeros
@@ -145,7 +145,9 @@ files:
 - lib/queryko.rb
 - lib/queryko/able.rb
 - lib/queryko/after_attributes.rb
+- lib/queryko/base.rb
 - lib/queryko/feature.rb
+- lib/queryko/filter_classes.rb
 - lib/queryko/filterer.rb
 - lib/queryko/filters/after.rb
 - lib/queryko/filters/base.rb
@@ -175,9 +177,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6