hairtrigger 1.0.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d99ce209cb3572d2bcc2987758e5887b203f3fdf50ef295b18169a9f030d0d3a
-  data.tar.gz: 8e79c7bf238ebb1339bdefce635eb47050d509faad270c4af88d39a7ba89a8a3
+  metadata.gz: 00e0ef28f55f9f28dddc16dadc2acfadbefa3007eacc294591fc8a2047f547ed
+  data.tar.gz: 7c1aef527b1343d68651bddc00a4cd1b9012b78a4c9a81c0fd333be8f2adb72d
 SHA512:
-  metadata.gz: ffee9a6cac525abb8d0d7e49ec3f78877b54cdbfcaa77a2e2c5b6ac86d4b87401e02f0b54da8a62ebd8029d35ad7d0e798cdbcae34c9db429a4dea5d05aa8e51
-  data.tar.gz: d0c6a189591d1e0722fcbd72b51392efacd222734ae7da513f2f8da651f9c9ed5cf035174d6af04cb1206913873329cf3d8ec645d722810df86889030586ab96
+  metadata.gz: e81ed119bd7f7a3c20fc5f9a7ed365ed5a67551b11063efbd3aeecf9f4116b88b662d6ecf309e7e8fa1b7efedd76519c2f5770851797639750078e034793e152
+  data.tar.gz: e1416ac1fca775b6a600c2a658a1aa51088893293a818d56d8bd0df13821ff4bf54d104177db54bf532a85c054cbbde55a1afe2575b1ab48ef66139b06981afa

data/README.md

@@ -125,6 +125,21 @@ trigger.after(:insert).declare("user_type text; status text") do
 end
 ```
 
+#### new_as(name) or old_as(name)
+PostgreSQL-specific option for "after" triggers to allow accessing the row as it was before the operation (`old`) or as it is after the operation (`new`). This is useful in statement trigger when you want to compare the old and new values of all rows changed during an update trigger. For example:
+
+```ruby
+trigger.after(:update).for_each(:statement).new_as(:new_users).old_as(:old_users) do
+  <<-SQL
+    INSERT INTO user_changes(id, old_name, new_name) FROM (
+        SELECT new_users.id, old_users.name AS old_name, new_users.name AS new_name
+        FROM new_users
+        INNER JOIN old_users ON new_users.id = old_users.id
+      ) agg
+  SQL
+end
+```
+
 #### all
 Noop, useful for trigger groups (see below).
 
@@ -202,6 +217,15 @@ you need to actually implement `up`/`down` methods in your migration
 (rather than `change`) so that it does the right thing when
 rolling back.
 
+The `drop_trigger` currently only supports the `drop_trigger(name, table, options = {})`
+format. You will need to determine what the resulting trigger name is (e.g. `SHOW TRIGGERS`
+query) and use that name in the `drop_triggers` call. Your `down` migration method
+might contain something like:
+
+```ruby
+drop_trigger(:users_after_insert_row_tr, :transactions)
+```
+
 #### Manual triggers and :compatibility
 
 As bugs are fixed and features are implemented in HairTrigger, it's possible
@@ -314,6 +338,13 @@ ignore. Note that this behavior [may change](https://github.com/jenseng/hair_tri
 in a future release, meaning you'll first need to explicitly drop the
 existing trigger if you wish to redefine it.
 
+## Custom adapters
+
+Out of the box, HairTrigger supports the standard adapters for PostgreSQL, MySQL, and SQLite, plus several common variations (`postgis`, `mysql2rgeo`, `trilogy`, and `litedb`). If you would like to use HairTrigger with another compatible variation, you can dynamically add it to `HairTrigger.hair_trigger_configuration`, for example:
+```ruby
+HairTrigger.hair_trigger_configuration.postgresql_adapters << :postgresql_proxy
+```
+
 ## Gotchas
 
 * As is the case with `ActiveRecord::Base.update_all` or any direct SQL you do,
@@ -353,8 +384,8 @@ to manage all that w/ automagical gemfiles. So the tl;dr when testing locally is
 
 ## Compatibility
 
-* Ruby 2.3.0+
-* Rails 5.0+
+* Ruby 3.0+
+* Rails 6.1+
 * PostgreSQL 8.0+
 * MySQL 5.0.10+
 * SQLite 3.3.8+
@@ -363,4 +394,4 @@ to manage all that w/ automagical gemfiles. So the tl;dr when testing locally is
 
 ## Copyright
 
-Copyright (c) 2011-2022 Jon Jensen. See LICENSE.txt for further details.
+Copyright (c) 2011-2024 Jon Jensen. See LICENSE.txt for further details.

data/lib/hair_trigger/adapter.rb

@@ -27,11 +27,11 @@ module HairTrigger
       name_clause = options[:only] ? "IN ('" + options[:only].join("', '") + "')" : nil
       adapter_name = HairTrigger.adapter_name_for(self)
       case adapter_name
-        when :sqlite
+        when *HairTrigger.hair_trigger_config.sqlite_adapters
           select_rows("SELECT name, sql FROM sqlite_master WHERE type = 'trigger' #{name_clause ? " AND name " + name_clause : ""}").each do |(name, definition)|
             triggers[name] = quote_table_name_in_trigger(definition) + ";\n"
           end
-        when :mysql
+        when *HairTrigger.hair_trigger_config.mysql_adapters
           select_rows("SHOW TRIGGERS").each do |(name, event, table, actions, timing, created, sql_mode, definer)|
             definer = normalize_mysql_definer(definer)
             next if options[:only] && !options[:only].include?(name)
@@ -41,14 +41,14 @@ FOR EACH ROW
 #{actions}
             SQL
           end
-        when :postgresql, :postgis
+        when *HairTrigger.hair_trigger_config.postgresql_adapters
           function_conditions = "(SELECT typname FROM pg_type WHERE oid = prorettype) = 'trigger'"
           function_conditions << <<-SQL unless options[:simple_check]
             AND oid IN (
               SELECT tgfoid
               FROM pg_trigger
               WHERE NOT tgisinternal AND tgconstrrelid = 0 AND tgrelid IN (
-                SELECT oid FROM pg_class WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+                SELECT oid FROM pg_class WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '#{HairTrigger.pg_schema}')
               )
             )
           SQL
@@ -57,9 +57,9 @@ FOR EACH ROW
             SELECT tgname::varchar, pg_get_triggerdef(oid, true)
             FROM pg_trigger
             WHERE NOT tgisinternal AND tgconstrrelid = 0 AND tgrelid IN (
-              SELECT oid FROM pg_class WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+              SELECT oid FROM pg_class WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '#{HairTrigger.pg_schema}')
             )
-            
+
             #{name_clause ? " AND tgname::varchar " + name_clause : ""}
             UNION
             SELECT proname || '()', pg_get_functiondef(oid)

data/lib/hair_trigger/builder.rb

@@ -44,7 +44,7 @@ module HairTrigger
     end
 
     def name(name)
-      @errors << ["trigger name cannot exceed 63 for postgres", :postgresql] if name.to_s.size > 63
+      @errors << ["trigger name cannot exceed 63 for postgres", *HairTrigger.hair_trigger_config.postgresql_adapters] if name.to_s.size > 63
       options[:name] = name.to_s
     end
 
@@ -54,7 +54,7 @@ module HairTrigger
     end
 
     def for_each(for_each)
-      @errors << ["sqlite and mysql don't support FOR EACH STATEMENT triggers", :sqlite, :mysql] if for_each == :statement
+      @errors << ["sqlite and mysql don't support FOR EACH STATEMENT triggers", *HairTrigger.hair_trigger_config.sqlite_adapters, *HairTrigger.hair_trigger_config.mysql_adapters] if for_each == :statement
       raise DeclarationError, "invalid for_each" unless [:row, :statement].include?(for_each)
       options[:for_each] = for_each.to_s.upcase
     end
@@ -82,6 +82,18 @@ module HairTrigger
       options[:of] = columns
     end
 
+    def old_as(table)
+      raise DeclarationError, "`old_as' requested, but no table_name specified" unless table.present?
+      options[:referencing] ||= {}
+      options[:referencing][:old] = table
+    end
+
+    def new_as(table)
+      raise DeclarationError, "`new_as' requested, but no table_name specified" unless table.present?
+      options[:referencing] ||= {}
+      options[:referencing][:new] = table
+    end
+
     def declare(declarations)
       options[:declarations] = declarations
     end
@@ -95,9 +107,9 @@ module HairTrigger
         raise DeclarationError, "trigger security should be :invoker, :definer, CURRENT_USER, or a valid user (e.g. 'user'@'host')"
       end
       # sqlite default is n/a, mysql default is :definer, postgres default is :invoker
-      @errors << ["sqlite doesn't support trigger security", :sqlite]
-      @errors << ["postgresql doesn't support arbitrary users for trigger security", :postgresql] unless [:definer, :invoker].include?(user)
-      @errors << ["mysql doesn't support invoker trigger security", :mysql] if user == :invoker
+      @errors << ["sqlite doesn't support trigger security", *HairTrigger.hair_trigger_config.sqlite_adapters]
+      @errors << ["postgresql doesn't support arbitrary users for trigger security", *HairTrigger.hair_trigger_config.postgresql_adapters] unless [:definer, :invoker].include?(user)
+      @errors << ["mysql doesn't support invoker trigger security", *HairTrigger.hair_trigger_config.mysql_adapters] if user == :invoker
       options[:security] = user
     end
 
@@ -110,8 +122,8 @@ module HairTrigger
       events << :insert if events.delete(:create)
       events << :delete if events.delete(:destroy)
       raise DeclarationError, "invalid events" unless events & [:insert, :update, :delete, :truncate] == events
-      @errors << ["sqlite and mysql triggers may not be shared by multiple actions", :mysql, :sqlite] if events.size > 1
-      @errors << ["sqlite and mysql do not support truncate triggers", :mysql, :sqlite] if events.include?(:truncate)
+      @errors << ["sqlite and mysql triggers may not be shared by multiple actions", *HairTrigger.hair_trigger_config.mysql_adapters, *HairTrigger.hair_trigger_config.sqlite_adapters] if events.size > 1
+      @errors << ["sqlite and mysql do not support truncate triggers", *HairTrigger.hair_trigger_config.mysql_adapters, *HairTrigger.hair_trigger_config.sqlite_adapters] if events.include?(:truncate)
       options[:events] = events.map{ |e| e.to_s.upcase }
     end
 
@@ -140,7 +152,7 @@ module HairTrigger
           def #{method}(*args, &block)
             @chained_calls << :#{method}
             if @triggers || @trigger_group
-              @errors << ["mysql doesn't support #{method} within a trigger group", :mysql] unless [:name, :where, :all, :of].include?(:#{method})
+              @errors << ["mysql doesn't support #{method} within a trigger group", *HairTrigger.hair_trigger_config.mysql_adapters] unless [:name, :where, :all, :of].include?(:#{method})
             end
             set_#{method}(*args, &(block_given? ? block : nil))
           end
@@ -159,10 +171,10 @@ module HairTrigger
         METHOD
       end
     end
-    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap, :of, :declare
+    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap, :of, :declare, :old_as, :new_as
 
     def create_grouped_trigger?
-      adapter_name == :mysql
+      HairTrigger.hair_trigger_config.mysql_adapters.include?(adapter_name)
     end
 
     def prepare!
@@ -222,11 +234,11 @@ module HairTrigger
 
         [generate_drop_trigger] +
         [case adapter_name
-          when :sqlite
+          when *HairTrigger.hair_trigger_config.sqlite_adapters
             generate_trigger_sqlite
-          when :mysql
+          when *HairTrigger.hair_trigger_config.mysql_adapters
             generate_trigger_mysql
-          when :postgresql, :postgis
+          when *HairTrigger.hair_trigger_config.postgresql_adapters
             generate_trigger_postgresql
           else
             raise GenerationError, "don't know how to build #{adapter_name} triggers yet"
@@ -306,6 +318,10 @@ module HairTrigger
             "where(#{prepared_where.inspect})"
           when :of
             "of(#{options[:of].inspect[1..-2]})"
+          when :old_as
+            "old_as(#{options[:referencing][:old].inspect})"
+          when :new_as
+            "new_as(#{options[:referencing][:new].inspect})"
           when :for_each
             "for_each(#{options[:for_each].downcase.to_sym.inspect})"
           when :declare
@@ -329,8 +345,8 @@ module HairTrigger
     def maybe_execute(&block)
       raise DeclarationError, "of may only be specified on update triggers" if options[:of] && options[:events] != ["UPDATE"]
       if block.arity > 0 # we're creating a trigger group, so set up some stuff and pass the buck
-        @errors << ["trigger group must specify timing and event(s) for mysql", :mysql] unless options[:timing] && options[:events]
-        @errors << ["nested trigger groups are not supported for mysql", :mysql] if @trigger_group
+        @errors << ["trigger group must specify timing and event(s) for mysql", *HairTrigger.hair_trigger_config.mysql_adapters] unless options[:timing] && options[:events]
+        @errors << ["nested trigger groups are not supported for mysql", *HairTrigger.hair_trigger_config.mysql_adapters] if @trigger_group
         @triggers = []
         block.call(self)
         raise DeclarationError, "trigger group did not define any triggers" if @triggers.empty?
@@ -359,9 +375,9 @@ module HairTrigger
       subtriggers = all_triggers(false)
       named_subtriggers = subtriggers.select{ |t| t.options[:name] }
       if named_subtriggers.present? && !options[:name]
-        @warnings << ["nested triggers have explicit names, but trigger group does not. trigger name will be inferred", :mysql]
+        @warnings << ["nested triggers have explicit names, but trigger group does not. trigger name will be inferred", *HairTrigger.hair_trigger_config.mysql_adapters]
       elsif subtriggers.present? && !named_subtriggers.present? && options[:name]
-        @warnings << ["trigger group has an explicit name, but nested triggers do not. trigger names will be inferred", :postgresql, :sqlite]
+        @warnings << ["trigger group has an explicit name, but nested triggers do not. trigger names will be inferred", *HairTrigger.hair_trigger_config.postgresql_adapters, *HairTrigger.hair_trigger_config.sqlite_adapters]
       end
     end
 
@@ -396,20 +412,37 @@ module HairTrigger
 
     def supports_of?
       case adapter_name
-      when :sqlite
+      when *HairTrigger.hair_trigger_config.sqlite_adapters
         true
-      when :postgresql, :postgis
+      when *HairTrigger.hair_trigger_config.postgresql_adapters
         db_version >= 90000
       else
         false
       end
     end
 
+    def referencing_clause(check_support = true)
+      if options[:referencing] && (!check_support || supports_referencing?)
+        "REFERENCING " + options[:referencing].map{ |k, v| "#{k.to_s.upcase} TABLE AS #{v}" }.join(" ")
+      end
+    end
+
+    def supports_referencing?
+      case adapter_name
+      when *HairTrigger.hair_trigger_config.sqlite_adapters, *HairTrigger.hair_trigger_config.mysql_adapters
+        false
+      when *HairTrigger.hair_trigger_config.postgresql_adapters
+        db_version >= 100000
+      else
+        false
+      end
+    end
+
     def generate_drop_trigger
       case adapter_name
-        when :sqlite, :mysql
+        when *HairTrigger.hair_trigger_config.sqlite_adapters, *HairTrigger.hair_trigger_config.mysql_adapters
           "DROP TRIGGER IF EXISTS #{prepared_name};\n"
-        when :postgresql, :postgis
+        when *HairTrigger.hair_trigger_config.postgresql_adapters
           "DROP TRIGGER IF EXISTS #{prepared_name} ON #{adapter.quote_table_name(options[:table])};\nDROP FUNCTION IF EXISTS #{adapter.quote_table_name(prepared_name)}();\n"
         else
           raise GenerationError, "don't know how to drop #{adapter_name} triggers yet"
@@ -433,6 +466,7 @@ END;
       raise GenerationError, "security cannot be used in conjunction with nowrap" if options[:nowrap] && options[:security]
       raise GenerationError, "where can only be used in conjunction with nowrap on postgres 9.0 and greater" if options[:nowrap] && prepared_where && db_version < 90000
       raise GenerationError, "of can only be used in conjunction with nowrap on postgres 9.1 and greater" if options[:nowrap] && options[:of] && db_version < 90100
+      raise GenerationError, "referencing can only be used on postgres 10.0 and greater" if options[:referencing] && db_version < 100000
 
       sql = ''
 
@@ -472,6 +506,7 @@ $$ LANGUAGE plpgsql#{security ? " SECURITY #{security.to_s.upcase}" : ""};
 
       [sql, <<-SQL]
 CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].join(" OR ")} #{of_clause}ON #{adapter.quote_table_name(options[:table])}
+#{referencing_clause}
 FOR EACH #{options[:for_each]}#{prepared_where && db_version >= 90000 ? " WHEN (" + prepared_where + ')': ''} EXECUTE PROCEDURE #{trigger_action};
       SQL
     end
@@ -497,7 +532,7 @@ BEGIN
 
     def db_version
       @db_version ||= case adapter_name
-        when :postgresql, :postgis
+        when *HairTrigger.hair_trigger_config.postgresql_adapters
           adapter.send(:postgresql_version)
       end
     end

data/lib/hair_trigger/configuration.rb

@@ -0,0 +1,11 @@
+module HairTrigger
+  class Configuration
+    attr_accessor :postgresql_adapters, :mysql_adapters, :sqlite_adapters
+
+    def initialize(postgresql_adapters: [], mysql_adapters: [], sqlite_adapters: [])
+      @postgresql_adapters = postgresql_adapters
+      @mysql_adapters      = mysql_adapters
+      @sqlite_adapters     = sqlite_adapters
+    end
+  end
+end

data/lib/hair_trigger/schema_dumper.rb

@@ -74,7 +74,7 @@ module HairTrigger
     def normalize_trigger(name, definition, type)
       @adapter_name = @connection.adapter_name.downcase.to_sym
 
-      return definition unless @adapter_name == :postgresql || @adapter_name == :postgis
+      return definition unless HairTrigger.hair_trigger_config.postgresql_adapters.include?(@adapter_name)
       # because postgres does not preserve the original CREATE TRIGGER/
       # FUNCTION statements, its decompiled reconstruction will not match
       # ours. we work around it by creating our generated trigger/function,

data/lib/hair_trigger/version.rb

@@ -1,5 +1,5 @@
 module HairTrigger
-  VERSION = "1.0.0"
+  VERSION = "1.3.1"
 
   def VERSION.<=>(other)
     split(/\./).map(&:to_i) <=> other.split(/\./).map(&:to_i)

data/lib/hair_trigger.rb

@@ -8,12 +8,28 @@ require 'hair_trigger/schema_dumper'
 require 'hair_trigger/railtie' if defined?(Rails::Railtie)
 
 module HairTrigger
+  POSTGRESQL_ADAPTERS = %i[postgresql postgis]
+  MYSQL_ADAPTERS = %i[mysql mysql2rgeo trilogy]
+  SQLITE_ADAPTERS = %i[sqlite litedb]
 
+  autoload :Configuration, 'hair_trigger/configuration'
   autoload :Builder, 'hair_trigger/builder'
   autoload :MigrationReader, 'hair_trigger/migration_reader'
 
   class << self
-    attr_writer :model_path, :schema_rb_path, :migration_path
+    attr_writer :model_path, :schema_rb_path, :migration_path, :pg_schema
+
+    def configure
+      yield hair_trigger_config
+    end
+
+    def hair_trigger_config
+      @hair_trigger_config ||= Configuration.new(
+        postgresql_adapters: POSTGRESQL_ADAPTERS,
+        mysql_adapters:      MYSQL_ADAPTERS,
+        sqlite_adapters:     SQLITE_ADAPTERS
+      )
+    end
 
     def current_triggers
       # see what the models say there should be
@@ -39,7 +55,12 @@ module HairTrigger
     end
 
     def migrator
-      if ActiveRecord::VERSION::STRING >= "7.1."
+      if Gem::Version.new("7.2.0") <= ActiveRecord.gem_version
+        connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+        schema_migration = connection.schema_migration
+        migrations = ActiveRecord::MigrationContext.new(migration_path, schema_migration).migrations
+        ActiveRecord::Migrator.new(:up, migrations, schema_migration, ActiveRecord::InternalMetadata.new(connection))
+      elsif Gem::Version.new("7.1.0") <= ActiveRecord.gem_version
         connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
         schema_migration = connection.schema_migration
         migrations = ActiveRecord::MigrationContext.new(migration_path, schema_migration).migrations
@@ -223,6 +244,10 @@ end
       @migration_path ||= 'db/migrate'
     end
 
+    def pg_schema
+      @pg_schema ||= 'public'
+    end
+
     def adapter_name_for(adapter)
       adapter.adapter_name.downcase.sub(/\d$/, '').to_sym
     end

data/lib/tasks/hair_trigger.rake

@@ -11,13 +11,56 @@ namespace :db do
   namespace :schema do
     desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
     task :dump => :environment do
+      format = ActiveRecord.respond_to?(:schema_format) ? ActiveRecord.schema_format : ActiveRecord::Base.schema_format
+      next unless format == :ruby
+
       require 'active_record/schema_dumper'
-      filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
-      ActiveRecord::SchemaDumper.previous_schema = File.exist?(filename) ? File.read(filename) : nil
-      File.open(filename, "w") do |file|
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+
+      databases = ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: name)
+        connection = get_connection(ActiveRecord::Base.establish_connection(db_config))
+
+        filename = dump_filename(db_config.name)
+        ActiveRecord::SchemaDumper.previous_schema = File.exist?(filename) ? File.read(filename) : nil
+
+        File.open(filename, "w") do |file|
+
+          ActiveRecord::SchemaDumper.dump(connection, file)
+        end
       end
+
       Rake::Task["db:schema:dump"].reenable
     end
+
+    def get_connection(connection_pool)
+      if Gem::Version.new("7.2.0") <= ActiveRecord.gem_version
+        connection_pool
+      else
+        connection_pool.connection
+      end
+    end
+
+    def schema_file_type(format)
+      case format
+        when :ruby
+          "schema.rb"
+        when :sql
+          "structure.sql"
+      end
+    end
+
+    # code adopted from activerecord/lib/active_record/tasks/database_tasks.rb#L441
+    def dump_filename(db_config_name)
+      format = ActiveRecord.respond_to?(:schema_format) ? ActiveRecord.schema_format : ActiveRecord::Base.schema_format
+      filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
+                   schema_file_type(format)
+                 else
+                   "#{db_config_name}_#{schema_file_type(format)}"
+                 end
+
+      ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hairtrigger
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Jon Jensen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-13 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: ruby_parser
   requirement: !ruby/object:Gem::Requirement
@@ -72,6 +72,7 @@ files:
 - lib/hair_trigger/adapter.rb
 - lib/hair_trigger/base.rb
 - lib/hair_trigger/builder.rb
+- lib/hair_trigger/configuration.rb
 - lib/hair_trigger/migration_reader.rb
 - lib/hair_trigger/migrator.rb
 - lib/hair_trigger/railtie.rb
@@ -91,14 +92,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: easy database triggers for active record