trailblazer-finder 0.1.4 → 0.2.5

data/lib/trailblazer/finder/features/predicate.rb

@@ -1,32 +0,0 @@
-module Trailblazer
-  class Finder
-    module Features
-      module Predicate
-        PREDICATES = %w[eq not_eq blank not_blank lt lte gt gte].freeze
-
-        def self.included(base)
-          base.extend ClassMethods
-          base.instance_eval do
-            include Predicates
-          end
-        end
-
-        module ClassMethods
-          def predicate_filter(attribute, predicate)
-            filter_by "#{attribute}_#{predicate}" do |entity_type, value|
-              splitter = Utils::Splitter.new "#{attribute}_#{predicate}", value
-              splitter.split_key predicate.to_sym
-              send splitter.op, splitter.field, splitter.value, entity_type
-            end
-          end
-
-          def predicates_for(*attributes)
-            attributes.each do |attribute|
-              PREDICATES.each { |predicate| predicate_filter(attribute, predicate) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/features/sorting.rb

@@ -1,108 +0,0 @@
-module Trailblazer
-  class Finder
-    module Features
-      module Sorting
-        def self.included(base)
-          base.extend ClassMethods
-          base.instance_eval do
-            filter_by :sort do |entity_type, value|
-              next sort_it(entity_type, [sort_orders(sort_attribute(value), sort_direction(value))]) if value.nil?
-              sort_attributes = value.split(',')
-              sorters = []
-              sort_attributes.each do |sort_attr|
-                sorters << sort_orders(sort_attribute(sort_attr), sort_direction(sort_attr))
-              end
-              sort_it(entity_type, sorters)
-            end
-          end
-        end
-
-        def sort?(attribute)
-          sort.include?(attribute.to_s)
-        end
-
-        def sort_direction_for(attribute)
-          return 'asc' if !sort.nil? && sort.include?("#{attribute} asc")
-          'desc'
-        end
-
-        def reverse_sort_direction_for(attribute)
-          return 'desc' if sort_direction_for(attribute) == 'asc'
-          'asc'
-        end
-
-        def sort_params_for(attribute, options = {})
-          options['sort'] = if sort.nil?
-                              "#{attribute} #{sort_direction_for(attribute)}"
-                            elsif sort.include?(attribute.to_s)
-                              sort
-                            else
-                              "#{attribute} #{sort_direction_for(attribute)}"
-                            end
-          params options
-        end
-
-        def new_sort_params_for(attribute, options = {})
-          options['sort'] = "#{attribute} #{sort_direction_for(attribute)}"
-          params options
-        end
-
-        def add_sort_params_for(attribute, options = {})
-          options['sort'] = if sort.nil?
-                              "#{attribute} #{sort_direction_for(attribute)}"
-                            elsif sort.include?(attribute.to_s)
-                              sort.gsub(/#{attribute} #{sort_direction_for(attribute)}/, "#{attribute} #{reverse_sort_direction_for(attribute)}")
-                            else
-                              "#{sort}, #{attribute} #{sort_direction_for(attribute)}"
-                            end
-          params options
-        end
-
-        private
-
-        # ORM Adapters will overwite this method
-        def sort_it(entity_type, sort_attributes)
-          entity_type.sort do |this, that|
-            sort_attributes.reduce(0) do |diff, order|
-              next diff if diff != 0 # this and that have differed at an earlier order entry
-              key, direction = order
-              # deal with nil cases
-              next  0 if this[key].nil? && that[key].nil?
-              next  1 if this[key].nil?
-              next -1 if that[key].nil?
-              # do the actual comparison
-              comparison = this[key] <=> that[key]
-              comparison * direction
-            end
-          end
-        end
-
-        # ORM Adapters will overwite this method
-        def sort_orders(sort_attr, sort_dir)
-          [sort_attr.to_sym, (sort_dir.to_sym == :asc ? 1 : -1)]
-        end
-
-        def sort_attribute(attribute)
-          result = Utils::Extra.ensure_included attribute.to_s.split(' ', 2).first, self.class.sort_attributes
-          result
-        end
-
-        def sort_direction(attribute)
-          return Utils::Extra.ensure_included attribute.to_s.split(' ', 2).last, %w[desc asc] unless attribute.nil?
-          'desc'
-        end
-
-        module ClassMethods
-          attr_accessor :sorted_attributes
-          def sortable_by(*attributes)
-            config[:sort_attributes] = attributes.map(&:to_s)
-          end
-
-          def sort_attributes
-            config[:sort_attributes] ||= []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/filter.rb

@@ -1,66 +0,0 @@
-module Trailblazer
-  class Finder
-    module Filter
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def filter_by(name, options = nil, &block)
-          return super unless options.is_a?(Hash) && options[:defined_by]
-
-          raise Error::BlockIgnored if block
-          raise Error::WithIgnored if options[:with]
-
-          handler = Handler.build(name, options[:defined_by])
-
-          super(name, options, &handler)
-        end
-      end
-
-      module Handler
-        module_function
-
-        def build(name, defined_bys) 
-          defined_bys = defined_bys.map(&:to_s)
-          handler = self
-          lambda do |entity_type, value|
-            handler.apply_filter(
-              object: self,
-              filter_by: name,
-              defined_bys: defined_bys,
-              entity_type: entity_type,
-              value: value
-            )
-          end
-        end
-
-        def apply_filter(object:, filter_by:, defined_bys:, entity_type:, value:) 
-          return if value.nil? || value == ''
-
-          unless defined_bys.include? value
-            return handle_invalid_value(
-              object: object,
-              filter_by: filter_by,
-              defined_bys: defined_bys,
-              entity_type: entity_type,
-              value: value
-            )
-          end
-
-          object.send("apply_#{filter_by}_with_#{Utils::String.underscore(value)}", entity_type)
-        end
-
-        def handle_invalid_value(object:, filter_by:, defined_bys:, entity_type:, value:)
-          specific = "handle_invalid_#{filter_by}"
-          return object.send(specific, entity_type, value) if object.respond_to? specific, true
-
-          catch_all = 'handle_invalid_defined_by'
-          return object.send(catch_all, filter_by, entity_type, value) if object.respond_to? catch_all, true
-
-          raise Error::InvalidDefinedByValue.new(filter_by, defined_bys, value)
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/predicates.rb

@@ -1,39 +0,0 @@
-module Trailblazer
-  class Finder
-    module Predicates
-      def not_eq(attribute, value, entity_type)
-        return if Utils::String.blank?(value.to_s)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_s != value.to_s && v != nil }, entity_type
-      end
-
-      def eq(attribute, value, entity_type)
-        return if Utils::String.blank?(value.to_s)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_s == value.to_s && v != nil }, entity_type
-      end
-
-      def blank(attribute, _value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && Utils::String.blank?(v.to_s) }, entity_type
-      end
-
-      def not_blank(attribute, _value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && !Utils::String.blank?(v.to_s) }, entity_type
-      end
-
-      def gt(attribute, value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i > value.to_f }, entity_type
-      end
-
-      def gte(attribute, value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i >= value.to_f }, entity_type
-      end
-
-      def lt(attribute, value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i < value.to_f }, entity_type
-      end
-
-      def lte(attribute, value, entity_type)
-        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i <= value.to_f }, entity_type
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/utils/deep_locate.rb

@@ -1,30 +0,0 @@
-module Trailblazer
-  class Finder
-    module Utils
-      module DeepLocate
-        def self.deep_locate(comparator, object, result = [])
-          if object.is_a?(::Enumerable)
-            if object.any? { |value| match_comparator?(value, comparator, object) }
-              result.push object
-            end
-            (object.respond_to?(:values) ? object.values : object.entries).each do |value|
-              deep_locate(comparator, value, result)
-            end
-          end
-
-          result
-        end
-
-        def self.match_comparator?(value, comparator, object)
-          if object.is_a?(::Hash)
-            key, value = value
-          else
-            key = nil
-          end
-
-          comparator.call(key, value, object)
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/utils/params.rb

@@ -1,28 +0,0 @@
-# TODO: Clean this shit up
-module Trailblazer
-  class Finder
-    # Helper module
-    module Utils
-      module Params
-        module_function
-
-        def stringify_keys(hash)
-          hash = hash.to_unsafe_h if hash.respond_to? :to_unsafe_h
-          Hash[(hash || {}).map { |k, v| [k.to_s, v] }]
-        end
-
-        def slice_keys(hash, keys)
-          keys.each_with_object({}) do |key, memo|
-            memo[key] = hash[key] if hash.key? key
-          end
-        end
-
-        def normalize_params(defaults, filters, keys)
-          (defaults || {}).merge(
-            slice_keys(stringify_keys(filters || {}), keys || [])
-          )
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/finder/utils/parse.rb

@@ -1,25 +0,0 @@
-require 'date'
-
-module Trailblazer
-  class Finder
-    # Helper module
-    module Utils
-      class Parse
-        # Need a replacement for this
-        def self.date(value)
-          return unless valid_date(value)
-          Date.parse(value).strftime('%Y-%m-%d')
-        end
-
-        def self.valid_date(date)
-          date_hash = Date._parse(date.to_s)
-          Date.valid_date?(date_hash[:year].to_i, date_hash[:mon].to_i, date_hash[:mday].to_i)
-        end
-
-        def self.term(value)
-          "%#{value.gsub(/\s+/, '%')}%"
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper_data_mapper.rb

@@ -1,35 +0,0 @@
-require_relative 'spec_helper'
-require_relative 'support/paging_shared_example'
-require 'data_mapper'
-
-DataMapper.setup(:default, 'sqlite::memory:')
-
-class DProduct
-  include DataMapper::Resource
-
-  property :id,             Serial
-  property :name,           String
-  property :slug,           String
-  property :d_category_id,  Integer
-  property :price,          Integer
-  property :created_at,     DateTime
-  property :updated_at,     DateTime
-
-  belongs_to :d_category
-end
-
-class DCategory
-  include DataMapper::Resource
-
-  property :id,             Serial
-  property :title,          String
-  property :slug,           String
-  property :created_at,     DateTime
-  property :updated_at,     DateTime
-
-  has n, :d_product
-end
-
-DataMapper.finalize
-require 'dm-migrations'
-DataMapper.auto_migrate!

data/spec/support/paging_shared_example.rb

@@ -1,65 +0,0 @@
-shared_examples_for 'a paging feature' do
-  describe '#page' do
-    it 'treats nil page as 0' do
-      finder = finder_with_page nil
-      expect(finder.page).to eq 0
-    end
-
-    it 'treats negative page numbers as positive' do
-      finder = finder_with_page(-1)
-      expect(finder.page).to eq 0
-    end
-  end
-
-  describe '#per_page' do
-    it 'returns the class defined per page' do
-      finder = finder_class.new
-      expect(finder.per_page).to eq 2
-    end
-
-    it 'can be overwritten as option' do
-      finder = finder_class.new per_page: 3
-      expect(finder.per_page).to eq 3
-    end
-
-    it 'respects min per page' do
-      finder = finder_class.new per_page: 1
-      expect(finder.per_page).to eq 2
-    end
-
-    it 'respects max per page' do
-      finder = finder_class.new per_page: 100
-      expect(finder.per_page).to eq 10
-    end
-  end
-
-  describe '.per_page' do
-    it 'does not accept 0' do
-      expect { define_finder_class { per_page(0) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-
-    it 'does not accept negative number' do
-      expect { define_finder_class { per_page(-1) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-  end
-
-  describe '.min_per_page' do
-    it 'does not accept 0' do
-      expect { define_finder_class { min_per_page(0) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-
-    it 'does not accept negative number' do
-      expect { define_finder_class { min_per_page(-1) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-  end
-
-  describe '.max_per_page' do
-    it 'does not accept 0' do
-      expect { define_finder_class { max_per_page(0) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-
-    it 'does not accept negative number' do
-      expect { define_finder_class { max_per_page(-1) } }.to raise_error Trailblazer::Finder::Error::InvalidNumber
-    end
-  end
-end

data/spec/support/sorting_shared_example.rb

@@ -1,125 +0,0 @@
-shared_examples_for 'a sorting feature' do
-  describe '#sort?' do
-    it 'says if the requested item is sorted on, for single sort' do
-      finder = finder_with_sort 'price desc'
-
-      expect(finder).to be_sort :price
-      expect(finder).not_to be_sort :name
-    end
-
-    it 'says if the requested item is sorted on for multiple sorts' do
-      finder = finder_with_sort 'price desc, name asc, id desc'
-
-      expect(finder).to be_sort :price
-      expect(finder).to be_sort :name
-      expect(finder).to be_sort :id
-      expect(finder).not_to be_sort :created_at
-    end
-
-    it 'matches string also, for single sort' do
-      finder = finder_with_sort 'price desc'
-
-      expect(finder).to be_sort 'price'
-      expect(finder).not_to be_sort 'name'
-    end
-
-    it 'matches string also, for multiple sorts' do
-      finder = finder_with_sort 'price desc, name asc, id desc'
-
-      expect(finder).to be_sort 'price'
-      expect(finder).to be_sort 'name'
-      expect(finder).to be_sort 'id'
-      expect(finder).not_to be_sort 'created_at'
-    end
-
-    it 'matches exact strings, for single sort' do
-      finder = finder_with_sort 'price desc'
-
-      expect(finder).to be_sort 'price desc'
-      expect(finder).not_to be_sort 'price asc'
-    end
-
-    it 'matches exact strings, for multiple sort' do
-      finder = finder_with_sort 'price desc, name asc'
-
-      expect(finder).to be_sort 'price desc'
-      expect(finder).to be_sort 'name asc'
-      expect(finder).not_to be_sort 'name desc'
-    end
-  end
-
-  describe '#sort_direction_for' do
-    it 'returns desc if current sort attribute is not the given attribute' do
-      expect(finder_with_sort('price desc').sort_direction_for('name')).to eq 'desc'
-    end
-
-    it 'returns asc if current sort attribute is the given attribute' do
-      expect(finder_with_sort('name desc').sort_direction_for('name')).to eq 'desc'
-    end
-
-    it 'returns desc if current sort attribute is the given attribute, but asc with direction' do
-      expect(finder_with_sort('name asc').sort_direction_for('name')).to eq 'asc'
-    end
-  end
-
-  describe '#reverse_sort_direction_for' do
-    it 'returns desc if current sort attribute is not the given attribute' do
-      expect(finder_with_sort('price desc').reverse_sort_direction_for('name')).to eq 'asc'
-    end
-
-    it 'returns asc if current sort attribute is the given attribute' do
-      expect(finder_with_sort('name desc').reverse_sort_direction_for('name')).to eq 'asc'
-    end
-
-    it 'returns desc if current sort attribute is the given attribute, but asc with direction' do
-      expect(finder_with_sort('name asc').reverse_sort_direction_for('name')).to eq 'desc'
-    end
-  end
-
-  describe '#new_sort_params_for' do
-    it 'adds new sort parmas when none are present' do
-      finder = finder_with_sort
-      expect(finder.new_sort_params_for(:price)).to eq 'sort' => 'price desc'
-    end
-
-    it 'adds new sort params when multiple ones exists (replaces them all)' do
-      finder = finder_with_sort 'name desc, price desc, id asc', name: 'test'
-      expect(finder.new_sort_params_for(:name)).to eq 'sort' => 'name desc', 'name' => 'test'
-    end
-  end
-
-  describe '#sort_params_for' do
-    it 'adds sort direction' do
-      finder = finder_with_sort 'name', name: 'test'
-      expect(finder.sort_params_for(:price)).to eq 'sort' => 'price desc', 'name' => 'test'
-    end
-
-    it 'finds params for multiple sorts' do
-      finder = finder_with_sort 'name desc, price desc, id asc', name: 'test'
-      expect(finder.sort_params_for(:name)).to eq 'sort' => 'name desc, price desc, id asc', 'name' => 'test'
-      expect(finder.sort_params_for(:price)).to eq 'sort' => 'name desc, price desc, id asc', 'name' => 'test'
-    end
-
-    it 'accepts additional options' do
-      finder = finder_with_sort
-      expect(finder.sort_params_for(:price, name: 'value')).to eq 'sort' => 'price desc', 'name' => 'value'
-    end
-  end
-
-  describe '#add_sort_params_for' do
-    it 'adds sort params when none exists' do
-      finder = finder_with_sort
-      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'price desc'
-    end
-
-    it 'adds sort params when one already exists' do
-      finder = finder_with_sort 'name', name: 'test'
-      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'name, price desc', 'name' => 'test'
-    end
-
-    it 'adds sort params when current attribute already exists, but change it' do
-      finder = finder_with_sort 'name asc, price asc', name: 'test'
-      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'name asc, price desc', 'name' => 'test'
-    end
-  end
-end