mini_record-compat 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,10 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-2.0
+  - ruby-head
+  - ree
+notifications:
+  recipients:
+    - d.dagostino@lipsiasoft.com

data/Gemfile

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

data/README.md

@@ -0,0 +1,167 @@
+[![Build Status](https://secure.travis-ci.org/DAddYE/mini_record.png)](http://travis-ci.org/DAddYE/mini_record)
+
+
+MiniRecord is a micro extension for our `ActiveRecord` gem.
+With MiniRecord you can add the ability to create columns outside the default `schema.rb`, directly
+in your **model** in a similar way that should know in others projects
+like  DataMapper, MongoMapper or MongoID.
+
+My inspiration come from this handy [project](https://github.com/pjhyett/auto_migrations).
+
+## Features
+
+* Define columns/properties inside your model
+* Perform migrations automatically
+* Auto upgrade your schema, so if you know what you are doing you don't lost your existing data!
+* Add, Remove, Change Columns; Add, Remove, Change indexes
+
+## Instructions
+
+What you need is to move/remove your `db/schema.rb`.
+This avoid conflicts.
+
+Add to your `Gemfile`:
+
+``` rb
+gem 'mini_record'
+```
+
+That's all!
+
+## Examples
+
+Remember that inside properties you can use all migrations methods,
+see [documentation](http://api.rubyonrails.org/classes/ActiveRecord/Migration.html)
+
+``` rb
+class Post < ActiveRecord::Base
+  col :title_en, :title_jp
+  col :description_en, :description_jp, :as => :text
+  col :permalink, :index => true, :limit => 50
+  col :comments_count, :as => :integer
+  col :category, :as => :references, :index => true
+end
+Post.auto_upgrade!
+```
+
+If you don't like `col` there are also few aliases: `key, field, property, attribute`
+
+Instead of `:as => :my_type` you can use `:type => :my_type`
+
+Option `:as` or `:type` if not provided is `:string` by default, you can use all ActiveRecord types:
+
+``` rb
+:primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean
+:references, :belongs_to, :polymorphic, :timestamp
+```
+
+You can provide others ActiveRecord options like:
+
+``` rb
+:limit, :default, :null, :precision, :scale
+
+# example
+class Foo < ActiveRecord::Base
+  col :title, :default => "MyTitle" # :as => :string is by default
+  col :price, :as => :decimal, :scale => 8, :precision => 2
+end
+```
+
+See [ActiveRecord::TableDefinition](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html) 
+for more details.
+
+Finally, when you execute `MyModel.auto_upgrade!`, missing columns, indexes and tables will be created on the fly.
+Indexes and columns present in the db but **not** in your model schema will be **deleted*** also in your db.
+
+### Single Table Inheritance
+
+MiniRecord as ActiveRecord support STI plus some goodness, see our specs for more details.
+
+### Adding a new column
+
+Super easy, open your model and just add it:
+
+``` rb
+class Post < ActiveRecord::Base
+  col :title
+  col :body, :as => :text # <<- this
+  col :permalink, :index => true
+  col :comments_count, :as => :integer
+  col :category, :as => :references, :index => true
+end
+Post.auto_upgrade!
+```
+
+So now when you invoke `MyModel.auto_upgrade!` you should see a SQL query like `ALTER TABLE` that mean that your existing
+records are happy and safe.
+
+### Removing a column
+
+It's exactly the same, but the column will be _really_ deleted without affect other columns.
+
+### Change columns
+
+It's not possible for us know when/what column you have renamed, but we can know if you changed the `type` so
+if you change `t.string :name` to `t.text :name` we are be able to perform an `ALTER TABLE`
+
+### Add/Remove indexes
+
+In the same ways we manage columns MiniRecord will detect new indexes and indexes that needs to be removed.
+So when you perform `MyModel.auto_upgrade!` a SQL command like:
+
+``` SQL
+PRAGMA index_info('index_people_on_name')
+CREATE INDEX "index_people_on_surname" ON "people" ("surname")
+```
+
+Note that writing it in DSL way you have same options as `add_index` so you are be able to write:
+
+``` rb
+class Fox < ActiveRecord::Base
+  col :foo, :index => true
+  col :foo, :index => :custom_name
+  col :foo, :index => [:foo, :bar]
+  col :foo, :index => { :column => [:branch_id, :party_id], :unique => true, :name => 'by_branch_party' }
+end
+```
+
+That is the same of:
+
+``` rb
+class Fox < ActiveRecord::Base
+  col :foo
+  add_index :foo
+  add_index :custom_name
+  add_index [:foo, :bar]
+  add_index [:branch_id, :party_id], :unique => true, :name => 'by_branch_party'
+end
+```
+
+## Warnings
+
+This software is not super well tested in a production project.
+Im stated to using it in two customer's projects without any problem.
+
+## TODO
+
+* reduce the number of methods we add to ActiveRecord::Base objects
+
+## Author
+
+DAddYE, you can follow me on twitter [@daddye](http://twitter.com/daddye) or take a look at my site [daddye.it](http://www.daddye.it)
+
+## Copyright
+
+Copyright (C) 2011 Davide D'Agostino - [@daddye](http://twitter.com/daddye)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the “Software”), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,38 @@
+require "bundler/gem_tasks"
+require "rake"
+require "rake/testtask"
+
+%w(install release).each do |task|
+  Rake::Task[task].enhance do
+    sh "rm -rf pkg"
+  end
+end
+
+desc "Bump version on github"
+task :bump do
+  if `git status -s`.strip == ""
+    puts "\e[31mNothing to commit (working directory clean)\e[0m"
+  else
+    version  = Bundler.load_gemspec(Dir[File.expand_path('../*.gemspec', __FILE__)].first).version
+    sh "git add .; git commit -a -m \"Bump to version #{version}\""
+  end
+end
+
+task :release => :bump
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'spec'
+  test.test_files = Dir['spec/**/*_spec.rb']
+  test.verbose = true
+end
+
+task :test_each_db_adapter do
+  %w{ mysql sqlite3 postgresql }.each do |db_adapter|
+    puts
+    puts "#{'*'*10} Running #{db_adapter} tests"
+    puts
+    puts `bundle exec rake test TEST=spec/#{db_adapter}_spec.rb`
+  end
+end
+
+task :default => :test_each_db_adapter
+task :spec => :test_each_db_adapter

data/lib/mini_record/auto_schema.rb

@@ -0,0 +1,220 @@
+require 'zlib'
+module MiniRecord
+  module AutoSchema
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+
+      def table_definition
+        return superclass.table_definition unless superclass == ActiveRecord::Base
+
+        @_table_definition ||= begin
+          ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+        end
+      end
+
+      def indexes
+        return superclass.indexes unless superclass == ActiveRecord::Base
+
+        @_indexes ||= {}
+      end
+
+      def col(*args)
+        return unless connection?
+
+        options = args.extract_options!
+        type = options.delete(:as) || options.delete(:type) || :string
+        args.each do |column_name|
+          table_definition.send(type, column_name, options)
+          column_name = table_definition.columns[-1].name
+          case index_name = options.delete(:index)
+            when Hash
+              add_index(options.delete(:column) || column_name, index_name)
+            when TrueClass
+              add_index(column_name)
+            when String, Symbol, Array
+              add_index(index_name)
+          end
+        end
+      end
+      alias :key :col
+      alias :property :col
+      alias :field :col
+      alias :attribute :col
+
+      def reset_table_definition!
+        @_table_definition = nil
+      end
+      alias :reset_schema! :reset_table_definition!
+
+      def schema
+        reset_table_definition!
+        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 = shorten_index_name connection.index_name(table_name, :column => column_name)
+        indexes[index_name] = options.merge(:column => column_name, :name => index_name)
+        index_name
+      end
+      alias :index :add_index
+
+      def connection?
+        !!connection
+      rescue Exception => e
+        puts "\e[31m%s\e[0m" % e.message.strip
+        false
+      end
+      
+      def shorten_index_name(name)
+        if name.length < connection.index_name_length
+          name
+        else
+          name[0..(connection.index_name_length-11)] + ::Zlib.crc32(name).to_s
+        end
+      end
+      
+      def sqlite?
+        connection.adapter_name =~ /sqlite/i
+      end
+      
+      def mysql?
+        connection.adapter_name =~ /mysql/i
+      end
+      
+      def postgresql?
+        connection.adapter_name =~ /postgresql/i
+      end
+
+      def auto_upgrade!(create_table_options = '')
+        return unless connection?
+        
+        # normally activerecord's mysql adapter does this
+        if mysql?
+          create_table_options ||= 'ENGINE=InnoDB'
+        end
+
+        non_standard_primary_key = if (primary_key_column = table_definition.columns.detect { |column| column.name.to_s == primary_key.to_s })
+          primary_key_column.type != :primary_key
+        end
+          
+        unless non_standard_primary_key
+          table_definition.column :id, :primary_key
+        end
+
+        # Table doesn't exist, create it
+        unless connection.table_exists? table_name
+          
+          # avoid using connection.create_table because in 3.0.x it ignores table_definition
+          # and it also is too eager about adding a primary key column
+          create_sql = "CREATE TABLE "
+          create_sql << "#{quoted_table_name} ("
+          create_sql << table_definition.to_sql
+          create_sql << ") #{create_table_options}"
+          connection.execute create_sql
+          
+          if non_standard_primary_key
+            if sqlite?
+              add_index primary_key, :unique => true
+            elsif mysql? or postgresql?
+            # can't use add_index method because it won't let you do "PRIMARY KEY"
+              connection.execute "ALTER TABLE #{quoted_table_name} ADD PRIMARY KEY (#{quoted_primary_key})"
+            else
+              raise RuntimeError, "mini_record doesn't support non-standard primary keys for the #{connection.adapter_name} adapter!"
+            end
+          end
+
+          reset_column_information
+        end
+
+        # Add to schema inheritance column if necessary
+        if descendants.present? && !table_definition.columns.any? { |column| column.name.to_s == inheritance_column.to_s }
+          table_definition.column inheritance_column, :string
+        end
+
+        # Grab database columns
+        fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+
+        # Grab new schema
+        fields_in_schema = table_definition.columns.inject({}) do |hash, column|
+          hash[column.name.to_s] = column
+          hash
+        end
+
+        # Remove fields from db no longer in schema
+        (fields_in_db.keys - fields_in_schema.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]
+          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?
+          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|
+          if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
+            changed  = false  # flag
+            new_type = fields_in_schema[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
+              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]
+
+            # 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|
+              next if att == :type or att == :base or att == :name # special cases
+              if !value.nil? && value != fields_in_db[field].send(att)
+                new_attr[att] = value
+                changed = true
+              end
+            end
+
+            # Change the column if applicable
+            connection.change_column table_name, field, new_type, new_attr if changed
+          end
+        end
+
+        # Remove old index
+        indexes_in_db = connection.indexes(table_name).map(&:name)
+        (indexes_in_db - indexes.keys).each do |name|
+          connection.remove_index(table_name, :name => name)
+        end
+
+        # Add indexes
+        indexes.each do |name, options|
+          options = options.dup
+          unless connection.indexes(table_name).detect { |i| i.name == name }
+            connection.add_index(table_name, options.delete(:column), options)
+          end
+        end
+
+        # Reload column information
+        reset_column_information
+      end
+    end # ClassMethods
+  end # AutoSchema
+end # MiniRecord

data/lib/mini_record/version.rb

@@ -0,0 +1,3 @@
+module MiniRecord
+  VERSION = "0.2.1"
+end

data/lib/mini_record.rb

@@ -0,0 +1,5 @@
+require 'rubygems' unless defined?(Gem)
+require 'active_record'
+require 'mini_record/auto_schema'
+
+ActiveRecord::Base.send(:include, MiniRecord::AutoSchema)

data/mini_record.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mini_record/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mini_record-compat"
+  s.version     = MiniRecord::VERSION
+  s.authors     = ["Davide D'Agostino", "Seamus Abshere"]
+  s.email       = ["d.dagostino@lipsiasoft.com", "seamus@abshere.net"]
+  s.homepage    = "https://github.com/seamusabshere/mini_record"
+  s.summary     = %q{Alternate gem published by Seamus Abshere for ActiveRecord 3.0 support. MiniRecord is a micro gem that allow you to write schema inside your model as you can do in DataMapper.}
+  s.description = %q{
+    With it you can add the ability to create columns outside the default schema, directly
+    in your model in a similar way that you just know in others projects
+    like  DataMapper or  MongoMapper.
+  }.gsub(/^ {4}/, '')
+
+  # s.rubyforge_project = "mini_record"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activerecord", ">=3"
+
+  # dev dependencies appear to be in the Gemfile
+end

data/spec/models.rb

@@ -0,0 +1,70 @@
+# be sure to set up activerecord before you require this helper
+
+class Person < ActiveRecord::Base
+  include SpecHelper
+  schema do |s|
+    s.string :name
+  end
+end
+
+class Post < ActiveRecord::Base
+  include SpecHelper
+
+  key :title
+  key :body
+  key :category, :as => :references
+  belongs_to :category
+end
+
+class Category < ActiveRecord::Base
+  include SpecHelper
+
+  key :title
+  has_many :posts
+end
+
+class Animal < ActiveRecord::Base
+  include SpecHelper
+
+  key :name, :index => true
+  index :id
+end
+
+class Pet < ActiveRecord::Base
+  include SpecHelper
+
+  key :name, :index => true
+end
+class Dog < Pet; end
+class Cat < Pet; end
+
+class Vegetable < ActiveRecord::Base
+  include SpecHelper
+
+  set_primary_key :latin_name
+  
+  col :latin_name
+  col :common_name
+end
+
+class User < ActiveRecord::Base
+  include SpecHelper
+  col :name
+  col :surname
+  col :role
+  set_inheritance_column :role
+end
+class Administrator < User; end
+class Customer < User; end
+
+class Fake < ActiveRecord::Base
+  include SpecHelper
+  col :name, :surname
+  col :category, :group, :as => :references
+end
+
+class AutomobileMakeModelYearVariant < ActiveRecord::Base
+  include SpecHelper
+  col :make_model_year_name
+  add_index :make_model_year_name
+end

data/spec/mysql_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+bin = ENV['TEST_MYSQL_BIN'] || 'mysql'
+username = ENV['TEST_MYSQL_USERNAME'] || 'root'
+password = ENV['TEST_MYSQL_PASSWORD'] || 'password'
+database = ENV['TEST_MYSQL_DATABASE'] || 'test_mini_record'
+cmd = "#{bin} -u #{username} -p#{password}"
+
+`#{cmd} -e 'show databases'`
+unless $?.success?
+  $stderr.puts "Skipping mysql tests because `#{cmd}` doesn't work"
+  exit 0
+end
+
+system %{#{cmd} -e "drop database #{database}"}
+system %{#{cmd} -e "create database #{database}"}
+
+ActiveRecord::Base.establish_connection(
+  'adapter' => 'mysql',
+  'encoding' => 'utf8',
+  'database' => database,
+  'username' => username,
+  'password' => password
+)
+
+# require 'logger'
+# ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
+
+require File.expand_path('../models.rb', __FILE__)
+
+require File.expand_path('../shared_examples.rb', __FILE__)

data/spec/postgresql_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+createdb_bin = ENV['TEST_CREATEDB_BIN'] || 'createdb'
+dropdb_bin = ENV['TEST_DROPDB_BIN'] || 'dropdb'
+username = ENV['TEST_POSTGRES_USERNAME'] || `whoami`.chomp
+# password = ENV['TEST_POSTGRES_PASSWORD'] || 'password'
+database = ENV['TEST_POSTGRES_DATABASE'] || 'test_mini_record'
+
+system %{#{dropdb_bin} #{database}}
+system %{#{createdb_bin} #{database}}
+
+ActiveRecord::Base.establish_connection(
+  'adapter' => 'postgresql',
+  'encoding' => 'utf8',
+  'database' => database,
+  'username' => username,
+  # 'password' => password
+)
+
+# require 'logger'
+# ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
+
+require File.expand_path('../models.rb', __FILE__)
+
+require File.expand_path('../shared_examples.rb', __FILE__)

data/spec/shared_examples.rb

@@ -0,0 +1,220 @@
+describe MiniRecord do
+  before do
+    ActiveRecord::Base.descendants.each do |active_record|
+      ActiveRecord::Base.connection.drop_table active_record.table_name if active_record.table_exists?
+    end
+  end
+
+  it 'has #schema inside model' do
+    # For unknown reason separate specs doesn't works
+    ActiveRecord::Base.connection.table_exists?(Person.table_name).must_equal false
+    Person.auto_upgrade!
+    Person.table_name.must_equal 'people'
+    Person.db_columns.sort.must_equal %w[id name]
+    Person.column_names.sort.must_equal Person.db_columns
+    Person.column_names.sort.must_equal Person.schema_columns
+    person = Person.create(:name => 'foo')
+    person.name.must_equal 'foo'
+    proc { person.surname }.must_raise NoMethodError
+
+    # Add a column without lost data
+    Person.class_eval do
+      schema do |p|
+        p.string :name
+        p.string :surname
+      end
+    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[id name surname]
+    Person.column_names.sort.must_equal Person.db_columns
+
+    # Remove a column without lost data
+    Person.class_eval do
+      schema do |p|
+        p.string :name
+      end
+    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[id name]
+    Person.column_names.sort.must_equal Person.db_columns
+    Person.column_names.sort.must_equal Person.schema_columns
+
+    # 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
+    ActiveRecord::Base.connection.table_exists?(Post.table_name).must_equal false
+    ActiveRecord::Base.connection.table_exists?(Category.table_name).must_equal false
+    Post.auto_upgrade!; Category.auto_upgrade!
+    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
+    post.wont_respond_to :title
+  end
+
+  it 'has indexes inside model' do
+    # Check indexes
+    Animal.auto_upgrade!
+    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
+    Pet.auto_upgrade!
+    Pet.reset_column_information
+    Pet.db_columns.must_include "type"
+    Dog.auto_upgrade!
+    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
+    Cat.auto_upgrade!
+    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
+    Dog.auto_upgrade!
+    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
+    User.auto_upgrade!
+    Administrator.create(:name => "Davide", :surname => "D'Agostino")
+    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
+    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 'allows non-integer primary keys' do
+    Vegetable.auto_upgrade!
+    Vegetable.primary_key.must_equal 'latin_name'
+  end
+  
+  it 'properly creates primary key columns so that ActiveRecord uses them' do
+    Vegetable.auto_upgrade!
+    Vegetable.delete_all
+    n = 'roobus roobious'
+    v = Vegetable.new; v.latin_name = n; v.save!
+    Vegetable.find(n).must_equal v
+  end
+  
+  it 'automatically shortens long index names' do
+    AutomobileMakeModelYearVariant.auto_upgrade!
+    AutomobileMakeModelYearVariant.db_indexes.first.start_with?('index_automobile_make_model_ye').must_equal true
+  end
+  
+  it 'properly creates primary key columns that are unique' do
+    Vegetable.auto_upgrade!
+    Vegetable.delete_all
+    n = 'roobus roobious'
+    v = Vegetable.new; v.latin_name = n; v.save!
+    if sqlite?
+      flunk # segfaults
+      # lambda { v = Vegetable.new; v.latin_name = n; v.save! }.must_raise(SQLite3::ConstraintException)
+    else
+      lambda { v = Vegetable.new; v.latin_name = n; v.save! }.must_raise(ActiveRecord::RecordNotUnique)
+    end
+  end
+  
+  it 'is idempotent' do
+    ActiveRecord::Base.descendants.each do |active_record|
+      active_record.auto_upgrade!
+      active_record.reset_column_information
+      before = [ active_record.db_columns, active_record.db_indexes ]
+      active_record.auto_upgrade!
+      active_record.reset_column_information
+      [ active_record.db_columns, active_record.db_indexes ].must_equal before
+      active_record.auto_upgrade!
+      active_record.reset_column_information
+      active_record.auto_upgrade!
+      active_record.reset_column_information
+      active_record.auto_upgrade!
+      active_record.reset_column_information
+      [ active_record.db_columns, active_record.db_indexes ].must_equal before    
+    end
+  end
+  
+  private
+  
+  def sqlite?
+    ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+require 'mini_record'
+require 'minitest/autorun'
+
+module SpecHelper
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  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
+  end
+end

data/spec/sqlite3_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+# require 'logger'
+# ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
+
+require File.expand_path('../models.rb', __FILE__)
+
+require File.expand_path('../shared_examples.rb', __FILE__)

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: mini_record-compat
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Davide D'Agostino
+- Seamus Abshere
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2154134460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154134460
+description: ! "\nWith it you can add the ability to create columns outside the default
+  schema, directly\nin your model in a similar way that you just know in others projects\nlike
+  \ DataMapper or  MongoMapper.\n  "
+email:
+- d.dagostino@lipsiasoft.com
+- seamus@abshere.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- lib/mini_record.rb
+- lib/mini_record/auto_schema.rb
+- lib/mini_record/version.rb
+- mini_record.gemspec
+- spec/models.rb
+- spec/mysql_spec.rb
+- spec/postgresql_spec.rb
+- spec/shared_examples.rb
+- spec/spec_helper.rb
+- spec/sqlite3_spec.rb
+homepage: https://github.com/seamusabshere/mini_record
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Alternate gem published by Seamus Abshere for ActiveRecord 3.0 support. MiniRecord
+  is a micro gem that allow you to write schema inside your model as you can do in
+  DataMapper.
+test_files:
+- spec/models.rb
+- spec/mysql_spec.rb
+- spec/postgresql_spec.rb
+- spec/shared_examples.rb
+- spec/spec_helper.rb
+- spec/sqlite3_spec.rb