duty_free 1.0.7 → 1.0.8

data/lib/duty_free/suggest_template.rb

@@ -40,15 +40,14 @@ module DutyFree
       assocs = {}
       this_klass.reflect_on_all_associations.each do |assoc|
         # PolymorphicReflection AggregateReflection RuntimeReflection
-        is_belongs_to = assoc.belongs_to? # is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        is_belongs_to = assoc.belongs_to?
         # Figure out if it's belongs_to, has_many, or has_one
-        # HasAndBelongsToManyReflection
         belongs_to_or_has_many =
           if is_belongs_to
             'belongs_to'
-          elsif (is_habtm = assoc.respond_to?(:macro) ? (assoc.macro == :has_and_belongs_to_many) : assoc.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection))
+          elsif (is_habtm = assoc.macro == :has_and_belongs_to_many)
             'has_and_belongs_to_many'
-          elsif assoc.respond_to?(:macro) ? (assoc.macro == :has_many) : assoc.is_a?(ActiveRecord::Reflection::HasManyReflection)
+          elsif assoc.macro == :has_many
             'has_many'
           else
             'has_one'
@@ -80,8 +79,7 @@ module DutyFree
 
             # Find applicable polymorphic has_many associations from each real model
             model.reflect_on_all_associations.each do |poly_assoc|
-              next unless poly_assoc.is_a?(ActiveRecord::Reflection::HasManyReflection) &&
-                          poly_assoc.inverse_of == assoc
+              next unless poly_assoc.macro == :has_many && poly_assoc.inverse_of == assoc
 
               this_belongs_tos += (fkeys = [poly_assoc.type, poly_assoc.foreign_key])
               assocs["#{assoc.name}_#{poly_assoc.active_record.name.underscore}".to_sym] = [[fkeys, assoc.active_record], poly_assoc.active_record]
@@ -238,11 +236,11 @@ module DutyFree
           if klass.columns.map(&:name).include?(attrib)
             s << attrib
           else
-            ho_and_bt_names = klass.reflect_on_all_associations.each_with_object([]) do |assoc, names|
-              names << assoc.name.to_s if assoc.belongs_to? || assoc.macro == :has_one
+            hm_and_bt_names = klass.reflect_on_all_associations.each_with_object([]) do |assoc, names|
+              names << assoc.name.to_s if [:belongs_to, :has_many, :has_one].include?(assoc.macro)
               names
             end
-            unless ho_and_bt_names.include?(attrib)
+            unless hm_and_bt_names.include?(attrib)
               puts "* In the #{klass.name} model  \"validates_presence_of :#{attrib}\"  should be removed as it does not refer to any existing column."
               errored_columns << klass_col
             end
@@ -287,10 +285,11 @@ module DutyFree
           v.each_with_index do |item, idx|
             # This is where most of the commas get printed, so you can do "#{child_count}," to diagnose things
             print ',' if idx.positive? && indent >= 0
-            if item.is_a?(Hash)
+            case item
+            when Hash
               # puts '^' unless child_count < 5 || indent.negative?
               child_count = _template_pretty_print(item, indent + 2, child_count)
-            elsif item.is_a?(Symbol)
+            when Symbol
               if indent.negative?
                 child_count += 1
               else

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 = 8
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duty_free
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Lorin Thwaits
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-24 00:00:00.000000000 Z
+date: 2021-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '6.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '6.2'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -134,14 +134,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.89.1
+        version: '0.93'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.89.1
+        version: '0.93'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -156,20 +156,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.42.0
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -206,7 +192,7 @@ dependencies:
         version: '1.4'
 description: 'Simplify data imports and exports with this slick ActiveRecord extension
 
-'
+  '
 email: lorint@gmail.com
 executables: []
 extensions: []
@@ -234,7 +220,7 @@ homepage: https://github.com/lorint/duty_free
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -249,8 +235,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.0.8
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Import and Export Data
 test_files: []