hairtrigger 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adffb212907d4617f9ed63b3bbed32f0f4c8e7113e50284eb560a2e9ac0f24cb
-  data.tar.gz: a437870c199e11d4264e496ac45ff6d6f61593e80b9082bc8bf320de33bd0b84
+  metadata.gz: 89b859bf3d396f6ba9b213d9be337e111b39cc1a87a5ee73918d553ab03a16b7
+  data.tar.gz: f6cab257e8b963d9f8b740a77b5a336a42403db622df72a57b51254643042117
 SHA512:
-  metadata.gz: cf089ae92b9427a39243f6c096c44eab7ea4d41e7e6bec757781ba2d9b5ebef09683b2528e8ce39c2c28b15919149b82461bd2edcef4d662161a28a52c24671f
-  data.tar.gz: 83c64e0d188cfc45a6ffb701e6f5ee56350d4b636eaaa106405d545731563cc3751e792eecd6eefc1f4d534fdfd31369099e8a9875cec63082ce91d6d753118a
+  metadata.gz: 616a0dfd17908b605b99ba5bedad6c986c98affde8128c3beff540fda85040c61b86fa2ab527d762a3f820ebd3136fab97860a9dd7a9ae0679f1cf73ac4a615c
+  data.tar.gz: 63a07f2d193d6f7e752c61f3b72a906c50059813a0204ffa480781248d00c8309c2c0a3620471b4a194db117534544e6a3b51ab6c7cc833baee199f5013df7d4

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).
 
@@ -362,8 +377,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+
@@ -372,4 +387,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::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, :trilogy
+        when *HairTrigger::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,7 +41,7 @@ FOR EACH ROW
 #{actions}
             SQL
           end
-        when :postgresql, :postgis
+        when *POSTGRESQL_ADAPTERS
           function_conditions = "(SELECT typname FROM pg_type WHERE oid = prorettype) = 'trigger'"
           function_conditions << <<-SQL unless options[:simple_check]
             AND oid IN (

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::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::SQLITE_ADAPTERS, *HairTrigger::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::SQLITE_ADAPTERS]
+      @errors << ["postgresql doesn't support arbitrary users for trigger security", *HairTrigger::POSTGRESQL_ADAPTERS] unless [:definer, :invoker].include?(user)
+      @errors << ["mysql doesn't support invoker trigger security", *HairTrigger::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::MYSQL_ADAPTERS, *HairTrigger::SQLITE_ADAPTERS] if events.size > 1
+      @errors << ["sqlite and mysql do not support truncate triggers", *HairTrigger::MYSQL_ADAPTERS, *HairTrigger::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::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 || adapter_name == :trilogy
+      HairTrigger::MYSQL_ADAPTERS.include?(adapter_name)
     end
 
     def prepare!
@@ -222,11 +234,11 @@ module HairTrigger
 
         [generate_drop_trigger] +
         [case adapter_name
-          when :sqlite
+          when *HairTrigger::SQLITE_ADAPTERS
             generate_trigger_sqlite
-          when :mysql, :trilogy
+          when *HairTrigger::MYSQL_ADAPTERS
             generate_trigger_mysql
-          when :postgresql, :postgis
+          when *HairTrigger::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::MYSQL_ADAPTERS] unless options[:timing] && options[:events]
+        @errors << ["nested trigger groups are not supported for mysql", *HairTrigger::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::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::POSTGRESQL_ADAPTERS, *HairTrigger::SQLITE_ADAPTERS]
       end
     end
 
@@ -396,20 +412,37 @@ module HairTrigger
 
     def supports_of?
       case adapter_name
-      when :sqlite
+      when *HairTrigger::SQLITE_ADAPTERS
         true
-      when :postgresql, :postgis
+      when *HairTrigger::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::SQLITE_ADAPTERS, *HairTrigger::MYSQL_ADAPTERS
+        false
+      when *HairTrigger::POSTGRESQL_ADAPTERS
+        db_version >= 100000
+      else
+        false
+      end
+    end
+
     def generate_drop_trigger
       case adapter_name
-        when :sqlite, :mysql, :trilogy
+        when *HairTrigger::SQLITE_ADAPTERS, *HairTrigger::MYSQL_ADAPTERS
           "DROP TRIGGER IF EXISTS #{prepared_name};\n"
-        when :postgresql, :postgis
+        when *HairTrigger::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::POSTGRESQL_ADAPTERS
           adapter.send(:postgresql_version)
       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::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.1.0"
+  VERSION = "1.2.0"
 
   def VERSION.<=>(other)
     split(/\./).map(&:to_i) <=> other.split(/\./).map(&:to_i)

data/lib/hair_trigger.rb

@@ -8,6 +8,9 @@ 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 :Builder, 'hair_trigger/builder'
   autoload :MigrationReader, 'hair_trigger/migration_reader'
@@ -39,7 +42,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

data/lib/tasks/hair_trigger.rake

@@ -11,7 +11,8 @@ 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
-      next unless ActiveRecord::Base.schema_format == :ruby
+      format = ActiveRecord.respond_to?(:schema_format) ? ActiveRecord.schema_format : ActiveRecord::Base.schema_format
+      next unless format == :ruby
 
       require 'active_record/schema_dumper'
 
@@ -43,7 +44,7 @@ namespace :db do
 
     # code adopted from activerecord/lib/active_record/tasks/database_tasks.rb#L441
     def dump_filename(db_config_name)
-      format = ActiveRecord::Base.schema_format
+      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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hairtrigger
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jon Jensen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-02 00:00:00.000000000 Z
+date: 2024-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord