trailblazer-finder 0.1.0

data/lib/trailblazer/finder/filter.rb

@@ -0,0 +1,66 @@
+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) # rubocop:disable Metrics/MethodLength
+          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:) # rubocop:disable Metrics/MethodLength
+          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/find.rb

@@ -0,0 +1,29 @@
+module Trailblazer
+  class Finder
+    class Find
+      attr_reader :params
+
+      def initialize(entity_type, params, actions)
+        @entity_type  = entity_type
+        @actions      = actions
+        @params       = params
+      end
+
+      def param(name)
+        @params[name]
+      end
+
+      def query(context)
+        @params.inject(@entity_type) do |entity_type, (name, value)|
+          value = Utils::Parse.date(value) if Utils::Parse.date(value)
+          new_entity_type = context.instance_exec entity_type, value, &@actions[name]
+          new_entity_type || entity_type
+        end
+      end
+
+      def count(context)
+        query(context).count
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      class Extra
+        def self.ensure_included(item, collection)
+          if collection.include? item
+            item
+          else
+            collection.first
+          end
+        end
+
+        def self.deep_copy(object) # rubocop:disable Metrics/MethodLength
+          case object
+          when Array
+            object.map { |element| deep_copy(element) }
+          when Hash
+            object.each_with_object({}) do |(key, value), result|
+              result[key] = deep_copy(value)
+            end
+          when NilClass, FalseClass, TrueClass, Symbol, Method, Numeric
+            object
+          else
+            object.dup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,25 @@
+require 'date'
+
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      class Parse
+        # Need a replacement for this
+        def self.date(value)
+          return if value.nil?
+          return if [true, false].include? value
+          return if value.is_a? Integer
+          return if value =~ /[[:alpha:]]/
+          Date.parse(value).strftime('%Y-%m-%d')
+        rescue ArgumentError
+          nil
+        end
+
+        def self.term(value)
+          "%#{value.gsub(/\s+/, '%')}%"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'date'
+
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      class String
+        def self.blank?(value)
+          return false if num?(value)
+          value.nil? || value.strip.empty?
+        end
+
+        def self.num?(str)
+          Integer(str)
+        rescue ArgumentError, TypeError
+          false
+        end
+
+        def self.camelize(text)
+          text.to_s.gsub(/(?:^|_)(.)/) { Regexp.last_match[1].upcase }
+        end
+
+        def self.underscore(text)
+          text
+            .to_s.gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .tr(' ', '_')
+            .downcase
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/version.rb

@@ -0,0 +1,5 @@
+module Trailblazer
+  class Finder
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/trailblazer/finder.rb

@@ -0,0 +1,29 @@
+require 'trailblazer/finder/version'
+require 'trailblazer/finder/errors/block_ignored'
+require 'trailblazer/finder/errors/invalid_defined_by_value'
+require 'trailblazer/finder/errors/invalid_number'
+require 'trailblazer/finder/errors/missing_entity_type'
+require 'trailblazer/finder/errors/with_ignored'
+require 'trailblazer/finder'
+require 'trailblazer/finder/utils/params'
+require 'trailblazer/finder/utils/parse'
+require 'trailblazer/finder/utils/string'
+require 'trailblazer/finder/utils/extra'
+require 'trailblazer/finder/base'
+require 'trailblazer/finder/find'
+require 'trailblazer/finder/filter'
+require 'trailblazer/finder/features'
+require 'trailblazer/finder/adapters'
+
+# :nocov:
+require 'trailblazer/operation/finder' if Gem.loaded_specs.key?('trailblazer')
+# :nocov:
+
+module Trailblazer
+  class Finder
+    include Base
+    include Filter
+    include Features
+    include Adapters
+  end
+end

data/lib/trailblazer/operation/finder.rb

@@ -0,0 +1,61 @@
+
+# Really gotta clean this up, but can't be bothered right now
+module Trailblazer
+  class Operation
+    def self.Finder(finder_class, action = nil, entity_type = nil)
+      task = Trailblazer::Activity::TaskBuilder::Binary.call(Finder.new)
+
+      extension = Trailblazer::Activity::TaskWrap::Merge.new(
+        Wrap::Inject::Defaults(
+          'finder.class'        => finder_class,
+          'finder.entity_type'  => entity_type,
+          'finder.action'       => action
+        )
+      )
+
+      { task: task, id: 'finder.build', extension: [extension] }
+    end
+
+    class Finder
+      def call(options, params:, **)
+        builder                   = Finder::Builder.new
+        options[:finder]          = finder = builder.call(options, params)
+        options['result.finder']  = result = Result.new(!finder.nil?, {})
+
+        result.success?
+      end
+
+      class Builder
+        def call(options, params)
+          finder_class  = options['finder.class']
+          entity_type   = options['finder.entity_type'] || nil
+          action        = options['finder.action'] || :all
+          action        = :all unless %i[all single].include?(action)
+
+          send("#{action}!", finder_class, entity_type, params, options['finder.action'])
+        end
+
+        private
+
+        def all!(finder_class, entity_type, params, *)
+          finder_class.new(entity_type: entity_type, filter: params[:f], page: params[:page], per_page: params[:per_page])
+        end
+
+        def single!(finder_class, entity_type, params, *)
+          apply_id(params)
+          if entity_type.nil?
+            finder_class.new(filter: params[:f], page: params[:page], per_page: params[:per_page]).results.first
+          else
+            finder_class.new(entity_type: entity_type, filter: params[:f]).results.first
+          end
+        end
+
+        def apply_id(params)
+          return if params[:id].nil?
+          params[:f] = {} unless params.key?('f')
+          params[:f][:id] = params[:id] unless params[:f].key?('id')
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.start do
+  add_group 'Trailblazer-Finder', 'lib'
+  add_group 'Tests', 'spec'
+end
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'trailblazer/finder'

data/spec/spec_helper_active_record.rb

@@ -0,0 +1,50 @@
+require_relative 'spec_helper'
+require_relative 'support/paging_shared_example'
+require_relative 'support/sorting_shared_example'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :products, force: true do |t|
+    t.string :name
+    t.string :slug
+    t.integer :category_id
+    t.integer :price
+
+    t.timestamps null: true
+  end
+
+  create_table :categories, force: true do |t|
+    t.string :title
+    t.string :slug
+
+    t.timestamps null: true
+  end
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :category
+end
+
+class Category < ActiveRecord::Base
+end
+
+module ActiveRecord
+  class Base
+    def self.reset_pk_sequence
+      case ActiveRecord::Base.connection.adapter_name
+      when 'SQLite'
+        new_max = maximum(primary_key) || 0
+        update_seq_sql = "update sqlite_sequence set seq = #{new_max} where name = '#{table_name}';"
+        ActiveRecord::Base.connection.execute(update_seq_sql)
+      when 'PostgreSQL'
+        ActiveRecord::Base.connection.reset_pk_sequence!(table_name)
+      else
+        raise 'Task not implemented for this DB adapter'
+      end
+    end
+  end
+end

data/spec/spec_helper_data_mapper.rb

@@ -0,0 +1,35 @@
+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/spec_helper_sequel.rb

@@ -0,0 +1,32 @@
+require_relative 'spec_helper'
+require_relative 'support/paging_shared_example'
+require_relative 'support/sorting_shared_example'
+require 'sequel'
+Sequel::Model.plugin :timestamps
+DB = Sequel.sqlite
+
+DB.create_table :s_products do
+  primary_key :id
+  String :name
+  String :slug
+  Integer :s_category_id
+  Integer :price
+  DateTime :created_at
+  DateTime :updated_at
+end
+
+DB.create_table :s_categories do
+  primary_key :id
+  String :title
+  String :slug
+  DateTime :created_at
+  DateTime :updated_at
+end
+
+class SProduct < Sequel::Model
+  many_to_one :s_category
+end
+
+class SCategory < Sequel::Model
+  one_to_many :s_product
+end

data/spec/support/paging_shared_example.rb

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,95 @@
+shared_examples_for 'a sorting feature' do
+  describe '#sort?' do
+    it 'matches the sort option' 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' do
+      finder = finder_with_sort 'price desc'
+
+      expect(finder).to be_sort 'price'
+      expect(finder).not_to be_sort 'name'
+    end
+
+    it 'matches exact strings' do
+      finder = finder_with_sort 'price desc'
+
+      expect(finder).to be_sort 'price desc'
+      expect(finder).not_to be_sort 'price asc'
+    end
+  end
+
+  describe '#sort_attribute' do
+    it 'returns sort option attribute' do
+      finder = finder_with_sort 'price desc'
+      expect(finder.sort_attribute).to eq 'price'
+    end
+
+    it 'defaults to the first sort by option' do
+      finder = finder_with_sort
+      expect(finder.sort_attribute).to eq 'name'
+    end
+
+    it 'rejects invalid sort options, uses defaults' do
+      finder = finder_with_sort 'invalid'
+      expect(finder.sort_attribute).to eq 'name'
+    end
+  end
+
+  describe '#sort_direction' do
+    it 'returns asc or desc' do
+      expect(finder_with_sort('price desc').sort_direction).to eq 'desc'
+      expect(finder_with_sort('price asc').sort_direction).to eq 'asc'
+    end
+
+    it 'defaults to desc' do
+      expect(finder_with_sort.sort_direction).to eq 'desc'
+      expect(finder_with_sort('price').sort_direction).to eq 'desc'
+    end
+
+    it 'rejects invalid sort options, uses desc' do
+      expect(finder_with_sort('price foo').sort_direction).to eq '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 'asc'
+    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 'desc'
+    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 'reverses sort direction if this is the current sort attribute' do
+      finder = finder_with_sort 'name desc', name: 'test'
+      expect(finder.sort_params_for(:name)).to eq 'sort' => 'name 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 '#reverted_sort_direction' do
+    it 'reverts sorting direction' do
+      expect(finder_with_sort('price desc').reverted_sort_direction).to eq 'asc'
+      expect(finder_with_sort('price asc').reverted_sort_direction).to eq 'desc'
+    end
+  end
+end