hairtrigger 0.1.4 → 0.1.5

data/Gemfile

@@ -1,8 +1,12 @@
 source "http://rubygems.org"
+
 gem "activerecord", ">=2.3.0", "<3.0"
 group :development do
   gem "rspec", "~> 2.3.0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
   gem "rcov", ">= 0"
+  gem 'mysql', '>= 2.8.1'
+  gem 'pg', '>= 0.10.1'
+  gem 'sqlite3-ruby', '>= 1.3.2'
 end

data/README.rdoc

@@ -4,7 +4,7 @@ HairTrigger lets you create and manage database triggers in a concise,
 db-agnostic, Rails-y way. You declare triggers right in your models in Ruby,
 and a simple rake task does all the dirty work for you.
 
-== Install
+== Installation
 
 === Step 1.
 
@@ -55,7 +55,8 @@ contain the ":generated => true" option, indicating that they were created
 from the model definition. This is important, as the rake task will also
 generate appropriate drop/create statements for any model triggers that get
 removed or updated. It does this by diffing the current model trigger
-declarations and any auto-generated triggers from previous migrations.
+declarations and any auto-generated triggers in schema.rb (and subsequent
+migrations).
 
 === Manual Migrations
 
@@ -81,7 +82,7 @@ Optional, inferred from other calls.
 Ignored in models, required in migrations.
 
 ==== for_each(item)
-Defaults to :row, PostgreSQL/MySQL allow :statement.
+Defaults to :row, PostgreSQL allows :statement.
 
 ==== before(*events)
 Shorthand for timing(:before).events(*events).
@@ -128,10 +129,28 @@ For MySQL, this will just create a single trigger with conditional logic
 distinct triggers. This same notation is also used within trigger migrations.
 MySQL does not currently support nested trigger groups.
 
+== rake db:schema:dump
+
+HairTrigger hooks into rake db:schema:dump (and rake tasks that call it) to
+make it trigger-aware. A newly generated schema.rb will contain:
+
+* create_trigger statements for any database triggers that exactly match a
+  create_trigger statement in an applied migration or in the previous
+  schema.rb file. this includes both generated and manual create_trigger
+  calls.
+* adapter-specific execute('CREATE TRIGGER..') statements for any unmatched
+  database triggers.
+
+As long as you don't delete old migrations and schema.rb prior to running
+rake db:schema:dump, the result should be what you expect (and portable).
+If you have deleted all trigger migrations, you can regenerate a new
+baseline for model triggers via rake db:generate_trigger_migration.
+
 == Testing
 
 To stay on top of things, it's strongly recommended that you add a test or
-spec to ensure your migrations match your models. This is as simple as:
+spec to ensure your migrations/schema.rb match your models. This is as simple
+as:
 
  assert HairTrigger::migrations_current?
 
@@ -166,10 +185,8 @@ e.g.
 HairTrigger does not validate your SQL, so be sure to test it in all databases
 you want to support.
 
-== Gotchas, Known Issues
+== Gotchas
 
-* HairTrigger does not check config.active_record.timestamped_migrations, it
-  always assumes it is true. As a workaround, you can rename the migration.
 * As is the case with ActiveRecord::Base.update_all or any direct SQL you do,
   be careful to reload updated objects from the database. For example, the
   following code will display the wrong count since we aren't reloading the
@@ -188,11 +205,13 @@ you want to support.
 
 * Rails 2.3.x
 * Postgres 8.0+
-* MySQL 5.0+
-* SQLite 3.0+
+* MySQL 5.0.10+
+* SQLite 3.3.8+
 
 == Version History
 
+* 0.1.4 Compatibility tracking, fixed Postgres return bug, ensure last action
+  has a semicolon
 * 0.1.3 Better error handling, Postgres 8.x support, updated docs
 * 0.1.2 Fixed Builder#security, updated docs
 * 0.1.1 Fixed bug in HairTrigger.migrations_current?, fixed up Gemfile

data/Rakefile

@@ -19,7 +19,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{allows you to declare database triggers in ruby in your models, and then generate appropriate migrations as they change}
   gem.email = "jenseng@gmail.com"
   gem.authors = ["Jon Jensen"]
-  gem.add_runtime_dependency "activerecord", ">=2.3.0", "<3.0"
+  gem.add_dependency "activerecord", ">=2.3.0", "<3.0"
   gem.add_development_dependency "rspec", "~> 2.3.0"
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/lib/hair_trigger.rb

@@ -1,13 +1,22 @@
+require 'ostruct'
+require 'hair_trigger/base'
+require 'hair_trigger/builder'
+require 'hair_trigger/migration'
+require 'hair_trigger/adapter'
+require 'hair_trigger/schema_dumper'
+require 'hair_trigger/schema'
+
 module HairTrigger
   def self.current_triggers
     # see what the models say there should be
     canonical_triggers = []
-    Dir['app/models/*rb'].each do |model|
+    Dir[model_path + '/*rb'].each do |model|
       class_name = model.sub(/\A.*\/(.*?)\.rb\z/, '\1').camelize
       begin
+        require model
         klass = Kernel.const_get(class_name)
-      rescue
-        raise "unable to load #{class_name} and its trigger(s)"  if File.read(model) =~ /^\s*trigger[\.\(]/
+      rescue LoadError
+        raise "unable to load #{class_name} and its trigger(s)" if File.read(model) =~ /^\s*trigger[\.\(]/
         next
       end
       canonical_triggers += klass.triggers if klass < ActiveRecord::Base && klass.triggers
@@ -15,36 +24,163 @@ module HairTrigger
     canonical_triggers.each(&:prepare!) # interpolates any vars so we match the migrations
   end
 
-  def self.current_migrations
+  def self.current_migrations(options = {})
+    if options[:in_rake_task]
+      options[:include_manual_triggers] = true
+      options[:schema_rb_first] = true
+      options[:skip_pending_migrations] = true
+    end
+
+    prev_verbose = ActiveRecord::Migration.verbose
     ActiveRecord::Migration.verbose = false
     ActiveRecord::Migration.extract_trigger_builders = true
+    ActiveRecord::Migration.extract_all_triggers = options[:include_manual_triggers] || false
     
-    # see what generated triggers are defined by the migrations
-    migrations = []
-    migrator = ActiveRecord::Migrator.new(:up, 'db/migrate')
-    migrator.migrations.select{ |migration|
-      File.read(migration.filename) =~ /(create|drop)_trigger.*:generated *=> *true/
-    }.each do |migration|
+    # if we're in a db:schema:dump task (explict or kicked off by db:migrate),
+    # we evaluate the previous schema.rb (if it exists), and then all applied
+    # migrations in order (even ones older than schema.rb). this ensures we
+    # handle db:migrate:down scenarios correctly
+    #
+    # if we're not in such a rake task (i.e. we just want to know what
+    # triggers are defined, whether or not they are applied in the db), we
+    # evaluate all migrations along with schema.rb, ordered by version
+    migrator = ActiveRecord::Migrator.new(:up, migration_path)
+    migrated = migrator.migrated rescue []
+    migrations = migrator.migrations.select{ |migration|
+      (options[:skip_pending_migrations] ? migrated.include?(migration.version) : true)
+    }.each{ |migration|
       migration.migrate(:up)
+    }
+
+    if options.has_key?(:previous_schema)
+      eval(options[:previous_schema]) if options[:previous_schema]
+    elsif File.exist?(schema_rb_path)
+      load(schema_rb_path)
+    end
+    if ActiveRecord::Schema.info && ActiveRecord::Schema.trigger_builders
+      migrations.unshift OpenStruct.new({:version => ActiveRecord::Schema.info[:version], :trigger_builders => ActiveRecord::Schema.trigger_builders})
+    end
+    migrations = migrations.sort_by(&:version) unless options[:schema_rb_first]
+
+    all_builders = []
+    migrations.each do |migration|
+      next unless migration.trigger_builders
       migration.trigger_builders.each do |new_trigger|
         # if there is already a trigger with this name, delete it since we are
         # either dropping it or replacing it
-        migrations.delete_if{ |(n, t)| t.prepared_name == new_trigger.prepared_name }
-        migrations << [migration.name, new_trigger] unless new_trigger.options[:drop]
+        new_trigger.prepare!
+        all_builders.delete_if{ |(n, t)| t.prepared_name == new_trigger.prepared_name }
+        all_builders << [migration.name, new_trigger] unless new_trigger.options[:drop]
       end
     end
-    migrations.each{ |(n, t)| t.prepare! }
+
+    all_builders
+
   ensure
-    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migration.verbose = prev_verbose
     ActiveRecord::Migration.extract_trigger_builders = false
+    ActiveRecord::Migration.extract_all_triggers = false
   end
 
   def self.migrations_current?
     current_migrations.map(&:last).sort.eql? current_triggers.sort
   end
+
+  def self.generate_migration(silent = false)
+    begin
+      canonical_triggers = current_triggers
+    rescue 
+      $stderr.puts $!
+      exit 1
+    end
+
+    migrations = current_migrations
+    migration_names = migrations.map(&:first)
+    existing_triggers = migrations.map(&:last)
+
+    up_drop_triggers = []
+    up_create_triggers = []
+    down_drop_triggers = []
+    down_create_triggers = []
+
+    existing_triggers.each do |existing|
+      unless canonical_triggers.any?{ |t| t.prepared_name == existing.prepared_name }
+        up_drop_triggers += existing.drop_triggers
+        down_create_triggers << existing
+      end
+    end
+
+    (canonical_triggers - existing_triggers).each do |new_trigger|
+      up_create_triggers << new_trigger
+      down_drop_triggers += new_trigger.drop_triggers
+      if existing = existing_triggers.detect{ |t| t.prepared_name == new_trigger.prepared_name }
+        # it's not sufficient to rely on the new trigger to replace the old
+        # one, since we could be dealing with trigger groups and the name
+        # alone isn't sufficient to know which component triggers to remove
+        up_drop_triggers += existing.drop_triggers
+        down_create_triggers << existing
+      end
+    end
+
+    unless up_drop_triggers.empty? && up_create_triggers.empty?
+      migration_base_name = if up_create_triggers.size > 0
+        ("create trigger#{up_create_triggers.size > 1 ? 's' : ''} " +
+         up_create_triggers.map{ |t| [t.options[:table], t.options[:events].join(" ")].join(" ") }.join(" and ")
+        ).downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_').camelize
+      else
+        ("drop trigger#{up_drop_triggers.size > 1 ? 's' : ''} " +
+         up_drop_triggers.map{ |t| t.options[:table] }.join(" and ")
+        ).downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_').camelize
+      end
+
+      name_version = nil
+      while migration_names.include?("#{migration_base_name}#{name_version}")
+        name_version = name_version.to_i + 1
+      end
+      migration_name = "#{migration_base_name}#{name_version}"
+      migration_version = ActiveRecord::Base.timestamped_migrations ?
+        Time.now.getutc.strftime("%Y%m%d%H%M%S") :
+        Dir.glob(migration_path + '/*rb').map{ |f| f.gsub(/.*\/(\d+)_.*/, '\1').to_i}.inject(0){ |curr, i| i > curr ? i : curr }
+      file_name = migration_path + '/' + migration_version + "_" + migration_name.underscore + ".rb"
+      File.open(file_name, "w"){ |f| f.write <<-MIGRATION }
+# This migration was auto-generated via `rake db:generate_trigger_migration'.
+# While you can edit this file, any changes you make to the definitions here
+# will be undone by the next auto-generated trigger migration.
+
+class #{migration_name} < ActiveRecord::Migration
+  def self.up
+    #{(up_drop_triggers + up_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
+  end
+
+  def self.down
+    #{(down_drop_triggers + down_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
+  end
+end
+      MIGRATION
+      file_name
+    end
+  end
+
+  class << self
+    attr_writer :model_path, :schema_rb_path, :migration_path
+
+    def model_path
+      @model_path ||= 'app/models'
+    end
+
+    def schema_rb_path
+      @schema_rb_path ||= 'db/schema.rb'
+    end
+
+    def migration_path
+      @migration_path ||= 'db/migrate'
+    end
+  end
 end
 
 ActiveRecord::Base.send :extend, HairTrigger::Base
 ActiveRecord::Migration.send :extend, HairTrigger::Migration
 ActiveRecord::MigrationProxy.send :delegate, :trigger_builders, :to=>:migration
 ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval { include HairTrigger::Adapter }
+ActiveRecord::SchemaDumper.class_eval { include HairTrigger::SchemaDumper }
+ActiveRecord::Schema.send :extend, HairTrigger::Schema

data/lib/hair_trigger/adapter.rb

@@ -11,5 +11,57 @@ module HairTrigger
     def drop_trigger(name, table, options = {})
       ::HairTrigger::Builder.new(name, options.merge(:execute => true, :drop => true, :table => table)){}
     end
+
+    def triggers(options = {})
+      triggers = {}
+      name_clause = options[:only] ? "IN ('" + options[:only].join("', '") + "')" : nil
+      case self.adapter_name.downcase.to_sym
+        when :sqlite
+          select_rows("SELECT name, sql FROM sqlite_master WHERE type = 'trigger' #{name_clause ? " AND name " + name_clause : ""}").each do |(name, definition)|
+            triggers[name] = definition + ";\n"
+          end
+        when :mysql
+          select_rows("SHOW TRIGGERS").each do |(name, event, table, actions, timing, created, sql_mode, definer)|
+            next if options[:only] && !options[:only].include?(name)
+            triggers[name] = <<-SQL
+CREATE #{definer != "#{@config[:username]}@#{@config[:host]}" ? "DEFINER = #{definer} " : ""}TRIGGER #{name} #{timing} #{event} ON #{table}
+FOR EACH ROW
+#{actions}
+            SQL
+          end
+        when :postgresql
+          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')
+              )
+            )
+          SQL
+          function_conditions = 
+          sql = <<-SQL
+            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')
+            )
+            
+            #{name_clause ? " AND tgname::varchar " + name_clause : ""}
+            UNION
+            SELECT proname || '()', pg_get_functiondef(oid)
+            FROM pg_proc
+            WHERE #{function_conditions}
+              #{name_clause ? " AND (proname || '()')::varchar " + name_clause : ""}
+          SQL
+          select_rows(sql).each do |(name, definition)|
+            triggers[name] = definition
+          end
+        else
+          raise "don't know how to retrieve #{adapter_name} triggers yet"
+      end
+      triggers
+    end
   end
 end

data/lib/hair_trigger/builder.rb

@@ -50,7 +50,7 @@ module HairTrigger
     end
 
     def for_each(for_each)
-      @errors << ["sqlite doesn't support FOR EACH STATEMENT triggers", :sqlite] if for_each == :statement
+      @errors << ["sqlite and mysql don't support FOR EACH STATEMENT triggers", :sqlite, :mysql] if for_each == :statement
       raise DeclarationError, "invalid for_each" unless [:row, :statement].include?(for_each)
       options[:for_each] = for_each.to_s.upcase
     end
@@ -170,8 +170,8 @@ module HairTrigger
         raise GenerationError, "need to specify the event(s) (:insert, :update, :delete)" if !options[:events] || options[:events].empty?
         raise GenerationError, "need to specify the timing (:before/:after)" unless options[:timing]
 
-        ret = [generate_drop_trigger]
-        ret << case adapter_name
+        [generate_drop_trigger] +
+        [case adapter_name
           when :sqlite
             generate_trigger_sqlite
           when :mysql
@@ -180,23 +180,23 @@ module HairTrigger
             generate_trigger_postgresql
           else
             raise GenerationError, "don't know how to build #{adapter_name} triggers yet"
-        end
-        ret
+        end].flatten
       end
     end
 
-    def to_ruby(indent = '')
+    def to_ruby(indent = '', always_generated = true)
       prepare!
       if options[:drop]
-        "#{indent}drop_trigger(#{prepared_name.inspect}, #{options[:table].inspect}, :generated => true)"
+        "#{indent}drop_trigger(#{prepared_name.inspect}, #{options[:table].inspect})"
       else
         if @trigger_group
           str = "t." + chained_calls_to_ruby + " do\n"
           str << actions_to_ruby("#{indent}  ") + "\n"
           str << "#{indent}end"
         else
-          str = "#{indent}create_trigger(#{prepared_name.inspect}, :generated => true, :compatibility => #{@compatibility}).\n" +
-          "#{indent}    " + chained_calls_to_ruby(".\n#{indent}    ")
+          str = "#{indent}create_trigger(#{prepared_name.inspect}"
+          str << ", :generated => true, :compatibility => #{@compatibility}" if always_generated || options[:generated]
+          str << ").\n#{indent}    " + chained_calls_to_ruby(".\n#{indent}    ")
           if @triggers
             str << " do |t|\n"
             str << "#{indent}  " + @triggers.map{ |t| t.to_ruby("#{indent}  ") }.join("\n\n#{indent}  ") + "\n"
@@ -337,6 +337,8 @@ BEGIN
       sql << <<-SQL
 END;
 $$ LANGUAGE plpgsql#{security ? " SECURITY #{security.to_s.upcase}" : ""};
+      SQL
+      [sql, <<-SQL]
 CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].join(" OR ")} ON #{options[:table]}
 FOR EACH #{options[:for_each]}#{prepared_where && db_version >= 90000 ? " WHEN (" + prepared_where + ')': ''} EXECUTE PROCEDURE #{prepared_name}();
       SQL

data/lib/hair_trigger/migration.rb

@@ -4,13 +4,13 @@ module HairTrigger
 
     def method_missing_with_trigger_building(method, *arguments, &block)
       if extract_trigger_builders
-        if method.to_sym == :create_trigger && arguments[1].delete(:generated)
+        if method.to_sym == :create_trigger && (extract_all_triggers || arguments[1].delete(:generated))
           arguments.unshift(nil) if arguments.first.is_a?(Hash)
           arguments[1][:compatibility] ||= 0
           trigger = ::HairTrigger::Builder.new(*arguments)
           (@trigger_builders ||= []) << trigger
           trigger
-        elsif method.to_sym == :drop_trigger && arguments[2] && arguments[2].delete(:generated)
+        elsif method.to_sym == :drop_trigger && (extract_all_triggers || arguments[2] && arguments[2].delete(:generated))
           trigger = ::HairTrigger::Builder.new(arguments[0], {:table => arguments[1], :drop => true})
           (@trigger_builders ||= []) << trigger
           trigger
@@ -28,6 +28,7 @@ module HairTrigger
         class << self
           alias_method_chain :method_missing, :trigger_building
           cattr_accessor :extract_trigger_builders
+          cattr_accessor :extract_all_triggers
         end
       end
     end

data/lib/hair_trigger/schema.rb

@@ -0,0 +1,17 @@
+module HairTrigger
+  module Schema
+    attr_reader :info
+    def define_with_no_save(info={}, &block)
+      instance_eval(&block)
+      @info = info
+    end
+
+    def self.extended(base)
+      base.instance_eval do
+        class << self
+          alias_method_chain :define, :no_save
+        end
+      end
+    end
+  end
+end

data/lib/hair_trigger/schema_dumper.rb

@@ -0,0 +1,87 @@
+module HairTrigger
+  module SchemaDumper
+    def trailer_with_triggers(stream)
+      triggers(stream)
+      trailer_without_triggers(stream)
+    end
+
+    def triggers(stream)
+      @connection = ActiveRecord::Base.connection
+      @adapter_name = @connection.adapter_name.downcase.to_sym
+
+      db_triggers = @connection.triggers; nil
+      db_trigger_warnings = {}
+
+      migration_triggers = HairTrigger.current_migrations(:in_rake_task => true, :previous_schema => self.class.previous_schema).map do |(name, builder)|
+        definitions = []
+        builder.generate.each do |statement|
+          if statement =~ /\ACREATE(.*TRIGGER| FUNCTION) ([^ \n]+)/
+            definitions << [$2, statement, $1 == ' FUNCTION' ? :function : :trigger]
+          end
+        end
+        {:builder => builder, :definitions => definitions}
+      end
+
+      migration_triggers.each do |migration|
+        next unless migration[:definitions].all? do |(name, definition, type)|
+          db_triggers[name] && (db_trigger_warnings[name] = true) && db_triggers[name] == normalize_trigger(name, definition, type)
+        end
+        migration[:definitions].each do |(name, trigger, type)|
+          db_triggers.delete(name)
+          db_trigger_warnings.delete(name)
+        end
+
+        stream.print migration[:builder].to_ruby('  ', false) + "\n\n"
+      end
+
+      db_triggers.to_a.sort_by{ |t| (t.first + 'a').sub(/\(/, '_') }.each do |(name, definition)|
+        if db_trigger_warnings[name]
+          stream.puts "  # WARNING: generating adapter-specific definition for #{name} due to a mismatch."
+          stream.puts "  # either there's a bug in hairtrigger or you've messed up your migrations and/or db :-/"
+        else
+          stream.puts "  # no candidate create_trigger statement could be found, creating an adapter-specific one"
+        end
+        if definition =~ /\n/
+          stream.print "  execute(<<-TRIGGERSQL)\n#{definition.rstrip}\n  TRIGGERSQL\n\n"
+        else
+          stream.print "  execute(#{definition.inspect})\n\n"
+        end
+      end
+    end
+
+    def normalize_trigger(name, definition, type)
+      @connection = ActiveRecord::Base.connection
+      @adapter_name = @connection.adapter_name.downcase.to_sym
+
+      return definition unless @adapter_name == :postgresql
+      begin
+        # 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,
+        # asking postgres for its definition, and then rolling back.
+        begin
+          @connection.transaction do
+            chars = ('a'..'z').to_a + ('0'..'9').to_a + ['_']
+            test_name = '_hair_trigger_test_' + (0..43).map{ chars[(rand * chars.size).to_i] }.join
+            test_name << (type == :function ? '()' : '')
+            @connection.execute(definition.sub(name, test_name))
+            definition = @connection.triggers(:only => [test_name], :simple_check => true).values.first
+            definition.sub!(test_name, name)
+            raise
+          end
+        rescue
+        end
+      end
+      definition
+    end
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :trailer, :triggers
+        class << self
+          attr_accessor :previous_schema
+        end
+      end
+    end
+  end
+end

data/lib/tasks/hair_trigger.rake

@@ -1,77 +1,23 @@
 namespace :db do
   desc "Creates a database migration for any newly created/modified/deleted triggers in the models"
   task :generate_trigger_migration => :environment do
-
-    begin
-      canonical_triggers = HairTrigger::current_triggers
-    rescue 
-      $stderr.puts $!
-      exit 1
-    end
-
-    migrations = HairTrigger::current_migrations
-    migration_names = migrations.map(&:first)
-    existing_triggers = migrations.map(&:last)
-
-    up_drop_triggers = []
-    up_create_triggers = []
-    down_drop_triggers = []
-    down_create_triggers = []
-
-    existing_triggers.each do |existing|
-      unless canonical_triggers.any?{ |t| t.prepared_name == existing.prepared_name }
-        up_drop_triggers += existing.drop_triggers
-        down_create_triggers << existing
-      end
-    end
-
-    (canonical_triggers - existing_triggers).each do |new_trigger|
-      up_create_triggers << new_trigger
-      down_drop_triggers += new_trigger.drop_triggers
-      if existing = existing_triggers.detect{ |t| t.prepared_name == new_trigger.prepared_name }
-        # it's not sufficient to rely on the new trigger to replace the old
-        # one, since we could be dealing with trigger groups and the name
-        # alone isn't sufficient to know which component triggers to remove
-        up_drop_triggers += existing.drop_triggers
-        down_create_triggers << existing
-      end
-    end
-
-    unless up_drop_triggers.empty? && up_create_triggers.empty?
-      migration_base_name = if up_create_triggers.size > 0
-        ("create trigger#{up_create_triggers.size > 1 ? 's' : ''} " +
-         up_create_triggers.map{ |t| [t.options[:table], t.options[:events].join(" ")].join(" ") }.join(" and ")
-        ).downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_').camelize
-      else
-        ("drop trigger#{up_drop_triggers.size > 1 ? 's' : ''} " +
-         up_drop_triggers.map{ |t| t.options[:table] }.join(" and ")
-        ).downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_').camelize
-      end
-
-      name_version = nil
-      while migration_names.include?("#{migration_base_name}#{name_version}")
-        name_version = name_version.to_i + 1
-      end
-      migration_name = "#{migration_base_name}#{name_version}"
-      file_name = 'db/migrate/' + Time.now.getutc.strftime("%Y%m%d%H%M%S") + "_" + migration_name.underscore + ".rb"
-      File.open(file_name, "w"){ |f| f.write <<-MIGRATION }
-# This migration was auto-generated via `rake db:generate_trigger_migration'.
-# While you can edit this file, any changes you make to the definitions here
-# will be undone by the next auto-generated trigger migration.
-
-class #{migration_name} < ActiveRecord::Migration
-  def self.up
-    #{(up_drop_triggers + up_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
-  end
-
-  def self.down
-    #{(down_drop_triggers + down_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
-  end
-end
-      MIGRATION
+    if file_name = HairTrigger.generate_migration
       puts "Generated #{file_name}"
     else
       puts "Nothing to do"
     end
   end
+
+  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
+      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)
+      end
+      Rake::Task["db:schema:dump"].reenable
+    end
+  end
 end

data/spec/builder_spec.rb

@@ -1,5 +1,5 @@
 require 'rspec'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/hair_trigger/builder.rb')
+require 'hair_trigger/builder'
 
 HairTrigger::Builder.show_warnings = false
 
@@ -25,6 +25,14 @@ describe "builder" do
     end
   end
 
+  context "generation" do
+    it "should tack on a semicolon if none is provided" do
+      @adapter = MockAdapter.new("mysql")
+      builder.on(:foos).after(:update){ "FOO " }.generate.
+      grep(/FOO;/).size.should eql(1)
+    end
+  end
+
   context "comparison" do
     it "should view identical triggers as identical" do
       @adapter = MockAdapter.new("mysql")
@@ -78,6 +86,12 @@ describe "builder" do
       }.should raise_error
     end
 
+    it "should reject for_each :statement" do
+      lambda {
+        builder.on(:foos).after(:update).for_each(:statement){ "FOO" }.generate
+      }.should raise_error
+    end
+
     it "should reject multiple events" do
       lambda {
         builder.on(:foos).after(:update, :delete){ "FOO" }.generate

data/spec/migrations/20110331212003_initial_tables.rb

@@ -0,0 +1,17 @@
+class InitialTables < ActiveRecord::Migration
+  def self.up
+    create_table "users" do |t|
+      t.integer  "group_id"
+      t.string   "name"
+    end
+
+    create_table "groups" do |t|
+      t.integer  "bob_count", :default => 0
+    end
+  end
+
+  def self.down
+    drop_table "users"
+    drop_table "groups"
+  end
+end

data/spec/migrations/20110331212631_user_trigger.rb

@@ -0,0 +1,18 @@
+# This migration was auto-generated via `rake db:generate_trigger_migration'.
+# While you can edit this file, any changes you make to the definitions here
+# will be undone by the next auto-generated trigger migration.
+
+class UserTrigger < ActiveRecord::Migration
+  def self.up
+    create_trigger("users_after_insert_row_when_new_name_bob__tr", :generated => true, :compatibility => 1).
+        on("users").
+        after(:insert).
+        where("NEW.name = 'bob'") do
+      "UPDATE groups SET bob_count = bob_count + 1"
+    end
+  end
+
+  def self.down
+    drop_trigger("users_after_insert_row_when_new_name_bob__tr", "users")
+  end
+end

data/spec/models/group.rb

@@ -0,0 +1,3 @@
+class Group < ActiveRecord::Base
+  has_many :users
+end

data/spec/models/user.rb

@@ -0,0 +1,6 @@
+class User < ActiveRecord::Base
+  belongs_to :group
+  trigger.after(:insert).where("NEW.name = 'bob'") do
+    "UPDATE groups SET bob_count = bob_count + 1"
+  end
+end

data/spec/schema_dumper_spec.rb

@@ -0,0 +1,99 @@
+require 'active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+require 'active_record/connection_adapters/mysql_adapter'
+require 'active_record/connection_adapters/sqlite3_adapter'
+require 'rspec'
+require 'hair_trigger'
+
+# for this spec to work, you need to have postgres and mysql installed (in
+# addition to the gems), and you should make sure that you have set up
+# hairtrigger_schema_test dbs in mysql and postgres, along with a hairtrigger
+# user (no password) having appropriate privileges (user needs to be able to
+# drop/recreate this db)
+
+def reset_tmp
+  HairTrigger.model_path = 'tmp/models'
+  HairTrigger.migration_path = 'tmp/migrations'
+  FileUtils.rm_rf('tmp') if File.directory?('tmp')
+  FileUtils.mkdir_p(HairTrigger.model_path)
+  FileUtils.mkdir_p(HairTrigger.migration_path)
+  FileUtils.cp_r('spec/models', 'tmp')
+  FileUtils.cp_r('spec/migrations', 'tmp')
+end
+
+def initialize_db(adapter)
+  reset_tmp
+  config = {:database => 'hairtrigger_schema_test', :username => 'hairtrigger', :adapter => adapter.to_s, :host => 'localhost'}
+  case adapter
+    when :mysql
+      ret = `echo "drop database if exists hairtrigger_schema_test; create database hairtrigger_schema_test;" | mysql hairtrigger_schema_test -u hairtrigger`
+      raise "error creating database: #{ret}" unless $?.exitstatus == 0
+    when :sqlite3
+      config[:database] = 'tmp/hairtrigger_schema_test.sqlite3'
+    when :postgresql
+      `dropdb -U hairtrigger hairtrigger_schema_test &>/dev/null`
+      ret = `createdb -U hairtrigger hairtrigger_schema_test 2>&1`
+      raise "error creating database: #{ret}" unless $?.exitstatus == 0
+      config[:min_messages] = :error
+  end
+  ActiveRecord::Base.establish_connection(config)
+  ActiveRecord::Base.logger = Logger.new('/dev/null')
+  ActiveRecord::Migrator.migrate(HairTrigger.migration_path)
+end
+
+describe "schema" do
+  [:mysql, :postgresql, :sqlite3].each do |adapter|
+    it "should correctly dump #{adapter}" do
+      ActiveRecord::Migration.verbose = false
+      initialize_db(adapter)
+      ActiveRecord::Base.connection.triggers.values.grep(/bob_count \+ 1/).size.should eql(1)
+
+      # schema dump w/o previous schema.rb
+      ActiveRecord::SchemaDumper.previous_schema = nil
+      io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+      io.rewind
+      schema_rb = io.read
+      schema_rb.should match(/create_trigger\("users_after_insert_row_when_new_name_bob__tr", :generated => true, :compatibility => 1\)/)
+
+      # schema dump w/ schema.rb
+      ActiveRecord::SchemaDumper.previous_schema = schema_rb
+      io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+      io.rewind
+      schema_rb2 = io.read
+      schema_rb2.should eql(schema_rb)
+
+      # edit our model trigger, generate and apply a new migration
+      user_model = File.read(HairTrigger.model_path + '/user.rb')
+      File.open(HairTrigger.model_path + '/user.rb', 'w') { |f|
+        f.write user_model.sub('UPDATE groups SET bob_count = bob_count + 1', 'UPDATE groups SET bob_count = bob_count + 2')
+      }
+      migration = HairTrigger.generate_migration
+      ActiveRecord::Migrator.migrate(HairTrigger.migration_path)
+      ActiveRecord::Base.connection.triggers.values.grep(/bob_count \+ 1/).size.should eql(0)
+      ActiveRecord::Base.connection.triggers.values.grep(/bob_count \+ 2/).size.should eql(1)
+      
+      # schema dump, should have the updated trigger
+      ActiveRecord::SchemaDumper.previous_schema = schema_rb2
+      io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+      io.rewind
+      schema_rb3 = io.read
+      schema_rb3.should_not eql(schema_rb2)
+      schema_rb3.should match(/create_trigger\("users_after_insert_row_when_new_name_bob__tr", :generated => true, :compatibility => 1\)/)
+      schema_rb3.should match(/UPDATE groups SET bob_count = bob_count \+ 2/)
+
+      # undo migration, schema dump should be back to previous version
+      ActiveRecord::Migrator.rollback(HairTrigger.migration_path)
+      ActiveRecord::SchemaDumper.previous_schema = schema_rb3
+      io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+      io.rewind
+      schema_rb4 = io.read
+      schema_rb4.should_not eql(schema_rb3)
+      schema_rb4.should eql(schema_rb2)
+      ActiveRecord::Base.connection.triggers.values.grep(/bob_count \+ 1/).size.should eql(1)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hairtrigger
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - Jon Jensen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-25 00:00:00 -06:00
+date: 2011-03-31 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,6 +105,54 @@ dependencies:
   type: :development
 - !ruby/object:Gem::Dependency 
   requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 45
+        segments: 
+        - 2
+        - 8
+        - 1
+        version: 2.8.1
+  version_requirements: *id006
+  name: mysql
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 53
+        segments: 
+        - 0
+        - 10
+        - 1
+        version: 0.10.1
+  version_requirements: *id007
+  name: pg
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 3
+        - 2
+        version: 1.3.2
+  version_requirements: *id008
+  name: sqlite3-ruby
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - <
@@ -122,12 +170,12 @@ dependencies:
         - 3
         - 0
         version: 2.3.0
-  version_requirements: *id006
+  version_requirements: *id009
   name: activerecord
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency 
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -138,7 +186,7 @@ dependencies:
         - 3
         - 0
         version: 2.3.0
-  version_requirements: *id007
+  version_requirements: *id010
   name: rspec
   prerelease: false
   type: :development
@@ -165,10 +213,16 @@ files:
 - lib/hair_trigger/base.rb
 - lib/hair_trigger/builder.rb
 - lib/hair_trigger/migration.rb
+- lib/hair_trigger/schema.rb
+- lib/hair_trigger/schema_dumper.rb
 - lib/tasks/hair_trigger.rake
 - rails/init.rb
 - spec/builder_spec.rb
-- spec/spec_helper.rb
+- spec/migrations/20110331212003_initial_tables.rb
+- spec/migrations/20110331212631_user_trigger.rb
+- spec/models/group.rb
+- spec/models/user.rb
+- spec/schema_dumper_spec.rb
 has_rdoc: true
 homepage: http://github.com/jenseng/hair_trigger
 licenses: 
@@ -205,4 +259,8 @@ specification_version: 3
 summary: easy database triggers for active record
 test_files: 
 - spec/builder_spec.rb
-- spec/spec_helper.rb
+- spec/migrations/20110331212003_initial_tables.rb
+- spec/migrations/20110331212631_user_trigger.rb
+- spec/models/group.rb
+- spec/models/user.rb
+- spec/schema_dumper_spec.rb

data/spec/spec_helper.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
-require 'hairtrigger'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-RSpec.configure do |config|
-  
-end