schema_plus 1.0.0 → 1.0.1

data/README.rdoc

@@ -46,48 +46,48 @@ With standard rails migrations, you specify indexes separately from the table de
     end
 
     add_index :parts, :name     # index repeats table and column names and is defined separately
-    add_index :parts, :product_code, :unique => true
+    add_index :parts, :product_code, unique: true
 
 But with SchemaPlus you can specify your indexes when you define each column, with options as desired
 
     # More DRY way...
     create_table :parts do |t|
-      t.string :name,           :index => true
-      t.string :product_code,   :index => { :unique => true }
+      t.string :name,           index: true
+      t.string :product_code,   index: { unique: true }
     end
 
 The options hash can include an index name:
 
-    t.string :product_code,     :index => { :unique => true, :name => "my_index_name" }
+    t.string :product_code,     index: { unique: true, name: "my_index_name" }
 
 You can also create multi-column indexes, for example:
 
     t.string :first_name
-    t.string :last_name,        :index => { :with => :first_name }
+    t.string :last_name,        index: { with: :first_name }
 
     t.string :country_code
     t.string :area_code
-    t.string :local_number      :index => { :with => [:country_code, :area_code], :unique => true }
+    t.string :local_number      index: { with: [:country_code, :area_code], unique: true }
 
 And you can specify index orders:
 
     t.string :first_name
-    t.string :last_name,        :index => { :with => :first_name, :order => {:first_name => :desc, :last_name => :asc}}
+    t.string :last_name,        index: { with: :first_name, order: { first_name: :desc, last_name: :asc}}
 
 As a convenient shorthand, the :unique option can be specified as
 
-    t.string :product_code,   :index => :unique 
+    t.string :product_code,   index: :unique
 
 which is equivalent to
 
-    t.string :product_code,   :index => { :unique => true }
+    t.string :product_code,   index: { unique: true }
 
 If you're using Postgresql, SchemaPlus provides support for conditions, expressions, index methods, and case-insensitive indexes:
 
-    t.string :last_name,  :index => { :conditions => 'deleted_at IS NULL' }
-    t.string :last_name,  :index => { :expression => 'upper(last_name)' }
-    t.string :last_name,  :index => { :kind => 'hash' }
-    t.string :last_name,  :index => { :case_sensitive => false }        # shorthand for :expression => 'lower(last_name)'
+    t.string :last_name,  index: { conditions: 'deleted_at IS NULL' }
+    t.string :last_name,  index: { expression: 'upper(last_name)' }
+    t.string :last_name,  index: { kind: 'hash' }
+    t.string :last_name,  index: { case_sensitive: false }        # shorthand for expression: 'lower(last_name)'
 
 These features are available also in ActiveRecord::Migration.add_index.  See
 doc at SchemaPlus::ActiveRecord::ConnectionAdapters::PostgresqlAdapter and
@@ -128,29 +128,29 @@ Here are some examples:
 
     t.integer :author_id                                 # automatically references table 'authors', key id
     t.integer :parent_id                                 # special name parent_id automatically references its own table (for tree nodes)
-    t.integer :author_id, :foreign_key => true           # same as default automatic behavior
-    t.integer :author,    :foreign_key => true           # non-conventional column name needs to force creation, table name is assumed to be 'authors'
-    t.integer :author_id, :foreign_key => false          # don't create a constraint
-
-    t.integer :author_id, :foreign_key => { :references => :authors }        # same as automatic behavior
-    t.integer :author,    :foreign_key => { :reference => :authors}          # same default name
-    t.integer :author_id, :foreign_key => { :references => [:authors, :id] } # same as automatic behavior
-    t.integer :author_id, :foreign_key => { :references => :people }         # override table name
-    t.integer :author_id, :foreign_key => { :references => [:people, :ssn] } # override table name and key
-    t.integer :author_id, :foreign_key => { :references => nil }             # don't create a constraint
-    t.integer :author_id, :foreign_key => { :name => "my_fk" }               # override default generated constraint name
-    t.integer :author_id, :foreign_key => { :on_delete => :cascade }
-    t.integer :author_id, :foreign_key => { :on_update: => :set_null }
-    t.integer :author_id, :foreign_key => { :deferrable => true }
+    t.integer :author_id, foreign_key: true           # same as default automatic behavior
+    t.integer :author,    foreign_key: true           # non-conventional column name needs to force creation, table name is assumed to be 'authors'
+    t.integer :author_id, foreign_key: false          # don't create a constraint
+
+    t.integer :author_id, foreign_key: { references: :authors }        # same as automatic behavior
+    t.integer :author,    foreign_key: { reference: :authors}          # same default name
+    t.integer :author_id, foreign_key: { references: [:authors, :id] } # same as automatic behavior
+    t.integer :author_id, foreign_key: { references: :people }         # override table name
+    t.integer :author_id, foreign_key: { references: [:people, :ssn] } # override table name and key
+    t.integer :author_id, foreign_key: { references: nil }             # don't create a constraint
+    t.integer :author_id, foreign_key: { name: "my_fk" }               # override default generated constraint name
+    t.integer :author_id, foreign_key: { on_delete: :cascade }
+    t.integer :author_id, foreign_key: { on_update: :set_null }
+    t.integer :author_id, foreign_key: { deferrable: true }
 
 Of course the options can be combined, e.g.
 
-    t.integer :author_id, :foreign_key => { :name => "my_fk", :on_delete => :no_action }
+    t.integer :author_id, foreign_key: { name: "my_fk", on_delete: :no_action }
 
 As a shorthand, all options except +:name+ can be specified without placing them in a hash, e.g.
 
-    t.integer :author_id, :on_delete => :cascade
-    t.integer :author_id, :references => nil
+    t.integer :author_id, on_delete: :cascade
+    t.integer :author_id, references: nil
 
 The foreign key behavior can be configured globally (see Config) or per-table (see create_table).
 
@@ -163,7 +163,7 @@ that reference a given table.  See SchemaPlus::ActiveRecord::ConnectionAdapters:
 
 SchemaPlus provides support for creating and dropping views.  In a migration, a view can be created using a rails relation or literal sql:
 
-  create_view :posts_commented_by_staff,  Post.joins(:comment => :user).where(:users => {:role => 'staff'}).uniq
+  create_view :posts_commented_by_staff,  Post.joins(comment: user).where(users: {role: 'staff'}).uniq
   create_view :uncommented_posts,        "SELECT * FROM posts LEFT OUTER JOIN comments ON comments.post_id = posts.id WHERE comments.id IS NULL"
 
 And can be dropped:
@@ -184,19 +184,19 @@ ActiveRecord works with views the same as with ordinary tables.  That is, for th
 
 SchemaPlus allows defaults to be set using expressions or constant values:
 
-  t.datetime :seen_at, :default => { :expr => 'NOW()' }
-  t.datetime :seen_at, :default => { :value => "2011-12-11 00:00:00" }
+  t.datetime :seen_at, default: { expr: 'NOW()' }
+  t.datetime :seen_at, default: { value: "2011-12-11 00:00:00" }
 
 Note that in MySQL only the TIMESTAMP column data type accepts SQL column
 defaults and Rails uses DATETIME, so expressions can't be used with MySQL.
 
 The standard syntax will still work as usual:
 
-  t.datetime :seen_at, :default => "2011-12-11 00:00:00"
+  t.datetime :seen_at, default: "2011-12-11 00:00:00"
 
 Also, as a convenience
 
-  t.datetime :seen_at, :default => :now
+  t.datetime :seen_at, default: :now
 
 resolves to:
 
@@ -208,8 +208,8 @@ resolves to:
 
 SchemaPlus introduces a constant <tt>ActiveRecord::DB_DEFAULT</tt> that you can use to explicitly instruct the database to use the column default value (or expression).  For example:
 
-  Post.create(:category => ActiveRecord::DB_DEFAULT)
-  post.update_attributes(:category => ActiveRecord::DB_DEFAULT)
+  Post.create(category: ActiveRecord::DB_DEFAULT)
+  post.update_attributes(category: ActiveRecord::DB_DEFAULT)
 
 (Without <tt>ActiveRecord::DB_DEFAULT</tt>, you can update a value to <tt>NULL</tt> but not to its default value.) 
 
@@ -246,7 +246,24 @@ take advantage of auto-creation of foreign key constraints, you can re-enable it
 
 == Release notes:
 
-=== master (to be released)
+
+=== 1.0.1
+
+* README cleanups (thanks to https://github.com/denispeplin)
+
+* Now raises ArgumentError if index has both :case_sensitive => false and an :expression
+
+* Now creates consistent default name for foreign key constraints
+
+* Bug fix: respect :length keyword for index (thanks to https://github.com/teleological )
+
+* Bug fix: renaming table with multiple foreign key constraints (thanks to https://github.com/teleological )
+
+* Bug fix: don't dump :case_sensitive => false for index with an expression that includes "lower(name)".
+
+* Bug fix: Properly dump multi-column case-insensitive indexes
+
+=== 1.0.0
 
 * No longer support rails < 3.2 and ruby < 1.9
 
@@ -268,7 +285,7 @@ take advantage of auto-creation of foreign key constraints, you can re-enable it
 
 * Bug fix: when removing a foreign key constraint, remove its auto-generated index.
 
-* Bug fix: SchemaDumper.ignore_tables needs to support regexps (suggeste by https://github.com/mtalcott)
+* Bug fix: SchemaDumper.ignore_tables needs to support regexps (suggested by https://github.com/mtalcott)
 
 * Bug fix: More robust handling of Postgresql schema_search path (suggested by https://github.com/mtalcott)
 
@@ -317,10 +334,11 @@ Then:
   $ ./runspecs --install  # do this once, it runs 'bundle install' for all versions
   $ ./runspecs # as many times as you like
 
-See <tt>./runspecs --help</tt> for more options.  You can also manually pick a specific version of rails, ruby, and db to use, such as:
-  $ rvm use 1.9.2
-  $ export BUNDLE_GEMFILE=gemfiles/rails-3.2/Gemfile.sqlite3
-  $ bundle exec rake spec
+See <tt>./runspecs --help</tt> for more options.  In particular, to run
+rspec on a specific file or example (rather than running the full suite)
+you can do, e.g.
+
+  $ ./runspecs [other options] --rspec -- spec/migration_spec.rb -e 'default name'
 
 Code coverage results will be in coverage/index.html -- it should be at 100% coverage if you're running against all databases
 

data/Rakefile

@@ -12,14 +12,17 @@ task :spec do
     Rake::Task["#{adapter}:spec"].invoke
 end
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  require File.dirname(__FILE__) + '/lib/schema_plus/version'
+# work around a bug in rake 10.0.3 with ruby 1.9.2
+unless RUBY_VERSION == "1.9.2"
+    require 'rdoc/task'
+    Rake::RDocTask.new do |rdoc|
+    require File.dirname(__FILE__) + '/lib/schema_plus/version'
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "schema_plus #{SchemaPlus::VERSION}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = "schema_plus #{SchemaPlus::VERSION}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+    end
 end
 
 require 'rspec/core/rake_task'

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

@@ -69,7 +69,7 @@ module SchemaPlus
         # it's created.  If you're using Sqlite3, this method will raise an
         # error.)
         def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
-          foreign_key = ForeignKeyDefinition.new(options[:name], table_name, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
+          foreign_key = ForeignKeyDefinition.new(options[:name] || ForeignKeyDefinition.default_name(table_name, column_names), table_name, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
           execute "ALTER TABLE #{quote_table_name(table_name)} ADD #{foreign_key.to_sql}"
         end
 
@@ -102,7 +102,7 @@ module SchemaPlus
             rename_index(newname, index.name, index_name(newname, index.columns))
           end
           foreign_keys(newname).each do |fk|
-            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, index.columns)}
+            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, fk.column_names)}
             begin
               remove_foreign_key(newname, fk.name)
             rescue NotImplementedError
@@ -113,7 +113,7 @@ module SchemaPlus
             # if the index is on a foreign key constraint
             rename_index(newname, index.name, ForeignKeyDefinition.auto_index_name(newname, index.columns)) if index
             begin
-              add_foreign_key(newname, fk.column_names, fk.references_table_name, fk.references_column_names, :name => newname, :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
+              add_foreign_key(newname, fk.column_names, fk.references_table_name, fk.references_column_names, :name => fk.name.sub(/#{oldname}/, newname), :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
             rescue NotImplementedError
               # sqlite3 can't add foreign keys, so just skip it
             end

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

@@ -106,6 +106,10 @@ module SchemaPlus
           value.to_s.sub(/^["`](.*)["`]$/, '\1')
         end
 
+        def self.default_name(table_name, column_names)
+          "fk_#{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_')}"
         end

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

@@ -22,7 +22,7 @@ module SchemaPlus
           # same args as add_index(table_name, column_names, options)
           if args.length == 3 and Hash === args.last
             table_name, column_names, options = args + [{}]
-            initialize_without_schema_plus(table_name, options[:name], options[:unique], column_names, options[:lengths], options[:orders])
+            initialize_without_schema_plus(table_name, options[:name], options[:unique], column_names, options[:length], options[:orders])
             @conditions = options[:conditions]
             @expression = options[:expression]
             @kind = options[:kind]
@@ -38,7 +38,7 @@ module SchemaPlus
           opts = {}
           opts[:name]           = name unless name.nil?
           opts[:unique]         = unique unless unique.nil?
-          opts[:lengths]        = lengths unless lengths.nil?
+          opts[:length]         = lengths unless lengths.nil?
           opts[:conditions]     = conditions unless conditions.nil?
           opts[:expression]     = expression unless expression.nil?
           opts[:kind]           = kind unless kind.nil?

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

@@ -33,6 +33,8 @@ module SchemaPlus
           rename_indexes_and_foreign_keys(oldname, newname)
         end
 
+        # used only for mysql not mysql2.  the quoting methods on ActiveRecord::DB_DEFAULT are
+        # sufficient for mysql2
         def exec_stmt_with_schema_plus(sql, name, binds, &block)
           if binds.any?{ |col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
             binds.each_with_index do |(col, val), i|

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

@@ -60,17 +60,21 @@ module SchemaPlus
         # * +:conditions+ - SQL conditions for the WHERE clause of the index
         # * +:expression+ - SQL expression to index.  column_name can be nil or ommitted, in which case :name must be provided
         # * +:kind+ - index method for Postgresql to use
-        # * +:case_sensitive - if +false+ then the index will be created on LOWER(column_name)
+        # * +:case_sensitive - setting to +false+ is a shorthand for :expression => 'LOWER(column_name)'
         #
         # The <tt>:case_sensitive => false</tt> option ties in with Rails built-in support for case-insensitive searching:
         #    validates_uniqueness_of :name, :case_sensitive => false
         #
+        # Since since <tt>:case_sensitive => false</tt> is implemented by
+        # using <tt>:expression</tt>, this raises an ArgumentError if both
+        # are specified simultaneously.
+        #
         def add_index(table_name, column_name, options = {})
           column_name, options = [], column_name if column_name.is_a?(Hash)
           column_names = Array(column_name).compact
           if column_names.empty?
-            raise ArgumentError, "No columns and :expression missing from options - cannot create index" if options[:expression].blank?
-            raise ArgumentError, "Index name not given. Pass :name option" if options[:name].blank?
+            raise ArgumentError, "No columns and :expression missing from options - cannot create index" unless options[:expression]
+            raise ArgumentError, "Index name not given. Pass :name option" unless options[:name]
           end
 
           index_type = options[:unique] ? "UNIQUE" : ""
@@ -79,6 +83,7 @@ module SchemaPlus
           kind       = options[:kind]
 
           if expression = options[:expression] then
+            raise ArgumentError, "Cannot specify :case_sensitive => false with an expression.  Use LOWER(column_name)" if options[:case_sensitive] == false
             # Wrap expression in parentheses if necessary
             expression = "(#{expression})" if expression !~ /(using|with|tablespace|where)/i
             expression = "USING #{kind} #{expression}" if kind
@@ -138,10 +143,16 @@ module SchemaPlus
             SQL
 
             column_names = columns.values_at(*index_keys).compact
-            # extract column name from the expression, for a
-            # case-insensitive 
-            if md = expression.try(:match, /^lower\(\(?([^)]+)\)?(::text)?\)$/i)
-              column_names << md[1]
+            case_sensitive = true
+
+            # extract column names from the expression, for a
+            # case-insensitive index
+            if expression
+              rexp_lower = %r{\blower\(\(?([^)]+)(\)::text)?\)}
+              if expression.match /^(#{rexp_lower}(, )?)+$/
+                column_names = expression.scan(rexp_lower).map(&:first)
+                case_sensitive = false
+              end
             end
             
             # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
@@ -153,7 +164,7 @@ module SchemaPlus
                                                                     :unique => unique,
                                                                     :orders => orders,
                                                                     :conditions => conditions,
-                                                                    :case_sensitive => !(expression =~ /lower/i),
+                                                                    :case_sensitive => case_sensitive,
                                                                     :kind => kind.downcase == "btree" ? nil : kind,
                                                                     :expression => expression)
           end

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

@@ -127,7 +127,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
     end
 
     def foreign_key(column_names, references_table_name, references_column_names, options = {})
-      @foreign_keys << ForeignKeyDefinition.new(options[:name], nil, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
+      @foreign_keys << ForeignKeyDefinition.new(options[:name] || ForeignKeyDefinition.default_name(self.name, column_names), self.name, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
       self
     end
 

data/lib/schema_plus/version.rb

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

data/runspecs

@@ -2,6 +2,7 @@
 
 require 'optparse'
 require 'ostruct'
+require 'shellwords'
 require 'tempfile'
 
 RUBY_VERSIONS = %W[1.9.2 1.9.3]
@@ -52,12 +53,15 @@ OptionParser.new do |opts|
       o.db_adapters = ["postgresql"]
     end
 
+    opts.on("--rspec", "run rspec rather than rake") do |v|
+        o.rspec = v
+    end
+
 end.parse!
 
 
 Combo = Struct.new(:ruby, :rails, :db_adapter)
 
-
 combos = o.ruby_versions.product(o.rails_versions, o.db_adapters).map{|product| Combo.new(*product)}.select {|combo|
     case
     when combo.rails >= "3.2" && combo.ruby <= "1.8.7" then false  # no longer happens, just keeping it as an example
@@ -78,11 +82,13 @@ combos.each_with_index do |combo, n|
               "bundle update"
           when o.install
               "bundle install"
+          when o.rspec
+              "bundle exec rspec -Ispec/connections/#{db_adapter}"
           else
               "bundle exec rake #{db_adapter}:spec"
           end
 
-    command = %Q{BUNDLE_GEMFILE="#{File.join(GEMFILES_DIR, "rails-#{rails}", "Gemfile.#{db_adapter}")}" rvm #{ruby} do #{cmd}}
+    command = %Q{BUNDLE_GEMFILE="#{File.join(GEMFILES_DIR, "rails-#{rails}", "Gemfile.#{db_adapter}")}" rvm #{ruby} do #{cmd} #{Shellwords.join(ARGV)}}
 
     puts "\n\n*** ruby version #{ruby} - rails version #{rails} - db adapter: #{db_adapter}  [#{n+1} of #{combos.size}]\n\n#{command}"
 

data/schema_plus.gemspec

@@ -6,13 +6,13 @@ Gem::Specification.new do |s|
   s.name        = "schema_plus"
   s.version     = SchemaPlus::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = ">= 1.9.2"
   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."
   s.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."
 
-
   s.rubyforge_project = "schema_plus"
 
   s.files         = `git ls-files`.split("\n")

data/spec/foreign_key_spec.rb

@@ -145,7 +145,7 @@ describe "Foreign Key" do
         before(:each) do
           migration.suppress_messages do
             migration.create_table :references, :force => true do |t|
-              t.integer :post_id
+              t.integer :post_id, :foreign_key => false
             end
           end
         end

data/spec/index_spec.rb

@@ -108,13 +108,18 @@ describe "add_index" do
     end
 
     it "should raise if no column given and expression is missing" do
-      expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError)
+      expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError, /expression/)
     end
 
     it "should raise if expression without name is given" do
-      expect { add_index(:users, :expression => "USING btree (login)") }.to raise_error(ArgumentError)
+      expect { add_index(:users, :expression => "USING btree (login)") }.to raise_error(ArgumentError, /name/)
     end
 
+    it "should raise if expression is given and case_sensitive is false" do
+      expect { add_index(:users, :name => 'users_login_index', :expression => "USING btree (login)", :case_sensitive => false) }.to raise_error(ArgumentError, /use LOWER/i)
+    end
+
+
   end # of postgresql specific examples
 
   protected

data/spec/migration_spec.rb

@@ -78,6 +78,13 @@ describe ActiveRecord::Migration do
       @model.should reference(:users, :id).on(:author_id)
     end
 
+    it "should create foreign key with default name" do
+      recreate_table @model do |t|
+        t.integer :user_id, :foreign_key => true
+      end
+      @model.should reference(:users, :id).with_name("fk_#{@model.table_name}_user_id")
+    end
+
     it "should create foreign key with specified name" do
       recreate_table @model do |t|
         t.integer :user_id, :foreign_key => { :name => "wugga" }
@@ -162,6 +169,17 @@ describe ActiveRecord::Migration do
       @model.should have_unique_index.on(:state)
     end
 
+    if SchemaPlusHelpers.mysql?
+      it "should pass index length option properly" do
+        recreate_table(@model) do |t|
+          t.string :foo
+          t.string :bar, :index => { :with => :foo, :length => { :foo => 8, :bar => 12 }}
+        end
+        index = @model.indexes.first
+        Hash[index.columns.zip(index.lengths.map(&:to_i))].should == { "foo" => 8, "bar" => 12}
+      end
+    end
+
     it "should create an index if specified explicitly" do
       recreate_table(@model) do |t|
         t.integer :state
@@ -672,12 +690,44 @@ describe ActiveRecord::Migration do
     end
 
     unless SchemaPlusHelpers.sqlite3?
-      it "should rename foreign key definitions" do
+      it "should rename foreign key constraints" do
         ActiveRecord::Base.connection.foreign_keys(:newname).first.name.should =~ /newname/
       end
     end
 
   end
+
+  unless SchemaPlusHelpers.sqlite3?
+
+    context "when table with more than one fk constraint is renamed" do
+
+      before(:each) do
+        @model = Comment
+        recreate_table @model do |t|
+          t.integer :user_id
+          t.integer :member_id
+        end
+        ActiveRecord::Migration.suppress_messages do
+          ActiveRecord::Migration.rename_table @model.table_name, :newname
+        end
+      end
+
+      around(:each) do |example|
+        begin
+          example.run
+        ensure
+          ActiveRecord::Migration.suppress_messages do
+            ActiveRecord::Migration.rename_table :newname, :comments
+          end
+        end
+      end
+      it "should rename foreign key constraints" do
+        names = ActiveRecord::Base.connection.foreign_keys(:newname).map(&:name)
+        names.grep(/newname/).should == names
+      end
+    end
+
+  end
     
   def recreate_table(model, opts={}, &block)
     ActiveRecord::Migration.suppress_messages do

data/spec/schema_dumper_spec.rb

@@ -163,8 +163,8 @@ describe "Schema dump" do
   if SchemaPlusHelpers.postgresql?
 
     it "should define case insensitive index" do
-      with_index Post, :name => "posts_user_body_index", :expression => "USING btree (LOWER(body))" do
-        dump_posts.should match(to_regexp(%q{t.index ["body"], :name => "posts_user_body_index", :case_sensitive => false}))
+      with_index Post, [:body, :string_no_default], :case_sensitive => false do
+        dump_posts.should match(to_regexp(%q{t.index ["body", "string_no_default"], :name => "index_posts_on_body_and_string_no_default", :case_sensitive => false}))
       end
     end
 
@@ -180,6 +180,13 @@ describe "Schema dump" do
       end
     end
 
+    it "should not define :case_sensitive => false with non-trivial expression" do
+      with_index Post, :name => "posts_user_body_index", :expression => "BTRIM(LOWER(body))" do
+        dump_posts.should match(%r{#{to_regexp(%q{t.index :name => "posts_user_body_index", :expression => "btrim(lower(body))"})}$})
+      end
+    end
+
+
     it "should define kind" do
       with_index Post, :name => "posts_body_index", :expression => "USING hash (body)" do
         dump_posts.should match(to_regexp(%q{t.index ["body"], :name => "posts_body_index", :kind => "hash"}))
@@ -277,7 +284,7 @@ describe "Schema dump" do
   def determine_index_name(model, columns, options)
     name = columns[:name] if columns.is_a?(Hash)
     name ||= options[:name]
-    name ||= model.indexes.detect { |index| index.table == model.table_name.to_s && index.columns == Array(columns).collect(&:to_s) }.name
+    name ||= model.indexes.detect { |index| index.table == model.table_name.to_s && index.columns.sort == Array(columns).collect(&:to_s).sort }.name
     name
   end
 

data/spec/support/matchers/reference.rb

@@ -19,23 +19,24 @@ module SchemaPlusMatchers
       else
         @result = @model.foreign_keys
       end
-      if @column_names 
-        @result.any? do |fk| 
-          fk.column_names == @column_names &&
-            (@on_update ? fk.on_update == @on_update : true) &&
-            (@on_delete ? fk.on_delete == @on_delete : true) &&
-            (@name ? fk.name == @name : true)
-        end
-      else
-        !@result.empty?
-      end
+      @result.keep_if {|fk| fk.column_names == @column_names } if @column_names
+      @result.keep_if {|fk| fk.on_update == @on_update } if @on_update
+      @result.keep_if {|fk| fk.on_delete == @on_delete } if @on_delete
+      @result.keep_if {|fk| fk.name == @name } if @name
+      !@result.empty?
     end
 
     def failure_message_for_should(should_not = false)
       target_column_names = @column_names.present? ? "(#{@column_names.join(', ')})" : "" 
       destinantion_column_names = @references_table_name ? "#{@references_table_name}(#{@references_column_names.join(', ')})" : "anything"
       invert = should_not ? 'not' : ''
-      "Expected #{@model.table_name}#{target_column_names} to #{invert} reference #{destinantion_column_names}"
+      msg = "Expected #{@model.table_name}#{target_column_names} to #{invert} reference #{destinantion_column_names}"
+      with = []
+      with << "on_update=#{@on_update.inspect}" if @on_update
+      with << "on_delete=#{@on_delete.inspect}" if @on_delete
+      with << "name=#{@name.inspect}" if @name
+      msg += " with #{with.join(" and ")}" if with.any?
+      msg
     end
 
     def failure_message_for_should_not

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_plus
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-04 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -173,7 +173,6 @@ files:
 - spec/support/matchers/automatic_foreign_key_matchers.rb
 - spec/support/matchers/have_index.rb
 - spec/support/matchers/reference.rb
-- spec/support/reference.rb
 - spec/views_spec.rb
 homepage: https://github.com/lomba/schema_plus
 licenses: []
@@ -186,13 +185,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1266061864634900724
 requirements: []
 rubyforge_project: schema_plus
 rubygems_version: 1.8.24
@@ -223,6 +225,4 @@ test_files:
 - spec/support/matchers/automatic_foreign_key_matchers.rb
 - spec/support/matchers/have_index.rb
 - spec/support/matchers/reference.rb
-- spec/support/reference.rb
 - spec/views_spec.rb
-has_rdoc: 

data/spec/support/reference.rb

@@ -1,66 +0,0 @@
-module SchemaPlusMatchers
-
-  class Reference
-    def initialize(expected)
-      @column_names = nil
-      unless expected.empty?
-        @references_column_names = Array(expected).collect(&:to_s)
-        @references_table_name = @references_column_names.shift 
-      end
-    end
-
-    def matches?(model)
-      @model = model
-      if @references_table_name
-        @result = @model.foreign_keys.select do |fk|
-          fk.references_table_name == @references_table_name && 
-            @references_column_names.empty? ? true : fk.references_column_names == @references_column_names
-        end
-      else
-        @result = @model.foreign_keys
-      end
-      if @column_names 
-        @result.any? do |fk| 
-          fk.column_names == @column_names &&
-            (@on_update ? fk.on_update == @on_update : true) &&
-            (@on_delete ? fk.on_delete == @on_delete : true)
-        end
-      else
-        !@result.empty?
-      end
-    end
-
-    def failure_message_for_should(should_not = false)
-      target_column_names = @column_names.present? ? "(#{@column_names.join(', ')})" : "" 
-      destinantion_column_names = @references_table_name ? "#{@references_table_name}(#{@references_column_names.join(', ')})" : "anything"
-      invert = should_not ? 'not' : ''
-      "Expected #{@model.table_name}#{target_column_names} to #{invert} reference #{destinantion_column_names}"
-    end
-
-    def failure_message_for_should_not
-      failure_message_for_should(true)
-    end
-  
-    def on(*column_names)
-      @column_names = column_names.collect(&:to_s)
-      self
-    end
-
-    def on_update(action)
-      @on_update = action
-      self
-    end
-
-    def on_delete(action)
-      @on_delete = action
-      self
-    end
-
-  end
-
-  def reference(*expect)
-    Reference.new(expect)
-  end
-
-end
-