Add configuration class for custom adapters (#135)

The list of supported adapters is hardcoded, which makes it difficult to
use this gem on custom adapters.

We use `postgresql_proxy` from `active_record_proxy_adapters`, for
instance. Currently, we need to monkey patch the gem and hot swap the
constant `HairTrigger::POSTGRESQL_ADAPTERS` when the application boots
to make it work with the proxy adapter.

Although it works, it's not ideal.

I've added a new configuration class whose values will default to the
current ones (`%i[mysql2 trilogy]` for `mysql_adapters`, `%i[postgresql
postgis]` for `postgresql_adapters` , and `%i[sqlite litedb]` for
`sqlite_adapters`), but allow the user to add custom adapters for each.

I don't expect any breaking changes here as the values fall back to the
existing constants, but please double check. Thanks!

Author: mateuscruz

lib/hair_trigger.rb

@@ -12,12 +12,25 @@ module HairTrigger
   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, :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
       canonical_triggers = models.map(&:triggers).flatten.compact

lib/hair_trigger/adapter.rb

@@ -27,11 +27,11 @@ def triggers(options = {})
       name_clause = options[:only] ? "IN ('" + options[:only].join("', '") + "')" : nil
       adapter_name = HairTrigger.adapter_name_for(self)
       case adapter_name
-        when *HairTrigger::SQLITE_ADAPTERS
+        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 *HairTrigger::MYSQL_ADAPTERS
+        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,7 +41,7 @@ def triggers(options = {})
 #{actions}
             SQL
           end
-        when *POSTGRESQL_ADAPTERS
+        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 (

lib/hair_trigger/builder.rb

@@ -44,7 +44,7 @@ def drop_triggers
     end
 
     def name(name)
-      @errors << ["trigger name cannot exceed 63 for postgres", *HairTrigger::POSTGRESQL_ADAPTERS] 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 @@ def on(table)
     end
 
     def for_each(for_each)
-      @errors << ["sqlite and mysql don't support FOR EACH STATEMENT triggers", *HairTrigger::SQLITE_ADAPTERS, *HairTrigger::MYSQL_ADAPTERS] 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
@@ -107,9 +107,9 @@ def security(user)
         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", *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
+      @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
 
@@ -122,8 +122,8 @@ def events(*events)
       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", *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)
+      @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
 
@@ -152,7 +152,7 @@ def self.chainable_methods(*methods)
           def #{method}(*args, &block)
             @chained_calls << :#{method}
             if @triggers || @trigger_group
-              @errors << ["mysql doesn't support #{method} within a trigger group", *HairTrigger::MYSQL_ADAPTERS] 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
@@ -174,7 +174,7 @@ def set_#{method}(*args, &block)
     chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap, :of, :declare, :old_as, :new_as
 
     def create_grouped_trigger?
-      HairTrigger::MYSQL_ADAPTERS.include?(adapter_name)
+      HairTrigger.hair_trigger_config.mysql_adapters.include?(adapter_name)
     end
 
     def prepare!
@@ -234,11 +234,11 @@ def generate(validate = true)
 
         [generate_drop_trigger] +
         [case adapter_name
-          when *HairTrigger::SQLITE_ADAPTERS
+          when *HairTrigger.hair_trigger_config.sqlite_adapters
             generate_trigger_sqlite
-          when *HairTrigger::MYSQL_ADAPTERS
+          when *HairTrigger.hair_trigger_config.mysql_adapters
             generate_trigger_mysql
-          when *HairTrigger::POSTGRESQL_ADAPTERS
+          when *HairTrigger.hair_trigger_config.postgresql_adapters
             generate_trigger_postgresql
           else
             raise GenerationError, "don't know how to build #{adapter_name} triggers yet"
@@ -345,8 +345,8 @@ def actions_to_ruby(indent = '')
     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", *HairTrigger::MYSQL_ADAPTERS] unless options[:timing] && options[:events]
-        @errors << ["nested trigger groups are not supported for mysql", *HairTrigger::MYSQL_ADAPTERS] 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?
@@ -375,9 +375,9 @@ def validate_names!
       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", *HairTrigger::MYSQL_ADAPTERS]
+        @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", *HairTrigger::POSTGRESQL_ADAPTERS, *HairTrigger::SQLITE_ADAPTERS]
+        @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
 
@@ -412,9 +412,9 @@ def declarations
 
     def supports_of?
       case adapter_name
-      when *HairTrigger::SQLITE_ADAPTERS
+      when *HairTrigger.hair_trigger_config.sqlite_adapters
         true
-      when *HairTrigger::POSTGRESQL_ADAPTERS
+      when *HairTrigger.hair_trigger_config.postgresql_adapters
         db_version >= 90000
       else
         false
@@ -429,9 +429,9 @@ def referencing_clause(check_support = true)
 
     def supports_referencing?
       case adapter_name
-      when *HairTrigger::SQLITE_ADAPTERS, *HairTrigger::MYSQL_ADAPTERS
+      when *HairTrigger.hair_trigger_config.sqlite_adapters, *HairTrigger.hair_trigger_config.mysql_adapters
         false
-      when *HairTrigger::POSTGRESQL_ADAPTERS
+      when *HairTrigger.hair_trigger_config.postgresql_adapters
         db_version >= 100000
       else
         false
@@ -440,9 +440,9 @@ def supports_referencing?
 
     def generate_drop_trigger
       case adapter_name
-        when *HairTrigger::SQLITE_ADAPTERS, *HairTrigger::MYSQL_ADAPTERS
+        when *HairTrigger.hair_trigger_config.sqlite_adapters, *HairTrigger.hair_trigger_config.mysql_adapters
           "DROP TRIGGER IF EXISTS #{prepared_name};\n"
-        when *HairTrigger::POSTGRESQL_ADAPTERS
+        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"
@@ -532,7 +532,7 @@ def generate_trigger_mysql
 
     def db_version
       @db_version ||= case adapter_name
-        when *HairTrigger::POSTGRESQL_ADAPTERS
+        when *HairTrigger.hair_trigger_config.postgresql_adapters
           adapter.send(:postgresql_version)
       end
     end

lib/hair_trigger/configuration.rb

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

lib/hair_trigger/schema_dumper.rb

@@ -74,7 +74,7 @@ def triggers(stream)
     def normalize_trigger(name, definition, type)
       @adapter_name = @connection.adapter_name.downcase.to_sym
 
-      return definition unless HairTrigger::POSTGRESQL_ADAPTERS.include?(@adapter_name)
+      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,