syllable_counter 0.0.1 → 1.0.0

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/deprecation.rb

@@ -0,0 +1,18 @@
+module RSpec
+  module Mocks
+    module Deprecation
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def deprecate(deprecated, options={})
+        message = "DEPRECATION: #{deprecated} is deprecated."
+        message << " Use #{options[:replacement]} instead." if options[:replacement]
+        message << " Called from #{caller(0)[2]}."
+        warn message
+      end
+    end
+  end
+
+  extend(Mocks::Deprecation) unless respond_to?(:deprecate)
+end
+

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/error_generator.rb

@@ -0,0 +1,179 @@
+module RSpec
+  module Mocks
+    # @private
+    class ErrorGenerator
+      attr_writer :opts
+
+      def initialize(target, name, options={})
+        @declared_as = options[:__declared_as] || 'Mock'
+        @target = target
+        @name = name
+      end
+
+      # @private
+      def opts
+        @opts ||= {}
+      end
+
+      # @private
+      def raise_unexpected_message_error(message, *args)
+        __raise "#{intro} received unexpected message :#{message}#{arg_message(*args)}"
+      end
+
+      # @private
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_missing_default_stub_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}\n Please stub a default value first if message might be received with other args as well. \n"
+      end
+
+      # @private
+      def raise_similar_message_args_error(expectation, *args_for_multiple_calls)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args_for_multiple_calls.collect {|a| format_received_args(*a)}.join(", ")
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, *args)
+        expected_part = expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        received_part = received_part_of_expectation_error(actual_received_count, *args)
+        __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
+      end
+
+      # @private
+      def received_part_of_expectation_error(actual_received_count, *args)
+        "received: #{count_message(actual_received_count)}" +
+          method_call_args_description(args)
+      end
+
+      # @private
+      def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        "expected: #{count_message(expected_received_count, expectation_count_type)}" +
+          method_call_args_description(argument_list_matcher.expected_args)
+      end
+
+      # @private
+      def method_call_args_description(args)
+        if args.first.is_a?(ArgumentMatchers::AnyArgsMatcher)
+          " with any arguments"
+        elsif args.first.is_a?(ArgumentMatchers::NoArgsMatcher)
+          " with no arguments"
+        elsif args.length > 0
+          " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+        else
+          ""
+        end
+      end
+
+      # @private
+      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+        "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
+      end
+
+      # @private
+      def raise_out_of_order_error(message)
+        __raise "#{intro} received :#{message} out of order"
+      end
+
+      # @private
+      def raise_block_failed_error(message, detail)
+        __raise "#{intro} received :#{message} but passed block failed with: #{detail}"
+      end
+
+      # @private
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+
+      # @private
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+
+      # @private
+      def raise_only_valid_on_a_partial_mock(method)
+        __raise "#{intro} is a pure mock object. `#{method}` is only " +
+                "available on a partial mock object."
+      end
+
+      # @private
+      def raise_expectation_on_unstubbed_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has not been stubbed."
+      end
+
+      # @private
+      def raise_expectation_on_mocked_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has been mocked instead of stubbed."
+      end
+
+      def self.raise_double_negation_error(wrapped_expression)
+        raise "Isn't life confusing enough? You've already set a " +
+              "negative message expectation and now you are trying to " +
+              "negate it again with `never`. What does an expression like " +
+              "`#{wrapped_expression}.not_to receive(:msg).never` even mean?"
+      end
+
+      private
+
+      def intro
+        if @name
+          "#{@declared_as} #{@name.inspect}"
+        elsif TestDouble === @target
+          @declared_as
+        elsif Class === @target
+          "<#{@target.inspect} (class)>"
+        elsif @target
+          @target
+        else
+          "nil"
+        end
+      end
+
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+      end
+
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
+      end
+
+      def format_received_args(*args)
+        args.empty? ? "(no args)" : "(" + received_arg_list(*args) + ")"
+      end
+
+      def received_arg_list(*args)
+        args.collect(&:inspect).join(", ")
+      end
+
+      def count_message(count, expectation_count_type=nil)
+        return "at least #{pretty_print(count.abs)}" if count < 0 || expectation_count_type == :at_least
+        return "at most #{pretty_print(count)}" if expectation_count_type == :at_most
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        "#{count} time#{count == 1 ? '' : 's'}"
+      end
+
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/errors.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Mocks
+    # @private
+    class MockExpectationError < Exception
+    end
+
+    # @private
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/example_methods.rb

@@ -0,0 +1,156 @@
+module RSpec
+  module Mocks
+    module ExampleMethods
+      include RSpec::Mocks::ArgumentMatchers
+
+      # @overload double()
+      # @overload double(name)
+      # @overload double(stubs)
+      # @overload double(name, stubs)
+      # @param name [String/Symbol] (optional) used in
+      #   clarify intent
+      # @param stubs (Hash) (optional) hash of method/return-value pairs
+      # @return (Mock)
+      #
+      # Constructs an instance of [RSpec::Mocks::Mock](RSpec::Mocks::Mock) configured
+      # with an optional name, used for reporting in failure messages, and an optional
+      # hash of method/return-value pairs.
+      #
+      # @example
+      #
+      #   book = double("book", :title => "The RSpec Book")
+      #   book.title #=> "The RSpec Book"
+      #
+      #   card = double("card", :suit => "Spades", :rank => "A")
+      #   card.suit  #=> "Spades"
+      #   card.rank  #=> "A"
+      #
+      # @see #mock
+      # @see #stub
+      def double(*args)
+        declare_double('Double', *args)
+      end
+
+      # Deprecated: Use [double](#double-instance_method).
+      def mock(*args)
+        RSpec.deprecate "mock", :replacement => "double"
+        declare_double('Mock', *args)
+      end
+
+      # Deprecated: Use [double](#double-instance_method).
+      def stub(*args)
+        RSpec.deprecate "stub", :replacement => "double"
+        declare_double('Stub', *args)
+      end
+
+      # Disables warning messages about expectations being set on nil.
+      #
+      # By default warning messages are issued when expectations are set on
+      # nil.  This is to prevent false-positives and to catch potential bugs
+      # early on.
+      def allow_message_expectations_on_nil
+        RSpec::Mocks.space.proxy_for(nil).warn_about_expectations = false
+      end
+
+      # Stubs the named constant with the given value.
+      # Like method stubs, the constant will be restored
+      # to its original value (or lack of one, if it was
+      # undefined) when the example completes.
+      #
+      # @param constant_name [String] The fully qualified name of the constant. The current
+      #   constant scoping at the point of call is not considered.
+      # @param value [Object] The value to make the constant refer to. When the
+      #   example completes, the constant will be restored to its prior state.
+      # @param options [Hash] Stubbing options.
+      # @option options :transfer_nested_constants [Boolean, Array<Symbol>] Determines
+      #   what nested constants, if any, will be transferred from the original value
+      #   of the constant to the new value of the constant. This only works if both
+      #   the original and new values are modules (or classes).
+      # @return [Object] the stubbed value of the constant
+      #
+      # @example
+      #
+      #   stub_const("MyClass", Class.new) # => Replaces (or defines) MyClass with a new class object.
+      #   stub_const("SomeModel::PER_PAGE", 5) # => Sets SomeModel::PER_PAGE to 5.
+      #
+      #   class CardDeck
+      #     SUITS = [:Spades, :Diamonds, :Clubs, :Hearts]
+      #     NUM_CARDS = 52
+      #   end
+      #
+      #   stub_const("CardDeck", Class.new)
+      #   CardDeck::SUITS # => uninitialized constant error
+      #   CardDeck::NUM_CARDS # => uninitialized constant error
+      #
+      #   stub_const("CardDeck", Class.new, :transfer_nested_constants => true)
+      #   CardDeck::SUITS # => our suits array
+      #   CardDeck::NUM_CARDS # => 52
+      #
+      #   stub_const("CardDeck", Class.new, :transfer_nested_constants => [:SUITS])
+      #   CardDeck::SUITS # => our suits array
+      #   CardDeck::NUM_CARDS # => uninitialized constant error
+      def stub_const(constant_name, value, options = {})
+        ConstantMutator.stub(constant_name, value, options)
+      end
+
+      # Hides the named constant with the given value. The constant will be
+      # undefined for the duration of the test.
+      #
+      # Like method stubs, the constant will be restored to its original value
+      # when the example completes.
+      #
+      # @param constant_name [String] The fully qualified name of the constant.
+      #   The current constant scoping at the point of call is not considered.
+      #
+      # @example
+      #
+      #   hide_const("MyClass") # => MyClass is now an undefined constant
+      def hide_const(constant_name)
+        ConstantMutator.hide(constant_name)
+      end
+
+      # Verifies that the given object received the expected message during the
+      # course of the test. The method must have previously been stubbed in
+      # order for messages to be verified.
+      #
+      # Stubbing and verifying messages received in this way implements the
+      # Test Spy pattern.
+      #
+      # @param method_name [Symbol] name of the method expected to have been
+      #   called.
+      #
+      # @example
+      #
+      #   invitation = double('invitation', accept: true)
+      #   user.accept_invitation(invitation)
+      #   expect(invitation).to have_received(:accept)
+      #
+      #   # You can also use most message expectations:
+      #   expect(invitation).to have_received(:accept).with(mailer).once
+      def have_received(method_name)
+        Matchers::HaveReceived.new(method_name)
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          # This gets mixed in so that if `RSpec::Matchers` is included in
+          # `klass` later, it's definition of `expect` will take precedence.
+          include ExpectHost unless method_defined?(:expect)
+        end
+      end
+
+    private
+
+      def declare_double(declared_as, *args)
+        args << {} unless Hash === args.last
+        args.last[:__declared_as] = declared_as
+        RSpec::Mocks::Mock.new(*args)
+      end
+
+      # This module exists to host the `expect` method for cases where
+      # rspec-mocks is used w/o rspec-expectations.
+      module ExpectHost
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/extensions/instance_exec.rb

@@ -0,0 +1,34 @@
+module RSpec
+  module Mocks
+    # @private
+    module InstanceExec
+      unless respond_to?(:instance_exec)
+        # @private
+        #
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class of matcher instead of global
+        #   InstanceExecHelper module
+        # - this keeps it scoped to this class only, which is the
+        #   only place we need it
+        # - only necessary for ruby 1.8.6
+        def instance_exec(*args, &block)
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/extensions/marshal.rb

@@ -0,0 +1,17 @@
+module Marshal
+  class << self
+    # Duplicates any mock objects before serialization. Otherwise,
+    # serialization will fail because methods exist on the singleton class.
+    def dump_with_mocks(object, *rest)
+      if ::RSpec::Mocks.space.nil? || !::RSpec::Mocks.space.registered?(object) || NilClass === object
+        dump_without_mocks(object, *rest)
+      else
+        dump_without_mocks(object.dup, *rest)
+      end
+    end
+
+    alias_method :dump_without_mocks, :dump
+    undef_method :dump
+    alias_method :dump, :dump_with_mocks
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.14.3/lib/rspec/mocks/framework.rb

@@ -0,0 +1,34 @@
+# Require everything except the global extensions of class and object. This
+# supports wrapping rspec's mocking functionality without invading every
+# object in the system.
+
+require 'rspec/mocks/deprecation'
+require 'rspec/mocks/extensions/instance_exec'
+require 'rspec/mocks/instance_method_stasher'
+require 'rspec/mocks/method_double'
+require 'rspec/mocks/argument_matchers'
+require 'rspec/mocks/example_methods'
+require 'rspec/mocks/proxy'
+require 'rspec/mocks/proxy_for_nil'
+require 'rspec/mocks/test_double'
+require 'rspec/mocks/mock'
+require 'rspec/mocks/argument_list_matcher'
+require 'rspec/mocks/message_expectation'
+require 'rspec/mocks/order_group'
+require 'rspec/mocks/errors'
+require 'rspec/mocks/error_generator'
+require 'rspec/mocks/space'
+require 'rspec/mocks/extensions/marshal'
+require 'rspec/mocks/any_instance/chain'
+require 'rspec/mocks/any_instance/stub_chain'
+require 'rspec/mocks/any_instance/stub_chain_chain'
+require 'rspec/mocks/any_instance/expectation_chain'
+require 'rspec/mocks/any_instance/message_chains'
+require 'rspec/mocks/any_instance/recorder'
+require 'rspec/mocks/mutate_const'
+require 'rspec/mocks/matchers/have_received'
+require 'rspec/mocks/matchers/receive'
+require 'rspec/mocks/stub_chain'
+require 'rspec/mocks/targets'
+require 'rspec/mocks/syntax'
+require 'rspec/mocks/configuration'