syllable_counter 0.0.1 → 1.0.0

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/deprecation.rb

@@ -0,0 +1,17 @@
+module RSpec
+  module Expectations
+    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(Expectations::Deprecation) unless respond_to?(:deprecate)
+end

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/differ.rb

@@ -0,0 +1,140 @@
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'pp'
+
+module RSpec
+  module Expectations
+    class Differ
+      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+      def diff_as_string(input_data_new, input_data_old)
+        output = matching_encoding("", input_data_old)
+        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
+        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
+        diffs = Diff::LCS.diff(data_old, data_new)
+        return output if diffs.empty?
+        oldhunk = hunk = nil
+        file_length_difference = 0
+        diffs.each do |piece|
+          begin
+            hunk = Diff::LCS::Hunk.new(
+              data_old, data_new, piece, context_lines, file_length_difference
+            )
+            file_length_difference = hunk.file_length_difference
+            next unless oldhunk
+            # Hunks may overlap, which is why we need to be careful when our
+            # diff includes lines of context. Otherwise, we might print
+            # redundant lines.
+            if (context_lines > 0) and hunk.overlaps?(oldhunk)
+              if hunk.respond_to?(:merge)
+                # diff-lcs 1.2.x
+                hunk.merge(oldhunk)
+              else
+                # diff-lcs 1.1.3
+                hunk.unshift(oldhunk)
+              end
+            else
+              output << matching_encoding(oldhunk.diff(format).to_s, output)
+            end
+          ensure
+            oldhunk = hunk
+            output << matching_encoding("\n", output)
+          end
+        end
+        #Handle the last remaining hunk
+        output << matching_encoding(oldhunk.diff(format).to_s,output)
+        output << matching_encoding("\n",output)
+        color_diff output
+      rescue Encoding::CompatibilityError
+        if input_data_new.encoding != input_data_old.encoding
+          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
+          "differs from the encoding of the expected string (#{input_data_new.encoding})"
+        else
+          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
+        end
+      end
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        if diff = diff_as_string(actual_as_string, expected_as_string)
+          color_diff diff
+        end
+      end
+
+    protected
+
+      def format
+        :unified
+      end
+
+      def context_lines
+        3
+      end
+
+      def color(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      def red(text)
+        color(text, 31)
+      end
+
+      def green(text)
+        color(text, 32)
+      end
+
+      def blue(text)
+        color(text, 34)
+      end
+
+      def color_diff(diff)
+        return diff unless RSpec::Matchers.configuration.color?
+
+        diff.lines.map { |line|
+          case line[0].chr
+          when "+"
+            green line
+          when "-"
+            red line
+          when "@"
+            line[1].chr == "@" ? blue(line) : line
+          else
+            line
+          end
+        }.join
+      end
+
+      def object_to_string(object)
+        case object
+        when Hash
+          object.keys.sort_by { |k| k.to_s }.map do |key|
+            pp_key   = PP.singleline_pp(key, "")
+            pp_value = PP.singleline_pp(object[key], "")
+
+            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
+            #
+            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
+            # <# a: b: c:> not <# c: a: b:>
+            matching_encoding("#{pp_key} => #{pp_value}", key)
+          end.join(",\n")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object,"")
+        end
+      end
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string, source)
+          string.encode(source.encoding)
+        end
+      else
+        def matching_encoding(string, source)
+          string
+        end
+      end
+    end
+
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/errors.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Expectations
+    if defined?(Test::Unit::AssertionFailedError)
+      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
+    else
+      class ExpectationNotMetError < ::StandardError; end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/expectation_target.rb

@@ -0,0 +1,87 @@
+module RSpec
+  module Expectations
+    # Wraps the target of an expectation.
+    # @example
+    #   expect(something) # => ExpectationTarget wrapping something
+    #
+    #   # used with `to`
+    #   expect(actual).to eq(3)
+    #
+    #   # with `not_to`
+    #   expect(actual).not_to eq(3)
+    class ExpectationTarget
+      class << self
+        attr_accessor :deprecated_should_enabled
+        alias deprecated_should_enabled? deprecated_should_enabled
+      end
+
+      # @api private
+      def initialize(target)
+        @target = target
+      end
+
+      # Runs the given expectation, passing if `matcher` returns true.
+      # @example
+      #   expect(value).to eq(5)
+      #   expect { perform }.to raise_error
+      # @param [Matcher]
+      #   matcher
+      # @param [String] message optional message to display when the expectation fails
+      # @return [Boolean] true if the expectation succeeds (else raises)
+      # @see RSpec::Matchers
+      def to(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:to, matcher)
+        RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
+      end
+
+      # Runs the given expectation, passing if `matcher` returns false.
+      # @example
+      #   expect(value).not_to eq(5)
+      # @param [Matcher]
+      #   matcher
+      # @param [String] message optional message to display when the expectation fails
+      # @return [Boolean] false if the negative expectation succeeds (else raises)
+      # @see RSpec::Matchers
+      def not_to(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:not_to, matcher)
+        RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
+      end
+      alias to_not not_to
+
+      def self.enable_deprecated_should
+        return if deprecated_should_enabled?
+
+        def should(*args)
+          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
+          @target.should(*args)
+        end
+
+        def should_not(*args)
+          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
+          @target.should_not(*args)
+        end
+
+        self.deprecated_should_enabled = true
+      end
+
+      def self.disable_deprecated_should
+        return unless deprecated_should_enabled?
+
+        remove_method :should
+        remove_method :should_not
+
+        self.deprecated_should_enabled = false
+      end
+
+    private
+
+      def prevent_operator_matchers(verb, matcher)
+        return if matcher
+
+        raise ArgumentError, "The expect syntax does not support operator matchers, " +
+                             "so you must pass a matcher to `##{verb}`."
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/extensions.rb

@@ -0,0 +1,2 @@
+require 'rspec/expectations/extensions/array'
+require 'rspec/expectations/extensions/object'

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/extensions/array.rb

@@ -0,0 +1,9 @@
+# @private
+class Array
+  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
+    # Supports +none?+ on early patch levels of Ruby 1.8.6
+    def none?(&block)
+      !any?(&block)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/extensions/object.rb

@@ -0,0 +1,29 @@
+module RSpec
+  module Expectations
+    module DeprecatedConstants
+      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
+      # delegates to super.
+      def const_missing(name)
+        case name
+        when :Rspec, :Spec
+          RSpec.deprecate(name.to_s, :replacement => "RSpec")
+          RSpec
+        else
+          begin
+            super
+          rescue Exception => e
+            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
+            raise e
+          end
+        end
+      end
+    end
+
+    # @deprecated (no replacement)
+    def differ=(ignore)
+      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
+    end
+  end
+end
+
+extend RSpec::Expectations::DeprecatedConstants

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/fail_with.rb

@@ -0,0 +1,79 @@
+module RSpec
+  module Expectations
+    class << self
+      # @private
+      def differ
+        @differ ||= Differ.new
+      end
+
+      # Raises an RSpec::Expectations::ExpectationNotMetError with message.
+      # @param [String] message
+      # @param [Object] expected
+      # @param [Object] actual
+      #
+      # Adds a diff to the failure message when `expected` and `actual` are
+      # both present.
+      def fail_with(message, expected=nil, actual=nil)
+        if !message
+          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
+                               "appropriate failure_message_for_* method to return a string?"
+        end
+
+        if actual && expected
+          if all_strings?(actual, expected)
+            if any_multiline_strings?(actual, expected)
+              message << "\nDiff:" << differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
+            end
+          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+            message << "\nDiff:" << differ.diff_as_object(actual, expected)
+          end
+        end
+
+        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+      end
+
+    private
+
+      def no_procs?(*args)
+        args.flatten.none? {|a| Proc === a}
+      end
+
+      def all_strings?(*args)
+        args.flatten.all? {|a| String === a}
+      end
+
+      def any_multiline_strings?(*args)
+        all_strings?(*args) && args.flatten.any? { |a| multiline?(a) }
+      end
+
+      def no_numbers?(*args)
+        args.flatten.none? {|a| Numeric === a}
+      end
+
+      def coerce_to_string(string_or_array)
+        return string_or_array unless Array === string_or_array
+        diffably_stringify(string_or_array).join("\n")
+      end
+
+      def diffably_stringify(array)
+        array.map do |entry|
+          if Array === entry
+            entry.inspect
+          else
+            entry.to_s.gsub("\n", "\\n")
+          end
+        end
+      end
+
+      if String.method_defined?(:encoding)
+        def multiline?(string)
+          string.include?("\n".encode(string.encoding))
+        end
+      else
+        def multiline?(string)
+          string.include?("\n")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.14.2/lib/rspec/expectations/handler.rb

@@ -0,0 +1,68 @@
+module RSpec
+  module Expectations
+
+    class ExpectationHandler
+      def self.check_message(msg)
+        unless msg.nil? || msg.respond_to?(:to_str) || msg.respond_to?(:call)
+          ::Kernel.warn [
+            "WARNING: ignoring the provided expectation message argument (",
+            msg.inspect,
+            ") since it is not a string or a proc."
+          ].join
+        end
+      end
+    end
+
+    class PositiveExpectationHandler < ExpectationHandler
+
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        check_message(message)
+        ::RSpec::Matchers.last_should = :should
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        return match if match
+
+        message = message.call if message.respond_to?(:call)
+
+        message ||= matcher.respond_to?(:failure_message_for_should) ?
+                    matcher.failure_message_for_should :
+                    matcher.failure_message
+
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+
+    class NegativeExpectationHandler < ExpectationHandler
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        check_message(message)
+        ::RSpec::Matchers.last_should = :should_not
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.respond_to?(:does_not_match?) ?
+                !matcher.does_not_match?(actual, &block) :
+                matcher.matches?(actual, &block)
+        return match unless match
+
+        message = message.call if message.respond_to?(:call)
+
+        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
+                    matcher.failure_message_for_should_not :
+                    matcher.negative_failure_message
+
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+  end
+end
+