schema_plus 0.1.0.pre1

data/schema_plus.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_plus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_plus"
+  s.version     = SchemaPlus::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/lomba/schema_plus"
+  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"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails")
+  s.add_dependency("valuable")
+      
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rails", ">= 3.1.0.rc1")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/schema_plus.gemspec.rails3.0

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_plus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_plus"
+  s.version     = SchemaPlus::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/lomba/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.rubyforge_project = "schema_plus"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails")
+  s.add_dependency("valuable")
+      
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rails", "~> 3.0")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2", "0.2.6")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/schema_plus.gemspec.rails3.1

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_plus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_plus"
+  s.version     = SchemaPlus::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/lomba/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.rubyforge_project = "schema_plus"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails")
+  s.add_dependency("valuable")
+      
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rails", ">= 3.1.0.rc1")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/spec/association_spec.rb

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