hairtrigger 0.2.21 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f20c9f46678e0f212a8dddf861f0872609c4a519
-  data.tar.gz: 3dd34ed254df8230ff6ffd32020be89d9b63c386
+  metadata.gz: 935691cbc5895c59ed3a1302e29112a6bdfd3722
+  data.tar.gz: fcc0c590a2c112a895d303e6027a202c3b192c1b
 SHA512:
-  metadata.gz: a8db4cbe050c37d6aed248679e72770767e4b1b05812f8dc704ae2234e02ff5c7a8d38e3f4663ef23642b9c2aa3d39d18a813b73eb3f5ccc25cc24b5019170ca
-  data.tar.gz: 827a7536fcee643bc4652a6cb7b073e13ab182b1b03f69bf80b63deb63f7618c6b564d3a91df5fa48acda4059f3e8c7eed03eb06510c79e4ed45d3aa7ffa6794
+  metadata.gz: 15b0da9b7da0f7c0534393a6ee88c034ec6b69e03589f6675fec1d8f3d221d69ec672d3bf9b7058c0ef5095897a071ad7247a904b3fd1d0a133c0548fdbf4c54
+  data.tar.gz: bed6e7c495e5dd1d6866f7ce86ddaa7521244ba7e3176e99c983494715a804d5fdeaeeab0ffaada4b78348bbd3b964f9c56d4df7b80fa601fc65c9a8ac64e965

data/README.md

@@ -7,8 +7,15 @@ and a simple rake task does all the dirty work for you.
 
 ## Installation
 
-If you are using Rails 3 or beyond, just add `gem 'hairtrigger'` to your
-Gemfile. For Rails 2, it's [slightly more involved](RAILS2.md)
+HairTrigger works with Rails 5.0 onwards. Add the following line to your Gemfile:
+
+```ruby
+gem 'hairtrigger'
+```
+
+Then run `bundle install`
+
+For older versions of Rails check the last [0.2 release](https://github.com/jenseng/hair_trigger/tree/v0.2.21)
 
 ## Usage
 
@@ -248,7 +255,7 @@ create.
 
 ## Warnings and Errors
 
-There are a couple classes of errors: declaration errors and generation 
+There are a couple classes of errors: declaration errors and generation
 errors/warnings.
 
 Declaration errors happen if your trigger declaration is obviously wrong, and
@@ -313,10 +320,26 @@ existing trigger if you wish to redefine it.
 * Manual `create_trigger` statements have some gotchas. See the section
   "Manual triggers and :compatibility"
 
+## Contributing
+
+Contributions welcome! I don't write much Ruby these days 😢 (and haven't used this
+gem in years 😬) but am happy to take contributions. If I'm slow to respond, don't
+hesitate to @ me repeatedly, sometimes those github notifications slip through
+the cracks. 😆.
+
+If you want to add a feature/bugfix, you can rely on Travis to run the tests, but
+do also run them locally (especially if you are changing supported railses/etc).
+HairTrigger uses [appraisal](https://github.com/thoughtbot/appraisal) to manage all
+that w/ automagical gemfiles. So the tl;dr when testing locally is:
+
+1. make sure you have mysql and postgres installed (homebrew or whatever)
+2. `bundle exec appraisal install` -- get all the dependencies
+3. `bundle exec appraisal rake` -- run the specs every which way
+
 ## Compatibility
 
-* Ruby 1.8.7+
-* Rails 2.3+
+* Ruby 2.3.0+
+* Rails 5.0+
 * PostgreSQL 8.0+
 * MySQL 5.0.10+
 * SQLite 3.3.8+
@@ -325,4 +348,4 @@ existing trigger if you wish to redefine it.
 
 ## Copyright
 
-Copyright (c) 2011-2017 Jon Jensen. See LICENSE.txt for further details.
+Copyright (c) 2011-2019 Jon Jensen. See LICENSE.txt for further details.

data/lib/hair_trigger.rb

@@ -22,7 +22,7 @@ module HairTrigger
     end
 
     def models
-      if defined?(Rails) && Rails::VERSION::MAJOR > 2
+      if defined?(Rails)
         Rails.application.eager_load!
       else
         Dir[model_path + '/*rb'].each do |model|
@@ -35,17 +35,13 @@ module HairTrigger
           end
         end
       end
-      ActiveRecord::VERSION::STRING < "3.0." ?
-        ActiveRecord::Base.send(:subclasses) :
-        ActiveRecord::Base.descendants
+      ActiveRecord::Base.descendants
     end
 
     def migrator
       version = ActiveRecord::VERSION::STRING
       if version >= "5.2."
         migrations = ActiveRecord::MigrationContext.new(migration_path).migrations
-      elsif version < "4.0."
-        migrations = migration_path
       else # version >= "4.0."
         migrations = ActiveRecord::Migrator.migrations(migration_path)
       end
@@ -59,7 +55,7 @@ module HairTrigger
         options[:schema_rb_first] = true
         options[:skip_pending_migrations] = true
       end
-  
+
       # 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
@@ -76,7 +72,7 @@ module HairTrigger
         triggers = MigrationReader.get_triggers(migration, options)
         migrations << [migration, triggers] unless triggers.empty?
       end
-  
+
       if previous_schema = (options.has_key?(:previous_schema) ? options[:previous_schema] : File.exist?(schema_rb_path) && File.read(schema_rb_path))
         base_triggers = MigrationReader.get_triggers(previous_schema, options)
         unless base_triggers.empty?
@@ -84,9 +80,9 @@ module HairTrigger
           migrations.unshift [OpenStruct.new({:version => version}), base_triggers]
         end
       end
-      
+
       migrations = migrations.sort_by{|(migration, triggers)| migration.version} unless options[:schema_rb_first]
-  
+
       all_builders = []
       migrations.each do |(migration, triggers)|
         triggers.each do |new_trigger|
@@ -97,7 +93,7 @@ module HairTrigger
           all_builders << [migration.name, new_trigger] unless new_trigger.options[:drop]
         end
       end
-  
+
       all_builders
     end
 
@@ -108,27 +104,27 @@ module HairTrigger
     def generate_migration(silent = false)
       begin
         canonical_triggers = current_triggers
-      rescue 
+      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 = []
-  
+
       # see which triggers need to be dropped
       existing_triggers.each do |existing|
         next if canonical_triggers.any?{ |t| t.prepared_name == existing.prepared_name }
         up_drop_triggers.concat existing.drop_triggers
         down_create_triggers << existing
       end
-  
+
       # see which triggers need to be added/replaced
       (canonical_triggers - existing_triggers).each do |new_trigger|
         up_create_triggers << new_trigger
@@ -141,29 +137,28 @@ module HairTrigger
           down_create_triggers << existing
         end
       end
-  
+
       return if up_drop_triggers.empty? && up_create_triggers.empty?
 
       migration_name = infer_migration_name(migration_names, up_create_triggers, up_drop_triggers)
       migration_version = infer_migration_version(migration_name)
       file_name = migration_path + '/' + migration_version + "_" + migration_name.underscore + ".rb"
       FileUtils.mkdir_p migration_path
-      prefix = ActiveRecord::VERSION::STRING < "3.1." ? "self." : ""
-      File.open(file_name, "w"){ |f| f.write <<-MIGRATION }
+      File.open(file_name, "w") { |f| f.write <<-RUBY }
 # 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 #{prefix}up
+class #{migration_name} < ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]
+  def up
     #{(up_drop_triggers + up_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
   end
 
-  def #{prefix}down
+  def down
     #{(down_drop_triggers + down_create_triggers).map{ |t| t.to_ruby('    ') }.join("\n\n").lstrip}
   end
 end
-      MIGRATION
+      RUBY
       file_name
     end
 
@@ -226,10 +221,6 @@ end
 end
 
 ActiveRecord::Base.send :extend, HairTrigger::Base
-if ActiveRecord::VERSION::STRING < "4.1."
-  ActiveRecord::Migrator.send :extend, HairTrigger::Migrator
-else
-  ActiveRecord::Migration.send :include, HairTrigger::Migrator
-end
+ActiveRecord::Migration.send :include, HairTrigger::Migrator
 ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval { include HairTrigger::Adapter }
 ActiveRecord::SchemaDumper.class_eval { include HairTrigger::SchemaDumper }

data/lib/hair_trigger/builder.rb

@@ -335,10 +335,11 @@ module HairTrigger
         block.call(self)
         raise DeclarationError, "trigger group did not define any triggers" if @triggers.empty?
       else
-        @actions = block.call
-        (@actions.is_a?(Hash) ? @actions.values : [@actions]).each do |actions|
-          actions.sub!(/(\s*)\z/, ';\1') if actions && actions !~ /;\s*\z/
-        end
+        @actions =
+          case (actions = block.call)
+          when Hash then actions.map { |key, action| [key, ensure_semicolon(action)] }.to_h
+          else ensure_semicolon(actions)
+          end
       end
       # only the top-most block actually executes
       if !@trigger_group
@@ -350,6 +351,10 @@ module HairTrigger
       self
     end
 
+    def ensure_semicolon(action)
+      action && action !~ /;\s*\z/ ? action.sub(/(\s*)\z/, ';\1') : action
+    end
+
     def validate_names!
       subtriggers = all_triggers(false)
       named_subtriggers = subtriggers.select{ |t| t.options[:name] }

data/lib/hair_trigger/schema_dumper.rb

@@ -55,7 +55,7 @@ module HairTrigger
           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"
+          stream.print "  execute(<<-SQL)\n#{definition.rstrip}\n  SQL\n\n"
         else
           stream.print "  execute(#{definition.inspect})\n\n"
         end
@@ -99,9 +99,8 @@ module HairTrigger
     def self.included(base)
       base.class_eval do
         prepend TrailerWithTriggersSupport
-        class << self
-          attr_accessor :previous_schema
-        end
+
+        class_attribute :previous_schema
       end
     end
   end

data/lib/hair_trigger/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hairtrigger
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.22
 platform: ruby
 authors:
 - Jon Jensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-08 00:00:00.000000000 Z
+date: 2019-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: ruby_parser
   requirement: !ruby/object:Gem::Requirement
@@ -73,22 +79,6 @@ files:
 - lib/hair_trigger/version.rb
 - lib/hairtrigger.rb
 - lib/tasks/hair_trigger.rake
-- spec/adapter_spec.rb
-- spec/builder_spec.rb
-- spec/migrations-3.2/20110331212003_initial_tables.rb
-- spec/migrations-3.2/20110331212631_user_trigger.rb
-- spec/migrations-3.2/20110417185102_manual_user_trigger.rb
-- spec/migrations-pre-3.1/20110331212003_initial_tables.rb
-- spec/migrations-pre-3.1/20110331212631_user_trigger.rb
-- spec/migrations-pre-3.1/20110417185102_manual_user_trigger.rb
-- spec/migrations/20110331212003_initial_tables.rb
-- spec/migrations/20110331212631_user_trigger.rb
-- spec/migrations/20110417185102_manual_user_trigger.rb
-- spec/migrations_spec.rb
-- spec/models/user.rb
-- spec/models/user_group.rb
-- spec/schema_dumper_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/jenseng/hair_trigger
 licenses:
 - MIT
@@ -101,12 +91,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.5
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.13

data/spec/adapter_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-# 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
-# appropriate users and permissions. see database.yml for more info
-
-describe "adapter" do
-  include_context "hairtrigger utils"
-
-  describe ".triggers" do
-    before do
-      reset_tmp(:migration_glob => "*initial_tables*")
-      initialize_db
-      migrate_db
-    end
-
-    shared_examples_for "mysql" do
-      # have to stub SHOW TRIGGERS to get back a '%' host, since GRANTs
-      # and such get a little dicey for testing (local vs travis, etc.)
-      it "matches the generated trigger with a '%' grant" do
-        conn.instance_variable_get(:@config)[:host] = "somehost" # wheeeee!
-        implicit_definer = "'root'@'somehost'"
-        show_triggers_definer = "root@%"
-
-        builder = trigger.on(:users).before(:insert){ "UPDATE foos SET bar = 1" }
-        triggers = builder.generate.select{|t|t !~ /\ADROP/}
-        expect(conn).to receive(:implicit_mysql_definer).and_return(implicit_definer)
-        expect(conn).to receive(:select_rows).with("SHOW TRIGGERS").and_return([
-          ['users_before_insert_row_tr', 'INSERT', 'users', "BEGIN\n    UPDATE foos SET bar = 1;\nEND", 'BEFORE', 'NULL', 'STRICT_ALL_TABLES', show_triggers_definer]
-        ])
-
-        expect(db_triggers).to eq(triggers)
-      end
-
-      it "quotes table names" do
-        conn.execute <<-SQL
-          CREATE TRIGGER foos_tr AFTER DELETE ON users
-          FOR EACH ROW
-          BEGIN
-            UPDATE user_groups SET bob_count = bob_count - 1;
-          END
-        SQL
-
-        expect(conn.triggers["foos_tr"]).to match(/CREATE TRIGGER foos_tr AFTER DELETE ON `users`/)
-      end
-    end
-
-    context "mysql" do
-      let(:adapter) { :mysql }
-      it_behaves_like "mysql"
-    end if ADAPTERS.include? :mysql
-
-    context "mysql2" do
-      let(:adapter) { :mysql2 }
-      it_behaves_like "mysql"
-    end if ADAPTERS.include? :mysql2
-
-    context "postgresql" do
-      let(:adapter) { :postgresql }
-
-      it "quotes table names" do
-        conn.execute <<-SQL
-          CREATE FUNCTION foos_tr()
-          RETURNS TRIGGER AS $$
-          BEGIN
-            UPDATE user_groups SET bob_count = bob_count - 1;
-          END;
-          $$ LANGUAGE plpgsql;
-
-          CREATE TRIGGER foos_tr AFTER DELETE ON users
-          FOR EACH ROW EXECUTE PROCEDURE foos_tr();
-        SQL
-
-        expect(conn.triggers["foos_tr"]).to match(/CREATE TRIGGER foos_tr AFTER DELETE ON "users"/)
-      end
-    end
-
-    context "sqlite3" do
-      let(:adapter) { :sqlite3 }
-
-      it "quotes table names" do
-        conn.execute <<-SQL
-          CREATE TRIGGER foos_tr AFTER DELETE ON users
-          FOR EACH ROW
-          BEGIN
-            UPDATE user_groups SET bob_count = bob_count - 1;
-          END;
-        SQL
-
-        expect(conn.triggers["foos_tr"]).to match(/CREATE TRIGGER foos_tr AFTER DELETE ON "users"/)
-      end
-    end
-  end
-end

data/spec/builder_spec.rb

@@ -1,433 +0,0 @@
-require 'spec_helper'
-
-HairTrigger::Builder.show_warnings = false
-
-class MockAdapter
-  attr_reader :adapter_name
-  def initialize(type, methods = {})
-    @adapter_name = type
-    methods.each do |key, value|
-      instance_eval("def #{key}; #{value.inspect}; end")
-    end
-  end
-
-  def quote_table_name(table)
-    table
-  end
-end
-
-def builder(name = nil)
-  HairTrigger::Builder.new(name, :adapter => @adapter)
-end
-
-describe "builder" do
-  context "chaining" do
-    it "should use the last redundant chained call" do
-      @adapter = MockAdapter.new("mysql")
-      builder.where(:foo).where(:bar).options[:where].should be(:bar)
-    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")
-      builder.on(:foos).after(:update){ "FOO" }.
-        should eql(builder.on(:foos).after(:update){ "FOO" })
-    end
-
-    it "should view incompatible triggers as different" do
-      @adapter = MockAdapter.new("mysql")
-      HairTrigger::Builder.new(nil, :adapter => @adapter, :compatibility => 0).on(:foos).after(:update){ "FOO" }.
-        should_not eql(builder.on(:foos).after(:update){ "FOO" })
-    end
-  end
-
-  describe "name" do
-    it "should be inferred if none is provided" do
-      builder.on(:foos).after(:update){ "foo" }.prepared_name.
-        should == "foos_after_update_row_tr"
-    end
-
-    it "should respect the last chained name" do
-      builder("lolwut").on(:foos).after(:update){ "foo" }.prepared_name.
-        should == "lolwut"
-      builder("lolwut").on(:foos).name("zomg").after(:update).name("yolo"){ "foo" }.prepared_name.
-        should == "yolo"
-    end
-  end
-
-  describe "`of' columns" do
-    it "should be disallowed for non-update triggers" do
-      lambda {
-        builder.on(:foos).after(:insert).of(:bar, :baz){ "BAR" }
-      }.should raise_error /of may only be specified on update triggers/
-    end
-  end
-
-  describe "groups" do
-    it "should allow chained methods" do
-      triggers = builder.on(:foos){ |t|
-        t.where('bar=1').name('bar'){ 'BAR;' }
-        t.where('baz=1').name('baz'){ 'BAZ;' }
-      }.triggers
-      triggers.map(&:prepare!)
-      triggers.map(&:prepared_name).should == ['bar', 'baz']
-      triggers.map(&:prepared_where).should == ['bar=1', 'baz=1']
-      triggers.map(&:prepared_actions).should == ['BAR;', 'BAZ;']
-    end
-  end
-
-  context "adapter-specific actions" do
-    before(:each) do
-      @adapter = MockAdapter.new("mysql")
-    end
-
-    it "should generate the appropriate trigger for the adapter" do
-      sql = builder.on(:foos).after(:update).where('BAR'){
-        {:default => "DEFAULT", :mysql => "MYSQL"}
-      }.generate
-
-      sql.grep(/DEFAULT/).size.should eql(0)
-      sql.grep(/MYSQL/).size.should eql(1)
-
-      sql = builder.on(:foos).after(:update).where('BAR'){
-        {:default => "DEFAULT", :postgres => "POSTGRES"}
-      }.generate
-
-      sql.grep(/POSTGRES/).size.should eql(0)
-      sql.grep(/DEFAULT/).size.should eql(1)
-    end
-
-    it "should complain if no actions are provided for this adapter" do
-      lambda {
-        builder.on(:foos).after(:update).where('BAR'){ {:postgres => "POSTGRES"} }.generate
-      }.should raise_error
-    end
-  end
-
-  context "mysql" do
-    before(:each) do
-      @adapter = MockAdapter.new("mysql")
-    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' }
-          }
-        }.generate
-      }.should raise_error
-    end
-
-    it "should warn on explicit subtrigger names and no group name" do
-      trigger = builder.on(:foos){ |t|
-        t.where('bar=1').name('bar'){ 'BAR;' }
-        t.where('baz=1').name('baz'){ 'BAZ;' }
-      }
-      trigger.warnings.size.should == 1
-      trigger.warnings.first.first.should =~ /nested triggers have explicit names/
-    end
-
-    it "should accept security" do
-      builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate.
-        grep(/DEFINER/).size.should eql(0) # default, so we don't include it
-      builder.on(:foos).after(:update).security("CURRENT_USER"){ "FOO" }.generate.
-        grep(/DEFINER = CURRENT_USER/).size.should eql(1)
-      builder.on(:foos).after(:update).security("'user'@'host'"){ "FOO" }.generate.
-        grep(/DEFINER = 'user'@'host'/).size.should eql(1)
-    end
-
-    it "should infer `if' conditionals from `of' columns" do
-      builder.on(:foos).after(:update).of(:bar){ "BAZ" }.generate.join("\n").
-        should include("IF NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL) THEN")
-    end
-
-    it "should merge `where` and `of` into an `if` conditional" do
-      builder.on(:foos).after(:update).of(:bar).where("lol"){ "BAZ" }.generate.join("\n").
-        should include("IF (lol) AND (NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL)) THEN")
-    end
-
-    it "should reject :invoker security" do
-      lambda {
-        builder.on(:foos).after(:update).security(:invoker){ "FOO" }.generate
-      }.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
-      }.should raise_error
-    end
-
-    it "should reject truncate" do
-      lambda {
-        builder.on(:foos).after(:truncate){ "FOO" }.generate
-      }.should raise_error
-    end
-
-    describe "#to_ruby" do
-      it "should fully represent the builder" do
-        code = <<-CODE.strip.gsub(/^ +/, '')
-          on("foos").
-          security(:definer).
-          for_each(:row).
-          before(:update) do |t|
-            t.where("NEW.foo") do
-              "FOO;"
-            end
-          end
-        CODE
-        b = builder
-        b.instance_eval(code)
-        b.to_ruby.strip.gsub(/^ +/, '').should be_include(code)
-      end
-    end
-  end
-
-  context "postgresql" do
-    before(:each) do
-      @adapter = MockAdapter.new("postgresql", :postgresql_version => 94000)
-    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 warn on an explicit group names and no subtrigger names" do
-      trigger = builder.on(:foos).name('foos'){ |t|
-        t.where('bar=1'){ 'BAR;' }
-        t.where('baz=1'){ 'BAZ;' }
-      }
-      trigger.warnings.size.should == 1
-      trigger.warnings.first.first.should =~ /trigger group has an explicit name/
-    end
-
-    it "should accept `of' columns" do
-      trigger = builder.on(:foos).after(:update).of(:bar, :baz){ "BAR" }
-      trigger.generate.grep(/AFTER UPDATE OF bar, baz/).size.should eql(1)
-    end
-
-    it "should accept security" do
-      builder.on(:foos).after(:update).security(:invoker){ "FOO" }.generate.
-        grep(/SECURITY/).size.should eql(0) # default, so we don't include it
-      builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate.
-        grep(/SECURITY DEFINER/).size.should eql(1)
-    end
-
-    it "should reject arbitrary user security" do
-      lambda {
-        builder.on(:foos).after(:update).security("'user'@'host'"){ "FOO" }.
-        generate
-      }.should raise_error
-    end
-
-    it "should accept multiple events" 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" }.generate
-      }.should raise_error
-    end
-
-    it "should allow truncate with for_each statement" do
-      builder.on(:foos).after(:truncate).for_each(:statement){ "FOO" }.generate.
-        grep(/TRUNCATE.*FOR EACH STATEMENT/m).size.should eql(1)
-    end
-
-    it "should reject truncate with for_each row" do
-      lambda {
-        builder.on(:foos).after(:truncate){ "FOO" }.generate
-      }.should raise_error
-    end
-
-    it "should add a return statement if none is provided" do
-      builder.on(:foos).after(:update){ "FOO" }.generate.
-        grep(/RETURN NULL;/).size.should eql(1)
-    end
-
-    it "should not wrap the action in a function" do
-      builder.on(:foos).after(:update).nowrap{ 'existing_procedure()' }.generate.
-        grep(/CREATE FUNCTION/).size.should eql(0)
-    end
-
-    it "should reject combined use of security and nowrap" do
-      lambda {
-        builder.on(:foos).after(:update).security("'user'@'host'").nowrap{ "FOO" }.generate
-      }.should raise_error
-    end
-
-    it "should allow variable declarations" do
-      builder.on(:foos).after(:insert).declare("foo INT"){ "FOO" }.generate.join("\n").
-        should match(/DECLARE\s*foo INT;\s*BEGIN\s*FOO/)
-    end
-
-    context "legacy" do
-      it "should reject truncate pre-8.4" do
-        @adapter = MockAdapter.new("postgresql", :postgresql_version => 80300)
-        lambda {
-          builder.on(:foos).after(:truncate).for_each(:statement){ "FOO" }.generate
-        }.should raise_error
-      end
-
-      it "should use conditionals pre-9.0" do
-        @adapter = MockAdapter.new("postgresql", :postgresql_version => 80400)
-        builder.on(:foos).after(:insert).where("BAR"){ "FOO" }.generate.
-        grep(/IF BAR/).size.should eql(1)
-      end
-
-      it "should reject combined use of where and nowrap pre-9.0" do
-        @adapter = MockAdapter.new("postgresql", :postgresql_version => 80400)
-        lambda {
-          builder.on(:foos).after(:insert).where("BAR").nowrap{ "FOO" }.generate
-        }.should raise_error
-      end
-
-      it "should infer `if' conditionals from `of' columns on pre-9.0" do
-        @adapter = MockAdapter.new("postgresql", :postgresql_version => 80400)
-        builder.on(:foos).after(:update).of(:bar){ "BAZ" }.generate.join("\n").
-          should include("IF NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL) THEN")
-      end
-    end
-
-    describe "#to_ruby" do
-      it "should fully represent the builder" do
-        code = <<-CODE.strip.gsub(/^ +/, '')
-          on("foos").
-          of("bar").
-          security(:invoker).
-          for_each(:row).
-          before(:update) do |t|
-            t.where("NEW.foo").declare("row RECORD") do
-              "FOO;"
-            end
-          end
-        CODE
-        b = builder
-        b.instance_eval(code)
-        b.to_ruby.strip.gsub(/^ +/, '').should be_include(code)
-      end
-    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 warn on an explicit group names and no subtrigger names" do
-      trigger = builder.on(:foos).name('foos'){ |t|
-        t.where('bar=1'){ 'BAR;' }
-        t.where('baz=1'){ 'BAZ;' }
-      }
-      trigger.warnings.size.should == 1
-      trigger.warnings.first.first.should =~ /trigger group has an explicit name/
-    end
-
-    it "should accept `of' columns" do
-      trigger = builder.on(:foos).after(:update).of(:bar, :baz){ "BAR" }
-      trigger.generate.grep(/AFTER UPDATE OF bar, baz/).size.should eql(1)
-    end
-
-    it "should reject security" do
-      lambda {
-        builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate
-      }.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
-      }.should raise_error
-    end
-
-    it "should reject truncate" do
-      lambda {
-        builder.on(:foos).after(:truncate){ "FOO" }.generate
-      }.should raise_error
-    end
-
-    describe "#to_ruby" do
-      it "should fully represent the builder" do
-        code = <<-CODE.strip.gsub(/^ +/, '')
-          on("foos").
-          of("bar").
-          before(:update) do |t|
-            t.where("NEW.foo") do
-              "FOO;"
-            end
-          end
-        CODE
-        b = builder
-        b.instance_eval(code)
-        b.to_ruby.strip.gsub(/^ +/, '').should be_include(code)
-      end
-    end
-  end
-end