module RSpec::Core::Subject::ExampleGroupMethods

def explicit_subject
  group = self
  while group.respond_to?(:explicit_subject_block)
    return group.explicit_subject_block if group.explicit_subject_block
    group = group.superclass
  end
end

def implicit_subject
  described = described_class || description
  Class === described ? proc { described.new } : proc { described }
end

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

its(['admin']) { should eq(:all_permissions) }
its([:max_users]) { should eq(3) }

end
'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, &block)
  describe(attribute) do
    example do
      self.class.class_eval do
        define_method(:subject) do
          if defined?(@_subject)
            @_subject
          else
            @_subject = Array === attribute ? super()[*attribute] : _nested_attribute(super(), attribute)
          end
        end
      end
      instance_eval(&block)
    end
  end
end

Other tags:

See: ExampleMethods#should -
See: ExampleMethods#subject -

Parameters:

• block () -- defines the value to be returned by `subject` in examples
• name (String, Symbol) -- used to define an accessor with an

def subject(name=nil, &block)
  define_method(name) { subject } if name
  block ? @explicit_subject_block = block : explicit_subject || implicit_subject
end