active_record_inline_schema 0.4.0 → 0.5.0

data/CHANGELOG

@@ -0,0 +1,53 @@
+## 0.5.0 / 2012-04-19
+
+* Known issues
+
+  * Custom inheritance columns will be ignored unless you have activerecord >3.2.3 (unreleased as of this writing). The bug is https://github.com/rails/rails/pull/5327
+
+* Breaking changes
+
+  * the block form (schema {}) is removed
+  * .col only accepts one column at a time
+  * .col no longer accepts :as => :references
+      was: col :group, :as => :references
+      now: col :group_id, :type => :integer
+  * .col no longer accepts :index => true
+      was: col :foo, :index => true
+      now: col :foo and then add_index :foo
+  * A whole bunch of class methods are no longer mixed into ActiveRecord::Base (see Enhancements below)
+
+* Enhancements
+
+  * Database connection no longer needs to be established before you define columns/indexes (but of course you have to connect before you auto_upgrade!)
+  * Only adds four (4) class methods to ActiveRecord::Base: .auto_upgrade!, .col, .add_index, and .inline_schema_config
+  * Tested on MRI 1.8, MRI 1.9, and JRuby 1.6.7+ across mysql, postgresql, and sqlite3
+  * Simply and DRY via a big refactor
+
+## Difference between mini_record v0.2.1 and active_record_inline_schema v0.4.0
+
+Having diverged at [this commit](https://github.com/DAddYE/mini_record/commit/55b2545f9772f7500d3782ac530b3da456f50023), I did stuff like...
+
+* didn't set primary key on table definition
+* allow custom column types
+* removed aliases
+* shorten name with zlib trick
+* allow passing create_table_options
+* default to ENGINE=InnoDB on mysql
+* detect and create table for non-standard primary key
+* move where schema inheritance columns are defined
+* removed table_definition accessor
+* allow custom column types like `varbinary`
+* more compatible with ActiveRecord 3.0 and 3.2.2
+
+## Difference between mini_record v0.2.1 and mini_record v0.3.0 (which I didn't fork)
+
+After I made this list, I decided to diverge from mini_record v0.2.1 instead of doing a pull request:
+
+* allow custom column types
+* add timestamps
+* remove unused (unmentioned) tables
+* call auto_upgrade on descendant tables
+* automagically generate fields from associations
+* revised difference checking code
+
+Pity the forker (me)!

data/Gemfile

@@ -1,10 +1,26 @@
-source "http://rubygems.org"
-
-gem "rake"
-gem "minitest"
-gem "sqlite3"
-gem 'mysql'
-gem 'sqlite3-ruby'
-gem 'pg'
+source :rubygems
 
 gemspec
+
+gem 'rake'
+gem 'minitest'
+gem 'minitest-reporters'
+
+platforms :ruby do
+  # if RUBY_VERSION >= '1.9'
+  #   gem 'debugger'
+  # else
+  #   gem 'ruby-debug19'
+  # end
+  # gem 'mysql2', '~>0.2'
+  gem 'mysql2', '>=0.3'
+  gem 'sqlite3'
+  gem 'pg'
+end
+
+platforms :jruby do
+  gem 'jruby-openssl'
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/README.md

@@ -33,6 +33,9 @@ Lots and lots of use in the [`earth` library](https://github.com/brighterplanet/
     Airport.auto_upgrade!
 
     class ApiResponse < ActiveRecord::Base
+      # store with:    self.body = Zlib::Deflate.deflate(body, Zlib::BEST_SPEED)
+      # retrieve with: Zlib::Inflate.inflate(raw_body).force_encoding 'UTF-8'
+      # just an idea!
       col :raw_body, :type => 'varbinary(16384)'
     end
     ApiResponse.auto_upgrade!
@@ -43,8 +46,12 @@ Massive thanks to DAddYE, who you follow on twitter [@daddye](http://twitter.com
 
 ## 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
+* investigate switching back to ActiveRecord::ConnectionAdapters::TableDefinition as a way of holding column and index info
+
+## History
+
+Forked from [`mini_record` version v0.2.1](https://github.com/DAddYE/mini_record) - thanks @daddye! See CHANGELOG for a rough outline of the differences.
 
 ## Copyright
 

data/active_record_inline_schema.gemspec

@@ -1,6 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "active_record_inline_schema/version"
+require File.expand_path("../lib/active_record_inline_schema/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "active_record_inline_schema"
@@ -16,10 +15,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_runtime_dependency 'lock_method'
+  s.add_runtime_dependency 'activesupport'
   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"
+  # s.add_runtime_dependency "activerecord", "~>3.0" # must use mysql2 ~>0.2 to test
+  # s.add_runtime_dependency "activerecord", "~>3.1"
+  # s.add_runtime_dependency "activerecord", "~>3.2"
 
   # dev dependencies appear to be in the Gemfile
 end

data/lib/active_record_inline_schema/active_record_class_methods.rb

@@ -0,0 +1,27 @@
+require 'thread'
+
+module ActiveRecordInlineSchema::ActiveRecordClassMethods
+  MUTEX = ::Mutex.new
+
+  def inline_schema_config
+    if superclass != ::ActiveRecord::Base
+      return base_class.inline_schema_config
+    end
+    @inline_schema_config || MUTEX.synchronize do
+      @inline_schema_config ||= ::ActiveRecordInlineSchema::Config.new self
+    end
+  end
+
+  def col(column_name, options = {})
+    inline_schema_config.add_ideal_column column_name, options
+  end
+
+  # this is not a typo - specify column name, not index name
+  def add_index(column_name, options = {})
+    inline_schema_config.add_ideal_index column_name, options
+  end
+
+  def auto_upgrade!(create_table_options = nil)
+    inline_schema_config.apply create_table_options
+  end
+end

data/lib/active_record_inline_schema/config/column.rb

@@ -0,0 +1,35 @@
+class ActiveRecordInlineSchema::Config::Column
+  DEFAULT_TYPE = :string
+
+  attr_reader :parent
+  attr_reader :name
+  attr_reader :type
+  attr_reader :options
+
+  def initialize(parent, name, options)
+    @parent = parent
+    @name = name.to_s
+    options = options.symbolize_keys
+    if options.slice(:precision, :scale).keys.length == 1
+      raise ::ArgumentError, %{[active_record_inline_schema] :precision and :scale must always be specified together}
+    end
+    @type = options.fetch(:type, DEFAULT_TYPE).to_sym
+    @options = options.except :type, :name
+  end
+
+  def inject(table_definition)
+    if type != :primary_key and table_definition.respond_to?(type)
+      table_definition.send type, name, options
+    else
+      table_definition.column name, type, options
+    end
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) and parent == other.parent and name == other.name and options == other.options
+  end
+
+  def hash
+    [parent, name, options].hash
+  end
+end

data/lib/active_record_inline_schema/config/index.rb

@@ -0,0 +1,44 @@
+require 'zlib'
+require 'thread'
+
+class ActiveRecordInlineSchema::Config::Index
+  attr_reader :parent
+  attr_reader :column_name
+  attr_reader :initial_options
+
+  delegate :connection, :to => :parent
+  delegate :model, :to => :parent
+
+  def initialize(parent, column_name, options)
+    @parent = parent
+    @column_name = column_name.to_s
+    @initial_options = options.symbolize_keys
+    @name_mutex = ::Mutex.new
+  end
+
+  def name
+    @name || @name_mutex.synchronize do
+      @name ||= begin
+        max_name_length = connection.index_name_length
+        prototype = connection.index_name model.table_name, :column => column_name
+        if prototype.length < max_name_length
+          prototype
+        else
+          prototype[0..(max_name_length-11)] + ::Zlib.crc32(prototype).to_s
+        end
+      end
+    end
+  end
+
+  def options
+    @initial_options.merge(:column_name => column_name, :name => name)
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) and parent == other.parent and column_name == other.column_name and initial_options == other.initial_options
+  end
+
+  def hash
+    [parent, column_name, initial_options].hash
+  end
+end

data/lib/active_record_inline_schema/config.rb

@@ -0,0 +1,219 @@
+require 'set'
+require 'lock_method'
+
+class ActiveRecordInlineSchema::Config
+  DEFAULT_CREATE_TABLE_OPTIONS = {
+    :mysql => 'ENGINE=InnoDB'
+  }
+
+  attr_reader :model
+  attr_reader :ideal_columns
+  attr_reader :ideal_indexes
+
+  def initialize(model)
+    @model = model
+    @ideal_columns = ::Set.new
+    @ideal_indexes = ::Set.new
+  end
+
+  def add_ideal_column(column_name, options)
+    ideal_columns.add Column.new(self, column_name, options)
+  end
+
+  def add_ideal_index(column_name, options)
+    ideal_indexes.add Index.new(self, column_name, options)
+  end
+
+  def apply(create_table_options)
+    non_standard_primary_key = if (primary_key_column = find_ideal_column(model.primary_key))
+      primary_key_column.type != :primary_key
+    end
+
+    unless non_standard_primary_key
+      add_ideal_column :id, :type => :primary_key
+    end
+
+    # Table doesn't exist, create it
+    unless connection.table_exists? model.table_name
+
+      if mysql?
+        create_table_options ||= DEFAULT_CREATE_TABLE_OPTIONS[database_type]
+      end
+
+      table_definition = ::ActiveRecord::ConnectionAdapters::TableDefinition.new connection
+      ideal_columns.each do |ideal_column|
+        ideal_column.inject table_definition
+      end
+
+      # 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 #{model.quoted_table_name} (#{table_definition.to_sql}) #{create_table_options}"
+
+      if sqlite?
+        connection.execute create_sql
+        if non_standard_primary_key
+          add_ideal_index model.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 #{model.quoted_table_name} ADD PRIMARY KEY (#{model.quoted_primary_key})"
+        end
+      elsif mysql?
+        if non_standard_primary_key
+          # only string keys are supported
+          create_sql.sub! %r{#{connection.quote_column_name(model.primary_key)} varchar\(255\)([^,\)]*)}, "#{connection.quote_column_name(model.primary_key)} varchar(255)\\1 PRIMARY KEY"
+          create_sql.sub! 'DEFAULT NULLPRIMARY KEY', 'PRIMARY KEY'
+        end
+        connection.execute create_sql
+      end
+      safe_reset_column_information
+    end
+
+    # Add to schema inheritance column if necessary
+    if model.descendants.any? and not find_ideal_column(model.inheritance_column)
+      add_ideal_column model.inheritance_column, :type => :string
+    end
+
+    # Remove fields from db no longer in schema
+    existing_column_names.reject do |existing_column_name|
+      find_ideal_column existing_column_name
+    end.each do |existing_column_name|
+      connection.remove_column model.table_name, existing_column_name
+    end
+
+    # Add fields to db new to schema
+    ideal_columns.reject do |ideal_column|
+      find_existing_column ideal_column.name
+    end.each do |ideal_column|
+      connection.add_column model.table_name, ideal_column.name, ideal_column.type, ideal_column.options
+    end
+
+    # Change attributes of existent columns
+    existing_columns_hash.each do |existing_column_name, existing_column|
+      next if existing_column_name.to_s == model.primary_key.to_s
+      ideal_column = find_ideal_column existing_column_name
+      option_changes = {}
+
+      # First, check if the field type changed
+      type_changed = !([existing_column.type.to_s, existing_column.sql_type.to_s].include?(ideal_column.type.to_s))
+
+      # Next, iterate through our extended attributes, looking for any differences
+      # This catches stuff like :null, :precision, etc
+      ideal_column.options.except(:base).each do |k, v|
+        if !v.nil? and v != existing_column.send(k)
+          option_changes[k] = v
+        end
+      end
+
+      # Change the column if applicable
+      if type_changed or option_changes.any?
+        connection.change_column model.table_name, existing_column_name, ideal_column.type, option_changes
+      end
+    end
+
+    # Remove old index
+    existing_index_names.reject do |existing_index_name|
+      find_ideal_index existing_index_name
+    end.each do |existing_index_name|
+      connection.remove_index model.table_name, :name => existing_index_name
+    end
+
+    # Add indexes
+    ideal_indexes.reject do |ideal_index|
+      find_existing_index ideal_index.name
+    end.each do |ideal_index|
+      connection.add_index model.table_name, ideal_index.column_name, ideal_index.options
+    end
+
+    safe_reset_column_information
+  end
+  lock_method :apply, :ttl => 60
+
+  def as_lock
+    if connection.respond_to?(:current_database)
+      [connection.current_database, model.name]
+    else
+      model.name
+    end
+  end
+
+  def clear
+    @ideal_columns = ::Set.new
+    @ideal_indexes = ::Set.new
+  end
+  lock_method :clear, :ttl => 60
+
+  private
+
+  def find_ideal_column(name)
+    ideal_columns.detect { |ideal_column| ideal_column.name.to_s == name.to_s }
+  end
+
+  def find_existing_column(name)
+    existing_column_names.detect { |existing_column_name| existing_column_name.to_s == name.to_s }
+  end
+
+  def find_ideal_index(name)
+    ideal_indexes.detect { |ideal_index| ideal_index.name.to_s == name.to_s }
+  end
+
+  def find_existing_index(name)
+    existing_index_names.detect { |existing_index_name| existing_index_name.to_s == name.to_s }
+  end
+
+  def safe_reset_column_information
+    if connection.respond_to?(:schema_cache)
+      connection.schema_cache.clear!
+    end
+    model.reset_column_information
+    model.descendants.each do |descendant|
+      descendant.reset_column_information
+    end
+  end
+
+  def existing_index_names
+    safe_reset_column_information
+    connection.indexes(model.table_name).map(&:name)
+  end
+
+  def existing_column_names
+    safe_reset_column_information
+    model.column_names
+  end
+
+  def existing_columns_hash
+    safe_reset_column_information
+    model.columns_hash
+  end
+
+  def connection
+    unless model.connection.active?
+      raise ::RuntimeError, %{[active_record_inline_schema] Must connect to database before running ActiveRecord::Base.auto_upgrade!}
+    end
+    model.connection
+  end
+
+  def database_type
+    if mysql?
+      :mysql
+    elsif postgresql?
+      :postgresql
+    elsif sqlite?
+      :sqlite
+    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
+end

data/lib/active_record_inline_schema/version.rb

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

data/lib/active_record_inline_schema.rb

@@ -1,5 +1,12 @@
-require 'rubygems' unless defined?(Gem)
+require 'active_support/core_ext'
 require 'active_record'
-require 'active_record_inline_schema/auto_schema'
 
-ActiveRecord::Base.send(:include, ActiveRecordInlineSchema::AutoSchema)
+require 'active_record_inline_schema/config'
+require 'active_record_inline_schema/config/column'
+require 'active_record_inline_schema/config/index'
+require 'active_record_inline_schema/active_record_class_methods'
+
+module ActiveRecordInlineSchema
+end
+
+ActiveRecord::Base.extend ActiveRecordInlineSchema::ActiveRecordClassMethods

data/spec/models.rb

@@ -2,9 +2,7 @@
 
 class Person < ActiveRecord::Base
   include SpecHelper
-  schema do |s|
-    s.string :name
-  end
+  col :name
 end
 
 class Post < ActiveRecord::Base
@@ -12,7 +10,7 @@ class Post < ActiveRecord::Base
 
   col :title
   col :body
-  col :category, :as => :references
+  col :category_id, :type => :integer
   belongs_to :category
 end
 
@@ -26,14 +24,16 @@ end
 class Animal < ActiveRecord::Base
   include SpecHelper
 
-  col :name, :index => true
+  col :name
+  add_index :name
   add_index :id
 end
 
 class Pet < ActiveRecord::Base
   include SpecHelper
 
-  col :name, :index => true
+  col :name
+  add_index :name
 end
 class Dog < Pet; end
 class Cat < Pet; end
@@ -56,8 +56,8 @@ class Gender < ActiveRecord::Base
 end
 
 class User < ActiveRecord::Base
+  self.inheritance_column = 'role'
   include SpecHelper
-  self.inheritance_column = 'role' # messed up in 3.2.2
   col :name
   col :surname
   col :role
@@ -67,8 +67,10 @@ class Customer < User; end
 
 class Fake < ActiveRecord::Base
   include SpecHelper
-  col :name, :surname
-  col :category, :group, :as => :references
+  col :name
+  col :surname
+  col :category_id, :type => :integer
+  col :group_id, :type => :integer
 end
 
 class AutomobileMakeModelYearVariant < ActiveRecord::Base

data/spec/mysql_spec.rb

@@ -16,7 +16,7 @@ system %{#{cmd} -e "drop database #{database}"}
 system %{#{cmd} -e "create database #{database}"}
 
 ActiveRecord::Base.establish_connection(
-  'adapter' => 'mysql',
+  'adapter' => (RUBY_PLATFORM == 'java' ? 'mysql' : 'mysql2'),
   'encoding' => 'utf8',
   'database' => database,
   'username' => username,
@@ -26,6 +26,6 @@ ActiveRecord::Base.establish_connection(
 # require 'logger'
 # ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
 
-require File.expand_path('../models.rb', __FILE__)
+# require File.expand_path('../models.rb', __FILE__)
 
 require File.expand_path('../shared_examples.rb', __FILE__)

data/spec/postgresql_spec.rb

@@ -13,13 +13,11 @@ ActiveRecord::Base.establish_connection(
   'adapter' => 'postgresql',
   'encoding' => 'utf8',
   'database' => database,
-  'username' => username,
+  '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

@@ -5,61 +5,9 @@ describe ActiveRecordInlineSchema do
     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
+    (!!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
@@ -74,10 +22,10 @@ describe ActiveRecordInlineSchema do
 
 
     # Remove a column
-    Post.reset_table_definition!
+    Post.inline_schema_config.clear
     Post.class_eval do
       col :name
-      col :category, :as => :references
+      col :category_id, :type => :integer
     end
     Post.auto_upgrade!
     post = Post.first
@@ -90,19 +38,21 @@ describe ActiveRecordInlineSchema do
     # Check indexes
     Animal.auto_upgrade!
     Animal.db_indexes.size.must_be :>, 0
-    Animal.db_indexes.must_equal Animal.indexes.keys.sort
+    Animal.db_indexes.must_equal Animal.schema_indexes
 
     indexes_was = Animal.db_indexes
 
     # Remove an index
-    Animal.indexes.delete(indexes_was.pop)
+    target = indexes_was.pop
+    Animal.inline_schema_config.ideal_indexes.delete_if { |ideal_index| ideal_index.name.to_s == target.to_s }
     Animal.auto_upgrade!
-    Animal.indexes.keys.sort.must_equal indexes_was
+    Animal.schema_indexes.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
+      col :category_id, :type => :integer
+      add_index :category_id
     end
     Animal.auto_upgrade!
     Animal.db_columns.must_include "category_id"
@@ -111,7 +61,7 @@ describe ActiveRecordInlineSchema do
 
   it 'works with STI' do
     Pet.auto_upgrade!
-    Pet.reset_column_information
+    Pet.safe_reset_column_information
     Pet.db_columns.must_include "type"
     Dog.auto_upgrade!
     Pet.db_columns.must_include "type"
@@ -129,8 +79,7 @@ describe ActiveRecordInlineSchema do
     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.schema_indexes.must_equal Pet.schema_indexes
     Dog.class_eval do
       col :bau
     end
@@ -142,6 +91,7 @@ describe ActiveRecordInlineSchema do
 
   it 'works with custom inheritance column' do
     User.auto_upgrade!
+    User.inheritance_column.must_equal 'role' # known to fail on rails 3
     Administrator.create(:name => "Davide", :surname => "D'Agostino")
     Customer.create(:name => "Foo", :surname => "Bar")
     Administrator.count.must_equal 1
@@ -149,8 +99,8 @@ describe ActiveRecordInlineSchema do
     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"
+    User.find_by_name('Davide').role.must_equal "Administrator"
+    User.find_by_name('Foo').role.must_equal "Customer"
   end
 
   it 'allow multiple columns definitions' do
@@ -202,17 +152,17 @@ describe ActiveRecordInlineSchema do
   it 'is idempotent' do
     ActiveRecord::Base.descendants.each do |active_record|
       active_record.auto_upgrade!
-      active_record.reset_column_information
+      active_record.safe_reset_column_information
       before = [ active_record.db_columns, active_record.db_indexes ]
       active_record.auto_upgrade!
-      active_record.reset_column_information
+      active_record.safe_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.safe_reset_column_information
       active_record.auto_upgrade!
-      active_record.reset_column_information
+      active_record.safe_reset_column_information
       active_record.auto_upgrade!
-      active_record.reset_column_information
+      active_record.safe_reset_column_information
       [ active_record.db_columns, active_record.db_indexes ].must_equal before    
     end
   end

data/spec/spec_helper.rb

@@ -1,7 +1,19 @@
-require 'rubygems' unless defined?(Gem)
+require 'rubygems'
 require 'bundler/setup'
-require 'active_record_inline_schema'
+
+if ::Bundler.definition.specs['debugger'].first
+  require 'debugger'
+elsif ::Bundler.definition.specs['ruby-debug'].first
+  require 'ruby-debug'
+end
+
+require 'minitest/spec'
 require 'minitest/autorun'
+require 'minitest/reporters'
+MiniTest::Unit.runner = MiniTest::SuiteRunner.new
+MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new
+
+require 'active_record_inline_schema'
 
 # require 'logger'
 # ActiveRecord::Base.logger = Logger.new($stderr)
@@ -22,7 +34,20 @@ module SpecHelper
     end
 
     def schema_columns
-      table_definition.columns.map { |c| c.name.to_s }.sort
+      inline_schema_config.ideal_columns.map { |c| c.name.to_s }.sort
+    end
+
+    def schema_indexes
+      inline_schema_config.ideal_indexes.map { |c| c.name.to_s }.sort
+    end
+
+    def safe_reset_column_information
+      if connection.respond_to?(:schema_cache)
+        connection.schema_cache.clear!
+      end
+      reset_column_information
     end
   end
 end
+
+require File.expand_path('../models.rb', __FILE__)

data/spec/sqlite3_spec.rb

@@ -5,6 +5,4 @@ ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':me
 # 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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_inline_schema
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,43 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-26 00:00:00.000000000 Z
+date: 2012-04-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: lock_method
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2166623420 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,7 +54,12 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2166623420
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
 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.
@@ -35,12 +72,16 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG
 - 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/active_record_class_methods.rb
+- lib/active_record_inline_schema/config.rb
+- lib/active_record_inline_schema/config/column.rb
+- lib/active_record_inline_schema/config/index.rb
 - lib/active_record_inline_schema/version.rb
 - spec/models.rb
 - spec/mysql_spec.rb
@@ -68,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Define table structure (columns and indexes) inside your ActiveRecord models

data/lib/active_record_inline_schema/auto_schema.rb

@@ -1,229 +0,0 @@
-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