scopiform 0.1.4 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1434c2a39865b2f08dcb918354dad1523cd53d9aa8363f4a699fbcb9ddec537c
-  data.tar.gz: 7930cc5a93d5f71dfe6e3ced466b3d39b2d68730b65528e2630febbeb8b5388d
+  metadata.gz: 60fdf69684da8b4a16efc5b52b69bcae18d30824b844fb57fdc3219780ed2894
+  data.tar.gz: fbc86f9e966127b7c64546adc46b805e1c78caaa6d8aa9c49acceaeea7120639
 SHA512:
-  metadata.gz: d67daa8c043e7edaaf459da62baa64108b2554f81867ca0a24d97d52816a2b887aaa93249def97b1650d102d98d42149414f5e6740c4687ac2762c96b0d0001c
-  data.tar.gz: 8b6d543af8a98acf91c5f8d0c4de23a812c40b0304c755412427d860d4ab7ab9baabbe477ead4d43a16a3eca1c61107012ff9a963688b889d029d8e851302a19
+  metadata.gz: 6165fbab6073d4ec637aed25cfb58d2f13ef7ecd590724b17374f47e9718850c62740655768f11f1e1b7f14a119a30eba863897c6189b620844e03b0c54fa0ee
+  data.tar.gz: 5730438bea472073e31a9f37d45ce3de8e066615e9dea0b0fa99af5bb955d5b3192cd068898c6367515d959d84354a202c90d405f5a08f488f8f07f342439aa7

data/README.md

@@ -24,7 +24,7 @@ $ gem install scopiform
 ## Public ActiveRecord Methods
 :aliases_for
 :apply_filters
-:apply_orders
+:apply_sorts
 :association
 :attribute_aliases_inverted
 :auto_scope_add

data/lib/scopiform/association_scopes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
+require 'scopiform/scope_context'
 
 module Scopiform
   module AssociationScopes
@@ -11,12 +12,25 @@ module Scopiform
     end
 
     module ClassMethods
-      def reflection_added(_name, reflection)
-        setup_association_auto_scopes(reflection)
+      def scopiform_association_scope(association, method, value, ctx:)
+        is_root = ctx.nil?
+        ctx = ScopeContext.from(ctx)
+        ctx.set(arel_table) if is_root || ctx.arel_table.blank?
+
+        ctx.association = association
+        ctx.build_joins
+
+        applied = ctx.association.klass.send(method, value, ctx: ScopeContext.from(ctx).set(ctx.association_arel_table))
+
+        if is_root
+          ctx.scopes.reduce(joins(ctx.joins).merge(applied)) { |chain, scope| chain.merge(scope) }
+        else
+          ctx.scopes.reduce(all.merge(applied)) { |chain, scope| chain.merge(scope) }
+        end
       end
 
-      def scopiform_joins(*args, **kargs)
-        respond_to?(:left_outer_joins) ? left_outer_joins(*args, **kargs) : eager_load(*args, **kargs)
+      def reflection_added(_name, reflection)
+        setup_association_auto_scopes(reflection)
       end
 
       private
@@ -30,30 +44,22 @@ module Scopiform
       def setup_association_auto_scopes(association)
         auto_scope_add(
           association.name,
-          Proc.new { |value, joins: nil|
-            is_root = joins.nil?
-            joins = {} if is_root
-
-            joins[association.name] ||= {}
-            applied = association.klass.apply_filters(value, joins: joins[association.name])
-
-            if is_root
-              scopiform_joins(joins).merge(applied)
-            else
-              all.merge(applied)
-            end
+          proc { |value, ctx: nil|
+            scopiform_association_scope(association, :apply_filters, value, ctx: ctx)
           },
           suffix: '_is',
           argument_type: :hash
         )
 
-        # Ordering
+        # Sorting
         auto_scope_add(
           association.name,
-          Proc.new { |value| scopiform_joins(association.name).merge(association.klass.apply_orders(value)) },
-          prefix: 'order_by_',
+          proc { |value, ctx: nil|
+            scopiform_association_scope(association, :apply_sorts, value, ctx: ctx)
+          },
+          prefix: 'sort_by_',
           argument_type: :hash,
-          type: :order
+          type: :sort
         )
       end
     end

data/lib/scopiform/common_scopes.rb

@@ -21,24 +21,24 @@ module Scopiform
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(name_sym => value) },
+            proc { |value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].eq(value)) },
             suffix: '_is',
             argument_type: type
           )
           auto_scope_add(
             name,
-            Proc.new { |value| where.not(name_sym => value) },
+            proc { |value, ctx: nil, **| where.not(scopiform_arel(ctx)[name_sym].eq(value)) },
             suffix: '_not',
             argument_type: type
           )
 
-          # Ordering
+          # Sorting
           auto_scope_add(
             name,
-            ->(value = :asc) { order(name_sym => value) },
-            prefix: 'order_by_',
+            proc { |value = :asc, ctx: nil, **| order(scopiform_arel(ctx)[name_sym].send(value.to_s.downcase)) },
+            prefix: 'sort_by_',
             argument_type: :string,
-            type: :order
+            type: :sort
           )
         end
       end

data/lib/scopiform/core.rb

@@ -8,6 +8,8 @@ module Scopiform
     extend ActiveSupport::Concern
 
     module ClassMethods
+      attr_accessor :scopiform_ctx
+
       def auto_scopes
         @auto_scopes || []
       end
@@ -18,16 +20,14 @@ module Scopiform
       end
 
       def auto_scope?(name)
-        auto_scopes.find { |scope| scope.name == name }
+        auto_scopes.find { |scope| scope.name == name }.present?
       end
 
       def auto_scope_add(attribute, block, prefix: nil, suffix: nil, **options)
-        scope_name = "#{prefix}#{attribute}#{suffix}".underscore
-        scope_name_sym = scope_name.to_sym
-        scope scope_name_sym, block
-
         scope_definition = auto_scope_add_definition(attribute, prefix: prefix, suffix: suffix, **options)
 
+        scope scope_definition.name, block
+
         aliases_for(attribute).each do |alias_name|
           auto_scope_for_alias(alias_name, scope_definition)
         end
@@ -41,8 +41,31 @@ module Scopiform
         end
       end
 
+      def enum(definitions)
+        super(definitions)
+
+        definitions.each_key { |name| update_scope_to_enum(name) }
+      end
+
       private
 
+      def update_scope_to_enum(name)
+        scopes = auto_scopes_by_attribute(name)
+
+        scopes.each do |scope|
+          if scope.options[:type].blank?
+            argument_type = scope.options[:argument_type]
+            scope.options[:argument_type] = argument_type.is_a?(Array) ? [:string] : :string if argument_type
+            scope.options[:type] = :enum
+          end
+
+          if scope.options[:remove_for_enum]
+            singleton_class.send(:remove_method, scope.name)
+            @auto_scopes.delete(scope)
+          end
+        end
+      end
+
       def auto_scope_add_definition(attribute, **options)
         definition = ScopeDefinition.new(attribute, **options)
         @auto_scopes ||= []
@@ -52,10 +75,13 @@ module Scopiform
       end
 
       def auto_scope_for_alias(alias_name, scope_definition)
-        scope_name = "#{scope_definition.prefix}#{scope_definition.attribute}#{scope_definition.suffix}".underscore
-        alias_method_name = "#{scope_definition.prefix}#{alias_name}#{scope_definition.suffix}".underscore
-        singleton_class.send(:alias_method, alias_method_name.to_sym, scope_name.to_sym)
-        auto_scope_add_definition(alias_name, prefix: scope_definition.prefix, suffix: scope_definition.suffix, **scope_definition.options)
+        alias_scope_definition = scope_definition.dup
+        alias_scope_definition.attribute = alias_name.to_sym
+
+        @auto_scopes ||= []
+        @auto_scopes << alias_scope_definition
+
+        singleton_class.send(:alias_method, alias_scope_definition.name, scope_definition.name)
       end
     end
   end

data/lib/scopiform/filters.rb

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
+require 'scopiform/scope_context'
 
 module Scopiform
   module Filters
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def apply_filters(filters_hash, injecting: all, joins: nil)
-        filters_hash.keys.inject(injecting) { |out, filter_name| resolve_filter(out, filter_name, filters_hash[filter_name], joins) }
+      def apply_filters(filters_hash, injecting: all, ctx: nil)
+        filters_hash.keys.inject(injecting) { |out, filter_name| resolve_filter(out, filter_name, filters_hash[filter_name], ctx: ctx) }
       end
 
-      def apply_orders(orders_hash, injecting = all)
-        orders_hash.keys.inject(injecting) { |out, order_name| resolve_order(out, order_name, orders_hash[order_name]) }
+      def apply_sorts(sorts_hash, injecting = all, ctx: nil)
+        sorts_hash.keys.inject(injecting) { |out, sort_name| resolve_sort(out, sort_name, sorts_hash[sort_name], ctx: ctx) }
       end
 
       private
 
-      def resolve_filter(out, filter_name, filter_argument, joins)
+      def resolve_filter(out, filter_name, filter_argument, ctx:)
         if filter_name.to_s.casecmp('OR').zero?
-          or_joins = {}
+          ctx ||= ScopeContext.new
+          ctx.joins = []
 
           return (
             filter_argument
-              .map { |or_filters_hash| apply_filters(or_filters_hash, injecting: out, joins: or_joins) }
-              .map { |a| a.scopiform_joins(or_joins) }
+              .map { |or_filters_hash| apply_filters(or_filters_hash, injecting: out, ctx: ctx) }
+              .map { |a| a.joins(ctx.joins) }
               .inject { |chain, applied| chain.or(applied) }
           )
         end
-        out.send(filter_name, filter_argument, joins: joins)
+        out.send(filter_name, filter_argument, ctx: ctx)
       end
 
-      def resolve_order(out, order_name, order_argument)
-        method_name = "order_by_#{order_name}"
-        out.send(method_name, order_argument)
+      def resolve_sort(out, sort_name, sort_argument, ctx:)
+        method_name = "sort_by_#{sort_name}"
+        out.send(method_name, sort_argument, ctx: ctx)
       end
     end
   end

data/lib/scopiform/helpers.rb

@@ -43,7 +43,7 @@ module Scopiform
       def association(name)
         name = resolve_alias(name)
         association = reflect_on_association(name)
-  
+
         association.klass if association.present?
         association
       rescue NameError
@@ -51,6 +51,14 @@ module Scopiform
         nil
       end
 
+      def enum_attribute?(name)
+        defined_enums.include? name.to_s
+      end
+
+      def scopiform_arel(ctx)
+        ctx&.arel_table || arel_table
+      end
+
       protected
 
       def safe_columns

data/lib/scopiform/reflection_plugin.rb

@@ -1,9 +1,9 @@
 module Scopiform
   module ReflectionPlugin
-    def add_reflection(ar, name, reflection)
-      super(ar, name, reflection)
+    def add_reflection(record, name, reflection)
+      super(record, name, reflection)
 
-      ar.reflection_added(name, reflection) if ar.respond_to? :reflection_added
+      record.reflection_added(name, reflection) if record.respond_to? :reflection_added
     end
   end
 end

data/lib/scopiform/scope_context.rb

@@ -0,0 +1,81 @@
+module Scopiform
+  class ScopeContext
+    attr_accessor :association, :arel_table, :association_arel_table, :joins, :ancestors, :scopes
+
+    def self.from(ctx)
+      created = new
+
+      if ctx
+        created.set(ctx.arel_table)
+        created.association = ctx.association
+        created.association_arel_table = ctx.association_arel_table
+        created.joins = ctx.joins
+        created.ancestors = [*ctx.ancestors]
+      end
+
+      created
+    end
+
+    def initialize
+      @joins = []
+      @ancestors = []
+      @scopes = []
+    end
+
+    def set(arel_table)
+      @arel_table = arel_table
+
+      self
+    end
+
+    def build_joins
+      loop do
+        if association.through_reflection
+          source_reflection_name = association.source_reflection_name
+          self.association = association.through_reflection
+        end
+
+        ancestors << association.name.to_s.pluralize
+        self.association_arel_table = association.klass.arel_table.alias(alias_name)
+
+        joins << create_join
+
+        if association.scope.present? && association.scope.arity.zero?
+          association.klass.scopiform_ctx = ScopeContext.from(self).set(association_arel_table)
+          scopes << association.klass.instance_exec(&association.scope)
+          association.klass.scopiform_ctx = nil
+        end
+
+        break if source_reflection_name.blank?
+
+        self.association = association.klass.reflect_on_association(source_reflection_name)
+        self.arel_table = association_arel_table
+      end
+
+      joins
+    end
+
+    def alias_name
+      ancestors.join('_').downcase
+    end
+
+    private
+
+    def conditions
+      # Rails 4 join_keys has arity of 1, expecting a klass as an argument
+      keys = association.method(:join_keys).arity == 1 ? association.join_keys(association.klass) : association.join_keys
+      [*keys.foreign_key]
+        .zip([*keys.key])
+        .map { |foreign, primary| arel_table[foreign].eq(association_arel_table[primary]) }
+        .reduce { |acc, cond| acc.and(cond) }
+    end
+
+    def create_join
+      arel_table.create_join(
+        association_arel_table,
+        association_arel_table.create_on(conditions),
+        Arel::Nodes::OuterJoin
+      )
+    end
+  end
+end

data/lib/scopiform/scope_definition.rb

@@ -10,7 +10,18 @@ module Scopiform
     end
 
     def name
-      "#{prefix}#{attribute}#{suffix}".underscore
+      name_for(attribute)
+    end
+
+    def name_for(attribute_name)
+      "#{prefix}#{attribute_name}#{suffix}".underscore.to_sym
+    end
+
+    def dup
+      duplicate = super
+      duplicate.options = options.dup
+
+      duplicate
     end
   end
 end

data/lib/scopiform/string_number_date_scopes.rb

@@ -20,46 +20,45 @@ module Scopiform
           name = column.name
           name_sym = name.to_sym
           type = column.type
-          arel_column = arel_table[name]
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(name_sym => value) },
+            proc { |*value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].in(value.flatten)) },
             suffix: '_in',
             argument_type: [type]
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where.not(name_sym => value) },
+            proc { |*value, ctx: nil, **| where.not(scopiform_arel(ctx)[name_sym].in(value.flatten)) },
             suffix: '_not_in',
             argument_type: [type]
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.lt(value)) },
+            proc { |value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].lt(value)) },
             suffix: '_lt',
             argument_type: type
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.lteq(value)) },
+            proc { |value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].lteq(value)) },
             suffix: '_lte',
             argument_type: type
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.gt(value)) },
+            proc { |value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].gt(value)) },
             suffix: '_gt',
             argument_type: type
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.gteq(value)) },
+            proc { |value, ctx: nil, **| where(scopiform_arel(ctx)[name_sym].gteq(value)) },
             suffix: '_gte',
             argument_type: type
           )

data/lib/scopiform/string_number_scopes.rb

@@ -13,65 +13,101 @@ module Scopiform
     module ClassMethods
       private
 
+      def cast_to_text(arel_column)
+        cast_to = connection.adapter_name.downcase.starts_with?('mysql') ? 'CHAR' : 'TEXT'
+        Arel::Nodes::NamedFunction.new(
+          'CAST',
+          [arel_column.as(cast_to)]
+        )
+      end
+
       def setup_string_and_number_auto_scopes
         string_numbers = Helpers::STRING_TYPES + Helpers::NUMBER_TYPES
-        string_number_columns = safe_columns.select { |column| string_numbers.include? column.type }
+        string_number_columns = safe_columns.select do |column|
+          string_numbers.include?(column.type) && !enum_attribute?(column.name)
+        end
         string_number_columns.each do |column|
           name = column.name
           type = column.type
-          arel_column = arel_table[name]
+          cast = false
 
           # Numeric values don't work properly with `.matches`.  Using workaround
           # https://coderwall.com/p/qtgvdq/using-arel_table-for-ilike-yes-even-with-integers
-          if Helpers::NUMBER_TYPES.include? column.type
-            arel_column = Arel::Nodes::NamedFunction.new(
-              'CAST',
-              [arel_column.as('TEXT')]
-            )
-
+          if Helpers::NUMBER_TYPES.include? type
+            cast = true
             type = :string
           end
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"))
+            },
             suffix: '_contains',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"))
+            },
             suffix: '_not_contains',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"))
+            },
             suffix: '_starts_with',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where.not(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where.not(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"))
+            },
             suffix: '_not_starts_with',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}"))
+            },
             suffix: '_ends_with',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
 
           auto_scope_add(
             name,
-            Proc.new { |value| where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}")) },
+            proc { |value, ctx: nil, **|
+              arel_column = scopiform_arel(ctx)[name]
+              arel_column = cast_to_text(arel_column) if cast
+              where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}"))
+            },
             suffix: '_not_ends_with',
-            type: type
+            argument_type: type,
+            remove_for_enum: true
           )
         end
       end

data/lib/scopiform/version.rb

@@ -1,3 +1,3 @@
 module Scopiform
-  VERSION = '0.1.4'
+  VERSION = '0.2.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scopiform
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.4
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-15 00:00:00.000000000 Z
+date: 2020-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: warning
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: composite_primary_keys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - jayce.pulsipher@3-form.com
@@ -69,6 +97,7 @@ files:
 - lib/scopiform/filters.rb
 - lib/scopiform/helpers.rb
 - lib/scopiform/reflection_plugin.rb
+- lib/scopiform/scope_context.rb
 - lib/scopiform/scope_definition.rb
 - lib/scopiform/string_number_date_scopes.rb
 - lib/scopiform/string_number_scopes.rb