trailblazer-finder 0.1.0

data/Rakefile

@@ -0,0 +1,29 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation --format RspecJunitFormatter --out test-reports/spec.xml'
+end
+RSpec::Core::RakeTask.new(:tests) do |t|
+  t.rspec_opts = '--format progress --format documentation'
+end
+RSpec::Core::RakeTask.new(:spec_report) do |t|
+  t.rspec_opts = '--format html --out reports/rspec_results.html'
+end
+
+RuboCop::RakeTask.new(:rubocop)
+
+desc 'Remove temporary files'
+task :clean do
+  %x{rm -rf *.gem doc pkg coverage test-reports}
+  %x{rm -f `find . -name '*.rbc'`}
+end
+
+desc "Build the gem"
+task :gem do
+  %x{gem build trailblazer-finder.gemspec}
+end
+
+desc 'Running Tests'
+task default: %i[clean spec rubocop]

data/lib/trailblazer/finder/adapters/active_record/paging.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module ActiveRecord
+        # ActiveRecord - Paging Adapter
+        module Paging
+          def self.included(base)
+            base.extend Features::Paging::ClassMethods
+          end
+
+          private
+
+          def apply_paging(entity_type)
+            entity_type.limit(per_page).offset(([page, 1].max - 1) * per_page)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/active_record/sorting.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module ActiveRecord
+        # ActiveRecord - Sorting Adapter
+        module Sorting
+          def self.included(base)
+            base.extend Features::Sorting::ClassMethods
+          end
+
+          private
+
+          def sort_it(entity_type, sort_attribute, sort_direction)
+            entity_type.order sort_attribute.to_s => sort_direction
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/active_record.rb

@@ -0,0 +1,30 @@
+require 'trailblazer/finder/adapters/active_record/paging'
+require 'trailblazer/finder/adapters/active_record/sorting'
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module ActiveRecord
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # :nocov:
+          def normalize_find_handler(handler, key)
+            case handler
+            when Symbol then ->(entity_type, value) { method(handler).call entity_type, value }
+            when Proc then handler
+            else ->(entity_type, value) { entity_type.where(key.to_sym => value) unless Utils::String.blank?(value) }
+            end
+          end
+          # :nocov:
+        end
+
+        include Paging if defined?(Features::Paging::ClassMethods)
+        include Sorting if defined?(Features::Sorting::ClassMethods)
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/data_mapper/paging.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module DataMapper
+        # Sequel - Paging Adapter
+        module Paging
+          def self.included(base)
+            base.extend Features::Paging::ClassMethods
+          end
+
+          private
+
+          def apply_paging(entity_type)
+            entity_type.all(limit: per_page, offset: ([page, 1].max - 1) * per_page)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/data_mapper/sorting.rb

@@ -0,0 +1,25 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module DataMapper
+        # Sequel - Sorting Adapter
+        module Sorting
+          def self.included(base)
+            base.extend Features::Sorting::ClassMethods
+          end
+
+          private
+
+          def sort_it(entity_type, sort_attribute, sort_direction)
+            case sort_direction
+            when 'asc', 'ascending'
+              entity_type.all(order: [sort_attribute.to_sym.asc])
+            when 'desc', 'descending'
+              entity_type.all(order: [sort_attribute.to_sym.desc])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/data_mapper.rb

@@ -0,0 +1,30 @@
+require 'trailblazer/finder/adapters/data_mapper/paging'
+require 'trailblazer/finder/adapters/data_mapper/sorting'
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module DataMapper
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # :nocov:
+          def normalize_find_handler(handler, key)
+            case handler
+            when Symbol then ->(entity_type, value) { method(handler).call entity_type, value }
+            when Proc then handler
+            else ->(entity_type, value) { entity_type.all(key.to_sym => value) unless Utils::String.blank?(value) }
+            end
+          end
+          # :nocov:
+        end
+
+        include Paging if defined?(Features::Paging::ClassMethods)
+        include Sorting if defined?(Features::Sorting::ClassMethods)
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/friendly_id.rb

@@ -0,0 +1,33 @@
+if Gem.loaded_specs.key?('activerecord')
+  module Trailblazer
+    class Finder
+      module Adapters
+        # FriendlyId Adapter
+        module FriendlyId
+          def self.included(base)
+            base.extend ClassMethods
+            base.class_eval do
+              filter_by :id, with: :apply_slug_filter
+            end
+          end
+
+          def apply_slug_filter(entity_type, value)
+            return if value.nil?
+            return if value == ''
+            if num?(value)
+              entity_type.where(id: value)
+            else
+              entity_type.where(slug: Utils::String.underscore(value.downcase))
+            end
+          end
+
+          def num?(str)
+            Integer(str)
+          rescue ArgumentError, TypeError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/kaminari.rb

@@ -0,0 +1,18 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      # Kaminari Adapter
+      module Kaminari
+        def self.included(base)
+          base.extend Features::Paging::ClassMethods
+        end
+
+        private
+
+        def apply_paging(entity_type)
+          entity_type.page(page).per(per_page)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/sequel/paging.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module Sequel
+        # Sequel - Paging Adapter
+        module Paging
+          def self.included(base)
+            base.extend Features::Paging::ClassMethods
+          end
+
+          private
+
+          def apply_paging(entity_type)
+            entity_type.limit(per_page).offset(([page, 1].max - 1) * per_page)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/sequel/sorting.rb

@@ -0,0 +1,25 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module Sequel
+        # Sequel - Sorting Adapter
+        module Sorting
+          def self.included(base)
+            base.extend Features::Sorting::ClassMethods
+          end
+
+          private
+
+          def sort_it(entity_type, sort_attribute, sort_direction)
+            case sort_direction
+            when 'asc', 'ascending'
+              entity_type.order(sort_attribute.to_sym)
+            when 'desc', 'descending'
+              entity_type.reverse(sort_attribute.to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/sequel.rb

@@ -0,0 +1,30 @@
+require 'trailblazer/finder/adapters/sequel/paging'
+require 'trailblazer/finder/adapters/sequel/sorting'
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # Sequel Adapter
+      module Sequel
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # :nocov:
+          def normalize_find_handler(handler, key)
+            case handler
+            when Symbol then ->(entity_type, value) { method(handler).call entity_type, value }
+            when Proc then handler
+            else ->(entity_type, value) { entity_type.where(key.to_sym => value) unless Utils::String.blank?(value) }
+            end
+          end
+          # :nocov:
+        end
+
+        include Paging if defined?(Features::Paging::ClassMethods)
+        include Sorting if defined?(Features::Sorting::ClassMethods)
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/will_paginate.rb

@@ -0,0 +1,18 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      # WillPaginate Adapter
+      module WillPaginate
+        def self.included(base)
+          base.extend Features::Paging::ClassMethods
+        end
+
+        private
+
+        def apply_paging(entity_type)
+          entity_type.paginate per_page: per_page, page: page.zero? ? nil : page
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters.rb

@@ -0,0 +1,26 @@
+require 'trailblazer/finder/adapters/active_record'
+require 'trailblazer/finder/adapters/sequel'
+require 'trailblazer/finder/adapters/data_mapper'
+require 'trailblazer/finder/adapters/kaminari'
+require 'trailblazer/finder/adapters/will_paginate'
+require 'trailblazer/finder/adapters/friendly_id'
+
+module Trailblazer
+  class Finder
+    # Adapters
+    module Adapters
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # ClassMethods
+      module ClassMethods
+        def adapters(*mods)
+          mods.each do |mod|
+            include mod
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/base.rb

@@ -0,0 +1,98 @@
+require 'hashie/extensions/deep_locate'
+
+module Trailblazer
+  class Finder
+    # Base module
+    module Base
+      def self.included(base)
+        base.extend ClassMethods
+        base.instance_eval do
+          @config = {
+            defaults:  {},
+            actions:   {},
+            entity_type:     nil
+          }
+        end
+      end
+
+      def initialize(options = {})
+        config      = self.class.config
+        entity_type = options[:entity_type] || (config[:entity_type] && instance_eval(&config[:entity_type]))
+        actions     = config[:actions] || {}
+        params      = Utils::Params.normalize_params(config[:defaults], options[:filter], actions.keys)
+
+        raise Error::MissingEntityType unless entity_type
+
+        @find = Find.new(entity_type, params, actions)
+      end
+
+      def results
+        @results ||= fetch_results
+      end
+
+      def results?
+        results.any?
+      end
+
+      def count
+        @count ||= @find.count self
+      end
+
+      def params(additions = {})
+        if additions.empty?
+          @find.params
+        else
+          @find.params.merge Utils::Params.stringify_keys(additions)
+        end
+      end
+
+      private
+
+      def fetch_results
+        @find.query self
+      end
+
+      # ClassMethods
+      module ClassMethods
+        attr_reader :config
+
+        def inherited(base)
+          base.instance_variable_set '@config', Utils::Extra.deep_copy(config)
+        end
+
+        def entity_type(&block)
+          config[:entity_type] = block
+        end
+
+        def filter_by(name, options = nil, &block)
+          options = { default: options } unless options.is_a?(Hash)
+
+          name    = name.to_s
+          default = options[:default]
+          handler = options[:with] || block
+
+          config[:defaults][name] = default unless default.nil?
+          config[:actions][name]  = normalize_find_handler(handler, name)
+
+          define_method(name) { @find.param name }
+        end
+
+        def results(*args)
+          new(*args).results
+        end
+
+        def normalize_find_handler(handler, key)
+          case handler
+          when Symbol then ->(entity_type, value) { method(handler).call entity_type, value }
+          when Proc then handler
+          else
+            lambda do |entity_type, value|
+              return if Utils::String.blank?(value)
+              Hashie::Extensions::DeepLocate.deep_locate ->(k, v, _object) { k == key.to_sym && v == value }, entity_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/errors/block_ignored.rb

@@ -0,0 +1,11 @@
+module Trailblazer
+  class Finder
+    module Error
+      class BlockIgnored < ArgumentError
+        def initialize(message = "defined_by filter_by's don't accept blocks")
+          super message
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/errors/invalid_defined_by_value.rb

@@ -0,0 +1,11 @@
+module Trailblazer
+  class Finder
+    module Error
+      class InvalidDefinedByValue < ArgumentError
+        def initialize(filter_by, defined_bys, value)
+          super "Invalid value '#{value}' used for defined_by #{filter_by} (expected one of #{defined_bys.join(', ')})"
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/errors/invalid_number.rb

@@ -0,0 +1,16 @@
+module Trailblazer
+  class Finder
+    module Error
+      class InvalidNumber < ArgumentError
+        attr_reader :field, :number
+
+        def initialize(field, number)
+          @field  = field
+          @number = number
+
+          super "#{field} should be more than 0. Currently '#{number}' is given."
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/errors/missing_entity_type.rb

@@ -0,0 +1,11 @@
+module Trailblazer
+  class Finder
+    module Error
+      class MissingEntityType < ArgumentError
+        def initialize(message = 'No Entity Type provided. Entity Type can be defined on a class level or passed as an option.')
+          super message
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/errors/with_ignored.rb

@@ -0,0 +1,11 @@
+module Trailblazer
+  class Finder
+    module Error
+      class WithIgnored < ArgumentError
+        def initialize(message = "defined_by filter_by's don't accept :with")
+          super message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Trailblazer
+  class Finder
+    module Features
+      module Paging
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        attr_reader :page, :per_page
+
+        def initialize(options = {})
+          @page     = [options[:page].to_i, 0].max
+          @per_page = self.class.calculate_per_page options[:per_page]
+
+          super options
+        end
+
+        private
+
+        def fetch_results
+          apply_paging super
+        end
+
+        # Adapters will overwite this method
+        def apply_paging(entity_type)
+          entity_type.drop(([page, 1].max - 1) * per_page).first(per_page)
+        end
+
+        module ClassMethods
+          def per_page(number)
+            raise Error::InvalidNumber.new('Per page', number) unless number > 0
+            config[:per_page] = number
+          end
+
+          def min_per_page(number)
+            raise Error::InvalidNumber.new('Min per page', number) unless number > 0
+            config[:min_per_page] = number
+          end
+
+          def max_per_page(number)
+            raise Error::InvalidNumber.new('Max per page', number) unless number > 0
+            config[:max_per_page] = number
+          end
+
+          def calculate_per_page(given)
+            per_page = (given || config[:per_page] || 25).to_i.abs
+            per_page = [per_page, config[:max_per_page]].min if config[:max_per_page]
+            per_page = [per_page, config[:min_per_page]].max if config[:min_per_page]
+            per_page
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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, _|
+              sort_it(entity_type, sort_attribute, sort_direction)
+            end
+          end
+        end
+
+        # Adapters will overwite this method
+        def sort_it(entity_type, sort_attribute, sort_direction)
+          case sort_direction
+          when 'asc', 'ascending'
+            entity_type.sort_by { |a| a[sort_attribute.to_sym] }
+          when 'desc', 'descending'
+            entity_type.sort_by { |a| a[sort_attribute.to_sym] }.reverse
+          end
+        end
+
+        def sort?(attribute)
+          attribute == sort || sort.to_s.start_with?("#{attribute} ")
+        end
+
+        def sort_attribute
+          @sort_attribute ||= Utils::Extra.ensure_included sort.to_s.split(' ', 2).first, self.class.sort_attributes
+        end
+
+        def sort_direction
+          @sort_direction ||= Utils::Extra.ensure_included sort.to_s.split(' ', 2).last, %w[desc asc]
+        end
+
+        def sort_direction_for(attribute)
+          if sort_attribute == attribute.to_s
+            reverted_sort_direction
+          else
+            'desc'
+          end
+        end
+
+        def sort_params_for(attribute, options = {})
+          options['sort'] = "#{attribute} #{sort_direction_for(attribute)}"
+          params options
+        end
+
+        def reverted_sort_direction
+          sort_direction == 'desc' ? 'asc' : 'desc'
+        end
+
+        module ClassMethods
+          def sortable_by(*attributes)
+            config[:sort_attributes]  = attributes.map(&:to_s)
+            config[:defaults]['sort'] = "#{config[:sort_attributes].first} desc"
+          end
+
+          def sort_attributes
+            config[:sort_attributes] ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/features.rb

@@ -0,0 +1,22 @@
+require 'trailblazer/finder/features/paging'
+require 'trailblazer/finder/features/sorting'
+
+module Trailblazer
+  class Finder
+    # Features
+    module Features
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # ClassMethods
+      module ClassMethods
+        def features(*mods)
+          mods.each do |mod|
+            include mod
+          end
+        end
+      end
+    end
+  end
+end