mini_record 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44eb9e5c3b23585ea142c23f9b79cc8783a06204
-  data.tar.gz: 78dcc1beff902922d33bfc660b819f22d73b8061
+  metadata.gz: 784a891255be111d6c3d06375ee93264c7692dfe
+  data.tar.gz: 45ffe1d08143af8c90cbe2f3902765b234d99fb8
 SHA512:
-  metadata.gz: 1436a23b6d6fa2327ee7545258f3059b068cc0c85dd9964ff8d8ccc1b634fcd277c5a82d5644c6c9092e433a993e2e681f053f3bd7b70e8426bdc8e8e2ee91bd
-  data.tar.gz: 662eeecaa4f45ff27854ec646e381b71959ac143766731ee585394c3b3f1b110778171878d27f684cc5cf7971332d22ea187fba58eaada58437f02ff55df1274
+  metadata.gz: 1efebe1b000c99b4eaa89ff150a7d782ca2a94db3f03d8fe782fa53656b243dca7ff3c419a9a93e2ef90f9a58ed83835985ad727c1cc995eb7e3d17debca98ce
+  data.tar.gz: 5198ecfa9d0f2169ebfceecffdb625b72b2e274bbf8b06875dab5ed832284a3e630a7a6a59b7084b5ac69c85d41648e2f5af6dc99ea385cea93d49a1af820e25

data/Gemfile

@@ -3,11 +3,18 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in mini_record.gemspec
 gem 'rake'
 gem 'minitest'
+
+# Test database adapters with "rake test DB=mysql2"
 gem 'sqlite3'
-gem 'mysql2'
-gem 'mysql'
 gem 'pg'
-gem 'activerecord', '<= 3.2'
+gem 'mysql'
+gem 'mysql2'
+
+# Uncomment to test older versions, then "bundle update"
+# gem 'activerecord', '<= 3.2'
+# gem 'activerecord', '~> 4.0.0'
+# gem 'activerecord', '~> 4.1.0'
+gem 'activerecord', '>= 4.2.0'
 
 group :test do
   gem 'foreigner', '>= 1.4.2'

data/lib/mini_record/auto_schema.rb

@@ -3,7 +3,7 @@ module MiniRecord
     def self.included(base)
       base.extend(ClassMethods)
     end
-    
+
     module ClassMethods
       def init_table_definition(connection)
         #connection.create_table(table_name) unless connection.table_exists?(table_name)
@@ -23,7 +23,7 @@ module MiniRecord
             "Unsupported number of args for ActiveRecord::ConnectionAdapters::TableDefinition.new()"
         end
       end
-      
+
       def schema_tables
         @@_schema_tables ||= []
       end
@@ -139,7 +139,7 @@ module MiniRecord
       alias :col       :field
 
       def timestamps
-        field :created_at, :updated_at, :as => :datetime, :null => false
+        field :created_at, :updated_at, :as => :datetime
       end
 
       def reset_table_definition!
@@ -178,9 +178,9 @@ module MiniRecord
       end
 
       def clear_tables!(dry_run = false)
-        return unless MiniRecord.configuration.destructive == true 
+        return unless MiniRecord.configuration.destructive == true
         (connection.tables - schema_tables).each do |name|
-          logger.debug "[MiniRecord] Dropping table #{name}"
+          logger.debug "[MiniRecord] Dropping table #{name}" if logger
           unless dry_run
             connection.drop_table(name)
             schema_tables.delete(name)
@@ -196,12 +196,12 @@ module MiniRecord
 
       # Remove foreign keys for indexes with :foreign=>false option
       def remove_foreign_keys(dry_run)
-        return unless MiniRecord.configuration.destructive == true 
+        return unless MiniRecord.configuration.destructive == true
         indexes.each do |name, options|
           if options[:foreign]==false
             foreign_key = foreign_keys.detect { |fk| fk.options[:column] == options[:column].to_s }
             if foreign_key
-              logger.debug "[MiniRecord] Removing Foreign Key #{foreign_key.options[:name]} on table #{table_name}"
+              logger.debug "[MiniRecord] Removing Foreign Key #{foreign_key.options[:name]} on table #{table_name}" if logger
               connection.remove_foreign_key(table_name, :name => foreign_key.options[:name]) unless dry_run
               foreign_keys.delete(foreign_key)
             end
@@ -216,7 +216,7 @@ module MiniRecord
             column = options[:column].to_s
             unless foreign_keys.detect { |fk| fk[:options][:column] == column }
               to_table = reflect_on_all_associations.detect { |a| a.foreign_key.to_s==column }.table_name
-              logger.debug "[MiniRecord] Adding Foreign Key on #{table_name} to #{to_table}"
+              logger.debug "[MiniRecord] Adding Foreign Key on #{table_name} to #{to_table}" if logger
               connection.add_foreign_key(table_name, to_table, options) unless dry_run
               foreign_keys << { :options=> { :column=>column } }
             end
@@ -224,6 +224,51 @@ module MiniRecord
         end
       end
 
+      # Helper to determine if/how a field will change
+      def field_attr_changes(field_name)
+        field    = field_name.to_s
+        changed  = false  # flag
+        new_attr = {}
+
+        # Next, iterate through our extended attributes, looking for any differences
+        # This catches stuff like :null, :precision, etc
+        # Ignore junk attributes that different versions of Rails include
+        [:name, :limit, :precision, :scale, :default, :null].each do |att|
+          value = fields[field][att]
+          value = true if att == :null && value.nil?
+
+          # Skip unspecified limit/precision/scale as DB will set them to defaults,
+          # and on subsequent runs, this will be erroneously detected as a change.
+          next if value.nil? and [:limit, :precision, :scale].include?(att)
+
+          old_value = fields_in_db[field].send(att)
+          # puts "#{field_name}[#{att}] = #{value.inspect} vs #{old_value.inspect}"
+
+          attr_changed = false
+          if att == :default
+            # Rails 4.2 changed behavior to pass DB values directly through, so we must re-map
+            if value.to_s =~ /^(false|f|0)$/i
+              attr_changed = true if old_value.to_s !~ /^(false|f|0)$/i
+            elsif value.to_s =~ /^(true|t|1)$/i
+              attr_changed = true if old_value.to_s !~ /^(true|t|1)$/i
+            elsif value.to_s != old_value.to_s
+              attr_changed = true
+            end
+          elsif value != old_value
+            attr_changed = true
+          end
+
+          if attr_changed
+            logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}##{att} " +
+                         "from #{old_value.inspect} to #{value.inspect}" if logger
+            new_attr[att] = value
+            changed ||= attr_changed
+          end
+        end
+
+        [new_attr, changed]
+      end
+
       # dry-run
       def auto_upgrade_dry
         auto_upgrade!(true)
@@ -240,7 +285,7 @@ module MiniRecord
           # If table doesn't exist, create it
           unless connection.tables.include?(table_name)
             class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
-            logger.debug "[MiniRecord] Creating Table #{table_name}"
+            logger.debug "[MiniRecord] Creating Table #{table_name}" if logger
             unless dry_run
               connection.table_definition = table_definition
               connection.create_table(table_name, *create_table_options)
@@ -274,7 +319,7 @@ module MiniRecord
                 unless connection.tables.include?(table.to_s)
                   foreign_key             = association.options[:foreign_key] || association.foreign_key
                   association_foreign_key = association.options[:association_foreign_key] || association.association_foreign_key
-                  logger.debug "[MiniRecord] Creating Join Table #{table} with keys #{foreign_key} and #{association_foreign_key}"
+                  logger.debug "[MiniRecord] Creating Join Table #{table} with keys #{foreign_key} and #{association_foreign_key}" if logger
                   unless dry_run
                     connection.create_table(table, :id => false) do |t|
                       t.integer foreign_key
@@ -283,7 +328,7 @@ module MiniRecord
                   end
                   index_name = connection.index_name(table, :column => [foreign_key, association_foreign_key])
                   index_name = index_name[0...connection.index_name_length] if index_name.length > connection.index_name_length
-                  logger.debug "[MiniRecord] Creating Join Table Index #{index_name} (#{foreign_key}, #{association_foreign_key}) on #{table}"
+                  logger.debug "[MiniRecord] Creating Join Table Index #{index_name} (#{foreign_key}, #{association_foreign_key}) on #{table}" if logger
                   connection.add_index table, [foreign_key, association_foreign_key], :name => index_name, :unique => true unless dry_run or suppressed_indexes[association.name]
                 end
                 # Add join table to our schema tables
@@ -300,77 +345,48 @@ module MiniRecord
 
           # Group Destructive Actions
           if MiniRecord.configuration.destructive == true and connection.tables.include?(table_name)
-            
+
             # Rename fields
             rename_fields.each do |old_name, new_name|
               old_column = fields_in_db[old_name.to_s]
               new_column = fields_in_db[new_name.to_s]
               if old_column && !new_column
-                logger.debug "[MiniRecord] Renaming column #{table_name}.#{old_column.name} to #{new_name}"
+                logger.debug "[MiniRecord] Renaming column #{table_name}.#{old_column.name} to #{new_name}" if logger
                 connection.rename_column(table_name, old_column.name, new_name) unless dry_run
               end
             end
-            
+
             # Remove fields from db no longer in schema
             columns_to_delete = fields_in_db.keys - fields.keys & fields_in_db.keys
             columns_to_delete.each do |field|
               column = fields_in_db[field]
-              logger.debug "[MiniRecord] Removing column #{table_name}.#{column.name}"
+              logger.debug "[MiniRecord] Removing column #{table_name}.#{column.name}" if logger
               connection.remove_column table_name, column.name unless dry_run
             end
-            
+
             # Change attributes of existent columns
             (fields.keys & fields_in_db.keys).each do |field|
               if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
-                changed  = false  # flag
-                new_attr = {}
-
-                # Special catch for precision/scale, since *both* must be specified together
-                # Always include them in the attr struct, but they'll only get applied if changed = true
-                new_attr[:precision] = fields[field][:precision]
-                new_attr[:scale]     = fields[field][:scale]
-
-                # If we have precision this is also the limit
-                fields[field][:limit] ||= fields[field][:precision]
-
-                # Next, iterate through our extended attributes, looking for any differences
-                # This catches stuff like :null, :precision, etc
-                # Ignore junk attributes that different versions of Rails include
-                [:name, :limit, :precision, :scale, :default, :null].each do |att|
-                  value = fields[field][att]
-                  value = true if att == :null && value.nil?
-
-                  # Skip unspecified limit/precision/scale as DB will set them to defaults,
-                  # and on subsequent runs, this will be erroneously detected as a change.
-                  next if value.nil? and [:limit, :precision, :scale].include?(att)
-
-                  old_value = fields_in_db[field].send(att)
-                  if value != old_value
-                    logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}##{att} " +
-                                 "from #{old_value.inspect} to #{value.inspect}" if logger
-                    new_attr[att] = value
-                    changed = true
-                  end
-                end
+                new_attr, changed = field_attr_changes(field)
 
                 # Change the column if applicable
                 new_type = fields[field].type.to_sym
                 if changed
-                  logger.debug "[MiniRecord] Changing column #{table_name}.#{field} to new type #{new_type}"
+                  logger.debug "[MiniRecord] Changing column #{table_name}.#{field} to new type #{new_type}" if logger
                   connection.change_column table_name, field, new_type, new_attr unless dry_run
                 end
               end
             end
-            
+
             remove_foreign_keys(dry_run) if connection.respond_to?(:foreign_keys)
 
             # Remove old index
             index_names = indexes.collect{ |name, opts| (opts[:name] || name).to_s }
             (indexes_in_db.keys - index_names).each do |name|
-              logger.debug "[MiniRecord] Removing index #{name} on #{table_name}"
+              logger.debug "[MiniRecord] Removing index #{name} on #{table_name}" if logger
               connection.remove_index(table_name, :name => name) unless dry_run
             end
-            
+
           end
 
           if connection.tables.include?(table_name)
@@ -381,7 +397,7 @@ module MiniRecord
               options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
               options[:default] = column.default unless column.default.nil?
               options[:null]    = column.null    unless column.null.nil?
-              logger.debug "[MiniRecord] Adding column #{table_name}.#{column.name}"
+              logger.debug "[MiniRecord] Adding column #{table_name}.#{column.name}" if logger
               connection.add_column table_name, column.name, column.type.to_sym, options unless dry_run
             end
           end
@@ -391,7 +407,7 @@ module MiniRecord
             options = options.dup
             index_name = (options[:name] || name).to_s
             unless connection.indexes(table_name).detect { |i| i.name == index_name }
-              logger.debug "[MiniRecord] Adding index #{index_name} #{options[:column].inspect} on #{table_name}"
+              logger.debug "[MiniRecord] Adding index #{index_name} #{options[:column].inspect} on #{table_name}" if logger
               connection.add_index(table_name, options.delete(:column), options) unless dry_run
             end
           end

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.4.4"
+  VERSION = "0.4.5"
 end

data/test/helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems' unless defined?(Gem)
 require 'bundler/setup'
+require 'logger'
 require 'mini_record'
 require 'minitest/autorun'
 
@@ -39,24 +40,25 @@ class ActiveRecord::Base
 
     def auto_upgrade!(*args)
       ActiveRecord::Base.logs = StringIO.new
-      ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(ActiveRecord::Base.logs)
+      ActiveRecord::Base.logger = Logger.new(ActiveRecord::Base.logs)
       silence_stream(STDERR) { super }
     end
 
     def auto_upgrade_dry
       ActiveRecord::Base.logs = StringIO.new
-      ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(ActiveRecord::Base.logs)
+      ActiveRecord::Base.logger = Logger.new(ActiveRecord::Base.logs)
       silence_stream(STDERR) { super }
     end
   end
 end # ActiveRecord::Base
 
-# Setup Adatper
+# Setup Adapter
+puts "Testing with DB=#{ENV['DB'] || 'sqlite'}"
 case ENV['DB']
 when 'mysql'
-  ActiveRecord::Base.establish_connection(:adapter => 'mysql', :database => 'test', :user => 'root')
+  ActiveRecord::Base.establish_connection(:adapter => 'mysql', :database => 'test', :username => 'root')
 when 'mysql2'
-  ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'test', :user => 'root')
+  ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'test', :username => 'root')
   Bundler.require(:test)  # require 'foreigner'
   Foreigner.load
 when 'pg', 'postgresql'

data/test/test_mini_record.rb

@@ -10,7 +10,7 @@ describe MiniRecord do
       conn.tables.each { |table| silence_stream(STDERR) { conn.execute "DROP TABLE IF EXISTS #{table}" } }
     end
 
-    ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) if Object.const_defined?(klass.to_s) }
+    ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) if Object.const_defined?(klass.name.to_s) }
     ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
   end
 
@@ -141,7 +141,7 @@ describe MiniRecord do
     assert_includes Foo.db_indexes, 'by_customer'
     # Run auto_upgrade! again and ensure no statements issued.
     Foo.auto_upgrade!
-    assert_empty Foo.queries
+    refute_match /schema\s+change/, Foo.queries
   end
 
   it 'does not add already defined composite indexes' do
@@ -156,7 +156,7 @@ describe MiniRecord do
     assert_includes Foo.db_indexes, 'by_region_and_customer'
     # Run auto_upgrade! again and ensure no statements issued.
     Foo.auto_upgrade!
-    assert_empty Foo.queries
+    refute_match /schema\s+change/, Foo.queries
   end
 
   it 'supports indexes with symbols for names' do
@@ -169,7 +169,7 @@ describe MiniRecord do
     assert_includes Foo.db_indexes, 'idx_for_some_field'
     # Run auto_upgrade! again and ensure no statements issued.
     Foo.auto_upgrade!
-    assert_empty Foo.queries
+    refute_match /schema\s+change/, Foo.queries
   end
 
   it 'works with STI' do
@@ -244,7 +244,7 @@ describe MiniRecord do
   end
 
   it 'allow custom query' do
-    skip unless conn.adapter_name =~ /mysql/i
+    skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
     class Foo < ActiveRecord::Base
       col :name, :as => "ENUM('foo','bar')"
@@ -253,7 +253,7 @@ describe MiniRecord do
     assert_match /ENUM/, Foo.queries
 
     Foo.auto_upgrade!
-    assert_empty Foo.queries
+    refute_match /schema\s+change/, Foo.queries
     assert_equal %w[id name], Foo.db_columns
     assert_equal %w[id name], Foo.schema_columns
 
@@ -282,6 +282,8 @@ describe MiniRecord do
     end
 
     it 'removes a column and index when relation is removed' do
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       class Foo < ActiveRecord::Base
         key :name
         belongs_to :image, :polymorphic => true
@@ -304,7 +306,7 @@ describe MiniRecord do
       refute_includes Foo.db_columns, 'image_id'
       assert_empty Foo.db_indexes
     end
-    
+
     it 'doesnt remove a column and index when relation is removed and destructive is false' do
       MiniRecord.configuration.destructive = false
       class Foo < ActiveRecord::Base
@@ -397,16 +399,17 @@ describe MiniRecord do
 
     it 'should not override previous defined column relation' do
       class Foo < ActiveRecord::Base
-        key :user, :as => :references, :null => false, :limit => 4
+        key :user, :as => :references, :null => false, :limit => 4, :default => 42
         belongs_to :user
       end
       Foo.auto_upgrade!
       assert_equal 4, Foo.db_fields[:user_id].limit
       assert_equal false, Foo.db_fields[:user_id].null
+      assert_equal "42", Foo.db_fields[:user_id].default.to_s
     end
 
     it 'add/remove foreign key with :foreign option, when Foreigner gem used on mysql' do
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :publisher
@@ -428,10 +431,10 @@ describe MiniRecord do
 
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
     end
-    
+
     it 'doesnt remove foreign key with :foreign option, when Foreigner gem used on mysql and destructive = false' do
       MiniRecord.configuration.destructive = false
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :publisher
@@ -456,7 +459,7 @@ describe MiniRecord do
     end
 
     it 'add/remove named foreign key with :foreign option, when Foreigner gem used on mysql' do
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :publisher
@@ -479,10 +482,10 @@ describe MiniRecord do
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
       Object.send(:remove_const, :Book)
     end
-    
+
     it 'doesnt remove named foreign key with :foreign option, when Foreigner gem used on mysql and destructive = false' do
       MiniRecord.configuration.destructive = false
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :publisher
@@ -508,7 +511,7 @@ describe MiniRecord do
     end
 
     it 'support :foreign option in the index with custom :foreign_key in the belong_to association' do
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :second_publisher, :foreign_key => 'second_publisher_id', :class_name => 'Publisher'
@@ -530,10 +533,10 @@ describe MiniRecord do
 
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'second_publisher_id'}
     end
-    
+
     it 'support :foreign option in the index with custom :foreign_key in the belong_to association and wont remove if destructive = false' do
       MiniRecord.configuration.destructive = false
-      skip unless conn.adapter_name =~ /mysql/i
+      skip "foreign key tests only for mysql" unless conn.adapter_name =~ /mysql/i
 
       class Book < ActiveRecord::Base
         belongs_to :second_publisher, :foreign_key => 'second_publisher_id', :class_name => 'Publisher'
@@ -579,6 +582,8 @@ describe MiniRecord do
 
   describe 'relation #habtm' do
     it 'creates a join table with indexes for has_and_belongs_to_many relations' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       tables = Tool.connection.tables
       assert_includes tables, 'purposes_tools'
 
@@ -592,19 +597,22 @@ describe MiniRecord do
     end
 
     it 'drops join table if has_and_belongs_to_many relation is deleted' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       Tool.schema_tables.delete('purposes_tools')
       refute_includes ActiveRecord::Base.schema_tables, 'purposes_tools'
 
       ActiveRecord::Base.clear_tables!
       refute_includes Tool.connection.tables, 'purposes_tools'
     end
-    
+
     it 'keeps join table if has_and_belongs_to_many relation is deleted and destructive = false' do
       MiniRecord.configuration.destructive = false
-      
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       tables = Tool.connection.tables
       assert_includes tables, 'purposes_tools'
-      
+
       Tool.schema_tables.delete('purposes_tools')
       refute_includes ActiveRecord::Base.schema_tables, 'purposes_tools'
 
@@ -613,6 +621,8 @@ describe MiniRecord do
     end
 
     it 'has_and_belongs_to_many with custom join_table and foreign keys' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       class Foo < ActiveRecord::Base
         has_and_belongs_to_many :watchers, :join_table => :watching, :foreign_key => :custom_foo_id, :association_foreign_key => :customer_id
       end
@@ -626,6 +636,8 @@ describe MiniRecord do
     end
 
     it 'creates a join table with indexes with long indexes names' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       class Foo < ActiveRecord::Base
         has_and_belongs_to_many :people,   :join_table  => :long_people,
                                            :foreign_key => :custom_long_long_long_long_id,
@@ -638,6 +650,8 @@ describe MiniRecord do
     end
 
     it 'creates a join table without an index when suppressed for has_and_belongs_to_many relations' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       class Foo < ActiveRecord::Base
         has_and_belongs_to_many :bars
         suppress_index :bars
@@ -648,6 +662,8 @@ describe MiniRecord do
     end
 
     it 'adds unique index' do
+      skip "habtm key tests only for mysql" unless conn.adapter_name =~ /mysql/i
+
       page = Page.create(:title => 'Foo')
       photogallery = Photogallery.create(:title => 'Bar')
       assert photogallery.valid?
@@ -698,19 +714,19 @@ describe MiniRecord do
     case conn.adapter_name
     when /sqlite/i
       # In sqlite there is a difference between limit: 4 and limit: 11
-      assert_match 'altered', Foo.queries
-      assert_equal 4, Foo.db_fields[:number].limit
+      assert_match 'foos.number#limit', Foo.queries
       assert_equal 4, Foo.schema_fields[:number].limit
+      assert_equal 4, Foo.db_fields[:number].limit
     when /mysql/i
       # In mysql according to this: http://goo.gl/bjZE7 limit: 4 is same of limit:11
-      assert_empty Foo.queries
-      assert_equal 4, Foo.db_fields[:number].limit
+      refute_match /schema\s+change/, Foo.queries
       assert_equal 4, Foo.schema_fields[:number].limit
+      assert_equal 4, Foo.db_fields[:number].limit
     when /postgres/i
       # In postgres limit: 4 will be translated to nil
       assert_match /ALTER COLUMN "number" TYPE integer$/, Foo.queries
-      assert_equal nil, Foo.db_fields[:number].limit
       assert_equal   4, Foo.schema_fields[:number].limit
+      assert_equal nil, Foo.db_fields[:number].limit
     end
 
     # Change limit to string
@@ -719,7 +735,7 @@ describe MiniRecord do
     refute_empty Foo.queries
     assert_equal 255, Foo.db_fields[:string].limit
   end
-  
+
   it 'should not change #limit if destructive = false' do
     MiniRecord.configuration.destructive = false
     class Foo < ActiveRecord::Base
@@ -739,12 +755,12 @@ describe MiniRecord do
     case conn.adapter_name
     when /sqlite/i
       # In sqlite there is a difference between limit: 4 and limit: 11
-      assert_match Foo.queries, "" 
+      assert_match Foo.queries, ""
       assert_equal nil, Foo.db_fields[:number].limit
       assert_equal 4, Foo.schema_fields[:number].limit
     when /mysql/i
       # In mysql according to this: http://goo.gl/bjZE7 limit: 4 is same of limit:11
-      assert_empty Foo.queries
+      refute_match /schema\s+change/, Foo.queries
       assert_equal nil, Foo.db_fields[:number].limit
       assert_equal 4, Foo.schema_fields[:number].limit
     when /postgres/i
@@ -757,10 +773,42 @@ describe MiniRecord do
     # Change limit to string
     Foo.key :string, :limit => 255
     Foo.auto_upgrade!
-    assert_empty Foo.queries
+    refute_match /schema\s+change/, Foo.queries
     assert_equal 100, Foo.db_fields[:string].limit
   end
 
+  it 'should handle integer defaults correctly' do
+    class Foo < ActiveRecord::Base
+      field :some_int, type: :integer, default: 33
+      field :some_bool, type: :boolean, default: false
+      field :some_bool2, type: :boolean, default: false
+      field :some_bool3, type: :boolean, default: true
+      auto_upgrade!
+    end
+
+    # Reopen class
+    class Foo < ActiveRecord::Base
+      field :some_int, type: :integer, default: 66
+      field :some_bool, type: :boolean, default: true
+    end
+
+    new_attr, changed = Foo.field_attr_changes(:some_int)
+    assert_equal 66, new_attr[:default]
+    assert_equal true, changed
+
+    new_attr, changed = Foo.field_attr_changes(:some_bool)
+    assert_equal true, changed
+    assert_equal true, new_attr[:default]
+
+    new_attr, changed = Foo.field_attr_changes(:some_bool2)
+    assert_equal false, changed
+    assert_empty new_attr
+
+    new_attr, changed = Foo.field_attr_changes(:some_bool3)
+    assert_equal false, changed
+    assert_empty new_attr
+  end
+
   it 'should change #null' do
     class Foo < ActiveRecord::Base
       key :string
@@ -781,10 +829,10 @@ describe MiniRecord do
 
     Foo.key :string, :null => false
     Foo.auto_upgrade!
-    assert_match /alter/i, Foo.queries
+    assert_match /foos.string#null/i, Foo.queries
     refute Foo.db_fields[:string].null
   end
-  
+
   it 'should not change #null if destructive = false' do
     MiniRecord.configuration.destructive = false
     class Foo < ActiveRecord::Base
@@ -817,19 +865,18 @@ describe MiniRecord do
     Foo.auto_upgrade!
     assert_equal 8, Foo.db_fields[:currency].precision
     assert_equal 2, Foo.db_fields[:currency].scale
-    assert_equal 8, Foo.db_fields[:currency].limit
 
     Foo.auto_upgrade!
-    refute_match /alter/i, Foo.queries
+    new_attr, changed = Foo.field_attr_changes(:currency)
+    assert_equal false, changed
 
     Foo.field :currency, :as => :decimal, :precision => 4, :scale => 2, :limit => 5
     Foo.auto_upgrade!
-    assert_match /alter/i, Foo.queries
+    assert_match /foos.currency#limit/i, Foo.queries
     assert_equal 4, Foo.db_fields[:currency].precision
     assert_equal 2, Foo.db_fields[:currency].scale
-    assert_equal 4, Foo.db_fields[:currency].limit
   end
-  
+
   it 'should not change #scale #precision if destructive = false' do
     MiniRecord.configuration.destructive = false
     class Foo < ActiveRecord::Base
@@ -838,7 +885,6 @@ describe MiniRecord do
     Foo.auto_upgrade!
     assert_equal 8, Foo.db_fields[:currency].precision
     assert_equal 2, Foo.db_fields[:currency].scale
-    assert_equal 8, Foo.db_fields[:currency].limit
 
     Foo.auto_upgrade!
     refute_match /alter/i, Foo.queries
@@ -848,7 +894,6 @@ describe MiniRecord do
     assert_match "", Foo.queries
     assert_equal 8, Foo.db_fields[:currency].precision
     assert_equal 2, Foo.db_fields[:currency].scale
-    assert_equal 8, Foo.db_fields[:currency].limit
   end
 
   it 'should ignore abstract classes' do
@@ -897,7 +942,7 @@ describe MiniRecord do
     end
     Foo.auto_upgrade!
     assert_match /CREATE TABLE/, Foo.queries
-    
+
     Foo.create :currency => 'USD'
 
     Foo.rename_field :currency, :new_name => :currency_iso
@@ -905,14 +950,7 @@ describe MiniRecord do
 
     Foo.auto_upgrade!
 
-    case conn.adapter_name
-    when /sqlite/i
-      assert_match /CREATE TEMPORARY TABLE "altered_foos"/i, Foo.queries
-    when /mysql/i
-      assert_match /ALTER TABLE `foos` CHANGE `currency` `currency_iso`/i, Foo.queries
-    when /postgres/i
-      assert_match /ALTER TABLE "foos" RENAME COLUMN "currency" TO "currency_iso"/, Foo.queries
-    end
+    assert_match /foos.currency to currency_iso/i, Foo.queries
 
     foo = Foo.first
     assert_equal 'USD', foo.currency_iso
@@ -921,7 +959,7 @@ describe MiniRecord do
     assert_match '', Foo.queries
 
   end
-  
+
   it 'should note rename a column specified by rename_field if destructive = false' do
     MiniRecord.configuration.destructive = false
     class Foo < ActiveRecord::Base
@@ -929,7 +967,7 @@ describe MiniRecord do
     end
     Foo.auto_upgrade!
     assert_match /CREATE TABLE/, Foo.queries
-    
+
     Foo.create :currency => 'USD'
 
     Foo.rename_field :currency, :new_name => :currency_iso

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_record
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Davide D'Agostino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -74,3 +74,4 @@ test_files:
 - test/helper.rb
 - test/models.rb
 - test/test_mini_record.rb
+has_rdoc: