nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-expectations-2.7.0/lib/rspec/matchers/respond_to.rb

@@ -0,0 +1,85 @@
+module RSpec
+  module Matchers
+    
+    class RespondTo
+      def initialize(*names)
+        @names = names
+        @expected_arity = nil
+      end
+      
+      def matches?(actual)
+        find_failing_method_names(actual, :reject).empty?
+      end
+
+      def does_not_match?(actual)
+        find_failing_method_names(actual, :select).empty?
+      end
+      
+      def failure_message_for_should
+        "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+      end
+      
+      def failure_message_for_should_not
+        failure_message_for_should.sub(/to respond to/, 'not to respond to')
+      end
+      
+      def description
+        "respond to #{pp_names}#{with_arity}"
+      end
+      
+      def with(n)
+        @expected_arity = n
+        self
+      end
+      
+      def argument
+        self
+      end
+      alias :arguments :argument
+      
+    private
+
+      def find_failing_method_names(actual, filter_method)
+        @actual = actual
+        @failing_method_names = @names.send(filter_method) do |name|
+          @actual.respond_to?(name) && matches_arity?(actual, name)
+        end
+      end
+      
+      def matches_arity?(actual, name)
+        return true unless @expected_arity
+
+        actual_arity = actual.method(name).arity
+        if actual_arity < 0
+          # ~ inverts the one's complement and gives us the number of required args
+          ~actual_arity <= @expected_arity
+        else
+          actual_arity == @expected_arity
+        end
+      end
+      
+      def with_arity
+        @expected_arity.nil?? "" :
+          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+      end
+      
+      def pp_names
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+        @names.length == 1 ? "##{@names.first}" : @names.inspect
+      end
+    end
+    
+    # :call-seq:
+    #   should respond_to(*names)
+    #   should_not respond_to(*names)
+    #
+    # Matches if the target object responds to all of the names
+    # provided. Names can be Strings or Symbols.
+    #
+    # == Examples
+    # 
+    def respond_to(*names)
+      Matchers::RespondTo.new(*names)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/lib/rspec/matchers/satisfy.rb

@@ -0,0 +1,51 @@
+module RSpec
+  module Matchers
+    
+    class Satisfy
+      def initialize(&block)
+        @block = block
+      end
+      
+      def matches?(actual, &block)
+        @block = block if block
+        @actual = actual
+        @block.call(actual)
+      end
+      
+      def failure_message_for_should
+        "expected #{@actual} to satisfy block"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@actual} not to satisfy block"
+      end
+
+      def description
+        "satisfy block"
+      end
+    end
+    
+    # :call-seq:
+    #   should satisfy {}
+    #   should_not satisfy {}
+    #
+    # Passes if the submitted block returns true. Yields target to the
+    # block.
+    #
+    # Generally speaking, this should be thought of as a last resort when
+    # you can't find any other way to specify the behaviour you wish to
+    # specify.
+    #
+    # If you do find yourself in such a situation, you could always write
+    # a custom matcher, which would likely make your specs more expressive.
+    #
+    # == Examples
+    #
+    #   5.should satisfy { |n|
+    #     n > 3
+    #   }
+    def satisfy(&block)
+      Matchers::Satisfy.new(&block)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/lib/rspec/matchers/throw_symbol.rb

@@ -0,0 +1,121 @@
+module RSpec
+  module Matchers
+    
+    class ThrowSymbol
+      def initialize(expected_symbol = nil, expected_arg=nil)
+        @expected_symbol = expected_symbol
+        @expected_arg = expected_arg
+        @caught_symbol = @caught_arg = nil
+      end
+      
+      def matches?(given_proc)
+        begin
+          if @expected_symbol.nil?
+            given_proc.call
+          else
+            @caught_arg = catch :proc_did_not_throw_anything do
+              catch @expected_symbol do
+                given_proc.call
+                throw :proc_did_not_throw_anything, :nothing_thrown
+              end
+            end
+
+            if @caught_arg == :nothing_thrown
+              @caught_arg = nil
+            else
+              @caught_symbol = @expected_symbol
+            end
+          end
+
+        # Ruby 1.8 uses NameError with `symbol'
+        # Ruby 1.9 uses ArgumentError with :symbol
+        rescue NameError, ArgumentError => e
+          unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+            other_exception = e
+            raise
+          end
+          @caught_symbol = $2.to_sym
+        rescue => other_exception
+          raise
+        ensure
+          unless other_exception
+            if @expected_symbol.nil?
+              return !@caught_symbol.nil?
+            else
+              if @expected_arg.nil?
+                return @caught_symbol == @expected_symbol
+              else
+                return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+              end
+            end
+          end
+        end
+      end
+
+      def failure_message_for_should
+        "expected #{expected} to be thrown, got #{caught}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+      end
+      
+      def description
+        "throw #{expected}"
+      end
+      
+      private
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
+        end
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
+        end
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+            " with #{arg.inspect}"
+          elsif @expected_arg && @caught_symbol == @expected_symbol
+            " with no argument"
+          else
+            ""
+          end
+
+          symbol_description + arg_description
+        end
+
+    end
+ 
+    # :call-seq:
+    #   should throw_symbol()
+    #   should throw_symbol(:sym)
+    #   should throw_symbol(:sym, arg)
+    #   should_not throw_symbol()
+    #   should_not throw_symbol(:sym)
+    #   should_not throw_symbol(:sym, arg)
+    #
+    # Given no argument, matches if a proc throws any Symbol.
+    #
+    # Given a Symbol, matches if the given proc throws the specified Symbol.
+    #
+    # Given a Symbol and an arg, matches if the given proc throws the
+    # specified Symbol with the specified arg.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
+    #
+    #   lambda { do_something_risky }.should_not throw_symbol
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
+    def throw_symbol(expected_symbol = nil, expected_arg=nil)
+      Matchers::ThrowSymbol.new(expected_symbol, expected_arg)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/spec/rspec/expectations/differ_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'ostruct'
+
+module RSpec
+  module Fixtures
+    class Animal
+      def initialize(name,species)
+        @name,@species = name,species
+      end
+
+      def inspect
+        <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+        EOA
+      end
+    end
+  end
+end
+
+describe "Diff" do
+  before(:each) do
+    @options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
+    @differ = RSpec::Expectations::Differ.new(@options)
+  end
+
+  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)
+    diff.should eql(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)
+    diff.should == expected_diff
+  end
+
+  it "outputs unified diff message of two objects" do
+    expected = RSpec::Fixtures::Animal.new "bob", "giraffe"
+    actual   = RSpec::Fixtures::Animal.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)
+    diff.should == expected_diff
+  end
+
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,45 @@
+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)    
+    @target.should @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")
+    lambda {
+      @target.should @matcher
+    }.should fail_with("the failure message")
+  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)
+    
+    @target.should_not @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")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the failure message for should not")
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/spec/rspec/expectations/fail_with_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe RSpec::Expectations, "#fail_with with diff" do
+  let(:differ) { double("differ") }
+
+  before(:each) do
+    RSpec::Expectations.stub(:differ) { differ }
+  end
+
+  it "calls differ if expected/actual are not strings (or numbers or procs)" do
+    differ.should_receive(:diff_as_object).and_return("diff")
+    lambda {
+      RSpec::Expectations.fail_with "the message", Object.new, Object.new
+    }.should fail_with("the message\nDiff:diff")
+  end
+
+  context "with two strings" do
+    context "and actual is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected\nthis", "actual"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and expected is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected", "actual\nthat"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and both are single line strings" do
+      it "does not call differ" do
+        differ.should_not_receive(:diff_as_string)
+        lambda {
+          RSpec::Expectations.fail_with("the message", "expected", "actual")
+        }.should fail_with("the message")
+      end
+    end
+  end
+
+  it "does not call differ if no expected/actual" do
+    lambda {
+      RSpec::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ expected is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", 1, "1"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ when actual is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", "1", 1
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ if expected or actual are procs" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", lambda {}, lambda {}
+    }.should fail_with("the message")
+  end
+end
+