duty_free 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6139333a59c0d3cfb29003ee8d076214906b49270f05de439a260dcf6db227b
-  data.tar.gz: 2e129dec49e960970b8116983d7b483fa0144511d315586f12a15a2df3ca52b7
+  metadata.gz: 51bb54397528578ae7d4d43a04d1d6c31f81d1417d9c076f1fb751b18c09afaa
+  data.tar.gz: 8561d19c0a0166462c011f6a310429944de9b95751dbf9b36dbbb32fdce4bf76
 SHA512:
-  metadata.gz: 553fe2590a1803cf52b166290b6c2d2525f58d59a45bba5f1b2f1e1a8e6be42451f5e6642c1971195816bdbe8a3573f5327f5b1f9fedf46abe57762bc1131fd4
-  data.tar.gz: 1ded83dc81de148793c4e98ad809e31efff083b650cd69af07b99e305f0ada3e1a4ccc749a00569838397d018ff1817d40a8a2e89a7ae0964cc8ea4afe4f8ef6
+  metadata.gz: 02ae8681512885e5ab618aaef343ae88375338fc396ec711b28db78bd97daad361949b86c18c1ca81401e3a15f6629814900a751145bf8a270e50f1fa5669cab
+  data.tar.gz: 0444426a5468f3dcf7143f3f8859f79f2808db968b6a59561ff0351223993b0071aa94e95b4e50924d99ccbf4ae78f7a9b190a617eac6c21305d8ae0e7dd7f87

data/lib/duty_free.rb

@@ -62,7 +62,137 @@ module DutyFree
   end
 end
 
+# Major compatibility fixes for ActiveRecord < 4.2
+# ================================================
 ActiveSupport.on_load(:active_record) do
+  # ActiveRecord before 4.0 didn't have #version
+  unless ActiveRecord.respond_to?(:version)
+    module ActiveRecord
+      def self.version
+        ::Gem::Version.new(ActiveRecord::VERSION::STRING)
+      end
+    end
+  end
+
+  # 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
+        def find_by(*args)
+          where(*args).limit(1).to_a.first
+        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)
+              "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
+            else
+              column_name
+            end
+          end
+
+          # Same as:  if has_include?(column_names.first)
+          if eager_loading? || (includes_values.present? && (column_names.first || references_eager_loaded_tables?))
+            construct_relation_for_association_calculations.pluck(*column_names)
+          else
+            relation = clone # spawn
+            relation.select_values = column_names
+            result = if respond_to?(:bind_values)
+                       klass.connection.select_all(relation.arel, nil, bind_values)
+                     else
+                       klass.connection.select_all(relation.arel.to_sql, nil)
+                     end
+            if result.empty?
+              []
+            else
+              columns = result.first.keys.map do |key|
+                # rubocop:disable Style/SingleLineMethods Naming/MethodParameterName
+                klass.columns_hash.fetch(key) do
+                  Class.new { def type_cast(v); v; end }.new
+                end
+                # rubocop:enable Style/SingleLineMethods Naming/MethodParameterName
+              end
+
+              result = result.map do |attributes|
+                values = klass.initialize_attributes(attributes).values
+
+                columns.zip(values).map do |column, value|
+                  column.type_cast(value)
+                end
+              end
+              columns.one? ? result.map!(&:first) : result
+            end
+          end
+        end
+      end
+
+      unless Base.is_a?(Calculations)
+        class Base
+          class << self
+            delegate :pluck, :find_by, to: :scoped
+          end
+        end
+      end
+
+      # ActiveRecord < 3.2 doesn't have initialize_attributes, used by .pluck()
+      unless AttributeMethods.const_defined?('Serialization')
+        class Base
+          class << self
+            def initialize_attributes(attributes, options = {}) #:nodoc:
+              serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
+              # super(attributes, options)
+
+              serialized_attributes.each do |key, coder|
+                attributes[key] = Attribute.new(coder, attributes[key], serialized) if attributes.key?(key)
+              end
+
+              attributes
+            end
+          end
+        end
+      end
+
+      # This only gets added for ActiveRecord < 3.2
+      module Reflection
+        unless AssociationReflection.instance_methods.include?(:foreign_key)
+          class AssociationReflection < MacroReflection
+            alias foreign_key association_foreign_key
+          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
+
+          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
+  end
+
   include ::DutyFree::Extensions
 end
 

data/lib/duty_free/column.rb

@@ -36,19 +36,15 @@ module DutyFree
     end
 
     def titleize
-      @titleized ||= sym_string.titleize
+      @titleized ||= to_sym.titleize
     end
 
-    delegate :to_sym, to: :sym_string
-
     def path
       @path ||= ::DutyFree::Util._prefix_join([pre_prefix, prefix]).split('.').map(&:to_sym)
     end
 
-  private
-
     # The snake-cased column name to be used for building the full list of template_columns
-    def sym_string
+    def to_sym
       @sym_string ||= ::DutyFree::Util._prefix_join(
         [pre_prefix, prefix, ::DutyFree::Util._clean_name(name, import_template_as)],
         '_'

data/lib/duty_free/extensions.rb

@@ -19,7 +19,8 @@ module DutyFree
       # end
 
       # Export at least column header, and optionally include all existing data as well
-      def df_export(is_with_data = true, import_template = nil)
+      def df_export(is_with_data = true, import_template = nil, use_inner_joins = false)
+        use_inner_joins = true unless respond_to?(:left_joins)
         # In case they are only supplying the columns hash
         if is_with_data.is_a?(Hash) && !import_template
           import_template = is_with_data
@@ -52,12 +53,20 @@ module DutyFree
         if is_with_data
           # Automatically create a JOINs strategy and select list to get back all related rows
           template_cols, template_joins = ::DutyFree::Extensions._recurse_def(self, import_template[:all], import_template)
-          relation = left_joins(template_joins)
+          relation = use_inner_joins ? joins(template_joins) : left_joins(template_joins)
 
           # So we can properly create the SELECT list, create a mapping between our
           # column alias prefixes and the aliases AREL creates.
-          arel_alias_names = ::DutyFree::Util._recurse_arel(relation.arel.ast.cores.first.source)
-          our_names = ::DutyFree::Util._recurse_arel(template_joins)
+          core = relation.arel.ast.cores.first
+          # Accommodate AR < 3.2
+          arel_alias_names = if core.froms.is_a?(Arel::Table)
+                               # All recent versions of AR have #source which brings up an Arel::Nodes::JoinSource
+                               ::DutyFree::Util._recurse_arel(core.source)
+                             else
+                               # With AR < 3.2, "froms" brings up the top node, an Arel::Nodes::InnerJoin
+                               ::DutyFree::Util._recurse_arel(core.froms)
+                             end
+          our_names = ['_'] + ::DutyFree::Util._recurse_arel(template_joins)
           mapping = our_names.zip(arel_alias_names).to_h
 
           relation.select(template_cols.map { |x| x.to_s(mapping) }).each do |result|
@@ -157,7 +166,6 @@ module DutyFree
             arguments = [data, import_template][0..last_arg_idx]
             data = ret if (ret = my_before_import.call(*arguments)).is_a?(Enumerable)
           end
-          col_list = nil
           data.each_with_index do |row, row_num|
             row_errors = {}
             if is_first # Anticipate that first row has column names
@@ -186,10 +194,7 @@ module DutyFree
                   col.strip!
                 end
               end
-              # %%% Will the uniques saved into @defined_uniques here just get redefined later
-              # after the next line, the map! with clean to change out the alias names?  So we can't yet set
-              # col_list?
-              cols.map! { |col| ::DutyFree::Util._clean_name(col, import_template[:as]) } # %%%
+              cols.map! { |col| ::DutyFree::Util._clean_name(col, import_template[:as]) }
               defined_uniques(uniques, cols, cols.join('|'), starred)
               # Make sure that at least half of them match what we know as being good column names
               template_column_objects = ::DutyFree::Extensions._recurse_def(self, import_template[:all], import_template).first
@@ -210,9 +215,9 @@ module DutyFree
               is_first = false
             else # Normal row of data
               is_insert = false
-              is_do_save = true
               existing_unique = valid_unique.inject([]) do |s, v|
                 s << if v.last.is_a?(Array)
+                       # binding.pry
                        v.last[0].where(v.last[1] => row[v.last[2]]).limit(1).pluck(MAX_ID).first.to_s
                      else
                        row[v.last].to_s
@@ -252,6 +257,7 @@ module DutyFree
                 end
                 sub_obj = obj
                 this_path = +''
+                # puts "p: #{v.path}"
                 v.path.each_with_index do |path_part, idx|
                   this_path << (this_path.blank? ? path_part.to_s : ",#{path_part}")
                   unless (sub_next = sub_objects[this_path])
@@ -274,56 +280,45 @@ module DutyFree
                     # This works for belongs_to or has_one.  has_many gets sorted below.
                     # Get existing related object, or create a new one
                     if (sub_next = sub_obj.send(path_part)).nil?
-                      is_has_one = assoc.is_a?(ActiveRecord::Reflection::HasOneReflection)
                       klass = Object.const_get(assoc&.class_name)
-                      sub_next = if is_has_one
+                      # assoc.is_a?(ActiveRecord::Reflection::HasOneReflection)
+                      # %%% When we support only AR 4.2 and above then we can do:  assoc.has_one?
+                      sub_next = if assoc.macro == :has_one
                                    has_ones << v.path
                                    klass.new
                                  else
                                    # Try to find a unique item if one is referenced
                                    sub_bt = nil
                                    begin
-                                     # Goofs up if trim_prefix isn't the same name as the class, or if it's
-                                     # a self-join?  (like when trim_prefix == 'Reports To')
-                                     # %%% Need to test this more when the self-join is more than one hop away,
-                                     # such as importing orders and having employees come along :)
-                                     # if sub_obj.class == klass
-                                     #   trim_prefix = ''
-                                     # end
-                                     # %%% Maybe instead of passing in "klass" we can give the belongs_to association and build through that instead,
-                                     # allowing us to nix the klass.new(criteria) line below.
                                      trim_prefix = v.titleize[0..-(v.name.length + 2)]
                                      trim_prefix << ' ' unless trim_prefix.blank?
-                                     # if klass == sub_obj.class # Self-referencing thing pointing to us?
-                                     # %%% This should be more general than just for self-referencing things.
                                      sub_bt, criteria = klass.find_existing(uniques, cols, starred, import_template, keepers, nil, row, klass, all, trim_prefix)
                                    rescue ::DutyFree::NoUniqueColumnError
-                                     sub_unique = nil
                                    end
-                                   # Self-referencing shouldn't build a new one if it couldn't find one
-                                   # %%% Can criteria really ever be empty anymore?
+                                   # %%% Can criteria really ever be nil anymore?
                                    sub_bt ||= klass.new(criteria || {}) unless klass == sub_obj.class && criteria.empty?
                                    sub_obj.send("#{path_part}=", sub_bt)
                                    sub_bt
                                  end
                     end
                     # Look for possible missing polymorphic detail
+                    # Maybe can test for this via assoc.through_reflection
                     if assoc.is_a?(ActiveRecord::Reflection::ThroughReflection) &&
                        (delegate = assoc.send(:delegate_reflection)&.active_record&.reflect_on_association(assoc.source_reflection_name)) &&
                        delegate.options[:polymorphic]
                       polymorphics << { parent: sub_next, child: sub_obj, type_col: delegate.foreign_type, id_col: delegate.foreign_key.to_s }
                     end
                     # From a has_many?
-                    if sub_next.is_a?(ActiveRecord::Associations::CollectionProxy)
+                    # Rails 4.0 and later can do:  sub_next.is_a?(ActiveRecord::Associations::CollectionProxy)
+                    if assoc.macro == :has_many && !assoc.options[:through]
                       # Try to find a unique item if one is referenced
                       # %%% There is possibility that when bringing in related classes using a nil
                       # in IMPORT_TEMPLATE[:all] that this will break.  Need to test deeply nested things.
                       start = (v.pre_prefix.blank? ? 0 : v.pre_prefix.length)
                       trim_prefix = v.titleize[start..-(v.name.length + 2)]
                       trim_prefix << ' ' unless trim_prefix.blank?
-                      klass = sub_next.klass
                       # assoc.inverse_of is the belongs_to side of the has_many train we came in here on.
-                      sub_hm, criteria = klass.find_existing(uniques, cols, starred, import_template, keepers, assoc.inverse_of, row, sub_next, all, trim_prefix)
+                      sub_hm, criteria = assoc.klass.find_existing(uniques, cols, starred, import_template, keepers, assoc.inverse_of, row, sub_next, all, trim_prefix)
 
                       # If still not found then create a new related object using this has_many collection
                       # (criteria.empty? ? nil : sub_next.new(criteria))
@@ -347,7 +342,7 @@ module DutyFree
 
                 next unless sub_obj.respond_to?(sym = "#{v.name}=".to_sym)
 
-                col_type = (sub_class = sub_obj.class).columns_hash[v.name.to_s]&.type
+                col_type = sub_obj.class.columns_hash[v.name.to_s]&.type
                 if col_type.nil? && (virtual_columns = import_template[:virtual_columns]) &&
                    (virtual_columns = virtual_columns[this_path] || virtual_columns)
                   col_type = virtual_columns[v.name]
@@ -355,9 +350,9 @@ module DutyFree
                 if col_type == :boolean
                   if row[key].nil?
                     # Do nothing when it's nil
-                  elsif %w[true t yes y].include?(row[key]&.downcase) # Used to cover 'on'
+                  elsif %w[true t yes y].include?(row[key]&.strip&.downcase) # Used to cover 'on'
                     row[key] = true
-                  elsif %w[false f no n].include?(row[key]&.downcase) # Used to cover 'off'
+                  elsif %w[false f no n].include?(row[key]&.strip&.downcase) # Used to cover 'off'
                     row[key] = false
                   else
                     row_errors[v.name] ||= []
@@ -366,7 +361,7 @@ module DutyFree
                 end
                 sub_obj.send(sym, row[key])
                 # else
-                #   puts "  #{sub_class.name} doesn't respond to #{sym}"
+                #   puts "  #{sub_obj.class.name} doesn't respond to #{sym}"
               end
               # Try to save a final sub-object if one exists
               sub_obj.save if sub_obj && this_path && !is_has_one && sub_obj.valid?
@@ -442,31 +437,54 @@ module DutyFree
             s
           end
         end
+        col_list = cols.join('|')
 
         # First add in foreign key stuff we can find from belongs_to associations (other than the
         # one we might have arrived here upon).
-        criteria = {}
+        criteria = {} # Enough detail to find or build a new object
         bt_criteria = {}
         bt_criteria_all_nil = true
         bt_col_indexes = []
         available_bts = []
         only_valid_uniques = (train_we_came_in_here_on == false)
-        uniq_lookups = {}
-        # %%% Ultimately may consider making this recursive
-        bts = reflect_on_all_associations.each_with_object([]) do |sn_assoc, s|
-          if sn_assoc.is_a?(ActiveRecord::Reflection::BelongsToReflection) &&
-             (!train_we_came_in_here_on || sn_assoc != train_we_came_in_here_on)
-            # %%% Make sure there's a starred column we know about from this one
-            uniq_lookups[sn_assoc.foreign_key] = nil if only_valid_uniques
-            s << sn_assoc
-          end
-          s
+        uniq_lookups = {} # The data, or how to look up the data
+
+        vus = ((@valid_uniques ||= {})[col_list] ||= {}) # Fancy memoisation
+
+        if (is_new_vus = vus.empty?)
+          #   # Let's do general attributes before the tricky foreign key stuff
+          # Find all unique combinations that are available based on incoming columns, and
+          # pair them up with column number mappings.
+          template_column_objects = ::DutyFree::Extensions._recurse_def(self, all || import_template[:all], import_template).first
+          available = if trim_prefix.blank?
+                        template_column_objects.select { |col| col.pre_prefix.blank? && col.prefix.blank? }
+                      else
+                        trim_prefix_snake = trim_prefix.downcase.tr(' ', '_')
+                        template_column_objects.select do |col|
+                          this_prefix = ::DutyFree::Util._prefix_join([col.pre_prefix, col.prefix], '_').tr('.', '_')
+                          trim_prefix_snake == "#{this_prefix}_"
+                        end
+                      end.map { |avail| avail.name.to_s.titleize }
+          all_vus = defined_uniques(uniques, cols, nil, starred, trim_prefix)
+          #   k, v = all_vus.first
+          #   k.each_with_index do |col, idx|
+          #     if available.include?(col) # || available_bts.include?(col)
+          #       vus[col] ||= v[idx]
+          #     end
+          #     # if available_bts.include?(k)
         end
-        bts.each do |sn_bt|
+
+        # %%% Ultimately may consider making this recursive
+        reflect_on_all_associations.each do |sn_bt|
+          next unless sn_bt.belongs_to? && (!train_we_came_in_here_on || sn_bt != train_we_came_in_here_on)
+
+          # # %%% Make sure there's a starred column we know about from this one
+          # uniq_lookups[sn_bt.foreign_key] = nil if only_valid_uniques
+
           # This search prefix becomes something like "Order Details Product "
           cols.each_with_index do |bt_col, idx|
             next if bt_col_indexes.include?(idx) ||
-                    !bt_col&.start_with?(trim_prefix + "#{sn_bt.name.to_s.underscore.tr('_', ' ').titleize} ")
+                    !bt_col&.start_with?(bt_prefix = (trim_prefix + "#{sn_bt.name.to_s.underscore.tr('_', ' ').titleize} "))
 
             available_bts << bt_col
             fk_id = if row
@@ -475,6 +493,26 @@ module DutyFree
                       # (like first_name, last_name on a referenced employee)
                       sn_bt.klass.where(keepers[idx].name => row[idx]).limit(1).pluck(MAX_ID).first
                     else
+                      # elsif is_new_vus
+                      #   # Add to our criteria if this belongs_to is required
+                      #   bt_req_by_default = sn_bt.klass.respond_to?(:belongs_to_required_by_default) &&
+                      #                       sn_bt.klass.belongs_to_required_by_default
+                      #   unless !vus.values.first&.include?(idx) &&
+                      #          (sn_bt.options[:optional] || (sn_bt.options[:required] == false) || !bt_req_by_default)
+                      #     # # Add this fk to the criteria
+                      #     # criteria[fk_name] = fk_id
+
+                      #     ref = [keepers[idx].name, idx]
+                      #     # bt_criteria[(fk_name = sn_bt.foreign_key)] ||= [sn_bt.klass, []]
+                      #     # bt_criteria[fk_name].last << ref
+                      #     # bt_criteria[bt_col] = [sn_bt.klass, ref]
+
+                      #     # Maybe this is the most useful
+                      #     # First array is friendly column names, second is references
+                      #     foreign_uniques = (bt_criteria[sn_bt.name] ||= [sn_bt.klass, [], []])
+                      #     foreign_uniques[1] << ref
+                      #     foreign_uniques[2] << bt_col
+                      #     vus[bt_col] = foreign_uniques # And we can look up this growing set from any foreign column
                       [sn_bt.klass, keepers[idx].name, idx]
                     end
             if fk_id
@@ -482,74 +520,76 @@ module DutyFree
               bt_criteria_all_nil = false
             end
             bt_criteria[(fk_name = sn_bt.foreign_key)] = fk_id
+
             # Add to our criteria if this belongs_to is required
-            # %%% Rails older than 5.0 handles this stuff differently!
-            if sn_bt.options[:optional] || !sn_bt.klass.belongs_to_required_by_default
-              # Should not have this fk as a requirement
-              uniq_lookups.delete(fk_name) if only_valid_uniques && uniq_lookups.include?(fk_name)
-            else # Add to the criteria
-              criteria[fk_name] = fk_id
-            end
+            bt_req_by_default = sn_bt.klass.respond_to?(:belongs_to_required_by_default) &&
+                                sn_bt.klass.belongs_to_required_by_default
+
+            # The first check, "!all_vus.keys.first.exists { |k| k.start_with?(bt_prefix) }"
+            # is to see if one of the columns we're working with from the unique that we've chosen
+            # comes from the table referenced by this belongs_to (sn_bt).
+            next if all_vus.keys.first.none? { |k| k.start_with?(bt_prefix) } &&
+                    (sn_bt.options[:optional] || !bt_req_by_default)
+
+            # Add to the criteria
+            criteria[fk_name] = fk_id
           end
         end
 
-        @valid_uniques ||= {} # Fancy memoisation
-        col_list = cols.join('|')
-        unless (vus = @valid_uniques[col_list])
-          # Find all unique combinations that are available based on incoming columns, and
-          # pair them up with column number mappings.
-          template_column_objects = ::DutyFree::Extensions._recurse_def(self, all || import_template[:all], import_template).first
-          available = if trim_prefix.blank?
-                        template_column_objects.select { |col| col.pre_prefix.blank? && col.prefix.blank? }
-                      else
-                        trim_prefix_snake = trim_prefix.downcase.tr(' ', '_')
-                        template_column_objects.select do |col|
-                          this_prefix = ::DutyFree::Util._prefix_join([col.pre_prefix, col.prefix], '_').tr('.', '_')
-                          trim_prefix_snake == "#{this_prefix}_"
-                        end
-                      end.map { |avail| avail.name.to_s.titleize }
-          vus = defined_uniques(uniques, cols, nil, starred).select do |k, _v|
-            is_good = true
-            k.each do |k_col|
-              unless available.include?(k_col) || available_bts.include?(k_col)
-                is_good = false
-                break
+        if is_new_vus
+          available += available_bts
+          all_vus.each do |k, v|
+            combined_k = []
+            combined_v = []
+            k.each_with_index do |key, idx|
+              if available.include?(key)
+                combined_k << key
+                combined_v << v[idx]
               end
             end
-            is_good
+            vus[combined_k] = combined_v unless combined_k.empty?
           end
-          @valid_uniques[col_list] = vus
         end
 
+        # uniq_lookups = vus.inject({}) do |s, v|
+        #   return s if available_bts.include?(v.first) # These will be provided in criteria, and not uniq_lookups
+
+        #   # uniq_lookups[k[trim_prefix.length..-1].downcase.tr(' ', '_').to_sym] = val[idx] if k.start_with?(trim_prefix)
+        #   s[v.first.downcase.tr(' ', '_').to_sym] = v.last
+        #   s
+        # end
+
+        new_criteria_all_nil = bt_criteria_all_nil
+
         # Make sure they have at least one unique combination to take cues from
         unless vus.empty? # raise NoUniqueColumnError.new(I18n.t('import.no_unique_column_error'))
           # Convert the first entry to a simplified hash, such as:
           #   {[:investigator_institutions_name, :investigator_institutions_email] => [8, 9], ...}
           #     to {:name => 8, :email => 9}
-          key, val = vus.first
+          key, val = vus.first # Utilise the first identified set of valid uniques
           key.each_with_index do |k, idx|
             next if available_bts.include?(k) # These will be provided in criteria, and not uniq_lookups
 
             # uniq_lookups[k[trim_prefix.length..-1].downcase.tr(' ', '_').to_sym] = val[idx] if k.start_with?(trim_prefix)
-            uniq_lookups[k.downcase.tr(' ', '_').to_sym] = val[idx]
-          end
-        end
-
-        # Find by all corresponding columns
+            k_sym = k.downcase.tr(' ', '_').to_sym
+            v = val[idx]
+            uniq_lookups[k_sym] = v # The column number in which to find the data
 
-        new_criteria_all_nil = bt_criteria_all_nil
-        unless only_valid_uniques
-          uniq_lookups.each do |k, v|
-            next if bt_col_indexes.include?(v)
+            next if only_valid_uniques || bt_col_indexes.include?(v)
 
+            # Find by all corresponding columns
             if (row_value = row[v])
               new_criteria_all_nil = false
-              criteria[k.to_sym] = row_value
+              criteria[k_sym] = row_value # The data, or how to look up the data
             end
           end
         end
 
         # Short-circuiting this to only get back the valid_uniques?
+        # unless uniq_lookups == criteria
+        #   puts "Compare #{uniq_lookups.inspect}"
+        #   puts "Compare #{criteria.inspect}"
+        # end
         return uniq_lookups.merge(criteria) if only_valid_uniques
 
         # If there's nothing to match upon then we're out
@@ -560,35 +600,37 @@ module DutyFree
         found_object = klass_or_collection.find_by(criteria)
         # If not successful, such as when fields are exposed via helper methods instead of being
         # real columns in the database tables, try this more intensive routine.
-        found_object ||= klass_or_collection.find do |obj|
-          is_good = true
-          criteria.each do |k, v|
-            if obj.send(k).to_s != v.to_s
-              is_good = false
-              break
+        unless found_object || klass_or_collection.is_a?(Array)
+          found_object = klass_or_collection.find do |obj|
+            is_good = true
+            criteria.each do |k, v|
+              if obj.send(k).to_s != v.to_s
+                is_good = false
+                break
+              end
             end
+            is_good
           end
-          is_good
         end
         [found_object, criteria.merge(bt_criteria)]
       end
 
     private
 
-      def defined_uniques(uniques, cols = [], col_list = nil, starred = [])
+      def defined_uniques(uniques, cols = [], col_list = nil, starred = [], trim_prefix = '')
         col_list ||= cols.join('|')
-        @defined_uniques ||= {}
-        unless (defined_uniq = @defined_uniques[col_list])
+        unless (defined_uniq = (@defined_uniques ||= {})[col_list])
           utilised = {} # Track columns that have been referenced thusfar
           defined_uniq = uniques.each_with_object({}) do |unique, s|
             if unique.is_a?(Array)
               key = []
               value = []
               unique.each do |unique_part|
-                val = cols.index(unique_part_name = unique_part.to_s.titleize)
-                next if val.nil?
+                val = (unique_part_name = unique_part.to_s.titleize).start_with?(trim_prefix) &&
+                      cols.index(upn = unique_part_name[trim_prefix.length..-1])
+                next unless val
 
-                key << unique_part_name
+                key << upn
                 value << val
               end
               unless key.empty?
@@ -596,12 +638,14 @@ module DutyFree
                 utilised[key] = nil
               end
             else
-              val = cols.index(unique_part_name = unique.to_s.titleize)
-              unless val.nil?
-                s[[unique_part_name]] = [val]
-                utilised[[unique_part_name]] = nil
+              val = (unique_name = unique.to_s.titleize).start_with?(trim_prefix) &&
+                    cols.index(un = unique_name[trim_prefix.length..-1])
+              if val
+                s[[un]] = [val]
+                utilised[[un]] = nil
               end
             end
+            s
           end
           if defined_uniq.empty?
             (starred - utilised.keys).each { |star| defined_uniq[[star]] = [cols.index(star)] }
@@ -616,8 +660,8 @@ module DutyFree
     # The snake-cased column alias names used in the query to export data
     def self._template_columns(klass, import_template = nil)
       template_detail_columns = klass.instance_variable_get(:@template_detail_columns)
-      if (template_import_columns = klass.instance_variable_get(:@template_import_columns)) != import_template
-        klass.instance_variable_set(:@template_import_columns, template_import_columns = import_template)
+      if klass.instance_variable_get(:@template_import_columns) != import_template
+        klass.instance_variable_set(:@template_import_columns, import_template)
         klass.instance_variable_set(:@template_detail_columns, (template_detail_columns = nil))
       end
       unless template_detail_columns
@@ -639,7 +683,7 @@ module DutyFree
         s + if col.is_a?(Hash)
               col.inject([]) do |s2, v|
                 joins << { v.first.to_sym => (joins_array = []) }
-                s2 += _recurse_def(klass, (v.last.is_a?(Array) ? v.last : [v.last]), import_template, assocs, joins_array, prefixes, v.first.to_sym).first
+                s2 + _recurse_def(klass, (v.last.is_a?(Array) ? v.last : [v.last]), import_template, assocs, joins_array, prefixes, v.first.to_sym).first
               end
             elsif col.nil?
               if assocs.empty?
@@ -658,9 +702,13 @@ module DutyFree
     end
   end # module Extensions
 
-  class NoUniqueColumnError < ActiveRecord::RecordNotUnique
+  # Rails < 4.0 doesn't have ActiveRecord::RecordNotUnique, so use the more generic ActiveRecord::ActiveRecordError instead
+  ar_not_unique_error = ActiveRecord.const_defined?('RecordNotUnique') ? ActiveRecord::RecordNotUnique : ActiveRecord::ActiveRecordError
+  class NoUniqueColumnError < ar_not_unique_error
   end
 
-  class LessThanHalfAreMatchingColumnsError < ActiveRecord::RecordInvalid
+  # Rails < 4.2 doesn't have ActiveRecord::RecordInvalid, so use the more generic ActiveRecord::ActiveRecordError instead
+  ar_invalid_error = ActiveRecord.const_defined?('RecordInvalid') ? ActiveRecord::RecordInvalid : ActiveRecord::ActiveRecordError
+  class LessThanHalfAreMatchingColumnsError < ar_invalid_error
   end
 end

data/lib/duty_free/suggest_template.rb

@@ -40,15 +40,18 @@ module DutyFree
       assocs = {}
       this_klass.reflect_on_all_associations.each do |assoc|
         # PolymorphicReflection AggregateReflection RuntimeReflection
-        is_belongs_to = assoc.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        is_belongs_to = assoc.belongs_to? # is_a?(ActiveRecord::Reflection::BelongsToReflection)
         # 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.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection))
+          elsif (is_habtm = assoc.respond_to?(:macro) ? (assoc.macro == :has_and_belongs_to_many) : assoc.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection))
             'has_and_belongs_to_many'
+          elsif assoc.respond_to?(:macro) ? (assoc.macro == :has_many) : assoc.is_a?(ActiveRecord::Reflection::HasManyReflection)
+            'has_many'
           else
-            (assoc.is_a?(ActiveRecord::Reflection::HasManyReflection) ? 'has_many' : 'has_one')
+            'has_one'
           end
         # Always process belongs_to, and also process has_one and has_many if do_has_many is chosen.
         # Skip any HMT or HABTM. (Maybe break out HABTM into a combo HM and BT in the future.)
@@ -178,7 +181,8 @@ module DutyFree
     # Find belongs_tos for this model to one more more other klasses
     def self._find_belongs_tos(klass, to_klass, errored_assocs)
       klass.reflect_on_all_associations.each_with_object([]) do |bt_assoc, s|
-        next unless bt_assoc.is_a?(ActiveRecord::Reflection::BelongsToReflection) && !errored_assocs.include?(bt_assoc)
+        # .is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        next unless bt_assoc.belongs_to? && !errored_assocs.include?(bt_assoc)
 
         begin
           s << bt_assoc if !bt_assoc.polymorphic? && bt_assoc.klass == to_klass

data/lib/duty_free/util.rb

@@ -35,20 +35,34 @@ module DutyFree
         end
 
       # ActiveRecord AREL objects
-      elsif piece.is_a?(Arel::Nodes::JoinSource)
-        # The left side is the "FROM" table
-        # names += _recurse_arel(piece.left)
-        # The right side is an array of all JOINs
-        names += piece.right.inject([]) { |s, v| s + _recurse_arel(v) }
       elsif piece.is_a?(Arel::Nodes::Join) # INNER or OUTER JOIN
-        # The left side is the "JOIN" table
-        names += _recurse_arel(piece.left)
-        # (The right side of these is the "ON" clause)
+        # 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".
+          # The left side here is either another earlier JOIN, or at the end of the whole tree, it is
+          # the first table.
+          names += _recurse_arel(piece.left)
+          # 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.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.name
       elsif piece.is_a?(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!
+        # The left side is the "FROM" table
+        # names += _recurse_arel(piece.left)
+        names << 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

data/lib/duty_free/version_number.rb

@@ -5,7 +5,7 @@ module DutyFree
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 4
+    TINY = 5
 
     # 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.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-15 00:00:00.000000000 Z
+date: 2020-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -204,10 +204,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-description: |
-  An ActiveRecord extension that simplifies importing and exporting of data
-  stored in one or more models.  Source and destination can be CSV, XLS,
-  XLSX, ODT, HTML tables, or simple Ruby arrays.
+description: 'Simplify data imports and exports with this slick ActiveRecord extension
+
+'
 email: lorint@gmail.com
 executables: []
 extensions: []
@@ -243,7 +242,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.3.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="