mini_record 0.2.1 → 0.3.0.a

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rvmrc
+*.swp
+*.swo

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

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

data/README.md

@@ -1,3 +1,6 @@
+[![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
@@ -9,7 +12,7 @@ My inspiration come from this handy [project](https://github.com/pjhyett/auto_mi
 
 * 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!
+* Auto upgrade your schema, so if you know what you are doing you don't lose your existing data!
 * Add, Remove, Change Columns; Add, Remove, Change indexes
 
 ## Instructions
@@ -48,8 +51,8 @@ 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, :primary_key, :timestamp
+:primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, 
+:date, :binary, :boolean, :references, :belongs_to, :timestamp
 ```
 
 You can provide others ActiveRecord options like:
@@ -64,7 +67,7 @@ class Foo < ActiveRecord::Base
 end
 ```
 
-See [ActiveRecord::TableDefinition](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html) 
+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.
@@ -74,6 +77,34 @@ Indexes and columns present in the db but **not** in your model schema will be *
 
 MiniRecord as ActiveRecord support STI plus some goodness, see our specs for more details.
 
+### ActiveRecord Relations
+
+MiniRecord has built-in support of belongs_to, belongs_to polymorphic and habtm relations. Just declaring these in your model will generate the necessary id columns, indexes and join tables
+
+#### belongs_to
+```ruby
+class Address < ActiveRecord::Base
+  belongs_to :person
+end
+```
+Will result in a person_id column (you can override with the `foreign_key` option) which is indexed
+
+#### belongs_to (polymorphic)
+```ruby
+class Address < ActiveRecord::Base
+  belongs_to :addressable, :polymorphic => true
+end
+```
+Will result in addressable id and type columns with composite indexes `add_index(:addresses), [:addressable_id, :addressable_type]`
+
+#### habtm
+```ruby
+class Address < ActiveRecord::Base
+  has_and_belongs_to_many :people
+end
+```
+Will generate a "addresses_people" join table and index the id columns
+
 ### Adding a new column
 
 Super easy, open your model and just add it:
@@ -136,8 +167,8 @@ end
 
 ## Warnings
 
-This software is not yet tested in a production project, now is only heavy development and if you can
-pleas fork it, find bug add a spec and then come back with a pull request. Thanks!
+This software is not super well tested in a production project.
+Im stated to using it in two customer's projects without any problem.
 
 ## Author
 
@@ -157,4 +188,4 @@ The above copyright notice and this permission notice shall be included in all c
 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.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/mini_record/auto_schema.rb

@@ -6,6 +6,10 @@ module MiniRecord
 
     module ClassMethods
 
+      def schema_tables
+        @@_schema_tables ||= []
+      end
+
       def table_definition
         return superclass.table_definition unless superclass == ActiveRecord::Base
 
@@ -31,12 +35,12 @@ module MiniRecord
           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)
+          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
@@ -45,6 +49,10 @@ module MiniRecord
       alias :field :col
       alias :attribute :col
 
+      def timestamps
+        col :created_at, :updated_at, :as => :datetime
+      end
+
       def reset_table_definition!
         @_table_definition = nil
       end
@@ -74,99 +82,149 @@ module MiniRecord
         false
       end
 
+      def clear_tables!
+        # Drop unsued tables
+        (connection.tables - schema_tables).each do |name|
+          connection.drop_table(name)
+          schema_tables.delete(name)
+        end
+      end
+
       def auto_upgrade!
         return unless connection?
 
-        # Table doesn't exist, create it
-        unless connection.tables.include?(table_name)
-          # TODO: Add to create_table options
-          class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
-          connection.table_definition = table_definition
-          connection.create_table(table_name)
-          connection.table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
-        end
+        if self == ActiveRecord::Base
+          descendants.each(&:auto_upgrade!)
+          clear_tables!
+        else
+          # Table doesn't exist, create it
+          unless connection.tables.include?(table_name)
+            # TODO: create_table options
+            class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
+            connection.table_definition = table_definition
+            connection.create_table(table_name)
+            connection.table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+          end
 
-        # Grab database columns
-        fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
-          hash[column.name] = column
-          hash
-        end
+          # Add this to our schema tables
+          schema_tables << table_name unless schema_tables.include?(table_name)
 
-        # Grab new schema
-        fields_in_schema = table_definition.columns.inject({}) do |hash, column|
-          hash[column.name.to_s] = column
-          hash
-        end
+          # Grab database columns
+          fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
+            hash[column.name] = column
+            hash
+          end
 
-        # Add to schema inheritance column if necessary
-        if descendants.present? && !fields_in_schema.include?(inheritance_column.to_s)
-          table_definition.column inheritance_column, :string
-        end
+          # Generate fields from associations
+          if reflect_on_all_associations.any?
+            reflect_on_all_associations.each do |association|
+              id_key = if association.options[:foreign_key]
+                association.options[:foreign_key]
+              else
+                "#{association.name.to_s}_id".to_sym
+              end
+              type_key = "#{association.name.to_s}_type".to_sym
+              case association.macro
+              when :belongs_to
+                table_definition.send(:integer, id_key)
+                if association.options[:polymorphic]
+                  table_definition.send(:string, type_key)
+                  add_index [id_key, type_key]
+                else
+                  add_index id_key
+                end
+              when :has_and_belongs_to_many
+                table = [table_name, association.name.to_s].sort.join("_")
+                index = ""
+                unless connection.tables.include?(table)
+                  connection.create_table(table)
+                  connection.add_column table, "#{table.singularize}_id", :integer
+                  connection.add_column table, "#{association.name.to_s.singularize}_id", :integer
+                  connection.add_index table.to_sym, ["#{table.singularize}_id", "#{association.name.to_s.singularize}_id"].sort.map(&:to_sym), association.options
+                end
+                # Add join table to our schema tables
+                schema_tables << table unless schema_tables.include?(table)
+              end
+            end
+          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 to schema inheritance column if necessary
+          if descendants.present? && !fields_in_schema.include?(inheritance_column.to_s)
+            table_definition.column inheritance_column, :string
+          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
+          # 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
 
-        # 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 = {}
+          # 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
 
-            # 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
+          # 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 = {}
 
-            # 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
+              # 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
-            end
 
-            # Change the column if applicable
-            connection.change_column table_name, field, new_type, new_attr if changed
+              # 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
-        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
+          # Remove old index
+          # TODO: remove index from habtm t
+          indexes_in_db = connection.indexes(table_name).map(&:name)
+          (indexes_in_db - indexes.keys).each do |name|
+            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)
+          # 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
 
-        # Reload column information
-        reset_column_information
       end
     end # ClassMethods
   end # AutoSchema

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.2.1"
+  VERSION = "0.3.0.a"
 end

data/mini_record.gemspec

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

data/spec/mini_record_spec.rb

@@ -1,26 +1,34 @@
 require File.expand_path('../spec_helper.rb', __FILE__)
-require File.expand_path('../models.rb', __FILE__)
 
 describe MiniRecord do
 
+  before do
+    ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) }
+    ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
+    load File.expand_path('../models.rb', __FILE__)
+    ActiveRecord::Base.auto_upgrade!
+  end
+
   it 'has #schema inside model' do
-    # 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.must_equal Person.db_columns
-    Person.column_names.must_equal Person.schema_columns
+    Person.db_columns.sort.must_equal %w[created_at id name updated_at]
+    Person.column_names.sort.must_equal Person.db_columns.sort
+    Person.column_names.sort.must_equal Person.schema_columns.sort
     person = Person.create(:name => 'foo')
     person.name.must_equal 'foo'
     proc { person.surname }.must_raise NoMethodError
 
+    # Test the timestamp columns exist
+    person.must_respond_to :created_at
+    person.must_respond_to :updated_at
+
     # Add a column without lost data
     Person.class_eval do
       schema do |p|
         p.string :name
         p.string :surname
       end
+      timestamps
     end
     Person.auto_upgrade!
     Person.count.must_equal 1
@@ -28,22 +36,23 @@ describe MiniRecord do
     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.must_equal Person.db_columns
+    Person.db_columns.sort.must_equal %w[created_at id name surname updated_at]
+    # Person.column_names.must_equal Person.db_columns
 
     # Remove a column without lost data
     Person.class_eval do
       schema do |p|
         p.string :name
       end
+      timestamps
     end
     Person.auto_upgrade!
     person = Person.last
     person.name.must_equal 'foo'
     proc { person.surname }.must_raise NoMethodError
-    Person.db_columns.sort.must_equal %w[id name]
-    Person.column_names.must_equal Person.db_columns
-    Person.column_names.must_equal Person.schema_columns
+    Person.db_columns.sort.must_equal %w[created_at id name updated_at]
+    Person.column_names.sort.must_equal Person.db_columns.sort
+    Person.column_names.sort.must_equal Person.schema_columns.sort
 
     # Change column without lost data
     Person.class_eval do
@@ -56,9 +65,6 @@ describe MiniRecord do
   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
 
@@ -81,12 +87,11 @@ describe MiniRecord do
     post = Post.first
     post.name.must_be_nil
     post.category.must_equal category
-    post.wont_respond_to :title
+    proc { post.title }.must_raise ActiveModel::MissingAttributeError
   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
 
@@ -110,11 +115,9 @@ describe MiniRecord do
   it 'works with STI' do
     class Dog < Pet; end
     class Cat < Pet; end
-    Pet.auto_upgrade!
+    ActiveRecord::Base.auto_upgrade!
 
     # Check inheritance column
-    Pet.db_columns.wont_include "type"
-    Dog.auto_upgrade!
     Pet.db_columns.must_include "type"
 
     # Now, let's we know if STI is working
@@ -126,7 +129,6 @@ describe MiniRecord do
     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?
@@ -135,10 +137,11 @@ describe MiniRecord do
     Dog.class_eval do
       col :bau
     end
-    Dog.auto_upgrade!
+    ActiveRecord::Base.auto_upgrade!
+    Dog.schema_columns.must_include "bau"
     Pet.db_columns.must_include "bau"
-    Dog.new.must_respond_to :bau
-    Cat.new.must_respond_to :bau
+    # Dog.new.must_respond_to :bau
+    # Cat.new.must_respond_to :bau
   end
 
   it 'works with custom inheritance column' do
@@ -146,13 +149,15 @@ describe MiniRecord do
       col :name
       col :surname
       col :role
-      set_inheritance_column :role
+      def self.inheritance_column; 'role'; end
     end
+
     class Administrator < User; end
     class Customer < User; end
 
     User.auto_upgrade!
-    Administrator.create(:name => "Davide", :surname => "D'Agostino")
+    User.inheritance_column.must_equal 'role'
+    Administrator.create(:name => "Davide", :surname => 'DAddYE')
     Customer.create(:name => "Foo", :surname => "Bar")
     Administrator.count.must_equal 1
     Administrator.first.name.must_equal "Davide"
@@ -176,4 +181,103 @@ describe MiniRecord do
     fake.category_id.must_equal 1
     fake.group_id.must_equal 2
   end
+
+  it 'creates a column and index based on belongs_to relation' do
+    Article.create(:title => 'Hello', :publisher_id => 1)
+    Article.first.tap do |a|
+      a.title.must_equal 'Hello'
+      a.publisher_id.must_equal 1
+    end
+    Article.db_indexes.must_include 'index_articles_on_publisher_id'
+    # Ensure that associated field/index is not deleted on upgrade
+    Article.auto_upgrade!
+    Article.first.publisher_id.must_equal 1
+    Article.db_indexes.must_include 'index_articles_on_publisher_id'
+  end
+
+  it 'removes a column and index when belongs_to relation is removed' do
+    class Foo < ActiveRecord::Base
+      key :name
+      belongs_to :image, :polymorphic => true
+    end
+    Foo.auto_upgrade!
+    Foo.db_columns.must_include 'name'
+    Foo.db_columns.must_include 'image_type'
+    Foo.db_columns.must_include 'image_id'
+    Foo.db_indexes.must_include 'index_foos_on_image_id_and_image_type'
+    Foo.class_eval do
+      reset_table_definition!
+      reflections.clear
+      indexes.clear
+      key :name
+    end
+    Foo.auto_upgrade!
+    Foo.db_columns.must_include 'name'
+    Foo.db_columns.wont_include 'image_type'
+    Foo.db_columns.wont_include 'image_id'
+    Foo.db_indexes.must_be_empty
+  end
+
+  it 'creates columns and index based on belongs_to polymorphic relation' do
+    Attachment.create(:name => 'Avatar', :attachable_id => 1, :attachable_type => 'Post')
+    Attachment.first.tap do |attachment|
+      attachment.name.must_equal 'Avatar'
+      attachment.attachable_id.must_equal 1
+      attachment.attachable_type.must_equal 'Post'
+    end
+    index = 'index_attachments_on_attachable_id_and_attachable_type'
+    Attachment.db_indexes.must_include index
+    # Ensure that associated fields/indexes are not deleted on subsequent upgrade
+    Attachment.auto_upgrade!
+    Attachment.first.attachable_id.must_equal 1
+    Attachment.first.attachable_type.must_equal 'Post'
+    Attachment.db_indexes.must_include index
+  end
+
+  it 'creates a join table with indexes for has_and_belongs_to_many relations' do
+    tables = Tool.connection.tables
+    tables.must_include('purposes_tools')
+    index = 'index_purposes_tools_on_purpose_id_and_purposes_tool_id'
+    Tool.connection.indexes('purposes_tools').map(&:name).must_include index
+    # Ensure that join table is not deleted on subsequent upgrade
+    Tool.auto_upgrade!
+    tables.must_include('purposes_tools')
+    Tool.connection.indexes('purposes_tools').map(&:name).must_include index
+  end
+
+  it 'drops join table if has_and_belongs_to_many relation is deleted' do
+    Tool.schema_tables.delete('purposes_tools')
+    ActiveRecord::Base.schema_tables.wont_include('purposes_tools')
+    ActiveRecord::Base.clear_tables!
+    Tool.connection.tables.wont_include('purposes_tools')
+  end
+
+  it 'should support #belongs_to with :class_name' do
+    Task.schema_columns.must_include 'author_id'
+    Task.db_columns.must_include 'author_id'
+  end
+
+  it 'should support #belongs_to with :foreign_key' do
+    Activity.schema_columns.must_include 'custom_id'
+    Activity.db_columns.must_include 'custom_id'
+  end
+
+  it 'should memonize in schema relationships' do
+    conn = ActiveRecord::Base.connection
+    conn.create_table('foos')
+    conn.add_column :foos, :name, :string
+    conn.add_column :foos, :bar_id, :integer
+    conn.add_index  :foos, :bar_id
+    class Foo < ActiveRecord::Base
+      col :name
+      belongs_to :bar
+    end
+    Foo.db_columns.must_include 'name'
+    Foo.db_columns.must_include 'bar_id'
+    Foo.db_indexes.must_include 'index_foos_on_bar_id'
+    Foo.auto_upgrade!
+    Foo.schema_columns.must_include 'name'
+    Foo.schema_columns.must_include 'bar_id'
+    Foo.indexes.must_include 'index_foos_on_bar_id'
+  end
 end

data/spec/models.rb

@@ -1,38 +1,14 @@
-require 'logger'
-
 ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
 # ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stdout)
 
-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
-
 class Person < ActiveRecord::Base
-  include SpecHelper
   schema do |s|
     s.string :name
   end
+  timestamps
 end
 
 class Post < ActiveRecord::Base
-  include SpecHelper
-
   key :title
   key :body
   key :category, :as => :references
@@ -40,21 +16,52 @@ class Post < ActiveRecord::Base
 end
 
 class Category < ActiveRecord::Base
-  include SpecHelper
-
   key :title
+  has_many :articles
   has_many :posts
+  has_many :items
 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 Tool < ActiveRecord::Base
+  has_and_belongs_to_many :purposes
+end
+
+class Purpose < ActiveRecord::Base
+  has_and_belongs_to_many :tools
+end
+
+class Publisher < ActiveRecord::Base
+  has_many :articles
+  col :name
+end
+
+class Article < ActiveRecord::Base
+  key :title
+  belongs_to :publisher
+end
+
+class Attachment < ActiveRecord::Base
+  key :name
+  belongs_to :attachable, :polymorphic => true
+end
+
+class Account < ActiveRecord::Base
+  key :name
+end
+
+class Task < ActiveRecord::Base
+  belongs_to :author, :class_name => 'Account'
+end
+
+class Activity < ActiveRecord::Base
+  belongs_to :author, :class_name => 'Account', :foreign_key => 'custom_id'
+end

data/spec/spec_helper.rb

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

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: mini_record
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: 
+  hash: 50
+  prerelease: 6
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  - a
+  version: 0.3.0.a
 platform: ruby
 authors: 
 - Davide D'Agostino
@@ -15,8 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-11 00:00:00 +02:00
-default_executable: 
+date: 2012-01-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 15
         segments: 
         - 3
-        - 1
+        - 2
         - 0
-        version: 3.1.0
+        version: 3.2.0
   type: :runtime
   version_requirements: *id001
 description: "\n\
@@ -48,6 +48,7 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .travis.yml
 - Gemfile
 - README.md
 - Rakefile
@@ -58,7 +59,6 @@ files:
 - spec/mini_record_spec.rb
 - spec/models.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: https://github.com/DAddYE/mini_record
 licenses: []
 
@@ -79,16 +79,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: mini_record
-rubygems_version: 1.6.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: MiniRecord is a micro gem that allow you to write schema inside your model as you can do in DataMapper.
@@ -96,3 +98,4 @@ test_files:
 - spec/mini_record_spec.rb
 - spec/models.rb
 - spec/spec_helper.rb
+has_rdoc: