actionset 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4c9246a4316813c78ee58c47708a977b5811c2c
-  data.tar.gz: d6f45a1104daad185b971f7e9a4ac47abc698432
+  metadata.gz: 2d8befffeaabf8526df7cdd15f501f2e9e99732b
+  data.tar.gz: 9dc431b8b1af60ed1d6d57d8ba9e66ac6e6a0688
 SHA512:
-  metadata.gz: df2cc22b86dfc5bc3579bd9f84964844920afe47a3906ed31ed150f297e1eea0c9feecfdd0767c9c8e3dcec03e82d721ab1a5cd4a3a98833ea94b7f956cce03f
-  data.tar.gz: 9851ffa5d0e416ed93af12ae5a939fbbbe60b49a4670386e085af9a9d9c38f8d7bd313125d04710c891b3c950e296de1940e2f7c6137976f069669ef58a9bf0c
+  metadata.gz: 076e19f851950c2a0c2ac377c51a04eaf16198060ce8a1e6a766339f659c61eab1ae125c34005db809b27b0b0c02aad85e9ad1502f13c11ad04a821be6d40d0d
+  data.tar.gz: c2de49f8fb3a36ecf86dfc00c51a880b675ea8f7db129de84a0eace0565c9175528cd53fcf25096ff04151c727189ce09c53ac54b50221df20784e8ba8e52270

data/CHANGELOG

@@ -1,3 +1,20 @@
+v 0.8.1
+  - add a case-insensitive filtering/sorting option (`/i/`)
+  - standardize how filtering by class scopes behaves
+    + only collection-returning class methods are handled
+    + scopes defined on computed associations aren't handled
+  - refactor parts of the strategy implemention layer
+    + create generalize "set instruction" classes for ActiveRecord and Enumerable strategies
+    + handle default operators in the strategy layer, not the instruction layer
+  - refactor parts of the instruction implementation layer
+    + memoize instruction getters to avoid recomputing on access
+  - refactor specs
+    + update filtering by data types when using an invalid field test
+    + remove case-insensitive sorting example
+    + simplify the sorted collection expectation
+    + add some helper methods for generating unique factory data
+    + print a detailed report of the state data on spec failure
+    + update the filtering request specs to run more of then, but still running random subsets
 v 0.8.0
   - merge ActiveSet and ActionSet into a monorepo
   - merge and overhaul the specs

data/Gemfile.lock

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

data/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.0'
+  spec.version       = '0.8.1'
   spec.authors       = ['Stephen Margheim']
   spec.email         = ['stephen.margheim@gmail.com']
 

data/lib/action_set/helpers/pagination/current_page_description_for_helper.rb

@@ -9,7 +9,12 @@ module Pagination
     include Pagination::TotalPagesForHelper
 
     def pagination_current_page_description_for(set)
-      description = "Page&nbsp;<strong>#{pagination_current_page_for(set)}</strong>&nbsp;of&nbsp;<strong>#{pagination_total_pages_for(set)}</strong>".html_safe
+      description = [
+        'Page',
+        "<strong>#{pagination_current_page_for(set)}</strong>",
+        'of',
+        "<strong>#{pagination_total_pages_for(set)}</strong>"
+      ].join('&nbsp;').html_safe
 
       content_tag(:span,
                   description,

data/lib/action_set/helpers/pagination/total_pages_for_helper.rb

@@ -8,7 +8,7 @@ module Pagination
 
     def pagination_total_pages_for(set)
       total_set_size = set.instructions.dig(:paginate, :count)
-      return 1 if total_set_size == 0
+      return 1 if total_set_size.zero?
 
       (total_set_size.to_f / pagination_page_size_for(set)).ceil
     end

data/lib/active_set/active_record_set_instruction.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  class ActiveRecordSetInstruction < SimpleDelegator
+    def initialize(attribute_instruction, set)
+      @attribute_instruction = attribute_instruction
+      @set = set
+      super(@attribute_instruction)
+    end
+
+    def initial_relation
+      return @set if @attribute_instruction.associations_array.empty?
+
+      @set.eager_load(@attribute_instruction.associations_hash)
+    end
+
+    def arel_type
+      attribute_model
+        .columns_hash[@attribute_instruction.attribute]
+        .type
+    end
+
+    def arel_table
+      # This is to work around an bug in ActiveRecord,
+      # where BINARY fields aren't found properly when using
+      # the `arel_table` class method to build an ARel::Node
+      if arel_type == :binary
+        Arel::Table.new(attribute_model.table_name)
+      else
+        attribute_model.arel_table
+      end
+    end
+
+    def arel_column
+      _arel_column = arel_table[@attribute_instruction.attribute]
+      return _arel_column.lower if case_insensitive_operation?
+
+      _arel_column
+    end
+
+    def arel_operator
+      @attribute_instruction.operator(default: :eq)
+    end
+
+    def arel_value
+      _arel_value = @attribute_instruction.value
+      return _arel_value.downcase if case_insensitive_operation?
+
+      _arel_value
+    end
+
+    def case_insensitive_operation?
+      @attribute_instruction.case_insensitive? && arel_type.presence_in(%i[string text])
+    end
+
+    def attribute_model
+      return @set.klass if @attribute_instruction.associations_array.empty?
+      return @attribute_model if defined? @attribute_model
+
+      @attribute_model = @attribute_instruction
+                         .associations_array
+                         .reduce(@set) do |obj, assoc|
+        obj.reflections[assoc.to_s]&.klass
+      end
+    end
+  end
+end

data/lib/active_set/attribute_instruction.rb

@@ -17,36 +17,56 @@ class ActiveSet
       @processed
     end
 
+    def case_insensitive?
+      return false unless options
+
+      options.include? :i
+    end
+
     def attribute
-      attribute = @keypath.last
-      return attribute.sub(operator_regex, '') if attribute&.match operator_regex
+      return @attribute if defined? @attribute
 
-      attribute
+      attribute = @keypath.last
+      attribute = attribute&.sub(operator_regex, '')
+      attribute = attribute&.sub(options_regex, '')
+      @attribute = attribute
     end
 
     def operator(default: '==')
-      attribute = @keypath.last
-      return attribute[operator_regex, 1] if attribute&.match operator_regex
+      return @operator if defined? @operator
+
+      attribute_instruction = @keypath.last
+      @operator = (attribute_instruction[operator_regex, 1] || default).to_sym
+    end
+
+    def options
+      return @options if defined? @options
 
-      default
+      @options = @keypath.last[options_regex, 1]&.split('')&.map(&:to_sym)
     end
 
     def associations_array
+      return @associations_array if defined? @associations_array
       return [] unless @keypath.any?
 
-      @keypath.slice(0, @keypath.length - 1)
+      @associations_array = @keypath.slice(0, @keypath.length - 1)
     end
 
     def associations_hash
+      return @associations_hash if defined? @associations_hash
       return {} unless @keypath.any?
 
-      associations_array.reverse.reduce({}) do |hash, association|
+      @associations_hash = associations_array.reverse.reduce({}) do |hash, association|
         { association => hash }
       end
     end
 
     def value_for(item:)
-      resource_for(item: item).public_send(attribute)
+      @values_for ||= Hash.new do |h, key|
+        h[key] = resource_for(item: key).public_send(attribute)
+      end
+
+      @values_for[item]
     rescue StandardError
       # :nocov:
       nil
@@ -54,11 +74,15 @@ class ActiveSet
     end
 
     def resource_for(item:)
-      associations_array.reduce(item) do |resource, association|
-        return nil unless resource.respond_to? association
+      @resources_for ||= Hash.new do |h, key|
+        h[key] = associations_array.reduce(key) do |resource, association|
+          break nil unless resource.respond_to? association
 
-        resource.public_send(association)
+          resource.public_send(association)
+        end
       end
+
+      @resources_for[item]
     rescue StandardError
       # :nocov:
       nil
@@ -68,7 +92,11 @@ class ActiveSet
     private
 
     def operator_regex
-      /\((.*?)\)/
+      %r{\((.*?)\)}
+    end
+
+    def options_regex
+      %r{\/(.*?)\/}
     end
   end
 end

data/lib/active_set/enumerable_set_instruction.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  class EnumerableSetInstruction < SimpleDelegator
+    def initialize(attribute_instruction, set)
+      @attribute_instruction = attribute_instruction
+      @set = set
+      super(@attribute_instruction)
+    end
+
+    def attribute_value_for(item)
+      item_value = @attribute_instruction
+                    .value_for(item: item)
+      item_value = item_value.downcase if case_insensitive_operation_for?(item_value)
+      item_value
+    end
+
+    def attribute_value
+      _attribute_value = @attribute_instruction.value
+      _attribute_value = _attribute_value.downcase if case_insensitive_operation_for?(_attribute_value)
+      _attribute_value
+    end
+
+    def case_insensitive_operation_for?(value)
+      return false unless @attribute_instruction.case_insensitive?
+
+      value.is_a?(String) || value.is_a?(Symbol)
+    end
+
+    def attribute_instance
+      set_item = @set.find(&:present?)
+      return set_item if @attribute_instruction.associations_array.empty?
+      return @attribute_model if defined? @attribute_model
+
+      @attribute_model = @attribute_instruction
+                         .associations_array
+                         .reduce(set_item) do |obj, assoc|
+        obj.public_send(assoc)
+      end
+    end
+
+    def attribute_class
+      attribute_instance&.class
+    end
+  end
+end

data/lib/active_set/filtering/active_record_strategy.rb

@@ -1,21 +1,34 @@
 # frozen_string_literal: true
 
+require_relative '../active_record_set_instruction'
+require 'active_support/core_ext/module/delegation'
+
 class ActiveSet
   module Filtering
     class ActiveRecordStrategy
+      delegate :attribute_model,
+               :arel_column,
+               :arel_operator,
+               :arel_value,
+               :arel_type,
+               :initial_relation,
+               :attribute,
+               to: :@set_instruction
+
       def initialize(set, attribute_instruction)
         @set = set
         @attribute_instruction = attribute_instruction
+        @set_instruction = ActiveRecordSetInstruction.new(attribute_instruction, set)
       end
 
       def execute
         return false unless @set.respond_to? :to_sql
 
-        if execute_where_operation?
-          statement = where_operation
-        elsif execute_merge_operation?
+        if execute_filter_operation?
+          statement = filter_operation
+        elsif execute_intersect_operation?
           begin
-            statement = merge_operation
+            statement = intersect_operation
           rescue ArgumentError # thrown if merging a non-ActiveRecord::Relation
             return false
           end
@@ -28,71 +41,45 @@ class ActiveSet
 
       private
 
-      def execute_where_operation?
+      def execute_filter_operation?
         return false unless attribute_model
         return false unless attribute_model.respond_to?(:attribute_names)
-        return false unless attribute_model.attribute_names.include?(@attribute_instruction.attribute)
+        return false unless attribute_model.attribute_names.include?(attribute)
 
         true
       end
 
-      def execute_merge_operation?
+      def execute_intersect_operation?
         return false unless attribute_model
-        return false unless attribute_model.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_model.method(@attribute_instruction.attribute).arity.zero?
+        return false unless attribute_model.respond_to?(attribute)
+        return false if attribute_model.method(attribute).arity.zero?
 
         true
       end
 
-      def where_operation
+      def filter_operation
         initial_relation
           .where(
             arel_column.send(
-              @attribute_instruction.operator(default: 'eq'),
-              @attribute_instruction.value
+              arel_operator,
+              arel_value
             )
           )
       end
 
-      def merge_operation
+      def intersect_operation
+        # NOTE: If merging relations that contain duplicate column conditions,
+        # the second condition will replace the first.
+        # e.g. Thing.where(id: [1,2]).merge(Thing.where(id: [2,3]))
+        # => [Thing<2>, Thing<3>] NOT [Thing<2>]
         initial_relation
           .merge(
             attribute_model.public_send(
-              @attribute_instruction.attribute,
-              @attribute_instruction.value
+              attribute,
+              arel_value
             )
           )
       end
-
-      def initial_relation
-        return @set if @attribute_instruction.associations_array.empty?
-
-        @set.eager_load(@attribute_instruction.associations_hash)
-      end
-
-      def arel_column
-        attribute_type = attribute_model.columns_hash[@attribute_instruction.attribute].type
-
-        # This is to work around an bug in ActiveRecord,
-        # where BINARY fields aren't found properly when using the `arel_table` class method
-        # to build an ARel::Node
-        if attribute_type == :binary
-          Arel::Table.new(attribute_model.table_name)[@attribute_instruction.attribute]
-        else
-          attribute_model.arel_table[@attribute_instruction.attribute]
-        end
-      end
-
-      def attribute_model
-        return @set.klass if @attribute_instruction.associations_array.empty?
-        return @attribute_model if defined? @attribute_model
-
-        @attribute_model = @attribute_instruction
-                           .associations_array
-                           .reduce(@set) do |obj, assoc|
-          obj.reflections[assoc.to_s]&.klass
-        end
-      end
     end
   end
 end

data/lib/active_set/filtering/enumerable_strategy.rb

@@ -1,77 +1,78 @@
 # frozen_string_literal: true
 
+require_relative '../enumerable_set_instruction'
+require 'active_support/core_ext/module/delegation'
+
 class ActiveSet
   module Filtering
     class EnumerableStrategy
+      delegate :attribute_instance,
+               :attribute_class,
+               :attribute_value,
+               :attribute_value_for,
+               :operator,
+               :attribute,
+               to: :@set_instruction
+
       def initialize(set, attribute_instruction)
         @set = set
         @attribute_instruction = attribute_instruction
+        @set_instruction = EnumerableSetInstruction.new(attribute_instruction, set)
       end
 
       def execute
         return false unless @set.respond_to? :select
 
-        @set.select do |item|
-          next attribute_matches_for?(item) if can_match_attribute_for?(item)
-          next class_method_matches_for?(item) if can_match_class_method_for?(item)
-
-          false
+        if execute_filter_operation?
+          set = filter_operation
+        elsif execute_intersect_operation?
+          begin
+            set = intersect_operation
+          rescue TypeError # thrown if intersecting with a non-Array
+            return false
+          end
+        else
+          return false
         end
+
+        set
       end
 
       private
 
-      def can_match_attribute_for?(item)
-        attribute_item = attribute_item_for(item)
-
-        return false unless attribute_item
-        return false unless attribute_item.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_item.method(@attribute_instruction.attribute).arity.positive?
+      def execute_filter_operation?
+        return false unless attribute_instance
+        return false unless attribute_instance.respond_to?(attribute)
+        return false if attribute_instance.method(attribute).arity.positive?
 
         true
       end
 
-      def can_match_class_method_for?(item)
-        attribute_item = attribute_item_for(item)
-
-        return false unless attribute_item
-        return false unless attribute_item.class
-        return false unless attribute_item.class.respond_to?(@attribute_instruction.attribute)
-        return false if attribute_item.class.method(@attribute_instruction.attribute).arity.zero?
+      def execute_intersect_operation?
+        return false unless attribute_class
+        return false unless attribute_class.respond_to?(attribute)
+        return false if attribute_class.method(attribute).arity.zero?
 
         true
       end
 
-      def attribute_matches_for?(item)
-        @attribute_instruction
-          .value_for(item: item)
-          .public_send(
-            @attribute_instruction.operator,
-            @attribute_instruction.value
-          )
-      end
-
-      # rubocop:disable Metrics/MethodLength
-      def class_method_matches_for?(item)
-        maybe_item_or_collection_or_nil = attribute_item_for(item)
-                                          .class
-                                          .public_send(
-                                            @attribute_instruction.attribute,
-                                            @attribute_instruction.value
-                                          )
-        if maybe_item_or_collection_or_nil.nil?
-          false
-        elsif maybe_item_or_collection_or_nil.respond_to?(:each)
-          maybe_item_or_collection_or_nil.include? attribute_item_for(item)
-        else
-          maybe_item_or_collection_or_nil == attribute_item_for(item)
+      def filter_operation
+        @set.select do |item|
+          attribute_value_for(item)
+            .public_send(
+              operator,
+              attribute_value
+            )
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
-      def attribute_item_for(item)
-        @attribute_instruction
-          .resource_for(item: item)
+      def intersect_operation
+        other_set = attribute_class
+                    .public_send(
+                      attribute,
+                      attribute_value
+                    )
+        @set & other_set
       end
     end
   end

data/lib/active_set/sorting/active_record_strategy.rb

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
+require_relative '../active_record_set_instruction'
+
 class ActiveSet
   module Sorting
     class ActiveRecordStrategy
       def initialize(set, attribute_instructions)
         @set = set
         @attribute_instructions = attribute_instructions
+        @set_instructions = attribute_instructions.map do |attribute_instruction|
+          ActiveRecordSetInstruction.new(attribute_instruction, set)
+        end
       end
 
       def execute
         return false unless @set.respond_to? :to_sql
 
-        executable_instructions.reduce(set_with_eager_loaded_associations) do |set, attribute_instruction|
-          statement = set.merge(order_operation_for(attribute_instruction))
-
-          return false if throws?(ActiveRecord::StatementInvalid) { statement.load }
+        executable_instructions.reduce(@set) do |set, set_instruction|
+          statement = set.merge(set_instruction.initial_relation)
+          statement = statement.merge(order_operation_for(set_instruction))
 
-          attribute_instruction.processed = true
+          set_instruction.processed = true
           statement
         end
       end
@@ -24,11 +28,11 @@ class ActiveSet
       def executable_instructions
         return {} unless @set.respond_to? :to_sql
 
-        @attribute_instructions.select do |attribute_instruction|
-          attribute_model = attribute_model_for(attribute_instruction)
+        @set_instructions.select do |set_instruction|
+          attribute_model = set_instruction.attribute_model
           next false unless attribute_model
           next false unless attribute_model.respond_to?(:attribute_names)
-          next false unless attribute_model.attribute_names.include?(attribute_instruction.attribute)
+          next false unless attribute_model.attribute_names.include?(set_instruction.attribute)
 
           true
         end
@@ -36,40 +40,20 @@ class ActiveSet
 
       private
 
-      def set_with_eager_loaded_associations
-        associations_hash = @attribute_instructions.reduce({}) { |h, i| h.merge(i.associations_hash) }
-        @set.eager_load(associations_hash)
-      end
-
       # https://stackoverflow.com/a/44912964/2884386
       # Force null values to be sorted as if larger than any non-null value
       # ASC => [-2, -1, 1, 2, nil]
       # DESC => [nil, 2, 1, -1, -2]
-      def order_operation_for(attribute_instruction)
-        attribute_model = attribute_model_for(attribute_instruction)
+      def order_operation_for(set_instruction)
+        attribute_model = set_instruction.attribute_model
 
-        arel_column = Arel::Table.new(attribute_model.table_name)[attribute_instruction.attribute]
-        arel_column = case_insensitive?(attribute_instruction) ? arel_column.lower : arel_column
-        arel_direction = direction_operator(attribute_instruction.value)
+        arel_column = set_instruction.arel_column
+        arel_direction = direction_operator(set_instruction.value)
         nil_sorter = arel_column.send(arel_direction == :asc ? :eq : :not_eq, nil)
 
         attribute_model.order(nil_sorter).order(arel_column.send(arel_direction))
       end
 
-      def attribute_model_for(attribute_instruction)
-        return @set.klass if attribute_instruction.associations_array.empty?
-
-        attribute_instruction
-          .associations_array
-          .reduce(@set) do |obj, assoc|
-            obj.reflections[assoc.to_s]&.klass
-          end
-      end
-
-      def case_insensitive?(attribute_instruction)
-        attribute_instruction.operator.to_s.casecmp('i').zero?
-      end
-
       def direction_operator(direction)
         return :desc if direction.to_s.downcase.start_with? 'desc'
 

data/lib/active_set/sorting/enumerable_strategy.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../helpers/transform_to_sortable_numeric'
+require_relative '../enumerable_set_instruction'
 
 class ActiveSet
   module Sorting
@@ -8,14 +9,17 @@ class ActiveSet
       def initialize(set, attribute_instructions)
         @set = set
         @attribute_instructions = attribute_instructions
+        @set_instructions = attribute_instructions.map do |attribute_instruction|
+          EnumerableSetInstruction.new(attribute_instruction, set)
+        end
       end
 
       def execute
         # http://brandon.dimcheff.com/2009/11/18/rubys-sort-vs-sort-by/
         @set.sort_by do |item|
-          @attribute_instructions.map do |instruction|
-            value_for_comparison = sortable_numeric_for(instruction, item)
-            direction_multiplier = direction_multiplier(instruction.value)
+          @set_instructions.map do |set_instruction|
+            value_for_comparison = sortable_numeric_for(set_instruction, item)
+            direction_multiplier = direction_multiplier(set_instruction.value)
 
             # Force null values to be sorted as if larger than any non-null value
             # ASC => [-2, -1, 1, 2, nil]
@@ -29,23 +33,12 @@ class ActiveSet
         end
       end
 
-      def sortable_numeric_for(instruction, item)
-        value = instruction.value_for(item: item)
-        if value.is_a?(String) || value.is_a?(Symbol)
-          value = if case_insensitive?(instruction, value)
-                    value.to_s.downcase
-                  else
-                    value.to_s
-                  end
-        end
+      def sortable_numeric_for(set_instruction, item)
+        value = set_instruction.attribute_value_for(item)
 
         transform_to_sortable_numeric(value)
       end
 
-      def case_insensitive?(instruction, _value)
-        instruction.operator.to_s.casecmp('i').zero?
-      end
-
       def direction_multiplier(direction)
         return -1 if direction.to_s.downcase.start_with? 'desc'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionset
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2019-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -280,8 +280,10 @@ files:
 - lib/action_set/helpers/sort/next_direction_for_helper.rb
 - lib/action_set/helpers/sort/path_for_helper.rb
 - lib/active_set.rb
+- lib/active_set/active_record_set_instruction.rb
 - lib/active_set/attribute_instruction.rb
 - lib/active_set/column_instruction.rb
+- lib/active_set/enumerable_set_instruction.rb
 - lib/active_set/exporting/csv_strategy.rb
 - lib/active_set/exporting/operation.rb
 - lib/active_set/filtering/active_record_strategy.rb