filterameter 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f711873e7af07c76d8ce2df1c25fee486408b9072f4c7fc4fde29b0fd9cf60e3
-  data.tar.gz: 568e9031173ae41b4a7cf514649c77d182be5cb7188516989f7213f69bd56f71
+  metadata.gz: d8110e021be072bc1f37dd324c42e590e3c91a94fbadd934fdc0758f1f85d700
+  data.tar.gz: 7ee31589a1fb66717647a1085658ab4dd5b9ba7deb58d847102fc72be1d9dffe
 SHA512:
-  metadata.gz: 1b3cd23fed20b0d106ed1348eb6f874a2a883409237631c18e5ae77f3bc0a3a917512a764e3340cbfbbf357fa89053ec355267bc925e2ca8dfe29e507f159b7b
-  data.tar.gz: 910188eaa493a2abadcb44b37c429529f5b8b3921d27f3abf5a2e7bd123b148ec449dc6d84697eb013f34f063a69dc892aebb76c380576fd7b7c81d13eb22706
+  metadata.gz: 83117da59a74ba92bf255cdb8ccd025f071f5549dfeb315af5894c12dc8829928fef6aae0eb6d94eaec7abfd5f2a85aa1d085bd7b3ec26d0b476d0506febd7a4
+  data.tar.gz: 3f777e21518ce18d2f62f36912ba3b532839a9f5d03bc73dd7796648d1fcec81992701b07ad639dbe021f7765ab5d5baa66d4d82bf92edc7264a2463df4044ff

data/README.md

@@ -39,6 +39,24 @@ filter :size, validates: { inclusion: { in: %w[Small Medium Large] }, unless: ->
 
 Note that the `inclusion` validator does not allow arrays to be specified. If the filter should allow multiple values to be specified, then the validation needs to be disabled when the value an array.
 
+#### partial
+Specify the partial option if the filter should do a partial search (SQL's `LIKE`). The partial option accepts a hash to specify the search behavior. Here are the available options:
+- match: anywhere (default), from_start, dynamic
+- case_sensitive: true, false (default)
+
+There are two shortcuts: : the partial option can be declared with `true`, which just uses the defaults; or the partial option can be declared with the match option directly, such as `partial: :from_start`.
+
+```ruby
+filter :description, partial: true
+filter :department_name, partial: :from_start
+filter :reason, partial: { match: :dynamic, case_sensitive: true } 
+```
+
+The `match` options defines where you are searching (which then controls where the wildcard(s) appear):
+- anywhere: adds wildcards at the start and end, for example '%blue%'
+- from_start: adds a wildcard at the end, for example 'blue%'
+- dynamic: adds no wildcards; this enables the client to fully control the search string
+
 ### Configuring Controllers
 
 Rails conventions are used to determine the controller's model as well as the name of the instance variable to apply the filters to. For example, the PhotosController will use the variable `@photos` to store a query against the Photo model. If the conventions do not provide the correct info, they can be overridden with the following two methods:

data/lib/filterameter/filter_declaration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/array/wrap'
+require 'filterameter/options/partial_options'
 
 module Filterameter
   # = Filter Declaration
@@ -17,6 +18,7 @@ module Filterameter
       @association = options[:association]
       @filter_on_empty = options.fetch(:filter_on_empty, false)
       @validations = Array.wrap(options[:validates])
+      @raw_partial_options = options.fetch(:partial, false)
     end
 
     def nested?
@@ -31,10 +33,18 @@ module Filterameter
       @filter_on_empty
     end
 
+    def partial_search?
+      partial_options.present?
+    end
+
+    def partial_options
+      @partial_options ||= @raw_partial_options ? Options::PartialOptions.new(@raw_partial_options) : nil
+    end
+
     private
 
     def validate_options(options)
-      options.assert_valid_keys(:name, :association, :filter_on_empty, :validates)
+      options.assert_valid_keys(:name, :association, :filter_on_empty, :validates, :partial)
     end
   end
 end

data/lib/filterameter/filter_factory.rb

@@ -2,6 +2,7 @@
 
 require 'filterameter/filters/attribute_filter'
 require 'filterameter/filters/conditional_scope_filter'
+require 'filterameter/filters/matches_filter'
 require 'filterameter/filters/nested_filter'
 require 'filterameter/filters/scope_filter'
 
@@ -16,19 +17,21 @@ module Filterameter
 
     def build(declaration)
       model = declaration.nested? ? model_from_association(declaration.association) : @model_class
-      filter = build_filter(model, declaration.name)
+      filter = build_filter(model, declaration)
 
       declaration.nested? ? Filterameter::Filters::NestedFilter.new(declaration.association, model, filter) : filter
     end
 
     private
 
-    def build_filter(model, name)
+    def build_filter(model, declaration)
       # checking dangerous_class_method? excludes any names that cannot be scope names, such as "name"
-      if model.respond_to?(name) && !model.dangerous_class_method?(name)
-        Filterameter::Filters::ScopeFilter.new(name)
+      if model.respond_to?(declaration.name) && !model.dangerous_class_method?(declaration.name)
+        Filterameter::Filters::ScopeFilter.new(declaration.name)
+      elsif declaration.partial_search?
+        Filterameter::Filters::MatchesFilter.new(declaration.name, declaration.partial_options)
       else
-        Filterameter::Filters::AttributeFilter.new(name)
+        Filterameter::Filters::AttributeFilter.new(declaration.name)
       end
     end
 

data/lib/filterameter/filters/matches_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Filters
+    # = Matches Filter
+    #
+    # Class MatchesFilter uses arel's `matches` to generate a LIKE query.
+    class MatchesFilter
+      def initialize(attribute_name, options)
+        @attribute_name = attribute_name
+        @prefix = options.match_anywhere? ? '%' : nil
+        @suffix = options.match_anywhere? || options.match_from_start? ? '%' : nil
+        @case_sensitive = options.case_sensitive?
+      end
+
+      def apply(query, value)
+        arel = query.arel_table[@attribute_name].matches("#{@prefix}#{value}#{@suffix}", false, @case_sensitive)
+        query.where(arel)
+      end
+    end
+  end
+end

data/lib/filterameter/options/partial_options.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Options
+  # = Partial Options
+  #
+  # Class PartialOptions parses the options passed in as partial, then exposes those. Here are the options along with
+  # their valid values:
+  # - match: anywhere (default), from_start, dynamic
+  # - case_sensitive: true, false (default)
+  #
+  # Options may be specified by passing a hash with the option keys:
+  #
+  #   partial: { match: :from_start, case_sensitive: true }
+  #
+  # There are two shortcuts: the partial option can be declared with `true`, which just uses the defaults; or the
+  # partial option can be declared with the match option directly, such as partial: :from_start.
+  class PartialOptions
+    VALID_OPTIONS = %i[match case_sensitive].freeze
+    VALID_MATCH_OPTIONS = %w[anywhere from_start dynamic].freeze
+
+    def initialize(options)
+      @match = 'anywhere'
+      @case_sensitive = false
+
+      if options.is_a?(TrueClass)
+        nil
+      elsif options.is_a? Hash
+        evaluate_hash(options)
+      elsif options.is_a?(String) || options.is_a?(Symbol)
+        assign_match(options)
+      end
+    end
+
+    def case_sensitive?
+      @case_sensitive
+    end
+
+    def match_anywhere?
+      @match == 'anywhere'
+    end
+
+    def match_from_start?
+      @match == 'from_start'
+    end
+
+    def match_dynamically?
+      @match == 'dynamic'
+    end
+
+    private
+
+    def evaluate_hash(options)
+      options.assert_valid_keys(:match, :case_sensitive)
+      assign_match(options[:match]) if options.key?(:match)
+      assign_case_sensitive(options[:case_sensitive]) if options.key?(:case_sensitive)
+    end
+
+    def assign_match(value)
+      validate_match(value)
+      @match = value.to_s
+    end
+
+    def validate_match(value)
+      return if VALID_MATCH_OPTIONS.include? value.to_s
+
+      raise ArgumentError,
+            "Invalid match option for partial: #{value}. Valid options are #{VALID_MATCH_OPTIONS.to_sentence}"
+    end
+
+    def assign_case_sensitive(value)
+      validate_case_sensitive(value)
+      @case_sensitive = value
+    end
+
+    def validate_case_sensitive(value)
+      return if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      raise ArgumentError, "Invalid case_sensitive option for partial: #{value}. Valid options are true and false."
+    end
+  end
+end

data/lib/filterameter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Filterameter
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filterameter
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Todd Kummer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-18 00:00:00.000000000 Z
+date: 2020-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -144,9 +144,11 @@ files:
 - lib/filterameter/filter_factory.rb
 - lib/filterameter/filters/attribute_filter.rb
 - lib/filterameter/filters/conditional_scope_filter.rb
+- lib/filterameter/filters/matches_filter.rb
 - lib/filterameter/filters/nested_filter.rb
 - lib/filterameter/filters/scope_filter.rb
 - lib/filterameter/log_subscriber.rb
+- lib/filterameter/options/partial_options.rb
 - lib/filterameter/parameters_base.rb
 - lib/filterameter/version.rb
 - lib/tasks/filterameter_tasks.rake