with_model 0.3.2 → 1.0.0

data/lib/with_model/model/dsl.rb

@@ -0,0 +1,18 @@
+module WithModel
+  class Model
+    class DSL
+      def initialize model
+        @model = model
+      end
+
+      def table options = {}, &block
+        @model.table_options = options
+        @model.table_block = block
+      end
+
+      def model &block
+        @model.model_block = block
+      end
+    end
+  end
+end

data/lib/with_model/table.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+
+module WithModel
+  class Table
+    def initialize name, options = {}, &block
+      @name = name.freeze
+      @options = options.freeze
+      @block = block
+    end
+
+    def create
+      connection = ActiveRecord::Base.connection
+      connection.drop_table(@name) if connection.table_exists?(@name)
+      connection.create_table(@name, @options, &@block)
+    end
+
+    def destroy
+      ActiveRecord::Base.connection.drop_table(@name)
+    end
+  end
+end

data/lib/with_model/version.rb

@@ -1,3 +1,3 @@
 module WithModel
-  VERSION = "0.3.2"
+  VERSION = '1.0.0'.freeze
 end

data/spec/active_record_behaviors_spec.rb

@@ -4,9 +4,11 @@ describe "ActiveRecord behaviors" do
   describe "a temporary ActiveRecord model created with with_model" do
     context "that has a named scope" do
       before do
-        class RegularModel < ActiveRecord::Base
+        regular_model = Class.new ActiveRecord::Base do
           scope :title_is_foo, lambda { where(:title => 'foo') }
         end
+        stub_const 'RegularModel', regular_model
+
         RegularModel.connection.drop_table(RegularModel.table_name) rescue nil
         RegularModel.connection.create_table(RegularModel.table_name) do |t|
           t.string 'title'
@@ -32,25 +34,26 @@ describe "ActiveRecord behaviors" do
       end
 
       describe "the named scope" do
-        it "should work like a regular named scope" do
-          included = RegularModel.create!(:title => 'foo', :content => "Include me!")
-          excluded = RegularModel.create!(:title => 'bar', :content => "Include me!")
+        it "works like a regular named scope" do
+          included = RegularModel.create!(:title => 'foo', :content => 'Include me!')
+          excluded = RegularModel.create!(:title => 'bar', :content => 'Include me!')
 
-          RegularModel.title_is_foo.should == [included]
+          expect(RegularModel.title_is_foo).to eq [included]
 
-          included = BlogPost.create!(:title => 'foo', :content => "Include me!")
-          excluded = BlogPost.create!(:title => 'bar', :content => "Include me!")
+          included = BlogPost.create!(:title => 'foo', :content => 'Include me!')
+          excluded = BlogPost.create!(:title => 'bar', :content => 'Include me!')
 
-          BlogPost.title_is_foo.should == [included]
+          expect(BlogPost.title_is_foo).to eq [included]
         end
       end
     end
 
     context "that has a polymorphic belongs_to" do
       before do
-        class Animal < ActiveRecord::Base
+        animal = Class.new ActiveRecord::Base do
           has_many :tea_cups, :as => :pet
         end
+        stub_const 'Animal', animal
       end
 
       with_model :TeaCup do
@@ -71,17 +74,17 @@ describe "ActiveRecord behaviors" do
       end
 
       describe "the polymorphic belongs_to" do
-        it "should work like a regular polymorphic belongs_to" do
+        it "works like a regular polymorphic belongs_to" do
           animal = Animal.create!
           stuffed_animal = StuffedAnimal.create!
 
           tea_cup_for_animal = TeaCup.create!(:pet => animal)
-          tea_cup_for_animal.pet_type.should == "Animal"
-          animal.tea_cups.should include(tea_cup_for_animal)
+          expect(tea_cup_for_animal.pet_type).to eq 'Animal'
+          expect(animal.tea_cups).to include(tea_cup_for_animal)
 
           tea_cup_for_stuffed_animal = TeaCup.create!(:pet => stuffed_animal)
-          tea_cup_for_stuffed_animal.pet_type.should == "StuffedAnimal"
-          stuffed_animal.tea_cups.should include(tea_cup_for_stuffed_animal)
+          expect(tea_cup_for_stuffed_animal.pet_type).to eq 'StuffedAnimal'
+          expect(stuffed_animal.tea_cups).to include(tea_cup_for_stuffed_animal)
         end
       end
     end
@@ -97,18 +100,17 @@ describe "ActiveRecord behaviors" do
       end
     end
 
-    with_model :Country do
-    end
+    with_model :Country
 
     context "in earlier examples" do
-      it "should work as normal" do
+      it "works as normal" do
         Province.create!(:country => Country.create!)
       end
     end
 
     context "in later examples" do
-      it "should not hold a reference to earlier example groups' classes" do
-        Province.reflect_on_association(:country).klass.should == Country
+      it "does not hold a reference to earlier example groups' classes" do
+        expect(Province.reflect_on_association(:country).klass).to eq Country
       end
     end
   end

data/spec/readme_spec.rb

@@ -1,86 +1,105 @@
-  require 'spec_helper'
+require 'spec_helper'
 
-  describe "A blog post" do
-
-    with_model :BlogPost do
-      # The table block works just like a migration.
-      table do |t|
-        t.string :title
-        t.timestamps
-      end
-
-      # The model block works just like the class definition.
-      model do
-        include SomeModule
-        has_many :comments
-        validates_presence_of :title
+describe "A blog post" do
+  before :all do
+    module SomeModule; end
+  end
 
-        def self.some_class_method
-          'chunky'
-        end
+  after :all do
+    Object.send :remove_const, :SomeModule
+  end
 
-        def some_instance_method
-          'bacon'
-        end
-      end
+  with_model :BlogPost do
+    # The table block works just like a migration.
+    table do |t|
+      t.string :title
+      t.timestamps
     end
 
-    # with_model classes can have associations.
-    with_model :Comment do
-      table do |t|
-        t.string :text
-        t.belongs_to :blog_post
-        t.timestamps
+    # The model block works just like the class definition.
+    model do
+      include SomeModule
+      has_many :comments
+      validates_presence_of :title
+
+      def self.some_class_method
+        'chunky'
       end
 
-      model do
-        belongs_to :blog_post
+      def some_instance_method
+        'bacon'
       end
     end
+  end
 
-    it "can be accessed as a constant" do
-      BlogPost.should be
+  # with_model classes can have associations.
+  with_model :Comment do
+    table do |t|
+      t.string :text
+      t.belongs_to :blog_post
+      t.timestamps
     end
 
-    it "has the module" do
-      BlogPost.include?(SomeModule).should be_true
+    model do
+      belongs_to :blog_post
     end
+  end
 
-    it "has the class method" do
-      BlogPost.some_class_method.should == 'chunky'
-    end
+  it "can be accessed as a constant" do
+    expect(BlogPost).to be
+  end
 
-    it "has the instance method" do
-      BlogPost.new.some_instance_method.should == 'bacon'
-    end
+  it "has the module" do
+    expect(BlogPost.include?(SomeModule)).to be_true
+  end
 
-    it "can do all the things a regular model can" do
-      record = BlogPost.new
-      record.should_not be_valid
-      record.title = "foo"
-      record.should be_valid
-      record.save.should be_true
-      record.reload.should == record
-      record.comments.create!(:text => "Lorem ipsum")
-      record.comments.count.should == 1
-    end
+  it "has the class method" do
+    expect(BlogPost.some_class_method).to eq 'chunky'
   end
 
-  describe "another example group" do
-    it "should not have the constant anymore" do
-      defined?(BlogPost).should be_false
-    end
+  it "has the instance method" do
+    expect(BlogPost.new.some_instance_method).to eq 'bacon'
   end
 
-  describe "with table options" do
-    with_model :WithOptions do
-      table :id => false do |t|
-        t.string 'foo'
-        t.timestamps
-      end
-    end
+  it "can do all the things a regular model can" do
+    record = BlogPost.new
+    expect(record).to_not be_valid
+    record.title = "foo"
+    expect(record).to be_valid
+    expect(record.save).to be_true
+    expect(record.reload).to eq record
+    record.comments.create!(:text => "Lorem ipsum")
+    expect(record.comments.count).to eq 1
+  end
+
+  # with_model classes can have inheritance.
+  class Car < ActiveRecord::Base
+    self.abstract_class = true
+  end
+
+  with_model :Ford, superclass: Car do
+  end
+
+  it "has a specified superclass" do
+    expect(Ford < Car).to be_true
+  end
+end
 
-    it "should respect the additional options" do
-      WithOptions.columns.map(&:name).should_not include("id")
+describe "another example group" do
+  it "does not have the constant anymore" do
+    expect(defined?(BlogPost)).to be_false
+  end
+end
+
+describe "with table options" do
+  with_model :WithOptions do
+    table :id => false do |t|
+      t.string 'foo'
+      t.timestamps
     end
   end
+
+  it "respects the additional options" do
+    expect(WithOptions.columns.map(&:name)).to_not include("id")
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
-require "active_record"
-require "with_model"
+require 'bundler'
+Bundler.setup
 
 begin
   require 'coveralls'
@@ -7,43 +7,48 @@ begin
 rescue LoadError
 end
 
+require 'with_model'
 RSpec.configure do |config|
   config.extend WithModel
+
+  config.warnings = true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
 end
 
-jruby = RUBY_PLATFORM =~ /\bjava\b/
-adapter = jruby ? "jdbcsqlite3" : "sqlite3"
+is_jruby = RUBY_PLATFORM =~ /\bjava\b/
+adapter = is_jruby ? 'jdbcsqlite3' : 'sqlite3'
 
 # WithModel requires ActiveRecord::Base.connection to be established.
 # If ActiveRecord already has a connection, as in a Rails app, this is unnecessary.
-ActiveRecord::Base.establish_connection(:adapter => adapter, :database => ":memory:")
-
-# For readme_spec.rb
-module SomeModule; end
-
-if defined?(ActiveModel)
-  shared_examples_for "ActiveModel" do
-    require 'test/unit/assertions'
-    require 'active_model/lint'
-    include Test::Unit::Assertions
-    include ActiveModel::Lint::Tests
-
-    # to_s is to support ruby-1.9
-    ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m|
-      example m.gsub('_',' ') do
-        begin
-          send m
-        rescue
-          puts $!.message
-        end
-      end
-    end
+require 'active_record'
+ActiveRecord::Base.establish_connection(:adapter => adapter, :database => ':memory:')
 
-    before { @model = subject }
-  end
+if defined?(I18n) && I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = true
+end
+
+if ENV['LOGGER']
+  require 'logger'
+  ActiveRecord::Base.logger = Logger.new($stdout)
 end
 
-if ENV["LOGGER"]
-  require "logger"
-  ActiveRecord::Base.logger = Logger.new(STDOUT)
+module SpecHelper
+  module RailsTestCompatability
+    if ::ActiveRecord::VERSION::STRING >= '4.1.0'
+      require 'minitest'
+      include Minitest::Assertions
+      def assertions; @assertions || 0; end
+      def assertions= value; @assertions = value; end
+    else
+      require 'test/unit/assertions'
+      include Test::Unit::Assertions
+    end
+  end
 end

data/spec/with_model_spec.rb

@@ -1,5 +1,24 @@
+require 'active_model'
 require 'spec_helper'
 
+shared_examples_for "ActiveModel" do
+  require 'active_model/lint'
+  include SpecHelper::RailsTestCompatability
+  include ActiveModel::Lint::Tests
+
+  active_model_methods = ActiveModel::Lint::Tests.public_instance_methods
+  active_model_lint_tests = active_model_methods.map(&:to_s).grep(/^test/)
+
+  active_model_lint_tests.each do |method_name|
+    friendly_name = method_name.gsub('_', ' ')
+    example friendly_name do
+      public_send method_name.to_sym
+    end
+  end
+
+  before { @model = subject }
+end
+
 describe "a temporary ActiveRecord model created with with_model" do
   non_shadowing_example_ran = false
 
@@ -22,52 +41,48 @@ describe "a temporary ActiveRecord model created with with_model" do
       non_shadowing_example_ran = true
     end
 
-    it "should act like a normal ActiveRecord model" do
-      record = BlogPost.create!(:title => 'New blog post', :content => "Hello, world!")
+    it "acts like a normal ActiveRecord model" do
+      record = BlogPost.create!(:title => 'New blog post', :content => 'Hello, world!')
 
       record.reload
 
-      record.title.should == 'New blog post'
-      record.content.should == 'Hello, world!'
-      record.updated_at.should be_present
+      expect(record.title).to eq 'New blog post'
+      expect(record.content).to eq 'Hello, world!'
+      expect(record.updated_at).to be_present
 
       record.destroy
 
-      lambda {
-        record.reload
-      }.should raise_error(ActiveRecord::RecordNotFound)
+      expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    if defined?(ActiveModel)
-      describe "the class" do
-        subject { BlogPost.new }
-        it_should_behave_like "ActiveModel"
-      end
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
     end
 
-    it "should have methods defined in its model block" do
-      BlogPost.new(:title => 'New blog post').fancy_title.should == "Title: New blog post"
+    it "has the methods defined in its model block" do
+      expect(BlogPost.new(:title => 'New blog post').fancy_title).to eq 'Title: New blog post'
     end
 
-    it "should define a constant" do
-      BlogPost.should be_a(Class)
+    it "defines a constant" do
+      expect(BlogPost).to be_a(Class)
     end
 
     describe ".with_model?" do
-      it "should return true" do
-        BlogPost.with_model?.should be_true
+      it "returns true" do
+        expect(BlogPost.with_model?).to be_true
       end
     end
 
-    it "should have a base_class of itself" do
-      BlogPost.base_class.should == BlogPost
+    it "is its own base_class" do
+      expect(BlogPost.base_class).to eq BlogPost
     end
   end
 
   context "after an example which uses with_model without shadowing an existing constant" do
-    it "should return the constant to its undefined state" do
-      non_shadowing_example_ran.should be_true
-      defined?(BlogPost).should be_false
+    it "returns the constant to its undefined state" do
+      expect(non_shadowing_example_ran).to be_true
+      expect(defined?(BlogPost)).to be_false
     end
   end
 
@@ -82,49 +97,59 @@ describe "a temporary ActiveRecord model created with with_model" do
       shadowing_example_ran = true
     end
 
-    it "should shadow that constant" do
-      MyConst.should be_a(Class)
+    it "shadows that constant" do
+      expect(MyConst).to be_a(Class)
     end
   end
 
   context "in later examples" do
-    it "should return the constant to its original value" do
-      shadowing_example_ran.should be_true
-      MyConst.should == 1
+    it "returns the constant to its original value" do
+      expect(shadowing_example_ran).to be_true
+      expect(MyConst).to eq 1
     end
   end
 
   describe "with a plural name" do
     with_model :BlogPosts
 
-    it "should not singularize the constant name" do
-      BlogPosts.should be
-      lambda { BlogPost }.should raise_error(NameError)
+    it "does not singularize the constant name" do
+      expect(BlogPosts).to be
+      expect(lambda { BlogPost }).to raise_error(NameError)
     end
   end
 
   describe "with a name containing capital letters" do
     with_model :BlogPost
 
-    it "should tableize the table name" do
-      BlogPost.table_name.should match(/_blog_posts_/)
-      BlogPost.table_name.should == BlogPost.table_name.downcase
+    it "tableizes the table name" do
+      expect(BlogPost.table_name).to match(/_blog_posts_/)
+      expect(BlogPost.table_name).to eq BlogPost.table_name.downcase
     end
   end
 
   describe "with a name with underscores" do
     with_model :blog_post
 
-    it "should constantize the name" do
-      BlogPost.should be
+    it "constantizes the name" do
+      expect(BlogPost).to be
     end
 
-    it "should tableize the table name" do
-      BlogPost.table_name.should match(/_blog_posts_/)
-      BlogPost.table_name.should == BlogPost.table_name.downcase
+    it "tableizes the table name" do
+      expect(BlogPost.table_name).to match(/_blog_posts_/)
+      expect(BlogPost.table_name).to eq BlogPost.table_name.downcase
     end
   end
 
+  describe "using the constant in the model block" do
+    with_model :BlogPost do
+      model do
+        raise 'I am not myself!' unless self == BlogPost
+      end
+    end
+
+    it "is available" do end
+  end
+
   module AMixin
     def foo
     end
@@ -139,9 +164,9 @@ describe "a temporary ActiveRecord model created with with_model" do
 
     before { ::ModelWithMixin = WithAMixin }
 
-    it "should have the mixin" do
-      lambda { ::ModelWithMixin.new.foo }.should_not raise_error
-      ::ModelWithMixin.include?(AMixin).should be_true
+    it "has the mixin" do
+      expect(lambda { ::ModelWithMixin.new.foo }).to_not raise_error
+      expect(::ModelWithMixin.include?(AMixin)).to be_true
     end
   end
 
@@ -163,26 +188,17 @@ describe "a temporary ActiveRecord model created with with_model" do
       end
     end
 
-    it "should only have one after_save callback" do
-      subject.should_receive(:my_method).once
+    it "only has one after_save callback" do
+      expect(subject).to receive(:my_method).once
       subject.save
     end
 
-    it "should still only have one after_save callback in future tests" do
-      subject.should_receive(:my_method).once
+    it "still only has one after_save callback in future tests" do
+      expect(subject).to receive(:my_method).once
       subject.save
     end
   end
 
-  if defined?(Mixico)
-    context "after a context that uses a mixin" do
-      it "should not have the mixin" do
-        lambda { ::ModelWithMixin.new.foo }.should raise_error(NoMethodError)
-        ::ModelWithMixin.include?(AMixin).should be_false
-      end
-    end
-  end
-
   context "with table options" do
     with_model :WithOptions do
       table :id => false do |t|
@@ -191,48 +207,40 @@ describe "a temporary ActiveRecord model created with with_model" do
       end
     end
 
-    it "should respect the additional options" do
-      WithOptions.columns.map(&:name).should_not include("id")
+    it "respects the additional options" do
+      expect(WithOptions.columns.map(&:name)).to_not include('id')
     end
   end
 
   context "without a block" do
     with_model :BlogPost
 
-    it "should act like a normal ActiveRecord model" do
+    it "acts like a normal ActiveRecord model" do
       record = BlogPost.create!
       record.reload
       record.destroy
-      lambda {
-        record.reload
-      }.should raise_error(ActiveRecord::RecordNotFound)
+      expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    if defined?(ActiveModel)
-      describe "the class" do
-        subject { BlogPost.new }
-        it_should_behave_like "ActiveModel"
-      end
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
     end
   end
 
   context "with an empty block" do
     with_model(:BlogPost) {}
 
-    it "should act like a normal ActiveRecord model" do
+    it "acts like a normal ActiveRecord model" do
       record = BlogPost.create!
       record.reload
       record.destroy
-      lambda {
-        record.reload
-      }.should raise_error(ActiveRecord::RecordNotFound)
+      expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    if defined?(ActiveModel)
-      describe "the class" do
-        subject { BlogPost.new }
-        it_should_behave_like "ActiveModel"
-      end
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
     end
   end
 
@@ -245,50 +253,40 @@ describe "a temporary ActiveRecord model created with with_model" do
       end
     end
 
-    it "should act like a normal ActiveRecord model" do
-      record = BlogPost.create!(:title => 'New blog post', :content => "Hello, world!")
+    it "acts like a normal ActiveRecord model" do
+      record = BlogPost.create!(:title => 'New blog post', :content => 'Hello, world!')
 
       record.reload
 
-      record.title.should == 'New blog post'
-      record.content.should == 'Hello, world!'
-      record.updated_at.should be_present
+      expect(record.title).to eq 'New blog post'
+      expect(record.content).to eq 'Hello, world!'
+      expect(record.updated_at).to be_present
 
       record.destroy
 
-      lambda {
-        record.reload
-      }.should raise_error(ActiveRecord::RecordNotFound)
+      expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    if defined?(ActiveModel)
-      describe "the class" do
-        subject { BlogPost.new }
-        it_should_behave_like "ActiveModel"
-      end
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
     end
-
   end
 
-  context "without a table block" do
-    with_model :BlogPost do
-    end
+  context "without a table or model block" do
+    with_model :BlogPost
 
-    it "should act like a normal ActiveRecord model" do
-      BlogPost.columns.map(&:name).should == ["id"]
+    it "acts like a normal ActiveRecord model" do
+      expect(BlogPost.columns.map(&:name)).to eq ['id']
       record = BlogPost.create!
       record.reload
       record.destroy
-      lambda {
-        record.reload
-      }.should raise_error(ActiveRecord::RecordNotFound)
+      expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    if defined?(ActiveModel)
-      describe "the class" do
-        subject { BlogPost.new }
-        it_should_behave_like "ActiveModel"
-      end
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
     end
   end
 
@@ -296,15 +294,46 @@ describe "a temporary ActiveRecord model created with with_model" do
     with_model :BlogPost
 
     it "includes the correct model class in descendants on the first test run" do
-      ActiveRecord::Base.descendants.detect do |c|
+      descendant = ActiveRecord::Base.descendants.detect do |c|
         c.table_name == BlogPost.table_name
-      end.should == BlogPost
+      end
+      expect(descendant).to eq BlogPost
     end
 
     it "includes the correct model class in descendants on the second test run" do
-      ActiveRecord::Base.descendants.detect do |c|
+      descendant = ActiveRecord::Base.descendants.detect do |c|
         c.table_name == BlogPost.table_name
-      end.should == BlogPost
+      end
+      expect(descendant).to eq BlogPost
+    end
+  end
+
+  context "with 'superclass' option" do
+    class BlogPostParent < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    with_model :BlogPost, superclass: BlogPostParent do
+      table do |t|
+        t.string 'title'
+      end
+    end
+
+    describe "the class" do
+      subject { BlogPost.new }
+      it_should_behave_like "ActiveModel"
+    end
+
+    it "is a subclass of the supplied superclass" do
+      expect(BlogPost < BlogPostParent).to be_true
+    end
+
+    it "is its own base_class" do
+      expect(BlogPost.base_class).to eq BlogPost
+    end
+
+    it "responds to .with_model? with true" do
+      expect(BlogPost.with_model?).to be_true
     end
   end
 end