sshp 0.0.1

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/lib/rspec/matchers/method_missing.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Matchers
+
+    private
+
+    def method_missing(method, *args, &block)
+      return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
+      return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/lib/rspec/matchers/operator_matcher.rb

@@ -0,0 +1,109 @@
+module RSpec
+  module Matchers
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def unregister(klass, operator)
+          registry[klass] && registry[klass].delete(operator)
+        end
+
+        def get(klass, operator)
+          klass.ancestors.each { |ancestor|
+            matcher = registry[ancestor] && registry[ancestor][operator]
+            return matcher if matcher
+          }
+
+          nil
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+              "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        RSpec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+
+      private
+
+      if Method.method_defined?(:owner) # 1.8.6 lacks Method#owner :-(
+        def uses_generic_implementation_of?(op)
+          @actual.method(op).owner == ::Kernel
+        end
+      else
+        def uses_generic_implementation_of?(op)
+          # This is a bit of a hack, but:
+          #
+          # {}.method(:=~).to_s # => "#<Method: Hash(Kernel)#=~>"
+          #
+          # In the absence of Method#owner, this is the best we
+          # can do to see if the method comes from Kernel.
+          @actual.method(op).to_s.include?('(Kernel)')
+        end
+      end
+
+      def eval_match(actual, operator, expected)
+        ::RSpec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+    end
+
+    module BuiltIn
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          elsif ['==','===', '=~'].include?(operator)
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})") 
+          else
+            fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          end
+        end
+      end
+
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+          return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/lib/rspec/matchers/pretty.rb

@@ -0,0 +1,64 @@
+module RSpec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words)
+        return "" unless words
+        words = Array(words).map { |w| to_word(w) }
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+
+      def to_word(item)
+        item.respond_to?(:description) ? item.description : item.inspect
+      end
+
+      def name_to_sentence
+        split_words(name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected) if defined?(@expected)
+      end
+
+      def name
+        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
+      end
+
+      # Borrowed from ActiveSupport
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/spec/rspec/expectations/differ_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require 'ostruct'
+
+module RSpec
+  module Expectations
+    describe Differ do
+      context "without --color" do
+
+      before { RSpec::Matchers.configuration.stub(:color? => false) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+        # color disabled context
+
+      describe '#diff_as_string' do
+        it "outputs unified diff of two strings" do
+          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+          diff = differ.diff_as_string(expected, actual)
+          expect(diff).to eql(expected_diff)
+        end
+      end
+
+      describe '#diff_as_object' do
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of single line strings" do
+          expected = "this is one string"
+          actual   = "this is another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,2 +1,2 @@
+-"this is another string"
++"this is one string"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+      end
+    end
+
+    context "with --color" do
+      before { RSpec::Matchers.configuration.stub(:color? => true) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+      it "outputs colored diffs" do
+        expected = "foo bar baz"
+        actual = "foo bang baz"
+        expected_diff = "\n\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+
+        diff = differ.diff_as_string(expected,actual)
+        expect(diff).to eq expected_diff
+      end
+    end
+
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/spec/rspec/expectations/expectation_target_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    # so our examples below can set expectations about the target
+    ExpectationTarget.send(:attr_reader, :target)
+
+    describe ExpectationTarget do
+      context 'when constructed via #expect' do
+        it 'constructs a new instance targetting the given argument' do
+          expect(expect(7).target).to eq(7)
+        end
+
+        it 'constructs a new instance targetting the given block' do
+          block = lambda {}
+          expect(expect(&block).target).to be(block)
+        end
+
+        it 'raises an ArgumentError when given an argument and a block' do
+          expect {
+            expect(7) { }
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an ArgumentError when given neither an argument nor a block' do
+          expect {
+            expect
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'can be passed nil' do
+          expect(expect(nil).target).to be_nil
+        end
+
+        it 'passes a valid positive expectation' do
+          expect(5).to eq(5)
+        end
+
+        it 'passes a valid negative expectation' do
+          expect(5).to_not eq(4)
+          expect(5).not_to eq(4)
+        end
+
+        it 'fails an invalid positive expectation' do
+          expect {
+            expect(5).to eq(4)
+          }.to fail_with(/expected: 4.*got: 5/m)
+        end
+
+        it 'fails an invalid negative expectation' do
+          message = /expected 5 not to be a kind of Fixnum/
+          expect {
+            expect(5).to_not be_a(Fixnum)
+          }.to fail_with(message)
+          expect {
+            expect(5).not_to be_a(Fixnum)
+          }.to fail_with(message)
+        end
+
+        it 'does not support operator matchers from #to' do
+          expect {
+            expect(3).to == 3
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'does not support operator matchers from #not_to' do
+          expect {
+            expect(3).not_to == 4
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.13.0/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Object, "#should" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stub!(:matches?).and_return(true)
+    @matcher.stub!(:failure_message_for_should)
+  end
+
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    expect(@target).to @matcher
+  end
+
+  it "asks for a failure_message_for_should when matches? returns false" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
+    expect {
+      expect(@target).to @matcher
+    }.to fail_with("the failure message")
+  end
+
+  context "on interpretters that have BasicObject", :if => defined?(BasicObject) do
+    let(:proxy_class) do
+      Class.new(BasicObject) do
+        def initialize(target)
+          @target = target
+        end
+
+        def proxied?
+          true
+        end
+
+        def method_missing(name, *args)
+          @target.send(name, *args)
+        end
+      end
+    end
+
+    it 'works properly on BasicObject-subclassed proxy objects' do
+      expect(proxy_class.new(Object.new)).to be_proxied
+    end
+  end
+end
+
+describe Object, "#should_not" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.stub!(:failure_message_for_should_not)
+
+    expect(@target).not_to @matcher
+  end
+
+  it "asks for a failure_message_for_should_not when matches? returns true" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
+    expect {
+      expect(@target).not_to @matcher
+    }.to fail_with("the failure message for should not")
+  end
+end