hairtrigger 0.2.8 → 0.2.9

data/README.md

@@ -83,6 +83,11 @@ Required (but may be satisified by `before`/`after`). Possible values are `:befo
 #### events(*events)
 Required (but may be satisified by `before`/`after`). Possible values are `:insert`/`:update`/`:delete`/`:truncate`. MySQL/SQLite only support one action per trigger, and don't support `:truncate`.
 
+#### nowrap(flag = true)
+PostgreSQL specific option to prevent the trigger action from being wrapped in a `CREATE FUNCTION`. This is useful for executing existing triggers/functions directly, but is not compatible with the `security` setting nor can it be used with pre-9.0 PostgreSQL when supplying a `where` condition.
+
+Example: `trigger.after(:update).nowrap { "tsvector_update_trigger(...)" }`
+
 #### all
 Noop, useful for trigger groups (see below).
 

data/lib/hair_trigger/builder.rb

@@ -4,7 +4,7 @@ module HairTrigger
   class Builder
     class DeclarationError < StandardError; end
     class GenerationError < StandardError; end
-  
+
     attr_accessor :options
     attr_reader :triggers # nil unless this is a trigger group
     attr_reader :prepared_actions, :prepared_where # after delayed interpolation
@@ -73,6 +73,10 @@ module HairTrigger
       options[:where] = where
     end
 
+    def nowrap(flag = true)
+      options[:nowrap] = flag
+    end
+
     # noop, just a way you can pass a block within a trigger group
     def all
     end
@@ -146,7 +150,7 @@ module HairTrigger
         METHOD
       end
     end
-    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all
+    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap
 
     def create_grouped_trigger?
       adapter_name == :mysql
@@ -366,36 +370,48 @@ END;
     def generate_trigger_postgresql
       raise GenerationError, "truncate triggers are only supported on postgres 8.4 and greater" if db_version < 80400 && options[:events].include?('TRUNCATE')
       raise GenerationError, "FOR EACH ROW triggers may not be triggered by truncate events" if options[:for_each] == 'ROW' && options[:events].include?('TRUNCATE')
-      security = options[:security] if options[:security] && options[:security] != :invoker
-      sql = <<-SQL
+      raise GenerationError, "security cannot be used in conjunction with nowrap" if options[:nowrap] && options[:security]
+      raise GenerationError, "where can only be used in conjunction with nowrap on postgres 9.0 and greater" if options[:nowrap] && prepared_where && db_version < 90000
+
+      sql = ''
+
+      if options[:nowrap]
+        trigger_action = raw_actions
+      else
+        security = options[:security] if options[:security] && options[:security] != :invoker
+        sql << <<-SQL
 CREATE FUNCTION #{prepared_name}()
 RETURNS TRIGGER AS $$
 BEGIN
-      SQL
-      if prepared_where && db_version < 90000
-        sql << normalize("IF #{prepared_where} THEN", 1)
-        sql << normalize(raw_actions, 2)
-        sql << normalize("END IF;", 1)
-      else
-        sql << normalize(raw_actions, 1)
-      end
-      # if no return is specified at the end, be sure we set a sane one
-      unless raw_actions =~ /return [^;]+;\s*\z/i
-        if options[:timing] == "AFTER" || options[:for_each] == 'STATEMENT'
-          sql << normalize("RETURN NULL;", 1)
-        elsif options[:events].include?('DELETE')
-          sql << normalize("RETURN OLD;", 1)
+        SQL
+        if prepared_where && db_version < 90000
+          sql << normalize("IF #{prepared_where} THEN", 1)
+          sql << normalize(raw_actions, 2)
+          sql << normalize("END IF;", 1)
         else
-          sql << normalize("RETURN NEW;", 1)
+          sql << normalize(raw_actions, 1)
         end
-      end
-      sql << <<-SQL
+        # if no return is specified at the end, be sure we set a sane one
+        unless raw_actions =~ /return [^;]+;\s*\z/i
+          if options[:timing] == "AFTER" || options[:for_each] == 'STATEMENT'
+            sql << normalize("RETURN NULL;", 1)
+          elsif options[:events].include?('DELETE')
+            sql << normalize("RETURN OLD;", 1)
+          else
+            sql << normalize("RETURN NEW;", 1)
+          end
+        end
+        sql << <<-SQL
 END;
 $$ LANGUAGE plpgsql#{security ? " SECURITY #{security.to_s.upcase}" : ""};
-      SQL
+        SQL
+
+        trigger_action = "#{prepared_name}()"
+      end
+
       [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}();
+FOR EACH #{options[:for_each]}#{prepared_where && db_version >= 90000 ? " WHEN (" + prepared_where + ')': ''} EXECUTE PROCEDURE #{trigger_action};
       SQL
     end
 

data/lib/hair_trigger/version.rb

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

data/spec/builder_spec.rb

@@ -100,7 +100,7 @@ describe "builder" do
       }.should raise_error
     end
   end
-  
+
   context "mysql" do
     before(:each) do
       @adapter = MockAdapter.new("mysql")
@@ -242,6 +242,17 @@ describe "builder" do
         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
+
     context "legacy" do
       it "should reject truncate pre-8.4" do
         @adapter = MockAdapter.new("postgresql", :postgresql_version => 80300)
@@ -255,6 +266,13 @@ describe "builder" do
         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
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hairtrigger
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-27 00:00:00.000000000 Z
+date: 2014-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord