duty_free 1.0.7 → 1.0.9

data/lib/duty_free/util.rb

@@ -25,17 +25,18 @@ module DutyFree
     def self._recurse_arel(piece, prefix = '')
       names = []
       # Our JOINs mashup of nested arrays and hashes
-      if piece.is_a?(Array)
+      case piece
+      when Array
         names += piece.inject([]) { |s, v| s + _recurse_arel(v, prefix) }
-      elsif piece.is_a?(Hash)
+      when Hash
         names += piece.inject([]) do |s, v|
           new_prefix = "#{prefix}#{v.first}_"
-          s << new_prefix
+          s << [v.last.shift, new_prefix]
           s + _recurse_arel(v.last, new_prefix)
         end
 
       # ActiveRecord AREL objects
-      elsif piece.is_a?(Arel::Nodes::Join) # INNER or OUTER JOIN
+      when Arel::Nodes::Join # INNER or OUTER JOIN
         # rubocop:disable Style/IdenticalConditionalBranches
         if piece.right.is_a?(Arel::Table) # Came in from AR < 3.2?
           # Arel 2.x and older is a little curious because these JOINs work "back to front".
@@ -45,28 +46,38 @@ module DutyFree
           # The right side here at the top is the very last table, and anywhere else down the tree it is
           # the later "JOIN" table of this pair.  (The table that comes after all the rest of the JOINs
           # from the left side.)
-          names << (piece.right.table_alias || piece.right.name)
+          names << [_arel_table_type(piece.right), (piece.right.table_alias || piece.right.name)]
         else # "Normal" setup, fed from a JoinSource which has an array of JOINs
           # The left side is the "JOIN" table
           names += _recurse_arel(piece.left)
           # (The right side of these is the "ON" clause)
         end
         # rubocop:enable Style/IdenticalConditionalBranches
-      elsif piece.is_a?(Arel::Table) # Table
-        names << (piece.table_alias || piece.name)
-      elsif piece.is_a?(Arel::Nodes::TableAlias) # Alias
+      when Arel::Table # Table
+        names << [_arel_table_type(piece), (piece.table_alias || piece.name)]
+      when Arel::Nodes::TableAlias # Alias
         # Can get the real table name from:  self._recurse_arel(piece.left)
-        names << piece.right.to_s # This is simply a string; the alias name itself
-      elsif piece.is_a?(Arel::Nodes::JoinSource) # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
+        names << [_arel_table_type(piece.left), piece.right.to_s] # This is simply a string; the alias name itself
+      when Arel::Nodes::JoinSource # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
         # The left side is the "FROM" table
         # names += _recurse_arel(piece.left)
-        names << (piece.left.table_alias || piece.left.name)
+        names << [_arel_table_type(piece.left), (piece.left.table_alias || piece.left.name)]
         # The right side is an array of all JOINs
         names += piece.right.inject([]) { |s, v| s + _recurse_arel(v) }
       end
       names
     end
 
+    def self._arel_table_type(tbl)
+      # AR < 4.2 doesn't have type_caster at all, so rely on an instance variable getting set
+      # AR 4.2 - 5.1 have buggy type_caster entries for the root node
+      tbl.instance_variable_get(:@_arel_table_type) ||
+        # 5.2-6.1 does type_caster just fine, no bugs there, but the property with the type differs:
+        # 5.2 has "types" as public, 6.0 "types" as private, and 6.1 "klass" as private.
+        ((tc = tbl.send(:type_caster)) && tc.instance_variable_get(:@types)) ||
+        tc.send(:klass)
+    end
+
     def self._prefix_join(prefixes, separator = nil)
       prefixes.reject(&:blank?).join(separator || '.')
     end
@@ -83,5 +94,112 @@ module DutyFree
       end
       name
     end
+
+    # ===================================
+    # Epic require patch
+    def self._patch_require(module_filename, folder_matcher, search_text, replacement_text, autoload_symbol = nil)
+      mod_name_parts = module_filename.split('.')
+      extension = case mod_name_parts.last
+                  when 'rb', 'so', 'o'
+                    module_filename = mod_name_parts[0..-2].join('.')
+                    ".#{mod_name_parts.last}"
+                  else
+                    '.rb'
+                  end
+
+      if autoload_symbol
+        unless Object.const_defined?('ActiveSupport::Dependencies')
+          require 'active_support'
+          require 'active_support/dependencies'
+        end
+        alp = ActiveSupport::Dependencies.autoload_paths
+        custom_require_dir = ::DutyFree::Util._custom_require_dir
+        # Create any missing folder structure leading up to this file
+        module_filename.split('/')[0..-2].inject(custom_require_dir) do |s, part|
+          new_part = File.join(s, part)
+          Dir.mkdir(new_part) unless Dir.exist?(new_part)
+          new_part
+        end
+        if ::DutyFree::Util._write_patched(folder_matcher, module_filename, extension, custom_require_dir, nil, search_text, replacement_text) &&
+           !alp.include?(custom_require_dir)
+          alp.unshift(custom_require_dir)
+        end
+      else
+        unless (require_overrides = ::DutyFree::Util.instance_variable_get(:@_require_overrides))
+          ::DutyFree::Util.instance_variable_set(:@_require_overrides, (require_overrides = {}))
+
+          # Patch "require" itself so that when it specifically sees "active_support/values/time_zone" then
+          # a copy is taken of the original, an attempt is made to find the line with a circular error, that
+          # single line is patched, and then an updated version is written to a temporary folder which is
+          # then required in place of the original.
+
+          Kernel.module_exec do
+            # class << self
+            alias_method :orig_require, :require
+            # end
+            # To be most faithful to Ruby's normal behaviour, this should look like a public singleton
+            define_method(:require) do |name|
+              if (require_override = ::DutyFree::Util.instance_variable_get(:@_require_overrides)[name])
+                extension, folder_matcher, search_text, replacement_text, autoload_symbol = require_override
+                patched_filename = "/patched_#{name.tr('/', '_')}#{extension}"
+                if $LOADED_FEATURES.find { |f| f.end_with?(patched_filename) }
+                  false
+                else
+                  is_replaced = false
+                  if (replacement_path = ::DutyFree::Util._write_patched(folder_matcher, name, extension, ::DutyFree::Util._custom_require_dir, patched_filename, search_text, replacement_text))
+                    is_replaced = Kernel.send(:orig_require, replacement_path)
+                  elsif replacement_path.nil?
+                    puts "Couldn't find #{name} to require it!"
+                  end
+                  is_replaced
+                end
+              else
+                Kernel.send(:orig_require, name)
+              end
+            end
+          end
+        end
+        require_overrides[module_filename] = [extension, folder_matcher, search_text, replacement_text, autoload_symbol]
+      end
+    end
+
+    def self._custom_require_dir
+      unless (custom_require_dir = ::DutyFree::Util.instance_variable_get(:@_custom_require_dir))
+        ::DutyFree::Util.instance_variable_set(:@_custom_require_dir, (custom_require_dir = Dir.mktmpdir))
+        # So normal Ruby require will now pick this one up
+        $LOAD_PATH.unshift(custom_require_dir)
+        # When Ruby is exiting, remove this temporary directory
+        at_exit do
+          FileUtils.rm_rf(::DutyFree::Util.instance_variable_get(:@_custom_require_dir))
+        end
+      end
+      custom_require_dir
+    end
+
+    # Returns the full path to the replaced filename, or
+    # false if the file already exists, and nil if it was unable to write anything.
+    def self._write_patched(folder_matcher, name, extension, dir, patched_filename, search_text, replacement_text)
+      # See if our replacement file might already exist for some reason
+      name = +"/#{name}" unless name.start_with?('/')
+      name << extension unless name.end_with?(extension)
+      return false if File.exist?(replacement_path = "#{dir}#{patched_filename || name}")
+
+      # Dredge up the original .rb file, doctor it, and then require it instead
+      num_written = nil
+      orig_path = nil
+      orig_as = nil
+      # Using Ruby's approach to find files to require
+      $LOAD_PATH.each do |path|
+        orig_path = "#{path}#{name}"
+        break if path.include?(folder_matcher) && (orig_as = File.open(orig_path))
+      end
+      if (orig_text = orig_as&.read)
+        File.open(replacement_path, 'w') do |replacement|
+          num_written = replacement.write(orig_text.gsub(search_text, replacement_text))
+        end
+        orig_as.close
+      end
+      (num_written&.> 0) ? replacement_path : nil
+    end
   end
 end

data/lib/duty_free/version_number.rb

@@ -5,7 +5,7 @@ module DutyFree
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 7
+    TINY = 9
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/duty_free.rb

@@ -21,8 +21,8 @@ if ActiveRecord.version < ::Gem::Version.new('5.0') &&
   end
 end
 
-# Allow Rails 4.0 and 4.1 to work with newer Ruby (>= 2.4) by avoiding a "stack level too deep" error
-# when ActiveSupport tries to smarten up Numeric by messing with Fixnum and Bignum at the end of:
+# Allow ActiveRecord 4.0 and 4.1 to work with newer Ruby (>= 2.4) by avoiding a "stack level too deep"
+# error when ActiveSupport tries to smarten up Numeric by messing with Fixnum and Bignum at the end of:
 # activesupport-4.0.13/lib/active_support/core_ext/numeric/conversions.rb
 if ActiveRecord.version < ::Gem::Version.new('4.2') &&
    ActiveRecord.version > ::Gem::Version.new('3.2') &&
@@ -33,7 +33,7 @@ if ActiveRecord.version < ::Gem::Version.new('4.2') &&
   Numeric.const_set('Bignum', OurBignum)
 end
 
-# Allow Rails < 3.2 to run with newer versions of Psych gem
+# Allow ActiveRecord < 3.2 to run with newer versions of Psych gem
 if BigDecimal.respond_to?(:yaml_tag) && !BigDecimal.respond_to?(:yaml_as)
   class BigDecimal
     class <<self
@@ -42,6 +42,28 @@ if BigDecimal.respond_to?(:yaml_tag) && !BigDecimal.respond_to?(:yaml_as)
   end
 end
 
+require 'duty_free/util'
+
+# Allow ActiveRecord < 3.2 to work with Ruby 2.7 and later
+if ActiveRecord.version < ::Gem::Version.new('3.2') &&
+   ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.7')
+  # Remove circular reference for "now"
+  ::DutyFree::Util._patch_require(
+    'active_support/values/time_zone.rb', '/activesupport',
+    '  def parse(str, now=now)',
+    '  def parse(str, now=now())'
+  )
+  # Remove circular reference for "reflection" for ActiveRecord 3.1
+  if ActiveRecord.version >= ::Gem::Version.new('3.1')
+    ::DutyFree::Util._patch_require(
+      'active_record/associations/has_many_association.rb', '/activerecord',
+      'reflection = reflection)',
+      'reflection = reflection())',
+      :HasManyAssociation # Make sure the path for this guy is available to be autoloaded
+    )
+  end
+end
+
 require 'active_record'
 
 require 'duty_free/config'
@@ -107,14 +129,31 @@ end
 # Major compatibility fixes for ActiveRecord < 4.2
 # ================================================
 ActiveSupport.on_load(:active_record) do
-  # Rails < 4.0 cannot do #find_by, or do #pluck on multiple columns, so here are the patches:
-  if ActiveRecord.version < ::Gem::Version.new('4.0')
-    module ActiveRecord
-      module Calculations # Normally find_by is in FinderMethods, which older AR doesn't have
+  # rubocop:disable Lint/ConstantDefinitionInBlock
+  module ActiveRecord
+    class Base
+      unless respond_to?(:execute_sql)
+        class << self
+          def execute_sql(sql, *param_array)
+            param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
+            connection.execute(send(:sanitize_sql_array, [sql] + param_array))
+          end
+        end
+      end
+    end
+
+    # Rails < 4.0 cannot do #find_by, #find_or_create_by, or do #pluck on multiple columns, so here are the patches:
+    if version < ::Gem::Version.new('4.0')
+      # Normally find_by is in FinderMethods, which older AR doesn't have
+      module Calculations
         def find_by(*args)
           where(*args).limit(1).to_a.first
         end
 
+        def find_or_create_by(attributes, &block)
+          find_by(attributes) || create(attributes, &block)
+        end
+
         def pluck(*column_names)
           column_names.map! do |column_name|
             if column_name.is_a?(Symbol) && self.column_names.include?(column_name.to_s)
@@ -174,7 +213,7 @@ ActiveSupport.on_load(:active_record) do
       unless Base.is_a?(Calculations)
         class Base
           class << self
-            delegate :pluck, :find_by, to: :scoped
+            delegate :pluck, :find_by, :find_or_create_by, to: :scoped
           end
         end
       end
@@ -205,72 +244,208 @@ ActiveSupport.on_load(:active_record) do
           end
         end
       end
-    end
-  end
 
-  # Rails < 4.2 is not innately compatible with Ruby 2.4 and later, and comes up with:
-  # "TypeError: Cannot visit Integer" unless we patch like this:
-  unless ::Gem::Version.new(RUBY_VERSION) < ::Gem::Version.new('2.4')
-    unless Arel::Visitors::DepthFirst.private_instance_methods.include?(:visit_Integer)
-      module Arel
-        module Visitors
-          class DepthFirst < Visitor
-            alias visit_Integer terminal
-          end
+      # ActiveRecord 3.1 and 3.2 didn't try to bring in &block for the .extending() convenience thing
+      # that smartens up scopes, and Ruby 2.7 complained loudly about just doing the magical "Proc.new"
+      # that historically would just capture the incoming block.
+      module QueryMethods
+        unless instance_method(:extending).parameters.include?([:block, :block])
+          # These first two lines used to be:
+          # def extending(*modules)
+          #   modules << Module.new(&Proc.new) if block_given?
+
+          def extending(*modules, &block)
+            modules << Module.new(&block) if block_given?
+
+            return self if modules.empty?
 
-          class Dot < Visitor
-            alias visit_Integer visit_String
+            relation = clone
+            relation.send(:apply_modules, modules.flatten)
+            relation
           end
+        end
+      end
 
-          class ToSql < Visitor
-          private
+      # Same kind of thing for ActiveRecord::Scoping::Default#default_scope
+      module Scoping
+        module Default
+          module ClassMethods
+            if instance_methods.include?(:default_scope) &&
+               !instance_method(:default_scope).parameters.include?([:block, :block])
+              # Fix for AR 3.2-5.1
+              def default_scope(scope = nil, &block)
+                scope = block if block_given?
+
+                if scope.is_a?(Relation) || !scope.respond_to?(:call)
+                  raise ArgumentError,
+                        'Support for calling #default_scope without a block is removed. For example instead ' \
+                        "of `default_scope where(color: 'red')`, please use " \
+                        "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+                        'self.default_scope.)'
+                end
 
-            # ActiveRecord before v3.2 uses Arel < 3.x, which does not have Arel#literal.
-            unless private_instance_methods.include?(:literal)
-              def literal(obj)
-                obj
+                self.default_scopes += [scope]
               end
             end
-            alias visit_Integer literal
           end
         end
       end
     end
   end
+  # rubocop:enable Lint/ConstantDefinitionInBlock
 
-  if ActiveRecord.version < ::Gem::Version.new('5.0')
-    # Avoid pg gem deprecation warning:  "You should use PG::Connection, PG::Result, and PG::Error instead"
-    PGconn = PG::Connection
-    PGresult = PG::Result
-    PGError = PG::Error
+  # Rails < 4.2 is not innately compatible with Ruby 2.4 and later, and comes up with:
+  # "TypeError: Cannot visit Integer" unless we patch like this:
+  if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.4') &&
+     Arel::Visitors.const_defined?('DepthFirst') &&
+     !Arel::Visitors::DepthFirst.private_instance_methods.include?(:visit_Integer)
+    module Arel
+      module Visitors
+        class DepthFirst < Visitor
+          alias visit_Integer terminal
+        end
+
+        class Dot < Visitor
+          alias visit_Integer visit_String
+        end
+
+        class ToSql < Visitor
+        private
+
+          # ActiveRecord before v3.2 uses Arel < 3.x, which does not have Arel#literal.
+          unless private_instance_methods.include?(:literal)
+            def literal(obj)
+              obj
+            end
+          end
+          alias visit_Integer literal
+        end
+      end
+    end
   end
 
   unless DateTime.instance_methods.include?(:nsec)
     class DateTime < Date
       def nsec
-        (sec_fraction * 1000000000).to_i
+        (sec_fraction * 1_000_000_000).to_i
+      end
+    end
+  end
+
+  # First part of arel_table_type stuff:
+  # ------------------------------------
+  # (more found below)
+  # was:  ActiveRecord.version >= ::Gem::Version.new('3.2') &&
+  if ActiveRecord.version < ::Gem::Version.new('5.0')
+    # Used by Util#_arel_table_type
+    module ActiveRecord
+      class Base
+        def self.arel_table
+          @arel_table ||= Arel::Table.new(table_name, arel_engine).tap do |x|
+            x.instance_variable_set(:@_arel_table_type, self)
+          end
+        end
       end
     end
   end
 
   include ::DutyFree::Extensions
+
+  unless ::DutyFree::Extensions::IS_AMOEBA
+    # Add amoeba-compatible support
+    module ActiveRecord
+      class Base
+        def self.amoeba(*args)
+          puts "Amoeba called from #{name} with #{args.inspect}"
+        end
+      end
+    end
+  end
 end
 
-# # Require frameworks
-# if defined?(::Rails)
-#   # Rails module is sometimes defined by gems like rails-html-sanitizer
-#   # so we check for presence of Rails.application.
-#   if defined?(::Rails.application)
-#     require "duty_free/frameworks/rails"
-#   else
-#     ::Kernel.warn(<<-EOS.freeze
-# DutyFree has been loaded too early, before rails is loaded. This can
-# happen when another gem defines the ::Rails namespace, then DF is loaded,
-# all before rails is loaded. You may want to reorder your Gemfile, or defer
-# the loading of DF by using `require: false` and a manual require elsewhere.
-# EOS
-# )
-#   end
-# else
-#   require "duty_free/frameworks/active_record"
-# end
+# Do this earlier because stuff here gets mixed into JoinDependency::JoinAssociation and AssociationScope
+if ActiveRecord.version < ::Gem::Version.new('5.0') && Object.const_defined?('PG::Connection')
+  # Avoid pg gem deprecation warning:  "You should use PG::Connection, PG::Result, and PG::Error instead"
+  PGconn = PG::Connection
+  PGresult = PG::Result
+  PGError = PG::Error
+end
+
+# More arel_table_type stuff:
+# ---------------------------
+if ActiveRecord.version < ::Gem::Version.new('5.2')
+  # Specifically for AR 3.1 and 3.2 to avoid:  "undefined method `delegate' for ActiveRecord::Reflection::ThroughReflection:Class"
+  require 'active_support/core_ext/module/delegation' if ActiveRecord.version < ::Gem::Version.new('4.0')
+  # Used by Util#_arel_table_type
+  # rubocop:disable Style/CommentedKeyword
+  module ActiveRecord
+    module Reflection
+      # AR < 4.0 doesn't know about join_table and derive_join_table
+      unless AssociationReflection.instance_methods.include?(:join_table)
+        class AssociationReflection < MacroReflection
+          def join_table
+            @join_table ||= options[:join_table] || derive_join_table
+          end
+
+        private
+
+          def derive_join_table
+            [active_record.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", '_')
+          end
+        end
+      end
+    end
+
+    module Associations
+      # Specific to AR 4.2 - 5.1:
+      if Associations.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
+        class JoinDependency
+        private
+
+          if ActiveRecord.version < ::Gem::Version.new('5.1') # 4.2 or 5.0
+            def table_aliases_for(parent, node)
+              node.reflection.chain.map do |reflection|
+                alias_tracker.aliased_table_for(
+                  reflection.table_name,
+                  table_alias_for(reflection, parent, reflection != node.reflection)
+                ).tap do |x|
+                  # %%% Specific only to Rails 4.2 (and maybe 4.1?)
+                  x = x.left if x.is_a?(Arel::Nodes::TableAlias)
+                  y = reflection.chain.find { |c| c.table_name == x.name }
+                  x.instance_variable_set(:@_arel_table_type, y.klass)
+                end
+              end
+            end
+          end
+        end
+      elsif Associations.const_defined?('JoinHelper') && JoinHelper.private_instance_methods.include?(:construct_tables)
+        module JoinHelper
+        private
+
+          # AR > 3.0 and < 4.2 (%%% maybe only < 4.1?) uses construct_tables like this:
+          def construct_tables
+            tables = []
+            chain.each do |reflection|
+              tables << alias_tracker.aliased_table_for(
+                table_name_for(reflection),
+                table_alias_for(reflection, reflection != self.reflection)
+              ).tap do |x|
+                x = x.left if x.is_a?(Arel::Nodes::TableAlias)
+                x.instance_variable_set(:@_arel_table_type, reflection.chain.find { |c| c.table_name == x.name }.klass)
+              end
+
+              next unless reflection.source_macro == :has_and_belongs_to_many
+
+              tables << alias_tracker.aliased_table_for(
+                (reflection.source_reflection || reflection).join_table,
+                table_alias_for(reflection, true)
+              )
+            end
+            tables
+          end
+        end
+      end
+    end
+  end # module ActiveRecord
+  # rubocop:enable Style/CommentedKeyword
+end