rspec-core 2.12.2 → 2.13.0

data/lib/rspec/core/let.rb

@@ -1,110 +0,0 @@
-module RSpec
-  module Core
-    module Let
-
-      module ExampleGroupMethods
-        # Generates a method whose return value is memoized after the first
-        # call. Useful for reducing duplication between examples that assign
-        # values to the same local variable.
-        #
-        # @note `let` _can_ enhance readability when used sparingly (1,2, or
-        #   maybe 3 declarations) in any given example group, but that can
-        #   quickly degrade with overuse. YMMV.
-        #
-        # @note `let` uses an `||=` conditional that has the potential to
-        #   behave in surprising ways in examples that spawn separate threads,
-        #   though we have yet to see this in practice. You've been warned.
-        #
-        # @example
-        #
-        #   describe Thing do
-        #     let(:thing) { Thing.new }
-        #
-        #     it "does something" do
-        #       # first invocation, executes block, memoizes and returns result
-        #       thing.do_something
-        #
-        #       # second invocation, returns the memoized value
-        #       thing.should be_something
-        #     end
-        #   end
-        def let(name, &block)
-          define_method(name) do
-            __memoized.fetch(name) {|k| __memoized[k] = instance_eval(&block) }
-          end
-        end
-
-        # Just like `let`, except the block is invoked by an implicit `before`
-        # hook. This serves a dual purpose of setting up state and providing a
-        # memoized reference to that state.
-        #
-        # @example
-        #
-        #   class Thing
-        #     def self.count
-        #       @count ||= 0
-        #     end
-        #
-        #     def self.count=(val)
-        #       @count += val
-        #     end
-        #
-        #     def self.reset_count
-        #       @count = 0
-        #     end
-        #
-        #     def initialize
-        #       self.class.count += 1
-        #     end
-        #   end
-        #
-        #   describe Thing do
-        #     after(:each) { Thing.reset_count }
-        #
-        #     context "using let" do
-        #       let(:thing) { Thing.new }
-        #
-        #       it "is not invoked implicitly" do
-        #         Thing.count.should eq(0)
-        #       end
-        #
-        #       it "can be invoked explicitly" do
-        #         thing
-        #         Thing.count.should eq(1)
-        #       end
-        #     end
-        #
-        #     context "using let!" do
-        #       let!(:thing) { Thing.new }
-        #
-        #       it "is invoked implicitly" do
-        #         Thing.count.should eq(1)
-        #       end
-        #
-        #       it "returns memoized version on first invocation" do
-        #         thing
-        #         Thing.count.should eq(1)
-        #       end
-        #     end
-        #   end
-        def let!(name, &block)
-          let(name, &block)
-          before { __send__(name) }
-        end
-      end
-
-      # @private
-      module ExampleMethods
-        # @private
-        def __memoized
-          @__memoized ||= {}
-        end
-      end
-
-      def self.included(mod)
-        mod.extend ExampleGroupMethods
-        mod.__send__ :include, ExampleMethods
-      end
-    end
-  end
-end

data/lib/rspec/core/subject.rb

@@ -1,223 +0,0 @@
-module RSpec
-  module Core
-    module Subject
-      module ExampleMethods
-        # Returns the example group's `subject`.
-        #
-        # @note `subject` was contributed by Joe Ferris to support the one-liner
-        #   syntax embraced by shoulda matchers:
-        #
-        #       describe Widget do
-        #         it { should validate_presence_of(:name) }
-        #       end
-        #
-        #   While the examples below demonstrate how to use `subject`
-        #   explicitly in examples, we recommend that you define a method with
-        #   an intention revealing name instead.
-        #
-        # @example
-        #
-        #   # explicit declaration of subject
-        #   describe Person do
-        #     subject { Person.new(:birthdate => 19.years.ago) }
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #       # ^ ^ explicit reference to subject not recommended
-        #     end
-        #   end
-        #
-        #   # implicit subject => { Person.new }
-        #   describe Person do
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #       # ^ ^ explicit reference to subject not recommended
-        #     end
-        #   end
-        #
-        #   # one-liner syntax - should is invoked on subject
-        #   describe Person do
-        #     it { should be_eligible_to_vote }
-        #   end
-        #
-        # @see ExampleGroupMethods#subject
-        # @see #should
-        def subject
-          if defined?(@original_subject)
-            @original_subject
-          else
-            @original_subject = instance_eval(&self.class.subject)
-          end
-        end
-
-        # When `should` is called with no explicit receiver, the call is
-        # delegated to the object returned by `subject`. Combined with an
-        # implicit subject this supports very concise expressions.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     it { should be_eligible_to_vote }
-        #   end
-        #
-        # @see #subject
-        def should(matcher=nil, message=nil)
-          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(subject, matcher, message)
-        end
-
-        # Just like `should`, `should_not` delegates to the subject (implicit or
-        # explicit) of the example group.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     it { should_not be_eligible_to_vote }
-        #   end
-        #
-        # @see #subject
-        def should_not(matcher=nil, message=nil)
-          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(subject, matcher, message)
-        end
-
-        private
-
-        def _attribute_chain(attribute)
-          attribute.to_s.split('.')
-        end
-
-        def _nested_attribute(subject, attribute)
-          _attribute_chain(attribute).inject(subject) do |inner_subject, attr|
-            inner_subject.send(attr)
-          end
-        end
-      end
-
-      module ExampleGroupMethods
-        # 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
-        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
-
-        # Declares a `subject` for an example group which can then be the
-        # implicit receiver (through delegation) of calls to `should`.
-        #
-        # Given a `name`, defines a method with that name which returns the
-        # `subject`. This lets you declare the subject once and access it
-        # implicitly in one-liners and explicitly using an intention revealing
-        # name.
-        #
-        # @param [String,Symbol] name used to define an accessor with an
-        #   intention revealing name
-        # @param block defines the value to be returned by `subject` in examples
-        #
-        # @example
-        #
-        #   describe CheckingAccount, "with $50" do
-        #     subject { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { should have_a_balance_of(Money.new(50, :USD)) }
-        #     it { should_not be_overdrawn }
-        #   end
-        #
-        #   describe CheckingAccount, "with a non-zero starting balance" do
-        #     subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { should_not be_overdrawn }
-        #     it "has a balance equal to the starting balance" do
-        #       account.balance.should eq(Money.new(50, :USD))
-        #     end
-        #   end
-        #
-        # @see ExampleMethods#subject
-        # @see ExampleMethods#should
-        def subject(name=nil, &block)
-          if name
-            let(name, &block)
-            subject { send name }
-          else
-            block ? @explicit_subject_block = block : explicit_subject || implicit_subject
-          end
-        end
-
-        attr_reader :explicit_subject_block
-
-        private
-
-        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
-    end
-  end
-end

data/spec/rspec/core/let_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe "#let" do
-  let(:counter) do
-    Class.new do
-      def initialize
-        @count = 0
-      end
-      def count
-        @count += 1
-      end
-    end.new
-  end
-
-  let(:nil_value) do
-    @nil_value_count += 1
-    nil
-  end
-
-  it "generates an instance method" do
-    counter.count.should eq(1)
-  end
-
-  it "caches the value" do
-    counter.count.should eq(1)
-    counter.count.should eq(2)
-  end
-
-  it "caches a nil value" do
-    @nil_value_count = 0
-    nil_value
-    nil_value
-
-    @nil_value_count.should eq(1)
-  end
-end
-
-describe "#let!" do
-  let!(:creator) do
-    Class.new do
-      @count = 0
-      def self.count
-        @count += 1
-      end
-    end
-  end
-
-  it "evaluates the value non-lazily" do
-    lambda { creator.count }.should_not raise_error
-  end
-
-  it "does not interfere between tests" do
-    creator.count.should eq(1)
-  end
-end

data/spec/rspec/core/subject_spec.rb

@@ -1,255 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Core
-
-  describe Subject do
-    before(:each) { RSpec.configuration.configure_expectation_framework }
-
-    describe "implicit subject" do
-      describe "with a class" do
-        it "returns an instance of the class" do
-          ExampleGroup.describe(Array).subject.call.should eq([])
-        end
-      end
-
-      describe "with a Module" do
-        it "returns the Module" do
-          ExampleGroup.describe(Enumerable).subject.call.should eq(Enumerable)
-        end
-      end
-
-      describe "with a string" do
-        it "return the string" do
-          ExampleGroup.describe("Foo").subject.call.should eq("Foo")
-        end
-      end
-
-      describe "with a number" do
-        it "returns the number" do
-          ExampleGroup.describe(15).subject.call.should eq(15)
-        end
-      end
-
-    end
-
-    describe "explicit subject" do
-      [false, nil].each do |falsy_value|
-        context "with a value of #{falsy_value.inspect}" do
-          it "is evaluated once per example" do
-            group = ExampleGroup.describe(Array)
-            group.before do
-              Object.should_receive(:this_question?).once.and_return(falsy_value)
-            end
-            group.subject do
-              Object.this_question?
-            end
-            group.example do
-              subject
-              subject
-            end
-            group.run.should be_true, "expected subject block to be evaluated only once"
-          end
-        end
-      end
-
-      describe "defined in a top level group" do
-        it "replaces the implicit subject in that group" do
-          group = ExampleGroup.describe(Array)
-          group.subject { [1,2,3] }
-          group.subject.call.should eq([1,2,3])
-        end
-      end
-
-      describe "defined in a top level group" do
-        let(:group) do
-          ExampleGroup.describe do
-            subject{ [4,5,6] }
-          end
-        end
-
-        it "is available in a nested group (subclass)" do
-          nested_group = group.describe("I'm nested!") { }
-          nested_group.subject.call.should eq([4,5,6])
-        end
-
-        it "is available in a doubly nested group (subclass)" do
-          nested_group = group.describe("Nesting level 1") { }
-          doubly_nested_group = nested_group.describe("Nesting level 2") { }
-          doubly_nested_group.subject.call.should eq([4,5,6])
-        end
-      end
-
-      describe "with a name" do
-        it "defines a method that returns the memoized subject" do
-          group = ExampleGroup.describe do
-            subject(:list) { [1,2,3] }
-            example do
-              list.should equal(list)
-              subject.should equal(subject)
-              subject.should equal(list)
-            end
-          end
-          group.run.should be_true
-        end
-
-        it "is referred from inside subject by the name" do
-          group = ExampleGroup.describe do
-            subject(:list) { [1,2,3] }
-            describe 'first' do
-              subject(:first_element) { list.first }
-              it { should eq(1) }
-            end
-          end
-          group.run.should be_true
-        end
-      end
-    end
-
-    context "using 'self' as an explicit subject" do
-      it "delegates matcher to the ExampleGroup" do
-        group = ExampleGroup.describe("group") do
-          subject { self }
-          def ok?; true; end
-          def not_ok?; false; end
-
-          it { should eq(self) }
-          it { should be_ok }
-          it { should_not be_not_ok }
-        end
-
-        group.run.should be_true
-      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
-
-          group.run.should be_true
-        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
-    end
-  end
-end