schema_plus 0.1.2 → 0.1.3

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

@@ -86,7 +86,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
 
     def column_with_schema_plus(name, type, options = {}) #:nodoc:
       column_without_schema_plus(name, type, options)
-      if references = ActiveRecord::Migration.get_references(self.name, name, options, schema_plus_config)
+      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

data/lib/schema_plus/active_record/foreign_keys.rb

@@ -0,0 +1,177 @@
+module SchemaPlus::ActiveRecord
+  module ForeignKeys
+    # Enhances ActiveRecord::ConnectionAdapters::AbstractAdapter#add_column to support indexes and foreign keys, with automatic creation
+    #
+    # == Indexes
+    #
+    # The <tt>:index</tt> option takes a hash of parameters to pass to ActiveRecord::Migration.add_index.  Thus
+    #
+    #    add_column('books', 'isbn', :string, :index => {:name => "ISBN-index", :unique => true })
+    # 
+    # is equivalent to:
+    #
+    #    add_column('books', 'isbn', :string)
+    #    add_index('books', ['isbn'], :name => "ISBN-index", :unique => true)
+    #
+    #
+    # In order to support multi-column indexes, an special parameter <tt>:with</tt> may be specified, which takes another column name or an array of column names to include in the index.  Thus
+    #
+    #    add_column('contacts', 'phone_number', :string, :index => { :with => [:country_code, :area_code], :unique => true })
+    # 
+    # is equivalent to:
+    #
+    #    add_column('contacts', 'phone_number', :string)
+    #    add_index('contacts', ['phone_number', 'country_code', 'area_code'], :unique => true)
+    #
+    #
+    # Some convenient shorthands are available:
+    #
+    #    add_column('books', 'isbn', :index => true) # adds index with no extra options
+    #    add_column('books', 'isbn', :index => :unique) # adds index with :unique => true
+    #
+    # == Foreign Key Constraints
+    #
+    # The +:references+ option takes the name of a table to reference in
+    # a foreign key constraint.  For example:
+    #
+    #    add_column('widgets', 'color', :integer, :references => 'colors')
+    #
+    # is equivalent to
+    #
+    #    add_column('widgets', 'color', :integer)
+    #    add_foreign_key('widgets', 'color', 'colors', 'id')
+    #
+    # The foreign column name defaults to +id+, but a different column
+    # can be specified using <tt>:references => [table_name,column_name]</tt>
+    #
+    # Additional options +:on_update+ and +:on_delete+ can be spcified,
+    # with values as described at ConnectionAdapters::ForeignKeyDefinition.  For example:
+    #
+    #     add_column('comments', 'post', :integer, :references => 'posts', :on_delete => :cascade)
+    #
+    # Global default values for +:on_update+ and +:on_delete+ can be
+    # specified in SchemaPlus.steup via, e.g., <tt>config.foreign_keys.on_update = :cascade</tt>
+    #
+    # == Automatic Foreign Key Constraints
+    #
+    # SchemaPlus supports the convention of naming foreign key columns
+    # with a suffix of +_id+.   That is, if you define a column suffixed
+    # with +_id+, SchemaPlus assumes an implied :references to a table
+    # whose name is the column name prefix, pluralized.  For example,
+    # these are equivalent:
+    #
+    #     add_column('posts', 'author_id', :integer)
+    #     add_column('posts', 'author_id', :integer, :references => 'authors')
+    #
+    # As a special case, if the column is named 'parent_id', SchemaPlus
+    # assumes it's a self reference, for a record that acts as a node of
+    # a tree.  Thus, these are equivalent:
+    #
+    #     add_column('sections', 'parent_id', :integer)
+    #     add_column('sections', 'parent_id', :integer, :references => 'sections')
+    #      
+    # If the implicit +:references+ value isn't what you want (e.g., the
+    # table name isn't pluralized), you can explicitly specify
+    # +:references+ and it will override the implicit value.
+    #
+    # If you don't want a foreign key constraint to be created, specify
+    # <tt>:references => nil</tt>.
+    # To disable automatic foreign key constraint creation globally, set
+    # <tt>config.foreign_keys.auto_create = false</tt> in
+    # SchemaPlus.steup.
+    #
+    # == Automatic Foreign Key Indexes
+    #
+    # Since efficient use of foreign key constraints requires that the
+    # referencing column be indexed, SchemaPlus will automatically create
+    # an index for the column if it created a foreign key.  Thus
+    #
+    #    add_column('widgets', 'color', :integer, :references => 'colors')
+    #
+    # is equivalent to:
+    #
+    #    add_column('widgets', 'color', :integer, :references => 'colors', :index => true)
+    #
+    # If you want to pass options to the index, you can explcitly pass
+    # index options, such as <tt>:index => :unique</tt>. 
+    #
+    # If you don't want an index to be created, specify
+    # <tt>:index => nil</tt>.
+    # To disable automatic foreign key index creation globally, set
+    # <tt>config.foreign_keys.auto_index = false</tt> in
+    # SchemaPlus.steup.  (*Note*: If you're using MySQL, it will
+    # automatically create an index for foreign keys if you don't.)
+    #
+    def add_column(table_name, column_name, type, options = {})
+      super
+      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
+    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) }
+      remove_foreign_key(table_name, fk.name) if fk
+    end
+
+  end
+end

data/lib/schema_plus/version.rb

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

data/runspecs

@@ -3,26 +3,32 @@
 require 'optparse'
 require 'ostruct'
 
-PROJECT = File.basename(File.expand_path('..', __FILE__))
-
 RUBY_VERSIONS = %W[1.8.7 1.9.2]
 RAILS_VERSIONS = %W[2.3 3.0 3.1]
+DB_ADAPTERS = %W[postgresql mysql mysql2 sqlite3]
 
 o = OpenStruct.new
-o.ruby_versions = RUBY_VERSIONS
+o.ruby_versions = ["1.9.2"]
 o.rails_versions = RAILS_VERSIONS
-o.run_cmd = "rake spec"
+o.db_adapters = DB_ADAPTERS - ["mysql"]
 
 OptionParser.new do |opts|
     opts.banner = "Usage: #{$0} [options]"
 
+    opts.on("-n", "--dry-run", "Do a dry run without executing actions") do |v|
+        o.dry_run = true
+    end
+
+    opts.on("--update", "Update gem dependencies") do |v|
+        o.update = v
+    end
+
     opts.on("--install", "Install gem dependencies") do |v|
         o.install = v
     end
 
-    opts.on("--db adapter", String, "Choose which db adapter to run: postgresql, mysql, mysql2, or sqlite3.  Default is all of them" ) do |adapter|
-        p adapter
-        o.run_cmd = "rake #{adapter}:spec"
+    opts.on("--db adapter", String, "Choose which db adapter(s) to run. Default is: #{o.db_adapters.join(' ')}" ) do |adapter|
+        o.db_adapters = adapter.split
     end
 
     opts.on("--ruby version", String, "Choose which version(s) of ruby to run.  Default is: #{o.ruby_versions.join(' ')}") do |ruby|
@@ -33,29 +39,42 @@ OptionParser.new do |opts|
         o.rails_versions = rails.split(' ')
     end
 
+    opts.on("--full", "run complete matrix of ruby, rails, and db") do
+      o.ruby_versions  = RUBY_VERSIONS
+      o.rails_versions = RAILS_VERSIONS
+      o.db_adapters = DB_ADAPTERS
+    end
+
     opts.on("--quick", "quick run on Postgres, ruby #{RUBY_VERSIONS.last} and rails #{RAILS_VERSIONS.last}") do
       o.ruby_versions  = [RUBY_VERSIONS.last]
       o.rails_versions = [RAILS_VERSIONS.last]
-      o.run_cmd = "rake postgresql:spec"
+      o.db_adapters = ["postgresql"]
     end
 
 end.parse!
 
-cmds = if o.install
-           "bundle install"
-       else
-           "bundle exec #{o.run_cmd}"
-       end
+cmd = case
+      when o.update
+          "bundle update"
+      when o.install
+          "bundle install"
+      else
+          "bundle exec rake #{o.db_adapters.join(":spec ")}:spec"
+      end
 
 n = 1
 GEMFILES_DIR = File.expand_path('../gemfiles', __FILE__)
 total = o.ruby_versions.size * o.rails_versions.size
+errs = []
 o.ruby_versions.each do |ruby|
     o.rails_versions.each do |rails|
-        puts "\n\n*** ruby version #{ruby} - rails version #{rails}  [#{n} of #{total}]\n\n"
+        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 #{cmds}}
-        system(command)
+        command = %Q{BUNDLE_GEMFILE="#{gemfile}" rvm #{ruby} exec #{cmd}}
+        puts command
+        next if o.dry_run
+        system(command) or errs << "ruby #{ruby}, rails #{rails}"
     end
 end
+puts errs.any? ?  "\n*** #{errs.size} failures:\n\t#{errs.join("\n\t")}" : "\n*** #{total > 1 ? 'all versions' : 'spec'} succeeded ***" unless o.dry_run

data/spec/migration_spec.rb

@@ -1,14 +1,6 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe ActiveRecord::Migration do
-
-  it "should respond to get_references" do
-    ActiveRecord::Migration.should respond_to :get_references
-  end
-
-end
-
 describe ActiveRecord::Migration do
   include SchemaPlusHelpers
 
@@ -36,6 +28,16 @@ describe ActiveRecord::Migration do
       @model.should reference(:users, :id).on(:user_id)
     end
 
+    it "should create foreign key using t.references" do
+      create_table(@model,  :user => {:METHOD => :references})
+      @model.should reference(:users, :id).on(:user_id)
+    end
+
+    it "should not create foreign key using t.references with :references => nil" do
+      create_table(@model,  :user => {:METHOD => :references, :references => nil})
+      @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/rails3_migration_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ActiveRecord::Migration do
+  include SchemaPlusHelpers
+
+  before(:all) do
+    load_auto_schema
+  end
+
+  around(:each) do |example|
+    with_fk_config(:auto_create => true, :auto_index => true) { example.run }
+  end
+
+  context "when table is created" do
+
+    before(:each) do
+      @model = Post
+    end
+
+    it "should create foreign keys" do
+      create_table(:user_id => {},
+                   :author_id => { :references => :users },
+                   :member_id => { :references => nil } )
+      @model.should reference(:users, :id).on(:user_id)
+      @model.should reference(:users, :id).on(:author_id)
+      @model.should_not reference.on(:member_id)
+    end
+
+  end
+
+  unless SchemaPlusHelpers.sqlite3?
+
+    context "when column is added" do
+
+      before(:each) do
+        @model = Comment
+      end
+
+      it "should create a foreign key" do
+        add_column(:post_id, :integer) do
+          @model.should reference(:posts, :id).on(:post_id)
+        end
+      end
+
+      it "should create an index" do
+        add_column(:post_id, :integer) do
+          @model.should have_index.on(:post_id)
+        end
+      end
+
+    end
+
+    context "when column is changed" do
+
+      before(:each) do
+        @model = Comment
+      end
+
+      it "should create a foreign key" do
+        change_column :user, :string, :references => [:users, :login]
+        @model.should reference(:users, :login).on(:user)
+        change_column :user, :string, :references => nil
+      end
+
+    end
+
+    context "when column is removed" do
+
+      before(:each) do
+        @model = Comment
+      end
+
+      it "should remove a foreign key" do
+        suppress_messages do
+          target.add_column(@model.table_name, :post_id, :integer)
+          target.remove_column(@model.table_name, :post_id)
+        end
+        @model.should_not reference(:posts)
+      end
+
+      it "should remove an index" do
+        suppress_messages do
+          target.add_column(@model.table_name, :post_id, :integer)
+          target.remove_column(@model.table_name, :post_id)
+        end
+        @model.should_not have_index.on(:post_id)
+      end
+
+    end
+
+  end
+
+  protected
+  def target
+    ActiveRecord::Migration.connection
+  end
+
+  def add_column(column_name, *args)
+    table = @model.table_name
+    suppress_messages do
+      target.add_column(table, column_name, *args)
+      @model.reset_column_information
+      yield if block_given?
+      target.remove_column(table, column_name)
+    end
+  end
+
+  def change_column(column_name, *args)
+    table = @model.table_name
+    suppress_messages do
+      target.change_column(table, column_name, *args)
+      @model.reset_column_information
+    end
+  end
+
+  def create_table(columns_with_options)
+    suppress_messages do
+      target.create_table @model.table_name, :force => true do |t|
+        columns_with_options.each_pair do |column, options|
+          t.send :integer, column, options
+        end
+      end
+      @model.reset_column_information
+    end
+  end
+
+  def with_fk_config(opts, &block)
+    save = Hash[opts.keys.collect{|key| [key, SchemaPlus.config.foreign_keys.send(key)]}]
+    begin
+      SchemaPlus.config.foreign_keys.update_attributes(opts)
+      yield
+    ensure
+      SchemaPlus.config.foreign_keys.update_attributes(save)
+    end
+  end
+
+end