mini_record 0.3.0 → 0.3.1

data/.travis.yml

@@ -1,9 +1,10 @@
+language: ruby
 before_install: 'gem update --system'
 rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - rbx-2.0
+  - rbx-18mode
   - ruby-head
   - ree
 notifications:

data/Gemfile

@@ -1,7 +1,11 @@
 source "http://rubygems.org"
 
 # Specify your gem's dependencies in mini_record.gemspec
-gem "rake"
-gem "minitest"
-gem "sqlite3"
+gem 'rake'
+gem 'minitest'
+gem 'sqlite3'
+gem 'mysql2'
+gem 'mysql'
+gem 'pg'
+
 gemspec

data/Rakefile

@@ -20,8 +20,8 @@ end
 
 task :release => :bump
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'spec'
-  test.test_files = Dir['spec/**/*_spec.rb']
+  test.libs << 'test'
+  test.test_files = Dir['test/**/test_*.rb']
   test.verbose = true
 end
 

data/lib/mini_record/auto_schema.rb

@@ -14,10 +14,10 @@ module MiniRecord
         return superclass.table_definition unless superclass == ActiveRecord::Base
 
         @_table_definition ||= begin
-          tb = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
-          tb.primary_key(primary_key)
-          tb
-        end
+                                 tb = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+                                 tb.primary_key(primary_key)
+                                 tb
+                               end
       end
 
       def indexes
@@ -26,31 +26,66 @@ module MiniRecord
         @_indexes ||= {}
       end
 
-      def col(*args)
+      def indexes_in_db
+        connection.indexes(table_name).inject({}) do |hash, index|
+          hash[index.name] = index
+          hash
+        end
+      end
+
+      def fields
+        table_definition.columns.inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+      end
+
+      def fields_in_db
+        connection.columns(table_name).inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+      end
+
+      def field(*args)
         return unless connection?
 
-        options = args.extract_options!
-        type = options.delete(:as) || options.delete(:type) || :string
+        options    = args.extract_options!
+        type       = options.delete(:as) || options.delete(:type) || :string
+        index      = options.delete(:index)
+
         args.each do |column_name|
-          table_definition.send(type, column_name, options)
+
+          # Allow custom types like:
+          #   t.column :type, "ENUM('EMPLOYEE','CLIENT','SUPERUSER','DEVELOPER')"
+          if type.is_a?(String)
+            # will be converted in: t.column :type, "ENUM('EMPLOYEE','CLIENT')"
+            table_definition.column(column_name, type, options.reverse_merge(:limit => 0))
+          else
+            # wil be converted in: t.string :name
+            table_definition.send(type, column_name, options)
+          end
+
+          # Get the correct column_name i.e. in field :category, :as => :references
           column_name = table_definition.columns[-1].name
-          case index_name = options.delete(:index)
+
+          # Parse indexes
+          case index
           when Hash
-            add_index(options.delete(:column) || column_name, index_name)
+            add_index(options.delete(:column) || column_name, index)
           when TrueClass
             add_index(column_name)
           when String, Symbol, Array
-            add_index(index_name)
+            add_index(index)
           end
         end
       end
-      alias :key :col
-      alias :property :col
-      alias :field :col
-      alias :attribute :col
+      alias :key       :field
+      alias :property  :field
+      alias :col       :field
 
       def timestamps
-        col :created_at, :updated_at, :as => :datetime
+        field :created_at, :updated_at, :as => :datetime
       end
 
       def reset_table_definition!
@@ -63,14 +98,10 @@ module MiniRecord
         yield table_definition
         table_definition
       end
-      alias :keys :schema
-      alias :properties :schema
-      alias :fields :schema
-      alias :attributes :schema
 
       def add_index(column_name, options={})
         index_name = connection.index_name(table_name, :column => column_name)
-        indexes[index_name] = options.merge(:column => column_name)
+        indexes[index_name] = options.merge(:column => column_name) unless indexes.key?(index_name)
         index_name
       end
       alias :index :add_index
@@ -83,7 +114,6 @@ module MiniRecord
       end
 
       def clear_tables!
-        # Drop unsued tables
         (connection.tables - schema_tables).each do |name|
           connection.drop_table(name)
           schema_tables.delete(name)
@@ -97,7 +127,7 @@ module MiniRecord
           descendants.each(&:auto_upgrade!)
           clear_tables!
         else
-          # Table doesn't exist, create it
+          # If table doesn't exist, create it
           unless connection.tables.include?(table_name)
             # TODO: create_table options
             class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
@@ -109,25 +139,19 @@ module MiniRecord
           # Add this to our schema tables
           schema_tables << table_name unless schema_tables.include?(table_name)
 
-          # Grab database columns
-          fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
-            hash[column.name] = column
-            hash
-          end
-
           # Generate fields from associations
           if reflect_on_all_associations.any?
             reflect_on_all_associations.each do |association|
-              foreign_key = association.options[:foreign_key] || "#{association.name.to_s}_id"
+              foreign_key = association.options[:foreign_key] || "#{association.name}_id"
               type_key    = "#{association.name.to_s}_type"
               case association.macro
               when :belongs_to
-                table_definition.column(foreign_key, :integer)
+                field foreign_key, :as => :integer unless fields.key?(foreign_key.to_s)
                 if association.options[:polymorphic]
-                  table_definition.column(type_key, :string)
-                  add_index [foreign_key, type_key]
+                  field type_key, :as => :string unless fields.key?(type_key.to_s)
+                  index [foreign_key, type_key]
                 else
-                  add_index foreign_key
+                  index foreign_key
                 end
               when :has_and_belongs_to_many
                 table = if name = association.options[:join_table]
@@ -135,15 +159,16 @@ module MiniRecord
                         else
                           [table_name, association.name.to_s].sort.join("_")
                         end
-                index = ""
                 unless connection.tables.include?(table.to_s)
-                  foreign_key             = association.options[:foreign_key] || "#{table.singularize}_id"
-                  association_foreign_key = association.options[:association_foreign_key] || "#{association.name.to_s.singularize}_id"
+                  foreign_key             = association.options[:foreign_key] || association.foreign_key
+                  association_foreign_key = association.options[:association_foreign_key] || association.association_foreign_key
                   connection.create_table(table, :id => false) do |t|
                     t.integer foreign_key
                     t.integer association_foreign_key
                   end
-                  connection.add_index table.to_sym, [foreign_key, association_foreign_key].map(&:to_sym), association.options
+                  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
+                  connection.add_index table, [foreign_key, association_foreign_key], :name => index_name, :unique => true
                 end
                 # Add join table to our schema tables
                 schema_tables << table unless schema_tables.include?(table)
@@ -151,54 +176,57 @@ module MiniRecord
             end
           end
 
-          # Grab new schema
-          fields_in_schema = table_definition.columns.inject({}) do |hash, column|
-            hash[column.name.to_s] = column
-            hash
-          end
-
           # Add to schema inheritance column if necessary
-          if descendants.present? && !fields_in_schema.include?(inheritance_column.to_s)
-            table_definition.column inheritance_column, :string
+          if descendants.present?
+            field inheritance_column, :as => :string unless fields.key?(inheritance_column.to_s)
+            index inheritance_column
           end
 
           # Remove fields from db no longer in schema
-          (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
+          (fields_in_db.keys - fields.keys & fields_in_db.keys).each do |field|
             column = fields_in_db[field]
             connection.remove_column table_name, column.name
           end
 
           # Add fields to db new to schema
-          (fields_in_schema.keys - fields_in_db.keys).each do |field|
-            column  = fields_in_schema[field]
+          (fields.keys - fields_in_db.keys).each do |field|
+            column  = fields[field]
             options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
-            options[:default] = column.default if !column.default.nil?
-            options[:null]    = column.null    if !column.null.nil?
+            options[:default] = column.default unless column.default.nil?
+            options[:null]    = column.null    unless column.null.nil?
             connection.add_column table_name, column.name, column.type.to_sym, options
           end
 
           # Change attributes of existent columns
-          (fields_in_schema.keys & fields_in_db.keys).each do |field|
+          (fields.keys & fields_in_db.keys).each do |field|
             if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
               changed  = false  # flag
-              new_type = fields_in_schema[field].type.to_sym
+              new_type = fields[field].type.to_sym
               new_attr = {}
 
               # First, check if the field type changed
-              if fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym
+              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
                 changed = true
               end
 
               # 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_in_schema[field][:precision]
-              new_attr[:scale]     = fields_in_schema[field][:scale]
+              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
-              fields_in_schema[field].each_pair do |att,value|
+              fields[field].each_pair do |att,value|
                 next if att == :type or att == :base or att == :name # special cases
-                if !value.nil? && value != fields_in_db[field].send(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
                   new_attr[att] = value
                   changed = true
                 end
@@ -210,9 +238,7 @@ module MiniRecord
           end
 
           # Remove old index
-          # TODO: remove index from habtm t
-          indexes_in_db = connection.indexes(table_name).map(&:name)
-          (indexes_in_db - indexes.keys).each do |name|
+          (indexes_in_db.keys - indexes.keys).each do |name|
             connection.remove_index(table_name, :name => name)
           end
 
@@ -227,7 +253,6 @@ module MiniRecord
           # Reload column information
           reset_column_information
         end
-
       end
     end # ClassMethods
   end # AutoSchema

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/mini_record.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   # s.add_development_dependency "rspec"
-  s.add_dependency "activerecord", "~>3.2.0"
+  s.add_dependency "activerecord", ">=3.2.0"
 end

data/test/helper.rb

@@ -0,0 +1,65 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+require 'mini_record'
+require 'minitest/autorun'
+
+class ActiveRecord::Base
+  class << self
+    attr_accessor :logs
+
+    def db_fields
+      connection.columns(table_name).inject({}) do |hash, column|
+        hash[column.name.to_sym] = column
+        hash
+      end
+    end
+
+    def db_columns
+      connection.columns(table_name).map(&:name).sort
+    end
+
+    def db_indexes
+      connection.indexes(table_name).map(&:name).sort
+    end
+
+    def schema_columns
+      table_definition.columns.map { |c| c.name.to_s }.sort
+    end
+
+    def schema_fields
+      table_definition.columns.inject({}) do |hash, column|
+        hash[column.name.to_sym] = column
+        hash
+      end
+    end
+
+    def queries(pragma=false)
+      ActiveRecord::Base.logs.string.gsub(/\e\[[\d;]+m/, '').lines.reject { |l| !pragma && l =~ /pragma/i }.join("\n")
+    end
+
+    def auto_upgrade!
+      ActiveRecord::Base.logs = StringIO.new
+      ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(ActiveRecord::Base.logs)
+      silence_stream(STDERR) { super }
+    end
+  end
+end # ActiveRecord::Base
+
+# Setup Adatper
+case ENV['DB']
+when 'mysql'
+  ActiveRecord::Base.establish_connection(:adapter => 'mysql', :database => 'test', :user => 'root')
+when 'pg', 'postgresql'
+  ActiveRecord::Base.establish_connection(:adapter => 'postgresql', :database => 'test', :user => 'postgres', :host => 'localhost')
+else
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+end
+
+
+# Some helpers to minitest
+class MiniTest::Spec
+  def connection
+    ActiveRecord::Base.connection
+  end
+  alias :conn :connection
+end

data/{spec → test}/models.rb

@@ -1,6 +1,3 @@
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-# ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
-
 class Person < ActiveRecord::Base
   schema do |s|
     s.string :name
@@ -65,3 +62,13 @@ end
 class Activity < ActiveRecord::Base
   belongs_to :author, :class_name => 'Account', :foreign_key => 'custom_id'
 end
+
+class Page < ActiveRecord::Base
+  key :title
+  has_and_belongs_to_many :photogalleries
+end
+
+class Photogallery < ActiveRecord::Base
+  key :title
+  has_and_belongs_to_many :pages
+end

data/test/test_mini_record.rb

@@ -0,0 +1,503 @@
+require File.expand_path('../helper.rb', __FILE__)
+
+describe MiniRecord do
+
+  before do
+    conn.tables.each { |table| silence_stream(STDERR) { conn.execute "DROP TABLE IF EXISTS #{table}" } }
+    ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) }
+    ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
+    load File.expand_path('../models.rb', __FILE__)
+    ActiveRecord::Base.auto_upgrade!
+  end
+
+  it 'has #schema inside model' do
+    assert_equal 'people', Person.table_name
+    assert_equal %w[created_at id name updated_at], Person.db_columns.sort
+    assert_equal Person.db_columns, Person.column_names.sort
+    assert_equal Person.schema_columns, Person.column_names.sort
+
+    # Check surname attribute
+    person = Person.create(:name => 'foo')
+    assert_equal 'foo', person.name
+    assert_raises(NoMethodError){ person.surname }
+
+    # Test the timestamp columns exist
+    assert_respond_to person, :created_at
+    assert_respond_to person, :updated_at
+
+    # Add a column without lost data
+    Person.class_eval do
+      schema do |p|
+        p.string :name
+        p.string :surname
+      end
+      timestamps
+    end
+    Person.auto_upgrade!
+    assert_equal 1, Person.count
+
+    person = Person.last
+    assert_equal 'foo', person.name
+    assert_nil person.surname
+
+    person.update_attribute(:surname, 'bar')
+    assert_equal %w[created_at id name surname updated_at], Person.db_columns.sort
+
+    # Remove a column without lost data
+    Person.class_eval do
+      schema do |p|
+        p.string :name
+      end
+      timestamps
+    end
+    Person.auto_upgrade!
+    person = Person.last
+    assert_equal 'foo', person.name
+    assert_raises(NoMethodError) { person.surname }
+    assert_equal %w[created_at id name updated_at], Person.db_columns
+    assert_equal Person.column_names.sort, Person.db_columns
+    assert_equal Person.column_names.sort, Person.schema_columns
+
+    # Change column without lost data
+    Person.class_eval do
+      schema do |p|
+        p.text :name
+      end
+    end
+    person = Person.last
+    assert_equal 'foo', person.name
+  end
+
+  it 'has #key,col,property,attribute inside model' do
+    assert_equal Post.column_names.sort,     Post.db_columns
+    assert_equal Category.column_names.sort, Category.schema_columns
+
+    # Check default properties
+    category = Category.create(:title => 'category')
+    post = Post.create(:title => 'foo', :body => 'bar', :category_id => category.id)
+    post = Post.first
+    assert_equal 'foo', post.title
+    assert_equal 'bar', post.body
+    assert_equal category, post.category
+
+
+    # Remove a column
+    Post.reset_table_definition!
+    Post.class_eval do
+      col :name
+      col :category, :as => :references
+    end
+    Post.auto_upgrade!
+    refute_includes %w[title body], Post.db_columns
+
+    post = Post.first
+    assert_nil post.name
+    assert_equal category, post.category
+    assert_raises(NoMethodError, ActiveModel::MissingAttributeError) { post.title }
+  end
+
+  it 'has indexes inside model' do
+    # Check indexes
+    assert Animal.db_indexes.size > 0
+    assert_equal Animal.db_indexes, Animal.indexes.keys.sort
+
+
+    # Remove an index
+    indexes_was = Animal.db_indexes
+    Animal.indexes.delete(indexes_was.pop)
+    Animal.auto_upgrade!
+    assert_equal indexes_was, Animal.indexes.keys
+    assert_equal indexes_was, Animal.db_indexes
+
+    # Add a new index
+    Animal.class_eval do
+      col :category, :as => :references, :index => true
+    end
+    Animal.auto_upgrade!
+    new_indexes = indexes_was + %w[index_animals_on_category_id]
+    assert_includes Animal.db_columns, 'category_id'
+    assert_equal new_indexes.sort, Animal.db_indexes
+  end
+
+  it 'not add already defined indexes' do
+    class Foo < ActiveRecord::Base
+      index :customer_id, :unique => true, :name => 'by_customer'
+      belongs_to :customer
+    end
+    Foo.auto_upgrade!
+    assert_equal 1, Foo.db_indexes.size
+    assert_includes Foo.db_indexes, 'by_customer'
+  end
+
+  it 'works with STI' do
+    class Dog < Pet; end
+    class Cat < Pet; end
+    class Kitten < Cat; end
+    ActiveRecord::Base.auto_upgrade!
+
+    # Check inheritance column
+    assert_includes Pet.db_columns, "type"
+
+    # Now, let's we know if STI is working
+    Pet.create(:name => "foo")
+    Dog.create(:name => "bar")
+    Kitten.create(:name => 'foxy')
+    assert_equal 1, Dog.count
+    assert_equal 'bar', Dog.first.name
+    assert_equal 3, Pet.count
+    assert_equal %w[foo bar foxy], Pet.all.map(&:name)
+    assert_equal 'bar', Dog.first.name
+
+    # What's happen if we change schema?
+    assert_equal Dog.table_definition, Pet.table_definition
+    assert_equal Dog.indexes, Pet.indexes
+
+    Dog.class_eval do
+      col :bau
+    end
+    ActiveRecord::Base.auto_upgrade!
+    assert_includes Dog.schema_columns, 'bau'
+    assert_includes Pet.db_columns, 'bau'
+  end
+
+  it 'works with custom inheritance column' do
+    class User < ActiveRecord::Base
+      col :name
+      col :surname
+      col :role
+      def self.inheritance_column; 'role'; end
+    end
+
+    class Administrator < User; end
+    class Customer < User; end
+
+    User.auto_upgrade!
+    assert_equal 'role', User.inheritance_column
+
+    Administrator.create(:name => "Davide", :surname => 'DAddYE')
+    Customer.create(:name => "Foo", :surname => "Bar")
+    assert_equal 1, Administrator.count
+    assert_equal 'Davide', Administrator.first.name
+    assert_equal 1, Customer.count
+    assert_equal 'Foo', Customer.first.name
+    assert_equal 2, User.count
+    assert_equal 'Administrator', User.first.role
+    assert_equal 'Customer', User.last.role
+    assert_includes User.db_indexes, 'index_users_on_role'
+  end
+
+  it 'allow multiple columns definitions' do
+    class Fake < ActiveRecord::Base
+      col :name, :surname
+      col :category, :group, :as => :references
+    end
+    Fake.auto_upgrade!
+    Fake.create(:name => 'foo', :surname => 'bar', :category_id => 1, :group_id => 2)
+    fake = Fake.first
+    assert_equal 'foo', fake.name
+    assert_equal 'bar', fake.surname
+    assert_equal 1, fake.category_id
+    assert_equal 2, fake.group_id
+  end
+
+  it 'allow custom query' do
+    skip unless conn.adapter_name =~ /mysql/i
+
+    class Foo < ActiveRecord::Base
+      col :name, :as => "ENUM('foo','bar')"
+    end
+    Foo.auto_upgrade!
+    assert_match /ENUM/, Foo.queries
+
+    Foo.auto_upgrade!
+    assert_empty Foo.queries
+    assert_equal %w[id name], Foo.db_columns
+    assert_equal %w[id name], Foo.schema_columns
+
+    foo = Foo.create(:name => 'test')
+    assert_empty Foo.first.name
+
+    foo.update_attribute(:name, 'foo')
+
+    assert_equal 'foo', Foo.first.name
+  end
+
+  describe 'relation #belongs_to' do
+    it 'creates a column and index based on relation' do
+      Article.create(:title => 'Hello', :publisher_id => 1)
+      Article.first.tap do |a|
+        assert_equal 'Hello', a.title
+        assert_equal 1, a.publisher_id
+      end
+      assert_includes Article.db_indexes, 'index_articles_on_publisher_id'
+
+      # Ensure that associated field/index is not deleted on upgrade
+      Article.auto_upgrade!
+      assert_equal 1, Article.first.publisher_id
+      assert_includes Article.db_indexes, 'index_articles_on_publisher_id'
+    end
+
+    it 'removes a column and index when relation is removed' do
+      class Foo < ActiveRecord::Base
+        key :name
+        belongs_to :image, :polymorphic => true
+      end
+      Foo.auto_upgrade!
+      assert_includes Foo.db_columns, 'name'
+      assert_includes Foo.db_columns, 'image_type'
+      assert_includes Foo.db_columns, 'image_id'
+      assert_includes Foo.db_indexes, 'index_foos_on_image_id_and_image_type'
+
+      Foo.class_eval do
+        reset_table_definition!
+        reflections.clear
+        indexes.clear
+        key :name
+      end
+      Foo.auto_upgrade!
+      assert_includes Foo.db_columns, 'name'
+      refute_includes Foo.db_columns, 'image_type'
+      refute_includes Foo.db_columns, 'image_id'
+      assert_empty Foo.db_indexes
+    end
+
+    it 'creates columns and index based on polymorphic relation' do
+      Attachment.create(:name => 'Avatar', :attachable_id => 1, :attachable_type => 'Post')
+      Attachment.first.tap do |attachment|
+        assert_equal 'Avatar', attachment.name
+        assert_equal 1, attachment.attachable_id
+        assert_equal 'Post', attachment.attachable_type
+      end
+      index = 'index_attachments_on_attachable_id_and_attachable_type'
+      assert_includes Attachment.db_indexes, index
+
+      # Ensure that associated fields/indexes are not deleted on subsequent upgrade
+      Attachment.auto_upgrade!
+      assert_equal 1, Attachment.first.attachable_id
+      assert_equal 'Post', Attachment.first.attachable_type
+      assert_includes Attachment.db_indexes, index
+    end
+
+    it 'should support :class_name' do
+      assert_includes Task.schema_columns, 'author_id'
+      assert_includes Task.db_columns, 'author_id'
+    end
+
+    it 'should support :foreign_key' do
+      assert_includes Activity.schema_columns, 'custom_id'
+      assert_includes Activity.db_columns, 'custom_id'
+    end
+
+    it 'should memonize in schema relationships' do
+      silence_stream(STDERR) { conn.create_table('foos') }
+      conn.add_column :foos, :name, :string
+      conn.add_column :foos, :bar_id, :integer
+      conn.add_index  :foos, :bar_id
+      class Foo < ActiveRecord::Base
+        col :name
+        belongs_to :bar
+      end
+      assert_includes Foo.db_columns, 'name'
+      assert_includes Foo.db_columns, 'bar_id'
+      assert_includes Foo.db_indexes, 'index_foos_on_bar_id'
+
+      Foo.auto_upgrade!
+      assert_includes Foo.schema_columns, 'name'
+      assert_includes Foo.schema_columns, 'bar_id'
+      assert_includes Foo.indexes, 'index_foos_on_bar_id'
+    end
+
+    it 'should add new columns without lost belongs_to schema' do
+      publisher  = Publisher.create(:name => 'foo')
+      article = Article.create(:title => 'bar', :publisher => publisher)
+      assert article.valid?
+      assert_includes Article.indexes, 'index_articles_on_publisher_id'
+
+      # Here we perform a schema change
+      Article.key :body
+      Article.auto_upgrade!
+      article.reload
+      assert_nil article.body
+
+      article.update_attribute(:body, 'null')
+      assert_equal 'null', article.body
+
+      # Finally check the index existance
+      assert_includes Article.db_indexes, 'index_articles_on_publisher_id'
+    end
+
+    it 'should not override previous defined column relation' do
+      class Foo < ActiveRecord::Base
+        key :user, :as => :references, :null => false, :limit => 4
+        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
+    end
+  end
+
+  describe 'relation #habtm' do
+    it 'creates a join table with indexes for has_and_belongs_to_many relations' do
+      tables = Tool.connection.tables
+      assert_includes tables, 'purposes_tools'
+
+      index = 'index_purposes_tools_on_tool_id_and_purpose_id'
+      assert_includes Tool.connection.indexes('purposes_tools').map(&:name), index
+
+      # Ensure that join table is not deleted on subsequent upgrade
+      Tool.auto_upgrade!
+      assert_includes tables, 'purposes_tools'
+      assert_includes Tool.connection.indexes('purposes_tools').map(&:name), index
+    end
+
+    it 'drops join table if has_and_belongs_to_many relation is deleted' do
+      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 'has_and_belongs_to_many with custom join_table and foreign keys' do
+      class Foo < ActiveRecord::Base
+        has_and_belongs_to_many :watchers, :join_table => :watching, :foreign_key => :custom_foo_id, :association_foreign_key => :customer_id
+      end
+      Foo.auto_upgrade!
+      assert_includes conn.tables, 'watching'
+
+      cols = conn.columns('watching').map(&:name)
+      refute_includes cols, 'id'
+      assert_includes cols, 'custom_foo_id'
+      assert_includes cols, 'customer_id'
+    end
+
+    it 'creates a join table with indexes with long indexes names' do
+      class Foo < ActiveRecord::Base
+        has_and_belongs_to_many :people,   :join_table  => :long_people,
+                                           :foreign_key => :custom_long_long_long_long_id,
+                                           :association_foreign_key => :customer_super_long_very_long_trust_me_id
+      end
+      Foo.auto_upgrade!
+      index_name = 'index_long_people_on_custom_long_long_long_long_id_and_customer_super_long_very_long_trust_me_id'[0...conn.index_name_length]
+      assert_includes conn.tables, 'people'
+      assert_includes conn.indexes(:long_people).map(&:name), index_name
+    end
+
+    it 'adds unique index' do
+      page = Page.create(:title => 'Foo')
+      photogallery = Photogallery.create(:title => 'Bar')
+      assert photogallery.valid?
+
+      photogallery.pages << page
+      refute_empty Photogallery.queries
+      assert_includes photogallery.reload.pages, page
+      assert_raises(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid){ photogallery.pages << page }
+    end
+  end
+
+  it 'should add multiple index' do
+    class Foo < ActiveRecord::Base
+      key :name, :surname, :index => true
+    end
+    Foo.auto_upgrade!
+    assert_includes Foo.db_indexes, 'index_foos_on_name'
+    assert_includes Foo.db_indexes, 'index_foos_on_surname'
+  end
+
+  it 'should create a unique index' do
+    class Foo < ActiveRecord::Base
+      key :name, :surname
+      add_index([:name, :surname], :unique => true)
+    end
+    Foo.auto_upgrade!
+    db_indexes = Foo.connection.indexes('foos')[0]
+    assert_equal 'index_foos_on_name_and_surname', db_indexes.name
+    assert db_indexes.unique
+    assert_equal %w[name surname], db_indexes.columns.sort
+  end
+
+  it 'should change #limit' do
+    class Foo < ActiveRecord::Base
+      key :number, :as => :integer
+      key :string, :limit => 100
+    end
+    Foo.auto_upgrade!
+    assert_match /CREATE TABLE/, Foo.queries
+
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+
+    # According to this:
+    # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L476-487
+    Foo.key :number, :as => :integer, :limit => 4
+    Foo.auto_upgrade!
+    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_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
+      assert_equal 4, Foo.db_fields[:number].limit
+      assert_equal 4, Foo.schema_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
+    end
+
+    # Change limit to string
+    Foo.key :string, :limit => 255
+    Foo.auto_upgrade!
+    refute_empty Foo.queries
+    assert_equal 255, Foo.db_fields[:string].limit
+  end
+
+  it 'should change #null' do
+    class Foo < ActiveRecord::Base
+      key :string
+    end
+    Foo.auto_upgrade!
+    assert Foo.db_fields[:string].null
+
+    # Same as above
+    Foo.key :string, :null => true
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+    assert Foo.db_fields[:string].null
+
+    Foo.key :string, :null => nil
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+    assert Foo.db_fields[:string].null
+
+    Foo.key :string, :null => false
+    Foo.auto_upgrade!
+    assert_match /alter/i, Foo.queries
+    refute Foo.db_fields[:string].null
+  end
+
+  it 'should change #scale #precision' do
+    class Foo < ActiveRecord::Base
+      field :currency, :as => :decimal, :precision => 8, :scale => 2
+    end
+    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
+
+    Foo.field :currency, :as => :decimal, :precision => 4, :scale => 2, :limit => 5
+    Foo.auto_upgrade!
+    assert_match /alter/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
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mini_record
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Davide D'Agostino
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-22 00:00:00 Z
+date: 2012-02-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -23,7 +23,7 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 15
         segments: 
@@ -55,9 +55,9 @@ files:
 - lib/mini_record/auto_schema.rb
 - lib/mini_record/version.rb
 - mini_record.gemspec
-- spec/mini_record_spec.rb
-- spec/models.rb
-- spec/spec_helper.rb
+- test/helper.rb
+- test/models.rb
+- test/test_mini_record.rb
 homepage: https://github.com/DAddYE/mini_record
 licenses: []
 
@@ -92,7 +92,7 @@ signing_key:
 specification_version: 3
 summary: MiniRecord is a micro gem that allow you to write schema inside your model as you can do in DataMapper.
 test_files: 
-- spec/mini_record_spec.rb
-- spec/models.rb
-- spec/spec_helper.rb
+- test/helper.rb
+- test/models.rb
+- test/test_mini_record.rb
 has_rdoc: 

data/spec/mini_record_spec.rb

@@ -1,296 +0,0 @@
-require File.expand_path('../spec_helper.rb', __FILE__)
-
-describe MiniRecord do
-
-  before do
-    ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) }
-    ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
-    load File.expand_path('../models.rb', __FILE__)
-    ActiveRecord::Base.auto_upgrade!
-  end
-
-  it 'has #schema inside model' do
-    Person.table_name.must_equal 'people'
-    Person.db_columns.sort.must_equal %w[created_at id name updated_at]
-    Person.column_names.sort.must_equal Person.db_columns.sort
-    Person.column_names.sort.must_equal Person.schema_columns.sort
-    person = Person.create(:name => 'foo')
-    person.name.must_equal 'foo'
-    proc { person.surname }.must_raise NoMethodError
-
-    # Test the timestamp columns exist
-    person.must_respond_to :created_at
-    person.must_respond_to :updated_at
-
-    # Add a column without lost data
-    Person.class_eval do
-      schema do |p|
-        p.string :name
-        p.string :surname
-      end
-      timestamps
-    end
-    Person.auto_upgrade!
-    Person.count.must_equal 1
-    person = Person.last
-    person.name.must_equal 'foo'
-    person.surname.must_be_nil
-    person.update_attribute(:surname, 'bar')
-    Person.db_columns.sort.must_equal %w[created_at id name surname updated_at]
-    # Person.column_names.must_equal Person.db_columns
-
-    # Remove a column without lost data
-    Person.class_eval do
-      schema do |p|
-        p.string :name
-      end
-      timestamps
-    end
-    Person.auto_upgrade!
-    person = Person.last
-    person.name.must_equal 'foo'
-    proc { person.surname }.must_raise NoMethodError
-    Person.db_columns.sort.must_equal %w[created_at id name updated_at]
-    Person.column_names.sort.must_equal Person.db_columns.sort
-    Person.column_names.sort.must_equal Person.schema_columns.sort
-
-    # Change column without lost data
-    Person.class_eval do
-      schema do |p|
-        p.text :name
-      end
-    end
-    person = Person.last
-    person.name.must_equal 'foo'
-  end
-
-  it 'has #key,col,property,attribute inside model' do
-    Post.column_names.sort.must_equal Post.db_columns
-    Category.column_names.sort.must_equal Category.schema_columns
-
-    # Check default properties
-    category = Category.create(:title => 'category')
-    post = Post.create(:title => 'foo', :body => 'bar', :category_id => category.id)
-    post = Post.first
-    post.title.must_equal 'foo'
-    post.body.must_equal 'bar'
-    post.category.must_equal category
-
-
-    # Remove a column
-    Post.reset_table_definition!
-    Post.class_eval do
-      col :name
-      col :category, :as => :references
-    end
-    Post.auto_upgrade!
-    post = Post.first
-    post.name.must_be_nil
-    post.category.must_equal category
-    proc { post.title }.must_raise ActiveModel::MissingAttributeError
-  end
-
-  it 'has indexes inside model' do
-    # Check indexes
-    Animal.db_indexes.size.must_be :>, 0
-    Animal.db_indexes.must_equal Animal.indexes.keys.sort
-
-    indexes_was = Animal.db_indexes
-
-    # Remove an index
-    Animal.indexes.delete(indexes_was.pop)
-    Animal.auto_upgrade!
-    Animal.indexes.keys.sort.must_equal indexes_was
-    Animal.db_indexes.must_equal indexes_was
-
-    # Add a new index
-    Animal.class_eval do
-      col :category, :as => :references, :index => true
-    end
-    Animal.auto_upgrade!
-    Animal.db_columns.must_include "category_id"
-    Animal.db_indexes.must_equal((indexes_was << "index_animals_on_category_id").sort)
-  end
-
-  it 'works with STI' do
-    class Dog < Pet; end
-    class Cat < Pet; end
-    ActiveRecord::Base.auto_upgrade!
-
-    # Check inheritance column
-    Pet.db_columns.must_include "type"
-
-    # Now, let's we know if STI is working
-    Pet.create(:name => "foo")
-    Dog.create(:name => "bar")
-    Dog.count.must_equal 1
-    Dog.first.name.must_equal "bar"
-    Pet.count.must_equal 2
-    Pet.all.map(&:name).must_equal ["foo", "bar"]
-
-    # Check that this doesn't break things
-    Dog.first.name.must_equal "bar"
-
-    # What's happen if we change schema?
-    Dog.table_definition.must_equal Pet.table_definition
-    Dog.indexes.must_equal Pet.indexes
-    Dog.class_eval do
-      col :bau
-    end
-    ActiveRecord::Base.auto_upgrade!
-    Dog.schema_columns.must_include "bau"
-    Pet.db_columns.must_include "bau"
-    # Dog.new.must_respond_to :bau
-    # Cat.new.must_respond_to :bau
-  end
-
-  it 'works with custom inheritance column' do
-    class User < ActiveRecord::Base
-      col :name
-      col :surname
-      col :role
-      def self.inheritance_column; 'role'; end
-    end
-
-    class Administrator < User; end
-    class Customer < User; end
-
-    User.auto_upgrade!
-    User.inheritance_column.must_equal 'role'
-    Administrator.create(:name => "Davide", :surname => 'DAddYE')
-    Customer.create(:name => "Foo", :surname => "Bar")
-    Administrator.count.must_equal 1
-    Administrator.first.name.must_equal "Davide"
-    Customer.count.must_equal 1
-    Customer.first.name.must_equal "Foo"
-    User.count.must_equal 2
-    User.first.role.must_equal "Administrator"
-    User.last.role.must_equal "Customer"
-  end
-
-  it 'allow multiple columns definitions' do
-    class Fake < ActiveRecord::Base
-      col :name, :surname
-      col :category, :group, :as => :references
-    end
-    Fake.auto_upgrade!
-    Fake.create(:name => 'foo', :surname => 'bar', :category_id => 1, :group_id => 2)
-    fake = Fake.first
-    fake.name.must_equal 'foo'
-    fake.surname.must_equal 'bar'
-    fake.category_id.must_equal 1
-    fake.group_id.must_equal 2
-  end
-
-  it 'creates a column and index based on belongs_to relation' do
-    Article.create(:title => 'Hello', :publisher_id => 1)
-    Article.first.tap do |a|
-      a.title.must_equal 'Hello'
-      a.publisher_id.must_equal 1
-    end
-    Article.db_indexes.must_include 'index_articles_on_publisher_id'
-    # Ensure that associated field/index is not deleted on upgrade
-    Article.auto_upgrade!
-    Article.first.publisher_id.must_equal 1
-    Article.db_indexes.must_include 'index_articles_on_publisher_id'
-  end
-
-  it 'removes a column and index when belongs_to relation is removed' do
-    class Foo < ActiveRecord::Base
-      key :name
-      belongs_to :image, :polymorphic => true
-    end
-    Foo.auto_upgrade!
-    Foo.db_columns.must_include 'name'
-    Foo.db_columns.must_include 'image_type'
-    Foo.db_columns.must_include 'image_id'
-    Foo.db_indexes.must_include 'index_foos_on_image_id_and_image_type'
-    Foo.class_eval do
-      reset_table_definition!
-      reflections.clear
-      indexes.clear
-      key :name
-    end
-    Foo.auto_upgrade!
-    Foo.db_columns.must_include 'name'
-    Foo.db_columns.wont_include 'image_type'
-    Foo.db_columns.wont_include 'image_id'
-    Foo.db_indexes.must_be_empty
-  end
-
-  it 'creates columns and index based on belongs_to polymorphic relation' do
-    Attachment.create(:name => 'Avatar', :attachable_id => 1, :attachable_type => 'Post')
-    Attachment.first.tap do |attachment|
-      attachment.name.must_equal 'Avatar'
-      attachment.attachable_id.must_equal 1
-      attachment.attachable_type.must_equal 'Post'
-    end
-    index = 'index_attachments_on_attachable_id_and_attachable_type'
-    Attachment.db_indexes.must_include index
-    # Ensure that associated fields/indexes are not deleted on subsequent upgrade
-    Attachment.auto_upgrade!
-    Attachment.first.attachable_id.must_equal 1
-    Attachment.first.attachable_type.must_equal 'Post'
-    Attachment.db_indexes.must_include index
-  end
-
-  it 'creates a join table with indexes for has_and_belongs_to_many relations' do
-    tables = Tool.connection.tables
-    tables.must_include('purposes_tools')
-    index = 'index_purposes_tools_on_purposes_tool_id_and_purpose_id'
-    Tool.connection.indexes('purposes_tools').map(&:name).must_include index
-    # Ensure that join table is not deleted on subsequent upgrade
-    Tool.auto_upgrade!
-    tables.must_include('purposes_tools')
-    Tool.connection.indexes('purposes_tools').map(&:name).must_include index
-  end
-
-  it 'drops join table if has_and_belongs_to_many relation is deleted' do
-    Tool.schema_tables.delete('purposes_tools')
-    ActiveRecord::Base.schema_tables.wont_include('purposes_tools')
-    ActiveRecord::Base.clear_tables!
-    Tool.connection.tables.wont_include('purposes_tools')
-  end
-
-  it 'has_and_belongs_to_many with custom join_table and foreign keys' do
-    class Foo < ActiveRecord::Base
-      has_and_belongs_to_many :watchers, :join_table => :watchers, :foreign_key => :custom_foo_id, :association_foreign_key => :customer_id
-    end
-    Foo.auto_upgrade!
-    conn = ActiveRecord::Base.connection
-    conn.tables.must_include 'watchers'
-    cols = conn.columns('watchers').map(&:name)
-    cols.wont_include 'id'
-    cols.must_include 'custom_foo_id'
-    cols.must_include 'customer_id'
-  end
-
-  it 'should support #belongs_to with :class_name' do
-    Task.schema_columns.must_include 'author_id'
-    Task.db_columns.must_include 'author_id'
-  end
-
-  it 'should support #belongs_to with :foreign_key' do
-    Activity.schema_columns.must_include 'custom_id'
-    Activity.db_columns.must_include 'custom_id'
-  end
-
-  it 'should memonize in schema relationships' do
-    conn = ActiveRecord::Base.connection
-    conn.create_table('foos')
-    conn.add_column :foos, :name, :string
-    conn.add_column :foos, :bar_id, :integer
-    conn.add_index  :foos, :bar_id
-    class Foo < ActiveRecord::Base
-      col :name
-      belongs_to :bar
-    end
-    Foo.db_columns.must_include 'name'
-    Foo.db_columns.must_include 'bar_id'
-    Foo.db_indexes.must_include 'index_foos_on_bar_id'
-    Foo.auto_upgrade!
-    Foo.schema_columns.must_include 'name'
-    Foo.schema_columns.must_include 'bar_id'
-    Foo.indexes.must_include 'index_foos_on_bar_id'
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-require 'rubygems' unless defined?(Gem)
-require 'bundler/setup'
-require 'mini_record'
-require 'minitest/autorun'
-
-module SpecHelper
-  module ClassMethods
-    def db_columns
-      connection.columns(table_name).map(&:name).sort
-    end
-
-    def db_indexes
-      connection.indexes(table_name).map(&:name).sort
-    end
-
-    def schema_columns
-      table_definition.columns.map { |c| c.name.to_s }.sort
-    end
-
-    def reset!
-      reset
-    end
-  end
-end
-
-ActiveRecord::Base.extend(SpecHelper::ClassMethods)