scopiform 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3410bc990d8cdf96301ed976fd2a604f19712ec559a6e7a0e2eb8f384f887ba4
-  data.tar.gz: ff9cf85f92087f0cca007130236776532617002c4dfb9e8f557dc2f96b744d1f
+  metadata.gz: bdd67fcd99f42ab665dd31c6fedebe66f490e28ccb03d5d9ad5bd68d6c074b04
+  data.tar.gz: eb6622a1ca3489a78156e290020c36153ddd6008e9a97af05804b94b8cf4a2e4
 SHA512:
-  metadata.gz: 7000af69a75cad3e5092d27567280207a3301f6dd507b66d1477ee6695aee22de7ff48b9f547644ae4bb597d6289690f885e1f903dd1710c7513dffa4a14512d
-  data.tar.gz: 1c91fb0c3b91dfd73049fc80f1c09895d987ee125754a912ec0a70c55a8833b5db4c858d102569bb78d7f47dd266b1d65ea6e5caf2c7465297804cf419969bfc
+  metadata.gz: ebbbc3f4ed13cddd576958a6b82f5bd2238cb8930ac242ed3dfaeca6bdd71f388c9eaa33912cf02acdfaf31f710737aab3bbcbf2a1654f25a199ad5443eb53d5
+  data.tar.gz: 6ea5675e9a5a6d68a2221b4affd5887cd3a0b8a57c407515b693bb65ab0a49b0fde09d7a3c8a39bb1a14d22e074907ce417f92216a82e8b8aa188d269c8c4187

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
+          joins(ctx.joins).merge(applied)
+        else
+          all.merge(applied)
+        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,18 +44,8 @@ module Scopiform
       def setup_association_auto_scopes(association)
         auto_scope_add(
           association.name,
-          proc { |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
@@ -50,7 +54,9 @@ module Scopiform
         # Sorting
         auto_scope_add(
           association.name,
-          proc { |value| scopiform_joins(association.name).merge(association.klass.apply_sorts(value)) },
+          proc { |value, ctx: nil|
+            scopiform_association_scope(association, :apply_sorts, value, ctx: ctx)
+          },
           prefix: 'sort_by_',
           argument_type: :hash,
           type: :sort

data/lib/scopiform/common_scopes.rb

@@ -21,13 +21,13 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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 { |value| where.not(name_sym => value) },
+            proc { |value, ctx: nil, **| where.not(scopiform_arel(ctx)[name_sym].eq(value)) },
             suffix: '_not',
             argument_type: type
           )
@@ -35,7 +35,7 @@ module Scopiform
           # Sorting
           auto_scope_add(
             name,
-            ->(value = :asc) { order(name_sym => value) },
+            proc { |value = :asc, ctx: nil, **| order(scopiform_arel(ctx)[name_sym].send(value.to_s.downcase)) },
             prefix: 'sort_by_',
             argument_type: :string,
             type: :sort

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_sorts(sorts_hash, injecting = all)
-        sorts_hash.keys.inject(injecting) { |out, sort_name| resolve_sort(out, sort_name, sorts_hash[sort_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_sort(out, sort_name, sort_argument)
+      def resolve_sort(out, sort_name, sort_argument, ctx:)
         method_name = "sort_by_#{sort_name}"
-        out.send(method_name, sort_argument)
+        out.send(method_name, sort_argument, ctx: ctx)
       end
     end
   end

data/lib/scopiform/helpers.rb

@@ -55,6 +55,10 @@ module Scopiform
         defined_enums.include? name.to_s
       end
 
+      def scopiform_arel(ctx)
+        ctx&.arel_table || arel_table
+      end
+
       protected
 
       def safe_columns

data/lib/scopiform/scope_context.rb

@@ -0,0 +1,74 @@
+module Scopiform
+  class ScopeContext
+    attr_accessor :association, :arel_table, :association_arel_table, :joins, :ancestors
+
+    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 = []
+    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
+        self.association_arel_table = association.klass.arel_table.alias(alias_name)
+
+        joins << create_join
+
+        break if source_reflection_name.blank?
+
+        self.association = association.klass.association(source_reflection_name)
+        self.arel_table = association_arel_table
+      end
+
+      self
+    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/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 { |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 { |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 { |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 { |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 { |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 { |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,6 +13,14 @@ 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 do |column|
@@ -21,25 +29,22 @@ module Scopiform
         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
-            cast_to = 'TEXT'
-            cast_to = 'CHAR' if connection.adapter_name.downcase.starts_with? 'mysql'
-
-            arel_column = Arel::Nodes::NamedFunction.new(
-              'CAST',
-              [arel_column.as(cast_to)]
-            )
-
+          if Helpers::NUMBER_TYPES.include? type
+            cast = true
             type = :string
           end
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true
@@ -47,7 +52,11 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true
@@ -55,7 +64,11 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true
@@ -63,7 +76,11 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true
@@ -71,7 +88,11 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true
@@ -79,7 +100,11 @@ module Scopiform
 
           auto_scope_add(
             name,
-            proc { |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',
             argument_type: type,
             remove_for_enum: true

data/lib/scopiform/version.rb

@@ -1,3 +1,3 @@
 module Scopiform
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scopiform
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !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
@@ -83,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