schema_plus 0.1.0.pre2 → 0.1.0.pre3

data/README.rdoc

@@ -4,14 +4,18 @@
 
 SchemaPlus is an ActiveRecord extension that provides enhanced capabilities for schema definition and querying, including: enhanced and more DRY index capabilities, support and automation for foreign key constraints, and support for views.
 
-For added rails DRYness see also the gems {+schema_associations+}[http://rubygems.org/gems/schema_associations] and {+schema_validations+}[http://rubygems.org/gems/schema_associations]  <b>IMPORTANT PRERELEASE NOTE: <i>Those are not yet separate gems, they are currently bundled in here.  They're not documented yet though.</i></b>
+For added rails DRYness see also the gems
+{+schema_associations+}[http://rubygems.org/gems/schema_associations] and
+{+schema_validations+}[http://rubygems.org/gems/schema_associations]
+<b>IMPORTANT PRERELEASE NOTE: <i>schema_validations is not yet separate
+gems, it's currently bundled in here.  It's not documented yet though.</i></b>
 
 == Compatibility
 
 SchemaPlus supports all combinations of:
 * rails 3.0 or 3.1
 * MRI ruby 1.8.7 or 1.9.2
-* Postgres, MySQL (using mysql or mysql2 gem), or Sqlite3
+* PostgreSQL, MySQL (using mysql or mysql2 gem), or Sqlite3
 
 == Installation
 
@@ -25,7 +29,8 @@ or in a Gemfile
 
 == Features
 
-Here some examples that show off the high points.  For full details see the RDoc documentation.
+Here some examples that show off the high points.  For full details see the
+{RDoc documentation}[http://rubydoc.info/gems/schema_plus].
 
 === Indexes
 

data/lib/schema_plus.rb

@@ -11,7 +11,6 @@ require 'schema_plus/active_record/connection_adapters/abstract_adapter'
 require 'schema_plus/active_record/connection_adapters/column'
 require 'schema_plus/active_record/connection_adapters/foreign_key_definition'
 require 'schema_plus/active_record/connection_adapters/index_definition'
-require 'schema_plus/active_record/associations'
 require 'schema_plus/railtie' if defined?(Rails)
 
 module SchemaPlus
@@ -26,7 +25,7 @@ module SchemaPlus
     end
   end
 
-  # This global configuation options for SchmeaPlus.
+  # This global configuation options for SchemaPlus.
   # Set them in +config/initializers/schema_plus.rb+ using:
   #
   #    SchemaPlus.setup do |config|
@@ -34,7 +33,7 @@ module SchemaPlus
   #    end
   #
   # The options are grouped into subsets based on area of functionality.
-  # See Config::ForeignKeys, Config::Associations, Config::Validations
+  # See Config::ForeignKeys, Config::Validations
   #
   class Config < Valuable
 
@@ -81,63 +80,6 @@ module SchemaPlus
     end
     has_value :foreign_keys, :klass => ForeignKeys, :default => ForeignKeys.new
 
-    # This set of configuration options control SchemaPlus's automatic
-    # association behavior.  Set them in
-    # +config/initializers/schema_plus.rb+ using:
-    #
-    #    SchemaPlus.setup do |config|
-    #       config.associations.auto_create = ...
-    #    end
-    #
-    class Associations < Valuable
-      
-      ##
-      # :attr_accessor: auto_create
-      #
-      # Whether to automatically create associations based on foreign keys.
-      # Boolean, default is +true+.
-      has_value :auto_create, :klass => :boolean, :default => true
-
-      ##
-      # :attr_accessor: concise_names
-      #
-      # Whether to use concise naming (strip out common prefixes from class names).
-      # Boolean, default is +true+.
-      has_value :concise_names, :klass => :boolean, :default => true
-
-      ##
-      # :attr_accessor: except
-      #
-      # List of association names to exclude from automatic creation.
-      # Value is a single name, an array of names, or +nil+.  Default is +nil+.
-      has_value :except, :default => nil
-
-      ##
-      # :attr_accessor: only
-      #
-      # List of association names to include in automatic creation.
-      # Value is a single name, and array of names, or +nil+.  Default is +nil+.
-      has_value :only, :default => nil
-
-      ##
-      # :attr_accessor: except_type
-      #
-      # List of association types to exclude from automatic creation.
-      # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
-      # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
-      has_value :except_type, :default => nil
-
-      ##
-      # :attr_accessor: only_type
-      #
-      # List of association types to include from automatic creation.
-      # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
-      # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
-      has_value :only_type, :default => nil
-
-    end
-    has_value :associations, :klass => Associations, :default => Associations.new
-
     # This set of configuration options control SchemaPlus's automatic
     # validations behavior.  Set them in
     # +config/initializers/schema_plus.rb+ using:
@@ -246,3 +188,5 @@ module SchemaPlus
   end
 
 end
+
+SchemaPlus.insert unless defined? Rails::Railtie

data/lib/schema_plus/active_record/base.rb

@@ -7,7 +7,6 @@ module SchemaPlus
     module Base
       def self.included(base) #:nodoc:
         base.extend(ClassMethods)
-        base.extend(SchemaPlus::ActiveRecord::Associations)
         base.extend(SchemaPlus::ActiveRecord::Validations)
       end
 

data/lib/schema_plus/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlus
-  VERSION = "0.1.0.pre2"
+  VERSION = "0.1.0.pre3"
 end

data/schema_plus.gemspec.rails3.0

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
   s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
   s.homepage    = "https://github.com/ronen/schema_plus"
-  s.summary     = "Provides ActiveRecord support for foreign keys, database defined validations and associations."
-  s.description = "SchemaPlus is an ActiveRecord extension that provides support for defining foreign keys and indexes in database migrations and schemas, as well as for defining model validations and associations based on the database."
+  s.summary     = "Enhances ActiveRecord schema mechanism, including more DRY index creation and support for foreign key constraints and views."
+  s.description = "SchemaPlus is an ActiveRecord extension that provides enhanced capabilities for schema definition and querying, including: enhanced and more DRY index capabilities, support and automation for foreign key constraints, and support for views."
 
   s.rubyforge_project = "schema_plus"
 

data/spec/foreign_key_spec.rb

@@ -6,118 +6,136 @@ require 'models/comment'
 
 describe "Foreign Key" do
   
-  before(:all) do
-    load_core_schema
-  end
-
   let(:migration) { ::ActiveRecord::Migration }
 
-  if SchemaPlusHelpers.sqlite3?
+  context "created with table" do
+    before(:all) do
+      load_auto_schema
+    end
 
-    it "raises an exception when attempting to add" do
-      expect { 
-        add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
-      }.should raise_error(NotImplementedError)
+    it "should report foreign key constraints" do
+      Comment.foreign_keys.collect(&:column_names).flatten.should == [ "user_id" ]
     end
 
-    it "raises an exception when attempting to remove" do
-      expect { 
-        remove_foreign_key(:posts, "dummy")
-      }.should raise_error(NotImplementedError)
+    it "should report reverse foreign key constraints" do
+      User.reverse_foreign_keys.collect(&:column_names).flatten.should == [ "user_id" ]
     end
 
-  else
+  end
 
-    context "when is added", "posts(author_id)" do
+  context "modification" do
 
-      before(:each) do 
-        add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
-      end
+    before(:all) do
+      load_core_schema
+    end
 
-      after(:each) do
-        fk = Post.foreign_keys.detect { |fk| fk.column_names == %w[author_id] }
-        remove_foreign_key(:posts, fk.name)
-      end
+    if SchemaPlusHelpers.sqlite3?
 
-      it "references users(id)" do
-        Post.should reference(:users, :id).on(:author_id)
+      it "raises an exception when attempting to add" do
+        expect { 
+          add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+        }.should raise_error(NotImplementedError)
       end
 
-      it "cascades on update" do
-        Post.should reference(:users).on_update(:cascade)
+      it "raises an exception when attempting to remove" do
+        expect { 
+          remove_foreign_key(:posts, "dummy")
+        }.should raise_error(NotImplementedError)
       end
 
-      it "restricts on delete" do
-        Post.should reference(:users).on_delete(:restrict)
-      end
+    else
 
-      it "is available in Post.foreign_keys" do
-        Post.foreign_keys.collect(&:column_names).should include(%w[author_id])
-      end
+      context "when is added", "posts(author_id)" do
 
-      it "is available in User.reverse_foreign_keys" do
-        User.reverse_foreign_keys.collect(&:column_names).should include(%w[author_id])
-      end
+        before(:each) do 
+          add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+        end
 
-    end
+        after(:each) do
+          fk = Post.foreign_keys.detect { |fk| fk.column_names == %w[author_id] }
+          remove_foreign_key(:posts, fk.name)
+        end
 
-    context "when is dropped", "comments(post_id)" do
+        it "references users(id)" do
+          Post.should reference(:users, :id).on(:author_id)
+        end
 
-      let(:foreign_key_name) { fk = Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] } and fk.name }
+        it "cascades on update" do
+          Post.should reference(:users).on_update(:cascade)
+        end
 
-      before(:each) do
-        remove_foreign_key(:comments, foreign_key_name)
-      end
+        it "restricts on delete" do
+          Post.should reference(:users).on_delete(:restrict)
+        end
 
-      after(:each) do
-        add_foreign_key(:comments, :post_id, :posts, :id)
-      end
+        it "is available in Post.foreign_keys" do
+          Post.foreign_keys.collect(&:column_names).should include(%w[author_id])
+        end
 
-      it "doesn't reference posts(id)" do
-        Comment.should_not reference(:posts).on(:post_id)
-      end
+        it "is available in User.reverse_foreign_keys" do
+          User.reverse_foreign_keys.collect(&:column_names).should include(%w[author_id])
+        end
 
-      it "is no longer available in Post.foreign_keys" do
-        Comment.foreign_keys.collect(&:column_names).should_not include(%w[post_id])
       end
 
-      it "is no longer available in User.reverse_foreign_keys" do
-        Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
-      end
+      context "when is dropped", "comments(post_id)" do
 
-    end
+        let(:foreign_key_name) { fk = Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] } and fk.name }
+
+        before(:each) do
+          remove_foreign_key(:comments, foreign_key_name)
+        end
+
+        after(:each) do
+          add_foreign_key(:comments, :post_id, :posts, :id)
+        end
 
-    context "when referencing column and column is removed" do
+        it "doesn't reference posts(id)" do
+          Comment.should_not reference(:posts).on(:post_id)
+        end
 
-      let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] }.name }
+        it "is no longer available in Post.foreign_keys" do
+          Comment.foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+        end
+
+        it "is no longer available in User.reverse_foreign_keys" do
+          Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+        end
 
-      it "should remove foreign keys" do
-        remove_foreign_key(:comments, foreign_key_name)
-        Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }.should be_empty
       end
 
-    end
+      context "when referencing column and column is removed" do
 
-    context "when table name is a rerved word" do
-      before(:each) do
-        migration.suppress_messages do
-          migration.create_table :references, :force => true do |t|
-            t.integer :post_id
-          end
+        let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] }.name }
+
+        it "should remove foreign keys" do
+          remove_foreign_key(:comments, foreign_key_name)
+          Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }.should be_empty
         end
+
       end
 
-      it "can add, detect, and remove a foreign key without error" do
-        migration.suppress_messages do
-          expect {
-            migration.add_foreign_key(:references, :post_id, :posts, :id)
-            foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column_names == ["post_id"]}
-            migration.remove_foreign_key(:references, foreign_key.name)
-          }.should_not raise_error
+      context "when table name is a rerved word" do
+        before(:each) do
+          migration.suppress_messages do
+            migration.create_table :references, :force => true do |t|
+              t.integer :post_id
+            end
+          end
+        end
+
+        it "can add, detect, and remove a foreign key without error" do
+          migration.suppress_messages do
+            expect {
+              migration.add_foreign_key(:references, :post_id, :posts, :id)
+              foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column_names == ["post_id"]}
+              migration.remove_foreign_key(:references, foreign_key.name)
+            }.should_not raise_error
+          end
         end
       end
-    end
 
+    end
   end
 
   protected

data/spec/spec_helper.rb

@@ -12,8 +12,6 @@ require 'active_record'
 require 'schema_plus'
 require 'connection'
 
-SchemaPlus.insert
-
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|

data/spec/validations_spec.rb

@@ -4,8 +4,6 @@ describe "Validations" do
 
   before(:all) do
     define_schema
-    # TODO: it should work regardless of auto-associations
-    SchemaPlus.config.associations.auto_create = false
   end
 
   after(:each) do

metadata

@@ -2,7 +2,7 @@
 name: schema_plus
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.1.0.pre2
+  version: 0.1.0.pre3
 platform: ruby
 authors: 
 - Ronen Barzel
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-11 00:00:00 -07:00
+date: 2011-07-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -164,7 +164,6 @@ files:
 - Rakefile
 - init.rb
 - lib/schema_plus.rb
-- lib/schema_plus/active_record/associations.rb
 - lib/schema_plus/active_record/base.rb
 - lib/schema_plus/active_record/connection_adapters/abstract_adapter.rb
 - lib/schema_plus/active_record/connection_adapters/column.rb
@@ -184,7 +183,6 @@ files:
 - schema_plus.gemspec
 - schema_plus.gemspec.rails3.0
 - schema_plus.gemspec.rails3.1
-- spec/association_spec.rb
 - spec/connections/mysql/connection.rb
 - spec/connections/mysql2/connection.rb
 - spec/connections/postgresql/connection.rb
@@ -240,7 +238,6 @@ signing_key:
 specification_version: 3
 summary: Enhances ActiveRecord schema mechanism, including more DRY index creation and support for foreign key constraints and views.
 test_files: 
-- spec/association_spec.rb
 - spec/connections/mysql/connection.rb
 - spec/connections/mysql2/connection.rb
 - spec/connections/postgresql/connection.rb

data/lib/schema_plus/active_record/associations.rb

@@ -1,211 +0,0 @@
-require 'ostruct'
-
-module SchemaPlus
-  module ActiveRecord
-    module Associations
-
-      module Relation #:nodoc:
-        def self.included(base)
-          base.alias_method_chain :initialize, :schema_plus
-        end
-
-        def initialize_with_schema_plus(klass, *args)
-          klass.send :_load_schema_plus_associations
-          initialize_without_schema_plus(klass, *args)
-        end
-      end
-
-      def self.extended(base) #:nodoc:
-        class << base
-          alias_method_chain :reflect_on_association, :schema_plus
-          alias_method_chain :reflect_on_all_associations, :schema_plus
-        end
-        ::ActiveRecord::Relation.send :include, Relation
-      end
-
-      def reflect_on_association_with_schema_plus(*args) #:nodoc:
-        _load_schema_plus_associations
-        reflect_on_association_without_schema_plus(*args)
-      end
-
-      def reflect_on_all_associations_with_schema_plus(*args) #:nodoc:
-        _load_schema_plus_associations
-        reflect_on_all_associations_without_schema_plus(*args)
-      end
-
-      def define_attribute_methods(*args) #:nodoc:
-        super
-        _load_schema_plus_associations
-      end
-
-      private
-
-      def _load_schema_plus_associations #:nodoc:
-        return if @schema_plus_associations_loaded
-        @schema_plus_associations_loaded = true
-        return unless schema_plus_config.associations.auto_create?
-
-        reverse_foreign_keys.each do | foreign_key |
-          if foreign_key.table_name =~ /^#{table_name}_(.*)$/ || foreign_key.table_name =~ /^(.*)_#{table_name}$/
-            other_table = $1
-            if other_table == other_table.pluralize and connection.columns(foreign_key.table_name).any?{|col| col.name == "#{other_table.singularize}_id"}
-              _define_association(:has_and_belongs_to_many, foreign_key, other_table)
-            else
-              _define_association(:has_one_or_many, foreign_key)
-            end
-          else
-            _define_association(:has_one_or_many, foreign_key)
-          end
-        end
-
-        foreign_keys.each do | foreign_key |
-          _define_association(:belongs_to, foreign_key)
-        end
-      end
-
-      def _define_association(macro, fk, referencing_table_name = nil) #:nodoc:
-        return unless fk.column_names.size == 1
-
-        referencing_table_name ||= fk.table_name
-
-        column_name = fk.column_names.first
-        reference_name = column_name.sub(/_id$/, '')
-        references_name = fk.references_table_name.singularize
-        referencing_name = referencing_table_name.singularize
-
-        references_class_name = references_name.classify
-        referencing_class_name = referencing_name.classify
-
-        references_concise = _concise_name(references_name, referencing_name)
-        referencing_concise = _concise_name(referencing_name, references_name)
-
-        case reference_name
-        when 'parent'
-          belongs_to         = 'parent'
-          belongs_to_concise = 'parent'
-
-          has_one            = 'child'
-          has_one_concise    = 'child'
-
-          has_many           = 'children'
-          has_many_concise   = 'children'
-
-        when references_name
-          belongs_to         = references_name
-          belongs_to_concise = references_concise
-
-          has_one            = referencing_name
-          has_one_concise    = referencing_concise
-
-          has_many           = referencing_name.pluralize
-          has_many_concise   = referencing_concise.pluralize
-
-        when /(.*)_#{references_name}$/, /(.*)_#{references_concise}$/
-          label = $1
-          belongs_to         = "#{label}_#{references_name}"
-          belongs_to_concise = "#{label}_#{references_concise}"
-
-          has_one            = "#{referencing_name}_as_#{label}"
-          has_one_concise    = "#{referencing_concise}_as_#{label}"
-
-          has_many           = "#{referencing_name.pluralize}_as_#{label}"
-          has_many_concise   = "#{referencing_concise.pluralize}_as_#{label}"
-
-        when /^#{references_name}_(.*)$/, /^#{references_concise}_(.*)$/
-          label = $1
-          belongs_to            = "#{references_name}_#{label}"
-          belongs_to_concise    = "#{references_concise}_#{label}"
-
-          has_one               = "#{referencing_name}_as_#{label}"
-          has_one_concise       = "#{referencing_concise}_as_#{label}"
-
-          has_many              = "#{referencing_name.pluralize}_as_#{label}"
-          has_many_concise      = "#{referencing_concise.pluralize}_as_#{label}"
-
-        else
-          belongs_to            = reference_name
-          belongs_to_concise    = reference_name
-
-          has_one               = "#{referencing_name}_as_#{reference_name}"
-          has_one_concise       = "#{referencing_concise}_as_#{reference_name}"
-
-          has_many              = "#{referencing_name.pluralize}_as_#{reference_name}"
-          has_many_concise      = "#{referencing_concise.pluralize}_as_#{reference_name}"
-        end
-
-        case macro
-        when :has_and_belongs_to_many
-          name = has_many
-          name_concise = has_many_concise
-          opts = {:class_name => referencing_class_name, :join_table => fk.table_name, :foreign_key => column_name}
-        when :belongs_to
-          name = belongs_to
-          name_concise = belongs_to_concise
-          opts = {:class_name => references_class_name, :foreign_key => column_name}
-        when :has_one_or_many
-          opts = {:class_name => referencing_class_name, :foreign_key => column_name}
-          # use connection.indexes and connection.colums rather than class
-          # methods of the referencing class because using the class
-          # methods would require getting the class -- which might trigger
-          # an autoload which could start some recursion making things much
-          # harder to debug.
-          if connection.indexes(referencing_table_name, "#{referencing_table_name} Indexes").any?{|index| index.unique && index.columns == [column_name]}
-            macro = :has_one
-            name = has_one
-            name_concise = has_one_concise
-          else
-            macro = :has_many
-            name = has_many
-            name_concise = has_many_concise
-            if connection.columns(referencing_table_name, "#{referencing_table_name} Columns").any?{ |col| col.name == 'position' }
-              opts[:order] = :position
-            end
-          end
-        end
-        name = name_concise if _use_concise_name?
-        name = name.to_sym
-        if (_filter_association(macro, name) && !_method_exists?(name))
-          logger.info "SchemaPlus associations: #{self.name || self.table_name.classify}.#{macro} #{name.inspect}, #{opts.inspect[1...-1]}"
-          send macro, name, opts.dup
-        end
-      end
-
-      def _concise_name(string, other) #:nodoc:
-        case
-        when string =~ /^#{other}_(.*)$/           then $1
-        when string =~ /(.*)_#{other}$/            then $1
-        when leader = _common_leader(string,other) then string[leader.length, string.length-leader.length]
-        else                                            string
-        end
-      end
-
-      def _common_leader(string, other) #:nodoc:
-        leader = nil
-        other.split('_').each do |part|
-          test = "#{leader}#{part}_"
-          break unless string.start_with? test
-          leader = test
-        end
-        return leader
-      end
-
-      def _use_concise_name? #:nodoc:
-        schema_plus_config.associations.concise_names?
-      end
-
-      def _filter_association(macro, name) #:nodoc:
-        config = schema_plus_config.associations
-        return false if config.only        and not Array.wrap(config.only).include?(name)
-        return false if config.except      and     Array.wrap(config.except).include?(name)
-        return false if config.only_type   and not Array.wrap(config.only_type).include?(macro)
-        return false if config.except_type and     Array.wrap(config.except_type).include?(macro)
-        return true
-      end
-
-      def _method_exists?(name) #:nodoc:
-        method_defined?(name) || private_method_defined?(name) and not (name == :type && [Object, Kernel].include?(instance_method(:type).owner))
-      end
-
-    end
-  end
-end

data/spec/association_spec.rb

@@ -1,529 +0,0 @@
-# encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe ActiveRecord::Base do
-  include SchemaPlusHelpers
-
-  after(:each) do
-    remove_all_models
-  end
-
-  around(:each) do |example|
-    with_fk_auto_create(&example)
-  end
-
-  context "in basic case" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should create belongs_to association" do
-      reflection = Comment.reflect_on_association(:post)
-      reflection.should_not be_nil
-      reflection.macro.should == :belongs_to
-      reflection.options[:class_name].should == "Post"
-      reflection.options[:foreign_key].should == "post_id"
-    end
-    it "should create has_many association" do
-      reflection = Post.reflect_on_association(:comments)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_many
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "post_id"
-    end
-    it "shouldn't raise an exception when model is instantiated" do
-      expect { Post.new }.should_not raise_error
-    end
-  end
-
-  it "should override auto_create negatively" do
-    with_associations_auto_create(true) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {} }
-      )
-      class Post < ActiveRecord::Base
-        schema_plus :associations => { :auto_create => false }
-      end
-      class Comment < ActiveRecord::Base ; end
-      Post.reflect_on_association(:comments).should be_nil
-      Comment.reflect_on_association(:post).should_not be_nil
-    end
-  end
-
-  context "with multiple associations of all types" do
-    before(:each) do
-      create_tables(
-        "owners", {}, {},
-        "colors", {}, {},
-        "widgets", {}, {
-          :owner_id => {},
-        },
-        "parts", {}, { :widget_id => {} },
-        "manifests", {}, { :widget_id => { :index => {:unique => true}} },
-        "colors_widgets", {:id => false}, { :widget_id => {}, :color_id => {} }
-      )
-    end
-
-    def check_reflections(hash)
-      hash.each do |key, val|
-        reflection = Widget.reflect_on_association(key)
-        case val
-        when true then reflection.should_not be_nil
-        else           reflection.should be_nil
-        end
-      end
-    end
-
-    it "should default as expected" do
-      class Widget < ActiveRecord::Base ; end
-      check_reflections(:owner => true, :colors => true, :parts => true, :manifest => true)
-    end
-
-    it "should respect :only" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :only => :owner }
-      end
-      check_reflections(:owner => true, :colors => false, :parts => false, :manifest => false)
-    end
-
-    it "should respect :except" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :except => :owner }
-      end
-      check_reflections(:owner => false, :colors => true, :parts => true, :manifest => true)
-    end
-
-    it "should respect :only_type :belongs_to" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :only_type => :belongs_to }
-      end
-      check_reflections(:owner => true, :colors => false, :parts => false, :manifest => false)
-    end
-
-    it "should respect :except_type :belongs_to" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :except_type => :belongs_to }
-      end
-      check_reflections(:owner => false, :colors => true, :parts => true, :manifest => true)
-    end
-
-    it "should respect :only_type :has_many" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :only_type => :has_many }
-      end
-      check_reflections(:owner => false, :colors => false, :parts => true, :manifest => false)
-    end
-
-    it "should respect :except_type :has_many" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :except_type => :has_many }
-      end
-      check_reflections(:owner => true, :colors => true, :parts => false, :manifest => true)
-    end
-
-    it "should respect :only_type :has_one" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :only_type => :has_one }
-      end
-      check_reflections(:owner => false, :colors => false, :parts => false, :manifest => true)
-    end
-
-    it "should respect :except_type :has_one" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :except_type => :has_one }
-      end
-      check_reflections(:owner => true, :colors => true, :parts => true, :manifest => false)
-    end
-
-    it "should respect :only_type :has_and_belongs_to_many" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :only_type => :has_and_belongs_to_many }
-      end
-      check_reflections(:owner => false, :colors => true, :parts => false, :manifest => false)
-    end
-
-    it "should respect :except_type :has_and_belongs_to_many" do 
-      class Widget < ActiveRecord::Base
-        schema_plus :associations => { :except_type => :has_and_belongs_to_many }
-      end
-      check_reflections(:owner => true, :colors => false, :parts => true, :manifest => true)
-    end
-
-  end
-
-  it "should override auto_create positively" do
-    with_associations_auto_create(false) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {} }
-      )
-      class Post < ActiveRecord::Base
-        schema_plus :associations => { :auto_create => true }
-      end
-      class Comment < ActiveRecord::Base ; end
-      Post.reflect_on_association(:comments).should_not be_nil
-      Comment.reflect_on_association(:post).should be_nil
-    end
-  end
-
-
-  context "with unique index" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {:index => { :unique => true} } }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should create has_one association" do
-      reflection = Post.reflect_on_association(:comment)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_one
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "post_id"
-    end
-  end
-
-  context "with prefixed column names" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :subject_post_id => { :references => :posts} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should name belongs_to according to column" do
-      reflection = Comment.reflect_on_association(:subject_post)
-      reflection.should_not be_nil
-      reflection.macro.should == :belongs_to
-      reflection.options[:class_name].should == "Post"
-      reflection.options[:foreign_key].should == "subject_post_id"
-    end
-
-    it "should name has_many using 'as column'" do
-      reflection = Post.reflect_on_association(:comments_as_subject)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_many
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "subject_post_id"
-    end
-  end
-
-  context "with suffixed column names" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_cited => { :references => :posts} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should name belongs_to according to column" do
-      reflection = Comment.reflect_on_association(:post_cited)
-      reflection.should_not be_nil
-      reflection.macro.should == :belongs_to
-      reflection.options[:class_name].should == "Post"
-      reflection.options[:foreign_key].should == "post_cited"
-    end
-
-    it "should name has_many using 'as column'" do
-      reflection = Post.reflect_on_association(:comments_as_cited)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_many
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "post_cited"
-    end
-  end
-
-  context "with arbitrary column names" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :subject => {:references => :posts} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should name belongs_to according to column" do
-      reflection = Comment.reflect_on_association(:subject)
-      reflection.should_not be_nil
-      reflection.macro.should == :belongs_to
-      reflection.options[:class_name].should == "Post"
-      reflection.options[:foreign_key].should == "subject"
-    end
-
-    it "should name has_many using 'as column'" do
-      reflection = Post.reflect_on_association(:comments_as_subject)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_many
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "subject"
-    end
-  end
-
-
-  context "with position" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {}, :position => {} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-    it "should create ordered has_many association" do
-      reflection = Post.reflect_on_association(:comments)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_many
-      reflection.options[:class_name].should == "Comment"
-      reflection.options[:foreign_key].should == "post_id"
-      reflection.options[:order].to_s.should == "position"
-    end
-  end
-
-  context "regarding parent-child relationships" do
-
-    let (:migration) {ActiveRecord::Migration}
-
-    before(:each) do
-      create_tables(
-        "nodes", {:foreign_keys => {:auto_index => false}}, { :parent_id => {} }
-      )
-    end
-
-    it "should use children as the inverse of parent" do
-      class Node < ActiveRecord::Base ; end
-      reflection = Node.reflect_on_association(:children)
-      reflection.should_not be_nil
-    end
-
-    it "should use child as the singular inverse of parent" do
-      migration.suppress_messages do
-        migration.add_index(:nodes, :parent_id, :unique => true)
-      end
-      class Node < ActiveRecord::Base ; end
-      reflection = Node.reflect_on_association(:child)
-      reflection.should_not be_nil
-    end
-  end
-
-
-  context "regarding concise names" do
-
-    def prefix_one
-      create_tables(
-        "posts", {}, {},
-        "post_comments", {}, { :post_id => {} }
-      )
-      Object.const_set(:Post, Class.new(ActiveRecord::Base))
-      Object.const_set(:PostComment, Class.new(ActiveRecord::Base))
-    end
-
-    def suffix_one
-      create_tables(
-        "posts", {}, {},
-        "comment_posts", {}, { :post_id => {} }
-      )
-      Object.const_set(:Post, Class.new(ActiveRecord::Base))
-      Object.const_set(:CommentPost, Class.new(ActiveRecord::Base))
-    end
-
-    def prefix_both
-      create_tables(
-        "blog_page_posts", {}, {},
-        "blog_page_comments", {}, { :blog_page_post_id => {} }
-      )
-      Object.const_set(:BlogPagePost, Class.new(ActiveRecord::Base))
-      Object.const_set(:BlogPageComment, Class.new(ActiveRecord::Base))
-    end
-
-    it "should use concise association name for one prefix" do
-      with_associations_config(:auto_create => true, :concise_names => true) do
-        prefix_one
-        reflection = Post.reflect_on_association(:comments)
-        reflection.should_not be_nil
-        reflection.macro.should == :has_many
-        reflection.options[:class_name].should == "PostComment"
-        reflection.options[:foreign_key].should == "post_id"
-      end
-    end
-
-    it "should use concise association name for one suffix" do
-      with_associations_config(:auto_create => true, :concise_names => true) do
-        suffix_one
-        reflection = Post.reflect_on_association(:comments)
-        reflection.should_not be_nil
-        reflection.macro.should == :has_many
-        reflection.options[:class_name].should == "CommentPost"
-        reflection.options[:foreign_key].should == "post_id"
-      end
-    end
-
-    it "should use concise association name for shared prefixes" do
-      with_associations_config(:auto_create => true, :concise_names => true) do
-        prefix_both
-        reflection = BlogPagePost.reflect_on_association(:comments)
-        reflection.should_not be_nil
-        reflection.macro.should == :has_many
-        reflection.options[:class_name].should == "BlogPageComment"
-        reflection.options[:foreign_key].should == "blog_page_post_id"
-      end
-    end
-
-    it "should use full names and not concise names when so configured" do
-      with_associations_config(:auto_create => true, :concise_names => false) do
-        prefix_one
-        reflection = Post.reflect_on_association(:post_comments)
-        reflection.should_not be_nil
-        reflection.macro.should == :has_many
-        reflection.options[:class_name].should == "PostComment"
-        reflection.options[:foreign_key].should == "post_id"
-        reflection = Post.reflect_on_association(:comments)
-        reflection.should be_nil
-      end
-    end
-
-    it "should use concise names and not full names when so configured" do
-      with_associations_config(:auto_create => true, :concise_names => true) do
-        prefix_one
-        reflection = Post.reflect_on_association(:comments)
-        reflection.should_not be_nil
-        reflection.macro.should == :has_many
-        reflection.options[:class_name].should == "PostComment"
-        reflection.options[:foreign_key].should == "post_id"
-        reflection = Post.reflect_on_association(:post_comments)
-        reflection.should be_nil
-      end
-    end
-
-
-  end
-
-  context "with joins table" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "tags", {}, {},
-        "posts_tags", {:id => false}, { :post_id => {}, :tag_id => {}}
-      )
-      class Post < ActiveRecord::Base ; end
-      class Tag < ActiveRecord::Base ; end
-    end
-    it "should create has_and_belongs_to_many association" do
-      reflection = Post.reflect_on_association(:tags)
-      reflection.should_not be_nil
-      reflection.macro.should == :has_and_belongs_to_many
-      reflection.options[:class_name].should == "Tag"
-      reflection.options[:join_table].should == "posts_tags"
-    end
-  end
-
-  context "regarding existing methods" do
-    before(:each) do
-      create_tables(
-        "types", {}, {},
-        "posts", {}, {:type_id => {}}
-      )
-    end
-    it "should define association normally if no existing method is defined" do
-      class Type < ActiveRecord::Base ; end
-      Type.reflect_on_association(:posts).should_not be_nil # sanity check for this context
-    end
-    it "should not define association over existing public method" do
-      class Type < ActiveRecord::Base
-        def posts
-          :existing
-        end
-      end
-      Type.reflect_on_association(:posts).should be_nil
-    end
-    it "should not define association over existing private method" do
-      class Type < ActiveRecord::Base
-        private
-        def posts
-          :existing
-        end
-      end
-      Type.reflect_on_association(:posts).should be_nil
-    end
-    it "should define association :type over (deprecated) kernel method" do
-      class Post < ActiveRecord::Base ; end
-      Post.reflect_on_association(:type).should_not be_nil
-    end
-    it "should not define association :type over model method" do
-      class Post < ActiveRecord::Base
-        def type
-          :existing
-        end
-      end
-      Post.reflect_on_association(:type).should be_nil
-    end
-  end
-
-  context "regarding relations" do
-    before(:each) do
-      create_tables(
-        "posts", {}, {},
-        "comments", {}, { :post_id => {} }
-      )
-      class Post < ActiveRecord::Base ; end
-      class Comment < ActiveRecord::Base ; end
-    end
-
-    it "should define associations before needed by relation" do
-      Post.joins(:comments).all
-      expect { Post.joins(:comments).all }.should_not raise_error
-
-    end
-
-  end
-
-  protected
-
-  def with_fk_auto_create(value = true, &block)
-    save = SchemaPlus.config.foreign_keys.auto_create
-    begin
-      SchemaPlus.config.foreign_keys.auto_create = value
-      yield
-    ensure
-      SchemaPlus.config.foreign_keys.auto_create = save
-    end
-  end
-
-  def with_associations_auto_create(value, &block)
-    with_associations_config(:auto_create => value, &block)
-  end
-
-  def with_associations_config(opts, &block)
-    save = Hash[opts.keys.collect{|key| [key, SchemaPlus.config.associations.send(key)]}]
-    begin
-      SchemaPlus.config.associations.update_attributes(opts)
-      yield
-    ensure
-      SchemaPlus.config.associations.update_attributes(save)
-    end
-  end
-
-  def create_tables(*table_defs)
-    ActiveRecord::Migration.suppress_messages do
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Migration.drop_table table
-      end
-      table_defs.each_slice(3) do |table_name, opts, columns_with_options|
-        ActiveRecord::Migration.create_table table_name, opts do |t|
-          columns_with_options.each_pair do |column, options|
-            t.integer column, options
-          end
-        end
-      end
-    end
-  end
-
-end