remarkable_activerecord 3.1.8 → 3.1.9

data/spec/have_scope_matcher_spec.rb

@@ -1,85 +1,85 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'have_scope' do
-  include ModelBuilder
-
-  before(:each) do
-    @model = define_model :product, :title => :string, :category => :string do
-      named_scope :recent, :order => 'created_at DESC'
-      named_scope :latest, lambda {|c| {:limit => c}}
-      named_scope :since, lambda {|t| {:conditions => ['created_at > ?', t]}}
-      named_scope :between, lambda { |a, b| { :conditions => [ 'created_at > ? and created_at < ?', a, b ] } }
-
-      def self.beginning(c)
-        scoped(:offset => c)
-      end
-
-      def self.null
-        nil
-      end
-    end
-  end
-
-  describe 'messages' do
-
-    it 'should contain a description' do
-      matcher = have_scope(:title)
-      matcher.description.should == 'have to scope itself to {} when :title is called'
-
-      matcher.with(1)
-      matcher.description.should == 'have to scope itself to {} when :title is called with [1] as argument'
-    end
-
-    it 'should set is_scope? message' do
-      matcher = have_scope(:null)
-      matcher.matches?(@model)
-      matcher.failure_message.should == 'Expected :null when called on Product return an instance of ActiveRecord::NamedScope::Scope'
-    end
-
-    it 'should set options_match? message' do
-      matcher = have_scope(:recent, :conditions => {:special => true})
-      matcher.matches?(@model)
-      matcher.failure_message.should == 'Expected :recent when called on Product scope to {:conditions=>{:special=>true}}, got {:order=>"created_at DESC"}'
-    end
-
-  end
-
-  describe 'matchers' do
-    it { should have_scope(:recent) }
-    it { should have_scope(:recent, :order => 'created_at DESC') }
-
-    it { should have_scope(:latest).with(10).limit(10) }
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'have_scope' do
+  include ModelBuilder
+
+  before(:each) do
+    @model = define_model :product, :title => :string, :category => :string do
+      named_scope :recent, :order => 'created_at DESC'
+      named_scope :latest, lambda {|c| {:limit => c}}
+      named_scope :since, lambda {|t| {:conditions => ['created_at > ?', t]}}
+      named_scope :between, lambda { |a, b| { :conditions => [ 'created_at > ? and created_at < ?', a, b ] } }
+
+      def self.beginning(c)
+        scoped(:offset => c)
+      end
+
+      def self.null
+        nil
+      end
+    end
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      matcher = have_scope(:title)
+      matcher.description.should == 'have to scope itself to {} when :title is called'
+
+      matcher.with(1)
+      matcher.description.should == 'have to scope itself to {} when :title is called with [1] as argument'
+    end
+
+    it 'should set is_scope? message' do
+      matcher = have_scope(:null)
+      matcher.matches?(@model)
+      matcher.failure_message.should == 'Expected :null when called on Product return an instance of ActiveRecord::NamedScope::Scope'
+    end
+
+    it 'should set options_match? message' do
+      matcher = have_scope(:recent, :conditions => {:special => true})
+      matcher.matches?(@model)
+      matcher.failure_message.should == 'Expected :recent when called on Product scope to {:conditions=>{:special=>true}}, got {:order=>"created_at DESC"}'
+    end
+
+  end
+
+  describe 'matchers' do
+    it { should have_scope(:recent) }
+    it { should have_scope(:recent, :order => 'created_at DESC') }
+
+    it { should have_scope(:latest).with(10).limit(10) }
     it { should have_scope(:beginning).with(10).offset(10) }
-    it { should have_scope(:since).with(false).conditions(["created_at > ?", false]) }
-    it { should have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(0)]) }
-    it { should have_scope(:between).with(2, 10).conditions(["created_at > ? and created_at < ?", 2, 10]) }
-
+    it { should have_scope(:since).with(false).conditions(["created_at > ?", false]) }
+    it { should have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(0)]) }
+    it { should have_scope(:between).with(2, 10).conditions(["created_at > ? and created_at < ?", 2, 10]) }
+
     it { should_not have_scope(:null) }
-    it { should_not have_scope(:latest).with(5).limit(10) }
-    it { should_not have_scope(:beginning).with(5).offset(10) }
-    it { should_not have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(1)]) }
-    it { should_not have_scope(:between).with(2, 10).conditions(["updated_at > ? and updated_at < ?", 2, 10]) }
-  end
-
-  describe 'macros' do
-    should_have_scope :recent
-    should_have_scope :recent, :order => 'created_at DESC'
-
-    should_have_scope :latest,    :with => 10, :limit => 10
-    should_have_scope :beginning, :with => 10, :offset => 10
+    it { should_not have_scope(:latest).with(5).limit(10) }
+    it { should_not have_scope(:beginning).with(5).offset(10) }
+    it { should_not have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(1)]) }
+    it { should_not have_scope(:between).with(2, 10).conditions(["updated_at > ? and updated_at < ?", 2, 10]) }
+  end
+
+  describe 'macros' do
+    should_have_scope :recent
+    should_have_scope :recent, :order => 'created_at DESC'
+
+    should_have_scope :latest,    :with => 10, :limit => 10
+    should_have_scope :beginning, :with => 10, :offset => 10
     should_have_scope :since,     :with => false, :conditions => ["created_at > ?", false]
-    should_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(0)]
+    should_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(0)]
     should_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "created_at > ? and created_at < ?", 2, 10 ]
 
     should_have_scope :between do |m|
       m.with(2, 10)
       m.conditions([ "created_at > ? and created_at < ?", 2, 10 ])
-    end
-
-    should_not_have_scope :null
-    should_not_have_scope :latest,    :with => 5, :limit => 10
-    should_not_have_scope :beginning, :with => 5, :offset => 10
-    should_not_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(1)]
-    should_not_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "updated_at > ? and updated_at < ?", 2, 10 ]
-  end
-end
+    end
+
+    should_not_have_scope :null
+    should_not_have_scope :latest,    :with => 5, :limit => 10
+    should_not_have_scope :beginning, :with => 5, :offset => 10
+    should_not_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(1)]
+    should_not_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "updated_at > ? and updated_at < ?", 2, 10 ]
+  end
+end

data/spec/model_builder.rb

@@ -1,101 +1,101 @@
-# This is based on Shoulda model builder for Test::Unit.
-#
-module ModelBuilder
-  def self.included(base)
-    return unless base.name =~ /^Spec/
-
-    base.class_eval do
-      after(:each) do
-        if @defined_constants
-          @defined_constants.each do |class_name| 
-            Object.send(:remove_const, class_name)
-          end
-        end
-
-        if @created_tables
-          @created_tables.each do |table_name|
-            ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name}")
-          end
-        end
-      end
-    end
-
-    base.extend ClassMethods
-  end
-
-  def create_table(table_name, &block)
-    connection = ActiveRecord::Base.connection
-
-    begin
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      connection.create_table(table_name, &block)
-      @created_tables ||= []
-      @created_tables << table_name
-      connection
-    rescue Exception => e
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      raise e
-    end
-  end
-
-  def define_constant(class_name, base, &block)
-    class_name = class_name.to_s.camelize
-
-    klass = Class.new(base)
-    Object.const_set(class_name, klass)
-
-    klass.class_eval(&block) if block_given?
-
-    @defined_constants ||= []
-    @defined_constants << class_name
-
-    klass
-  end
-
-  def define_model_class(class_name, &block)
-    define_constant(class_name, ActiveRecord::Base, &block)
-  end
-
-  def define_model(name, columns = {}, &block)
-    class_name = name.to_s.pluralize.classify
-    table_name = class_name.tableize
-
-    table = columns.delete(:table) || lambda {|table|
-      columns.each do |name, type|
-        table.column name, *type
-      end
-    }
-
-    create_table(table_name, &table)
-
-    klass    = define_model_class(class_name, &block)
-    instance = klass.new
-
-    self.class.subject { instance } if self.class.respond_to?(:subject)
-    instance
-  end
-
-  module ClassMethods
-    # This is a macro to run validations of boolean optionals such as :allow_nil
-    # and :allow_blank. This macro tests all scenarios. The specs must have a
-    # define_and_validate method defined.
-    #
-    def create_optional_boolean_specs(optional, base, options={})
-      base.describe "with #{optional} option" do
-        it { should define_and_validate(options.merge(optional => true)).send(optional)            }
-        it { should define_and_validate(options.merge(optional => false)).send(optional, false)    }
-        it { should_not define_and_validate(options.merge(optional => true)).send(optional, false) }
-        it { should_not define_and_validate(options.merge(optional => false)).send(optional)       }
-      end
-    end
-
-    def create_message_specs(base)
-      base.describe "with message option" do
-        it { should define_and_validate(:message => 'valid_message').message('valid_message') }
-        it { should_not define_and_validate(:message => 'not_valid').message('valid_message') }
-      end
-    end
-  end
-
-end
-
+# This is based on Shoulda model builder for Test::Unit.
+#
+module ModelBuilder
+  def self.included(base)
+    return unless base.name =~ /^Spec/
+
+    base.class_eval do
+      after(:each) do
+        if @defined_constants
+          @defined_constants.each do |class_name| 
+            Object.send(:remove_const, class_name)
+          end
+        end
+
+        if @created_tables
+          @created_tables.each do |table_name|
+            ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name}")
+          end
+        end
+      end
+    end
+
+    base.extend ClassMethods
+  end
+
+  def create_table(table_name, &block)
+    connection = ActiveRecord::Base.connection
+
+    begin
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      connection.create_table(table_name, &block)
+      @created_tables ||= []
+      @created_tables << table_name
+      connection
+    rescue Exception => e
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      raise e
+    end
+  end
+
+  def define_constant(class_name, base, &block)
+    class_name = class_name.to_s.camelize
+
+    klass = Class.new(base)
+    Object.const_set(class_name, klass)
+
+    klass.class_eval(&block) if block_given?
+
+    @defined_constants ||= []
+    @defined_constants << class_name
+
+    klass
+  end
+
+  def define_model_class(class_name, &block)
+    define_constant(class_name, ActiveRecord::Base, &block)
+  end
+
+  def define_model(name, columns = {}, &block)
+    class_name = name.to_s.pluralize.classify
+    table_name = class_name.tableize
+
+    table = columns.delete(:table) || lambda {|table|
+      columns.each do |name, type|
+        table.column name, *type
+      end
+    }
+
+    create_table(table_name, &table)
+
+    klass    = define_model_class(class_name, &block)
+    instance = klass.new
+
+    self.class.subject { instance } if self.class.respond_to?(:subject)
+    instance
+  end
+
+  module ClassMethods
+    # This is a macro to run validations of boolean optionals such as :allow_nil
+    # and :allow_blank. This macro tests all scenarios. The specs must have a
+    # define_and_validate method defined.
+    #
+    def create_optional_boolean_specs(optional, base, options={})
+      base.describe "with #{optional} option" do
+        it { should define_and_validate(options.merge(optional => true)).send(optional)            }
+        it { should define_and_validate(options.merge(optional => false)).send(optional, false)    }
+        it { should_not define_and_validate(options.merge(optional => true)).send(optional, false) }
+        it { should_not define_and_validate(options.merge(optional => false)).send(optional)       }
+      end
+    end
+
+    def create_message_specs(base)
+      base.describe "with message option" do
+        it { should define_and_validate(:message => 'valid_message').message('valid_message') }
+        it { should_not define_and_validate(:message => 'not_valid').message('valid_message') }
+      end
+    end
+  end
+
+end
+

data/spec/rcov.opts

@@ -1,2 +1,2 @@
---exclude "spec/*,gems/*" 
+--exclude "spec/*,gems/*" 
 --rails

data/spec/spec.opts

@@ -1,4 +1,4 @@
---colour
---format progress
---loadby mtime
---reverse
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -1,27 +1,27 @@
-# encoding: utf-8
-require 'rubygems'
-
-RAILS_VERSION = ENV['RAILS_VERSION'] || '2.3.2'
-
-gem 'activesupport', RAILS_VERSION
-require 'active_support'
-
-gem 'activerecord', RAILS_VERSION
-require 'active_record'
-
-# Configure ActiveRecord connection
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'sqlite3',
-  :database => ':memory:'
-)
-
-# Load Remarkable core on place to avoid gem to be loaded
-dir = File.dirname(__FILE__)
-require File.join(dir, '..', '..', 'remarkable', 'lib', 'remarkable')
-
-# Load Remarkable ActiveRecord
-require File.join(dir, 'model_builder')
-require File.join(dir, '..', 'lib', 'remarkable_activerecord')
-
-# Include matchers
-Remarkable.include_matchers!(Remarkable::ActiveRecord, Spec::Example::ExampleGroup)
+# encoding: utf-8
+require 'rubygems'
+
+RAILS_VERSION = ENV['RAILS_VERSION'] || '2.3.3'
+
+gem 'activesupport', RAILS_VERSION
+require 'active_support'
+
+gem 'activerecord', RAILS_VERSION
+require 'active_record'
+
+# Configure ActiveRecord connection
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+# Load Remarkable core on place to avoid gem to be loaded
+dir = File.dirname(__FILE__)
+require File.join(dir, '..', '..', 'remarkable', 'lib', 'remarkable')
+
+# Load Remarkable ActiveRecord
+require File.join(dir, 'model_builder')
+require File.join(dir, '..', 'lib', 'remarkable_activerecord')
+
+# Include matchers
+Remarkable.include_matchers!(Remarkable::ActiveRecord, Spec::Example::ExampleGroup)

data/spec/validate_acceptance_of_matcher_spec.rb

@@ -1,68 +1,68 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'validate_acceptance_of' do
-  include ModelBuilder
-
-  # Defines a model, create a validation and returns a raw matcher
-  def define_and_validate(options={})
-    @model = define_model :user, :eula => :string, :terms => :string, :name => :string do
-      validates_acceptance_of :eula, :terms, options
-    end
-
-    validate_acceptance_of(:eula, :terms)
-  end
-
-  describe 'messages' do
-    before(:each){ @matcher = define_and_validate }
-
-    it 'should contain a description' do
-      @matcher.description.should == 'require eula and terms to be accepted'
-
-      @matcher.accept('true')
-      @matcher.description.should == 'require eula and terms to be accepted with value "true"'
-
-      @matcher.allow_nil
-      @matcher.description.should == 'require eula and terms to be accepted with value "true" and allowing nil values'
-    end
-
-    it 'should set requires_acceptance? message' do
-      @matcher = validate_acceptance_of(:name)
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected User to be invalid if name is not accepted'
-    end
-
-    it 'should set accept_is_valid? message' do
-      @matcher.accept('accept_value').matches?(@model)
-      @matcher.failure_message.should == 'Expected User to be valid when eula is accepted with value "accept_value"'
-    end
-
-  end
-
-  describe 'matchers' do
-
-    describe 'without options' do
-      before(:each){ define_and_validate }
-
-      it { should validate_acceptance_of(:eula) }
-      it { should validate_acceptance_of(:eula, :terms) }
-      it { should_not validate_acceptance_of(:eula, :name) }
-    end
-
-    describe 'with accept as option' do
-      it { should define_and_validate(:accept => 'accept_value').accept('accept_value') }
-      it { should_not define_and_validate(:accept => 'another_value').accept('a_value') }
-    end
-
-    create_message_specs(self)
-    create_optional_boolean_specs(:allow_nil, self)
-  end
-
-  describe 'macros' do
-    before(:each){ define_and_validate }
-
-    should_validate_acceptance_of :eula
-    should_validate_acceptance_of :eula, :terms
-    should_not_validate_acceptance_of :eula, :name
-  end
-
-end
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_acceptance_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :user, :eula => :string, :terms => :string, :name => :string do
+      validates_acceptance_of :eula, :terms, options
+    end
+
+    validate_acceptance_of(:eula, :terms)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    it 'should contain a description' do
+      @matcher.description.should == 'require eula and terms to be accepted'
+
+      @matcher.accept('true')
+      @matcher.description.should == 'require eula and terms to be accepted with value "true"'
+
+      @matcher.allow_nil
+      @matcher.description.should == 'require eula and terms to be accepted with value "true" and allowing nil values'
+    end
+
+    it 'should set requires_acceptance? message' do
+      @matcher = validate_acceptance_of(:name)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected User to be invalid if name is not accepted'
+    end
+
+    it 'should set accept_is_valid? message' do
+      @matcher.accept('accept_value').matches?(@model)
+      @matcher.failure_message.should == 'Expected User to be valid when eula is accepted with value "accept_value"'
+    end
+
+  end
+
+  describe 'matchers' do
+
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_acceptance_of(:eula) }
+      it { should validate_acceptance_of(:eula, :terms) }
+      it { should_not validate_acceptance_of(:eula, :name) }
+    end
+
+    describe 'with accept as option' do
+      it { should define_and_validate(:accept => 'accept_value').accept('accept_value') }
+      it { should_not define_and_validate(:accept => 'another_value').accept('a_value') }
+    end
+
+    create_message_specs(self)
+    create_optional_boolean_specs(:allow_nil, self)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate }
+
+    should_validate_acceptance_of :eula
+    should_validate_acceptance_of :eula, :terms
+    should_not_validate_acceptance_of :eula, :name
+  end
+
+end