hairtrigger 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+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"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jon Jensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,134 @@
+= HairTrigger
+
+HairTrigger lets you create and manage database triggers in a concise,
+db-agnostic, Rails-y way.
+
+== Install
+
+Assuming you're using bundler:
+
+1. install the gem
+2. let rails know about it (via Gemfile, environment.rb, whatever)
+3. create lib/tasks/hair_trigger.rake with the following:
+
+ $VERBOSE = nil
+ Dir["#{Gem.searcher.find('hair_trigger').full_gem_path}/lib/tasks/*.rake"].each { |ext| load ext }
+
+An alternative to steps 2 and 3 is to unpack it in vendor/plugins and delete
+its Gemfile.
+
+== Usage
+ 
+Declare triggers in your models and use a rake task to auto-generate the
+appropriate migration. For example:
+
+ class AccountUser < ActiveRecord::Base
+   trigger.after(:insert) do
+     "UPDATE accounts SET user_count = user_count + 1 WHERE id = NEW.account_id;"
+   end
+ end
+
+and then:
+
+ rake db:generate_trigger_migration
+
+This will create a db-agnostic migration for the trigger that mirrors the
+model declaration. You can also manage triggers manually in your migrations
+(via create_trigger/drop_trigger), though that ends up being more work.
+
+Note that these auto-generated create_trigger statements 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.
+
+== Chainable Methods
+
+Triggers are built by chaining several methods together, ending in a block
+that specifies the SQL to be run when the trigger fires. Supported methods
+include:
+
+* name(trigger_name): Optional, inferred from other calls.
+* on(table_name): Ignored in models, required in migrations.
+* for_each(item): Defaults to :row, PostgreSQL/MySQL allow :statement.
+* before(*events): Shorthand for timing(:before).events(*events).
+* after(*events): Shorthand for timing(:after).events(*events).
+* where(conditions): Optional, limits when the trigger will fire.
+* security(user): Permissions/role to check when calling trigger, defaults to :invoker. PostgreSQL supports :definer, MySQL supports :definer and arbitrary users (syntax: 'user'@'host').
+* timing(timing): Required (but may be satisified by before/after). Possible values are :before/:after.
+* events(*events): Required (but may be satisified by before/after). MySQL/SQLite only support one action.
+* all: Noop, useful for trigger groups (see below).
+
+== Trigger Groups
+
+Trigger groups allow you to use a slightly more concise notation if you have
+several triggers that fire on a given model. This is also important for MySQL,
+since it does not support multiple triggers on a table for the same action
+and timing. For example:
+
+ trigger.after(:update) do |t|
+   t.all do # every row
+     # some sql
+   end
+   t.where("OLD.foo <> NEW.foo") do
+     # some more sql
+   end
+   t.where("OLD.bar <> NEW.bar") do
+     # some other sql
+   end
+ end
+
+For MySQL, this will just create a single trigger with conditional logic
+(since it doesn't support multiple triggers). PostgreSQL and SQLite will have
+distinct triggers. This same notation is also used within trigger migrations.
+MySQL does not currently support nested trigger groups.
+
+== 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:
+
+ assert HairTrigger::migrations_current?
+
+This way you'll know if there are any outstanding migrations you need to
+create.
+
+== Warnings and Errors
+
+If you try something your adapter doesn't support (e.g. multiple triggering
+events for MySQL), you will get an error. If your adapter does support it, you
+will just get a warning to let you know your trigger is not portable. You can
+silence warnings via `HairTrigger::Builder.show_warnings = false`
+
+HairTrigger does not validate your SQL, so be sure to test it in all database
+you want to support.
+
+== Gotchas, Known Issues
+
+* 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
+  account:
+   a = Account.find(123)
+   a.account_users.create(:name => 'bob')
+   puts "count is now #{a.user_count}"
+* For repeated chained calls, the last one wins, there is currently no
+  merging.
+* If you want your code to be portable, the trigger actions should be
+  limited to INSERT/UPDATE/DELETE/SELECT, and conditional logic should be
+  handled through the :where option/method. Otherwise you'll likely run into
+  trouble due to differences in syntax and supported features.
+
+== Compatibility
+
+* Rails 2.3.x
+* Postgres 9.0+
+* MySQL 5.0+
+* SQLite 3.0+
+
+== Copyright
+
+Copyright (c) 2011 Jon Jensen. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "hairtrigger"
+  gem.homepage = "http://github.com/jenseng/hairtrigger"
+  gem.license = "MIT"
+  gem.summary = %Q{easy database triggers for active record}
+  gem.description = %Q{}
+  gem.email = "jenseng@gmail.com"
+  gem.authors = ["Jon Jensen"]
+  gem.add_runtime_dependency "activerecord", ">=2.3.0", "<3.0"
+  gem.add_development_dependency "rspec", "~> 2.3.0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hairtrigger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/init.rb

@@ -0,0 +1 @@
+require 'hair_trigger'

data/lib/hair_trigger.rb

@@ -0,0 +1,50 @@
+module HairTrigger
+  def self.current_triggers
+    # see what the models say there should be
+    canonical_triggers = []
+    Dir['app/models/*rb'].each do |model|
+      class_name = model.sub(/\A.*\/(.*?)\.rb\z/, '\1').camelize
+      begin
+        klass = Kernel.const_get(class_name)
+      rescue
+        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
+    end
+    canonical_triggers.each(&:prepare!) # interpolates any vars so we match the migrations
+  end
+
+  def self.current_migrations
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Migration.extract_trigger_builders = true
+    
+    # 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|
+      migration.migrate(:up)
+      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]
+      end
+    end
+    migrations.each{ |(n, t)| t.prepare! }
+  ensure
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migration.extract_trigger_builders = false
+  end
+
+  def self.migrations_current?
+    current_migrations.map(&:last).sort == current_triggers.sort
+  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 }

data/lib/hair_trigger/adapter.rb

@@ -0,0 +1,15 @@
+module HairTrigger
+  module Adapter
+    def create_trigger(name = nil, options = {})
+      if name.is_a?(Hash)
+        options = name
+        name = nil
+      end
+      ::HairTrigger::Builder.new(name, options.merge(:execute => true))
+    end
+
+    def drop_trigger(name, table, options = {})
+      ::HairTrigger::Builder.new(name, options.merge(:execute => true, :drop => true, :table => table)){}
+    end
+  end
+end

data/lib/hair_trigger/base.rb

@@ -0,0 +1,16 @@
+module HairTrigger
+  module Base
+    attr_reader :triggers
+
+    def trigger(name = nil, options = {})
+      if name.is_a?(Hash)
+        options = name
+        name = nil
+      end
+      @triggers ||= []
+      trigger = ::HairTrigger::Builder.new(name, options)
+      @triggers << trigger
+      trigger.on(table_name)
+    end
+  end
+end

data/lib/hair_trigger/builder.rb

@@ -0,0 +1,348 @@
+module HairTrigger
+  class Builder
+    attr_accessor :options
+    attr_reader :triggers # nil unless this is a trigger group
+    attr_reader :prepared_actions, :prepared_where # after delayed interpolation
+
+    def initialize(name = nil, options = {})
+      @adapter = options[:adapter] || ActiveRecord::Base.connection rescue nil
+      @options = {}
+      @chained_calls = []
+      set_name(name) if name
+      {:timing => :after, :for_each => :row}.update(options).each do |key, value|
+        if respond_to?("set_#{key}")
+          send("set_#{key}", *Array[value])
+        else
+          @options[key] = value
+        end
+      end
+    end
+
+    def initialize_copy(other)
+      @trigger_group = other
+      @triggers = nil
+      @chained_calls = []
+      @options = @options.dup
+      @options.delete(:name) # this will be inferred (or set further down the line)
+      @options.each do |key, value|
+        @options[key] = value.dup rescue value
+      end
+    end
+
+    def drop_triggers
+      all_names.map{ |name| self.class.new(name, {:table => options[:table], :drop => true}) }
+    end
+
+    def name(name)
+      raise_or_warn "trigger name cannot exceed 63 for postgres", :postgresql if name.to_s.size > 63
+      options[:name] = name.to_s
+    end
+
+    def on(table)
+      raise "table has already been specified" if options[:table]
+      options[:table] = table.to_s
+    end
+
+    def for_each(for_each)
+      raise_or_warn "sqlite doesn't support FOR EACH STATEMENT triggers", :sqlite if for_each == :statement
+      raise "invalid for_each" unless [:row, :statement].include?(for_each)
+      options[:for_each] = for_each.to_s.upcase
+    end
+
+    def before(*events)
+      set_timing(:before)
+      set_events(*events)
+    end
+
+    def after(*events)
+      set_timing(:after)
+      set_events(*events)
+    end
+
+    def where(where)
+      options[:where] = where
+    end
+
+    # noop, just a way you can pass a block within a trigger group
+    def all
+    end
+
+    def security(user)
+      return if user == :invoker # default behavior
+      raise_or_warn "sqlite doesn't support trigger security clauses", :sqlite
+      raise_or_warn "postgresql doesn't support arbitrary users for security clauses", :postgresql unless user == :definer
+      options[:security] = user
+    end
+
+    def timing(timing)
+      raise "invalid timing" unless [:before, :after].include?(timing)
+      options[:timing] = timing.to_s.upcase
+    end
+
+    def events(*events)
+      events << :insert if events.delete(:create)
+      events << :delete if events.delete(:destroy)
+      raise "invalid events" unless events & [:insert, :update, :delete] == events
+      raise_or_warn "sqlite and mysql triggers may not be shared by multiple actions", :mysql, :sqlite if events.size > 1
+      options[:events] = events.map{ |e| e.to_s.upcase }
+    end
+
+    def prepared_name
+      @prepared_name ||= options[:name] ||= infer_name
+    end
+
+    def all_names
+      [prepared_name] + (@triggers ? @triggers.map(&:prepared_name) : [])
+    end
+
+    def self.chainable_methods(*methods)
+      methods.each do |method|
+        class_eval <<-METHOD
+          alias #{method}_orig #{method}
+          def #{method}(*args)
+            @chained_calls << :#{method}
+            if @triggers || @trigger_group
+              raise_or_warn "mysql doesn't support #{method} within a trigger group", :mysql unless [:name, :where, :all].include?(:#{method})
+            end
+            set_#{method}(*args, &(block_given? ? Proc.new : nil))
+          end
+          def set_#{method}(*args)
+            if @triggers # i.e. each time we say t.something within a trigger group block
+              @chained_calls.pop # the subtrigger will get this, we don't need it
+              @chained_calls = @chained_calls.uniq
+              @triggers << trigger = clone
+              trigger.#{method}(*args, &Proc.new)
+            else
+              #{method}_orig(*args)
+              maybe_execute(&Proc.new) if block_given?
+              self
+            end
+          end
+        METHOD
+      end
+    end
+    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all
+
+    def create_grouped_trigger?
+      adapter_name == :mysql
+    end
+
+    def prepare!
+      @triggers.each(&:prepare!) if @triggers
+      @prepared_where = options[:where] = interpolate(options[:where]) if options[:where]
+      @prepared_actions = interpolate(@actions).rstrip if @actions
+    end
+
+    def generate
+      return @triggers.map(&:generate).flatten if @triggers && !create_grouped_trigger?
+      prepare!
+      raise "need to specify the table" unless options[:table]
+      if options[:drop]
+        generate_drop_trigger
+      else
+        raise "no actions specified" if @triggers && create_grouped_trigger? ? @triggers.any?{ |t| t.prepared_actions.nil? } : prepared_actions.nil?
+        raise "need to specify the event(s) (:insert, :update, :delete)" if !options[:events] || options[:events].empty?
+        raise "need to specify the timing (:before/:after)" unless options[:timing]
+
+        ret = [generate_drop_trigger]
+        ret << case adapter_name
+          when :sqlite
+            generate_trigger_sqlite
+          when :mysql
+            generate_trigger_mysql
+          when :postgresql
+            generate_trigger_postgresql
+          else
+            raise "don't know how to build #{adapter_name} triggers yet"
+        end
+        ret
+      end
+    end
+
+    def to_ruby(indent = '')
+      prepare!
+      if options[:drop]
+        "#{indent}drop_trigger(#{prepared_name.inspect}, #{options[:table].inspect}, :generated => true)"
+      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).\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"
+          else
+            str << " do\n"
+            str << actions_to_ruby("#{indent}  ") + "\n"
+          end
+          str << "#{indent}end"
+        end
+      end
+    end
+
+    def <=>(other)
+      ret = prepared_name <=> other.prepared_name
+      ret == 0 ? hash <=> other.hash : ret
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(HairTrigger::Builder)
+      hash == other.hash
+    end
+
+    def hash
+      prepare!
+      [self.options.hash, self.prepared_actions.hash, self.prepared_where.hash, self.triggers.hash].hash
+    end
+
+    private
+
+    def chained_calls_to_ruby(join_str = '.')
+      @chained_calls.map { |c|
+        case c
+          when :before, :after, :events
+            "#{c}(#{options[:events].map{|c|c.downcase.to_sym.inspect}.join(', ')})"
+          when :on
+            "on(#{options[:table].inspect})"
+          when :where
+            "where(#{prepared_where.inspect})"
+          else
+            "#{c}(#{options[c].inspect})"
+        end
+      }.join(join_str)
+    end
+
+    def actions_to_ruby(indent = '')
+      if prepared_actions =~ /\n/
+        "#{indent}<<-SQL_ACTIONS\n#{prepared_actions}\n#{indent}SQL_ACTIONS"
+      else
+        indent + prepared_actions.inspect
+      end
+    end
+
+    def maybe_execute(&block)
+      if block.arity > 0 # we're creating a trigger group, so set up some stuff and pass the buck
+        raise_or_warn "trigger group must specify timing and event(s)", :mysql unless options[:timing] && options[:events]
+        raise_or_warn "nested trigger groups are not supported for mysql", :mysql if create_grouped_trigger? && @trigger_group
+        @triggers = []
+        block.call(self)
+        raise "trigger group did not define any triggers" if @triggers.empty?
+      else
+        @actions = block.call
+      end
+      # only the top-most block actually executes
+      Array(generate).each{ |action| @adapter.execute(action)} if options[:execute] && !@trigger_group
+      self
+    end
+
+    def adapter_name
+      @adapter_name ||= @adapter.adapter_name.downcase.to_sym
+    end
+
+    def infer_name
+      [options[:table],
+       options[:timing],
+       options[:events],
+       options[:for_each],
+       prepared_where ? 'when_' + prepared_where : nil
+      ].flatten.compact.
+      join("_").downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_')[0, 60] + "_tr"
+    end
+
+    def generate_drop_trigger
+      case adapter_name
+        when :sqlite, :mysql
+          "DROP TRIGGER IF EXISTS #{prepared_name};\n"
+        when :postgresql
+          "DROP TRIGGER IF EXISTS #{prepared_name} ON #{options[:table]};\nDROP FUNCTION IF EXISTS #{prepared_name}();\n"
+        else
+          raise "don't know how to drop #{adapter_name} triggers yet"
+      end
+    end
+
+    def generate_trigger_sqlite
+      <<-SQL
+CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events]} ON #{options[:table]}
+FOR EACH #{options[:for_each]}#{prepared_where ? " WHEN " + prepared_where : ''}
+BEGIN
+#{normalize(prepared_actions, 1).rstrip}
+END;
+      SQL
+    end
+
+    def generate_trigger_postgresql
+      <<-SQL
+CREATE FUNCTION #{prepared_name}()
+RETURNS TRIGGER AS $$
+BEGIN
+#{normalize(prepared_actions, 1).rstrip}
+END;
+$$ LANGUAGE plpgsql#{options[:security] ? " SECURITY #{options[:security].to_s.upcase}" : ""};
+CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].join(" OR ")} ON #{options[:table]}
+FOR EACH #{options[:for_each]}#{prepared_where ? " WHEN (" + prepared_where + ')': ''} EXECUTE PROCEDURE #{prepared_name}();
+      SQL
+    end
+
+    def generate_trigger_mysql
+      security = options[:security]
+      if security == :definer
+        config = @adapter.instance_variable_get(:@config)
+        security = "'#{config[:username]}'@'#{config[:host]}'"
+      end
+      sql = <<-SQL
+CREATE #{security ? "DEFINER = #{security} " : ""}TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].first} ON #{options[:table]}
+FOR EACH #{options[:for_each]}
+BEGIN
+      SQL
+      (@triggers ? @triggers : [self]).each do |trigger|
+        if trigger.prepared_where
+          sql << normalize("IF #{trigger.prepared_where} THEN", 1)
+          sql << normalize(trigger.prepared_actions, 2)
+          sql << normalize("END IF;", 1)
+        else
+          sql << normalize(trigger.prepared_actions, 1)
+        end
+      end
+      sql << "END\n";
+    end
+
+    def interpolate(str)
+      eval("%@#{str.gsub('@', '\@')}@")
+    end
+
+    def normalize(text, level = 0)
+      indent = level * self.class.tab_spacing
+      text.gsub!(/\t/, ' ' * self.class.tab_spacing)
+      existing = text.split(/\n/).map{ |line| line.sub(/[^ ].*/, '').size }.min
+      if existing > indent
+        text.gsub!(/^ {#{existing - indent}}/, '')
+      elsif indent > existing
+        text.gsub!(/^/, ' ' * (indent - existing))
+      end
+      text.rstrip + "\n"
+    end
+
+    def raise_or_warn(message, *adapters)
+      if adapters.include?(adapter_name)
+        raise message
+      else
+        $stderr.puts "WARNING: " + message if self.class.show_warnings
+      end
+    end
+
+    class << self
+      attr_writer :tab_spacing
+      attr_writer :show_warnings
+      def tab_spacing
+        @tab_spacing ||= 4
+      end
+      def show_warnings
+        @show_warnings = true if @show_warnings.nil?
+        @show_warnings
+      end
+    end
+  end
+end

data/lib/hair_trigger/migration.rb

@@ -0,0 +1,34 @@
+module HairTrigger
+  module Migration
+    attr_reader :trigger_builders
+
+    def method_missing_with_trigger_building(method, *arguments, &block)
+      if extract_trigger_builders
+        if method.to_sym == :create_trigger
+          arguments.unshift(nil) if arguments.first.is_a?(Hash)
+          trigger = ::HairTrigger::Builder.new(*arguments) if arguments[1].delete(:generated)
+          (@trigger_builders ||= []) << trigger
+          trigger
+        elsif method.to_sym == :drop_trigger
+          trigger = ::HairTrigger::Builder.new(arguments[0], {:table => arguments[1], :drop => true}) if arguments[2] && arguments[2].delete(:generated)
+          (@trigger_builders ||= []) << trigger
+          trigger
+        end
+        # normally we would fall through to the connection for everything
+        # else, but we don't want to do that since we are not actually
+        # running the migration
+      else
+        method_missing_without_trigger_building(method, *arguments, &block)
+      end
+    end
+
+    def self.extended(base)
+      base.class_eval do
+        class << self
+          alias_method_chain :method_missing, :trigger_building
+          cattr_accessor :extract_trigger_builders
+        end
+      end
+    end
+  end
+end

data/lib/tasks/hair_trigger.rake

@@ -0,0 +1,77 @@
+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").lstrip}
+  end
+
+  def self.down
+    #{(down_drop_triggers + down_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n").lstrip}
+  end
+end
+      MIGRATION
+      puts "Generated #{file_name}"
+    else
+      puts "Nothing to do"
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'hair_trigger'

data/spec/builder_spec.rb

@@ -0,0 +1,140 @@
+require 'rspec'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/hair_trigger/builder.rb')
+
+HairTrigger::Builder.show_warnings = false
+
+class MockAdapter
+  attr_reader :adapter_name, :config
+  def initialize(type, user = nil, host = nil)
+    @adapter_name = type
+    @config = {:username => user, :host => host}
+  end
+end
+
+def builder
+  HairTrigger::Builder.new(nil, :adapter => @adapter)
+end
+
+describe "builder" do
+  context "chaining" do
+    it "should use the last redundant chained call" do
+      @adapter = MockAdapter.new("mysql", "user", "host")
+      builder.where(:foo).where(:bar).options[:where].should be(:bar)
+    end
+  end
+
+  context "mysql" do
+    before(:each) do
+      @adapter = MockAdapter.new("mysql", "user", "host")
+    end
+
+    it "should create a single trigger for a group" do
+      trigger = builder.on(:foos).after(:update){ |t|
+        t.where('BAR'){ 'BAR' }
+        t.where('BAZ'){ 'BAZ' }
+      }
+      trigger.generate.grep(/CREATE.*TRIGGER/).size.should eql(1)
+    end
+
+    it "should disallow nested groups" do
+      lambda {
+        builder.on(:foos){ |t|
+          t.after(:update){ |t|
+            t.where('BAR'){ 'BAR' }
+            t.where('BAZ'){ 'BAZ' }
+          }
+        }
+      }.should raise_error
+    end
+
+    it "should accept security" do
+      builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate.
+        grep(/DEFINER = 'user'@'host'/).size.should eql(1)
+    end
+
+    it "should reject multiple timings" do
+      lambda { builder.on(:foos).after(:update, :delete){ "FOO" } }.
+        should raise_error
+    end
+  end
+
+  context "postgresql" do
+    before(:each) do
+      @adapter = MockAdapter.new("postgresql")
+    end
+
+    it "should create multiple triggers for a group" do
+      trigger = builder.on(:foos).after(:update){ |t|
+        t.where('BAR'){ 'BAR' }
+        t.where('BAZ'){ 'BAZ' }
+      }
+      trigger.generate.grep(/CREATE.*TRIGGER/).size.should eql(2)
+    end
+
+    it "should allow nested groups" do
+      trigger = builder.on(:foos){ |t|
+        t.after(:update){ |t|
+          t.where('BAR'){ 'BAR' }
+          t.where('BAZ'){ 'BAZ' }
+        }
+        t.after(:insert){ 'BAZ' }
+      }
+      trigger.generate.grep(/CREATE.*TRIGGER/).size.should eql(3)
+    end
+
+    it "should accept security" do
+      builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate.
+        grep(/SECURITY DEFINER/).size.should eql(1)
+    end
+
+    it "should accept multiple timings" do
+      builder.on(:foos).after(:update, :delete){ "FOO" }.generate.
+        grep(/UPDATE OR DELETE/).size.should eql(1)
+    end
+
+    it "should reject long names" do
+      lambda { builder.name('A'*65).on(:foos).after(:update){ "FOO" }}.
+        should raise_error
+    end
+  end
+
+  context "sqlite" do
+    before(:each) do
+      @adapter = MockAdapter.new("sqlite")
+    end
+
+    it "should create multiple triggers for a group" do
+      trigger = builder.on(:foos).after(:update){ |t|
+        t.where('BAR'){ 'BAR' }
+        t.where('BAZ'){ 'BAZ' }
+      }
+      trigger.generate.grep(/CREATE.*TRIGGER/).size.should eql(2)
+    end
+
+    it "should allow nested groups" do
+      trigger = builder.on(:foos){ |t|
+        t.after(:update){ |t|
+          t.where('BAR'){ 'BAR' }
+          t.where('BAZ'){ 'BAZ' }
+        }
+        t.after(:insert){ 'BAZ' }
+      }
+      trigger.generate.grep(/CREATE.*TRIGGER/).size.should eql(3)
+    end
+
+    it "should reject security" do
+      lambda { builder.on(:foos).after(:update).security(:definer){ "FOO" } }.
+        should raise_error
+    end
+
+    it "should reject for_each :statement" do
+      lambda { builder.on(:foos).after(:update).for_each(:statement){ "FOO" } }.
+        should raise_error
+    end
+
+    it "should reject multiple timings" do
+      lambda { builder.on(:foos).after(:update, :delete){ "FOO" } }.
+        should raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$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

metadata

@@ -0,0 +1,208 @@
+--- !ruby/object:Gem::Specification 
+name: hairtrigger
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jon Jensen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-21 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  version_requirements: *id001
+  name: activerecord
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  version_requirements: *id002
+  name: rspec
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  version_requirements: *id003
+  name: bundler
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  version_requirements: *id004
+  name: jeweler
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id005
+  name: rcov
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  version_requirements: *id006
+  name: activerecord
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  version_requirements: *id007
+  name: rspec
+  prerelease: false
+  type: :development
+description: ""
+email: jenseng@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/hair_trigger.rb
+- lib/hair_trigger/adapter.rb
+- lib/hair_trigger/base.rb
+- lib/hair_trigger/builder.rb
+- lib/hair_trigger/migration.rb
+- lib/tasks/hair_trigger.rake
+- rails/init.rb
+- spec/builder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jenseng/hairtrigger
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: easy database triggers for active record
+test_files: 
+- spec/builder_spec.rb
+- spec/spec_helper.rb