mini_record 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea0ce6ed20bb680e42d5f368b217d35da8cc604f
-  data.tar.gz: 8e8c428ebb7757f08d9cbe6a58eb26e298305668
+  metadata.gz: cf09f8afab0f2be41f0bd3e61a906d843430c58c
+  data.tar.gz: 6c7fbc8621bb0aef9f379854363ce4f4ca4e999f
 SHA512:
-  metadata.gz: 3c1802bb520244e113e46d475c87af7424f1e295238a8cc931afc2357a5dc9a46c2903f44885fb2000b1538a3f4904a60c87d09d178faf34de2c959d88bdca74
-  data.tar.gz: cd615e68bd67c671e49ba836a36a619a4cdd70d7c5c2fbbfbe532f62ec7fce382d9a24167fde115b791ceabd4970557548b06cb0ae8b82729188d11d6ffdaca9
+  metadata.gz: 5e1d29807ccff1ae65c3daf5dd8a3b5db185ff86bc7fef33196a084ea847bd516d6a76d5b03ee473d3de61500ff7191eb2ece88885051b005228e1fdf72aad5d
+  data.tar.gz: e9a376ad2b04e69f8ad98c9d38d0a713d8009380b86fce1baf47ec10f0a666fb130b22099b314f1b81bb66684f13433d49a1b1592480dd682251caa567852192

data/lib/mini_record/auto_schema.rb

@@ -5,23 +5,38 @@ module MiniRecord
     end
 
     module ClassMethods
+      def init_table_definition(connection)
+        #connection.create_table(table_name) unless connection.table_exists?(table_name)
+
+        case ActiveRecord::ConnectionAdapters::TableDefinition.instance_method(:initialize).arity
+        when 1
+          # Rails 3.2 and earlier
+          ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+        when 4
+          # Rails 4
+          ActiveRecord::ConnectionAdapters::TableDefinition.new(connection.native_database_types, table_name, false, {})
+        else
+          raise ArgumentError,
+            "Unsupported number of args for ActiveRecord::ConnectionAdapters::TableDefinition.new()"
+        end
+      end
 
       def schema_tables
         @@_schema_tables ||= []
       end
 
       def table_definition
-        return superclass.table_definition unless superclass == ActiveRecord::Base
+        return superclass.table_definition unless (superclass == ActiveRecord::Base) || (superclass.respond_to?(:abstract_class?) && superclass.abstract_class?)
 
         @_table_definition ||= begin
-                                 tb = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
-                                 tb.primary_key(primary_key)
-                                 tb
-                               end
+          tb = init_table_definition(connection)
+          tb.primary_key(primary_key)
+          tb
+        end
       end
 
       def indexes
-        return superclass.indexes unless superclass == ActiveRecord::Base
+        return superclass.indexes unless (superclass == ActiveRecord::Base) || (superclass.respond_to?(:abstract_class?) && superclass.abstract_class?)
 
         @_indexes ||= {}
       end
@@ -33,6 +48,16 @@ module MiniRecord
         end
       end
 
+      def get_sql_field_type(field)
+        if field.respond_to?(:sql_type)
+          # Rails 3.2 and earlier
+          field.sql_type.to_s.downcase
+        else
+          # Rails 4
+          connection.type_to_sql(field.type.to_sym, field.limit, field.precision, field.scale)
+        end
+      end
+
       def fields
         table_definition.columns.inject({}) do |hash, column|
           hash[column.name] = column
@@ -155,6 +180,7 @@ module MiniRecord
 
       def auto_upgrade!
         return unless connection?
+        return if respond_to?(:abstract_class?) && abstract_class?
 
         if self == ActiveRecord::Base
           descendants.each(&:auto_upgrade!)
@@ -166,7 +192,7 @@ module MiniRecord
             class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
             connection.table_definition = table_definition
             connection.create_table(table_name)
-            connection.table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+            connection.table_definition = init_table_definition(connection)
           end
 
           # Add this to our schema tables
@@ -238,9 +264,12 @@ module MiniRecord
               new_attr = {}
 
               # First, check if the field type changed
-              if fields[field].sql_type.to_s.downcase != fields_in_db[field].sql_type.to_s.downcase
-                logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}#type from " +
-                             "#{fields[field].sql_type.to_s.downcase.inspect} in #{fields_in_db[field].sql_type.to_s.downcase.inspect}" if logger
+              old_sql_type = get_sql_field_type(fields_in_db[field])
+              new_sql_type = get_sql_field_type(fields[field])
+
+              if old_sql_type != new_sql_type
+                logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}#type " +
+                             " from #{old_sql_type.inspect} to #{new_sql_type.inspect}" if logger
                 changed = true
               end
 
@@ -254,12 +283,14 @@ module MiniRecord
 
               # 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
               fields[field].each_pair do |att,value|
-                next if att == :type or att == :base or att == :name # special cases
+                next unless [:name, :limit, :precision, :scale, :default, :null].include?(att)
                 value = true if att == :null && value.nil?
-                if value != fields_in_db[field].send(att)
-                  logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}##{att} "+
-                               "from #{fields_in_db[field].send(att).inspect} in #{value.inspect}" if logger
+                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

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 end

data/test/test_mini_record.rb

@@ -578,4 +578,44 @@ describe MiniRecord do
     assert_equal 2, Foo.db_fields[:currency].scale
     assert_equal 4, Foo.db_fields[:currency].limit
   end
+
+  it 'should ignore abstract classes' do
+    class Foo < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class Bar < Foo
+    end
+
+    Foo.auto_upgrade!
+    Bar.auto_upgrade!
+
+    tables = Foo.connection.tables
+
+    refute_includes tables, 'foos'
+    refute_includes tables, ''
+    assert_includes tables, 'bars'
+  end
+
+  it 'should prevent abstract table class to leak columns to other tables' do
+
+    class Base < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class User < Base
+      col :name
+    end
+
+    class Book < Base
+      col :title
+      col :author
+    end
+
+    User.auto_upgrade!
+    Book.auto_upgrade!
+
+    assert_equal ['id', 'name'], User.db_columns.sort
+    assert_equal ['author', 'id', 'title'], Book.db_columns.sort
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_record
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Davide D'Agostino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: mini_record
-rubygems_version: 2.0.3
+rubygems_version: 2.1.2
 signing_key: 
 specification_version: 4
 summary: MiniRecord is a micro gem that allow you to write schema inside your model