nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-mocks-2.7.0/features/outside_rspec/standalone.feature

@@ -0,0 +1,32 @@
+Feature: standalone
+
+  require "rspec/mocks/standalone" to expose the mock framework
+  outside the RSpec environment. This is especially useful for
+  exploring rspec-mocks in irb.
+
+  Scenario: method stub outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.stub(:say_hi) { "Hello!" }
+      puts greeter.say_hi
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "Hello!"
+
+  Scenario: message expectation outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.should_receive(:say_hi)
+
+      RSpec::Mocks.verify
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "say_hi(any args) (RSpec::Mocks::MockExpectationError)"
+    Then the output should contain "expected: 1 time"
+    Then the output should contain "received: 0 times"

data/vendor/bundle/gems/rspec-mocks-2.7.0/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,4 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  Then %q{the output should contain "0 failures"}
+  Then %q{the exit status should be 0}
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  RUBY_PLATFORM =~ /java/ ? @aruba_timeout_seconds = 60 : @aruba_timeout_seconds = 5
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks.rb

@@ -0,0 +1,196 @@
+require 'rspec/mocks/framework'
+require 'rspec/mocks/version'
+require 'rspec/mocks/spec_methods'
+
+module RSpec
+  # == Test Doubles
+  #
+  # A Test Double is an object that stands in for a real object in a test.
+  # RSpec creates test doubles that support method stubs and message
+  # expectations.
+  #
+  #   book = double("book")
+  #
+  # == Method Stubs
+  #
+  # A method stub is an implementation that returns a pre-determined value.
+  #
+  #   book = double("book")
+  #   double.stub(:title) { "The RSpec Book" }
+  #   double.title # => "The RSpec Book"
+  #
+  # When we declare a stub, we say we are "stubbing" a method.
+  #
+  # == Message Expectations
+  #
+  # A message expectation is an expectation that the test double will receive a
+  # message some time before the example ends. If the message is received, the
+  # expectation is satisfied. If not, the example fails.
+  #
+  #   validator = double("validator")
+  #   validator.should_receive(:validate).with("02134")
+  #   zipcode = Zipcode.new("02134", validator)
+  #   zipcode.valid?
+  #   
+  # When we declare a message expectation, we say we are "mocking" a method.
+  #
+  # == Mock Objects and Test Stubs
+  #
+  # The names Mock Object and Test Stub suggest specialized Test Doubles.  i.e.
+  # a Test Stub is a Test Double that only supports method stubs, and a Mock
+  # Object is a Test Double that supports message expectations and method
+  # stubs.
+  #
+  # There is a lot of overlapping nomenclature here, and there are many
+  # variations of these patterns (fakes, spies, etc). Keep in mind that most of
+  # the time we're talking about method-level concepts that are variations of
+  # method stubs and message expectations, and we're applying to them to _one_
+  # generic kind of object: a Test Double.
+  #
+  # == Test-Specific Extension
+  #
+  # a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a
+  # real object in a system that is instrumented with test-double like
+  # behaviour in the context of a test. This technique is very common in Ruby
+  # because we often see class objects acting as global namespaces for methods.
+  # For example, in Rails:
+  #
+  #   person = double("person")
+  #   Person.stub(:find) { person }
+  #
+  # In this case we're instrumenting Person to return the person object we've
+  # defined whenever it receives the +find+ message. We can do this with any
+  # object in a system because rspec-mocks adds the +stub+ and +should_receive+
+  # methods to every object. When we use either, RSpec replaces the method
+  # we're stubbing or mocking with it's own test-double-like method. At the
+  # end of the example, RSpec verifies any message expectations, and then
+  # restores the original methods.
+  # 
+  # == Expecting Arguments
+  #
+  #   double.should_receive(:msg).with(*args)
+  #   double.should_not_receive(:msg).with(*args)
+  #
+  # == Argument Matchers
+  #
+  # Arguments that are passed to +with+ are compared with actual arguments
+  # received using ==. In cases in which you want to specify things about the
+  # arguments rather than the arguments themselves, you can use any of the
+  # matchers that ship with rspec-expectations. They don't all make syntactic
+  # sense (they were primarily designed for use with RSpec::Expectations), but
+  # you are free to create your own custom RSpec::Matchers.
+  #
+  # rspec-mocks also adds some keyword Symbols that you can use to
+  # specify certain kinds of arguments:
+  #
+  #   double.should_receive(:msg).with(no_args())
+  #   double.should_receive(:msg).with(any_args())
+  #   double.should_receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
+  #   double.should_receive(:msg).with(1, boolean(), "b") #2nd argument can true or false
+  #   double.should_receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
+  #   double.should_receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
+  #   double.should_receive(:msg).with(1, ducktype(:abs, :div), "b")
+  #                            #2nd argument can be object that responds to #abs and #div
+  #                                                                       
+  # == Receive Counts
+  #
+  #   double.should_receive(:msg).once
+  #   double.should_receive(:msg).twice
+  #   double.should_receive(:msg).exactly(n).times
+  #   double.should_receive(:msg).at_least(:once)
+  #   double.should_receive(:msg).at_least(:twice)
+  #   double.should_receive(:msg).at_least(n).times
+  #   double.should_receive(:msg).at_most(:once)
+  #   double.should_receive(:msg).at_most(:twice)
+  #   double.should_receive(:msg).at_most(n).times
+  #   double.should_receive(:msg).any_number_of_times
+  #
+  # == Ordering
+  #
+  #   double.should_receive(:msg).ordered
+  #   double.should_receive(:other_msg).ordered
+  #     #This will fail if the messages are received out of order
+  #
+  # == Setting Reponses
+  #
+  # Whether you are setting a message expectation or a method stub, you can
+  # tell the object precisely how to respond. The most generic way is to pass
+  # a block to +stub+ or +should_receive+:
+  #
+  #   double.should_receive(:msg) { value }
+  #
+  # When the double receives the +msg+ message, it evaluates the block and returns
+  # the result.
+  #
+  #   double.should_receive(:msg).and_return(value)
+  #   double.should_receive(:msg).exactly(3).times.and_return(value1, value2, value3)
+  #     # returns value1 the first time, value2 the second, etc
+  #   double.should_receive(:msg).and_raise(error)
+  #     #error can be an instantiated object or a class
+  #     #if it is a class, it must be instantiable with no args
+  #   double.should_receive(:msg).and_throw(:msg)
+  #   double.should_receive(:msg).and_yield(values,to,yield)
+  #   double.should_receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  #     # for methods that yield to a block multiple times
+  #
+  # Any of these responses can be applied to a stub as well
+  #
+  #   double.stub(:msg).and_return(value)
+  #   double.stub(:msg).and_return(value1, value2, value3)
+  #   double.stub(:msg).and_raise(error)
+  #   double.stub(:msg).and_throw(:msg)
+  #   double.stub(:msg).and_yield(values,to,yield)
+  #   double.stub(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  #
+  # == Arbitrary Handling
+  #
+  # Once in a while you'll find that the available expectations don't solve the
+  # particular problem you are trying to solve. Imagine that you expect the message
+  # to come with an Array argument that has a specific length, but you don't care
+  # what is in it. You could do this:
+  #
+  #   double.should_receive(:msg) do |arg|
+  #     arg.should be_an_istance_of(Array)
+  #     arg.length.should eq 7
+  #   end
+  #
+  # == Combining Expectation Details
+  #
+  # Combining the message name with specific arguments, receive counts and responses
+  # you can get quite a bit of detail in your expectations:
+  #
+  #   double.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
+  #
+  # == Further Reading
+  # 
+  # There are many different viewpoints about the meaning of mocks and stubs. If you are interested
+  # in learning more, here is some recommended reading:
+  # 
+  # * Mock Objects: http://www.mockobjects.com/
+  # * Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf
+  # * Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf
+  # * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
+  # * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
+  module Mocks
+    class << self
+      attr_accessor :space
+
+      def setup(includer)
+        Object.class_eval { include RSpec::Mocks::Methods }
+        Class.class_eval  { include RSpec::Mocks::AnyInstance }
+        (class << includer; self; end).class_eval do
+          include RSpec::Mocks::ExampleMethods
+        end
+        self.space ||= RSpec::Mocks::Space.new
+      end
+
+      def verify
+        space.verify_all
+      end
+
+      def teardown
+        space.reset_all
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,29 @@
+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'
+
+module RSpec
+  module Mocks
+    module AnyInstance
+      def any_instance
+        RSpec::Mocks::space.add(self)
+        __recorder
+      end
+      
+      def rspec_verify
+        __recorder.verify
+        super
+      ensure
+        __recorder.stop_all_observation!
+        @__recorder = nil
+      end
+
+      def __recorder
+        @__recorder ||= AnyInstance::Recorder.new(self)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks/any_instance/chain.rb

@@ -0,0 +1,49 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Chain
+        [
+          :with, :and_return, :and_raise, :and_yield,
+          :once, :twice, :any_number_of_times,
+          :exactly, :times, :never,
+          :at_least, :at_most
+          ].each do |method_name|
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{method_name}(*args, &block)
+                record(:#{method_name}, *args, &block)
+              end
+            EOM
+        end
+
+        def playback!(instance)
+          messages.inject(instance) do |_instance, message|
+            _instance.__send__(*message.first, &message.last)
+          end
+        end
+
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        private
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -0,0 +1,33 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class ExpectationChain < Chain
+        def initialize(*args, &block)
+          record(:should_receive, *args, &block)
+          @expectation_fulfilled = false
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :should_receive => [nil],
+            :with => [:should_receive],
+            :and_return => [:with, :should_receive],
+            :and_raise => [:with, :should_receive]
+          }
+        end
+
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        def expectation_fulfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+        end
+
+        private
+        def verify_invocation_order(rspec_method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks/any_instance/message_chains.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class MessageChains < Hash
+        def add(method_name, chain)
+          (self[method_name] ||= []) << chain
+        end
+        
+        def remove_stub_chains_for!(method_name)
+          chains = self[method_name]
+          chains.reject! { |chain| chain.is_a?(StubChain) || chain.is_a?(StubChainChain) }
+        end
+        
+        def has_expectation?(method_name)
+          !!self[method_name].find{|chain| chain.is_a?(ExpectationChain)}
+        end
+        
+        def each_expectation_fulfilled?
+          self.all? do |method_name, chains|
+            chains.all? { |chain| chain.expectation_fulfilled? }
+          end
+        end
+
+        def unfulfilled_expectations
+          self.map do |method_name, chains|
+            method_name.to_s if chains.last.is_a?(ExpectationChain) unless chains.last.expectation_fulfilled?
+          end.compact
+        end
+
+        def received_expected_message!(method_name)
+          self[method_name].each do |chain|
+            chain.expectation_fulfilled!
+          end
+        end
+        
+        def playback!(instance, method_name)
+          self[method_name].each do |chain|
+            @instance_with_expectation = instance if instance.is_a?(ExpectationChain) && !@instance_with_expectation
+            if instance.is_a?(ExpectationChain) && !@instance_with_expectation.equal?(instance)
+              raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+            end
+            chain.playback!(instance)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.7.0/lib/rspec/mocks/any_instance/recorder.rb

@@ -0,0 +1,168 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Recorder
+        attr_reader :message_chains
+        def initialize(klass)
+          @message_chains = MessageChains.new
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+        
+        def unstub(method_name)
+          unless @observed_methods.include?(method_name.to_sym)
+            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+          end
+          message_chains.remove_stub_chains_for!(method_name)
+          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
+        end
+        
+        def stub(method_name_or_method_map, *args, &block)
+          if method_name_or_method_map.is_a?(Hash)
+            method_map = method_name_or_method_map
+            method_map.each do |method_name, return_value| 
+              observe!(method_name)
+              message_chains.add(method_name, chain = StubChain.new(method_name))
+              chain.and_return(return_value)
+            end
+            method_map
+          else
+            method_name = method_name_or_method_map
+            observe!(method_name)
+            message_chains.add(method_name, chain = StubChain.new(method_name, *args, &block))
+            chain
+          end
+        end
+
+        def stub!(*)
+          raise "stub! is not supported on any_instance. Use stub instead."
+        end
+
+        def stub_chain(method_name_or_string_chain, *args, &block)
+          if period_separated_method_chain?(method_name_or_string_chain)
+            first_method_name = method_name_or_string_chain.split('.').first.to_sym
+          else
+            first_method_name = method_name_or_string_chain
+          end
+          observe!(first_method_name)
+          message_chains.add(first_method_name, chain = StubChainChain.new(method_name_or_string_chain, *args, &block))
+          chain
+        end
+        
+        def should_receive(method_name, *args, &block)
+          observe!(method_name)
+          @expectation_set = true
+          message_chains.add(method_name, chain = ExpectationChain.new(method_name, *args, &block))
+          chain
+        end
+
+        def stop_all_observation!
+          @observed_methods.each do |method_name|
+            restore_method!(method_name)
+          end
+        end
+
+        def playback!(instance, method_name)
+          RSpec::Mocks::space.add(instance)
+          message_chains.playback!(instance, method_name)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
+        end
+
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        def verify
+          if @expectation_set && !message_chains.each_expectation_fulfilled?
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
+          end
+        end
+
+        private
+        def period_separated_method_chain?(method_name)
+          method_name.is_a?(String) && method_name.include?('.')
+        end
+        
+        def received_expected_message!(method_name)
+          message_chains.received_expected_message!(method_name)
+          restore_method!(method_name)
+          mark_invoked!(method_name)
+        end
+        
+        def restore_method!(method_name)
+          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
+            restore_original_method!(method_name)
+          else
+            remove_dummy_method!(method_name)
+          end
+        end
+
+        def build_alias_method_name(method_name)
+          "__#{method_name}_without_any_instance__"
+        end
+
+        def restore_original_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            remove_method method_name
+            alias_method  method_name, alias_method_name
+            remove_method alias_method_name
+          end
+        end
+
+        def remove_dummy_method!(method_name)
+          @klass.class_eval do
+            remove_method method_name
+          end
+        end
+
+        def backup_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            alias_method alias_method_name, method_name
+          end if public_protected_or_private_method_defined?(method_name)
+        end
+        
+        def public_protected_or_private_method_defined?(method_name)
+          @klass.method_defined?(method_name) || @klass.private_method_defined?(method_name)
+        end
+        
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+        end
+
+        def already_observing?(method_name)
+          @observed_methods.include?(method_name)
+        end
+
+        def observe!(method_name)
+          stop_observing!(method_name) if already_observing?(method_name)
+          @observed_methods << method_name
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              self.class.__recorder.playback!(self, :#{method_name})
+              self.__send__(:#{method_name}, *args, &blk)
+            end
+          EOM
+        end
+
+        def mark_invoked!(method_name)
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              method_name = :#{method_name}
+              current_instance = self
+              invoked_instance = self.class.__recorder.instance_that_received(method_name)
+              raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by \#{self.inspect} but has already been received by \#{invoked_instance}"
+            end
+          EOM
+        end
+      end
+    end
+  end
+end