qreds 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22a68415c21985b6d9e24fd19cf1262f4590e3f1
+  data.tar.gz: 2cf842c2363fd974fb997de1c7488a9181d15d23
+SHA512:
+  metadata.gz: bdb40b713c60d70e280301c145c4e855630b8c0c03114179d39efc319c52a580aebaa3c9115230c0aa72f01b5d1e05971e078cd9c01abcaf11aea74f2bfd3d1f
+  data.tar.gz: c44b8659d0dbc8063b1a6f2ba1cfd3f2c1600c78dc6df0aa6b62b846c16473285d0d5b4ef9d02a2b7a5d10e07f83c2b0723acff27e630bb9c0873f06119963a0

data/lib/qreds.rb

@@ -0,0 +1,12 @@
+module Qreds
+  require 'bundler/setup'
+
+  require 'active_support'
+  require 'active_support/core_ext'
+
+  require_relative 'qreds/config'
+  require_relative 'qreds/functor'
+  require_relative 'qreds/catch_all_functor'
+  require_relative 'qreds/reducer'
+  require_relative 'qreds/endpoint'
+end

data/lib/qreds/catch_all_functor.rb

@@ -0,0 +1,36 @@
+module Qreds
+  class CatchAllFunctor < Functor
+    # @param query [any] the query to adjust
+    # @param value [any] the parameter value
+    # @param context [any]
+    # @param key [String] the parameter name
+    # @param config [Qreds::Config] current reducer config
+    def initialize(query, value, context, key, config)
+      super(query, value, context)
+
+      @key = key
+      @config = config
+    end
+
+    def call
+      head, _, tail = key.rpartition('_')
+      operator = map_operator(tail)
+      attr_name = operator.nil? ? key : head
+
+      config.default_lambda.call(query, attr_name, value, operator, context)
+    end
+
+    private
+
+    attr_reader :key, :config
+
+    def map_operator(operator)
+      return nil if config.operator_mapping.nil?
+      mapped = config.operator_mapping[operator]
+
+      raise "No operator mapping found for #{operator}" if mapped.nil?
+
+      mapped
+    end
+  end
+end

data/lib/qreds/config.rb

@@ -0,0 +1,80 @@
+require 'qreds/endpoint'
+
+module Qreds
+  class Config
+    attr_accessor :functor_group, :default_lambda, :operator_mapping
+
+    @reducers = {}
+
+    # @param args [Hash<#to_s, any>]
+    def initialize(args)
+      args.each do |(key, value)|
+        send("#{key}=", value)
+      end
+    end
+
+    class << self
+      delegate :[], to: :@reducers
+
+      # @param helper_name [Symbol|String] the name of the helper method to be defined
+      # @yield config [Hash]
+      def define_reducer(helper_name, strategy: method(:define_endpoint_method))
+        config = new(functor_group: helper_name)
+
+        yield config
+
+        strategy.call(helper_name, config)
+      end
+
+      private
+
+      def define_endpoint_method(helper_name, config)
+        ::Qreds::Endpoint.send(:define_method, helper_name) do |query, context={}, **args|
+          functor_group = config.functor_group
+
+          declared_params = declared(params, include_missing: false)[functor_group]
+
+          ::Qreds::Reducer.new(
+            query: query,
+            params: declared_params,
+            config: config,
+            context: context,
+            **args
+          ).call
+        end
+
+        @reducers[helper_name] = config
+      end
+    end
+
+    OPERATOR_MAPPING_COMP_PGSQL = {
+      'lt' => '< ?',
+      'lte' => '<= ?',
+      'eq' => '= ?',
+      'gt' => '> ?',
+      'gte' => '>= ?',
+      'in' => 'IN (?)',
+      'btw' => 'BETWEEN ? AND ?'
+    }
+
+    private_constant :OPERATOR_MAPPING_COMP_PGSQL
+
+    define_reducer :sort do |reducer|
+      reducer.default_lambda = ->(query, attr_name, value, _, _) do
+        query.order(attr_name => value)
+      end
+    end
+
+    define_reducer :filter do |reducer|
+      reducer.default_lambda = ->(query, attr_name, value, operator, _) do
+        if operator.count('?') > 1
+          query.where("#{attr_name} #{operator}", *value)
+        else
+          query.where("#{attr_name} #{operator}", value)
+        end
+      end
+      reducer.operator_mapping = OPERATOR_MAPPING_COMP_PGSQL
+      reducer.functor_group = 'filters'
+    end
+  end
+end

data/lib/qreds/endpoint.rb

@@ -0,0 +1,6 @@
+module Qreds
+  # A container for helper methods to invoke reducers.
+  # The methods are defined via configuration (Config.define_reducer)
+  module Endpoint
+  end
+end

data/lib/qreds/functor.rb

@@ -0,0 +1,16 @@
+module Qreds
+  class Functor
+    # @param query [any] the query to adjust
+    # @param value [any] the parameter value
+    # @param context [any]
+    def initialize(query, value, context={})
+      @query = query
+      @value = value
+      @context = context
+    end
+
+    private
+
+    attr_reader :query, :value, :context
+  end
+end

data/lib/qreds/reducer.rb

@@ -0,0 +1,53 @@
+module Qreds
+  class Reducer
+    # @param query [any] the query to be reduced
+    # @param params [Hash] with keys being functor names and values the functor arguments.
+    # @param config [Qreds::Config] current reducer config
+    # @param resource_name [String] the name of the resource that query operates on
+    # @param context [any]
+    def initialize(query:, params:, config:, resource_name: query.model.to_s, context: {})
+      @query = query
+      @params = params
+      @config = config
+      @resource_name = resource_name
+      @context = context
+    end
+
+    def call
+      return query if params.blank?
+
+      params.reduce(query) do |reduced_query, (functor_key, functor_value)|
+        functor_instance(functor_key, reduced_query, functor_value).call
+      end
+    end
+
+    private
+
+    attr_reader :query, :params, :config, :resource_name, :context
+
+    def functor_instance(functor_key, reduced_query, functor_value)
+      functor_group_name = config.functor_group.to_s.capitalize
+      functor_name = functor_key.classify
+
+      klass = functor_class(functor_key, reduced_query, functor_value)
+
+      return klass.new(reduced_query, functor_value, context) if klass
+
+      ::Qreds::CatchAllFunctor.new(
+        reduced_query,
+        functor_value,
+        context,
+        functor_key,
+        config
+      )
+    end
+
+    def functor_class(functor_key, reduced_query, functor_value)
+      functor_group_name = config.functor_group.to_s.capitalize
+      functor_name = functor_key.classify
+
+      klass = "::#{functor_group_name}::#{resource_name}::#{functor_name}".constantize
+    rescue NameError
+    end
+  end
+end

data/spec/qreds/catch_all_functor_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Qreds::CatchAllFunctor do
+  subject { described_class.new(query, value, context, key, config).call.map(&:value) }
+
+  let(:query) { MockCollection.new((1..3).map { |i| SimpleObject.new(i) }) }
+  let(:key) { 'some_field' }
+  let(:value) { 2 }
+  let(:context) { {} }
+  let(:base_config) do
+    {
+      default_lambda: ->(collection, attr_name, value, operator, context) do
+        operator = '==' if operator.nil?
+        collection.select { |x| x.public_send(attr_name).public_send(operator, value) }
+      end
+    }
+  end
+  let(:config) { Qreds::Config.new(base_config) }
+
+  it "calls given lambda and returns it's value" do
+    is_expected.to eq([2])
+  end
+
+  context 'when config has operator mapping' do
+    let(:config) do
+      Qreds::Config.new(
+        **base_config,
+        operator_mapping: {
+          'gte' => '>='
+        }
+      )
+    end
+
+    it 'raises a RuntimeError' do
+      expect { subject }.to raise_error(RuntimeError)
+    end
+
+    context 'when operator is used as key suffix' do
+      let(:key) { 'some_field_gte' }
+
+      it { is_expected.to eq([2, 3]) }
+    end
+  end
+end

data/spec/qreds/config_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+RSpec.describe Qreds::Config do
+  let(:query) { MockCollection.new((1..3).map { |i| SimpleObject.new(i) }) }
+  let(:attr_name) { 'some_field' }
+
+  describe '.define_reducer' do
+    let(:reducer) do
+      test_strategy = -> (_helper_name, config) { config }
+
+      described_class.define_reducer(:test_reducer, strategy: test_strategy) do |config|
+        config.operator_mapping = {}
+      end
+    end
+
+    it 'creates a reducer with defaults and allows changing any other keys' do
+      expect(reducer.functor_group).to eq(:test_reducer)
+      expect(reducer.operator_mapping).to eq({})
+    end
+  end
+
+  describe 'sorting reducer' do
+    let(:reducer) { described_class[:sort] }
+
+    describe 'default lambda' do
+      subject { reducer.default_lambda.call(query, attr_name, value, nil, {}).map(&:value) }
+      let(:value) { 'desc' }
+
+      it 'calls order with attr name and value' do
+        is_expected.to eq([3, 2, 1])
+      end
+    end
+  end
+
+  describe 'filtering reducer' do
+    let(:reducer) { described_class[:filter] }
+
+    describe 'default lambda' do
+      subject { reducer.default_lambda.call(query, attr_name, value, operator, {}).map(&:value) }
+      let(:value) { 2 }
+      let(:operator) { '>' }
+
+      it 'calls where with attr name, value and operator' do
+        is_expected.to eq([3])
+      end
+
+      context 'when translated operator has more than one "?"' do
+        let(:operator) { 'BETWEEN ? AND ?' }
+        let(:value) { [2, 3] }
+
+        it { is_expected.to eq([2, 3]) }
+      end
+    end
+
+    describe 'operator mapping' do
+      subject { reducer.operator_mapping }
+
+      it 'is suited to work with PostgreSQL' do
+        is_expected.to eq(
+          'lt' => '< ?',
+          'lte' => '<= ?',
+          'eq' => '= ?',
+          'gt' => '> ?',
+          'gte' => '>= ?',
+          'in' => 'IN (?)',
+          'btw' => 'BETWEEN ? AND ?'
+        )
+      end
+    end
+
+    describe 'functor_group' do
+      subject { reducer.functor_group }
+
+      it { is_expected.to eq('filters') }
+    end
+  end
+end

data/spec/qreds/endpoint_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe Qreds::Endpoint do
+  let(:endpoint) { MockEndpoint.new(params) }
+  let(:query) { MockCollection.new([2, 3, 1]) }
+
+  describe '#sort' do
+    subject { endpoint.sort(query) }
+    let(:params) do
+      {
+        'sort' => {
+          'simple' => 'asc'
+        }
+      }
+    end
+
+    it { is_expected.to eq([1, 2, 3]) }
+
+    context 'with dynamic sorting - no predefined sort' do
+      subject { endpoint.sort(query).map(&:value) }
+      let(:query) { MockCollection.new([2, 3, 1].map { |i| SimpleObject.new(i) })}
+      let(:params) do
+        {
+          'sort' => {
+            'some_field' => 'desc'
+          }
+        }
+      end
+
+      it { is_expected.to eq([3, 2, 1]) }
+    end
+  end
+
+  describe '#filter' do
+    subject { endpoint.filter(query) }
+    let(:params) do
+      {
+        'filters' => {
+          'equality' => 2
+        }
+      }
+    end
+
+    it 'filters the collection' do
+      is_expected.to eq([2])
+    end
+
+    context 'with dynamic filtering - no predefined filter' do
+      subject { endpoint.filter(query).map(&:value) }
+      let(:query) { MockCollection.new([1, 2, 3].map { |i| SimpleObject.new(i) })}
+      let(:params) do
+        {
+          'filters' => {
+            'some_field_eq' => 2
+          }
+        }
+      end
+
+      it { is_expected.to eq([2]) }
+    end
+  end
+end

data/spec/qreds/reducer_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+RSpec.describe Qreds::Reducer do
+  let(:base_args) do
+    {
+      query: query,
+      params: params,
+      config: config
+    }
+  end
+  let(:args) { base_args }
+  let(:fallback_method) { nil }
+
+  let(:config) do
+    Qreds::Config.new(
+      default_lambda: ->(*_) { ['transformed'] },
+      functor_group: functor_group
+    )
+  end
+
+  subject { described_class.new(args).call }
+
+  let(:functor_group) { 'Filters' }
+  let(:query) { MockCollection.new([1, 2, 3]) }
+  let(:params) { { 'equality' => 1 } }
+
+  it 'calls specified functor' do
+    is_expected.to eq([1])
+  end
+
+  context 'when params is empty' do
+    let(:params) { {} }
+
+    it 'returns the collection unchanged' do
+      is_expected.to eq(query)
+    end
+  end
+
+  context 'when passed a different resource_name' do
+    let(:resource_name) { 'DifferentMockModel' }
+    let(:args) { base_args.merge(resource_name: resource_name) }
+
+    it 'calls the different resource' do
+      is_expected.to eq([2, 3])
+    end
+  end
+
+  context 'when cannot find a class' do
+    let(:query) { MockCollection.new((1..3).map { |i| SimpleObject.new(i) }) }
+    let(:params) { { 'some_field' => 2 } }
+
+    subject { described_class.new(args).call }
+
+    it 'uses the config default lambda' do
+      is_expected.to eq(['transformed'])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+require 'qreds'
+
+Bundler.require(:default, :test)
+
+require_relative 'support/mock_collection'
+require_relative 'support/mock_endpoint'
+require_relative 'support/mock_model'
+require_relative 'support/filters'
+require_relative 'support/sort'
+require_relative 'support/simple_object'

data/spec/support/filters.rb

@@ -0,0 +1,17 @@
+module Filters
+  module MockModel
+    class Equality < ::Qreds::Functor
+      def call
+        query.select { |el| el == value }
+      end
+    end
+  end
+
+  module DifferentMockModel
+    class Equality < ::Qreds::Functor
+      def call
+        query.select { |el| el != value }
+      end
+    end
+  end
+end

data/spec/support/mock_collection.rb

@@ -0,0 +1,63 @@
+module TestBetweenInteger
+  def test_between_integer(left, right)
+    self >= left && self <= right
+  end
+end
+
+class Fixnum
+  include TestBetweenInteger
+end
+
+class Integer
+  include TestBetweenInteger
+end
+
+class MockCollection < Array
+  def model
+    MockModel
+  end
+
+  def where(arg, *values)
+    if values.nil?
+      handle_where_hash(arg)
+    else
+      handle_where_string(arg, *values)
+    end
+  end
+
+  def order(hash)
+    k, v = key_val(hash)
+
+    sort_by do |el|
+      sort_val = el.public_send(k)
+      v == 'asc' ? sort_val : -sort_val
+    end
+  end
+
+  private
+
+  def handle_where_hash(hash)
+    k, v = key_val(main_arg)
+
+    select { |el| el.public_send(k) == v }
+  end
+
+  def handle_where_string(attr_name_with_operator, *values)
+    attr_name, _, operator = attr_name_with_operator.partition(' ')
+
+    select { |el| el.public_send(attr_name).public_send(sanitize_operator(operator), *values) }
+  end
+
+  def sanitize_operator(operator)
+    return :== if operator == '= ?'
+    return :test_between_integer if operator == 'BETWEEN ? AND ?'
+    operator
+  end
+
+  def key_val(hash)
+    k = hash.keys.first
+    v = hash[k]
+
+    [k, v]
+  end
+end

data/spec/support/mock_endpoint.rb

@@ -0,0 +1,13 @@
+class MockEndpoint
+  include Qreds::Endpoint
+
+  def initialize(params)
+    @params = params
+  end
+
+  def declared(params, **_)
+    params.with_indifferent_access
+  end
+
+  attr_reader :params
+end

data/spec/support/mock_model.rb

@@ -0,0 +1,2 @@
+class MockModel
+end

data/spec/support/simple_object.rb

@@ -0,0 +1,11 @@
+class SimpleObject
+  def initialize(value)
+    @value = value
+  end
+
+  def some_field
+    @value
+  end
+
+  attr_reader :value
+end

data/spec/support/sort.rb

@@ -0,0 +1,9 @@
+module Sort
+  module MockModel
+    class Simple < ::Qreds::Functor
+      def call
+        query.sort_by { |el| value == 'asc' ? el : -el }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: qreds
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rafał Warzocha
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Query reducers with built-in support for ActiveRecord & Grape, open for
+  custom extensions.
+email: warzocha.rafal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/qreds.rb
+- lib/qreds/catch_all_functor.rb
+- lib/qreds/config.rb
+- lib/qreds/endpoint.rb
+- lib/qreds/functor.rb
+- lib/qreds/reducer.rb
+- spec/qreds/catch_all_functor_spec.rb
+- spec/qreds/config_spec.rb
+- spec/qreds/endpoint_spec.rb
+- spec/qreds/reducer_spec.rb
+- spec/spec_helper.rb
+- spec/support/filters.rb
+- spec/support/mock_collection.rb
+- spec/support/mock_endpoint.rb
+- spec/support/mock_model.rb
+- spec/support/simple_object.rb
+- spec/support/sort.rb
+homepage: https://github.com/rafal42/qreds
+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.6.14
+signing_key: 
+specification_version: 4
+summary: Query reducers.
+test_files:
+- spec/spec_helper.rb
+- spec/support/mock_collection.rb
+- spec/support/filters.rb
+- spec/support/mock_model.rb
+- spec/support/mock_endpoint.rb
+- spec/support/simple_object.rb
+- spec/support/sort.rb
+- spec/qreds/config_spec.rb
+- spec/qreds/endpoint_spec.rb
+- spec/qreds/catch_all_functor_spec.rb
+- spec/qreds/reducer_spec.rb