schema_plus 0.1.3 → 0.2.0

data/README.rdoc

@@ -45,7 +45,7 @@ With standard rails migrations, you specify indexes separately from the table de
     add_index :parts, :name     # index repeats table and column names and is defined separately
     add_index :parts, :product_code, :unique => true
 
-But with SchemaPlus rather than specify your outside your table definition you can specify your indexes when you define each column:
+But with SchemaPlus you can specify your indexes when you define each column:
 
     # More DRY way...
     create_table :parts do |t|
@@ -103,9 +103,9 @@ the same arguments.
 
 The foreign key behavior can be configured globally (see Config) or per-table (see create_table).
 
-To examine your foreign key constraints, connection.foreign_keys returns a
+To examine your foreign key constraints, <tt>connection.foreign_keys</tt> returns a
 list of foreign key constraints defined for a given table, and
-connection.reverse_foreign_keys returns a list of foreign key constraints
+<tt>connection.reverse_foreign_keys</tt> returns a list of foreign key constraints
 that reference a given table.  See SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.
 
 === Views
@@ -120,6 +120,31 @@ ActiveRecord works with views the same as with ordinary tables.  That is, for th
   class UncommentedPosts < ActiveRecord::Base
   end
 
+=== Schema Dump and Load (schema.rb)
+
+When dumping <tt>schema.rb</tt>, SchemaPlus orders the views and tables in
+the schema dump alphabetically, but subject to the requirement that each
+table or view be defined before those that depend on it.  This allows all
+foreign key constraints to be defined within the scope of the table
+definition. (Unless there are cyclical dependencies, in which case some
+foreign keys constraints must be defined later.)
+
+Also, when dumping <tt>schema.rb</tt>, SchemaPlus dumps explicit foreign key
+definition statements rather than relying on the auto-creation behavior,
+for maximum clarity and for independence from global config.  And
+correspondingly, when loading a schema, i.e. with the context of
+<tt>ActiveRecord::Schema.define</tt>, SchemaPlus ensures that auto creation of
+foreign keys is turned off regardless of the global setting.  But if for
+some reason you are creating your schema.rb file by hand, and would like to
+take advantage of auto-creation of foreign keys, you can re-enable it:
+
+    ActiveRecord::Schema.define do
+        SchemaPlus.config.foreign_keys.auto_create = true
+        SchemaPlus.config.foreign_keys.auto_index = true
+
+        create_table ...etc...
+    end
+
 
 == History
 

data/gemfiles/Gemfile.rails-2.3.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /home/snatcher/projects/schema_plus
   specs:
-    schema_plus (0.1.3)
+    schema_plus (0.2.0)
       rails
       valuable
 

data/gemfiles/Gemfile.rails-3.0.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /home/snatcher/projects/schema_plus
   specs:
-    schema_plus (0.1.3)
+    schema_plus (0.2.0)
       rails
       valuable
 

data/gemfiles/Gemfile.rails-3.1.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /home/snatcher/projects/schema_plus
   specs:
-    schema_plus (0.1.3)
+    schema_plus (0.2.0)
       rails
       valuable
 
@@ -97,7 +97,7 @@ GEM
     sprockets (2.0.0)
       hike (~> 1.2)
       rack (~> 1.0)
-      tilt (!= 1.3.0, ~> 1.1)
+      tilt (~> 1.1, != 1.3.0)
     sqlite3 (1.3.4)
     thor (0.14.6)
     tilt (1.3.3)

data/lib/rails/tasks/database.rake

@@ -0,0 +1,5 @@
+namespace :schema_plus do
+  task :load do
+    SchemaPlus.insert
+  end
+end

data/lib/schema_plus.rb

@@ -2,6 +2,7 @@ require 'valuable'
 
 require 'schema_plus/version'
 require 'schema_plus/active_record/base'
+require 'schema_plus/active_record/column_options_handler'
 require 'schema_plus/active_record/foreign_keys'
 require 'schema_plus/active_record/connection_adapters/table_definition'
 require 'schema_plus/active_record/connection_adapters/schema_statements'

data/lib/schema_plus/active_record/column_options_handler.rb

@@ -0,0 +1,55 @@
+module SchemaPlus::ActiveRecord
+  module ColumnOptionsHandler
+    def schema_plus_handle_column_options(table_name, column_name, column_options, opts = {}) #:nodoc:
+      config = opts[:config] || SchemaPlus.config
+      if references = get_references(table_name, column_name, column_options, config)
+        if index = column_options.fetch(:index, config.foreign_keys.auto_index?)
+          column_index(table_name, column_name, index)
+        end
+        add_foreign_key(table_name, column_name, references.first, references.last,
+                                    column_options.reverse_merge(:on_update => config.foreign_keys.on_update,
+                                                                 :on_delete => config.foreign_keys.on_delete))
+      elsif column_options[:index]
+        column_index(table_name, column_name, column_options[:index])
+      end
+    end
+
+    protected
+
+    # If auto_create is true:
+    #   get_references('comments', 'post_id') # => ['posts', 'id']
+    #
+    # And if <tt>column_name</tt> is parent_id it references to the same table
+    #   get_references('pages', 'parent_id')  # => ['pages', 'id']
+    #
+    # If :references option is given, it is used (whether or not auto_create is true)
+    #   get_references('widgets', 'main_page_id', :references => 'pages')) => ['pages', 'id']
+    #
+    # Also the referenced id column may be specified:
+    #   get_references('addresses', 'member_id', :references => ['users', 'uuid']) => ['users', 'uuid']
+    #
+    def get_references(table_name, column_name, column_options = {}, config = {}) #:nodoc:
+      if column_options.has_key?(:references)
+        references = column_options[:references]
+        references = [references, :id] unless references.nil? || references.is_a?(Array)
+        references
+      elsif config.foreign_keys.auto_create?
+        case column_name.to_s
+        when 'parent_id'
+          [table_name, :id]
+        when /^(.*)_id$/
+          determined_table_name = ActiveRecord::Base.pluralize_table_names ? $1.to_s.pluralize : $1
+          [determined_table_name, :id]
+        end
+      end
+    end
+
+    def column_index(table_name, column_name, options) #:nodoc:
+      options = {} if options == true
+      options = { :unique => true } if options == :unique
+      column_name = [column_name] + Array.wrap(options.delete(:with)).compact
+      add_index(table_name, column_name, options)
+    end
+
+  end
+end

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

@@ -39,7 +39,10 @@ module SchemaPlus
             # compatible with the monkey patches; but the definition only
             # appears once the adapter is loaded.  so wait til now to check
             # if that constant exists, then include the patches
-            ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition) if defined? ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition
+            if mysql2index = ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition rescue nil # rescues NameError
+              monkeypatch = SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition
+              mysql2index.send(:include, monkeypatch) unless mysql2index.include? monkeypatch
+            end
           end
           extend(SchemaPlus::ActiveRecord::ForeignKeys)
         end

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

@@ -61,19 +61,15 @@ module SchemaPlus
         end
 
         # Dumps a definition of foreign key.
-        # Must be invoked inside create_table block.
-        #
-        # It was introduced to satisfy sqlite which requires foreign key definitions
-        # to be declared when creating a table. That approach is fine for MySQL and
-        # PostgreSQL too.
-        def to_dump
-          dump = "  t.foreign_key"
+        def to_dump(opts={})
+          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 << ", :name => #{name.inspect}" if name
+          dump << "\n"
           dump
         end
 

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

@@ -52,6 +52,10 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
   # <tt>_id</tt>.  So the above examples are redundant, unless automatic
   # creation was disabled at initialization in the global Config.
   #
+  # SchemaPlus likewise by default automatically creates foreign key constraints for
+  # columns defined via <tt>t.references</tt>, unless the
+  # <tt>:polymorphic</tt> option is true
+  #
   # Finally, the configuration for foreign keys can be overriden on a per-table
   # basis by passing Config options to Migration::ClassMethods#create_table, such as
   #
@@ -60,6 +64,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
   #      end
   #
   module TableDefinition
+    include SchemaPlus::ActiveRecord::ColumnOptionsHandler
 
     attr_accessor :schema_plus_config #:nodoc:
 
@@ -69,6 +74,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
         attr_accessor :indexes
         alias_method_chain :initialize, :schema_plus
         alias_method_chain :column, :schema_plus
+        alias_method_chain :references, :schema_plus
         alias_method_chain :primary_key, :schema_plus
         alias_method_chain :to_sql, :schema_plus
       end
@@ -84,18 +90,16 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
       column(name, :primary_key, options)
     end
 
+    def references_with_schema_plus(*args)
+      options = args.extract_options!
+      options[:references] = nil if options[:polymorphic]
+      args << options
+      references_without_schema_plus(*args)
+    end
+
     def column_with_schema_plus(name, type, options = {}) #:nodoc:
       column_without_schema_plus(name, type, options)
-      if references = ActiveRecord::Migration.connection.get_references(self.name, name, options, schema_plus_config)
-        if index = options.fetch(:index, fk_use_auto_index?)
-          self.column_index(name, index)
-        end
-        foreign_key(name, references.first, references.last,
-                    options.reverse_merge(:on_update => schema_plus_config.foreign_keys.on_update,
-                                          :on_delete => schema_plus_config.foreign_keys.on_delete))
-      elsif options[:index]
-        self.column_index(name, options[:index])
-      end
+      schema_plus_handle_column_options(self.name, name, options, :config => schema_plus_config)
       self
     end
 
@@ -116,15 +120,16 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
     end
 
     protected
-    def column_index(name, options) #:nodoc:
-      options = {} if options == true
-      options = {:unique => true} if options == :unique
-      name = [name] + Array.wrap(options.delete(:with)).compact
-      self.index(name, options)
+    # The only purpose of that method is to provide a consistent intefrace
+    # for ColumnOptionsHandler. First argument (table name) is ignored.
+    def add_index(_, *args) #:nodoc:
+      index(*args)
     end
 
-    def fk_use_auto_index? #:nodoc:
-      schema_plus_config.foreign_keys.auto_index? && !ActiveRecord::Schema.defining?
+    # The only purpose of that method is to provide a consistent intefrace
+    # for ColumnOptionsHandler. First argument (table name) is ignored.
+    def add_foreign_key(_, *args) #:nodoc:
+      foreign_key(*args)
     end
 
   end

data/lib/schema_plus/active_record/foreign_keys.rb

@@ -1,5 +1,7 @@
 module SchemaPlus::ActiveRecord
   module ForeignKeys
+    include SchemaPlus::ActiveRecord::ColumnOptionsHandler
+
     # Enhances ActiveRecord::ConnectionAdapters::AbstractAdapter#add_column to support indexes and foreign keys, with automatic creation
     #
     # == Indexes
@@ -104,69 +106,17 @@ module SchemaPlus::ActiveRecord
     #
     def add_column(table_name, column_name, type, options = {})
       super
-      handle_column_options(table_name, column_name, options)
+      schema_plus_handle_column_options(table_name, column_name, options)
     end
 
     # Enhances ActiveRecord::Migration#change_column to support indexes and foreign keys same as add_column.
     def change_column(table_name, column_name, type, options = {})
       super
       remove_foreign_key_if_exists(table_name, column_name)
-      handle_column_options(table_name, column_name, options)
-    end
-
-    # Determines referenced table and column.
-    # Used in migrations.  
-    #
-    # If auto_create is true:
-    #   get_references('comments', 'post_id') # => ['posts', 'id']
-    #
-    # And if <tt>column_name</tt> is parent_id it references to the same table
-    #   get_references('pages', 'parent_id')  # => ['pages', 'id']
-    #
-    # If :references option is given, it is used (whether or not auto_create is true)
-    #   get_references('widgets', 'main_page_id', :references => 'pages')) 
-    #   # => ['pages', 'id']
-    #
-    # Also the referenced id column may be specified:
-    #   get_references('addresses', 'member_id', :references => ['users', 'uuid'])
-    #   # => ['users', 'uuid']
-    def get_references(table_name, column_name, options = {}, config=nil) #:nodoc:
-      column_name = column_name.to_s
-      if options.has_key?(:references)
-        references = options[:references]
-        references = [references, :id] unless references.nil? || references.is_a?(Array)
-        references
-      elsif (config || SchemaPlus.config).foreign_keys.auto_create? && !ActiveRecord::Schema.defining?
-        if column_name == 'parent_id'
-          [table_name, :id]
-        elsif column_name =~ /^(.*)_id$/
-          determined_table_name = ActiveRecord::Base.pluralize_table_names ? $1.to_s.pluralize : $1
-          [determined_table_name, :id]
-        end
-      end
+      schema_plus_handle_column_options(table_name, column_name, options)
     end
 
     protected
-    def handle_column_options(table_name, column_name, options) #:nodoc:
-      if references = get_references(table_name, column_name, options)
-        if index = options.fetch(:index, SchemaPlus.config.foreign_keys.auto_index? && !ActiveRecord::Schema.defining?)
-          column_index(table_name, column_name, index)
-        end
-        add_foreign_key(table_name, column_name, references.first, references.last,
-                        options.reverse_merge(:on_update => SchemaPlus.config.foreign_keys.on_update,
-                                              :on_delete => SchemaPlus.config.foreign_keys.on_delete))
-      elsif options[:index]
-        column_index(table_name, column_name, options[:index])
-      end
-    end
-
-    def column_index(table_name, column_name, options) #:nodoc:
-      options = {} if options == true
-      options = { :unique => true } if options == :unique
-      column_name = [column_name] + Array.wrap(options.delete(:with)).compact
-      add_index(table_name, column_name, options)
-    end
-
     def remove_foreign_key_if_exists(table_name, column_name) #:nodoc:
       foreign_keys = ActiveRecord::Base.connection.foreign_keys(table_name.to_s)
       fk = foreign_keys.detect { |fk| fk.table_name == table_name.to_s && fk.column_names == Array(column_name).collect(&:to_s) }

data/lib/schema_plus/active_record/schema.rb

@@ -8,18 +8,19 @@ module SchemaPlus
       module ClassMethods
         def self.extended(base)
           class << base
-            attr_accessor :defining
-            alias :defining? :defining
-
             alias_method_chain :define, :schema_plus
           end
         end
 
         def define_with_schema_plus(info={}, &block)
-          self.defining = true
-          define_without_schema_plus(info, &block)
-        ensure
-          self.defining = false
+          fk_override = { :auto_create => false, :auto_index => false }
+          save = Hash[fk_override.keys.collect{|key| [key, SchemaPlus.config.foreign_keys.send(key)]}]
+          begin
+            SchemaPlus.config.foreign_keys.update_attributes(fk_override)
+            define_without_schema_plus(info, &block)
+          ensure
+            SchemaPlus.config.foreign_keys.update_attributes(save)
+          end
         end
       end
     end

data/lib/schema_plus/active_record/schema_dumper.rb

@@ -31,24 +31,60 @@ module SchemaPlus
 
       private
 
+      def break_fk_cycles #:nodoc:
+        strongly_connected_components.select{|component| component.size > 1}.each do |tables|
+          table = tables.sort.first
+          backref_fks = @inline_fks[table].select{|fk| tables.include?(fk.references_table_name)}
+          @inline_fks[table] -= backref_fks
+          @dump_dependencies[table] -= backref_fks.collect(&:references_table_name)
+          backref_fks.each do |fk|
+            @backref_fks[fk.references_table_name] << fk
+          end
+        end
+      end
+
       def tables_with_schema_plus(stream) #:nodoc:
         @table_dumps = {}
-        @re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(#{(@connection.tables + @connection.views).join('|')})\b}
-        begin
-          tables_without_schema_plus(nil)
+        @inline_fks = Hash.new{ |h, k| h[k] = [] }
+        @backref_fks = Hash.new{ |h, k| h[k] = [] }
+        @dump_dependencies = {}
 
-          @connection.views.each do |view_name|
-            definition = @connection.view_definition(view_name)
-            @table_dumps[view_name] = "  create_view #{view_name.inspect}, #{definition.inspect}\n"
-          end
+        tables_without_schema_plus(nil)
 
-          tsort().each do |table|
-            stream.print @table_dumps[table]
+        @connection.views.each do |view_name|
+          definition = @connection.view_definition(view_name)
+          @table_dumps[view_name] = "  create_view #{view_name.inspect}, #{definition.inspect}\n"
+        end
+
+        re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(#{(@table_dumps.keys).join('|')})\b}
+        @table_dumps.keys.each do |table|
+          if @connection.views.include?(table)
+            dependencies = @connection.view_definition(table).scan(re_view_referent).flatten
+          else
+            @inline_fks[table] = @connection.foreign_keys(table)
+            dependencies = @inline_fks[table].collect(&:references_table_name)
           end
+          @dump_dependencies[table] = dependencies.sort.uniq - ::ActiveRecord::SchemaDumper.ignore_tables
+        end
 
-        ensure
-          @table_dumps = nil
+        # Normally we dump foreign key constraints inline in the table
+        # definitions, both for visual cleanliness and because sqlite3
+        # doesn't allow foreign key constraints to be added afterwards.
+        # But in case there's a cycle in the constraint references, some
+        # constraints will need to be broken out then added later.  (Adding
+        # constraints later won't work with sqlite3, but that means sqlite3
+        # won't let you create cycles in the first place.)
+        break_fk_cycles while strongly_connected_components.any?{|component| component.size > 1}
+
+        tsort().each do |table|
+          table_dump = @table_dumps[table]
+          if i = (table_dump =~ /^\s*[e]nd\s*$/)
+            table_dump.insert i, dump_indexes(table) + dump_foreign_keys(@inline_fks[table], :inline => true)
+          end
+          stream.print table_dump
+          stream.puts dump_foreign_keys(@backref_fks[table], :inline => false)+"\n" if @backref_fks[table].any?
         end
+
       end
 
       def tsort_each_node(&block) #:nodoc:
@@ -56,30 +92,13 @@ module SchemaPlus
       end
 
       def tsort_each_child(table, &block) #:nodoc:
-        references = if @connection.views.include?(table)
-                       @connection.view_definition(table).scan(@re_view_referent).flatten
-                     else
-                       @connection.foreign_keys(table).collect(&:references_table_name)
-                     end
-        references.sort.uniq.each(&block)
+        @dump_dependencies[table].each(&block)
       end
 
       def table_with_schema_plus(table, ignore) #:nodoc:
-
         stream = StringIO.new
         table_without_schema_plus(table, stream)
-        stream.rewind
-        table_dump = stream.read
-
-        if i = (table_dump =~ /^\s*[e]nd\s*$/)
-          stream = StringIO.new
-          dump_indexes(table, stream)
-          dump_foreign_keys(table, stream)
-          stream.rewind
-          table_dump.insert i, stream.read
-        end
-
-        @table_dumps[table] = table_dump
+        @table_dumps[table] = stream.string
       end
 
       def indexes_with_schema_plus(table, stream) #:nodoc:
@@ -87,36 +106,29 @@ module SchemaPlus
         # dumping the tables
       end
 
-      def dump_indexes(table, stream) #:nodoc:
-        indexes = @connection.indexes(table)
-        indexes.each do |index|
-          stream.print "    t.index"
+      def dump_indexes(table) #:nodoc:
+        @connection.indexes(table).collect{ |index|
+          dump = "    t.index"
           unless index.columns.blank? 
-            stream.print " #{index.columns.inspect}, :name => #{index.name.inspect}"
-            stream.print ", :unique => true" if index.unique
-            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
-            stream.print ", :case_sensitive => false" unless index.case_sensitive?
-            stream.print ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
+            dump << " #{index.columns.inspect}, :name => #{index.name.inspect}"
+            dump << ", :unique => true" if index.unique
+            dump << ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            dump << ", :case_sensitive => false" unless index.case_sensitive?
+            dump << ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
             index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
-            stream.print ", :length => #{Hash[*index.columns.zip(index.lengths).flatten].inspect}" if index_lengths.present?
+            dump << ", :length => #{Hash[*index.columns.zip(index.lengths).flatten].inspect}" if index_lengths.present?
           else
-            stream.print " :name => #{index.name.inspect}"
-            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
-            stream.print ", :expression => #{index.expression.inspect}"
+            dump << " :name => #{index.name.inspect}"
+            dump << ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            dump << ", :expression => #{index.expression.inspect}"
           end
-
-          stream.puts
-        end
+          dump << "\n"
+        }.join
       end
 
-      def dump_foreign_keys(table, stream) #:nodoc:
-        foreign_keys = @connection.foreign_keys(table)
-        foreign_keys.each do |foreign_key|
-          stream.print "  "
-          stream.puts foreign_key.to_dump
-        end
+      def dump_foreign_keys(foreign_keys, opts={}) #:nodoc:
+        foreign_keys.collect{ |foreign_key| "  " + foreign_key.to_dump(:inline => opts[:inline]) }.join
       end
-
     end
   end
 end

data/lib/schema_plus/railtie.rb

@@ -1,4 +1,4 @@
-module SchemaPlus 
+module SchemaPlus
   class Railtie < Rails::Railtie #:nodoc:
 
     initializer 'schema_plus.insert', :after => "active_record.initialize_database" do
@@ -7,5 +7,12 @@ module SchemaPlus
       end
     end
 
+    rake_tasks do
+      load 'rails/tasks/database.rake'
+      if task = Rake.application.tasks.find { |task| task.name == 'db:schema:dump' }
+        task.enhance(["schema_plus:load"])
+      end
+    end
+
   end
 end

data/lib/schema_plus/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlus
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/runspecs

@@ -8,7 +8,7 @@ RAILS_VERSIONS = %W[2.3 3.0 3.1]
 DB_ADAPTERS = %W[postgresql mysql mysql2 sqlite3]
 
 o = OpenStruct.new
-o.ruby_versions = ["1.9.2"]
+o.ruby_versions = RUBY_VERSIONS
 o.rails_versions = RAILS_VERSIONS
 o.db_adapters = DB_ADAPTERS - ["mysql"]
 
@@ -71,7 +71,7 @@ o.ruby_versions.each do |ruby|
         puts "\n\n*** ruby version #{ruby} - rails version #{rails} - db adapters: #{o.db_adapters.join(' ')}  [#{n} of #{total}]\n\n"
         gemfile = File.join(GEMFILES_DIR, "Gemfile.rails-#{rails}")
         n += 1
-        command = %Q{BUNDLE_GEMFILE="#{gemfile}" rvm #{ruby} exec #{cmd}}
+        command = %Q{BUNDLE_GEMFILE="#{gemfile}" rvm #{ruby} do #{cmd}}
         puts command
         next if o.dry_run
         system(command) or errs << "ruby #{ruby}, rails #{rails}"

data/schema_plus.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "schema_plus"
   s.version     = SchemaPlus::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.authors     = ["Ronen Barzel", "Michal Lomnicki"]
   s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
   s.homepage    = "https://github.com/lomba/schema_plus"
   s.summary     = "Enhances ActiveRecord schema mechanism, including more DRY index creation and support for foreign key constraints and views."

data/spec/connection_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Connection" do
+
+  it "should re-open without failure" do
+    expect {
+      ActiveRecord::Base.establish_connection "schema_plus"
+    }.should_not raise_error
+  end
+end

data/spec/migration_spec.rb

@@ -38,6 +38,11 @@ describe ActiveRecord::Migration do
       @model.should_not reference(:users, :id).on(:user_id)
     end
 
+    it "should not create foreign key using t.references with :polymorphic => true" do
+      create_table(@model,  :user => {:METHOD => :references, :polymorphic => true})
+      @model.should_not reference(:users, :id).on(:user_id)
+    end
+
     it "should create foreign key to the same table on parent_id" do
       create_table(@model,  :parent_id => {})
       @model.should reference(@model.table_name, :id).on(:parent_id)

data/spec/schema_dumper_spec.rb

@@ -1,48 +1,94 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'stringio'
 
-require 'models/post'
-
-describe "Schema dump (core)" do
+describe "Schema dump" do
 
   before(:all) do
-    load_core_schema
+    SchemaPlus.setup do |config|
+      config.foreign_keys.auto_create = false
+    end
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Schema.define do
+        connection.tables.each do |table| drop_table table end
+
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.datetime :deleted_at
+          t.integer :first_post_id
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :first_comment_id
+        end
+
+        create_table :comments, :force => true do |t|
+          t.text :body
+          t.integer :post_id
+          t.integer :commenter_id
+        end
+      end
+    end
+    class ::User < ActiveRecord::Base ; end
+    class ::Post < ActiveRecord::Base ; end
+    class ::Comment < ActiveRecord::Base ; end
   end
 
-  let(:dump) do
+  let(:dump_posts) do
     stream = StringIO.new
     ActiveRecord::SchemaDumper.ignore_tables = %w[users comments]
     ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
     stream.string
   end
 
+  let(:dump_all) do
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = []
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  end
+
   it "should include foreign_key definition" do
     with_foreign_key Post, :user_id, :users, :id do
-      dump.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"]}))
+      dump_posts.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"]}))
+    end
+  end
+
+  context "with constraint dependencies" do
+    it "should sort in Posts => Comments direction" do
+      with_foreign_key Comment, :post_id, :posts, :id do
+        dump_all.should match(%r{create_table "posts".*create_table "comments"}m)
+      end
+    end
+    it "should sort in Comments => Posts direction" do
+      with_foreign_key Post, :first_comment_id, :comments, :id do
+        dump_all.should match(%r{create_table "comments".*create_table "posts"}m)
+      end
     end
   end
 
   it "should include foreign_key options" do
     with_foreign_key Post, :user_id, :users, :id, :on_update => :cascade, :on_delete => :set_null do
-      dump.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"], :on_update => :cascade, :on_delete => :set_null}))
+      dump_posts.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"], :on_update => :cascade, :on_delete => :set_null}))
     end
   end
 
   it "should include index definition" do
     with_index Post, :user_id do
-      dump.should match(to_regexp(%q{t.index ["user_id"]}))
+      dump_posts.should match(to_regexp(%q{t.index ["user_id"]}))
     end
   end
 
   it "should include index name" do
     with_index Post, :user_id, :name => "posts_user_id_index" do
-      dump.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index"}))
+      dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index"}))
     end
   end
   
   it "should define unique index" do
     with_index Post, :user_id, :name => "posts_user_id_index", :unique => true do
-      dump.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :unique => true}))
+      dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :unique => true}))
     end
   end
 
@@ -50,30 +96,54 @@ describe "Schema dump (core)" do
 
     it "should define case insensitive index" do
       with_index Post, :name => "posts_user_body_index", :expression => "USING btree (LOWER(body))" do
-        dump.should match(to_regexp(%q{t.index ["body"], :name => "posts_user_body_index", :case_sensitive => false}))
+        dump_posts.should match(to_regexp(%q{t.index ["body"], :name => "posts_user_body_index", :case_sensitive => false}))
       end
     end
 
     it "should define conditions" do
       with_index Post, :user_id, :name => "posts_user_id_index", :conditions => "user_id IS NOT NULL" do
-        dump.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :conditions => "(user_id IS NOT NULL)"}))
+        dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :conditions => "(user_id IS NOT NULL)"}))
       end
     end
 
     it "should define expression" do
       with_index Post, :name => "posts_freaky_index", :expression => "USING hash (least(id, user_id))" do
-        dump.should match(to_regexp(%q{t.index :name => "posts_freaky_index", :kind => "hash", :expression => "LEAST(id, user_id)"}))
+        dump_posts.should match(to_regexp(%q{t.index :name => "posts_freaky_index", :kind => "hash", :expression => "LEAST(id, user_id)"}))
       end
     end
 
     it "should define kind" do
       with_index Post, :name => "posts_body_index", :expression => "USING hash (body)" do
-        dump.should match(to_regexp(%q{t.index ["body"], :name => "posts_body_index", :kind => "hash"}))
+        dump_posts.should match(to_regexp(%q{t.index ["body"], :name => "posts_body_index", :kind => "hash"}))
       end
     end
 
   end
 
+  unless SchemaPlusHelpers.sqlite3?
+    context "with cyclic foreign key constraints" do
+      before (:all) do
+        ActiveRecord::Base.connection.add_foreign_key(Comment.table_name, :commenter_id, User.table_name, :id)
+        ActiveRecord::Base.connection.add_foreign_key(Comment.table_name, :post_id, Post.table_name, :id)
+        ActiveRecord::Base.connection.add_foreign_key(Post.table_name, :first_comment_id, Comment.table_name, :id)
+        ActiveRecord::Base.connection.add_foreign_key(Post.table_name, :user_id, User.table_name, :id)
+        ActiveRecord::Base.connection.add_foreign_key(User.table_name, :first_post_id, Post.table_name, :id)
+      end
+
+      it "should not raise an error" do
+        expect { dump_all }.should_not raise_error
+      end
+
+      it "should dump constraints after the tables they reference" do
+        dump_all.should match(%r{create_table "comments".*foreign_key.*\["first_comment_id"\], "comments", \["id"\]}m)
+        dump_all.should match(%r{create_table "posts".*foreign_key.*\["first_post_id"\], "posts", \["id"\]}m)
+        dump_all.should match(%r{create_table "posts".*foreign_key.*\["post_id"\], "posts", \["id"\]}m)
+        dump_all.should match(%r{create_table "users".*foreign_key.*\["commenter_id"\], "users", \["id"\]}m)
+        dump_all.should match(%r{create_table "users".*foreign_key.*\["user_id"\], "users", \["id"\]}m)
+      end
+    end
+  end
+
   protected
   def to_regexp(string)
     Regexp.new(Regexp.escape(string))
@@ -130,38 +200,3 @@ describe "Schema dump (core)" do
   end
 
 end
-
-describe "Schema dump (auto)" do
-  
-  before(:all) do
-    load_auto_schema
-  end
-
-  let(:dump) do
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = []
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
-  end
-
-  unless SchemaPlusHelpers.sqlite3?
-    it "shouldn't include :index option for index" do
-      add_column(:author_id, :integer, :references => :users, :index => true) do
-        dump.should_not match(/index => true/)
-      end
-    end
-  end
-    
-  protected
-  def add_column(column_name, *args)
-    table = Post.table_name
-    ActiveRecord::Migration.suppress_messages do
-      ActiveRecord::Migration.add_column(table, column_name, *args)
-      Post.reset_column_information
-      yield if block_given?
-      ActiveRecord::Migration.remove_column(table, column_name)
-    end
-  end
-
-end
-

data/spec/views_spec.rb

@@ -98,6 +98,8 @@ describe ActiveRecord do
 
   def define_schema_and_data
     migration.suppress_messages do
+      connection.views.each do |view| connection.drop_view view end
+      connection.tables.each do |table| connection.drop_table table end
 
       schema.define do
 

metadata

@@ -1,126 +1,144 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: schema_plus
-version: !ruby/object:Gem::Version
-  version: 0.1.3
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
-authors:
+authors: 
 - Ronen Barzel
-- Michał Łomnicki
+- Michal Lomnicki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-28 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-10-22 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rails
-  requirement: &69439930 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
   prerelease: false
-  version_requirements: *69439930
-- !ruby/object:Gem::Dependency
-  name: valuable
-  requirement: &69439700 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: valuable
   prerelease: false
-  version_requirements: *69439700
-- !ruby/object:Gem::Dependency
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &69439390 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
         version: 0.8.7
   type: :development
-  prerelease: false
-  version_requirements: *69439390
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &69439120 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  version_requirements: *69439120
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: &69438750 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: pg
   prerelease: false
-  version_requirements: *69438750
-- !ruby/object:Gem::Dependency
-  name: mysql
-  requirement: &69438370 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: mysql
   prerelease: false
-  version_requirements: *69438370
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: &69437940 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
   prerelease: false
-  version_requirements: *69437940
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: &69437700 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: simplecov
   prerelease: false
-  version_requirements: *69437700
-- !ruby/object:Gem::Dependency
-  name: simplecov-gem-adapter
-  requirement: &69437420 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: simplecov-gem-adapter
   prerelease: false
-  version_requirements: *69437420
-description: ! 'SchemaPlus is an ActiveRecord extension that provides enhanced capabilities
-  for schema definition and querying, including: enhanced and more DRY index capabilities,
-  support and automation for foreign key constraints, and support for views.'
-email:
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+description: "SchemaPlus is an ActiveRecord extension that provides enhanced capabilities for schema definition and querying, including: enhanced and more DRY index capabilities, support and automation for foreign key constraints, and support for views."
+email: 
 - ronen@barzel.org
 - michal.lomnicki@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .travis.yml
 - Gemfile
@@ -134,8 +152,10 @@ files:
 - gemfiles/Gemfile.rails-3.1
 - gemfiles/Gemfile.rails-3.1.lock
 - init.rb
+- lib/rails/tasks/database.rake
 - lib/schema_plus.rb
 - lib/schema_plus/active_record/base.rb
+- lib/schema_plus/active_record/column_options_handler.rb
 - lib/schema_plus/active_record/connection_adapters/abstract_adapter.rb
 - lib/schema_plus/active_record/connection_adapters/column.rb
 - lib/schema_plus/active_record/connection_adapters/foreign_key_definition.rb
@@ -153,6 +173,7 @@ files:
 - runspecs
 - schema_plus.gemspec
 - spec/column_spec.rb
+- spec/connection_spec.rb
 - spec/connections/mysql/connection.rb
 - spec/connections/mysql2/connection.rb
 - spec/connections/postgresql/connection.rb
@@ -166,7 +187,6 @@ files:
 - spec/models/post.rb
 - spec/models/user.rb
 - spec/rails3_migration_spec.rb
-- spec/references_spec.rb
 - spec/schema/auto_schema.rb
 - spec/schema/core_schema.rb
 - spec/schema_dumper_spec.rb
@@ -178,29 +198,35 @@ files:
 - spec/support/matchers/reference.rb
 - spec/support/reference.rb
 - spec/views_spec.rb
+has_rdoc: true
 homepage: https://github.com/lomba/schema_plus
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: schema_plus
-rubygems_version: 1.8.10
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Enhances ActiveRecord schema mechanism, including more DRY index creation
-  and support for foreign key constraints and views.
+summary: Enhances ActiveRecord schema mechanism, including more DRY index creation and support for foreign key constraints and views.
 test_files: []
+

data/spec/references_spec.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'get_references method' do
-
-  before(:all) do
-    @target = ActiveRecord::Migration.connection
-    @table_name = 'comments'
-    @column_name = 'post_id'
-    @destination_table = 'posts'
-    @destinantion_column = :id
-  end
-
-  around(:each) do |example|
-    with_auto_create do
-      example.run
-    end
-  end
-
-  it "should accept table name and column name to references" do
-    lambda { @target.get_references(@table_name, @column_name) }.should_not raise_error
-  end
-
-  it "should return an array" do
-    @target.get_references(@table_name, @column_name).should be_an(Array)
-  end
-
-  it "should return nil if auto_create is disabled" do
-    SchemaPlus.config.foreign_keys.auto_create = false
-    @target.get_references(@table_name, @column_name).should be_nil
-  end
-
-  it "should split column name to table name and primary key" do
-    result = @target.get_references(@table_name, @column_name)
-    result[0].should eql @destination_table
-    result[1].should eql @destinantion_column
-  end
-
-  it "should not auto create referencs when configured not to" do
-    with_auto_create(false) do
-      result = @target.get_references(@table_name, @column_name)
-      result.should be_nil
-    end
-  end
-
-  it "should handle parent_id as belonging to the same table" do
-    column_name = 'parent_id'
-    result = @target.get_references(@table_name, column_name)
-    result[0].should eql @table_name
-    result[1].should eql :id
-  end
-
-  it "should accept :references option which overrides default table name" do
-    result = @target.get_references(@table_name, @column_name, :references => 'users')
-    result[0].should eql 'users'
-    result[1].should eql :id
-  end
-
-  it "should accept :references option which overrides default table name and default column name" do
-    result = @target.get_references(@table_name, @column_name, :references => ['users', 'uuid'])
-    result[0].should eql 'users'
-    result[1].should eql 'uuid'
-  end
-
-  protected
-
-  def with_auto_create(value = true)
-    old_value = SchemaPlus.config.foreign_keys.auto_create
-    SchemaPlus.config.foreign_keys.auto_create = value
-    begin
-      yield
-    ensure
-      SchemaPlus.config.foreign_keys.auto_create = old_value
-    end
-  end
-
-end
-