actionset 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec3fafb97dceebded86c4106ff2515254524d8ad
-  data.tar.gz: 18a2b68db72f4eac5205c58493447c3283db67c1
+  metadata.gz: ee8a50300e9e0918965a3c32ec78d1f740233add
+  data.tar.gz: 27789ef2fb5e1ff75f1a58ca0bc29c0f4d6fb938
 SHA512:
-  metadata.gz: '01828b37ea7c42ec93d8c3961b79b72abdea34b934a096e449436a04613653e9f811b4256336957ac78604f2341fcdc28ee6522217c0a0974e114ab65963d855'
-  data.tar.gz: 5085a765387a6d58d73cdd31504a59d35eb5e4b7e4b4a8b9fd05b307ae6cd1ec5824725855c44ddc56e469a02237e87951e06b123a825ae5e784ba8d1d790b26
+  metadata.gz: 66d724b335536136cd5ac2efdcaf644cf9586ae7f837a51dbf9acf8da6042b664ad9a1da5307f3b8c9f8e6c8ac3e7d031199dc893ad7baf5c04856302435a554
+  data.tar.gz: 304690a7e523c824c230349eeced3bf0871adb9bcb98614cc538960982e564612f16a72301440df0ddf45c2ebb5935e31b903677d2ab6f71b6f8d70d32e56b9d

data/actionset.gemspec

@@ -2,11 +2,10 @@
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'action_set/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'actionset'
-  spec.version       = ActionSet::VERSION
+  spec.version       = '0.6.0'
   spec.authors       = ['Stephen Margheim']
   spec.email         = ['stephen.margheim@gmail.com']
 
@@ -22,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activeset', '>= 0.6.0'
+  spec.add_dependency 'activeset', '>= 0.7.1'
   spec.add_dependency 'activesupport', '>= 4.0.2'
   spec.add_dependency 'railties'
 

data/lib/action_set.rb

@@ -5,8 +5,7 @@ require 'active_support/core_ext/object/blank'
 require 'active_support/lazy_load_hooks'
 require 'active_set'
 
-require 'action_set/version'
-require_relative './action_set/instruction/value'
+require_relative './action_set/attribute_value'
 require_relative './action_set/helpers/helper_methods'
 
 module ActionSet
@@ -44,19 +43,19 @@ module ActionSet
     def export_set(set)
       return send_file(set, export_set_options(request.format)) if set.is_a?(String) && File.file?(set)
       active_set = ensure_active_set(set)
-      transformed_data = active_set.transform(transform_structure)
-      send_data(transformed_data, export_set_options(request.format))
+      exported_data = active_set.export(export_structure)
+      send_data(exported_data, export_set_options(request.format))
     end
 
     private
 
     def filter_structure(set)
       filter_params.flatten_keys.reject { |_, v| v.blank? }.each_with_object({}) do |(keypath, value), memo|
-        instruction = ActiveSet::Instruction.new(keypath, value)
+        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)
-        typecast_value = Instruction::Value.new(value)
-                                           .cast(to: item_value.class)
+        typecast_value = ActionSet::AttributeValue.new(value)
+                           .cast(to: item_value.class)
 
         memo[keypath] = typecast_value
       end
@@ -66,10 +65,10 @@ module ActionSet
       paginate_params.transform_values(&:to_i)
     end
 
-    def transform_structure
+    def export_structure
       {}.tap do |struct|
-        struct[:format] = transform_params[:format] || request.format.symbol
-        columns_params = transform_params[:columns]&.map do |column|
+        struct[:format] = export_params[:format] || request.format.symbol
+        columns_params = export_params[:columns]&.map do |column|
           Hash[column&.map do |k, v|
             is_literal_value = ->(key) { key.to_s == 'value*' }
             key = is_literal_value.(k) ? 'value' : k
@@ -93,8 +92,8 @@ module ActionSet
       params.fetch(:paginate, {}).to_unsafe_hash
     end
 
-    def transform_params
-      params.fetch(:transform, {}).to_unsafe_hash
+    def export_params
+      params.fetch(:export, {}).to_unsafe_hash
     end
 
     def export_set_options(format)

data/lib/action_set/attribute_value.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module ActionSet
+  class AttributeValue
+    attr_reader :raw
+
+    def initialize(value)
+      @raw = value
+    end
+
+    def cast(to:)
+      adapters.reduce(nil) do |_, adapter|
+        mayble_value_or_nil = adapter.new(@raw, to).process
+        next if mayble_value_or_nil.nil?
+        return mayble_value_or_nil
+      end
+
+      @raw
+    end
+
+    private
+
+    def adapters
+      [ActiveModelAdapter, PlainRubyAdapter, BooleanAdapter, TimeWithZoneAdapter]
+    end
+
+    class PlainRubyAdapter
+      def initialize(raw, target)
+        @raw = raw
+        @target = target
+      end
+
+      def process
+        return @raw if @raw.is_a? @target
+        possible_values.find { |v| v.is_a? @target }
+      end
+
+      private
+
+      def possible_values
+        possible_typecasters.map { |m| typecast(m) }
+                            .compact
+      end
+
+      def possible_typecasters
+        @possible_typecasters ||= String.instance_methods
+                                        .map(&:to_s)
+                                        .select { |m| m.start_with? 'to_' }
+                                        .reject { |m| %[to_v8].include? m }
+      end
+
+      def typecast(method_name)
+        @raw.send(method_name)
+      rescue
+        nil
+      end
+    end
+
+    class ActiveModelAdapter
+      begin
+        require 'active_model/type'
+      rescue LoadError
+        require 'active_record/type'
+      end
+
+      def initialize(raw, target)
+        @raw = raw
+        @target = target
+      end
+
+      def process
+        return @raw if @raw.is_a? @target
+        possible_values.find { |v| v.is_a? @target }
+      end
+
+      private
+
+      def possible_values
+        possible_typecasters.map { |m| typecast(m, @raw) }
+      end
+
+      def possible_typecasters
+        @possible_typecasters ||= type_class.constants
+                                            .map(&:to_s)
+                                            .select { |t| can_typecast?(t) }
+                                            .reject { |t| t == 'Time' }
+                                            .map { |t| init_typecaster(t) }
+                                            .compact
+      end
+
+      def typecast(to_type, value)
+        return to_type.type_cast(value) if to_type.respond_to? :type_cast
+        to_type.cast(value)
+      end
+
+      def can_typecast?(const_name)
+        typecasting_class = type_class.const_get(const_name)
+        typecasting_class.instance_methods.include?(:cast) ||
+          typecasting_class.instance_methods.include?(:type_cast)
+      end
+
+      def init_typecaster(const_name)
+        type_class.const_get(const_name).new
+      rescue
+        nil
+      end
+
+      def type_class
+        ActiveModel::Type
+      rescue NameError
+        ActiveRecord::Type
+      end
+    end
+
+    class BooleanAdapter
+      def initialize(raw, target)
+        @raw = raw
+        @target = target
+      end
+
+      def process
+        return if @raw.is_a? @target
+        return unless @target.eql?(TrueClass) || @target.eql?(FalseClass)
+        # ActiveModel::Type::Boolean is too expansive in its casting; will get false positives
+        to_bool
+      end
+
+      private
+
+      def to_bool
+        return @raw if @raw.is_a?(TrueClass) || @raw.is_a?(FalseClass)
+        return true if %w[true yes 1 t].include? @raw.to_s.downcase
+        return false if %w[false no 0 f].include? @raw.to_s.downcase
+        nil
+      end
+    end
+
+    class TimeWithZoneAdapter
+      def initialize(raw, target)
+        @raw = raw
+        @target = target
+      end
+
+      def process
+        return if @raw.is_a? @target
+        return unless @target.eql?(ActiveSupport::TimeWithZone)
+        time_value = ActiveModelAdapter.new(@raw, Time).process
+
+        return unless time_value.is_a?(Time)
+        return time_value unless time_value.respond_to?(:in_time_zone)
+        time_value.in_time_zone
+      end
+    end
+  end
+end

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionset
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-22 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeset
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -227,6 +227,7 @@ files:
 - bin/setup
 - config.ru
 - lib/action_set.rb
+- lib/action_set/attribute_value.rb
 - lib/action_set/helpers/export/path_for_helper.rb
 - lib/action_set/helpers/helper_methods.rb
 - lib/action_set/helpers/pagination/current_page_description_for_helper.rb
@@ -247,8 +248,6 @@ files:
 - lib/action_set/helpers/sort/link_for_helper.rb
 - lib/action_set/helpers/sort/next_direction_for_helper.rb
 - lib/action_set/helpers/sort/path_for_helper.rb
-- lib/action_set/instruction/value.rb
-- lib/action_set/version.rb
 homepage: https://github.com/fractaledmind/actionset
 licenses:
 - MIT

data/lib/action_set/instruction/value.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module ActionSet
-  module Instruction
-    class Value
-      attr_reader :raw
-
-      def initialize(value)
-        @raw = value
-      end
-
-      def cast(to:)
-        adapters.map do |adapter|
-          value = adapter.new(@raw, to).process
-          return value unless value.nil?
-        end.compact.first || @raw
-      end
-
-      private
-
-      def adapters
-        [ActiveModelAdapter, PlainRubyAdapter, BooleanAdapter, TimeWithZoneAdapter]
-      end
-
-      class PlainRubyAdapter
-        def initialize(raw, target)
-          @raw = raw
-          @target = target
-        end
-
-        def process
-          return @raw if @raw.is_a? @target
-          possible_values.find { |v| v.is_a? @target }
-        end
-
-        private
-
-        def possible_values
-          possible_typecasters.map { |m| typecast(m) }
-                              .compact
-        end
-
-        def possible_typecasters
-          @possible_typecasters ||= String.instance_methods
-                                          .map(&:to_s)
-                                          .select { |m| m.starts_with? 'to_' }
-                                          .reject { |m| %[to_v8].include? m }
-        end
-
-        def typecast(method_name)
-          @raw.send(method_name)
-        rescue
-          nil
-        end
-      end
-
-      class ActiveModelAdapter
-        begin
-          require 'active_model/type'
-        rescue LoadError
-          require 'active_record/type'
-        end
-
-        def initialize(raw, target)
-          @raw = raw
-          @target = target
-        end
-
-        def process
-          return @raw if @raw.is_a? @target
-          possible_values.find { |v| v.is_a? @target }
-        end
-
-        private
-
-        def possible_values
-          possible_typecasters.map { |m| typecast(m, @raw) }
-        end
-
-        def possible_typecasters
-          @possible_typecasters ||= type_class.constants
-                                              .map(&:to_s)
-                                              .select { |t| can_typecast?(t) }
-                                              .reject { |t| t == 'Time' }
-                                              .map { |t| init_typecaster(t) }
-                                              .compact
-        end
-
-        def typecast(to_type, value)
-          return to_type.type_cast(value) if to_type.respond_to? :type_cast
-          to_type.cast(value)
-        end
-
-        def can_typecast?(const_name)
-          typecasting_class = type_class.const_get(const_name)
-          typecasting_class.instance_methods.include?(:cast) ||
-            typecasting_class.instance_methods.include?(:type_cast)
-        end
-
-        def init_typecaster(const_name)
-          type_class.const_get(const_name).new
-        rescue
-          nil
-        end
-
-        def type_class
-          ActiveModel::Type
-        rescue NameError
-          ActiveRecord::Type
-        end
-      end
-
-      class BooleanAdapter
-        def initialize(raw, target)
-          @raw = raw
-          @target = target
-        end
-
-        def process
-          return if @raw.is_a? @target
-          return unless @target.eql?(TrueClass) || @target.eql?(FalseClass)
-          # ActiveModel::Type::Boolean is too expansive in its casting; will get false positives
-          to_bool
-        end
-
-        private
-
-        def to_bool
-          return @raw if @raw.is_a?(TrueClass) || @raw.is_a?(FalseClass)
-          return true if %w[true yes 1 t].include? @raw.to_s.downcase
-          return false if %w[false no 0 f].include? @raw.to_s.downcase
-          nil
-        end
-      end
-
-      class TimeWithZoneAdapter
-        def initialize(raw, target)
-          @raw = raw
-          @target = target
-        end
-
-        def process
-          return if @raw.is_a? @target
-          return unless @target.eql?(ActiveSupport::TimeWithZone)
-          time_value = ActiveModelAdapter.new(@raw, Time).process
-
-          return unless time_value.is_a?(Time)
-          return time_value unless time_value.respond_to?(:in_time_zone)
-          time_value.in_time_zone
-        end
-      end
-    end
-  end
-end

data/lib/action_set/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module ActionSet
-  VERSION = '0.5.4'
-end