duty_free 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c9a4a9d552788b5fa4d273e4c000d8d12bbd7f8808eb7904c69bc57c7ccbd61
-  data.tar.gz: 3e7ccb0be3785814ef2c2bcb488b73d52a956c9ebcc6365ab9a0e3a4160a3924
+  metadata.gz: 87d07568c8c7a1692981435e098bd8426d17f30cd733ffff01a7b5a4e4fee4a9
+  data.tar.gz: 1d2ef595a271f40e5489cac67e576b4f85338d43d46bff26c6e5a6d706766a00
 SHA512:
-  metadata.gz: 10df4b7fbf2d78d2f4c9d24ea318461465e61064697b315e5f84ed92e2d342347a17d0c07e2440858f19453fe0a128524ba70b1adb7c7a564ed84d786ffca7b1
-  data.tar.gz: 1e377aa74a39e3fe9b3f4accda7ef83535bf3ca2b0fe36de1b3b50289df30a96192d6eca22265e4d6749cf2101b4316cc29211fb450aeb0c2112f84b64f031d8
+  metadata.gz: 4bdd6c53f65cb096de1c2da724a735ecee7ceaed464627f69adbb816b3afa20c85a202cce201a7ee5d35e52ae31663c7f8a9c02d47bc11ea7ead86cebfb0972f
+  data.tar.gz: 4664e2b6e724f3bba469ef1907b82fe25d90761251ff5cabb204bd75e1a64b522ba3a438438a76e5d58e80952870334abb8194d9d0199b6e2addb2143120b5fa

data/lib/duty_free/column.rb

@@ -5,15 +5,15 @@ require 'duty_free/util'
 module DutyFree
   # Holds detail about each column as we recursively explore the scope of what to import
   class Column
-    attr_accessor :name, :pre_prefix, :prefix, :prefix_assocs, :import_columns_as
+    attr_accessor :name, :pre_prefix, :prefix, :prefix_assocs, :import_template_as
     attr_writer :obj_class
 
-    def initialize(name, pre_prefix, prefix, prefix_assocs, obj_class, import_columns_as)
+    def initialize(name, pre_prefix, prefix, prefix_assocs, obj_class, import_template_as)
       self.name = name
       self.pre_prefix = pre_prefix
       self.prefix = prefix
       self.prefix_assocs = prefix_assocs
-      self.import_columns_as = import_columns_as
+      self.import_template_as = import_template_as
       self.obj_class = obj_class
     end
 
@@ -48,7 +48,7 @@ module DutyFree
     # The snake-cased column name to be used for building the full list of template_columns
     def sym_string
       @sym_string ||= ::DutyFree::Util._prefix_join(
-        [pre_prefix, prefix, ::DutyFree::Util._clean_name(name, import_columns_as)],
+        [pre_prefix, prefix, ::DutyFree::Util._clean_name(name, import_template_as)],
         '_'
       ).tr('.', '_')
     end

data/lib/duty_free/extensions.rb

@@ -2,10 +2,7 @@
 
 require 'duty_free/column'
 require 'duty_free/suggest_template'
-# require 'duty_free/attribute_serializers/object_attribute'
-# require 'duty_free/attribute_serializers/object_changes_attribute'
 # require 'duty_free/model_config'
-# require 'duty_free/record_trail'
 
 # :nodoc:
 module DutyFree
@@ -21,22 +18,40 @@ module DutyFree
       # end
 
       # Export at least column header, and optionally include all existing data as well
-      def df_export(is_with_data = true, import_columns = nil)
+      def df_export(is_with_data = true, import_template = nil)
         # In case they are only supplying the columns hash
-        if is_with_data.is_a?(Hash) && !import_columns
-          import_columns = is_with_data
+        if is_with_data.is_a?(Hash) && !import_template
+          import_template = is_with_data
           is_with_data = true
         end
-        import_columns ||= if constants.include?(:IMPORT_COLUMNS)
-                             self::IMPORT_COLUMNS
-                           else
-                             suggest_template(0, false, false)
-                           end
-        rows = [friendly_columns(import_columns)]
+        import_template ||= if constants.include?(:IMPORT_TEMPLATE)
+                              self::IMPORT_TEMPLATE
+                            else
+                              suggest_template(0, false, false)
+                            end
+
+        # Friendly column names that end up in the first row of the CSV
+        # Required columns get prefixed with a *
+        requireds = (import_template[:required] || [])
+        rows = ::DutyFree::Extensions._template_columns(self, import_template).map do |col|
+          is_required = requireds.include?(col)
+          col = col.to_s.titleize
+          # Alias-ify the full column names
+          aliases = (import_template[:as] || [])
+          aliases.each do |k, v|
+            if col.start_with?(v)
+              col = k + col[v.length..-1]
+              break
+            end
+          end
+          (is_required ? '* ' : '') + col
+        end
+        rows = Array(rows)
+
         if is_with_data
           # Automatically create a JOINs strategy and select list to get back all related rows
-          template_cols, template_joins = recurse_def(import_columns[:all], import_columns)
-          relation = joins(template_joins)
+          template_cols, template_joins = ::DutyFree::Extensions._recurse_def(self, import_template[:all], import_template)
+          relation = 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.
@@ -46,7 +61,7 @@ module DutyFree
           mapping = our_names.zip(arel_alias_names).to_h
 
           relation.select(template_cols.map { |x| x.to_s(mapping) }).each do |result|
-            rows << template_columns(import_columns).map do |col|
+            rows << ::DutyFree::Extensions._template_columns(self, import_template).map do |col|
               value = result.send(col)
               case value
               when true
@@ -63,12 +78,16 @@ module DutyFree
       end
 
       # With an array of incoming data, the first row having column names, perform the import
-      def df_import(data, import_columns = nil)
-        import_columns ||= if constants.include?(:IMPORT_COLUMNS)
-                             self::IMPORT_COLUMNS
-                           else
-                             suggest_template(0, false, false)
-                           end
+      def df_import(data, import_template = nil)
+        self.instance_variable_set(:@defined_uniques, nil)
+        self.instance_variable_set(:@valid_uniques, nil)
+
+        import_template ||= if constants.include?(:IMPORT_TEMPLATE)
+                              self::IMPORT_TEMPLATE
+                            else
+                              suggest_template(0, false, false)
+                            end
+        puts "Chose #{import_template}"
         inserts = []
         updates = []
         counts = Hash.new { |h, k| h[k] = [] }
@@ -79,17 +98,18 @@ module DutyFree
         cols = nil
         starred = []
         partials = []
-        all = import_columns[:all]
+        all = import_template[:all]
         keepers = {}
         valid_unique = nil
         existing = {}
         devise_class = ''
+        ret = nil
 
         reference_models = if Object.const_defined?('Apartment')
                              Apartment.excluded_models
                            else
                              []
-        end
+                           end
 
         if Object.const_defined?('Devise')
           Object.const_get('Devise') # If this fails, devise_class will remain a blank string.
@@ -123,13 +143,14 @@ module DutyFree
         # Will show as just one transaction when using auditing solutions such as PaperTrail
         ActiveRecord::Base.transaction do
           # Check to see if they want to do anything before the whole import
-          if before_import ||= (import_columns[:before_import]) # || some generic before_import)
+          if before_import ||= (import_template[:before_import]) # || some generic before_import)
             before_import.call(data)
           end
+          col_list = nil
           data.each_with_index do |row, row_num|
             row_errors = {}
             if is_first # Anticipate that first row has column names
-              uniques = import_columns[:uniques]
+              uniques = import_template[:uniques]
 
               # Look for UTF-8 BOM in very first cell
               row[0] = row[0][3..-1] if row[0].start_with?([239, 187, 191].pack('U*'))
@@ -154,10 +175,13 @@ module DutyFree
                   col.strip!
                 end
               end
-              defined_uniques(uniques, cols, starred)
-              cols.map! { |col| ::DutyFree::Util._clean_name(col, import_columns[:as]) } # %%%
+              # %%% 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?
+              defined_uniques(uniques, cols, cols.join('|'), starred)
+              cols.map! { |col| ::DutyFree::Util._clean_name(col, import_template[:as]) } # %%%
               # Make sure that at least half of them match what we know as being good column names
-              template_column_objects = recurse_def(import_columns[:all], import_columns).first
+              template_column_objects = ::DutyFree::Extensions._recurse_def(self, import_template[:all], import_template).first
               cols.each_with_index do |col, idx|
                 # prefixes = col_detail.pre_prefix + (col_detail.prefix.blank? ? [] : [col_detail.prefix])
                 keepers[idx] = template_column_objects.find { |col_obj| col_obj.titleize == col }
@@ -168,18 +192,25 @@ module DutyFree
               end
 
               # Returns just the first valid unique lookup set if there are multiple
-              valid_unique = valid_uniques(uniques, cols, starred, import_columns)
+              valid_unique = find_existing(uniques, cols, starred, import_template, keepers, false)
               # Make a lookup from unique values to specific IDs
-              existing = pluck(*([:id] + valid_unique.keys)).each_with_object(existing) { |v, s| s[v[1..-1].map(&:to_s)] = v.first; }
+              existing = pluck(*([:id] + valid_unique.keys)).each_with_object(existing) do |v, s|
+                s[v[1..-1].map(&:to_s)] = v.first
+                s
+              end
               is_first = false
             else # Normal row of data
               is_insert = false
               is_do_save = true
               existing_unique = valid_unique.inject([]) do |s, v|
-                s << row[v.last].to_s
+                s << if v.last.is_a?(Array)
+                       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
+                     end
               end
               # Check to see if they want to preprocess anything
-              if @before_process ||= import_columns[:before_process]
+              if @before_process ||= import_template[:before_process]
                 existing_unique = @before_process.call(valid_unique, existing_unique)
               end
               obj = if existing.include?(existing_unique)
@@ -200,17 +231,22 @@ module DutyFree
 
                 # Not the same as the last path?
                 if this_path && v.path != this_path.split(',').map(&:to_sym) && !is_has_one
-                  if sub_obj&.valid?
-                    # %%% Perhaps send them even invalid objects so they can be made valid here?
-                    if around_import_save
-                      around_import_save(sub_obj) do |yes_do_save|
-                        sub_obj.save if yes_do_save && sub_obj&.valid?
-                      end
+                  # puts sub_obj.class.name
+                  if respond_to?(:around_import_save)
+                    # Send them the sub_obj even if it might be invalid so they can choose
+                    # to make it valid if they wish.
+                    # binding.pry
+                    around_import_save(sub_obj) do |modded_obj = nil|
+                      modded_obj = (modded_obj || sub_obj)
+                      modded_obj.save if sub_obj&.valid?
                     end
+                  elsif sub_obj&.valid?
+                    # binding.pry if sub_obj.is_a?(Employee) && sub_obj.first_name == 'Andrew'
+                    sub_obj.save
                   end
                 end
                 sub_obj = obj
-                this_path = ''
+                this_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])
@@ -240,20 +276,36 @@ module DutyFree
                                    klass.new
                                  else
                                    # Try to find a unique item if one is referenced
-                                   trim_prefix = v.titleize[0..-(v.name.length + 2)]
+                                   sub_bt = nil
                                    begin
-                                     sub_unique = assoc.klass.valid_uniques(uniques, cols, starred, import_columns, all, trim_prefix)
+                                     # 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 = ''
+                                     #   # binding.pry
+                                     # 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_cols = cols.map { |c| c.start_with?(trim_prefix) ? c[trim_prefix.length..-1] : nil }
+                                       sub_bt, criteria = klass.find_existing(uniques, sub_cols, starred, import_template, keepers, assoc, row, klass, all, trim_prefix)
+                                     else
+                                       sub_bt, criteria = klass.find_existing(uniques, cols, starred, import_template, keepers, nil, row, klass, all, trim_prefix)
+                                     end
                                    rescue ::DutyFree::NoUniqueColumnError
                                      sub_unique = nil
                                    end
-                                   # Find by all corresponding columns
-                                   criteria = sub_unique&.inject({}) do |s, v|
-                                     s[v.first.to_sym] = row[v.last]
-                                     s
-                                   end
-                                   # Try looking up this belongs_to object through ActiveRecord
-                                   sub_bt = assoc.klass.find_by(criteria) if criteria
-                                   sub_bt || sub_obj.send("#{path_part}=", klass.new(criteria || {}))
+                                   # binding.pry if sub_obj.is_a?(Employee) && sub_obj.first_name == 'Nancy' &&
+                                   #   sub_bt.is_a?(Employee)
+                                   # %%% Can criteria really ever be nil anymore?
+                                   sub_bt ||= klass.new(criteria || {})
+                                   sub_obj.send("#{path_part}=", sub_bt)
+                                   sub_bt # unless klass == sub_obj.class # Don't go further if it's self-referencing
                                  end
                     end
                     # Look for possible missing polymorphic detail
@@ -266,25 +318,16 @@ module DutyFree
                     if sub_next.is_a?(ActiveRecord::Associations::CollectionProxy)
                       # Try to find a unique item if one is referenced
                       # %%% There is possibility that when bringing in related classes using a nil
-                      # in IMPORT_COLUMNS[:all] that this will break.  Need to test deeply nested things.
+                      # 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)]
-                      puts sub_next.klass
-                      sub_unique = sub_next.klass.valid_uniques(uniques, cols, starred, import_columns, all, trim_prefix)
-                      # Find by all corresponding columns
-                      criteria = sub_unique.each_with_object({}) { |v, s| s[v.first.to_sym] = row[v.last]; }
-                      sub_hm = sub_next.find do |hm_obj|
-                        is_good = true
-                        criteria.each do |k, v|
-                          if hm_obj.send(k).to_s != v.to_s
-                            is_good = false
-                            break
-                          end
-                        end
-                        is_good
-                      end
-                      # Try looking it up through ActiveRecord
-                      sub_hm = sub_next.find_by(criteria) if sub_hm.nil?
+                      trim_prefix << ' ' unless trim_prefix.blank?
+                      klass = sub_next.klass
+                      # binding.pry if klass.name == 'OrderDetail'
+
+                      # 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)
+
                       # If still not found then create a new related object using this has_many collection
                       sub_next = sub_hm || sub_next.new(criteria)
                     end
@@ -305,11 +348,10 @@ module DutyFree
                 next if sub_obj.nil?
 
                 sym = "#{v.name}=".to_sym
-                sub_class = sub_obj.class
                 next unless sub_obj.respond_to?(sym)
 
-                col_type = sub_class.columns_hash[v.name.to_s]&.type
-                if col_type.nil? && (virtual_columns = import_columns[:virtual_columns]) &&
+                col_type = (sub_class = 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]
                 end
@@ -347,13 +389,18 @@ module DutyFree
                 end
               end
 
-              # Give a window of opportinity to tweak user objects controlled by Devise
-              is_do_save = before_devise_save(obj, existing) if before_devise_save && obj.class.name == devise_class
+              # Give a window of opportunity to tweak user objects controlled by Devise
+              obj_class = obj.class
+              is_do_save = if obj_class.respond_to?(:before_devise_save) && obj_class.name == devise_class
+                             obj_class.before_devise_save(obj, existing)
+                           else
+                             true
+                           end
 
               if obj.valid?
                 obj.save if is_do_save
                 # Snag back any changes to the unique columns.  (For instance, Devise downcases email addresses.)
-                existing_unique = valid_unique.keys.inject([]) { |s, v| s << obj.send(v) }
+                existing_unique = valid_unique.keys.inject([]) { |s, v| s << obj.send(v).to_s }
                 # Update the duplicate counts and inserted / updated results
                 counts[existing_unique] << row_num
                 (is_insert ? inserts : updates) << { row_num => existing_unique } if is_do_save
@@ -365,65 +412,40 @@ module DutyFree
               errors << { row_num => row_errors } unless row_errors.empty?
             end
           end
-          duplicates = counts.inject([]) do |s, v|
-            s + v.last[1..-1].map { |line_num| { line_num => v.first } } if v.last.count > 1
+          duplicates = counts.each_with_object([]) do |v, s|
+            s += v.last[1..-1].map { |line_num| { line_num => v.first } } if v.last.count > 1
+            s
           end
-          # Check to see if they want to do anything before the whole import
+          # Check to see if they want to do anything after the import
           ret = { inserted: inserts, updated: updates, duplicates: duplicates, errors: errors }
-          if @after_import ||= (import_columns[:after_import]) # || some generic after_import)
+          if @after_import ||= (import_template[:after_import]) # || some generic after_import)
             ret = ret2 if (ret2 = @after_import.call(ret)).is_a?(Hash)
           end
         end
         ret
       end
 
-      # Friendly column names that end up in the first row of the CSV
-      # Required columns get prefixed with a *
-      def friendly_columns(import_columns = self::IMPORT_COLUMNS)
-        requireds = (import_columns[:required] || [])
-        template_columns(import_columns).map do |col|
-          is_required = requireds.include?(col)
-          col = col.to_s.titleize
-          # Alias-ify the full column names
-          aliases = (import_columns[:as] || [])
-          aliases.each do |k, v|
-            if col.start_with?(v)
-              col = k + col[v.length..-1]
-              break
-            end
-          end
-          (is_required ? '* ' : '') + col
-        end
-      end
-
-      # The snake-cased column alias names used in the query to export data
-      def template_columns(import_columns = nil)
-        if @template_import_columns != import_columns
-          @template_import_columns = import_columns
-          @template_detail_columns = nil
-        end
-        @template_detail_columns ||= recurse_def(import_columns[:all], import_columns).first.map(&:to_sym)
-      end
-
       # For use with importing, based on the provided column list calculate all valid combinations
       # of unique columns.  If there is no valid combination, throws an error.
-      def valid_uniques(uniques, cols, starred, import_columns, all = nil, trim_prefix = '')
-        col_name_offset = (trim_prefix.blank? ? 0 : trim_prefix.length + 1)
+      # Returns an object found by this means.
+      def find_existing(uniques, cols, starred, import_template, keepers, train_we_came_in_here_on, row = nil, obj = nil, all = nil, trim_prefix = '')
+        col_name_offset = trim_prefix.length
         @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 = recurse_def(all || import_columns[:all], import_columns).first
+          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|
-                          trim_prefix_snake == ::DutyFree::Util._prefix_join([col.pre_prefix, col.prefix], '_').tr('.', '_')
+                          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, starred).select do |k, _v|
+          vus = defined_uniques(uniques, cols, nil, starred).select do |k, _v|
             is_good = true
             k.each do |k_col|
               unless k_col.start_with?(trim_prefix) && available.include?(k_col[col_name_offset..-1])
@@ -437,26 +459,91 @@ module DutyFree
         end
 
         # Make sure they have at least one unique combination to take cues from
-        raise ::DutyFree::NoUniqueColumnError, I18n.t('import.no_unique_column_error') if vus.empty?
-
-        # 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
         ret = {}
-        key.each_with_index do |k, idx|
-          ret[k[col_name_offset..-1].downcase.tr(' ', '_').to_sym] = val[idx]
+        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.each_with_index do |k, idx|
+            ret[k[col_name_offset..-1].downcase.tr(' ', '_').to_sym] = val[idx] if k.start_with?(trim_prefix)
+          end
         end
-        ret
+
+        # %%% If uniqueness is based on something else hanging out on a belongs_to then we're pretty hosed.
+        # (Case in point, importing Order with related Order Detail and Product, and then Product needs to
+        # be found or built first before OrderDetail.)
+        # Might have to do a deferred save kind of thing, and also make sure the product stuff came first
+        # before the other stuff
+
+        # Add in any foreign key stuff we can find from other belongs_to associations
+        # %%% This is starting to look like the other BelongsToAssociation code above around line
+        # 697, so it really needs to be turned into something recursive instead of this two-layer
+        # thick thing at best.
+        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) &&
+             sn_assoc.klass != self # Omit stuff pointing to us (like self-referencing stuff)
+            # %%% Make sure there's a starred column we know about from this one
+            ret[sn_assoc.foreign_key] = nil if train_we_came_in_here_on == false
+            s << sn_assoc
+          end
+          s
+        end
+
+        # Find by all corresponding columns
+        criteria = {}
+        if train_we_came_in_here_on != false
+          criteria = ret.each_with_object({}) do |v, s|
+            s[v.first.to_sym] = row[v.last]
+            s
+          end
+        end
+
+        bts.each do |sn_bt|
+          # This search prefix becomes something like "Order Details Product "
+          cols.each_with_index do |bt_col, idx|
+            next unless bt_col.start_with?(trim_prefix + "#{sn_bt.name.to_s.underscore.tr('_', ' ').titleize} ")
+
+            fk_id = if row
+                      # Max ID so if there are multiple, only the most recent one is picked.
+                      # %%% Need to stack these up in case there are multiple (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
+                      [sn_bt.klass, keepers[idx].name, idx]
+                    end
+            criteria[sn_bt.foreign_key] = fk_id
+          end
+        end
+
+        # Short-circuiting this to only get back the valid_uniques?
+        return ret.merge(criteria) if train_we_came_in_here_on == false
+
+        # With this criteria, find any matching has_many row we can so we can update it
+        sub_hm = obj.find do |hm_obj|
+          is_good = true
+          criteria.each do |k, v|
+            if hm_obj.send(k).to_s != v.to_s
+              is_good = false
+              break
+            end
+          end
+          is_good
+        end
+        # Try looking it up through ActiveRecord
+        # %%% Should we perhaps do this first before the more intensive find routine above?
+        sub_hm = obj.find_by(criteria) if sub_hm.nil?
+        [sub_hm, criteria]
       end
 
     private
 
-      def defined_uniques(uniques, cols = [], starred = [])
+      def defined_uniques(uniques, cols = [], col_list = nil, starred = [])
+        col_list ||= cols.join('|')
         @defined_uniques ||= {}
-        unless (defined_uniques = @defined_uniques[cols])
+        unless (defined_uniq = @defined_uniques[col_list])
           utilised = {} # Track columns that have been referenced thusfar
-          defined_uniques = uniques.each_with_object({}) do |unique, s|
+          defined_uniq = uniques.each_with_object({}) do |unique, s|
             if unique.is_a?(Array)
               key = []
               value = []
@@ -479,42 +566,56 @@ module DutyFree
               end
             end
           end
-          (starred - utilised.keys).each { |star| defined_uniques[[star]] = [cols.index(star)] }
-          @defined_uniques[cols] = defined_uniques
+          (starred - utilised.keys).each { |star| defined_uniq[[star]] = [cols.index(star)] }
+          @defined_uniques[col_list] = defined_uniq
         end
-        defined_uniques
+        defined_uniq
       end
+    end # module ClassMethods
 
-      # Recurse and return two arrays -- one with all columns in sequence, and one a hierarchy of
-      # nested hashes to be used with ActiveRecord's .joins() to facilitate export.
-      def recurse_def(array, import_columns, assocs = [], joins = [], pre_prefix = '', prefix = '')
-        # Confirm we can actually navigate through this association
-        prefix_assoc = (assocs.last&.klass || self).reflect_on_association(prefix) if prefix.present?
-        assocs = assocs.dup << prefix_assoc unless prefix_assoc.nil?
-        prefixes = ::DutyFree::Util._prefix_join([pre_prefix, prefix])
-        array = array.inject([]) do |s, col|
-          s += if col.is_a?(Hash)
-                 col.inject([]) do |s2, v|
-                   joins << { v.first.to_sym => (joins_array = []) }
-                   s2 += recurse_def((v.last.is_a?(Array) ? v.last : [v.last]), import_columns, assocs, joins_array, prefixes, v.first.to_sym).first
-                 end
-               elsif col.nil?
-                 if assocs.empty?
-                   []
-                 else
-                   # Bring in from another class
-                   joins << { prefix => (joins_array = []) }
-                   # %%% Also bring in uniques and requireds
-                   recurse_def(assocs.last.klass::IMPORT_COLUMNS[:all], import_columns, assocs, joins_array, prefixes).first
-                 end
-               else
-                 [::DutyFree::Column.new(col, pre_prefix, prefix, assocs, self, import_columns[:as])]
-               end
-          s
-        end
-        [array, joins]
+    # 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)
+        klass.instance_variable_set(:@template_detail_columns, (template_detail_columns = nil))
       end
-    end # module ClassMethods
+      unless template_detail_columns
+        puts "* Redoing *"
+        template_detail_columns = _recurse_def(klass, import_template[:all], import_template).first.map(&:to_sym)
+        klass.instance_variable_set(:@template_detail_columns, template_detail_columns)
+      end
+      template_detail_columns
+    end
+
+    # Recurse and return two arrays -- one with all columns in sequence, and one a hierarchy of
+    # nested hashes to be used with ActiveRecord's .joins() to facilitate export.
+    def self._recurse_def(klass, array, import_template, assocs = [], joins = [], pre_prefix = '', prefix = '')
+      # Confirm we can actually navigate through this association
+      prefix_assoc = (assocs.last&.klass || klass).reflect_on_association(prefix) if prefix.present?
+      assocs = assocs.dup << prefix_assoc unless prefix_assoc.nil?
+      prefixes = ::DutyFree::Util._prefix_join([pre_prefix, prefix])
+      array = array.inject([]) do |s, col|
+        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
+              end
+            elsif col.nil?
+              if assocs.empty?
+                []
+              else
+                # Bring in from another class
+                joins << { prefix => (joins_array = []) }
+                # %%% Also bring in uniques and requireds
+                _recurse_def(klass, assocs.last.klass::IMPORT_TEMPLATE[:all], import_template, assocs, joins_array, prefixes).first
+              end
+            else
+              [::DutyFree::Column.new(col, pre_prefix, prefix, assocs, klass, import_template[:as])]
+            end
+      end
+      [array, joins]
+    end
   end # module Extensions
 
   class NoUniqueColumnError < ActiveRecord::RecordNotUnique

data/lib/duty_free/suggest_template.rb

@@ -167,7 +167,7 @@ module DutyFree
                 # belongs_to is more involved since there may be multiple foreign keys which point
                 # from the foreign table to this primary one, so exclude all these links.
                 _find_belongs_tos(assoc.first.last, assoc.last, errored_assocs).map do |f_assoc|
-                  [f_assoc.foreign_key.to_s, f_assoc.active_record]
+                  [[f_assoc.foreign_key.to_s], f_assoc.active_record]
                 end
               end
             # puts "New Poison: #{new_poison_links.inspect}"
@@ -247,11 +247,11 @@ module DutyFree
       end
     end
 
-    # Show a "pretty" version of IMPORT_COLUMNS, to be placed in a model
+    # Show a "pretty" version of IMPORT_TEMPLATE, to be placed in a model
     def self._template_pretty_print(template, indent = 0, child_count = 0, is_hash_in_hash = false)
       unless indent.negative?
         if indent.zero?
-          print 'IMPORT_COLUMNS = '
+          print 'IMPORT_TEMPLATE = '
         else
           puts unless is_hash_in_hash
         end
@@ -305,7 +305,7 @@ module DutyFree
       if indent == 2
         puts
         indent = 0
-        puts '}'
+        puts '}.freeze'
       elsif indent >= 0
         print "#{' ' unless child_count.zero?}}"
       end

data/lib/duty_free/util.rb

@@ -57,11 +57,11 @@ module DutyFree
       prefixes.reject(&:blank?).join(separator || '.')
     end
 
-    def self._clean_name(name, import_columns_as)
+    def self._clean_name(name, import_template_as)
       return name if name.is_a?(Symbol)
 
       # Expand aliases
-      (import_columns_as || []).each do |k, v|
+      (import_template_as || []).each do |k, v|
         if (k[-1] == ' ' && name.start_with?(k)) || name == k
           name.replace(v + name[k.length..-1])
           break

data/lib/duty_free/version_number.rb

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

data/lib/generators/duty_free/USAGE

@@ -1,2 +1,2 @@
 Description:
-  Generates (but does not run) a migration to add a versions table.
+  Modifies an existing model so that it includes an IMPORT_TEMPLATE.

data/lib/generators/duty_free/install_generator.rb

@@ -4,18 +4,10 @@ require 'rails/generators'
 require 'rails/generators/active_record'
 
 module DutyFree
-  # Installs DutyFree in a rails app.
+  # Auto-generates an IMPORT_TEMPLATE entry for one or more models
   class InstallGenerator < ::Rails::Generators::Base
     include ::Rails::Generators::Migration
 
-    # Class names of MySQL adapters.
-    # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
-    # - `Mysql2Adapter` - Used by `mysql2` gem.
-    MYSQL_ADAPTERS = [
-      'ActiveRecord::ConnectionAdapters::MysqlAdapter',
-      'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
-    ].freeze
-
     source_root File.expand_path('templates', __dir__)
     class_option(
       :with_changes,
@@ -68,8 +60,14 @@ module DutyFree
       "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
     end
 
+    # Class names of MySQL adapters.
+    # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
+    # - `Mysql2Adapter` - Used by `mysql2` gem.
     def mysql?
-      MYSQL_ADAPTERS.include?(ActiveRecord::Base.connection.class.name)
+      [
+        'ActiveRecord::ConnectionAdapters::MysqlAdapter',
+        'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
+      ].freeze.include?(ActiveRecord::Base.connection.class.name)
     end
 
     # Even modern versions of MySQL still use `latin1` as the default character

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duty_free
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-29 00:00:00.000000000 Z
+date: 2020-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord