syllable_counter 0.0.1 → 1.0.0

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "double" do
+  it "is an alias for stub and mock" do
+    expect(double()).to be_a(RSpec::Mocks::Mock)
+  end
+
+  it "uses 'Double' in failure messages" do
+    double = double('name')
+    expect {double.foo}.to raise_error(/Double "name" received/)
+  end
+
+  describe "deprecated aliases" do
+    it "warns if #stub is used" do
+      expect(RSpec).to receive(:deprecate).with("stub", :replacement => "double")
+      stub("TestDouble")
+    end
+
+    it "warns if #mock is used" do
+      expect(RSpec).to receive(:deprecate).with("mock", :replacement => "double")
+      mock("TestDouble")
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Marshal, 'extensions' do
+  # An object that raises when code attempts to dup it.
+  #
+  # Because we manipulate the internals of RSpec::Mocks.space below, we need
+  # an object that simply blows up when #dup is called without using any
+  # partial mocking or stubbing from rspec-mocks itself.
+  class UndupableObject
+    def dup
+      raise NotImplementedError
+    end
+  end
+
+  describe '#dump' do
+    context 'when rspec-mocks has not been fully initialized' do
+      def without_space
+        stashed_space, RSpec::Mocks.space = RSpec::Mocks.space, nil
+        yield
+      ensure
+        RSpec::Mocks.space = stashed_space
+      end
+
+      it 'does not duplicate the object before serialization' do
+        obj = UndupableObject.new
+        without_space do
+          serialized = Marshal.dump(obj)
+          expect(Marshal.load(serialized)).to be_an(UndupableObject)
+        end
+      end
+    end
+
+    context 'when rspec-mocks has been fully initialized' do
+      it 'duplicates objects with stubbed or mocked implementations before serialization' do
+        obj = double(:foo => "bar")
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(obj.class)
+      end
+
+      it 'does not duplicate other objects before serialization' do
+        obj = UndupableObject.new
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(UndupableObject)
+      end
+
+      it 'does not duplicate nil before serialization' do
+        serialized = Marshal.dump(nil)
+        expect(Marshal.load(serialized)).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "failing MockArgumentMatchers" do
+      before(:each) do
+        @double = double("double")
+        @reporter = double("reporter").as_null_object
+      end
+
+      after(:each) do
+        reset @double
+      end
+
+      it "rejects non boolean" do
+        @double.should_receive(:random_call).with(boolean())
+        expect do
+          @double.random_call("false")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non numeric" do
+        @double.should_receive(:random_call).with(an_instance_of(Numeric))
+        expect do
+          @double.random_call("1")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non string" do
+        @double.should_receive(:random_call).with(an_instance_of(String))
+        expect do
+          @double.random_call(123)
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects goose when expecting a duck" do
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted string" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails for a hash w/ wrong values" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call(:a => "b", :c => "e")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+
+      it "fails for a hash w/ wrong keys" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call("a" => "b", "c" => "d")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+
+      it "matches against a Matcher" do
+        expect do
+          @double.should_receive(:msg).with(equal(3))
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+      end
+
+      it "fails no_args with one arg" do
+        expect do
+          @double.should_receive(:msg).with(no_args)
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+      end
+
+      it "fails hash_including with missing key" do
+         expect do
+           @double.should_receive(:msg).with(hash_including(:a => 1))
+           @double.msg({})
+         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+      end
+
+      it "fails with block matchers" do
+        expect do
+          @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
+          @double.msg :no_msg_for_you
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+
+      it "fails with sensible message when args respond to #description" do
+        arg = Class.new do
+          def description
+          end
+
+          def inspect
+            "my_thing"
+          end
+        end.new
+
+        expect do
+          @double.should_receive(:msg).with(3)
+          @double.msg arg
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (3)\n       got: (my_thing)")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashExcludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
+        end
+
+        describe "passing" do
+          it "matches a hash without the specified key" do
+            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches a hash with the specified key, but different value" do
+            expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches a hash without the specified key, given as anything()" do
+            expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches an empty hash" do
+            expect(hash_not_including(:a)).to eq({})
+          end
+
+          it "matches a hash without any of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
+          end
+
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_not_including(:a => 1)).not_to eq 1
+          end
+
+          it "does not match a hash with a specified key" do
+            expect(hash_not_including(:b)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with the specified key/value pair" do
+            expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with the specified key" do
+            expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with one of the specified keys" do
+            expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with some of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with one key/value pair included" do
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashIncludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+        end
+
+        describe "passing" do
+          it "matches the same hash" do
+            expect(hash_including(:a => 1)).to eq({:a => 1})
+          end
+
+          it "matches a hash with extra stuff" do
+            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
+          end
+
+          describe "when matching against other matchers" do
+            it "matches an int against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches a string against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
+            end
+          end
+
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "matches if the key is present" do
+              expect(hash_including(:a)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if more keys are present" do
+              expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
+            end
+
+            it "matches a string against a given key" do
+              expect(hash_including(:a)).to eq({:a => "1", :b => 2})
+            end
+
+            it "matches if passed one key and one key/value pair" do
+              expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if passed many keys and one key/value pair" do
+              expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
+            end
+
+            it "matches if passed many keys and many key/value pairs" do
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
+            end
+          end
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_including(:a => 1)).not_to eq 1
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a => 1)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a)).not_to eq(:b => 2)
+          end
+
+          it "does not match an empty hash with a given key" do
+            expect(hash_including(:a)).not_to eq({})
+          end
+
+          it "does not match a hash with a missing key when one pair is matching" do
+            expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with an incorrect value" do
+            expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
+          end
+
+          it "does not match when values are nil but keys are different" do
+            expect(hash_including(:a => nil)).not_to eq(:b => nil)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe InstanceMethodStasher do
+      class ExampleClass
+        def hello
+          :hello_defined_on_class
+        end
+      end
+
+      def singleton_class_for(obj)
+        class << obj; self; end
+      end
+
+      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :hello_defined_on_singleton_class
+      end
+
+      it "stashes private instance methods" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+        singleton_class_for(obj).__send__(:private, :hello)
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        stashed_method.restore
+        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
+      end
+
+      it "only stashes methods directly defined on the given class, not its ancestors" do
+        obj = ExampleClass.new
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end;
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :overridden_hello
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Matchers::HaveReceived do
+      describe "expect(...).to have_received" do
+        it 'passes when the double has received the given message' do
+          dbl = double_with_met_expectation(:expected_method)
+          expect(dbl).to have_received(:expected_method)
+        end
+
+        it 'passes when a null object has received the given message' do
+          dbl = null_object_with_met_expectation(:expected_method)
+          expect(dbl).to have_received(:expected_method)
+        end
+
+        it 'fails when the double has not received the given message' do
+          dbl = double_with_unmet_expectation(:expected_method)
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/expected: 1 time/)
+        end
+
+        it 'fails when a null object has not received the given message' do
+          dbl = double.as_null_object
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/expected: 1 time/)
+        end
+
+        it 'fails when the method has not been previously stubbed' do
+          dbl = double
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/method has not been stubbed/)
+        end
+
+        it 'fails when the method has been mocked' do
+          dbl = double
+          dbl.should_receive(:expected_method)
+          dbl.expected_method
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/method has been mocked instead of stubbed/)
+        end
+
+        it 'resets expectations on class methods when mocks are reset' do
+          dbl = Object
+          dbl.stub(:expected_method)
+          dbl.expected_method
+          reset dbl
+          dbl.stub(:expected_method)
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/0 times/)
+        end
+
+        context "with" do
+          it 'passes when the given args match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+            expect(dbl).to have_received(:expected_method).with(:expected, :args)
+          end
+
+          it 'fails when the given args do not match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+
+            expect {
+              expect(dbl).to have_received(:expected_method).with(:unexpected, :args)
+            }.to raise_error(/with unexpected arguments/)
+          end
+        end
+
+        it 'generates a useful description' do
+          matcher = have_received(:expected_method).with(:expected_args).once
+          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
+        end
+
+        context "counts" do
+          let(:dbl) { double(:expected_method => nil) }
+
+          before do
+            dbl.expected_method
+            dbl.expected_method
+            dbl.expected_method
+          end
+
+          context "exactly" do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).exactly(3).times
+            end
+
+            it 'fails when the message was received more times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).exactly(2).times
+              }.to raise_error(/expected: 2 times.*received: 3 times/m)
+            end
+
+            it 'fails when the message was received fewer times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).exactly(4).times
+              }.to raise_error(/expected: 4 times.*received: 3 times/m)
+            end
+          end
+
+          context 'at_least' do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).at_least(3).times
+            end
+
+            it 'passes when the message was received more times' do
+              expect(dbl).to have_received(:expected_method).at_least(2).times
+            end
+
+            it 'fails when the message was received fewer times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).at_least(4).times
+              }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
+            end
+          end
+
+          context 'at_most' do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).at_most(3).times
+            end
+
+            it 'passes when the message was received fewer times' do
+              expect(dbl).to have_received(:expected_method).at_most(4).times
+            end
+
+            it 'fails when the message was received more times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).at_most(2).times
+              }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
+            end
+          end
+
+          context 'once' do
+            it 'passes when the message was received once' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              expect(dbl).to have_received(:expected_method).once
+            end
+
+            it 'fails when the message was never received' do
+              dbl = double(:expected_method => nil)
+
+              expect {
+                expect(dbl).to have_received(:expected_method).once
+              }.to raise_error(/expected: 1 time.*received: 0 times/m)
+            end
+
+            it 'fails when the message was received twice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).once
+              }.to raise_error(/expected: 1 time.*received: 2 times/m)
+            end
+          end
+
+          context 'twice' do
+            it 'passes when the message was received twice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+
+              expect(dbl).to have_received(:expected_method).twice
+            end
+
+            it 'fails when the message was received once' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).twice
+              }.to raise_error(/expected: 2 times.*received: 1 time/m)
+            end
+
+            it 'fails when the message was received thrice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).twice
+              }.to raise_error(/expected: 2 times.*received: 3 times/m)
+            end
+          end
+        end
+      end
+
+      describe "expect(...).not_to have_received" do
+        it 'passes when the double has not received the given message' do
+          dbl = double_with_unmet_expectation(:expected_method)
+          expect(dbl).not_to have_received(:expected_method)
+        end
+
+        it 'fails when the double has received the given message' do
+          dbl = double_with_met_expectation(:expected_method)
+
+          expect {
+            expect(dbl).not_to have_received(:expected_method)
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'fails when the method has not been previously stubbed' do
+          dbl = double
+
+          expect {
+            expect(dbl).not_to have_received(:expected_method)
+          }.to raise_error(/method has not been stubbed/)
+        end
+
+        context "with" do
+          it 'passes when the given args do not match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+            expect(dbl).not_to have_received(:expected_method).with(:unexpected, :args)
+          end
+
+          it 'fails when the given args match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+
+            expect {
+              expect(dbl).not_to have_received(:expected_method).with(:expected, :args)
+            }.to raise_error(/expected: 0 times.*received: 1 time/m) # TODO: better message
+          end
+        end
+
+        %w(exactly at_least at_most times once twice).each do |constraint|
+          it "does not allow #{constraint} to be used because it creates confusion" do
+            dbl = double_with_unmet_expectation(:expected_method)
+            expect {
+              expect(dbl).not_to have_received(:expected_method).send(constraint)
+            }.to raise_error(/can't use #{constraint} when negative/)
+          end
+        end
+      end
+
+      def double_with_met_expectation(method_name, *args)
+        double = double_with_unmet_expectation(method_name)
+        meet_expectation(double, method_name, *args)
+      end
+
+      def null_object_with_met_expectation(method_name, *args)
+        meet_expectation(double.as_null_object, method_name, *args)
+      end
+
+      def meet_expectation(double, method_name, *args)
+        double.send(method_name, *args)
+        double
+      end
+
+      def double_with_unmet_expectation(method_name)
+        double('double', method_name => true)
+      end
+    end
+  end
+end