syllable_counter 0.0.1 → 1.0.0

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_496_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module BugReport496
+  describe "a message expectation on a base class object" do
+    class BaseClass
+    end
+
+    class SubClass < BaseClass
+    end
+
+    it "is received" do
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_600_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module BugReport600
+  describe "stubbing a class method" do
+    class ExampleClass
+      def self.method_that_uses_define_method
+        define_method "defined_method" do |attributes|
+          load_address(address, attributes)
+        end
+      end
+    end
+
+    it "works" do
+      ExampleClass.should_receive(:define_method).with("defined_method")
+      ExampleClass.method_that_uses_define_method
+    end
+
+    it "restores the original method" do
+      ExampleClass.method_that_uses_define_method
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Bug7611
+  describe "A Partial Mock" do
+    class Foo; end
+    class Bar < Foo; end
+
+    it "respects subclasses" do
+      Foo.stub(:new).and_return(Object.new)
+    end
+
+    it "should" do
+      expect(Bar.new.class).to eq Bar
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "An object where respond_to? is true and does not have method" do
+  # When should_receive(message) is sent to any object, the Proxy sends
+  # respond_to?(message) to that object to see if the method should be proxied.
+  #
+  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
+  # to the object, the proxy is invoked and responds yes (if so set in the spec).
+  # When the object does NOT actually respond to `message`, an exception is thrown
+  # when trying to proxy it.
+  #
+  # The fix was to keep track of whether `respond_to?` had been proxied and, if
+  # so, call the munged copy of `respond_to?` on the object.
+
+  it "does not raise an exception for Object" do
+    obj = Object.new
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+  it "does not raise an exception for mock" do
+    obj = double("obj")
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_830_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe 'Calling a method that catches StandardError' do
+      class Foo
+        def self.foo
+          bar
+        rescue StandardError
+        end
+      end
+
+      it 'still reports mock failures' do
+        Foo.should_not_receive :bar
+        expect {
+          Foo.foo
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/bug_report_957_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stubbing a base class class method" do
+      before do
+        @base_class     = Class.new
+        @concrete_class = Class.new(@base_class)
+
+        @base_class.stub(:find).and_return "stubbed_value"
+      end
+
+      it "returns the value for the stub on the base class" do
+        expect(@base_class.find).to eq "stubbed_value"
+      end
+
+      it "returns the value for the descendent class" do
+        expect(@concrete_class.find).to eq "stubbed_value"
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/combining_implementation_instructions_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "Combining implementation instructions" do
+      it 'can combine and_yield and and_return' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return(3)
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(3)
+        }.to yield_with_args(5)
+      end
+
+      describe "combining and_yield, a block implementation and and_return" do
+        def verify_combined_implementation
+          dbl = double
+          (yield dbl).and_yield(5).and_return(3)
+
+          expect { |b|
+            expect(dbl.foo(:arg, &b)).to eq(3)
+          }.to yield_with_args(5)
+
+          expect(@block_called).to be_true
+        end
+
+        it 'works when passing a block to `stub`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `with`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo).with(:arg) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `exactly`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_least`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_most`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `any_number_of_times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).any_number_of_times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `once`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).once { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `twice`' do
+          the_double = nil
+
+          verify_combined_implementation do |dbl|
+            the_double = dbl
+            dbl.should_receive(:foo).twice { @block_called = true }
+          end
+
+          the_double.foo { |a| } # to ensure it is called twice
+        end
+
+        it 'works when passing a block to `ordered`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).ordered { @block_called = true }
+          end
+        end
+      end
+
+      it 'can combine and_yield and and_return with a block' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return { :return }
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(:return)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield and and_raise' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_raise' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'can combine and_yield and and_throw' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_throw' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'returns `nil` from all terminal actions to discourage further configuration' do
+        expect(double.stub(:foo).and_return(1)).to be_nil
+        expect(double.stub(:foo).and_raise("boom")).to be_nil
+        expect(double.stub(:foo).and_throw(:foo)).to be_nil
+      end
+
+      it 'allows the terminal action to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.and_return(1)
+        expect(dbl.foo).to eq(1)
+
+        stubbed_double.and_return(3)
+        expect(dbl.foo).to eq(3)
+
+        stubbed_double.and_raise("boom")
+        expect { dbl.foo }.to raise_error("boom")
+
+        stubbed_double.and_throw(:bar)
+        expect { dbl.foo }.to throw_symbol(:bar)
+      end
+
+      it 'allows the inner implementation block to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.with(:arg) { :with_block }
+        expect(dbl.foo(:arg)).to eq(:with_block)
+
+        stubbed_double.at_least(:once) { :at_least_block }
+        expect(dbl.foo(:arg)).to eq(:at_least_block)
+      end
+
+      it 'can combine and_call_original, with, and_return' do
+        obj = Struct.new(:value).new('original')
+        obj.stub(:value).and_call_original
+        obj.stub(:value).with(:arg).and_return('value')
+        expect(obj.value).to eq 'original'
+        expect(obj.value(:arg)).to eq 'value'
+      end
+
+      it 'raises an error if `and_call_original` is followed by any other instructions' do
+        dbl = [1, 2, 3]
+        stubbed = dbl.stub(:size)
+        stubbed.and_call_original
+
+        msg_fragment = /cannot be modified further/
+
+        expect { stubbed.and_yield }.to raise_error(msg_fragment)
+        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
+        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
+        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
+
+        expect { stubbed.once { } }.to raise_error(msg_fragment)
+
+        expect(dbl.size).to eq(3)
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.14.3/spec/rspec/mocks/configuration_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Configuration do
+      let(:config) { Configuration.new }
+      let(:mod_1)  { Module.new }
+      let(:mod_2)  { Module.new }
+
+      def instance_methods_of(mod)
+        mod_1.instance_methods.map(&:to_sym)
+      end
+
+      it 'adds stub and should_receive to the given modules' do
+        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
+
+        config.add_stub_and_should_receive_to(mod_1, mod_2)
+
+        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
+      end
+
+      shared_examples_for "configuring the syntax" do
+        def sandboxed
+          orig_syntax = RSpec::Mocks.configuration.syntax
+          yield
+        ensure
+          configure_syntax(orig_syntax)
+        end
+
+        around(:each) { |ex| sandboxed(&ex) }
+        let(:dbl) { double }
+        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
+        let(:should_class_methods) { [:any_instance] }
+        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
+
+        it 'defaults to enabling both the :should and :expect syntaxes' do
+          expect(dbl).to respond_to(*should_methods)
+          expect(self).to respond_to(*expect_methods)
+        end
+
+        context 'when configured to :expect' do
+          before { configure_syntax :expect }
+
+          it 'removes the should methods from every object' do
+            expect(dbl).not_to respond_to(*should_methods)
+          end
+
+          it 'removes `any_instance` from every class' do
+            expect(Class.new).not_to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :expect' do
+            expect(configured_syntax).to eq([:expect])
+          end
+
+          it 'is a no-op when configured a second time' do
+            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
+            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
+            configure_syntax :expect
+          end
+        end
+
+        context 'when configured to :should' do
+          before { configure_syntax :should }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'removes the expect methods from the example group context' do
+            expect(self).not_to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :should' do
+            expect(configured_syntax).to eq([:should])
+          end
+
+          it 'is a no-op when configured a second time' do
+            Syntax.default_should_syntax_host.should_not_receive(:method_added)
+            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
+            configure_syntax :should
+          end
+        end
+
+        context 'when configured to [:should, :expect]' do
+          before { configure_syntax [:should, :expect] }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that both syntaxes are enabled' do
+            expect(configured_syntax).to eq([:should, :expect])
+          end
+        end
+      end
+
+      describe "configuring rspec-mocks directly" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec::Mocks.configuration.syntax = syntax
+          end
+
+          def configured_syntax
+            RSpec::Mocks.configuration.syntax
+          end
+        end
+      end
+
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.syntax = syntax
+              end
+            end
+          end
+
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                return c.syntax
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+