schema_plus 1.0.1 → 1.1.0

data/lib/schema_plus/active_record/connection_adapters/column.rb

@@ -51,6 +51,12 @@ module SchemaPlus
             :update
           end
         end
+
+        # The default as_jon includes all instance variables.  but
+        # @connection can't be dumped (it contains circular references)
+        def as_json(options=nil)
+          instance_values.except "connection"
+        end
       end
     end
   end

data/lib/schema_plus/active_record/connection_adapters/foreign_key_definition.rb

@@ -9,6 +9,10 @@ module SchemaPlus
       #   :set_null
       #   :set_default
       #   :no_action
+      #
+      # The deferrable attribute can take on the following values:
+      #   true
+      #   :initially_deferred
       class ForeignKeyDefinition
 
         # The name of the foreign key constraint
@@ -65,9 +69,9 @@ module SchemaPlus
           dump = (opts[:inline] ? "  t.foreign_key" : "add_foreign_key #{table_name.inspect},")
           dump << " [#{Array(column_names).collect{ |name| name.inspect }.join(', ')}]"
           dump << ", #{references_table_name.inspect}, [#{Array(references_column_names).collect{ |name| name.inspect }.join(', ')}]"
-          dump << ", :on_update => :#{on_update}" if on_update
-          dump << ", :on_delete => :#{on_delete}" if on_delete
-          dump << ", :deferrable => #{deferrable}" if deferrable
+          dump << ", :on_update => #{on_update.inspect}" if on_update
+          dump << ", :on_delete => #{on_delete.inspect}" if on_delete
+          dump << ", :deferrable => #{deferrable.inspect}" if deferrable
           dump << ", :name => #{name.inspect}" if name
           dump << "\n"
           dump
@@ -79,6 +83,7 @@ module SchemaPlus
           sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
           sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
           sql << " DEFERRABLE" if deferrable
+          sql << " INITIALLY DEFERRED" if deferrable == :initially_deferred
           sql
         end
 
@@ -107,11 +112,16 @@ module SchemaPlus
         end
 
         def self.default_name(table_name, column_names)
-          "fk_#{table_name}_#{Array.wrap(column_names).join('_and_')}"
+          "fk_#{fixup_schema_name(table_name)}_#{Array.wrap(column_names).join('_and_')}"
         end
 
         def self.auto_index_name(table_name, column_name)
-          "fk__#{table_name}_#{Array.wrap(column_name).join('_and_')}"
+          "fk__#{fixup_schema_name(table_name)}_#{Array.wrap(column_name).join('_and_')}"
+        end
+
+        def self.fixup_schema_name(table_name)
+          # replace . with _
+          table_name.to_s.gsub(/[.]/, '_')
         end
 
       end

data/lib/schema_plus/active_record/connection_adapters/mysql_adapter.rb

@@ -47,6 +47,12 @@ module SchemaPlus
           exec_stmt_without_schema_plus(sql, name, binds, &block)
         end
 
+        # implement cascade by removing foreign keys
+        def drop_table(name, options={})
+          reverse_foreign_keys(name).each{ |foreign_key| remove_foreign_key(foreign_key.table_name, foreign_key.name) } if options[:cascade]
+          super
+        end
+
         def remove_foreign_key(table_name, foreign_key_name, options = {})
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{foreign_key_name}"
         end
@@ -54,6 +60,9 @@ module SchemaPlus
         def foreign_keys(table_name, name = nil)
           results = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
 
+          table_name = table_name.to_s
+          namespace_prefix = table_namespace_prefix(table_name)
+
           foreign_keys = []
 
           results.each do |row|
@@ -62,6 +71,7 @@ module SchemaPlus
                 name = $1
                 column_names = $2
                 references_table_name = $3
+                references_table_name = namespace_prefix + references_table_name if table_namespace_prefix(references_table_name).blank?
                 references_column_names = $4
                 on_update = $8
                 on_delete = $6
@@ -69,7 +79,7 @@ module SchemaPlus
                 on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :restrict
 
                 foreign_keys << ForeignKeyDefinition.new(name,
-                                                         table_name, column_names.gsub('`', '').split(', '),
+                                                         namespace_prefix + table_name, column_names.gsub('`', '').split(', '),
                                                          references_table_name, references_column_names.gsub('`', '').split(', '),
                                                          on_update, on_delete)
               end
@@ -83,17 +93,23 @@ module SchemaPlus
           results = execute(<<-SQL, name)
         SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
           FROM information_schema.key_column_usage
-         WHERE table_schema = SCHEMA()
+         WHERE table_schema = #{table_schema_sql(table_name)}
            AND referenced_table_schema = table_schema
          ORDER BY constraint_name, ordinal_position;
           SQL
           current_foreign_key = nil
           foreign_keys = []
 
+          namespace_prefix = table_namespace_prefix(table_name)
+
           results.each do |row|
-            next unless table_name.casecmp(row[3]) == 0
+            next unless table_name_without_namespace(table_name).casecmp(row[3]) == 0
             if current_foreign_key != row[0]
-              foreign_keys << ForeignKeyDefinition.new(row[0], row[1], [], row[3], [])
+                referenced_table_name = row[1]
+                referenced_table_name = namespace_prefix + referenced_table_name if table_namespace_prefix(referenced_table_name).blank?
+                references_table_name = row[3]
+                references_table_name = namespace_prefix + references_table_name if table_namespace_prefix(references_table_name).blank?
+              foreign_keys << ForeignKeyDefinition.new(row[0], referenced_table_name, [], references_table_name, [])
               current_foreign_key = row[0]
             end
 
@@ -134,6 +150,21 @@ module SchemaPlus
           when :now then 'CURRENT_TIMESTAMP'
           end
         end
+
+        private
+
+        def table_namespace_prefix(table_name)
+          table_name.to_s =~ /(.*[.])/ ? $1 : ""
+        end
+
+        def table_schema_sql(table_name)
+          table_name.to_s =~ /(.*)[.]/ ? "'#{$1}'" : "SCHEMA()"
+        end
+
+        def table_name_without_namespace(table_name)
+          table_name.to_s.sub /.*[.]/, ''
+        end
+
       end
     end
   end

data/lib/schema_plus/active_record/connection_adapters/postgresql_adapter.rb

@@ -53,6 +53,7 @@ module SchemaPlus
             alias_method_chain :rename_table, :schema_plus
             alias_method_chain :exec_cache, :schema_plus
           end
+          ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.send(:include, PostgreSQLColumn) unless ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.include?(PostgreSQLColumn)
         end
 
         # SchemaPlus provides the following extra options for Postgres
@@ -126,8 +127,8 @@ module SchemaPlus
            INNER JOIN pg_am m ON i.relam = m.oid
            WHERE i.relkind = 'i'
              AND d.indisprimary = 'f'
-             AND t.relname = '#{table_name}'
-             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+             AND t.relname = '#{table_name_without_namespace(table_name)}'
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(table_name)} )
           ORDER BY i.relname
           SQL
 
@@ -200,8 +201,8 @@ module SchemaPlus
           FROM pg_class t, pg_constraint f
          WHERE f.conrelid = t.oid
            AND f.contype = 'f'
-           AND t.relname = '#{table_name}'
-           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+           AND t.relname = '#{table_name_without_namespace(table_name)}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(table_name)} )
           SQL
         end
 
@@ -212,17 +213,19 @@ module SchemaPlus
          WHERE f.confrelid = t.oid
            AND f.conrelid = t2.oid
            AND f.contype = 'f'
-           AND t.relname = '#{table_name}'
-           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+           AND t.relname = '#{table_name_without_namespace(table_name)}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(table_name)} )
           SQL
         end
 
         def views(name = nil) #:nodoc:
-          query(<<-SQL, name).map { |row| row[0] }
-        SELECT viewname
-          FROM pg_views
-         WHERE schemaname = ANY (current_schemas(false))
+          sql = <<-SQL
+            SELECT viewname
+              FROM pg_views
+            WHERE schemaname = ANY (current_schemas(false))
           SQL
+          sql += " AND schemaname != 'postgis'" if adapter_name == 'PostGIS'
+          query(sql, name).map { |row| row[0] }
         end
 
         def view_definition(view_name, name = nil) #:nodoc:
@@ -238,11 +241,19 @@ module SchemaPlus
 
         private
 
+        def namespace_sql(table_name)
+          (table_name.to_s =~ /(.*)[.]/) ?  "'#{$1}'" : "ANY (current_schemas(false))"
+        end
+
+        def table_name_without_namespace(table_name)
+          table_name.to_s.sub /.*[.]/, ''
+        end
+
         def load_foreign_keys(sql, name = nil) #:nodoc:
           foreign_keys = []
 
           query(sql, name).each do |row|
-            if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE))?$/
+            if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE)( (INITIALLY DEFERRED|INITIALLY IMMEDIATE))?)?$/
               name = row[0]
               from_table_name = row[2]
               column_names = $1
@@ -251,6 +262,7 @@ module SchemaPlus
               on_update = $5
               on_delete = $7
               deferrable = $9 == "DEFERRABLE"
+              deferrable = :initially_deferred if ($11 == "INITIALLY DEFERRED" )
               on_update = on_update ? on_update.downcase.gsub(' ', '_').to_sym : :no_action
               on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :no_action
 

data/lib/schema_plus/active_record/connection_adapters/schema_statements.rb

@@ -22,6 +22,9 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
       config_options = {}
       options.keys.each { |key| config_options[key] = options.delete(key) if SchemaPlus.config.class.attributes.include? key }
 
+      # override rails' :force to cascade
+      drop_table(table, if_exists: true, cascade: true) if options.delete(:force)
+
       indexes = []
       create_table_without_schema_plus(table, options) do |table_definition|
         table_definition.schema_plus_config = SchemaPlus.config.merge(config_options)

data/lib/schema_plus/active_record/connection_adapters/sqlite3_adapter.rb

@@ -21,6 +21,7 @@ module SchemaPlus
             alias_method_chain :indexes, :schema_plus
             alias_method_chain :rename_table, :schema_plus
           end
+          ::ActiveRecord::ConnectionAdapters::SQLiteColumn.send(:include, SQLiteColumn) unless ::ActiveRecord::ConnectionAdapters::SQLiteColumn.include?(SQLiteColumn)
         end
 
         def indexes_with_schema_plus(table_name, name = nil)
@@ -39,7 +40,6 @@ module SchemaPlus
           rename_indexes_and_foreign_keys(oldname, newname)
         end
 
-
         def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
           raise NotImplementedError, "Sqlite3 does not support altering a table to add foreign key constraints (table #{table_name.inspect} column #{column_names.inspect})"
         end
@@ -48,6 +48,10 @@ module SchemaPlus
           raise NotImplementedError, "Sqlite3 does not support altering a table to remove foreign key constraints (table #{table_name.inspect} constraint #{foreign_key_name.inspect})"
         end
 
+        def drop_table(name, options={})
+          super(name, options.except(:cascade))
+        end
+
         def foreign_keys(table_name, name = nil)
           get_foreign_keys(table_name, name)
         end
@@ -83,22 +87,24 @@ module SchemaPlus
             \s*REFERENCES\s*[`"](.+?)[`"]\s*\((.+?)\)
             (\s+ON\s+UPDATE\s+(.+?))?
             (\s*ON\s+DELETE\s+(.+?))?
+            (\s*DEFERRABLE(\s+INITIALLY\s+DEFERRED)?)?
             \s*[,)]
           ]x
 
           foreign_keys = []
           results.each do |row|
             table_name = row["name"]
-            row["sql"].scan(re).each do |d0, name, column_names, references_table_name, references_column_names, d1, on_update, d2, on_delete|
+            row["sql"].scan(re).each do |d0, name, column_names, references_table_name, references_column_names, d1, on_update, d2, on_delete, deferrable, initially_deferred|
               column_names = column_names.gsub('`', '').split(', ')
 
               references_column_names = references_column_names.gsub('`"', '').split(', ')
               on_update = on_update ? on_update.downcase.gsub(' ', '_').to_sym : :no_action
               on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :no_action
+              deferrable = deferrable ? (initially_deferred ? :initially_deferred : true) : false
               foreign_keys << ForeignKeyDefinition.new(name,
                                                        table_name, column_names,
                                                        references_table_name, references_column_names,
-                                                       on_update, on_delete)
+                                                       on_update, on_delete, deferrable)
             end
           end
 

data/lib/schema_plus/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlus
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/runspecs

@@ -97,7 +97,7 @@ combos.each_with_index do |combo, n|
     Tempfile.open('runspecs') do |file|
         system("(#{command}) 2>&1 | tee #{file.path}")
         file.rewind
-        errs << "ruby #{ruby}, rails #{rails}#{db_adapter && ", db_adapter #{db_adapter}"}" if file.readlines.grep(/^Failed examples/).any?
+        errs << "ruby #{ruby}, rails #{rails}#{db_adapter && ", db_adapter #{db_adapter}"}" if file.readlines.grep(/(^Failed examples)|(rake aborted)/).any?
     end
 end
 puts errs.any? ?  "\n*** #{errs.size} failures:\n\t#{errs.join("\n\t")}" : "\n*** #{combos.size > 1 ? 'all versions' : 'spec'} succeeded ***" unless o.dry_run

data/spec/column_definition_spec.rb

@@ -133,7 +133,7 @@ describe "Column definition" do
       subject { @sql}
 
       it "should give the default as false" do
-        should match /boolean DEFAULT (\'f\'|0)/
+        should =~ /boolean DEFAULT (\'f\'|0)/
       end
     end
 
@@ -145,7 +145,7 @@ describe "Column definition" do
       subject { @sql}
 
       it "should give the default as true" do
-        should match /boolean DEFAULT (\'t\'|1)/
+        should =~ /boolean DEFAULT (\'t\'|1)/
       end
     end
   end

data/spec/column_spec.rb

@@ -8,6 +8,16 @@ describe "Column" do
     
   let(:migration) { ::ActiveRecord::Migration }
 
+  context "JSON serialization" do
+    before(:each) do
+      create_table(User, :login => { :index => true})
+      @login = User.columns.find{|column| column.name == "login"}
+    end
+    it "works properly" do
+      JSON.parse(@login.to_json).should include("name" => "login", "type" => "string")
+    end
+  end
+
   context "regarding indexes" do
 
     context "if not unique" do
@@ -78,7 +88,7 @@ describe "Column" do
       User.columns.find{|column| column.name == "login"}.required_on.should == :save
     end
 
-    it "must have a value on :updae if there's default" do
+    it "must have a value on :update if there's default" do
       create_table(User, :login => { :null => false, :default => "foo" })
       User.columns.find{|column| column.name == "login"}.required_on.should == :update
     end

data/spec/foreign_key_definition_spec.rb

@@ -4,10 +4,20 @@ describe "Foreign Key definition" do
 
   let(:definition) { SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id) }
 
-  it "it is dumped to sql with quoted values" do
+  it "dumps to sql with quoted values" do
     definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})}
   end
 
+  it "dumps to sql with deferrable values" do
+    deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id, nil, nil, true)
+    deferred_definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE}
+  end
+
+  it "dumps to sql with initially deferrable values" do
+    initially_deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id, nil, nil, :initially_deferred)
+    initially_deferred_definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE INITIALLY DEFERRED}
+  end
+
   def quote_table_name(table)
     ActiveRecord::Base.connection.quote_table_name(table)
   end

data/spec/migration_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe ActiveRecord::Migration do
   include SchemaPlusHelpers
 
-  before(:all) do
+  before(:each) do
     define_schema(:auto_create => true) do
 
       create_table :users, :force => true do |t|
@@ -293,14 +293,14 @@ describe ActiveRecord::Migration do
       end
     end
 
-    it "should use default on_update action" do
-      with_fk_config(:on_update => :cascade) do
+    [false, true, :initially_deferred].each do |status|
+      it "should create and detect deferrable #{status.inspect}" do
         recreate_table @model do |t|
-          t.integer :user_id
+          t.integer :user_id,   :on_delete => :cascade, :deferrable => status
         end
-        @model.should reference.on(:user_id).on_update(:cascade)
+        @model.should reference.on(:user_id).deferrable(status)
       end
-    end
+    end unless SchemaPlusHelpers.mysql?
 
     it "should use default on_delete action" do
       with_fk_config(:on_delete => :cascade) do

data/spec/{multiple_schemas_spec.rb → named_schemas_spec.rb}

@@ -121,6 +121,98 @@ describe "with multiple schemas" do
 
   end
 
+  context "foreign key migrations" do
+    before(:each) do
+      define_schema do
+        create_table "items", :force => true do |t|
+        end
+        create_table "schema_plus_test2.groups", :force => true do |t|
+        end
+        create_table "schema_plus_test2.members", :force => true do |t|
+          t.integer :item_id, :foreign_key => true unless SchemaPlusHelpers.mysql?
+          t.integer :group_id, :foreign_key => { references: "schema_plus_test2.groups" }
+        end
+      end
+      class Group < ::ActiveRecord::Base
+        self.table_name = "schema_plus_test2.groups"
+      end
+      class Item < ::ActiveRecord::Base
+        self.table_name = "items"
+      end
+      class Member < ::ActiveRecord::Base
+        self.table_name = "schema_plus_test2.members"
+      end
+    end
+
+    around(:each) do |example|
+      begin
+        example.run
+      ensure
+        connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.members'
+        connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.groups'
+        connection.execute 'DROP TABLE IF EXISTS items'
+      end
+    end
+
+    it "should find foreign keys" do
+      Member.foreign_keys.should_not be_empty
+    end
+
+    it "should find reverse foreign keys" do
+      Group.reverse_foreign_keys.should_not be_empty
+    end
+
+    it "should reference table in same schema" do
+      Member.foreign_keys.map(&:references_table_name).should include "schema_plus_test2.groups"
+    end
+
+    it "should reference table in default schema" do
+      Member.foreign_keys.map(&:references_table_name).should include "items"
+    end unless SchemaPlusHelpers.mysql?
+
+    it "should include the schema in the constraint name" do
+      expected_names = ["fk_schema_plus_test2_members_group_id"]
+      expected_names << "fk_schema_plus_test2_members_item_id" unless SchemaPlusHelpers.mysql?
+      Member.foreign_keys.map(&:name).should =~ expected_names
+    end
+  end
+
+  if SchemaPlusHelpers.postgresql?
+    context "when using PostGIS" do
+      before(:all) do
+        begin
+          connection.execute "CREATE SCHEMA postgis"
+        rescue ActiveRecord::StatementInvalid => e
+          raise unless e.message =~ /already exists/
+        end
+      end
+
+      around (:each) do |example|
+        begin
+          connection.execute "SET search_path to '$user','public','postgis'"
+          example.run
+        ensure
+          connection.execute "SET search_path to '$user','public'"
+        end
+      end
+
+      before(:each) do
+        connection.stub :adapter_name => 'PostGIS'
+      end
+
+      it "should hide views in postgis schema" do
+        begin
+        connection.create_view "postgis.hidden", "select 1", :force => true
+        connection.create_view :myview, "select 2", :force => true
+        connection.views.should == ["myview"]
+        ensure
+          connection.execute 'DROP VIEW postgis.hidden' rescue nil
+          connection.execute 'DROP VIEW myview' rescue nil
+        end
+      end
+    end
+  end
+
 end