activerecord-postgresql-extensions 0.0.11 → 0.0.12

data/Rakefile

@@ -2,6 +2,9 @@
 # -*- ruby -*-
 
 require 'rubygems'
+
+gem 'rdoc', '~> 3.12'
+
 require 'rubygems/package_task'
 require 'rake/testtask'
 require 'rdoc/task'
@@ -41,7 +44,6 @@ end
 
 desc 'Build docs'
 Rake::RDocTask.new do |t|
-  require 'rdoc'
   t.title = "ActiveRecord PostgreSQL Extensions #{version}"
   t.main = 'README.rdoc'
   t.rdoc_dir = 'doc'

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.0.12

data/activerecord-postgresql-extensions.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "activerecord-postgresql-extensions"
-  s.version = "0.0.11"
+  s.version = "0.0.12"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["J Smith"]
-  s.date = "2011-11-09"
+  s.date = "2012-03-22"
   s.description = "A whole bunch of extensions the ActiveRecord PostgreSQL adapter."
   s.email = "code@zoocasa.com"
   s.extra_rdoc_files = [
@@ -36,6 +36,7 @@ Gem::Specification.new do |s|
     "lib/postgresql_extensions/postgresql_schemas.rb",
     "lib/postgresql_extensions/postgresql_sequences.rb",
     "lib/postgresql_extensions/postgresql_tables.rb",
+    "lib/postgresql_extensions/postgresql_tablespaces.rb",
     "lib/postgresql_extensions/postgresql_text_search.rb",
     "lib/postgresql_extensions/postgresql_triggers.rb",
     "lib/postgresql_extensions/postgresql_types.rb",
@@ -53,12 +54,14 @@ Gem::Specification.new do |s|
     "test/schemas_tests.rb",
     "test/sequences_tests.rb",
     "test/tables_tests.rb",
+    "test/tablespace_tests.rb",
     "test/test_helper.rb",
-    "test/text_search_tests.rb"
+    "test/text_search_tests.rb",
+    "test/trigger_tests.rb"
   ]
   s.homepage = "http://github.com/zoocasa/activerecord-postgresql-extensions"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
+  s.rubygems_version = "1.8.15"
   s.summary = "A whole bunch of extensions the ActiveRecord PostgreSQL adapter."
 
   if s.respond_to? :specification_version then

data/lib/activerecord-postgresql-extensions.rb

@@ -10,6 +10,7 @@ dirname = File.join(File.dirname(__FILE__), 'postgresql_extensions')
   postgresql_adapter_extensions
   postgresql_constraints
   postgresql_tables
+  postgresql_tablespaces
   postgresql_indexes
   postgresql_permissions
   postgresql_schemas

data/lib/postgresql_extensions/postgresql_adapter_extensions.rb

@@ -66,7 +66,7 @@ module ActiveRecord
       #   with_schema :geospatial do
       #     Model.find(:all)
       #   end
-      def with_schema schema
+      def with_schema(schema)
         scoped_schemas << schema
         begin
           yield
@@ -483,17 +483,64 @@ module ActiveRecord
       alias_method_chain :schema_search_path, :csv_fix
 
       def disable_referential_integrity_with_views #:nodoc:
-        if supports_disable_referential_integrity?() then
-          execute((tables - views).collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
+        if supports_disable_referential_integrity? then
+          execute(tables_without_views.collect { |name|
+            "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL"
+          }.join(";"))
         end
         yield
       ensure
-        if supports_disable_referential_integrity?() then
-          execute((tables - views).collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+        if supports_disable_referential_integrity? then
+          execute(tables_without_views.collect { |name|
+            "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL"
+          }.join(";"))
         end
       end
       alias_method_chain :disable_referential_integrity, :views
 
+      # Enable triggers. If no triggers are specified, all triggers will
+      # be enabled.
+      def enable_triggers(table, *triggers)
+        quoted_table_name = quote_table_name(table)
+        triggers = if triggers.present?
+          triggers.collect { |trigger|
+            quote_generic(trigger)
+          }
+        else
+          'ALL'
+        end
+
+        Array(triggers).each do |trigger|
+          execute("ALTER TABLE #{quoted_table_name} ENABLE TRIGGER #{trigger};")
+        end
+      end
+
+      # Disable triggers. If no triggers are specified, all triggers will
+      # be disabled.
+      def disable_triggers(table, *triggers)
+        quoted_table_name = quote_table_name(table)
+        triggers = if triggers.present?
+          triggers.collect { |trigger|
+            quote_generic(trigger)
+          }
+        else
+          'ALL'
+        end
+
+        Array(triggers).each do |trigger|
+          execute("ALTER TABLE #{quoted_table_name} DISABLE TRIGGER #{trigger};")
+        end
+      end
+
+      # Temporarily disable triggers. If no triggers are specified, all
+      # triggers will be disabled.
+      def without_triggers(table, *triggers)
+        disable_triggers(table, *triggers)
+        yield
+      ensure
+        enable_triggers(table, *triggers)
+      end
+
       # Returns an Array of foreign keys for a particular table. The
       # Array itself is an Array of Arrays, where each particular Array
       # contains the table being referenced, the foreign key and the

data/lib/postgresql_extensions/postgresql_constraints.rb

@@ -76,7 +76,7 @@ module ActiveRecord
       private
         DEFERRABLE_TYPES = [ 'true', 'false', 'immediate', 'deferred' ].freeze
         def assert_valid_deferrable_option option
-          if !DEFERRABLE_TYPES.include? option.to_s.downcase
+          if !DEFERRABLE_TYPES.include?(option.to_s.downcase)
             raise ActiveRecord::InvalidDeferrableOption.new(option)
           end unless option.nil?
         end
@@ -553,13 +553,13 @@ module ActiveRecord
         ACTION_TYPES = %w{ no_action restrict cascade set_null set_default }.freeze
 
         def assert_valid_match_type(type) #:nodoc:
-          if !MATCH_TYPES.include? type.to_s
+          if !MATCH_TYPES.include?(type.to_s)
             raise ActiveRecord::InvalidMatchType.new(type)
           end
         end
 
         def assert_valid_action(type) #:nodoc:
-          if !ACTION_TYPES.include? type.to_s
+          if !ACTION_TYPES.include?(type.to_s)
             raise ActiveRecord::InvalidForeignKeyAction.new(type)
           end
         end

data/lib/postgresql_extensions/postgresql_extensions.rb

@@ -221,7 +221,7 @@ module ActiveRecord
         end
 
         def assert_valid_action(option) #:nodoc:
-          if !ACTIONS.include? option.to_s.downcase
+          if !ACTIONS.include?(option.to_s.downcase)
             raise ArgumentError.new("Excepted :add or :drop for PostgreSQLExtensionAlterer action.")
           end unless option.nil?
         end

data/lib/postgresql_extensions/postgresql_functions.rb

@@ -194,19 +194,19 @@ module ActiveRecord
         SECURITIES = %w{ invoker definer }.freeze
 
         def assert_valid_behavior(option) #:nodoc:
-          if !BEHAVIORS.include? option.to_s.downcase
+          if !BEHAVIORS.include?(option.to_s.downcase)
             raise ActiveRecord::InvalidFunctionBehavior.new(option)
           end unless option.nil?
         end
 
         def assert_valid_on_null_input(option) #:nodoc:
-          if !ON_NULL_INPUTS.include? option.to_s.downcase
+          if !ON_NULL_INPUTS.include?(option.to_s.downcase)
             raise ActiveRecord::InvalidFunctionOnNullInputValue.new(option)
           end unless option.nil?
         end
 
         def assert_valid_security(option) #:nodoc:
-          if !SECURITIES.include? option.to_s.downcase
+          if !SECURITIES.include?(option.to_s.downcase)
             raise ActiveRecord::InvalidFunctionSecurityValue.new(option)
           end unless option.nil?
         end

data/lib/postgresql_extensions/postgresql_languages.rb

@@ -31,7 +31,7 @@ module ActiveRecord
       # You don't often see people using the <tt>:handler</tt> and
       # <tt>:validator</tt> options, and they're really just kind of
       # here for the sake of completeness.
-      def create_language language, options = {}
+      def create_language(language, options = {})
         sql = 'CREATE '
         sql << 'TRUSTED ' if options[:trusted]
         sql << "PROCEDURAL LANGUAGE #{quote_language(language)}"
@@ -46,7 +46,7 @@ module ActiveRecord
       #
       # * <tt>:if_exists</tt> - adds IF EXISTS.
       # * <tt>:cascade</tt> - adds CASCADE.
-      def drop_language language, options = {}
+      def drop_language(language, options = {})
         sql = 'DROP PROCEDURAL LANGUAGE '
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << quote_language(language)
@@ -55,13 +55,13 @@ module ActiveRecord
       end
 
       # Renames a language.
-      def alter_language_name old_language, new_language, options = {}
+      def alter_language_name(old_language, new_language, options = {})
         execute "ALTER PROCEDURAL LANGUAGE #{quote_language(old_language)} RENAME TO #{quote_language(new_language)};"
       end
 
       # Changes a language's owner.
-      def alter_language_owner language, role, options = {}
-        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(language)} OWNER TO #{quote_language(role)};"
+      def alter_language_owner(language, role, options = {})
+        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(language)} OWNER TO #{quote_role(role)};"
       end
 
       # Returns an Array of available languages.

data/lib/postgresql_extensions/postgresql_schemas.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       # * <tt>:authorization</tt> - adds an AUTHORIZATION clause. This is
       #   used to set the owner of the schema. This can be changed with
       #   alter_schema_owner as necessary.
-      def create_schema schema, options = {}
+      def create_schema(schema, options = {})
         sql = "CREATE SCHEMA #{quote_schema(schema)}"
         sql << " AUTHORIZATION #{quote_role(options[:authorization])}" if options[:authorization]
         execute("#{sql};")
@@ -27,7 +27,7 @@ module ActiveRecord
       #
       # * <tt>:if_exists</tt> - adds IF EXISTS.
       # * <tt>:cascade</tt> - adds CASCADE.
-      def drop_schema schemas, options = {}
+      def drop_schema(schemas, options = {})
         sql = 'DROP SCHEMA '
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(schemas).collect { |s| quote_schema(s) }.join(', ')
@@ -36,13 +36,13 @@ module ActiveRecord
       end
 
       # Alter's a schema's name.
-      def alter_schema_name old_schema, new_schema
-        execute "ALTER SCHEMA #{quote_schema(old_schema)} RENAME TO #{quote_schema(new_schema)};"
+      def alter_schema_name(old_schema, new_schema)
+        execute("ALTER SCHEMA #{quote_schema(old_schema)} RENAME TO #{quote_schema(new_schema)};")
       end
 
       # Changes a schema's owner.
-      def alter_schema_owner schema, role
-        execute "ALTER SCHEMA #{quote_schema(schema)} OWNER TO #{quote_role(role)};"
+      def alter_schema_owner(schema, role)
+        execute("ALTER SCHEMA #{quote_schema(schema)} OWNER TO #{quote_role(role)};")
       end
     end
   end

data/lib/postgresql_extensions/postgresql_sequences.rb

@@ -73,12 +73,12 @@ module ActiveRecord
 
       # Renames the sequence.
       def rename_sequence(name, rename, options = {})
-        execute "ALTER SEQUENCE #{quote_sequence(name)} RENAME TO #{quote_generic_ignore_schema(rename)};"
+        execute("ALTER SEQUENCE #{quote_sequence(name)} RENAME TO #{quote_generic_ignore_schema(rename)};")
       end
 
       # Alters the sequence's schema.
       def alter_sequence_schema(name, schema, options = {})
-        execute "ALTER SEQUENCE #{quote_sequence(name)} SET SCHEMA #{quote_schema(schema)};"
+        execute("ALTER SEQUENCE #{quote_sequence(name)} SET SCHEMA #{quote_schema(schema)};")
       end
 
       # Alters any of the various options for a sequence. See
@@ -90,7 +90,7 @@ module ActiveRecord
       # function <tt>setval</tt> with a false value in the third
       # parameter.
       def alter_sequence(name, options = {})
-        execute PostgreSQLSequenceDefinition.new(self, :alter, name, options).to_s
+        execute(PostgreSQLSequenceDefinition.new(self, :alter, name, options).to_s)
       end
 
       # Calls the <tt>setval</tt> function on the sequence.

data/lib/postgresql_extensions/postgresql_tables.rb

@@ -12,7 +12,7 @@ module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
       # Set the schema of a table.
-      def alter_table_schema table_name, schema, options = {}
+      def alter_table_schema(table_name, schema, options = {})
         execute "ALTER TABLE #{quote_schema(table_name)} SET SCHEMA #{quote_schema(schema)};"
       end
 
@@ -46,6 +46,9 @@ module ActiveRecord
       # * <tt>:cascade_drop</tt> - when using the <tt>:force</tt>, this
       #   Jedi mindtrick will pass along the :cascade option to
       #   drop_table.
+      # * <tt>:of_type</tt> - for "OF type_name" clauses.
+      # * <tt>:if_not_exists</tt> - adds the "IF NOT EXISTS" clause.
+      # * <tt>:unlogged</tt> - creates an UNLOGGED table.
       #
       # We're expanding the doors of table definition perception with
       # this exciting new addition to the world of ActiveRecord
@@ -102,7 +105,7 @@ module ActiveRecord
         end
 
         table_definition = PostgreSQLTableDefinition.new(self, table_name, options)
-        yield table_definition
+        yield table_definition if block_given?
 
         execute table_definition.to_s
         unless table_definition.post_processing.blank?
@@ -182,7 +185,12 @@ module ActiveRecord
       def to_sql #:nodoc:
         sql = 'CREATE '
         sql << 'TEMPORARY ' if options[:temporary]
-        sql << "TABLE #{base.quote_table_name(table_name)} (\n  "
+        sql << 'UNLOGGED ' if options[:unlogged]
+        sql << 'TABLE '
+        sql << 'IF NOT EXISTS ' if options[:if_not_exists]
+        sql << "#{base.quote_table_name(table_name)} "
+        sql << "OF #{base.quote_table_name(options[:of_type])} " if options[:of_type]
+        sql << "(\n  "
 
         ary = @columns.collect(&:to_sql)
         ary << @like if @like
@@ -190,10 +198,10 @@ module ActiveRecord
         sql << ary * ",\n  "
         sql << "\n)"
 
-        sql << "INHERITS (" << Array(options[:inherits]).collect { |i| base.quote_table_name(i) }.join(', ') << ')' if options[:inherits]
-        sql << "ON COMMIT #{options[:on_commit].to_s.upcase}" if options[:on_commit]
-        sql << "#{options[:options]}" if options[:options]
-        sql << "TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
+        sql << "\nINHERITS (" << Array(options[:inherits]).collect { |i| base.quote_table_name(i) }.join(', ') << ')' if options[:inherits]
+        sql << "\nON COMMIT #{options[:on_commit].to_s.upcase.gsub(/_/, ' ')}" if options[:on_commit]
+        sql << "\n#{options[:options]}" if options[:options]
+        sql << "\nTABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
         "#{sql};"
       end
       alias :to_s :to_sql
@@ -292,7 +300,7 @@ module ActiveRecord
       alias_method_chain :column, :constraints
 
       private
-        LIKE_TYPES = [ 'defaults', 'constraints', 'indexes' ].freeze
+        LIKE_TYPES = %w{ defaults constraints indexes }.freeze
 
         def assert_valid_like_types(likes) #:nodoc:
           unless likes.blank?

data/lib/postgresql_extensions/postgresql_tablespaces.rb

@@ -0,0 +1,84 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidTablespaceParameter < ActiveRecordError #:nodoc:
+    def initialize(parameter)
+      super("Invalid tablespace parameter - #{parameter}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a new PostgreSQL tablespace.
+      def create_tablespace(name, location, options = {})
+        sql = "CREATE TABLESPACE #{quote_tablespace(name)} "
+        sql << "OWNER #{quote_role(options[:owner])} " if options[:owner]
+        sql << "LOCATION #{quote(location)}"
+
+        execute("#{sql};")
+      end
+
+      # Drops a tablespace.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      def drop_tablespace(name, options = {})
+        sql = 'DROP TABLESPACE '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_tablespace(name)
+
+        execute("#{sql};")
+      end
+
+      #ALTER TABLESPACE name SET ( tablespace_option = value [, ... ] )
+      #ALTER TABLESPACE name RESET ( tablespace_option [, ... ] )
+
+      # Renames a tablespace.
+      def rename_tablespace(old_name, new_name)
+        execute("ALTER TABLESPACE #{quote_tablespace(old_name)} RENAME TO #{quote_tablespace(new_name)};")
+      end
+
+      # Changes a tablespace's owner.
+      def alter_tablespace_owner(tablespace, role)
+        execute("ALTER TABLESPACE #{quote_tablespace(tablespace)} OWNER TO #{quote_role(role)};")
+      end
+
+      def alter_tablespace_parameters(tablespace, parameters_and_values)
+        sql = "ALTER TABLESPACE #{quote_tablespace(tablespace)} SET ("
+
+        sql << parameters_and_values.collect { |k, v|
+          assert_valid_tablespace_parameter(k)
+          "\n  #{quote_generic(k)} = #{v}"
+        }.join(",")
+
+        sql << "\n);"
+
+        execute(sql)
+      end
+
+      def reset_tablespace_parameters(tablespace, *parameters)
+        sql = "ALTER TABLESPACE #{quote_tablespace(tablespace)} RESET ("
+
+        sql << parameters.flatten.collect { |k|
+          assert_valid_tablespace_parameter(k)
+          "\n  #{quote_generic(k)}"
+        }.join(",")
+
+        sql << "\n);"
+
+        execute(sql)
+      end
+
+      private
+        TABLESPACE_PARAMETERS = %w{ seq_page_cost random_page_cost }.freeze
+
+        def assert_valid_tablespace_parameter(parameter)
+          if !TABLESPACE_PARAMETERS.include? parameter.to_s.downcase
+            raise ActiveRecord::InvalidTablespaceParameter.new(option)
+          end
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_triggers.rb

@@ -14,6 +14,30 @@ module ActiveRecord
     end
   end
 
+  class Base
+    class << self
+      # Enable triggers. If no triggers are specified, all triggers will
+      # be enabled.
+      def enable_triggers(*triggers)
+        self.connection.enable_triggers(self.table_name, *triggers)
+      end
+
+      # Disable triggers. If no triggers are specified, all triggers will
+      # be disabled.
+      def disable_triggers(*triggers)
+        self.connection.disable_triggers(self.table_name, *triggers)
+      end
+
+      # Temporarily disable triggers. If no triggers are specified, all
+      # triggers will be disabled.
+      def without_triggers(*triggers)
+        self.connection.without_triggers(self.table_name, *triggers) do
+          yield
+        end
+      end
+    end
+  end
+
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
       # Creates a PostgreSQL trigger.

data/test/adapter_tests.rb

@@ -81,4 +81,64 @@ class AdapterExtensionTests < Test::Unit::TestCase
       'SELECT current_role;'
     ], ARBC.statements)
   end
+
+  def test_enable_triggers
+    ARBC.enable_triggers(:foo)
+    ARBC.enable_triggers(:foo, :bar)
+    ARBC.enable_triggers(:foo, :bar, :baz)
+
+    assert_equal([
+      %{ALTER TABLE "foo" ENABLE TRIGGER ALL;},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
+
+  def test_disable_triggers
+    ARBC.disable_triggers(:foo)
+    ARBC.disable_triggers(:foo, :bar)
+    ARBC.disable_triggers(:foo, :bar, :baz)
+
+    assert_equal([
+      %{ALTER TABLE "foo" DISABLE TRIGGER ALL;},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
+
+  def test_without_triggers
+    begin
+      ARBC.without_triggers(:foo) do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    begin
+      ARBC.without_triggers(:foo, :bar) do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    begin
+      ARBC.without_triggers(:foo, :bar, :baz) do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    assert_equal([
+      %{ALTER TABLE "foo" DISABLE TRIGGER ALL;},
+      %{ALTER TABLE "foo" ENABLE TRIGGER ALL;},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" DISABLE TRIGGER "baz";},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foo" ENABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
 end

data/test/tables_tests.rb

@@ -46,4 +46,79 @@ class TablesTests < Test::Unit::TestCase
   "bar_id" integer DEFAULT '1 + 1'
 );} ], statements)
   end
+
+  def test_like
+    Mig.create_table('foo') do |t|
+      t.like :bar,
+        :including => %w{ constraints indexes},
+        :excluding => %w{ storage comments }
+    end
+
+    assert_equal([
+       %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  LIKE "bar" INCLUDING CONSTRAINTS INCLUDING INDEXES EXCLUDING STORAGE EXCLUDING COMMENTS
+);}
+    ], statements)
+  end
+
+  def test_option_unlogged
+    Mig.create_table('foo', :unlogged => true)
+
+    assert_equal([
+      %{CREATE UNLOGGED TABLE "foo" (\n  "id" serial primary key\n);}
+    ], statements)
+  end
+
+  def test_option_temporary
+    Mig.create_table('foo', :temporary => true)
+
+    assert_equal([
+      %{CREATE TEMPORARY TABLE "foo" (\n  "id" serial primary key\n);}
+    ], statements)
+  end
+
+  def test_option_if_not_exists
+    Mig.create_table('foo', :if_not_exists => true)
+
+    assert_equal([
+      %{CREATE TABLE IF NOT EXISTS "foo" (\n  "id" serial primary key\n);}
+    ], statements)
+  end
+
+  def test_option_on_commit
+    Mig.create_table('foo', :on_commit => :preserve_rows)
+    Mig.create_table('foo', :on_commit => :delete_rows)
+    Mig.create_table('foo', :on_commit => :drop)
+
+    assert_equal([
+      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT PRESERVE ROWS;},
+      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT DELETE ROWS;},
+      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT DROP;}
+    ], statements)
+  end
+
+  def test_option_inherits
+    Mig.create_table('foo', :inherits => 'bar')
+
+    assert_equal([
+      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nINHERITS ("bar");}
+    ], statements)
+  end
+
+  def test_option_tablespace
+    Mig.create_table('foo', :tablespace => 'bar')
+
+    assert_equal([
+      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nTABLESPACE "bar";}
+    ], statements)
+  end
+
+  def test_option_of_type
+    Mig.create_table('foo', :of_type => 'bar')
+
+    assert_equal([
+      %{CREATE TABLE "foo" OF "bar" (\n  "id" serial primary key\n);}
+    ], statements)
+  end
 end

data/test/tablespace_tests.rb

@@ -0,0 +1,63 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class TablespaceTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_create_tablespace
+    Mig.create_tablespace('foo', '/tmp/foo')
+    Mig.create_tablespace('foo', '/tmp/foo', :owner => :bar)
+
+    assert_equal([
+      %{CREATE TABLESPACE "foo" LOCATION '/tmp/foo';},
+      %{CREATE TABLESPACE "foo" OWNER "bar" LOCATION '/tmp/foo';}
+    ], statements)
+  end
+
+  def test_drop_tablespace
+    Mig.drop_tablespace('foo')
+    Mig.drop_tablespace('foo', :if_exists => true)
+
+    assert_equal([
+      %{DROP TABLESPACE "foo";},
+      %{DROP TABLESPACE IF EXISTS "foo";}
+    ], statements)
+  end
+
+  def test_rename_tablespace
+    Mig.rename_tablespace('foo', 'bar')
+
+    assert_equal([
+      %{ALTER TABLESPACE "foo" RENAME TO "bar";}
+    ], statements)
+  end
+
+  def test_alter_tablespace_owner
+    Mig.alter_tablespace_owner('foo', 'bar')
+
+    assert_equal([
+      %{ALTER TABLESPACE "foo" OWNER TO "bar";}
+    ], statements)
+  end
+
+  def test_alter_tablespace_paramters
+    Mig.alter_tablespace_parameters('foo', :seq_page_cost => 2.0, :random_page_cost => 5.0)
+
+    assert_equal([
+      %{ALTER TABLESPACE "foo" SET (
+  "seq_page_cost" = 2.0,
+  "random_page_cost" = 5.0
+);} ], statements)
+  end
+
+  def test_reset_tablespace_paramters
+    Mig.reset_tablespace_parameters('foo', :seq_page_cost, :random_page_cost)
+
+    assert_equal([
+      %{ALTER TABLESPACE "foo" RESET (
+  "seq_page_cost",
+  "random_page_cost"
+);} ], statements)
+  end
+end

data/test/test_helper.rb

@@ -65,3 +65,6 @@ end
 
 class Mig < ActiveRecord::Migration
 end
+
+class Foo < ActiveRecord::Base
+end

data/test/trigger_tests.rb

@@ -0,0 +1,85 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class TriggerTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_enable_triggers
+    Foo.enable_triggers
+    Foo.enable_triggers(:bar)
+    Foo.enable_triggers(:bar, :baz)
+
+    assert_equal([
+      %{ALTER TABLE "foos" ENABLE TRIGGER ALL;},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
+
+  def test_disable_triggers
+    Foo.disable_triggers
+    Foo.disable_triggers(:bar)
+    Foo.disable_triggers(:bar, :baz)
+
+    assert_equal([
+      %{ALTER TABLE "foos" DISABLE TRIGGER ALL;},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
+
+  def test_without_triggers
+    begin
+      Foo.without_triggers do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    begin
+      Foo.without_triggers(:bar) do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    begin
+      Foo.without_triggers(:bar, :baz) do
+        raise "WHAT HAPPEN"
+      end
+    rescue
+    end
+
+    assert_equal([
+      %{ALTER TABLE "foos" DISABLE TRIGGER ALL;},
+      %{ALTER TABLE "foos" ENABLE TRIGGER ALL;},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" DISABLE TRIGGER "baz";},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "bar";},
+      %{ALTER TABLE "foos" ENABLE TRIGGER "baz";}
+    ], ARBC.statements)
+  end
+
+  def test_create_trigger # (name, called, events, table, function, options = {})
+    ARBC.create_trigger(:foo, :before, :update, :bar, 'do_it', :for_each => :row)
+
+    assert_equal([
+      %{CREATE TRIGGER "foo" BEFORE UPDATE ON "bar" FOR EACH ROW EXECUTE PROCEDURE "do_it"();}
+    ], ARBC.statements)
+  end
+
+  def test_drop_trigger # (name, table, options = {})
+    ARBC.drop_trigger(:bar, :foo)
+    ARBC.drop_trigger(:bar, :foo, :if_exists => true, :cascade => true)
+
+    assert_equal([
+      %{DROP TRIGGER "bar" ON "foo";},
+      %{DROP TRIGGER IF EXISTS "bar" ON "foo" CASCADE;}
+    ], ARBC.statements)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgresql-extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-09 00:00:00.000000000 Z
+date: 2012-03-22 00:00:00.000000000 Z
 dependencies: []
 description: A whole bunch of extensions the ActiveRecord PostgreSQL adapter.
 email: code@zoocasa.com
@@ -38,6 +38,7 @@ files:
 - lib/postgresql_extensions/postgresql_schemas.rb
 - lib/postgresql_extensions/postgresql_sequences.rb
 - lib/postgresql_extensions/postgresql_tables.rb
+- lib/postgresql_extensions/postgresql_tablespaces.rb
 - lib/postgresql_extensions/postgresql_text_search.rb
 - lib/postgresql_extensions/postgresql_triggers.rb
 - lib/postgresql_extensions/postgresql_types.rb
@@ -55,8 +56,10 @@ files:
 - test/schemas_tests.rb
 - test/sequences_tests.rb
 - test/tables_tests.rb
+- test/tablespace_tests.rb
 - test/test_helper.rb
 - test/text_search_tests.rb
+- test/trigger_tests.rb
 homepage: http://github.com/zoocasa/activerecord-postgresql-extensions
 licenses: []
 post_install_message: 
@@ -77,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A whole bunch of extensions the ActiveRecord PostgreSQL adapter.