Feature/null sorting

.ruby-version

@@ -1 +1 @@
-2.4.1
+2.4.9

.travis.yml

@@ -1,7 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.1
+  - 2.4.9
 before_install:
   - gem install bundler -v 1.15.4
   - export TZ=America/New_York

CHANGELOG

@@ -1,3 +1,61 @@
+v 0.9.2
+  - allow for form-friendly filter parameters
+    ```
+      {
+        '0': {
+          attribute: :foo,
+          operator: :EQ,
+          query: 'query'
+        },
+        '1': {
+          attribute: :bar,
+          operator: :GT,
+          query: 'value'
+        }
+      }
+
+      { foo: 'query', bar(GT): 'value' }
+    ```
+  - allow for form-friendly sort parameters
+    ```
+      {
+        '0': {
+          attribute: :foo,
+          direction: :desc
+        },
+        '1': {
+          attribute: :bar,
+          direction: :asc
+        }
+      }
+
+      { foo: 'desc', bar: 'asc' }
+    ```
+
+v 0.9.1
+  - ensure that our RubyGems build is stable, since we had a TravisCI build problem in the last version
+v 0.9.0
+  - Add Enumerable support for the base filtering operations
+    + EQ, NOT_EQ, EQ_ANY, EQ_ALL, NOT_EQ_ANY, NOT_EQ_ALL
+    + IN, NOT_IN, IN_ANY, IN_ALL, NOT_IN_ANY, NOT_IN_ALL
+    + MATCHES, DOES_NOT_MATCH, MATCHES_ANY, MATCHES_ALL, DOES_NOT_MATCH_ANY, DOES_NOT_MATCH_ALL
+    + LT, LTEQ, LT_ANY, LT_ALL, LTEQ_ANY, LTEQ_ALL
+    + GT, GTEQ, GT_ANY, GT_ALL, GTEQ_ANY, GTEQ_ALL
+    + BETWEEN, NOT_BETWEEN
+  - Add unary predicate filtering operators, for both ActiveRecord and Enumerable
+    + IS_TRUE, IS_FALSE
+    + IS_NULL, NOT_NULL
+    + IS_PRESENT, IS_BLANK
+  - Add computed matcher filtering operators, for both ActiveRecord and Enumerable
+    + MATCH_START, MATCH_START_ANY, MATCH_START_ALL, MATCH_NOT_START, MATCH_NOT_START_ANY, MATCH_NOT_START_ALL
+    + MATCH_END, MATCH_END_ANY, MATCH_END_ALL, MATCH_NOT_END, MATCH_NOT_END_ANY, MATCH_NOT_END_ALL
+    + MATCH_CONTAIN, MATCH_CONTAIN_ANY, MATCH_CONTAIN_ALL, MATCH_NOT_CONTAIN, MATCH_NOT_CONTAIN_ANY, MATCH_NOT_CONTAIN_ALL
+  - Add view helpers for the range of records shown on the current page
+  - Use ActiveRecord's data dictionary to look up database column types when converting filter params to filter instructions
+  - Allow app to define type hints for filter attributes when converting filter params to filter instructions
+  - Allow sort params to be passed in short or long form
+    + e.g. { attribute: x, direction: x } or { attribute: direction }
+  - Fix enumerable intersection filtering when working across associations
 v 0.8.2
   - add `ActiveSet.configuration.on_asc_sort_nils_come` configuration
 v 0.8.1

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    actionset (0.8.2)
+    actionset (0.9.2)
       activesupport (>= 4.0.2)
       railties
 

Rakefile

@@ -5,4 +5,11 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+task :full_spec do
+  ENV['COVERAGE'] = 'true'
+  ENV['INSPECT_FAILURE'] = 'true'
+  ENV['LOGICALLY_EXHAUSTIVE_REQUEST_SPECS'] = 'true'
+  Rake::Task['spec'].invoke
+end
+
+task default: :full_spec

actionset.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.name          = 'actionset'
-  spec.version       = '0.8.2'
+  spec.version       = '0.9.2'
   spec.authors       = ['Stephen Margheim']
   spec.email         = ['stephen.margheim@gmail.com']
 

lib/action_set.rb

@@ -5,7 +5,8 @@
 require 'active_support/lazy_load_hooks'
 require 'active_set'
 
-require_relative './action_set/attribute_value'
+require_relative './action_set/filter_instructions'
+require_relative './action_set/sort_instructions'
 require_relative './action_set/helpers/helper_methods'
 
 module ActionSet
@@ -24,13 +25,13 @@ def process_set(set)
 
     def filter_set(set)
       active_set = ensure_active_set(set)
-      active_set = active_set.filter(filter_instructions_for(set)) if filter_params.any?
+      active_set = active_set.filter(FilterInstructions.new(filter_params, set, self).get) if filter_params.any?
       active_set
     end
 
     def sort_set(set)
       active_set = ensure_active_set(set)
-      active_set = active_set.sort(sort_params) if sort_params.any?
+      active_set = active_set.sort(SortInstructions.new(sort_params, set, self).get) if sort_params.any?
       active_set
     end
 
@@ -52,30 +53,11 @@ def export_set(set)
 
     private
 
-    def filter_instructions_for(set)
-      flatten_keys_of(filter_params).reject { |_, v| v.try(:empty?) }.each_with_object({}) do |(keypath, value), memo|
-        typecast_value = if value.respond_to?(:each)
-                           value.map { |v| filter_typecasted_value_for(keypath, v, set) }
-                         else
-                           filter_typecasted_value_for(keypath, value, set)
-                         end
-
-        memo[keypath] = typecast_value
-      end
-    end
-
-    def filter_typecasted_value_for(keypath, value, set)
-      instruction = ActiveSet::AttributeInstruction.new(keypath, value)
-      item_with_value = set.find { |i| !instruction.value_for(item: i).nil? }
-      item_value = instruction.value_for(item: item_with_value)
-      ActionSet::AttributeValue.new(value)
-                               .cast(to: item_value.class)
-    end
-
     def paginate_instructions
       paginate_params.transform_values(&:to_i)
     end
 
+    # rubocop:disable Metrics/AbcSize
     def export_instructions
       {}.tap do |struct|
         struct[:format] = export_params[:format] || request.format.symbol
@@ -93,10 +75,13 @@ def export_instructions
                            elsif respond_to?(:export_set_columns, true)
                              send(:export_set_columns)
                            else
+                             # :nocov:
                              [{}]
+                             # :nocov:
                            end
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def filter_params
       params.fetch(:filter, {}).to_unsafe_hash

lib/action_set/attribute_value.rb

@@ -11,7 +11,7 @@ def initialize(value)
     def cast(to:)
       adapters.reduce(nil) do |_, adapter|
         mayble_value_or_nil = adapter.new(@raw, to).process
-        next if mayble_value_or_nil.nil?
+        next nil if mayble_value_or_nil.nil?
 
         return mayble_value_or_nil
       end
@@ -62,7 +62,9 @@ class ActiveModelAdapter
       begin
         require 'active_model/type'
       rescue LoadError
+        # :nocov:
         require 'active_record/type'
+        # :nocov:
       end
 
       def initialize(raw, target)
@@ -106,13 +108,17 @@ def can_typecast?(const_name)
       def init_typecaster(const_name)
         type_class.const_get(const_name).new
       rescue StandardError
+        # :nocov:
         nil
+        # :nocov:
       end
 
       def type_class
         ActiveModel::Type
       rescue NameError
+        # :nocov:
         ActiveRecord::Type
+        # :nocov:
       end
     end
 

lib/action_set/filter_instructions.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative './attribute_value'
+
+module ActionSet
+  class FilterInstructions
+    def initialize(params, set, controller)
+      @params = params
+      @set = set
+      @controller = controller
+    end
+
+    def get
+      instructions_hash = if form_friendly_complex_params?
+                            form_friendly_complex_params_to_hash
+                          elsif form_friendly_simple_params?
+                            form_friendly_simple_params_to_hash
+                          else
+                            @params
+                          end
+      flattened_instructions = flatten_keys_of(instructions_hash).reject { |_, v| v.try(:empty?) }
+      flattened_instructions.each_with_object({}) do |(keypath, value), memo|
+        memo[keypath] = if value.respond_to?(:map)
+                          value.map { |v| AttributeValue.new(v).cast(to: klass_for_keypath(keypath, v, @set)) }
+                        else
+                          AttributeValue.new(value).cast(to: klass_for_keypath(keypath, value, @set))
+                        end
+      end
+    end
+
+    private
+
+    def form_friendly_complex_params?
+      @params.key?(:'0')
+    end
+
+    def form_friendly_simple_params?
+      @params.key?(:attribute) &&
+        @params.key?(:operator) &&
+        @params.key?(:query)
+    end
+
+    def form_friendly_complex_params_to_hash
+      ordered_instructions = @params.sort_by(&:first)
+      array_of_instructions = ordered_instructions.map { |_, h| ["#{h[:attribute]}(#{h[:operator]})", h[:query]] }
+      Hash[array_of_instructions]
+    end
+
+    def form_friendly_simple_params_to_hash
+      { "#{@params[:attribute]}(#{@params[:operator]})" => @params[:query] }
+    end
+
+    def klass_for_keypath(keypath, value, set)
+      if @controller.respond_to?(:filter_set_types, true)
+        type_declarations = @controller.public_send(:filter_set_types)
+        types = type_declarations['types'] || type_declarations[:types]
+        klass = types[keypath.join('.')]
+        return klass if klass
+      end
+
+      if set.is_a?(ActiveRecord::Relation) || set.view.is_a?(ActiveRecord::Relation)
+        klass_type = set.model.columns_hash.fetch(keypath, nil)&.type
+        return klass_type.class if klass_type
+      end
+
+      instruction = ActiveSet::AttributeInstruction.new(keypath, value)
+      item_with_value = set.find { |i| !instruction.value_for(item: i).nil? }
+      item_value = instruction.value_for(item: item_with_value)
+      item_value.class
+    end
+  end
+end

lib/action_set/helpers/helper_methods.rb

@@ -2,7 +2,7 @@
 
 require_relative './sort/link_for_helper'
 require_relative './pagination/links_for_helper'
-require_relative './pagination/path_for_helper'
+require_relative './pagination/record_description_for_helper'
 require_relative './params/form_for_object_helper'
 require_relative './export/path_for_helper'
 
@@ -11,6 +11,7 @@ module Helpers
     module HelperMethods
       include Sort::LinkForHelper
       include Pagination::LinksForHelper
+      include Pagination::RecordDescriptionForHelper
       include Params::FormForObjectHelper
       include Export::PathForHelper
     end

lib/action_set/helpers/pagination/record_description_for_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative './record_range_for_helper'
+require_relative './record_size_for_helper'
+
+module Pagination
+  module RecordDescriptionForHelper
+    include Pagination::RecordRangeForHelper
+    include Pagination::RecordSizeForHelper
+
+    def pagination_record_description_for(set)
+      [
+        pagination_record_range_for(set),
+        'of',
+        "<strong>#{pagination_record_size_for(set)}</strong>",
+        'records'
+      ].join('&nbsp;').html_safe
+    end
+  end
+end

lib/action_set/helpers/pagination/record_first_for_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative './current_page_for_helper'
+require_relative './page_size_for_helper'
+
+module Pagination
+  module RecordFirstForHelper
+    include Pagination::CurrentPageForHelper
+    include Pagination::PageSizeForHelper
+
+    def pagination_record_first_for(set)
+      current_page = pagination_current_page_for(set)
+      page_size = pagination_page_size_for(set)
+
+      return 1 if current_page == 1
+
+      ((current_page - 1) * page_size) + 1
+    end
+  end
+end

lib/action_set/helpers/pagination/record_last_for_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative './current_page_for_helper'
+require_relative './record_size_for_helper'
+require_relative './page_size_for_helper'
+require_relative './total_pages_for_helper'
+
+module Pagination
+  module RecordLastForHelper
+    include Pagination::RecordSizeForHelper
+    include Pagination::CurrentPageForHelper
+    include Pagination::PageSizeForHelper
+    include Pagination::TotalPagesForHelper
+
+    def pagination_record_last_for(set)
+      record_size = pagination_record_size_for(set)
+      current_page = pagination_current_page_for(set)
+      page_size = pagination_page_size_for(set)
+      total_pages = pagination_total_pages_for(set)
+
+      return record_size if current_page >= total_pages
+
+      current_page * page_size
+    end
+  end
+end

lib/action_set/helpers/pagination/record_range_for_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative './record_first_for_helper'
+require_relative './record_last_for_helper'
+
+module Pagination
+  module RecordRangeForHelper
+    include Pagination::CurrentPageForHelper
+    include Pagination::TotalPagesForHelper
+    include Pagination::RecordFirstForHelper
+    include Pagination::RecordLastForHelper
+
+    def pagination_record_range_for(set)
+      current_page = pagination_current_page_for(set)
+      total_pages = pagination_total_pages_for(set)
+      return 'None' if current_page > total_pages
+
+      [
+        pagination_record_first_for(set),
+        '–',
+        pagination_record_last_for(set)
+      ].join(' ').html_safe
+    end
+  end
+end