yeti 0.3.17 → 0.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bbd8487f2f17ceeec1a08a107737d2f13cdce68
-  data.tar.gz: 21d17721e0460e747ba55b552fd18208cb7cc6ff
+  metadata.gz: cbc3c3c5ad3cf40d7070a5e0473e57bdc346e20e
+  data.tar.gz: 442fabcf40e47bfa938a03fe3986f401a9ee6ec4
 SHA512:
-  metadata.gz: 599f03ea7b706f6ba33972bbd2a3272f4b1d7086e9a60ae9dc17f21c5e7304a85c744800922e4049e179ad409dcbbd3ab904fb74a3bc41cd53ed0f97595f18d7
-  data.tar.gz: daeb6e68efadacf59c330fc1f1dd8cc33185d6c628fa88036cc59f7ccd7f9d65383ccb08e2c6b949700495d81ac65073706821941d069e065dc700477611d0c1
+  metadata.gz: c2ed3b0d2ba92511d0b978cf930f4e6a5b0000b9f28fcc3e3b1a1ddc0107c2bda885cc13fef6e227bb1439dc7730b20605e5226ae436e91fb2ec9342c67f53e8
+  data.tar.gz: b73b9b438afe64808eadf24a023daa733c1c11f50683c0991c277edc936df39ff10102049cf3d05cde83e11f09e35e4887ddb9199c2bcc876a1a02065aefdbd9

data/.ruby-version

@@ -1 +1 @@
-2.1.1
+2.1.2

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in yeti.gemspec
 gemspec
+
+# Fix I18n.enforce_available_locales deprecation warning
+gem "i18n", github: "svenfuchs/i18n"

data/lib/yeti/errors.rb

@@ -15,7 +15,7 @@ module Yeti
       def normalize_message(attribute, message, options)
         message ||= :invalid
         if untranslated? && !message.is_a?(Proc)
-          message
+          options.fetch :message, message
         else
           super
         end

data/lib/yeti/version.rb

@@ -1,3 +1,3 @@
 module Yeti
-  VERSION = "0.3.17"
+  VERSION = "0.3.18"
 end

data/spec/support/matchers.rb

@@ -1,6 +1,6 @@
 RSpec::Matchers.define :delegates do |delegated_method|
   match do |subject|
-    stubbed = send(@delegate).stub(@delegate_method)
+    stubbed = allow(send @delegate).to receive @delegate_method
     stubbed.with @delegate_params if @delegate_params
     stubbed.and_return expected=double
     subject.send(delegated_method) === expected
@@ -25,11 +25,11 @@ RSpec::Matchers.define :delegates do |delegated_method|
     "delegates #{delegated_method} to #{@delegate}#{delegate_method}#{delegate_params}"
   end
 
-  failure_message_for_should do |text|
+  failure_message do |text|
     "expected delegation of #{delegated_method} to #{@delegate}"
   end
 
-  failure_message_for_should do |text|
+  failure_message do |text|
     "do not expected delegation of #{delegated_method} to #{@delegate}"
   end
 end

data/spec/yeti/context_spec.rb

@@ -3,20 +3,20 @@ require "spec_helper"
 describe Yeti::Context do
   context "without hash" do
     it "#account is an instance of Yeti::Context::NoAccount" do
-      Yeti::Context.new.account.should be_kind_of Yeti::Context::NoAccount
+      expect(Yeti::Context.new.account).to be_kind_of Yeti::Context::NoAccount
     end
   end
   context "when account_id is not in hash" do
     it "#account is an instance of Yeti::Context::NoAccount" do
-      Yeti::Context.new({}).account.should be_kind_of Yeti::Context::NoAccount
+      expect(Yeti::Context.new({}).account).to be_kind_of Yeti::Context::NoAccount
     end
   end
   context "when account_id is nil" do
     subject{ Yeti::Context.new account_id: nil }
     it "#account is an instance of Yeti::Context::NoAccount" do
-      subject.account.should be_kind_of Yeti::Context::NoAccount
+      expect(subject.account).to be_kind_of Yeti::Context::NoAccount
     end
-    it("#account_id is nil"){ subject.account_id.should be_nil }
+    it("#account_id is nil"){ expect(subject.account_id).to be_nil }
     it "no account can be overriden by subclasses" do
       subclass = Class.new Yeti::Context do
         def no_account
@@ -24,14 +24,14 @@ describe Yeti::Context do
         end
       end
       subject = subclass.new account_id: nil
-      subject.account.should == :custom_no_account
+      expect(subject.account).to eq(:custom_no_account)
     end
   end
   context "when account_id" do
     subject{ Yeti::Context.new account_id: 1 }
     it "uses find_account_by_id to find account" do
-      subject.stub(:find_account_by_id).with(1).and_return(expected = double)
-      subject.account.should be expected
+      allow(subject).to receive(:find_account_by_id).with(1).and_return(expected = double)
+      expect(subject.account).to be expected
     end
     it "#find_account_by_id is virtual" do
       expect do
@@ -39,8 +39,8 @@ describe Yeti::Context do
       end.to raise_error NotImplementedError
     end
     it "#account_id returns account.id" do
-      subject.stub(:find_account_by_id).with(1).and_return double(id: 2)
-      subject.account_id.should be 2
+      allow(subject).to receive(:find_account_by_id).with(1).and_return double(id: 2)
+      expect(subject.account_id).to be 2
     end
   end
 end

data/spec/yeti/editor_spec.rb

@@ -17,9 +17,9 @@ describe ::Yeti::Editor do
     let(:new_object){ double :new_object }
     let(:existing_object){ double :existing_object }
     context "with context only" do
-      before{ described_class.stub(:new_object).with(context).and_return new_object }
+      before{ allow(described_class).to receive(:new_object).with(context).and_return new_object }
       it "keeps given context" do
-        subject.context.should be context
+        expect(subject.context).to be context
       end
       it "#persist! is virtual" do
         expect do
@@ -27,29 +27,29 @@ describe ::Yeti::Editor do
         end.to raise_error NotImplementedError, "Yeti::Editor#persist!"
       end
       it "uses .new_object to initialize edited object" do
-        subject.edited.should == new_object
+        expect(subject.edited).to eq(new_object)
       end
       it "delegates id to edited object" do
-        should delegates(:id).to :new_object
+        is_expected.to delegates(:id).to :new_object
       end
       it "delegates to_param to edited object" do
-        should delegates(:to_param).to :new_object
+        is_expected.to delegates(:to_param).to :new_object
       end
       it "delegates persisted? edited object" do
-        should delegates(:persisted?).to :new_object
+        is_expected.to delegates(:persisted?).to :new_object
       end
       it ".new_object can be nil" do
-        described_class.stub :new_object
-        subject.edited.should be_nil
-        subject.id.should be_nil
-        subject.to_param.should be_nil
-        subject.should_not be_persisted
+        allow(described_class).to receive :new_object
+        expect(subject.edited).to be_nil
+        expect(subject.id).to be_nil
+        expect(subject.to_param).to be_nil
+        expect(subject).not_to be_persisted
       end
     end
     context "initialize with context and object to edit" do
       subject{ described_class.new context, existing_object }
       it "keeps given context" do
-        subject.context.should be context
+        expect(subject.context).to be context
       end
       it "#persist! is virtual" do
         expect do
@@ -57,13 +57,13 @@ describe ::Yeti::Editor do
         end.to raise_error NotImplementedError, "Yeti::Editor#persist!"
       end
       it "delegates id to edited object" do
-        should delegates(:id).to :existing_object
+        is_expected.to delegates(:id).to :existing_object
       end
       it "delegates to_param to edited object" do
-        should delegates(:to_param).to :existing_object
+        is_expected.to delegates(:to_param).to :existing_object
       end
       it "delegates persisted? edited object" do
-        should delegates(:persisted?).to :existing_object
+        is_expected.to delegates(:persisted?).to :existing_object
       end
     end
   end
@@ -74,37 +74,37 @@ describe ::Yeti::Editor do
     context "when given_id is nil" do
       let(:given_id){ nil }
       it "uses .new_object to generate object to edit" do
-        described_class.should_receive(:new_object).with(context).and_return new_object
-        subject.edited.should be new_object
+        expect(described_class).to receive(:new_object).with(context).and_return new_object
+        expect(subject.edited).to be new_object
       end
     end
     context "when given_id is not nil" do
       let(:given_id){ "1" }
       it "uses .find_by_id to find object to edit" do
-        described_class.should_receive(:find_by_id).with(context, "1").and_return do
+        expect(described_class).to receive(:find_by_id).with(context, "1") do
           existing_object
         end
-        subject.edited.should be existing_object
-        subject.id.should be 1
+        expect(subject.edited).to be existing_object
+        expect(subject.id).to be 1
       end
     end
   end
   context "when not valid" do
     it "#save returns false" do
-      subject.should_receive(:valid?).and_return false
-      subject.should_not_receive :persist!
-      subject.save.should be false
+      expect(subject).to receive(:valid?).and_return false
+      expect(subject).not_to receive :persist!
+      expect(subject.save).to be false
     end
     it "#save(validate: false) calls persist! then returns true" do
-      subject.should_not_receive :valid?
-      subject.should_receive :persist!
-      subject.save(validate: false).should be true
+      expect(subject).not_to receive :valid?
+      expect(subject).to receive :persist!
+      expect(subject.save(validate: false)).to be true
     end
   end
   context "when valid" do
     it "#save calls persist! then returns true" do
-      subject.should_receive :persist!
-      subject.save.should be true
+      expect(subject).to receive :persist!
+      expect(subject.save).to be true
     end
   end
   context "editor of one record" do
@@ -116,118 +116,137 @@ describe ::Yeti::Editor do
           "ObjectEditor"
         end
         def self.new_object(context)
-          Struct.new(:id, :name).new nil, nil
+          Struct.new(:id, :name, :password).new nil, nil, nil
         end
       end
     end
     context "new record" do
-      its(:id){ should be_nil }
-      its(:name){ should be_nil }
+      describe '#id' do
+        subject { super().id }
+        it { is_expected.to be_nil }
+      end
+
+      describe '#name' do
+        subject { super().name }
+        it { is_expected.to be_nil }
+      end
       it "#name= don't touch value if it's not a string" do
         subject.name = ["test"]
-        subject.name.should == ["test"]
+        expect(subject.name).to eq(["test"])
       end
       it "#name= cleans the value of harmful content if it's a string" do
         subject.name = "\tInfected\210\004"
-        subject.name.should == "Infected"
+        expect(subject.name).to eq("Infected")
       end
       it "#name= accepts nil" do
         subject.name = "Valid"
         subject.name = nil
-        subject.name.should be_nil
+        expect(subject.name).to be_nil
       end
       it "#attributes returns a hash" do
-        subject.attributes.should == {name: nil}
+        expect(subject.attributes).to eq({name: nil})
       end
       it "#attributes= assigns each attribute" do
-        subject.should_receive(:name=).with "Anthony"
+        expect(subject).to receive(:name=).with "Anthony"
         subject.attributes = {name: "Anthony"}
       end
       it "#attributes= skips unknown attributes" do
         subject.attributes = {unknown: "Anthony"}
+        expect(subject.attributes).to eq({name: nil})
       end
       context "before validation" do
-        its(:errors){ should be_empty }
-        it{ should be_without_error }
+        describe '#errors' do
+          subject { super().errors }
+          it { is_expected.to be_empty }
+        end
+        it{ is_expected.to be_without_error }
       end
       context "after validation" do
         it "has an error on name" do
           subject.valid?
-          subject.errors[:name].should have(1).item
-          subject.errors[:name].should == ["can't be blank"]
+          expect(subject.errors[:name].size).to eq(1)
+          expect(subject.errors[:name]).to eq(["can't be blank"])
         end
         it "is not without_error? anymore" do
           subject.valid?
-          subject.should_not be_without_error
+          expect(subject).not_to be_without_error
         end
         it "can return untranslated error messages" do
           described_class.class_eval do
             dont_translate_error_messages
           end
           subject.valid?
-          subject.errors[:name].should == [:blank]
+          expect(subject.errors[:name]).to eq([:blank])
+        end
+        it "message can be overridden" do
+          described_class.class_eval do
+            attribute :password
+            validates_presence_of :password, message: "overridden message"
+          end
+          subject.valid?
+          expect(subject.errors[:password]).to eq(["overridden message"])
         end
       end
       context "when name is empty" do
-        it{ should_not be_valid }
+        it{ is_expected.not_to be_valid }
       end
       context "when name is changed" do
         before{ subject.name = "Anthony" }
-        it{ should be_valid }
+        it{ is_expected.to be_valid }
         it "#attributes is updated" do
-          subject.attributes.should == {name: "Anthony"}
+          expect(subject.attributes).to eq({name: "Anthony"})
         end
-        it("name is updated"){ subject.name.should == "Anthony" }
-        it("name is dirty"){ subject.name_changed?.should be true }
+        it("name is updated"){ expect(subject.name).to eq("Anthony") }
+        it("name is dirty"){ expect(subject.name_changed?).to be true }
         it "name isn't dirty anymore if original value is set back" do
           subject.name = nil
-          subject.name_changed?.should be false
+          expect(subject.name_changed?).to be false
         end
       end
       context "after save" do
         before do
           subject.name = "Anthony"
-          subject.stub :persist!
+          allow(subject).to receive :persist!
           subject.save
         end
         it "resets dirty attributes" do
-          subject.name_changed?.should be false
+          expect(subject.name_changed?).to be false
         end
         it "still knows previous changes" do
-          subject.previous_changes.should == {"name"=>[nil, "Anthony"]}
+          expect(subject.previous_changes).to eq({"name"=>[nil, "Anthony"]})
         end
       end
     end
     context "existing record" do
       let(:existing_object){ double :existing_object, id: 1, name: "Anthony" }
       subject{ described_class.new context, existing_object }
-      it("gets id from record"){ subject.id.should be 1 }
+      it("gets id from record"){ expect(subject.id).to be 1 }
       it "gets name from record" do
-        subject.name.should == "Anthony"
+        expect(subject.name).to eq("Anthony")
       end
-      it{ should be_valid }
+      it{ is_expected.to be_valid }
       it "output formatting can be customized" do
-        subject.stub(:format_output).with("Anthony", {
+        allow(subject).to receive(:format_output).with("Anthony", {
           attribute_name: :name,
           from: :edited,
         }).and_return(expected = double)
-        subject.name.should be expected
+        expect(subject.name).to be expected
       end
       it "input formatting can be customized" do
-        subject.stub(:format_input).with("Tony", {
+        allow(subject).to receive(:format_input).with("Tony", {
           attribute_name: :name,
           from: :edited,
         }).and_return(expected = double)
         subject.name = "Tony"
-        subject.name.should be expected
+        expect(subject.name).to be expected
       end
       context "when name is changed" do
         before{ subject.name = nil }
-        it("name is updated"){ subject.name.should be_nil }
-        it("name is dirty"){ subject.name_changed?.should be true }
+        it("name is updated"){ expect(subject.name).to be_nil }
+        it("name is dirty"){ expect(subject.name_changed?).to be true }
         it "name isn't dirty anymore if original value is set back" do
           subject.name = "Anthony"
-          subject.name_changed?.should be false
+          expect(subject.name_changed?).to be false
         end
       end
     end
@@ -257,27 +276,30 @@ describe ::Yeti::Editor do
       end.new context, existing_object
     end
     it "attribute default value comes from edited" do
-      subject.id.should == 1
-      subject.name.should == "Anthony"
+      expect(subject.id).to eq(1)
+      expect(subject.name).to eq("Anthony")
     end
     it "attribute value can come from another object" do
-      subject.description.should == "Business man"
+      expect(subject.description).to eq("Business man")
     end
     it "attribute value can come from nowhere" do
-      subject.password.should be_nil
+      expect(subject.password).to be_nil
     end
     it "attribute value can come from specified method on self" do
-      subject.timestamp.should == "2001-01-01"
+      expect(subject.timestamp).to eq("2001-01-01")
     end
     it "attribute value can come from specified method on another object" do
-      subject.related_id.should == 2
+      expect(subject.related_id).to eq(2)
     end
     it "attribute raises if value cannot be found in source" do
       expect{ subject.invalid }.to raise_error NoMethodError
     end
+    it "calling an undefined method doesn't trigger a stack overflow" do
+      expect{ subject.undefined }.to raise_error NoMethodError
+    end
     it "do not assign default value on access" do
-      subject.with_default_from_another_attribute.should eq(2)
-      subject.instance_variable_get(:@with_default_from_another_attribute).should be_nil
+      expect(subject.with_default_from_another_attribute).to eq(2)
+      expect(subject.instance_variable_get(:@with_default_from_another_attribute)).to be_nil
     end
   end
   describe "#mandatory?" do
@@ -289,13 +311,13 @@ describe ::Yeti::Editor do
       end.new context
     end
     it "is true for an attribute with validates_presence_of" do
-      subject.mandatory?(:name).should be true
+      expect(subject.mandatory?(:name)).to be true
     end
     it "is false for an attribute without validates_presence_of" do
-      subject.mandatory?(:password).should be false
+      expect(subject.mandatory?(:password)).to be false
     end
     it "is false for an invalid attribute" do
-      subject.mandatory?(:invalid).should be false
+      expect(subject.mandatory?(:invalid)).to be false
     end
   end
   describe "equality" do
@@ -303,41 +325,41 @@ describe ::Yeti::Editor do
     let(:another){ double :object, id: 2, persisted?: true }
     subject{ described_class.from_id context, 1 }
     before do
-      described_class.stub(:find_by_id).with(context, 1).and_return existing
-      described_class.stub(:find_by_id).with(context, 2).and_return another
-      described_class.stub(:new_object).with(context).and_return do
+      allow(described_class).to receive(:find_by_id).with(context, 1).and_return existing
+      allow(described_class).to receive(:find_by_id).with(context, 2).and_return another
+      allow(described_class).to receive(:new_object).with(context) do
         double persisted?: false, id: nil
       end
     end
     it "two new editors are not equal" do
       subject = described_class.new context
       other = described_class.new context
-      subject.should_not == other
-      subject.should_not eql other
-      subject.hash.should == other.hash
+      expect(subject).not_to eq(other)
+      expect(subject).not_to eql other
+      expect(subject.hash).to eq(other.hash)
     end
     it "two editors of the same class with the same id are equal" do
       other = described_class.from_id context, 1
-      subject.should == other
-      subject.should eql other
-      subject.hash.should == other.hash
+      expect(subject).to eq(other)
+      expect(subject).to eql other
+      expect(subject.hash).to eq(other.hash)
     end
     it "two editors of the same class with different ids are not equal" do
       other = described_class.from_id context, 2
-      subject.should_not == other
-      subject.should_not eql other
-      subject.hash.should_not == other.hash
+      expect(subject).not_to eq(other)
+      expect(subject).not_to eql other
+      expect(subject.hash).not_to eq(other.hash)
     end
     it "two editors of different classes with the same id are not equal" do
       other = Class.new(described_class).from_id context, 1
-      subject.should_not == other
-      subject.should_not eql other
-      subject.hash.should == other.hash
+      expect(subject).not_to eq(other)
+      expect(subject).not_to eql other
+      expect(subject.hash).to eq(other.hash)
     end
   end
   describe "#attributes_for_persist" do
     subject{ described_class.new context }
-    before{ described_class.stub(:new_object).with(context).and_return record }
+    before{ allow(described_class).to receive(:new_object).with(context).and_return record }
     context "parses date format" do
       let :described_class do
         Class.new ::Yeti::Editor do
@@ -347,31 +369,31 @@ describe ::Yeti::Editor do
       let(:record){ double :new_record, valid_from: Date.parse("2002-09-01") }
       it "when a new value is assigned" do
         subject.valid_from = "2002-12-31"
-        subject.attributes.should == {valid_from: "2002-12-31"}
-        subject.attributes_for_persist.should == {
+        expect(subject.attributes).to eq({valid_from: "2002-12-31"})
+        expect(subject.attributes_for_persist).to eq({
           valid_from: Date.parse("2002-12-31")
-        }
+        })
       end
       it "without new value" do
-        subject.attributes.should == {valid_from: Date.parse("2002-09-01")}
-        subject.attributes_for_persist.should == {
+        expect(subject.attributes).to eq({valid_from: Date.parse("2002-09-01")})
+        expect(subject.attributes_for_persist).to eq({
           valid_from: Date.parse("2002-09-01")
-        }
+        })
       end
       it "when nil is assigned" do
         subject.valid_from = nil
-        subject.attributes.should == {valid_from: nil}
-        subject.attributes_for_persist.should == {valid_from: nil}
+        expect(subject.attributes).to eq({valid_from: nil})
+        expect(subject.attributes_for_persist).to eq({valid_from: nil})
       end
       it "when date is assigned" do
         today = Date.today
         subject.valid_from = today
-        subject.attributes.should == {valid_from: today}
-        subject.attributes_for_persist.should == {valid_from: today}
+        expect(subject.attributes).to eq({valid_from: today})
+        expect(subject.attributes_for_persist).to eq({valid_from: today})
       end
       it "when incorrect value is assigned" do
         subject.valid_from = "2002-13-31"
-        subject.attributes.should == {valid_from: "2002-13-31"}
+        expect(subject.attributes).to eq({valid_from: "2002-13-31"})
         expect do
           subject.attributes_for_persist
         end.to raise_error ::Yeti::Editor::InvalidDate, "2002-13-31"
@@ -386,18 +408,18 @@ describe ::Yeti::Editor do
       let(:record){ double :new_record, name: nil }
       it "uses format_input_for_persist on each value" do
         subject.name = "Tony"
-        subject.should_receive(:format_input_for_persist).with(
+        expect(subject).to receive(:format_input_for_persist).with(
           "Tony",
           attribute_name: :name,
           from: :edited
         ).and_return "Anthony"
-        subject.attributes_for_persist.should == {name: "Anthony"}
+        expect(subject.attributes_for_persist).to eq({name: "Anthony"})
       end
     end
   end
   describe "allows defining additional attributes in subclass" do
     subject{ described_class.new context }
-    before{ described_class.stub(:new_object).with(context).and_return record }
+    before{ allow(described_class).to receive(:new_object).with(context).and_return record }
     let(:record){ double :new_record, name: "Anthony", password: "tony" }
     let :parent_class do
       Class.new ::Yeti::Editor do
@@ -410,21 +432,21 @@ describe ::Yeti::Editor do
       end
     end
     it "merges attributes from parent" do
-      subject.attributes.should == {
+      expect(subject.attributes).to eq({
         name: "Anthony",
         password: "tony",
-      }
+      })
     end
   end
   context "#update_attributes" do
     it "can be called without argument" do
-      subject.should_receive(:attributes=).with({})
-      subject.should_receive(:save).and_return(expected = double)
+      expect(subject).to receive(:attributes=).with({})
+      expect(subject).to receive(:save).and_return(expected = double)
       expect( subject.update_attributes ).to be expected
     end
     it "can be called with attributes" do
-      subject.should_receive(:attributes=).with name: "Anthony"
-      subject.should_receive(:save).and_return(expected = double)
+      expect(subject).to receive(:attributes=).with name: "Anthony"
+      expect(subject).to receive(:save).and_return(expected = double)
       expect( subject.update_attributes name: "Anthony" ).to be expected
     end
   end

data/spec/yeti/search_spec.rb

@@ -13,16 +13,16 @@ describe Yeti::Search do
   context "given context and an empty hash" do
     subject{ Yeti::Search.new context, {} }
     it "keeps given context" do
-      subject.context.should be context
+      expect(subject.context).to be context
     end
     it "#search defaults to {}" do
-      subject.search.should == {}
+      expect(subject.search).to eq({})
     end
     it "#page defaults to 1" do
-      subject.page.should == 1
+      expect(subject.page).to eq(1)
     end
     it "#per_page defaults to 20" do
-      subject.per_page.should == 20
+      expect(subject.per_page).to eq(20)
     end
   end
   context "given context and params" do
@@ -37,65 +37,65 @@ describe Yeti::Search do
     end
     let(:results){ double :results }
     subject{ Yeti::Search.new context, search: search }
-    before{ subject.stub(:results).and_return results }
+    before{ allow(subject).to receive(:results).and_return results }
     it "#search comes from hash" do
-      subject.search.should == search
+      expect(subject.search).to eq(search)
     end
     it "gets common filters from search" do
-      subject.should respond_to(:name_contains)
-      subject.should respond_to(:popular_equals)
-      subject.should respond_to(:created_at_gte)
-      subject.should respond_to(:created_at_lte)
-      subject.name_contains.should == "tony"
-      subject.popular_equals.should == "1"
-      subject.created_at_gte.should == "2001-01-01"
-      subject.created_at_lte.should == "2002-01-01"
+      expect(subject).to respond_to(:name_contains)
+      expect(subject).to respond_to(:popular_equals)
+      expect(subject).to respond_to(:created_at_gte)
+      expect(subject).to respond_to(:created_at_lte)
+      expect(subject.name_contains).to eq("tony")
+      expect(subject.popular_equals).to eq("1")
+      expect(subject.created_at_gte).to eq("2001-01-01")
+      expect(subject.created_at_lte).to eq("2002-01-01")
     end
     it "doesn't get everything from search" do
-      subject.should_not respond_to(:uncommon_filter)
+      expect(subject).not_to respond_to(:uncommon_filter)
       expect{ subject.invalid_method }.to raise_error NoMethodError
       expect{ subject.uncommon_filter }.to raise_error NoMethodError
     end
     it "#page comes from hash" do
-      Yeti::Search.new(context, page: "2").page.should be 2
+      expect(Yeti::Search.new(context, page: "2").page).to be 2
     end
     it "doesn't accept page to be lower than 1" do
-      Yeti::Search.new(context, page: "0").page.should be 1
+      expect(Yeti::Search.new(context, page: "0").page).to be 1
     end
     it "#per_page comes from hash" do
-      Yeti::Search.new(context, per_page: "10").per_page.should be 10
+      expect(Yeti::Search.new(context, per_page: "10").per_page).to be 10
     end
     it "doesn't accept per_page to be lower than 1" do
-      Yeti::Search.new(context, per_page: "0").per_page.should be 1
+      expect(Yeti::Search.new(context, per_page: "0").per_page).to be 1
     end
     it "by default per_page has no limit" do
-      Yeti::Search.max_per_page.should be_nil
-      Yeti::Search.new(context, per_page: "9999").per_page.should be 9999
+      expect(Yeti::Search.max_per_page).to be_nil
+      expect(Yeti::Search.new(context, per_page: "9999").per_page).to be 9999
     end
     it "per_page can be limited" do
       search_class = Class.new Yeti::Search do
         max_per_page 50
       end
-      search_class.max_per_page.should be 50
-      search_class.new(context, per_page: "9999").per_page.should be 50
+      expect(search_class.max_per_page).to be 50
+      expect(search_class.new(context, per_page: "9999").per_page).to be 50
     end
     it "#paginated_results is virtual" do
       expect do
         subject.paginated_results
       end.to raise_error NotImplementedError
     end
-    it{ should delegates(:to_ary).to :results }
-    it{ should delegates(:empty?).to :results }
-    it{ should delegates(:each).to :results }
-    it{ should delegates(:group_by).to :results }
-    it{ should delegates(:size).to :results }
+    it{ is_expected.to delegates(:to_ary).to :results }
+    it{ is_expected.to delegates(:empty?).to :results }
+    it{ is_expected.to delegates(:each).to :results }
+    it{ is_expected.to delegates(:group_by).to :results }
+    it{ is_expected.to delegates(:size).to :results }
   end
   context "when paginated_results is defined" do
     let(:paginated_results){ double :paginated_results }
     subject{ Yeti::Search.new context, {} }
-    before{ subject.stub(:paginated_results).and_return paginated_results }
-    it{ should delegates(:page_count).to :paginated_results }
-    it{ should delegates(:count).to "paginated_results#pagination_record_count" }
-    it{ should delegates(:results).to "paginated_results#all" }
+    before{ allow(subject).to receive(:paginated_results).and_return paginated_results }
+    it{ is_expected.to delegates(:page_count).to :paginated_results }
+    it{ is_expected.to delegates(:count).to "paginated_results#pagination_record_count" }
+    it{ is_expected.to delegates(:results).to "paginated_results#all" }
   end
 end

data/spec/yeti/viewer_spec.rb

@@ -11,29 +11,29 @@ describe ::Yeti::Viewer do
     let(:existing_object){ double :existing_object }
     subject{ described_class.new context, existing_object }
     it "keeps given context" do
-      subject.context.should be context
+      expect(subject.context).to be context
     end
     it "keeps given object to decorate" do
-      subject.decorated.should be existing_object
+      expect(subject.decorated).to be existing_object
     end
     it "delegates id to decorated object" do
-      should delegates(:id).to :existing_object
+      is_expected.to delegates(:id).to :existing_object
     end
     it "delegates to_param to decorated object" do
-      should delegates(:to_param).to :existing_object
+      is_expected.to delegates(:to_param).to :existing_object
     end
     it "delegates persisted? decorated object" do
-      should delegates(:persisted?).to :existing_object
+      is_expected.to delegates(:persisted?).to :existing_object
     end
   end
   describe ".from_id(context, given_id)" do
     let(:existing_object){ double :existing_object }
     subject{ described_class.from_id context, "1" }
     it "uses .find_by_id to find object to edit" do
-      described_class.should_receive(:find_by_id).with(context, "1").and_return do
+      expect(described_class).to receive(:find_by_id).with(context, "1") do
         existing_object
       end
-      subject.decorated.should be existing_object
+      expect(subject.decorated).to be existing_object
     end
   end
   describe "equality" do
@@ -41,26 +41,26 @@ describe ::Yeti::Viewer do
     let(:another){ double :object, id: 2 }
     subject{ described_class.from_id context, 1 }
     before do
-      described_class.stub(:find_by_id).with(context, 1).and_return existing
-      described_class.stub(:find_by_id).with(context, 2).and_return another
+      allow(described_class).to receive(:find_by_id).with(context, 1).and_return existing
+      allow(described_class).to receive(:find_by_id).with(context, 2).and_return another
     end
     it "two viewers of the same class with the same id are equal" do
       other = described_class.from_id context, 1
-      subject.should == other
-      subject.should eql other
-      subject.hash.should == other.hash
+      expect(subject).to eq(other)
+      expect(subject).to eql other
+      expect(subject.hash).to eq(other.hash)
     end
     it "two viewers of the same class with different ids are not equal" do
       other = described_class.from_id context, 2
-      subject.should_not == other
-      subject.should_not eql other
-      subject.hash.should_not == other.hash
+      expect(subject).not_to eq(other)
+      expect(subject).not_to eql other
+      expect(subject.hash).not_to eq(other.hash)
     end
     it "two viewers of different classes with the same id are not equal" do
       other = Class.new(described_class).from_id context, 1
-      subject.should_not == other
-      subject.should_not eql other
-      subject.hash.should == other.hash
+      expect(subject).not_to eq(other)
+      expect(subject).not_to eql other
+      expect(subject.hash).to eq(other.hash)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeti
 version: !ruby/object:Gem::Version
-  version: 0.3.17
+  version: 0.3.18
 platform: ruby
 authors:
 - Joseph HALTER
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-07 00:00:00.000000000 Z
+date: 2014-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel