module RSpec::Its

def is_expected
  expect(__its_subject)
end

end
its(:age) { should eq(25) }
before { subject.age = 25 }
subject { Person.new }
describe Person do

@example

referring to the outer subject.
refer to `subject` in `let` or `before` blocks, you're still
Note that this method does not modify `subject` in any way, so if you

end
end
end
subject.size.should eq(0)
it "should eq(0)", :focus do
describe "size" do
describe Array do
# ... generates the same runtime structure as this:

end
its(:size, :focus) { should eq(0) }
describe Array do
# This ...

@example

some options to the generated example
You can pass more than one arguments on the `its` block to add

end
its(:size) { is_expected.to eq(0) }
describe Array do

@example

to `should` (e.g. for one-liner use)
With an implicit subject, `is_expected` can be used as an alternative

end
its(:count) { should eq(2) }
its(:keys) { should include(:max_users) }
# You can still access to its regular methods this way:

its(['john_doe', :permissions]) { should eq([:read, :write]) }
its(['admin']) { should eq(:all_permissions) }
its([:max_users]) { should eq(3) }

end
'john_doe' => {:permissions => [:read, :write]}}
'admin' => :all_permissions.
{ :max_users => 3,
subject do
describe "a configuration Hash" do

@example

specifying a `Symbol` or `String` in an array.
When the subject is a `Hash`, you can refer to the Hash keys by

end
its("phone_numbers.first") { should eq("555-1212") }

end
end
person.phone_numbers << "555-1212"
Person.new.tap do |person|
subject do
describe Person do

@example

onto the subject in an expression.
with dots, the result is as though you concatenated that `String`
The attribute can be a `Symbol` or a `String`. Given a `String`

end
end
end
subject.size.should eq(0)
it "should eq(0)" do
describe "size" do
describe Array do
# ... generates the same runtime structure as this:

end
its(:size) { should eq(0) }
describe Array do
# This ...

@example

and then generates an example using the submitted block.
Creates a nested example group named by the submitted `attribute`,

def its(attribute, *options, &block)
  its_caller = caller.select {|file_line| file_line !~ %r(/lib/rspec/its) }
  describe(attribute.to_s, :caller => its_caller) do
    let(:__its_subject) do
      if Array === attribute
        if Hash === subject
          attribute.inject(subject) {|inner, attr| inner[attr] }
        else
          subject[*attribute]
        end
      else
        attribute_chain = attribute.to_s.split('.')
        attribute_chain.inject(subject) do |inner_subject, attr|
          inner_subject.send(attr)
        end
      end
    end
    def is_expected
      expect(__its_subject)
    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
    options << { :caller => its_caller }
    example(nil, *options, &block)
  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