active_record_inline_schema 0.4.0

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:
+    - seamus@abshere.net

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "minitest"
+gem "sqlite3"
+gem 'mysql'
+gem 'sqlite3-ruby'
+gem 'pg'
+
+gemspec

data/README.md

@@ -0,0 +1,65 @@
+# ActiveRecordInlineSchema
+
+Define table structure (columns and indexes) inside your ActiveRecord models like you can do in migrations. Also similar to DataMapper inline schema syntax.
+
+Specify columns like you would with ActiveRecord migrations and then run .auto_upgrade! Based on the mini_record gem from Davide D'Agostino, it adds fewer aliases, doesn't create timestamps and relationship columns automatically.
+
+## Production use
+
+Over 2 years in [Brighter Planet's environmental impact API](http://impact.brighterplanet.com) and [reference data service](http://data.brighterplanet.com).
+
+Lots and lots of use in the [`earth` library](https://github.com/brighterplanet/earth).
+
+## Examples
+
+    class Breed < ActiveRecord::Base
+      col :species_name
+      col :weight, :type => :float
+      col :weight_units
+    end
+    Breed.auto_upgrade!
+
+    class Airport < ActiveRecord::Base
+      self.primary_key = "iata_code"
+      belongs_to :country, :foreign_key => 'country_iso_3166_code', :primary_key => 'iso_3166_code'
+      col :iata_code
+      col :name
+      col :city
+      col :country_name
+      col :country_iso_3166_code
+      col :latitude, :type => :float
+      col :longitude, :type => :float
+    end
+    Airport.auto_upgrade!
+
+    class ApiResponse < ActiveRecord::Base
+      col :raw_body, :type => 'varbinary(16384)'
+    end
+    ApiResponse.auto_upgrade!
+
+## Credits
+
+Massive thanks to DAddYE, who you follow on twitter [@daddye](http://twitter.com/daddye) and look at his site at [daddye.it](http://www.daddye.it)
+
+## TODO
+
+* merge back into mini_record? they make some choices (automatically creating relationships, mixing in lots of aliases, etc.) that I don't need
+* make the documentation as good as mini_record
+
+## Copyright
+
+Copyright 2012 Seamus Abshere
+
+Adapted from [mini_record](https://github.com/DAddYE/mini_record), which is copyright 2011 Davide D'Agostino
+
+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,21 @@
+require "bundler/gem_tasks"
+require "rake"
+require "rake/testtask"
+
+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 DB_ADAPTER=#{db_adapter} TEST=spec/#{db_adapter}_spec.rb`
+  end
+end
+
+task :default => :test_each_db_adapter
+task :spec => :test_each_db_adapter

data/active_record_inline_schema.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_record_inline_schema/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_record_inline_schema"
+  s.version     = ActiveRecordInlineSchema::VERSION
+  s.authors     = ["Seamus Abshere", "Davide D'Agostino"]
+  s.email       = ["seamus@abshere.net", "d.dagostino@lipsiasoft.com"]
+  s.homepage    = "https://github.com/seamusabshere/active_record_inline_schema"
+  s.summary     = %q{Define table structure (columns and indexes) inside your ActiveRecord models like you can do in migrations. Also similar to DataMapper inline schema syntax.}
+  s.description = %q{Specify columns like you would with ActiveRecord migrations and then run .auto_upgrade! Based on the mini_record gem from Davide D'Agostino, it adds fewer aliases, doesn't create timestamps and relationship columns automatically.}
+
+  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"
+  # s.add_runtime_dependency "activerecord", "3.0.12"
+  # s.add_runtime_dependency "activerecord", "3.1.3"
+  # s.add_runtime_dependency "activerecord", "3.2.2"
+
+  # dev dependencies appear to be in the Gemfile
+end

data/lib/active_record_inline_schema.rb

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

data/lib/active_record_inline_schema/auto_schema.rb

@@ -0,0 +1,229 @@
+require 'zlib'
+module ActiveRecordInlineSchema
+  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|
+          if table_definition.respond_to?(type)
+            table_definition.send(type, column_name, options)
+          else
+            table_definition.column(column_name, type, options)
+          end
+          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
+
+      def reset_table_definition!
+        @_table_definition = nil
+      end
+
+      def schema
+        reset_table_definition!
+        yield table_definition
+        table_definition
+      end
+
+      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
+
+      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 #{quoted_table_name} (#{table_definition.to_sql}) #{create_table_options}"
+          
+          if sqlite?
+            connection.execute create_sql
+            if non_standard_primary_key
+              add_index primary_key, :unique => true
+            end
+          elsif postgresql?
+            connection.execute create_sql
+            if non_standard_primary_key
+              # 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})"
+            end
+          elsif mysql?
+            if non_standard_primary_key
+              # only string keys are supported
+              create_sql.sub! %r{#{connection.quote_column_name(primary_key)} varchar\(255\)([^,\)]*)}, "#{connection.quote_column_name(primary_key)} varchar(255)\\1 PRIMARY KEY"
+              create_sql.sub! 'DEFAULT NULLPRIMARY KEY', 'PRIMARY KEY'
+            end
+            connection.execute create_sql
+          end
+
+          if connection.respond_to?(:schema_cache)
+            connection.schema_cache.clear!
+          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) and (fields_in_schema[field].type.to_sym != fields_in_db[field].sql_type.to_sym)
+              # $stderr.puts "A(#{field}) - #{fields_in_schema[field].type.to_sym}"
+              # $stderr.puts "B(#{field}) - #{fields_in_db[field].type.to_sym} - #{fields_in_db[field].sql_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)
+                # $stderr.puts "C(#{att}) - #{value.inspect}"
+                # $stderr.puts "D(#{att}) - #{fields_in_db[field].send(att).inspect}"
+                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
+        if connection.respond_to?(:schema_cache)
+          connection.schema_cache.clear!
+        end
+        reset_column_information
+      end
+    end # ClassMethods
+  end # AutoSchema
+end # ActiveRecordInlineSchema

data/lib/active_record_inline_schema/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordInlineSchema
+  VERSION = "0.4.0"
+end

data/spec/models.rb

@@ -0,0 +1,93 @@
+# 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
+
+  col :title
+  col :body
+  col :category, :as => :references
+  belongs_to :category
+end
+
+class Category < ActiveRecord::Base
+  include SpecHelper
+
+  col :title
+  has_many :posts
+end
+
+class Animal < ActiveRecord::Base
+  include SpecHelper
+
+  col :name, :index => true
+  add_index :id
+end
+
+class Pet < ActiveRecord::Base
+  include SpecHelper
+
+  col :name, :index => true
+end
+class Dog < Pet; end
+class Cat < Pet; end
+
+class Vegetable < ActiveRecord::Base
+  include SpecHelper
+
+  self.primary_key = 'latin_name'
+  
+  col :latin_name
+  col :common_name
+end
+
+class Gender < ActiveRecord::Base
+  include SpecHelper
+
+  self.primary_key = 'name'
+  
+  col :name
+end
+
+class User < ActiveRecord::Base
+  include SpecHelper
+  self.inheritance_column = 'role' # messed up in 3.2.2
+  col :name
+  col :surname
+  col :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
+
+case ENV['DB_ADAPTER']
+when 'mysql'
+  class CustomMysql < ActiveRecord::Base
+    include SpecHelper
+    col :varb, :type => 'varbinary(255)'
+    col :varc, :type => 'varchar(255)'
+  end
+when 'postgresql'
+  class CustomPostgresql < ActiveRecord::Base
+    include SpecHelper
+    col :inet, :type => 'inet'
+    col :bytea, :type => 'bytea'
+  end
+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_active_record_inline_schema'
+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_active_record_inline_schema'
+
+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,240 @@
+describe ActiveRecordInlineSchema do
+  before do
+    ActiveRecord::Base.descendants.each do |active_record|
+      ActiveRecord::Base.connection.drop_table active_record.table_name rescue nil
+    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 'properly creates tables with one column, a string primary key' do
+    Gender.auto_upgrade!
+    Gender.column_names.must_equal ['name']
+  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
+
+  case ENV['DB_ADAPTER']
+  when 'mysql'
+    it "takes custom types" do
+      CustomMysql.auto_upgrade!
+      CustomMysql.columns_hash['varb'].sql_type.must_equal 'varbinary(255)'
+      CustomMysql.columns_hash['varc'].sql_type.must_equal 'varchar(255)'
+    end
+  when 'postgresql'
+    it "takes custom types" do
+      CustomPostgresql.auto_upgrade!
+      CustomPostgresql.columns_hash['inet'].sql_type.must_equal 'inet'
+      CustomPostgresql.columns_hash['bytea'].sql_type.must_equal 'bytea'
+    end
+  end
+  
+  private
+  
+  def sqlite?
+    ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+require 'active_record_inline_schema'
+require 'minitest/autorun'
+
+# require 'logger'
+# ActiveRecord::Base.logger = Logger.new($stderr)
+# ActiveRecord::Base.logger.level = Logger::DEBUG
+
+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: active_record_inline_schema
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Seamus Abshere
+- Davide D'Agostino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2166623420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2166623420
+description: Specify columns like you would with ActiveRecord migrations and then
+  run .auto_upgrade! Based on the mini_record gem from Davide D'Agostino, it adds
+  fewer aliases, doesn't create timestamps and relationship columns automatically.
+email:
+- seamus@abshere.net
+- d.dagostino@lipsiasoft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- active_record_inline_schema.gemspec
+- lib/active_record_inline_schema.rb
+- lib/active_record_inline_schema/auto_schema.rb
+- lib/active_record_inline_schema/version.rb
+- 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/active_record_inline_schema
+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.15
+signing_key: 
+specification_version: 3
+summary: Define table structure (columns and indexes) inside your ActiveRecord models
+  like you can do in migrations. Also similar to DataMapper inline schema syntax.
+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
+has_rdoc: