duty_free 1.0.8 → 1.0.10

data/lib/duty_free/util.rb

@@ -97,7 +97,7 @@ module DutyFree
 
     # ===================================
     # Epic require patch
-    def self._patch_require(module_filename, folder_matcher, search_text, replacement_text, autoload_symbol = nil)
+    def self._patch_require(module_filename, folder_matcher, replacements, autoload_symbol = nil, is_bundler = false)
       mod_name_parts = module_filename.split('.')
       extension = case mod_name_parts.last
                   when 'rb', 'so', 'o'
@@ -120,10 +120,17 @@ module DutyFree
           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) &&
+        if ::DutyFree::Util._write_patched(folder_matcher, module_filename, extension, custom_require_dir, nil, replacements) &&
            !alp.include?(custom_require_dir)
           alp.unshift(custom_require_dir)
         end
+      elsif is_bundler
+        puts "Bundler hack"
+        require 'pry-byebug'
+        binding.pry
+        x = 5
+        # bin_path
+        # puts Bundler.require.inspect
       else
         unless (require_overrides = ::DutyFree::Util.instance_variable_get(:@_require_overrides))
           ::DutyFree::Util.instance_variable_set(:@_require_overrides, (require_overrides = {}))
@@ -134,19 +141,19 @@ module DutyFree
           # 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|
+              # %%% Can get a message such as "ActionDispatch::Routing is not missing constant RouteSet! (NameError)"
+              # binding.pry if name.start_with?('action_dispatch/routing/route_') # || name == 'active_support/values/time_zone'
               if (require_override = ::DutyFree::Util.instance_variable_get(:@_require_overrides)[name])
-                extension, folder_matcher, search_text, replacement_text, autoload_symbol = require_override
+                extension, folder_matcher, replacements, 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))
+                  if (replacement_path = ::DutyFree::Util._write_patched(folder_matcher, name, extension, ::DutyFree::Util._custom_require_dir, patched_filename, replacements))
                     is_replaced = Kernel.send(:orig_require, replacement_path)
                   elsif replacement_path.nil?
                     puts "Couldn't find #{name} to require it!"
@@ -159,12 +166,13 @@ module DutyFree
             end
           end
         end
-        require_overrides[module_filename] = [extension, folder_matcher, search_text, replacement_text, autoload_symbol]
+        require_overrides[module_filename] = [extension, folder_matcher, replacements, autoload_symbol]
       end
     end
 
     def self._custom_require_dir
       unless (custom_require_dir = ::DutyFree::Util.instance_variable_get(:@_custom_require_dir))
+        require 'tmpdir'
         ::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)
@@ -178,11 +186,12 @@ module DutyFree
 
     # 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)
+    def self._write_patched(folder_matcher, name, extension, dir, patched_filename, replacements)
       # 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}")
+      puts (replacement_path = "#{dir}#{patched_filename || name}")
+      return false if File.exist?(replacement_path)
 
       # Dredge up the original .rb file, doctor it, and then require it instead
       num_written = nil
@@ -193,9 +202,14 @@ module DutyFree
         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))
+      puts [folder_matcher, name].inspect
+      if (updated_text = orig_as&.read)
+        File.open(replacement_path, 'w') do |replaced_file|
+          replacements = [replacements] unless replacements.first.is_a?(Array)
+          replacements.each do |search_text, replacement_text|
+            updated_text.gsub!(search_text, replacement_text)
+          end
+          num_written = replaced_file.write(updated_text)
         end
         orig_as.close
       end

data/lib/duty_free/version_number.rb

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

data/lib/duty_free.rb

@@ -50,15 +50,15 @@ if ActiveRecord.version < ::Gem::Version.new('3.2') &&
   # Remove circular reference for "now"
   ::DutyFree::Util._patch_require(
     'active_support/values/time_zone.rb', '/activesupport',
-    '  def parse(str, now=now)',
-    '  def parse(str, now=now())'
+    ['  def parse(str, now=now)',
+    '  def parse(str, now=now())']
   )
   # Remove circular reference for "reflection" for ActiveRecord 3.1
   if ActiveRecord.version >= ::Gem::Version.new('3.1')
     ::DutyFree::Util._patch_require(
       'active_record/associations/has_many_association.rb', '/activerecord',
-      'reflection = reflection)',
-      'reflection = reflection())',
+      ['reflection = reflection)',
+      'reflection = reflection())'],
       :HasManyAssociation # Make sure the path for this guy is available to be autoloaded
     )
   end
@@ -129,9 +129,21 @@ end
 # Major compatibility fixes for ActiveRecord < 4.2
 # ================================================
 ActiveSupport.on_load(:active_record) do
-  # Rails < 4.0 cannot do #find_by, #find_or_create_by, or do #pluck on multiple columns, so here are the patches:
-  if ActiveRecord.version < ::Gem::Version.new('4.0')
-    module ActiveRecord
+  # rubocop:disable Lint/ConstantDefinitionInBlock
+  module ActiveRecord
+    class Base
+      unless respond_to?(:execute_sql)
+        class << self
+          def execute_sql(sql, *param_array)
+            param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
+            connection.execute(send(:sanitize_sql_array, [sql] + param_array))
+          end
+        end
+      end
+    end
+
+    # Rails < 4.0 cannot do #find_by, #find_or_create_by, or do #pluck on multiple columns, so here are the patches:
+    if version < ::Gem::Version.new('4.0')
       # Normally find_by is in FinderMethods, which older AR doesn't have
       module Calculations
         def find_by(*args)
@@ -280,6 +292,7 @@ ActiveSupport.on_load(:active_record) do
       end
     end
   end
+  # rubocop:enable Lint/ConstantDefinitionInBlock
 
   # 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:
@@ -322,6 +335,7 @@ ActiveSupport.on_load(:active_record) do
   # First part of arel_table_type stuff:
   # ------------------------------------
   # (more found below)
+  # was:  ActiveRecord.version >= ::Gem::Version.new('3.2') &&
   if ActiveRecord.version < ::Gem::Version.new('5.0')
     # Used by Util#_arel_table_type
     module ActiveRecord
@@ -336,6 +350,17 @@ ActiveSupport.on_load(:active_record) do
   end
 
   include ::DutyFree::Extensions
+
+  unless ::DutyFree::Extensions::IS_AMOEBA
+    # Add amoeba-compatible support
+    module ActiveRecord
+      class Base
+        def self.amoeba(*args)
+          puts "Amoeba called from #{name} with #{args.inspect}"
+        end
+      end
+    end
+  end
 end
 
 # Do this earlier because stuff here gets mixed into JoinDependency::JoinAssociation and AssociationScope

data/lib/generators/duty_free/model_generator.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'fancy_gets'
+
+module DutyFree
+  # Auto-generates an IMPORT_TEMPLATE entry for a model
+  class ModelGenerator < ::Rails::Generators::Base
+    include FancyGets
+    # include ::Rails::Generators::Migration
+
+    # # source_root File.expand_path('templates', __dir__)
+    # class_option(
+    #   :with_changes,
+    #   type: :boolean,
+    #   default: false,
+    #   desc: 'Add IMPORT_TEMPLATE to model'
+    # )
+
+    desc 'Adds an appropriate IMPORT_TEMPLATE entry into a model of your choosing so that' \
+         '  DutyFree can perform exports, and with the Pro version, the same template also' \
+         '  does imports.'
+
+    def df_model_template
+      # %%% If Apartment is active, ask which schema they want
+
+      # Load all models
+      Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+
+      # Generate a list of viable models that can be chosen
+      longest_length = 0
+      model_info = Hash.new { |h, k| h[k] = {} }
+      tableless = Hash.new { |h, k| h[k] = [] }
+      models = ActiveRecord::Base.descendants.reject do |m|
+        trouble = if m.abstract_class?
+                    true
+                  elsif !m.table_exists?
+                    tableless[m.table_name] << m.name
+                    ' (No Table)'
+                  else
+                    this_f_keys = (model_info[m][:f_keys] = m.reflect_on_all_associations.select { |a| a.macro == :belongs_to }) || []
+                    column_names = (model_info[m][:column_names] = m.columns.map(&:name) - [m.primary_key, 'created_at', 'updated_at', 'deleted_at'] - this_f_keys.map(&:foreign_key))
+                    if column_names.empty? && this_f_keys && !this_f_keys.empty?
+                      fk_message = ", although #{this_f_keys.length} foreign keys"
+                      " (No columns#{fk_message})"
+                    end
+                  end
+        # puts "#{m.name}#{trouble}" if trouble&.is_a?(String)
+        trouble
+      end
+      models.sort! do |a, b| # Sort first to separate namespaced stuff from the rest, then alphabetically
+        is_a_namespaced = a.name.include?('::')
+        is_b_namespaced = b.name.include?('::')
+        if is_a_namespaced && !is_b_namespaced
+          1
+        elsif !is_a_namespaced && is_b_namespaced
+          -1
+        else
+          a.name <=> b.name
+        end
+      end
+      models.each do |m| # Find longest name in the list for future use to show lists on the right side of the screen
+        # Strangely this can't be inlined since it assigns to "len"
+        if longest_length < (len = m.name.length)
+          longest_length = len
+        end
+      end
+
+      model_name = ARGV[0]&.camelize
+      unless (starting = models.find { |m| m.name == model_name })
+        puts "#{"Couldn't find #{model_name}.  " if model_name}Pick a model to start from:"
+        starting = gets_list(
+          list: models,
+          on_select: proc do |item|
+            selected = item[:selected] || item[:focused]
+            this_model_info = model_info[selected]
+            selected.name + " (#{(this_model_info[:column_names] + this_model_info[:f_keys].map(&:name).map(&:upcase)).join(', ')})"
+          end
+        )
+      end
+      puts "\nThinking..."
+
+      # %%% Find out how many hops at most we can go from this model
+      max_hm_nav = starting.suggest_template(-1, true, false)
+      max_bt_nav = starting.suggest_template(-1, false, false)
+      hops_with_hm, num_hm_hops_tables = calc_num_hops([[starting, max_hm_nav[:all]]], models)
+      hops, num_hops_tables = calc_num_hops([[starting, max_bt_nav[:all]]], models)
+      # print "\b" * 11
+      unless hops_with_hm.length == hops.length
+        starting_name = starting.name
+        unless (is_hm = ARGV[1]&.downcase)
+          puts "Navigate from #{starting_name} using:\n#{'=' * (21 + starting_name.length)}"
+          is_hm = gets_list(
+            ["Only belongs_to (max of #{hops.length} hops and #{num_hops_tables} tables)",
+             "has_many as well as belongs_to (max of #{hops_with_hm.length} hops and #{num_hm_hops_tables} tables)"]
+          )
+        end
+        is_hm = is_hm.start_with?('has_many') || is_hm[0] == 'y'
+        hops = hops_with_hm if is_hm
+      end
+
+      unless (num_hops = ARGV[2]&.to_i)
+        puts "\nNow, how many hops total would you like to navigate?"
+        index = 0
+        cumulative = 0
+        hops_list = ['0'] + hops.map { |h| "#{index += 1} (#{cumulative += h.length} linkages)" }
+        num_hops = gets_list(
+          list: hops_list,
+          on_select: proc do |value|
+                       associations = Hash.new { |h, k| h[k] = 0 }
+                       index = (value[:selected] || value[:focused]).split(' ').first.to_i - 1
+                       layer = hops[index] if index >= 0
+                       layer ||= []
+                       layer.each { |i| associations[i.last] += 1 }
+                       associations.each { |k, v| associations.delete(k) if v == 1 }
+                       layer.map do |l|
+                         associations.keys.include?(l.last) ? "#{l.first.name.demodulize} #{l.last}" : l.last
+                       end.join(', ')
+                       # y = model_info[data[:focused].name]
+                       # data[:focused].name + " (#{(y[:column_names] + y[:f_keys].map(&:name).map(&:upcase)).join(', ')})"
+                       # layer.inspect
+                     end
+        ).split(' ').first.to_i
+      end
+
+      print "Navigating from #{starting_name}" if model_name
+      puts "\nOkay, #{num_hops} hops#{', including has_many,' if is_hm} it is!"
+      # Grab the console output from this:
+      original_stdout = $stdout
+      $stdout = StringIO.new
+      starting.suggest_template(num_hops, is_hm)
+      output = $stdout
+      $stdout = original_stdout
+      filename = nil
+      output.rewind
+      lines = output.each_line.each_with_object([]) do |line, s|
+        if line == "\n"
+          # Do nothing
+        elsif filename
+          s << line
+        elsif line.start_with?('# Place the following into ')
+          filename = line[27..-1]&.split(':')&.first
+        end
+        s
+      end
+
+      model_file = File.open(filename, 'r+')
+      insert_at = nil
+      starting_name = starting.name.demodulize
+      loop do
+        break if model_file.eof?
+
+        line_parts = model_file.readline.strip.gsub(/ +/, ' ').split(' ')
+        if line_parts.first == 'class' && line_parts[1] && (line_parts[1] == starting_name || line_parts[1].end_with?("::#{starting_name}"))
+          insert_at = model_file.pos
+          break
+        end
+      end
+      line = nil
+      import_template_blocks = []
+      import_template_block = nil
+      indentation = nil
+      # See if there's already any IMPORT_TEMPLATE entries in the model file.
+      # If there already is just one, we will comment it out if needs be before adding a fresh one.
+      loop do
+        break if model_file.eof?
+
+        line_parts = (line = model_file.readline).strip.split(/[\s=]+/)
+        indentation ||= line[0...(/\S/ =~ line)]
+        case line_parts[-2..-1]
+        when ['IMPORT_TEMPLATE', '{']
+          import_template_blocks << import_template_block if import_template_block
+          import_template_block = [model_file.pos - line.length, nil, line.strip[0] == '#', []]
+        when ['#', '------------------------------------------']
+          import_template_block[1] = model_file.pos if import_template_block # && import_template_block[1].nil?
+        end
+        next unless import_template_block
+
+        # Collect all the lines of any existing block
+        import_template_block[3] << line
+        # Cap this one if it's done
+        if import_template_block[1]
+          import_template_blocks << import_template_block
+          import_template_block = nil
+        end
+      end
+      import_template_blocks << import_template_block if import_template_block
+      comments = nil
+      is_add_cr = nil
+      if import_template_blocks.length > 1
+        # %%% maybe in the future:  remove any older commented ones
+        puts 'Found multiple existing import template blocks.  Will not attempt to automatically add yet another.'
+        insert_at = nil
+      elsif import_template_blocks.length == 1
+        # Get set up to add the new block after the existing one
+        insert_at = (import_template_block = import_template_blocks.first)[1]
+        if insert_at.nil?
+          puts "Found what looked like the start of an existing IMPORT_TEMPLATE block, but couldn't determine where it ends.  Will not attempt to automatically add anything."
+        elsif import_template_block[2] # Already commented
+          is_add_cr = true
+        else # Needs to be commented
+          # Find what kind and how much indentation is present from the first commented line
+          indentation = import_template_block[3].first[0...(/\S/ =~ import_template_block[3].first)]
+          comments = import_template_block[3].map { |l| "#{l[0...indentation.length]}# #{l[indentation.length..-1]}" }
+        end
+        # else # Must be no IMPORT_TEMPLATE block yet
+        #   insert_at = model_file.pos
+      end
+      if insert_at.nil?
+        puts "Please edit #{filename} manually and add this code:\n\n#{lines.join}"
+      else
+        is_good = ARGV[3]&.downcase&.start_with?('y')
+        args = [starting_name,
+                is_hm ? 'has_many' : 'no',
+                num_hops]
+        args << 'yes' if is_good
+        args = args.each_with_object(+'') do |v, s|
+          s << " #{v}"
+          s
+        end
+        lines.unshift("# Added #{DateTime.now.strftime('%b %d, %Y %I:%M%P')} by running `bin/rails g duty_free:model#{args}`\n")
+        # add a new one afterwards
+        print is_good ? 'Will' : 'OK to'
+        print "#{" comment #{comments.length} existing lines and" if comments} add #{lines.length} new lines to #{filename}"
+        puts is_good ? '.' : '?'
+        if is_good || gets_list(%w[Yes No]) == 'Yes'
+          # Store rest of file
+          model_file.pos = insert_at
+          rest_of_file = model_file.read
+          if comments
+            model_file.pos = import_template_block[0]
+            model_file.write("#{comments.join}\n")
+            puts "Commented #{comments.length} existing lines"
+          else
+            model_file.pos = insert_at
+          end
+          model_file.write("\n") if is_add_cr
+          model_file.write(lines.map { |l| "#{indentation}#{l}" }.join)
+          model_file.write(rest_of_file)
+        end
+      end
+      model_file.close
+    end
+
+  private
+
+    # def calc_num_hops(all, num = 0)
+    #   max_num = num
+    #   all.each do |item|
+    #     if item.is_a?(Hash)
+    #       item.each do |k, v|
+    #         # puts "#{k} - #{num}"
+    #         this_num = calc_num_hops(item[k], num + 1)
+    #         max_num = this_num if this_num > max_num
+    #       end
+    #     end
+    #   end
+    #   max_num
+    # end
+
+    # Breadth first approach
+    def calc_num_hops(this_layer, models = nil)
+      seen_it = {}
+      layers = []
+      loop do
+        this_keys = []
+        next_layer = []
+        this_layer.each do |grouping|
+          klass = grouping.first
+          # binding.pry #unless klass.is_a?(Class)
+          grouping.last.each do |item|
+            next unless item.is_a?(Hash) && !seen_it.include?([klass, (k, v = item.first).first])
+
+            seen_it[[klass, k]] = nil
+            this_keys << [klass, k]
+            this_klass = klass.reflect_on_association(k)&.klass
+            if this_klass.nil? # Perhaps it's polymorphic
+              polymorphics = klass.reflect_on_all_associations.each_with_object([]) do |r, s|
+                prefix = "#{r.name}_"
+                if r.polymorphic? && k.to_s.start_with?(prefix)
+                  suffix = k.to_s[prefix.length..-1]
+                  possible_klass = models.find { |m| m.name.underscore == suffix }
+                  s << [suffix, possible_klass] if possible_klass
+                end
+                s
+              end
+              # binding.pry if polymorphics.length != 1
+              this_klass = polymorphics.first&.last
+            end
+            next_layer << [this_klass, v.select { |ip| ip.is_a?(Hash) }] if this_klass
+          end
+        end
+        layers << this_keys unless this_keys.empty?
+        break if next_layer.empty?
+
+        this_layer = next_layer
+      end
+      # puts "#{k} - #{num}"
+      [layers, seen_it.keys.map(&:first).uniq.length]
+    end
+
+    # # MySQL 5.6 utf8mb4 limit is 191 chars for keys used in indexes.
+    # def item_type_options
+    #   opt = { null: false }
+    #   opt[:limit] = 191 if mysql?
+    #   ", #{opt}"
+    # end
+
+    # def migration_version
+    #   return unless (major = ActiveRecord::VERSION::MAJOR) >= 5
+
+    #   "[#{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?
+    #   [
+    #     '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
+    # # encoding. Many users are not aware of this, and run into trouble when they
+    # # try to use DutyFree in apps that otherwise tend to use UTF-8. Postgres, by
+    # # comparison, uses UTF-8 except in the unusual case where the OS is configured
+    # # with a custom locale.
+    # #
+    # # - https://dev.mysql.com/doc/refman/5.7/en/charset-applications.html
+    # # - http://www.postgresql.org/docs/9.4/static/multibyte.html
+    # #
+    # # Furthermore, MySQL's original implementation of UTF-8 was flawed, and had
+    # # to be fixed later by introducing a new charset, `utf8mb4`.
+    # #
+    # # - https://mathiasbynens.be/notes/mysql-utf8mb4
+    # # - https://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html
+    # #
+    # def versions_table_options
+    #   if mysql?
+    #     ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+    #   else
+    #     ''
+    #   end
+    # end
+  end
+end

data/lib/generators/duty_free/templates/create_versions.rb.erb

@@ -1,5 +1,5 @@
-# This migration creates the `versions` table, the only schema PT requires.
-# All other migrations PT provides are optional.
+# This migration creates the `versions` table, the only schema DF requires.
+# All other migrations DF provides are optional.
 class CreateVersions < ActiveRecord::Migration<%= migration_version %>
 
   # The largest text column available in all supported RDBMS is

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duty_free
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.10
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-06 00:00:00.000000000 Z
+date: 2024-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.2'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -214,6 +208,7 @@ files:
 - lib/duty_free/version_number.rb
 - lib/generators/duty_free/USAGE
 - lib/generators/duty_free/install_generator.rb
+- lib/generators/duty_free/model_generator.rb
 - lib/generators/duty_free/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/duty_free/templates/create_versions.rb.erb
 homepage: https://github.com/lorint/duty_free
@@ -235,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Import and Export Data