nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-expectations-2.7.0/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.7.0/lib/rspec/expectations/extensions.rb

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

data/vendor/bundle/gems/rspec-expectations-2.7.0/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.7.0/lib/rspec/expectations/extensions/kernel.rb

@@ -0,0 +1,26 @@
+module Kernel
+  # Passes if +matcher+ returns true.  Available on every +Object+.
+  # @example
+  #   actual.should eq(expected)
+  #   actual.should be > 4
+  # @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 should(matcher=nil, message=nil, &block)
+    RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
+  end
+
+  # Passes if +matcher+ returns false.  Available on every +Object+.
+  # @example
+  #   actual.should_not eq(expected)
+  # @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 should_not(matcher=nil, message=nil, &block)
+    RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
+  end
+end

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

@@ -0,0 +1,39 @@
+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.warn_deprecation <<-WARNING
+*****************************************************************
+DEPRECATION WARNING: you are using a deprecated constant that will
+be removed from a future version of RSpec.
+
+#{caller(0)[2]}
+
+* #{name} is deprecated.
+* RSpec is the new top-level module in RSpec-2
+***************************************************************
+WARNING
+          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)", "nothing at all (diffing is now automatic and no longer configurable)")
+    end
+  end
+end
+
+extend RSpec::Expectations::DeprecatedConstants

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

@@ -0,0 +1,54 @@
+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:" << self.differ.diff_as_string(actual, expected)
+            end
+          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+            message << "\nDiff:" << self.differ.diff_as_object(actual, expected)
+          end
+        end
+
+        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+      end
+
+    private
+
+      def no_procs?(*args)
+        args.none? {|a| Proc === a}
+      end
+
+      def all_strings?(*args)
+        args.all? {|a| String === a}
+      end
+
+      def any_multiline_strings?(*args)
+        all_strings?(*args) && args.any? {|a| a =~ /\n/}
+      end
+
+      def no_numbers?(*args)
+        args.none? {|a| Numeric === a}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module RSpec
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class PositiveExpectationHandler        
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        ::RSpec::Matchers.last_should = :should
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        return match if match
+        
+        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.first, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+
+    class NegativeExpectationHandler
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        ::RSpec::Matchers.last_should = :should_not
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::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 ||= 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.first, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,8 @@
+module RSpec
+  module Expectations
+    # @private
+    module Version
+      STRING = '2.7.0'
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module RSpec
+  # rspec-expecations provides a number of useful Matchers we use to compose
+  # expectations. A Matcher is any object that responds to the following:
+  #
+  #  matches?(actual)
+  #  failure_message_for_should
+  #
+  # These methods are also part of the matcher protocol, but are optional:
+  #
+  #  does_not_match?(actual)
+  #  failure_message_for_should_not
+  #  description #optional
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, RSpec will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel.
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and RSpec will figure it out from there. For example:
+  #
+  #  [].should be_empty     # => [].empty?() | passes
+  #  [].should_not be_empty # => [].empty?() | fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #  "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #  3.should be_a_kind_of(Fixnum)        # => 3.kind_of?(Numeric)     | passes
+  #  3.should be_a_kind_of(Numeric)       # => 3.kind_of?(Numeric)     | passes
+  #  3.should be_an_instance_of(Fixnum)   # => 3.instance_of?(Fixnum)  | passes
+  #  3.should_not be_instance_of(Numeric) # => 3.instance_of?(Numeric) | fails
+  #
+  # RSpec will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and RSpec will
+  # call has_key?(:key) on the target. For example:
+  #
+  #  {:a => "A"}.should have_key(:a) # => {:a => "A"}.has_key?(:a) | passes
+  #  {:a => "A"}.should have_key(:b) # => {:a => "A"}.has_key?(:b) | fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Matchers
+  #
+  # When you find that none of the stock Expectation Matchers provide a natural
+  # feeling expectation, you can very easily write your own using RSpec's matcher
+  # DSL or writing one from scratch.
+  #
+  # === Matcher DSL
+  #
+  # Imagine that you are writing a game in which players can be in various
+  # zones on a virtual board. To specify that bob should be in zone 4, you
+  # could say:
+  #
+  #  bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #  bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #  bob.should_not be_in_zone("3")
+  #
+  # You can create such a matcher like so:
+  #
+  #  RSpec::Matchers.define :be_in_zone do |zone|
+  #    match do |player|
+  #      player.in_zone?(zone)
+  #    end
+  #  end
+  #
+  # This will generate a <tt>be_in_zone</tt> method that returns a matcher
+  # with logical default messages for failures. You can override the failure
+  # messages and the generated description as follows:
+  #
+  #  RSpec::Matchers.define :be_in_zone do |zone|
+  #    match do |player|
+  #      player.in_zone?(zone)
+  #    end
+  #
+  #    failure_message_for_should do |player|
+  #      # generate and return the appropriate string.
+  #    end
+  #
+  #    failure_message_for_should_not do |player|
+  #      # generate and return the appropriate string.
+  #    end
+  #
+  #    description do
+  #      # generate and return the appropriate string.
+  #    end
+  #  end
+  #
+  # Each of the message-generation methods has access to the block arguments
+  # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
+  # failure message methods (<tt>failure_message_for_should</tt> and
+  # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
+  # receiver of <tt>should</tt> or <tt>should_not</tt>).
+  #
+  # === Custom Matcher from scratch
+  #
+  # You could also write a custom matcher from scratch, as follows:
+  #
+  #  class BeInZone
+  #    def initialize(expected)
+  #      @expected = expected
+  #    end
+  #
+  #    def matches?(target)
+  #      @target = target
+  #      @target.current_zone.eql?(Zone.new(@expected))
+  #    end
+  #
+  #    def failure_message_for_should
+  #      "expected #{@target.inspect} to be in Zone #{@expected}"
+  #    end
+  #
+  #    def failure_message_for_should_not
+  #      "expected #{@target.inspect} not to be in Zone #{@expected}"
+  #    end
+  #  end
+  #
+  # ... and a method like this:
+  #
+  #  def be_in_zone(expected)
+  #    BeInZone.new(expected)
+  #  end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #  module CustomGameMatchers
+  #    class BeInZone
+  #      # ...
+  #    end
+  #
+  #    def be_in_zone(expected)
+  #      # ...
+  #    end
+  #  end
+  #
+  #  describe "Player behaviour" do
+  #    include CustomGameMatchers
+  #    # ...
+  #  end
+  #
+  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
+  # from your spec file(s):
+  #
+  #  RSpec::configure do |config|
+  #    config.include(CustomGameMatchers)
+  #  end
+  module Matchers
+    # Include Matchers for other test frameworks.
+    # Note that MiniTest _must_ come before TU because on ruby 1.9,
+    # T::U::TC is a subclass of MT::U::TC and a 1.9 bug can lead
+    # to infinite recursion from the `super` call in our method_missing
+    # hook.  See this gist for more info:
+    #   https://gist.github.com/845896
+    if defined?(MiniTest::Unit::TestCase)
+      MiniTest::Unit::TestCase.send(:include, self)
+    end
+    if defined?(Test::Unit::TestCase)
+      Test::Unit::TestCase.send(:include, self)
+    end
+  end
+end
+
+require 'rspec/matchers/extensions/instance_eval_with_args'
+require 'rspec/matchers/pretty'
+require 'rspec/matchers/matcher'
+require 'rspec/matchers/operator_matcher'
+require 'rspec/matchers/be'
+require 'rspec/matchers/be_close'
+require 'rspec/matchers/be_instance_of'
+require 'rspec/matchers/be_kind_of'
+require 'rspec/matchers/be_within'
+require 'rspec/matchers/block_aliases'
+require 'rspec/matchers/change'
+require 'rspec/matchers/cover' if (1..2).respond_to? :cover?
+require 'rspec/matchers/eq'
+require 'rspec/matchers/eql'
+require 'rspec/matchers/equal'
+require 'rspec/matchers/errors'
+require 'rspec/matchers/exist'
+require 'rspec/matchers/generated_descriptions'
+require 'rspec/matchers/has'
+require 'rspec/matchers/have'
+require 'rspec/matchers/include'
+require 'rspec/matchers/match'
+require 'rspec/matchers/match_array'
+require 'rspec/matchers/method_missing'
+require 'rspec/matchers/raise_error'
+require 'rspec/matchers/respond_to'
+require 'rspec/matchers/satisfy'
+require 'rspec/matchers/throw_symbol'
+require 'rspec/matchers/compatibility'
+require 'rspec/matchers/dsl'

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

@@ -0,0 +1,213 @@
+require 'rspec/matchers/dsl'
+
+module RSpec
+  module Matchers
+
+    # @method be_true
+    RSpec::Matchers.define :be_true do
+      match do |actual|
+        actual
+      end
+    end
+
+    RSpec::Matchers.define :be_false do
+      match do |actual|
+        !actual
+      end
+    end
+
+    RSpec::Matchers.define :be_nil do
+      match do |actual|
+        actual.nil?
+      end
+
+      failure_message_for_should do |actual|
+        "expected: nil\n     got: #{actual.inspect}"
+      end
+
+      failure_message_for_should_not do
+        "expected: not nil\n     got: nil"
+      end
+    end
+
+    class Be
+      include RSpec::Matchers::Pretty
+      
+      def initialize(*args, &block)
+        @args = args
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        !!@actual
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to evaluate to true"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} to evaluate to false"
+      end
+      
+      def description
+        "be"
+      end
+
+      [:==, :<, :<=, :>=, :>, :===].each do |operator|
+        define_method operator do |operand|
+          BeComparedTo.new(operand, operator)
+        end
+      end
+
+    private
+
+      def args_to_s
+        @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+      end
+      
+      def parenthesize(string)
+        "(#{string})"
+      end
+      
+      def inspected_args
+        @args.collect{|a| a.inspect}
+      end
+      
+      def expected_to_sentence
+        split_words(@expected)
+      end
+      
+      def args_to_sentence
+        to_sentence(@args)
+      end
+        
+    end
+
+    class BeComparedTo < Be
+
+      def initialize(operand, operator)
+        @expected, @operator = operand, operator
+        @args = []
+      end
+
+      def matches?(actual)
+        @actual = actual
+        @actual.__send__(@operator, @expected)
+      end
+
+      def failure_message_for_should
+        "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        message = <<-MESSAGE
+'should_not be #{@operator} #{@expected}' not only FAILED,
+it is a bit confusing.
+          MESSAGE
+          
+        raise message << ([:===,:==].include?(@operator) ?
+          "It might be more clearly expressed without the \"be\"?" :
+          "It might be more clearly expressed in the positive?")
+      end
+
+      def description
+        "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+      end
+
+    end
+
+    class BePredicate < Be
+
+      def initialize(*args, &block)
+        @expected = parse_expected(args.shift)
+        @args = args
+        @block = block
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        begin
+          return @result = actual.__send__(predicate, *@args, &@block)
+        rescue NameError => predicate_missing_error
+          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+        end
+
+        begin
+          return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+        rescue NameError
+          raise predicate_missing_error
+        end
+      end
+      
+      def failure_message_for_should
+        "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+      end
+
+      def description
+        "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+      end
+
+    private
+
+      def predicate
+        "#{@expected}?".to_sym
+      end
+      
+      def present_tense_predicate
+        "#{@expected}s?".to_sym
+      end
+      
+      def parse_expected(expected)
+        @prefix, expected = prefix_and_expected(expected)
+        expected
+      end
+
+      def prefix_and_expected(symbol)
+        symbol.to_s =~ /^(be_(an?_)?)(.*)/
+        return $1, $3
+      end
+
+      def prefix_to_sentence
+        split_words(@prefix)
+      end
+
+    end
+
+    # @example
+    #   actual.should be_true
+    #   actual.should be_false
+    #   actual.should be_nil
+    #   actual.should be_[arbitrary_predicate](*args)
+    #   actual.should_not be_nil
+    #   actual.should_not be_[arbitrary_predicate](*args)
+    #
+    # Given true, false, or nil, will pass if actual value is true, false or
+    # nil (respectively). Given no args means the caller should satisfy an if
+    # condition (to be or not to be). 
+    #
+    # Predicates are any Ruby method that ends in a "?" and returns true or
+    # false.  Given be_ followed by arbitrary_predicate (without the "?"),
+    # RSpec will match convert that into a query against the target object.
+    #
+    # The arbitrary_predicate feature will handle any predicate prefixed with
+    # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_"
+    # (e.g. be_empty), letting you choose the prefix that best suits the
+    # predicate.
+    def be(*args)
+      args.empty? ?
+        Matchers::Be.new : equal(*args)
+    end
+
+    # passes if target.kind_of?(klass)
+    def be_a(klass)
+      be_a_kind_of(klass)
+    end
+    
+    alias_method :be_an, :be_a
+  end
+end