actionset 0.7.0 → 0.8.0

data/lib/action_set/helpers/helper_methods.rb

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

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

@@ -21,12 +21,12 @@ module Pagination
                     'aria-label': 'Page navigation'
                   )) do
         safe_join([
-          pagination_first_page_link_for(set),
-          pagination_prev_page_link_for(set),
-          pagination_current_page_description_for(set),
-          pagination_next_page_link_for(set),
-          pagination_last_page_link_for(set)
-        ])
+                    pagination_first_page_link_for(set),
+                    pagination_prev_page_link_for(set),
+                    pagination_current_page_description_for(set),
+                    pagination_next_page_link_for(set),
+                    pagination_last_page_link_for(set)
+                  ])
       end
     end
   end

data/lib/action_set/helpers/sort/next_direction_for_helper.rb

@@ -11,7 +11,6 @@ module Sort
     def next_sort_direction_for(attribute, format: :short)
       direction = current_sort_direction_for(attribute)
 
-      return ascending_str(format) unless direction.presence_in %w[asc desc ascending descending]
       return ascending_str(format) if direction.presence_in %w[desc descending]
       return descending_str(format) if direction.presence_in %w[asc ascending]
 

data/lib/active_set.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/reverse_merge'
+require 'patches/core_ext/hash/flatten_keys'
+require 'helpers/throws'
+require 'active_set/attribute_instruction'
+require 'active_set/filtering/operation'
+require 'active_set/sorting/operation'
+require 'active_set/paginating/operation'
+require 'active_set/exporting/operation'
+
+class ActiveSet
+  include Enumerable
+
+  attr_reader :set, :view, :instructions
+
+  def initialize(set, view: nil, instructions: {})
+    @set = set
+    @view = view || set
+    @instructions = instructions
+  end
+
+  def each(&block)
+    @view.each(&block)
+  end
+
+  # :nocov:
+  def inspect
+    "#<ActiveSet:#{object_id} @instructions=#{@instructions.inspect}>"
+  end
+
+  def ==(other)
+    return @view == other unless other.is_a?(ActiveSet)
+
+    @view == other.view
+  end
+
+  def method_missing(method_name, *args, &block)
+    return @view.send(method_name, *args, &block) if @view.respond_to?(method_name)
+
+    super
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @view.respond_to?(method_name) || super
+  end
+  # :nocov:
+
+  def filter(instructions_hash)
+    filterer = Filtering::Operation.new(@view, instructions_hash)
+    reinitialize(filterer.execute, :filter, filterer.operation_instructions)
+  end
+
+  def sort(instructions_hash)
+    sorter = Sorting::Operation.new(@view, instructions_hash)
+    reinitialize(sorter.execute, :sort, sorter.operation_instructions)
+  end
+
+  def paginate(instructions_hash)
+    paginater = Paginating::Operation.new(@view, instructions_hash)
+    reinitialize(paginater.execute, :paginate, paginater.operation_instructions)
+  end
+
+  def export(instructions_hash)
+    exporter = Exporting::Operation.new(@view, instructions_hash)
+    exporter.execute
+  end
+
+  private
+
+  def reinitialize(processed_set, method, instructions)
+    self.class.new(@set,
+                   view: processed_set,
+                   instructions: @instructions.merge(
+                     method => instructions
+                   ))
+  end
+end

data/lib/active_set/attribute_instruction.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  class AttributeInstruction
+    attr_accessor :processed
+    attr_reader :keypath, :value
+
+    def initialize(keypath, value)
+      # `keypath` can be an Array (e.g. [:parent, :child, :grandchild, :attribute])
+      # or a String (e.g. 'parent.child.grandchild.attribute')
+      @keypath = Array(keypath).map(&:to_s).flat_map { |x| x.split('.') }
+      @value = value
+      @processed = false
+    end
+
+    def processed?
+      @processed
+    end
+
+    def attribute
+      attribute = @keypath.last
+      return attribute.sub(operator_regex, '') if attribute&.match operator_regex
+
+      attribute
+    end
+
+    def operator(default: '==')
+      attribute = @keypath.last
+      return attribute[operator_regex, 1] if attribute&.match operator_regex
+
+      default
+    end
+
+    def associations_array
+      return [] unless @keypath.any?
+
+      @keypath.slice(0, @keypath.length - 1)
+    end
+
+    def associations_hash
+      return {} unless @keypath.any?
+
+      associations_array.reverse.reduce({}) do |hash, association|
+        { association => hash }
+      end
+    end
+
+    def value_for(item:)
+      resource_for(item: item).public_send(attribute)
+    rescue StandardError
+      # :nocov:
+      nil
+      # :nocov:
+    end
+
+    def resource_for(item:)
+      associations_array.reduce(item) do |resource, association|
+        return nil unless resource.respond_to? association
+
+        resource.public_send(association)
+      end
+    rescue StandardError
+      # :nocov:
+      nil
+      # :nocov:
+    end
+
+    private
+
+    def operator_regex
+      /\((.*?)\)/
+    end
+  end
+end

data/lib/active_set/column_instruction.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './attribute_instruction'
+
+class ActiveSet
+  class ColumnInstruction
+    def initialize(instructions_hash, item)
+      @instructions_hash = instructions_hash.symbolize_keys
+      @item = item
+    end
+
+    def key
+      return @instructions_hash[:key] if @instructions_hash.key? :key
+
+      return titleized_attribute_key unless attribute_instruction.attribute
+
+      attribute_resource = attribute_instruction.resource_for(item: @item)
+      return titleized_attribute_key unless attribute_resource&.class&.respond_to?(:human_attribute_name)
+
+      attribute_resource.class.human_attribute_name(attribute_instruction.attribute)
+    end
+
+    def value
+      return default unless @instructions_hash.key?(:value)
+      return @instructions_hash[:value].call(@item) if @instructions_hash[:value]&.respond_to? :call
+
+      attribute_instruction.value_for(item: @item)
+    end
+
+    private
+
+    def attribute_instruction
+      AttributeInstruction.new(@instructions_hash[:value], nil)
+    end
+
+    def default
+      return @instructions_hash[:default] if @instructions_hash.key? :default
+
+      '—'
+    end
+
+    def titleized_attribute_key
+      attribute_instruction.keypath.map(&:titleize).join(' ')
+    end
+  end
+end

data/lib/active_set/exporting/csv_strategy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../column_instruction'
+
+class ActiveSet
+  module Exporting
+    class CSVStrategy
+      require 'csv'
+
+      def initialize(set, column_instructions)
+        @set = set
+        @column_instructions = column_instructions
+      end
+
+      def execute
+        ::CSV.generate do |output|
+          output << column_keys_for(item: @set.first)
+          @set.each do |item|
+            output << column_values_for(item: item)
+          end
+        end
+      end
+
+      private
+
+      def column_keys_for(item:)
+        columns.map do |column|
+          ColumnInstruction.new(column, item).key
+        end
+      end
+
+      def column_values_for(item:)
+        columns.map do |column|
+          ColumnInstruction.new(column, item).value
+        end
+      end
+
+      def columns
+        @column_instructions.compact
+      end
+    end
+  end
+end

data/lib/active_set/exporting/operation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative './csv_strategy'
+
+class ActiveSet
+  module Exporting
+    class Operation
+      def initialize(set, instructions_hash)
+        @set = set
+        @instructions_hash = instructions_hash
+      end
+
+      def execute
+        strategy_for(format: operation_instructions[:format].to_s.downcase)
+          .new(@set, operation_instructions[:columns])
+          .execute
+      end
+
+      def operation_instructions
+        @instructions_hash.symbolize_keys
+      end
+
+      private
+
+      def strategy_for(format:)
+        return CSVStrategy if format == 'csv'
+      end
+    end
+  end
+end

data/lib/active_set/filtering/active_record_strategy.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    class ActiveRecordStrategy
+      def initialize(set, attribute_instruction)
+        @set = set
+        @attribute_instruction = attribute_instruction
+      end
+
+      def execute
+        return false unless @set.respond_to? :to_sql
+
+        if execute_where_operation?
+          statement = where_operation
+        elsif execute_merge_operation?
+          begin
+            statement = merge_operation
+          rescue ArgumentError # thrown if merging a non-ActiveRecord::Relation
+            return false
+          end
+        else
+          return false
+        end
+
+        statement
+      end
+
+      private
+
+      def execute_where_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)
+
+        true
+      end
+
+      def execute_merge_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?
+
+        true
+      end
+
+      def where_operation
+        initial_relation
+          .where(
+            arel_column.send(
+              @attribute_instruction.operator(default: 'eq'),
+              @attribute_instruction.value
+            )
+          )
+      end
+
+      def merge_operation
+        initial_relation
+          .merge(
+            attribute_model.public_send(
+              @attribute_instruction.attribute,
+              @attribute_instruction.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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class ActiveSet
+  module Filtering
+    class EnumerableStrategy
+      def initialize(set, attribute_instruction)
+        @set = set
+        @attribute_instruction = attribute_instruction
+      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
+        end
+      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?
+
+        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?
+
+        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)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def attribute_item_for(item)
+        @attribute_instruction
+          .resource_for(item: item)
+      end
+    end
+  end
+end