Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove "its" support as part of rspec-core issue #1083 #1095

Merged
merged 1 commit into from
Oct 3, 2013
Merged

Remove "its" support as part of rspec-core issue #1083 #1095

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
1 change: 1 addition & 0 deletions Changelog.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,7 @@ Breaking Changes for 3.0.0:
* Extract Autotest support to a seperate gem (Jon Rowe)
* Raise an error when a `let` or `subject` declaration is
accessed in a `before(:all)` or `after(:all)` hook. (Myron Marston)
* Extract `its` support to a separate gem (Peter Alfvin)

Enhancements

Expand Down
124 changes: 0 additions & 124 deletions features/subject/attribute_of_subject.feature
View file
Open in desktop

This file was deleted.

90 changes: 0 additions & 90 deletions lib/rspec/core/memoized_helpers.rb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -364,96 +364,6 @@ def subject!(name=nil, &block)
subject(name, &block)
before { subject }
end

# Creates a nested example group named by the submitted `attribute`,
# and then generates an example using the submitted block.
#
# @example
#
# # This ...
# describe Array do
# its(:size) { should eq(0) }
# end
#
# # ... generates the same runtime structure as this:
# describe Array do
# describe "size" do
# it "should eq(0)" do
# subject.size.should eq(0)
# end
# end
# end
#
# The attribute can be a `Symbol` or a `String`. Given a `String`
# with dots, the result is as though you concatenated that `String`
# onto the subject in an expression.
#
# @example
#
# describe Person do
# subject do
# Person.new.tap do |person|
# person.phone_numbers << "555-1212"
# end
# end
#
# its("phone_numbers.first") { should eq("555-1212") }
# end
#
# When the subject is a `Hash`, you can refer to the Hash keys by
# specifying a `Symbol` or `String` in an array.
#
# @example
#
# describe "a configuration Hash" do
# subject do
# { :max_users => 3,
# 'admin' => :all_permissions }
# end
#
# its([:max_users]) { should eq(3) }
# its(['admin']) { should eq(:all_permissions) }
#
# # You can still access to its regular methods this way:
# its(:keys) { should include(:max_users) }
# its(:count) { should eq(2) }
# end
#
# Note that this method does not modify `subject` in any way, so if you
# refer to `subject` in `let` or `before` blocks, you're still
# referring to the outer subject.
#
# @example
#
# describe Person do
# subject { Person.new }
# before { subject.age = 25 }
# its(:age) { should eq(25) }
# end
def its(attribute, &block)
describe(attribute) do
if Array === attribute
let(:__its_subject) { subject[*attribute] }
else
let(:__its_subject) do
attribute_chain = attribute.to_s.split('.')
attribute_chain.inject(subject) do |inner_subject, attr|
inner_subject.send(attr)
end
end
end

def should(matcher=nil, message=nil)
RSpec::Expectations::PositiveExpectationHandler.handle_matcher(__its_subject, matcher, message)
end

def should_not(matcher=nil, message=nil)
RSpec::Expectations::NegativeExpectationHandler.handle_matcher(__its_subject, matcher, message)
end

example(&block)
end
end
end

# @api private
Expand Down
145 changes: 0 additions & 145 deletions spec/rspec/core/memoized_helpers_spec.rb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -302,151 +302,6 @@ def not_ok?; false; end
end
end

describe "#its" do
subject do
Class.new do
def initialize
@call_count = 0
end

def call_count
@call_count += 1
end
end.new
end

context "with a call counter" do
its(:call_count) { should eq(1) }
end

context "with nil value" do
subject do
Class.new do
def nil_value
nil
end
end.new
end
its(:nil_value) { should be_nil }
end

context "with nested attributes" do
subject do
Class.new do
def name
"John"
end
end.new
end
its("name") { should eq("John") }
its("name.size") { should eq(4) }
its("name.size.class") { should eq(Fixnum) }
end

context "when it responds to #[]" do
subject do
Class.new do
def [](*objects)
objects.map do |object|
"#{object.class}: #{object.to_s}"
end.join("; ")
end

def name
"George"
end
end.new
end
its([:a]) { should eq("Symbol: a") }
its(['a']) { should eq("String: a") }
its([:b, 'c', 4]) { should eq("Symbol: b; String: c; Fixnum: 4") }
its(:name) { should eq("George") }
context "when referring to an attribute without the proper array syntax" do
context "it raises an error" do
its(:age) do
expect do
should eq(64)
end.to raise_error(NoMethodError)
end
end
end
end

context "when it does not respond to #[]" do
subject { Object.new }

context "it raises an error" do
its([:a]) do
expect do
should eq("Symbol: a")
end.to raise_error(NoMethodError)
end
end
end

context "calling and overriding super" do
it "calls to the subject defined in the parent group" do
group = ExampleGroup.describe(Array) do
subject { [1, 'a'] }

its(:last) { should eq("a") }

describe '.first' do
def subject; super().first; end

its(:next) { should eq(2) }
end
end

expect(group.run).to be_truthy
end
end

context "with nil subject" do
subject do
Class.new do
def initialize
@counter = -1
end
def nil_if_first_time
@counter += 1
@counter == 0 ? nil : true
end
end.new
end
its(:nil_if_first_time) { should be(nil) }
end

context "with false subject" do
subject do
Class.new do
def initialize
@counter = -1
end
def false_if_first_time
@counter += 1
@counter > 0
end
end.new
end
its(:false_if_first_time) { should be(false) }
end

describe 'accessing `subject` in `before` and `let`' do
subject { 'my subject' }
before { @subject_in_before = subject }
let(:subject_in_let) { subject }
let!(:eager_loaded_subject_in_let) { subject }

# These examples read weird, because we're actually
# specifying the behaviour of `its` itself
its(nil) { expect(subject).to eq('my subject') }
its(nil) { expect(@subject_in_before).to eq('my subject') }
its(nil) { expect(subject_in_let).to eq('my subject') }
its(nil) { expect(eager_loaded_subject_in_let).to eq('my subject') }
end
end

describe '#subject!' do
let(:prepared_array) { [1,2,3] }
subject! { prepared_array.pop }
Expand Down