active_queryable 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 85318f4379a335f5d2398c1b85ab19ddb63cfbfa6955882c4dcd9e7a24a5168f
+  data.tar.gz: d9dbb94f9c174af1a34b680152b8add196cf1ddf1a38a895fc0f32370855a985
+SHA512:
+  metadata.gz: f64dda266de6dd21f1c6a21fae9bfba014a72a16f7acf6c560f6feea3771b4663db82b11b97c97fc751379963aa2b0b29b26a6a34339d2f8dade38576ee5868b
+  data.tar.gz: 89bad17c363651ddbc6c75ca6eeda418d436682c9376a1c9670e81bbc959e491b5a3b0acc1345cf71879ea01ad5ccf623fc8624a00e698c34a8131e1f1730c63

data/lib/active-queryable.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'active_queryable'

data/lib/active_queryable.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'kaminari/activerecord'
+
+module ActiveQueryable
+	extend ActiveSupport::Concern
+
+  QUERYABLE_VALID_PARAMS = [:filter, :sort, :page, :per].freeze
+
+  included do
+    class_attribute :_queryable_default_order
+    class_attribute :_queryable_default_page
+    class_attribute :_queryable_default_per
+    class_attribute :_queryable_filter_keys
+	end
+
+	module Initializer
+    def as_queryable
+			send :include, ActiveQueryable
+		end
+	end
+
+  module ClassMethods
+    def queryable(options)
+      self._queryable_default_order = options[:order] || { id: :asc }
+      self._queryable_default_page = options[:page] || 1
+      self._queryable_default_per = options[:per] || 25
+      self._queryable_filter_keys = ((options[:filter] || []) + ['not']).map(&:to_sym)
+
+      scope :query_by, ->(params) { queryable_scope(params) }
+      scope :of_not, ->(ids) { where.not(id: ids) }
+    end
+
+    def queryable_scope(params)
+      params = params.to_unsafe_h if params.respond_to? :to_unsafe_h
+      params = params.with_indifferent_access if params.respond_to?(:with_indifferent_access)
+      params.each_key { |k| QUERYABLE_VALID_PARAMS.include?(k.to_sym) || Rails.logger.error("Invalid key #{k} in queryable") }
+
+      order_params = queryable_validate_order_params(params[:sort])
+      query = queryable_parse_order_scope(order_params, self)
+
+      queryable_filtered_scope(params, query)
+    end
+
+    private
+
+    def queryable_filtered_scope(params, query)
+      filter_params = queryable_validate_filter_params(params[:filter])
+
+      page_params = queryable_validate_page_params(params)
+
+      scope = queryable_parse_filter_scope(filter_params, query)
+
+      unless page_params[:per] == 'all'
+        scope = scope
+                .page(page_params[:page])
+                .per(page_params[:per])
+      end
+
+      scope
+    end
+
+    def queryable_validate_order_params(params)
+      queryable_parse_order_params(params) || _queryable_default_order
+    end
+
+    def queryable_validate_page_params(params)
+      page_params = {}
+      if params[:page].respond_to?(:dig)
+        page_params[:page] = params.dig(:page, :number) || _queryable_default_page
+        page_params[:per] = params.dig(:page, :size) || params[:per] || _queryable_default_per
+      else
+        page_params[:page] = params[:page] || _queryable_default_page
+        page_params[:per] = params[:per] || _queryable_default_per
+      end
+      page_params
+    end
+
+    def queryable_validate_filter_params(filter_params)
+      return nil if filter_params.nil?
+
+      unpermitted = filter_params.except(*_queryable_filter_keys)
+      Rails.logger.warn("Unpermitted queryable parameters: #{unpermitted.keys.join(', ')}") if unpermitted.present?
+
+      filter_params.slice(*_queryable_filter_keys)
+    end
+
+    def queryable_parse_order_params(params)
+      return nil unless params.is_a? String
+
+      params.split(',').map! do |param|
+        clean_param = param.start_with?('-') ? param[1..-1] : param
+        [clean_param, clean_param == param ? :asc : :desc]
+      end.to_h
+    end
+
+    def queryable_parse_order_scope(params, query)
+      return query unless params
+
+      params.inject(query) do |current_query, (k, v)|
+        scope = "by_#{k}"
+
+        if current_query.respond_to?(scope, true)
+          current_query.public_send(scope, v)
+        else
+          current_query.order(params)
+        end
+      end || query
+    end
+
+    def queryable_parse_filter_scope(params, query)
+      return query unless params
+
+      params.inject(query) do |current_query, (k, v)|
+        scope = "of_#{k}"
+
+
+        if current_query.respond_to?(scope, true)
+          current_query.public_send(scope, v)
+        else
+          current_query.where(k => v)
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.send :extend, ActiveQueryable::Initializer

data/lib/active_queryable/version.rb

@@ -0,0 +1,3 @@
+module ActiveQueryable
+	VERSION = '0.2.0'
+end

data/spec/active_queryable/filters_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Filters' do
+  context 'default filters' do
+    it 'applies column name-based filters' do
+      query = Person.query_by(filter: { name: 'john doe' }, per: 'all')
+      expect(query.to_sql).to include('"people"."name" = \'john doe\'')
+      expect(query).to include(Person.first)
+    end
+
+    it 'applies id-exclusion filters' do
+      query = Person.query_by(filter: { not: [1, 2] }, per: 'all')
+      expect(query.to_sql).to include('NOT IN (1, 2)')
+      expect(query).to be_empty
+    end
+  end
+
+  it 'applies an explicit name filter' do
+    query = Article.query_by(filter: { title: 'sOME ARTICLE 1' }, per: 'all')
+    expect(query.to_sql).to include('lower(')
+    expect(query).to include(Article.find_by_title!('Some article 1'))
+  end
+
+  it 'applies an explicit article title filter' do
+    query = Person.query_by(filter: { article_title: 'Some article 1' }, per: 'all')
+    expect(query.to_sql).to include('INNER JOIN "articles"')
+    expect(query).to include(Person.first)
+  end
+end

data/spec/active_queryable/ordering_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Ordering' do
+  it 'default order' do
+    query = Person.query_by(per: 'all')
+    expect(query.to_sql).to include('ORDER BY "people"."name" ASC')
+  end
+
+  it 'order by column' do
+    query = Person.query_by(sort: '-name', per: 'all')
+    expect(query.to_sql).to include('ORDER BY "people"."name" DESC')
+  end
+
+  it 'order by scope' do
+    query = Person.query_by(sort: '-article_title', per: 'all')
+    expect(query.to_sql).to include('ORDER BY "articles"."title" DESC')
+  end
+end

data/spec/active_queryable/pagination_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Pagination' do
+  it 'paginates using `per` and `page`' do
+    query = Article.query_by(per: 2, page: 2)
+    expect(query.to_sql).to include('LIMIT 2 OFFSET 2')
+  end
+
+  it 'paginates using `page[number]` and `page[size]`' do
+    query = Person.query_by(page: { number: 2, size: 2 })
+    expect(query.to_sql).to include('LIMIT 2 OFFSET 2')
+  end
+
+  it 'accepts strings and numbers' do
+    query = Person.query_by(page: { number: '2', size: '2' })
+    expect(query.to_sql).to include('LIMIT 2 OFFSET 2')
+  end
+
+  it 'ignores invalid values of page' do
+    query = Person.query_by(page: {}, per: 20)
+    expect(query.to_sql).to include('LIMIT 20 OFFSET 0')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'active_support'
+require 'rspec'
+require 'active_record'
+require 'active_queryable'
+# require 'kaminari-activerecord'
+
+I18n.enforce_available_locales = false
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+Dir[File.expand_path('../support/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+
+  config.before(:suite) do
+    Schema.create
+  end
+
+
+  config.around(:each) do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+
+

data/spec/support/match_queries.rb

@@ -0,0 +1,9 @@
+def within_query
+  $__instrumentation = ActiveSupport::Notifications.subscribe 'sql.active_record' do |_, _, _, _, data|
+    yield data[:sql]
+  end
+end
+
+def query_clear
+  ActiveSupport::Notifications.unsubscribe($__instrumentation) if $__instrumentation
+end

data/spec/support/schema.rb

@@ -0,0 +1,54 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+class Person < ActiveRecord::Base
+  as_queryable
+  queryable order: { name: :asc }, filter: ['name', 'article_title']
+
+  has_many :articles
+
+  scope :of_article_title, ->(title) { joins(:articles).where(articles: { title: title }) }
+  scope :by_article_title, ->(direction) { joins(:articles).order(:'articles.title' => direction) }
+
+end
+
+class Article < ActiveRecord::Base
+  as_queryable
+  queryable order: { title: :asc }, filter: ['title']
+
+  scope :of_title, ->(title) { where('lower(title) = ?', title.downcase) }
+
+  belongs_to :person
+end
+
+module Schema
+  def self.create
+    ActiveRecord::Migration.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :people, force: true do |t|
+        t.string   :name
+        t.string   :email
+        t.boolean  :terms_and_conditions, default: false
+        t.timestamps null: false
+      end
+
+      create_table :articles, force: true do |t|
+        t.integer  :person_id
+        t.string   :title
+        t.text     :body
+        t.integer   :status
+        t.timestamps null: false
+      end
+    end
+
+    person = Person.create!(name: 'john doe', email: 'e@mail.com', terms_and_conditions: true)
+    10.times do |i|
+      article = Article.create!(person: person, title: "Some article #{i}", body: 'hello!', status: 0)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: active_queryable
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Mònade
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: kaminari-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: Gem to make easier model's filtering, sorting and pagination
+email: team@monade.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active-queryable.rb
+- lib/active_queryable.rb
+- lib/active_queryable/version.rb
+- spec/active_queryable/filters_spec.rb
+- spec/active_queryable/ordering_spec.rb
+- spec/active_queryable/pagination_spec.rb
+- spec/spec_helper.rb
+- spec/support/match_queries.rb
+- spec/support/schema.rb
+homepage: https://rubygems.org/gems/active_queryable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Gem to make easier model's filtering, sorting and pagination
+test_files:
+- spec/spec_helper.rb
+- spec/active_queryable/ordering_spec.rb
+- spec/active_queryable/pagination_spec.rb
+- spec/active_queryable/filters_spec.rb
+- spec/support/schema.rb
+- spec/support/match_queries.rb