queryko 1.2.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2344233fdafe42b76d1fbcef79137fc5506b0cd363fc8419e039da3b89bf62b0
-  data.tar.gz: f3675c95e31ef885e50309ccae71415e37895f75969db69d0546c27448aa7a55
+  metadata.gz: abb6e5b750a802a5aa0838bca55feed2fc57fd0fa2b5e4ffe5d8bdd15d226079
+  data.tar.gz: 4dd022ad40ac529ad3b5b9303bf8e20013bebeb70810738f7958b89076a11b25
 SHA512:
-  metadata.gz: b8bcabb4606be9cb25ada2e95819276b766e926fb6024d7c945d4189ad94e99fd6183b6377c6f73fb1050dc53218f949beb3e343b7482f379e47d96ffe6589fb
-  data.tar.gz: 8b38c51f4e7950f4131625259290ef7f78b3123bbaf9498a18fbb55302e584a0df20896261542054a2ab287ac35beb9f74108584df64192aea09f8ce4a551b75
+  metadata.gz: b5691585e6b1885c7ffb23138f996c77aad1f6fffc6c76ba8136c9458c80db18ddf0a9f94044f4a288be0e343dc7670b2dcabeb1fc9a317d82e1b4b9a84db3d4
+  data.tar.gz: 70d4ed989265d73ad5310727251cb1df113bd81facb5cbee091bed6a5a7b38b416650b1506d87adadb2d8a2e41065d4e210bf47b958fc73422bc90628944d9e9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    queryko (1.2.3)
+    queryko (1.2.2)
       activerecord (>= 4.0)
       activesupport (>= 4.0)
 
@@ -27,6 +27,7 @@ GEM
       tzinfo (~> 1.1)
     arel (9.0.0)
     builder (3.2.3)
+    byebug (11.0.1)
     concurrent-ruby (1.1.3)
     crass (1.0.4)
     diff-lcs (1.3)
@@ -82,6 +83,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.16)
+  byebug
   kaminari
   queryko!
   rake (~> 10.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,40 @@ 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
+  feature :id, :after, as: :since_id
+  feature :id, :batch, as: :by_ids
 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 +70,84 @@ 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   |
+
+
+### File structure
+You are free to structure your query objects and custom filters. Or group them
+in one folder
+```
+app/
+└─ queries/
+   ├─ filters/
+   │  └─ cool_search.rb
+   ├─ products_query.rb
+   └─ query_base.rb
+```
 
 ## 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/base.rb

@@ -0,0 +1,78 @@
+require "active_support/core_ext/class/attribute"
+require "queryko/naming"
+require "queryko/able"
+require "queryko/filterer"
+require "queryko/filter_classes"
+require "byebug"
+
+module Queryko
+
+  class Base
+    attr_reader :countable_resource
+    include Queryko::FilterClasses
+    include Queryko::Naming
+    include Queryko::Able
+    include Queryko::Filterer
+
+    attr_reader :params
+
+    def initialize(params = {}, rel=nil)
+      @relation = @original_relation = rel || self.class.model_class.all
+      @params = self.defaults.merge(params)
+    end
+
+    def self.call(params = {}, rel)
+      new(params, rel).call
+    end
+
+    def call
+      perform
+      return relation
+    end
+
+    def perform
+      return if @performed
+
+      @performed = true
+      filter
+      filter_by_filters
+      @countable_resource = relation
+    end
+
+
+    def self.total_count(params = {}, rel)
+      new(params, rel).total_count
+    end
+
+    def total_count
+      perform
+      countable_resource.count
+    end
+
+    def self.count(params = {}, rel)
+      new(params, rel).count
+    end
+
+    def count
+      call.to_a.count
+    end
+
+    private
+
+    attr_accessor :relation
+
+    def config
+      @config ||= {
+      }
+    end
+
+    def filter
+      # overridable method
+    end
+
+    class_attribute :defaults, default: {}
+    def self.default(sym, value)
+      self.defaults[sym] = value
+    end
+  end
+end

data/lib/queryko/filter_classes.rb

@@ -4,6 +4,9 @@ require "queryko/filters/before"
 require "queryko/filters/min"
 require "queryko/filters/max"
 require "queryko/filters/search"
+require "queryko/filters/order"
+require "queryko/filters/batch"
+require "queryko/filters/paginate"
 
 module Queryko
   module FilterClasses
@@ -22,7 +25,10 @@ module Queryko
             before: Queryko::Filters::Before,
             min: Queryko::Filters::Min,
             max: Queryko::Filters::Max,
-            search: Queryko::Filters::Search
+            search: Queryko::Filters::Search,
+            order: Queryko::Filters::Order,
+            batch: Queryko::Filters::Batch,
+            paginate: Queryko::Filters::Paginate
           }
         end
 

data/lib/queryko/filterer.rb

@@ -2,10 +2,17 @@ module Queryko
   module Filterer
     def filter_by_filters
       fields.each do |field, filter|
-        # puts field
-        # puts filter, filter.first.class.name
+        if field == 'limit' || field == 'page'
+          paginate(filter, )
+        end
         self.relation = filter.first.call(relation, params[field], self) if params[field]
       end
     end
+
+    def paginate(filter)
+      unless @paginated
+      end
+      @paginated ||= true
+    end
   end
 end

data/lib/queryko/filters/after.rb

@@ -1,11 +1,7 @@
 require "queryko/filters/base"
 
 class Queryko::Filters::After < Queryko::Filters::Base
-  def intialize(options = {}, feature)
-    super options, feature
-  end
-
-  def perform(collection, token, query_object)
+  def perform(collection, token, query_object = nil)
     collection.where("#{table_name}.#{column_name} > ?", token)
   end
 end

data/lib/queryko/filters/base.rb

@@ -5,7 +5,7 @@ module Queryko
 
       def initialize(options = {}, feature)
         @feature = feature
-        @table_name = options.fetch(:table_name) { @feature.query_object.defined_table_name }
+        @table_name = options[:table_name]
         @column_name = options.fetch(:column_name) { @feature.name }
         @as = options[:as]
       end
@@ -18,11 +18,25 @@ module Queryko
       end
 
       def field
-        @field ||= as || build_field_from_column
+        @field ||= as || build_param_key
       end
 
-      def build_field_from_column
-        "#{column_name}_#{self.class.name.split('::').last.underscore}"
+      def param_key_format
+        nil
+      end
+
+      private
+
+      def build_param_key
+        param_key_format || default_param_key_format
+      end
+
+      def default_param_key_format
+        "#{column_name}_#{parameterized_name}"
+      end
+
+      def parameterized_name
+        self.class.name.split('::').last.underscore
       end
     end
   end

data/lib/queryko/filters/batch.rb

@@ -0,0 +1,11 @@
+require "queryko/filters/base"
+
+class Queryko::Filters::Batch < Queryko::Filters::Base
+  def perform(collection, token, query_object = nil)
+    collection.where("#{table_name}.#{column_name} IN (?)", token.split(','))
+  end
+
+  def param_key_format
+    "by_#{column_name.pluralize}"
+  end
+end

data/lib/queryko/filters/before.rb

@@ -1,11 +1,7 @@
 require "queryko/filters/base"
 
 class Queryko::Filters::Before < Queryko::Filters::Base
-  def intialize(options = {}, feature)
-    super options, feature
-  end
-
-  def perform(collection, token, query_object)
+  def perform(collection, token, query_object = nil)
     collection.where("#{table_name}.#{column_name} < ?", token)
   end
 end

data/lib/queryko/filters/max.rb

@@ -1,11 +1,7 @@
 require "queryko/filters/base"
 
 class Queryko::Filters::Max < Queryko::Filters::Base
-  def intialize(options = {}, feature)
-    super options, feature
-  end
-
-  def perform(collection, token, query_object)
+  def perform(collection, token, query_object = nil)
     collection.where("#{table_name}.#{column_name} <= ?", token)
   end
 end

data/lib/queryko/filters/min.rb

@@ -1,15 +1,10 @@
 require "queryko/filters/base"
 
 class Queryko::Filters::Min < Queryko::Filters::Base
-  def intialize(options = {}, feature)
-    super options, feature
-  end
-
-  def perform(collection, token, query_object)
+  def perform(collection, token, query_object = nil)
     collection.where("#{table_name}.#{column_name} >= ?", token)
   end
 
-
   def build_field_from_column
     "#{column_name}_min"
   end

data/lib/queryko/filters/order.rb

@@ -0,0 +1,17 @@
+require "queryko/filters/base"
+
+class Queryko::Filters::Order < Queryko::Filters::Base
+
+  def perform(collection, token, query_object = nil)
+    collection.order("#{table_name}.#{column_name} #{filter_input(token)}", )
+  end
+
+  def filter_input(token)
+    return 'DESC' if token.to_s.downcase == 'desc'
+    return 'ASC'
+  end
+
+  def param_key_format
+    "order_by_#{column_name}"
+  end
+end

data/lib/queryko/filters/paginate.rb

@@ -0,0 +1,49 @@
+require "queryko/filters/base"
+
+class Queryko::Filters::Paginate < Queryko::Filters::Base
+  attr_reader :upper_limit, :lower_limit, :default_limit, :params
+
+  def initialize(options = {}, feature)
+    @upper_limit = options.fetch(:upper) { 100 }
+    @lower_limit = options.fetch(:lower) { 10 }
+
+    super(options, feature)
+  end
+
+  def perform(collection, paginate, query_object)
+    if paginate
+      @params = query_object.params
+
+      if defined?(WillPaginate)
+        collection.paginate(page: page, per_page: limit)
+      elsif defined?(Kaminari)
+        collection.page(page).per(limit)
+      else
+        raise 'Only kaminari and wil_paginate are supported'
+      end
+    end
+  end
+
+  def page
+    params[:page] || 1
+  end
+
+  def limit
+    get_limit
+  end
+
+  def get_limit
+     lim = params[:limit].to_i
+     if lower_limit > lim
+       lower_limit
+     elsif lim > upper_limit
+       upper_limit
+     else
+       lim
+     end
+  end
+
+  def param_key_format
+    "paginate"
+  end
+end

data/lib/queryko/filters/search.rb

@@ -5,10 +5,10 @@ class Queryko::Filters::Search < Queryko::Filters::Base
   def initialize(options = {}, feature)
     @cond = options.fetch(:cond) { :like }
     @token_format = options[:token_format] || '%token%'
-    super options, feature
+    super(options, feature)
   end
 
-  def perform(collection, token, query_object)
+  def perform(collection, token, query_object = nil)
     query_cond, query_token = format_query_params(token)
     table_property = "#{table_name}.#{column_name}"
 

data/lib/queryko/naming.rb

@@ -3,8 +3,9 @@ module Queryko
     def self.included(base)
       base.extend(ClassMethods)
       base.class_eval do
-        class_attribute :defined_table_name, default: nil, instance_writer: false
-        class_attribute :defined_model_class, default: nil, instance_writer: false
+        class_attribute :defined_table_name, default: :table, instance_writer: false
+        class_attribute :defined_model_class, default: :model, instance_writer: false
+        # class_attribute :abstract_class, default: false, instance_writer: false
 
         def table_name
           self.class.table_name
@@ -20,7 +21,7 @@ module Queryko
       def table_name(name = nil)
         if name
           self.defined_table_name = name.to_s
-        elsif self.defined_table_name.nil?
+        elsif self.defined_table_name == :table
           self.defined_table_name = inferred_from_class_name(self)
         end
 
@@ -30,13 +31,19 @@ module Queryko
       def model_class(name = nil)
         if name
           self.defined_model_class = name.to_s.constantize
-        elsif self.defined_model_class.nil?
+        elsif self.defined_model_class == :model
           self.defined_model_class = inferred_model(self)
         end
 
+        # require 'byebug'
+        # byebug
         return self.defined_model_class
       end
 
+      def abstract_class
+        @abstract_class = true
+      end
+
       def inferred_from_class_name(klass)
         # class names should be in plural form by default. No need to tableize
         klass.name.chomp('Query').split('::').last.underscore

data/lib/queryko/version.rb

@@ -1,3 +1,3 @@
 module Queryko
-  VERSION = "1.2.4"
+  VERSION = "2.0.0"
 end

data/lib/queryko.rb

@@ -1,5 +1,5 @@
 require "queryko/version"
-require "queryko/query_object"
+require "queryko/base"
 require "queryko/feature"
 require "queryko/able"
 require "queryko/filterer"

data/queryko.gemspec

@@ -41,4 +41,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'kaminari'
   spec.add_development_dependency 'will_paginate', '~> 3.1.0'
+  spec.add_development_dependency 'byebug'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queryko
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Joseph Nelson Valeros
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2019-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: " This gem provides additional functionality on your query objects. It
   will filter and paginate your query by supplying an option "
 email:
@@ -144,23 +158,22 @@ files:
 - bin/setup
 - 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
+- lib/queryko/filters/batch.rb
 - lib/queryko/filters/before.rb
 - lib/queryko/filters/max.rb
 - lib/queryko/filters/min.rb
+- lib/queryko/filters/order.rb
+- lib/queryko/filters/paginate.rb
 - lib/queryko/filters/search.rb
 - lib/queryko/naming.rb
-- lib/queryko/query_object.rb
-- lib/queryko/range_attributes.rb
-- lib/queryko/searchables.rb
 - lib/queryko/version.rb
 - queryko.gemspec
-- test.html
 homepage: https://github.com/neume/queryko
 licenses:
 - MIT

data/lib/queryko/after_attributes.rb

@@ -1,19 +0,0 @@
-module Queryko
-  module AfterAttributes
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def add_after_attributes(*args)
-        suggestion = []
-        args.each do |arg|
-          feature arg.to_sym, :after, as: "after_#{arg}"
-          suggestion << "feature :#{arg}, :after, as: 'after_#{arg}'"
-
-        end
-        warn "[DEPRECATION] `add_after_attributes` is deprecated. Please use `feature` instead.\nExample:\n#{suggestion.join("\n")}"
-      end
-    end
-  end
-end