scopiform 0.2.1 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc39ac0b6ce6d7e5c685fcd9baf94aff3595641362d8ea78cf7b10553d2373b
-  data.tar.gz: d5cca316fc383e63d2dbc1d76f67eb2aa405c4dee19f973860a7553d8eefca8c
+  metadata.gz: ae35b0a41cb186989dbb8f76fb8dbfa11604782e6b795fca0ac5e50e66bdd3fa
+  data.tar.gz: 88b9bb3f9cf86b143d997502d0ae997606652d813541259c684d76c7c379b40d
 SHA512:
-  metadata.gz: beb86577a3d13cbddf15ad2a90bb93d3422c8a3243c09462153977fd95a917d4fdbb3e011466dca362be54a9b3c3a6687341a9215a6fda43e4a7d801a2ae5f37
-  data.tar.gz: 4510cbd741943ccf3fe7313502997a3ec0430a974569d98e79369e3e0cd5901520ef1cbfada7d708acaef133feb85f09b40a1194e273318e7681ee8563c0164a
+  metadata.gz: a6239fb1c253b895b3bf35f640fde0f600cc853f9348839108536abf2eed887c71c763b1c1ebb71fa4d2eff07bb77b953732641edb4dde3f271127d25d76287e
+  data.tar.gz: fde9049ba6c66da3901eb99352b3e938130a46e8a24e85c42a04a92c4c641188e112299ea2882b632fe3f6d833f300d9bc8f7aa52928a69b4df7653377af268f

data/lib/scopiform/association_scopes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
+require 'scopiform/utilities'
 
 module Scopiform
   module AssociationScopes
@@ -15,10 +16,6 @@ module Scopiform
         setup_association_auto_scopes(reflection)
       end
 
-      def scopiform_joins(*args, **kargs)
-        respond_to?(:left_outer_joins) ? left_outer_joins(*args, **kargs) : eager_load(*args, **kargs)
-      end
-
       private
 
       def setup_associations_auto_scopes
@@ -30,18 +27,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|
+            Utilities.association_scope(self, association, :apply_filters, value, ctx: ctx)
           },
           suffix: '_is',
           argument_type: :hash
@@ -50,7 +37,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|
+            Utilities.association_scope(self, 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/core.rb

@@ -8,6 +8,8 @@ module Scopiform
     extend ActiveSupport::Concern
 
     module ClassMethods
+      attr_accessor :scopiform_ctx
+
       def auto_scopes
         @auto_scopes || []
       end
@@ -18,7 +20,7 @@ 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)
@@ -58,7 +60,7 @@ module Scopiform
           end
 
           if scope.options[:remove_for_enum]
-            singleton_class.remove_method scope.name
+            singleton_class.send(:remove_method, scope.name)
             @auto_scopes.delete(scope)
           end
         end
@@ -74,7 +76,11 @@ module Scopiform
 
       def auto_scope_for_alias(alias_name, scope_definition)
         alias_scope_definition = scope_definition.dup
-        alias_scope_definition.attribute = alias_name
+        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

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

@@ -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
@@ -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,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

@@ -14,7 +14,7 @@ module Scopiform
     end
 
     def name_for(attribute_name)
-      "#{prefix}#{attribute}#{suffix}".underscore.to_sym
+      "#{prefix}#{attribute_name}#{suffix}".underscore.to_sym
     end
 
     def dup

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
+require 'scopiform/utilities'
 
 module Scopiform
   module StringNumberScopes
@@ -21,25 +22,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 = Utilities.cast_to_text(arel_column, connection) 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 +45,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 = Utilities.cast_to_text(arel_column, connection) 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 +57,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 = Utilities.cast_to_text(arel_column, connection) 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 +69,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 = Utilities.cast_to_text(arel_column, connection) 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 +81,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 = Utilities.cast_to_text(arel_column, connection) 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 +93,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 = Utilities.cast_to_text(arel_column, connection) 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/utilities.rb

@@ -0,0 +1,30 @@
+require 'scopiform/scope_context'
+
+module Scopiform
+  module Utilities
+    def self.cast_to_text(arel_column, connection)
+      cast_to = connection.adapter_name.downcase.starts_with?('mysql') ? 'CHAR' : 'TEXT'
+      Arel::Nodes::NamedFunction.new(
+        'CAST',
+        [arel_column.as(cast_to)]
+      )
+    end
+
+    def self.association_scope(active_record, association, method, value, ctx:)
+      is_root = ctx.nil?
+      ctx = ScopeContext.from(ctx)
+      ctx.set(active_record.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(active_record.distinct.joins(ctx.joins).merge(applied)) { |chain, scope| chain.merge(scope) }
+      else
+        ctx.scopes.reduce(active_record.all.merge(applied)) { |chain, scope| chain.merge(scope) }
+      end
+    end
+  end
+end

data/lib/scopiform/version.rb

@@ -1,3 +1,3 @@
 module Scopiform
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.2.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scopiform
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.6
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2021-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,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'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -83,9 +97,11 @@ 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
+- lib/scopiform/utilities.rb
 - lib/scopiform/version.rb
 - lib/tasks/scopiform_tasks.rake
 homepage: https://github.com/3-form/scopiform
@@ -107,7 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Generate scope methods to ActiveRecord classes based on columns and associations