crispy 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce5cdae0bd61dc34b874f0d39aff7633c43e7418
+  data.tar.gz: 4865b17724178158276ea6e1134fd614e1cdffb8
+SHA512:
+  metadata.gz: e42a8e7746d256b99f4f9fa07ae84f55a154cce1c41a55a41812736249e2b5a49483eeff86d7315de0abd502ad4996ce455605c9283469a400510b81429fa7c3
+  data.tar.gz: a0b29456ff5b7a4b993716c3fbebce7b6c0d71fa1cbc0e8f4ec58cfa5d70448306bb464d8eaf782b3c4d801a6ac2a4fc3595990d62ecfe07fb4a1d0558fc0ad5

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in crispy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yamamoto Yuji
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+# Crispy
+
+Test Spy for Any Object in Ruby.
+
+## Features
+
+- Test spy for any object by using `prepend` (Sorry, it runs by Ruby 2.0 or higher!)
+- Extremely flexible query for received messages with `received_messages` method.
+    - By using Array and Enumerable's methods, you never have to remember the complex API and tons of the argument matchers in RSpec anymore!
+- Makes mocks obsolete so you don't have to be worried about where to put the expectations (i.e. *before or after the subject method*).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'crispy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install crispy
+
+## Usage
+
+<!--
+# Sample class for doctest.
+doctest_require: './test/doctest-fixtures/your_cool_class.rb'
+-->
+
+### Spy on a Object
+
+```ruby
+>> require 'crispy'
+>> include Crispy # import spy, spy_into and any other functions from Crispy namespace.
+
+>> object = YourCoolClass.new
+>> spy = spy_into object
+
+>> object.your_cool_method 1, 2, 3
+>> object.your_method_without_argument
+>> object.your_lovely_method 'great', 'arguments'
+>> object.your_lovely_method 'great', 'arguments', 'again'
+>> object.your_finalizer 'resource to release'
+```
+
+#### Spy methods with no arguments
+
+Call query methods through the spy object, instead of YourCoolClass's instance.
+
+```ruby
+>> spy(object).received? :your_cool_method
+=> true
+>> spy(object).received? :your_method_without_argument
+=> true
+>> spy(object).received? :your_lovely_method
+=> true
+>> spy(object).received? :your_ugly_method
+=> false
+```
+
+#### Spy methods with arguments
+
+Each argument is compared by `==` method.
+
+```ruby
+>> spy(object).received? :your_cool_method, 1, 2, 3
+=> true
+>> spy(object).received? :your_cool_method, 0, 0, 0
+=> false
+>> spy(object).received? :your_method_without_argument, :not, :given, :arguments
+=> false
+>> spy(object).received? :your_lovely_method, 'great', 'arguments'
+=> true
+>> spy(object).received? :your_ugly_method, 'of course', 'I gave no arguments'
+=> false
+```
+
+#### Spy methods with arguments and a block
+
+*Sorry, I'm still thinking of the specification for that case.*
+
+#### Count method calls
+
+```ruby
+>> spy(object).count_received :your_cool_method
+=> 1
+>> spy(object).count_received :your_cool_method, 1, 2, 3
+=> 1
+>> spy(object).count_received :your_cool_method, 0, 0, 0
+=> 0
+```
+
+#### Get more detailed log
+
+You can check arbitrary received methods with the familliar Array's (and of course including Enumerable's!) methods such as `any?`, `all`, `first`, `[]`, `index`.
+Because `spy(object).received_messages` returns an array of `Crispy::ReceivedMessage` instances.
+**You don't have to remember the tons of matchers for received arguments any more!!**
+
+```ruby
+>>
+  spy(object).received_messages.any? do|m|
+    m.method_name == :your_cool_method && m.arguments.all? {|arg| arg.is_a? Integer }
+  end
+=> true
+
+>> last_method_call = spy(object).received_messages.last
+>>
+  last_method_call.method_name == :your_finalizer &&
+    last_method_call.arguments == ['resource to release']
+=> true
+```
+
+### Stub Methods of a Spy
+
+```ruby
+>> spy(object).stub(:your_cool_method, 'Awesome!')
+>> object.your_cool_method
+=> "Awesome!"
+
+>> spy(object).stub(your_lovely_method: 'I love this method!', your_finalizer: 'Finalized!')
+>> object.your_lovely_method
+=> "I love this method!"
+>> object.your_finalizer
+=> "Finalized!"
+```
+
+### Stub Methods of a Double
+
+```ruby
+>> your_awesome_double = double('your awesome double', nice!: '+1!', sexy?: true)
+>> your_awesome_double.nice!
+=> "+1!"
+>> your_awesome_double.sexy?
+=> true
+
+>> your_awesome_double.stub(:another_method, 'can be stubbed.')
+>> your_awesome_double.another_method
+=> "can be stubbed."
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/igrep/crispy/fork )
+2. Create your feature branch (`git checkout -b your-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin your-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/crispy.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crispy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "crispy"
+  spec.version       = Crispy::VERSION
+  spec.authors       = ["Yamamoto Yuji"]
+  spec.email         = ["whosekiteneverfly@gmail.com"]
+  spec.summary       = %q{Test spy for any object in Ruby.}
+  spec.description   =
+    "Test spy for any object in Ruby.\n" \
+    "It makes mocks obsolete so you don't have to be worried about " \
+    "where to put the expectations (i.e. before or after the subject method)."
+  spec.homepage      = "https://github.com/igrep/crispy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rubydoctest"
+
+  spec.required_ruby_version = '>= 2.0'
+end

data/lib/crispy.rb

@@ -0,0 +1,41 @@
+require "crispy/version"
+require "crispy/crispy_internal/spy"
+require "crispy/crispy_internal/double"
+
+module Crispy
+  # All methods of this module should be module_function.
+  module_function
+
+  # Returns a Spy object to wrap all methods of the object.
+  def spy_into object, stubs_map = {}
+    ::Crispy::CrispyInternal::Spy.new object, stubs_map
+  end
+
+  def double name_or_stubs_map = nil, stubs_map = {}
+    ::Crispy::CrispyInternal::Double.new name_or_stubs_map, stubs_map
+  end
+
+  # Make and returns a Crispy::ClassSpy's instance to spy all instances of a class.
+  def spy_on_any_instance_of klass
+    raise NotImplementedError, "Sorry, this feature is under construction :("
+    ::Crispy::CrispyInternal::ClassSpy.new klass
+  end
+
+  def spy object
+    object.__CRISPY_SPY__
+  end
+
+  # Begins to log all instances and its received messages of a class.
+  # _NOTE_: replace the constant containing the class
+  def spy_into_class! klass
+    raise NotImplementedError, "Sorry, this feature is under construction :("
+    spy_class = spy_on_any_instance_of klass
+    stub_const! klass.name, spy_class
+    spy_class
+  end
+
+  def stub_const! const_name, value
+    raise NotImplementedError, "Sorry, this feature is under construction :("
+  end
+
+end

data/lib/crispy/crispy/received_message.rb

@@ -0,0 +1,25 @@
+module Crispy
+  module Crispy
+    class ReceivedMessage
+
+      attr_reader :method_name, :arguments, :attached_block
+
+      class << self
+        alias [] new
+      end
+
+      def initialize method_name, *arguments, &attached_block
+        @method_name = method_name
+        @arguments = arguments
+        @attached_block = attached_block
+      end
+
+      def == other
+        @method_name == other.method_name &&
+        @arguments == other.arguments &&
+        @attached_block == other.attached_block
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/double.rb

@@ -0,0 +1,25 @@
+require 'crispy/crispy_internal/with_stubber'
+
+module Crispy
+  module CrispyInternal
+    class Double
+      include WithStubber
+
+      def initialize name_or_stubs_map = nil, stubs_map = {}
+        if name_or_stubs_map.is_a? ::Hash
+          @name = ''.freeze
+          initialize_stubber(name_or_stubs_map)
+        else
+          @name = name_or_stubs_map
+          initialize_stubber(stubs_map)
+        end
+        singleton_class =
+          class << self
+            self
+          end
+        prepend_stubber singleton_class
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/spy.rb

@@ -0,0 +1,52 @@
+require 'crispy/crispy/received_message'
+require 'crispy/crispy_internal/spy_mixin'
+require 'crispy/crispy_internal/with_stubber'
+
+module Crispy
+  module CrispyInternal
+    class Spy < ::Module
+      include SpyMixin
+      include WithStubber
+
+      def initialize target, stubs_map = {}
+        super()
+        @received_messages = []
+        singleton_class =
+          class << target
+            self
+          end
+        initialize_stubber stubs_map
+        prepend_stubber singleton_class
+
+        prepend_features singleton_class
+        target.__CRISPY_SPY__ = self
+      end
+
+      def prepend_features klass
+        super
+        klass.public_instance_methods.each do|method_name|
+          self.module_eval { public define_wrapper(method_name) }
+        end
+        klass.protected_instance_methods.each do|method_name|
+          self.module_eval { protected define_wrapper(method_name) }
+        end
+        klass.private_instance_methods.each do|method_name|
+          self.module_eval { private define_wrapper(method_name) }
+        end
+
+        # define accessor after prepending to avoid to spy unexpectedly.
+        module_eval { attr_accessor :__CRISPY_SPY__ }
+      end
+
+      private def define_wrapper method_name
+        define_method method_name do|*arguments, &attached_block|
+          @__CRISPY_SPY__.received_messages <<
+            ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+          super(*arguments, &attached_block)
+        end
+        method_name
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/spy_mixin.rb

@@ -0,0 +1,37 @@
+require 'crispy/crispy/received_message'
+
+module Crispy
+  module CrispyInternal
+    module SpyMixin
+
+      attr_reader :received_messages
+
+      def received? method_name, *arguments, &attached_block
+        if arguments.empty? and attached_block.nil?
+          @received_messages.map(&:method_name).include? method_name
+        else
+          @received_messages.include? ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+        end
+      end
+
+      def received_once? method_name, *arguments, &attached_block
+        if arguments.empty? and attached_block.nil?
+          @received_messages.map(&:method_name).one? {|self_method_name| self_method_name == method_name }
+        else
+          @received_messages.one? do |self_received_message|
+            self_received_message == ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+          end
+        end
+      end
+
+      def count_received method_name, *arguments, &attached_block
+        if arguments.empty? and attached_block.nil?
+          @received_messages.map(&:method_name).count method_name
+        else
+          @received_messages.count ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+        end
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/stubber.rb

@@ -0,0 +1,31 @@
+module Crispy
+  module CrispyInternal
+    class Stubber < Module
+      public :prepend_features
+
+      def initialize stubs_map = {}
+        super()
+        stub stubs_map
+      end
+
+      NOT_SPECIFIED = ::Object.new
+
+      def stub method_name_or_hash, returned_value = NOT_SPECIFIED, &definition
+        case method_name_or_hash
+        when Hash
+          hash = method_name_or_hash
+          hash.each do|method_name, value|
+            stub method_name, value
+          end
+        when ::Symbol, ::String
+          self.module_exec method_name_or_hash do|method_name|
+            # TODO: should not ignore arguments?
+            define_method(method_name) {|*_arguments| returned_value }
+          end
+        end
+        self
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/with_stubber.rb

@@ -0,0 +1,22 @@
+require 'crispy/crispy_internal/stubber'
+
+module Crispy
+  module CrispyInternal
+    module WithStubber
+
+      private def initialize_stubber stubs_map = {}
+        @__CRISPY_STUBBER__ = Stubber.new(stubs_map)
+      end
+
+      private def prepend_stubber klass
+        @__CRISPY_STUBBER__.prepend_features klass
+      end
+
+      def stub *arguments, &definition
+        @__CRISPY_STUBBER__.stub(*arguments, &definition)
+        self
+      end
+
+    end
+  end
+end

data/lib/crispy/version.rb

@@ -0,0 +1,3 @@
+module Crispy
+  VERSION = "0.1.1"
+end

data/test/doctest-fixtures/your_cool_class.rb

@@ -0,0 +1,10 @@
+class YourCoolClass
+  def your_cool_method *args
+  end
+  def your_method_without_argument
+  end
+  def your_lovely_method *args
+  end
+  def your_finalizer *args
+  end
+end

data/test/test_crispy.rb

@@ -0,0 +1,145 @@
+$VERBOSE = true # enable warnings
+
+require 'crispy'
+require 'minitest/autorun'
+
+class TestCrispy < MiniTest::Test
+  include ::Crispy
+
+  # Inherit BasicObject because it has fewer meta-programming methods than Object
+  class ObjectClass < BasicObject
+    def hoge a, b, c
+      private_foo a
+      [a, b, c]
+    end
+    def foo
+      123
+    end
+    def bar
+      []
+    end
+    def method_to_stub1
+      fail "Not stubbed actually! The test fails."
+    end
+    def method_to_stub2
+      fail "Not stubbed actually! The test fails."
+    end
+
+    private def private_foo a
+      :private_foo
+    end
+  end
+
+  class TestCrispySpyInto < TestCrispy
+
+    def setup
+      @object = ObjectClass.new
+
+      @returned_spy = spy_into(
+        @object, method_to_stub1: :stubbed1, method_to_stub2: :stubbed2
+      )
+
+      @object.hoge 1, 2, 3
+      @object.foo
+      @object.hoge 3, 4, 5
+
+      @subject = spy(@object)
+    end
+
+    def test_spy_logs_messages_sent_to_an_object
+      assert_equal(
+        [
+          Crispy::ReceivedMessage[:hoge, 1, 2, 3],
+          Crispy::ReceivedMessage[:private_foo, 1],
+          Crispy::ReceivedMessage[:foo],
+          Crispy::ReceivedMessage[:hoge, 3, 4, 5],
+          Crispy::ReceivedMessage[:private_foo, 3],
+        ],
+        @subject.received_messages
+      )
+    end
+
+    def test_spy_has_received_messages_sent_to_an_object
+      assert @subject.received?(:hoge)
+      assert @subject.received?(:foo)
+      assert not(@subject.received?(:bar))
+      assert @subject.received?(:private_foo)
+    end
+
+    def test_spy_has_received_messages_with_arguments_sent_to_an_object
+      assert @subject.received?(:hoge, 1, 2, 3)
+      assert @subject.received?(:hoge, 3, 4, 5)
+      assert @subject.received?(:private_foo, 1)
+      assert @subject.received?(:private_foo, 3)
+      assert not(@subject.received?(:hoge, 0, 0, 0))
+      assert not(@subject.received?(:private_foo, 0, 0, 0))
+      assert not(@subject.received?(:foo, 1))
+      assert not(@subject.received?(:bar, nil))
+    end
+
+    def test_spy_has_received_messages_once_sent_to_an_object
+      assert not(@subject.received_once?(:hoge))
+      assert not(@subject.received_once?(:private_foo))
+      assert @subject.received_once?(:hoge, 3, 4, 5)
+      assert @subject.received_once?(:private_foo, 3)
+      assert not(@subject.received_once?(:private_foo, 3, 4))
+      assert @subject.received_once?(:foo)
+      assert not(@subject.received_once?(:bar))
+    end
+
+    def test_spy_counts_received_messages_sent_to_an_object
+      assert_equal(1, @subject.count_received(:hoge, 1, 2, 3))
+      assert_equal(1, @subject.count_received(:hoge, 3, 4, 5))
+      assert_equal(0, @subject.count_received(:hoge, 0, 0, 0))
+      assert_equal(2, @subject.count_received(:hoge))
+
+      assert_equal(1, @subject.count_received(:private_foo, 1))
+      assert_equal(1, @subject.count_received(:private_foo, 3))
+      assert_equal(0, @subject.count_received(:private_foo, 0))
+      assert_equal(2, @subject.count_received(:private_foo))
+
+      assert_equal(1, @subject.count_received(:foo))
+      assert_equal(0, @subject.count_received(:bar))
+    end
+
+    def test_spy_changes_stubbed_method
+      assert_equal(:stubbed1, @object.method_to_stub1)
+      assert_equal(:stubbed2, @object.method_to_stub2)
+    end
+
+    def test_spy_is_also_returned_by_spy_into_method
+      assert_same @subject, @returned_spy
+    end
+
+  end
+
+  class TestCrispyDouble < TestCrispy
+    def setup
+      @expected_hoge = Object.new
+      @expected_foo  = Object.new
+      @expected_bar  = Object.new
+      @expected_baz  = Object.new
+
+      @double = double('some double', hoge: @expected_hoge, foo: @expected_foo)
+      @double.stub(bar: @expected_bar, baz: @expected_baz)
+
+      @actual_hoge1 = @double.hoge :with, :any, :arguments do
+        'and a block'
+      end
+      @actual_hoge2 = @double.hoge
+      @actual_foo = @double.foo
+      @actual_bar = @double.bar
+      @actual_baz = @double.baz
+    end
+
+    def test_double_can_stub_specified_methods
+      assert_same @expected_hoge, @actual_hoge1
+      assert_same @expected_hoge, @actual_hoge2
+      assert_same @expected_foo, @actual_foo
+      assert_same @expected_bar, @actual_bar
+      assert_same @expected_baz, @actual_baz
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: crispy
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Yamamoto Yuji
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubydoctest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Test spy for any object in Ruby.
+  It makes mocks obsolete so you don't have to be worried about where to put the expectations (i.e. before or after the subject method).
+email:
+- whosekiteneverfly@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- crispy.gemspec
+- lib/crispy.rb
+- lib/crispy/crispy/received_message.rb
+- lib/crispy/crispy_internal/double.rb
+- lib/crispy/crispy_internal/spy.rb
+- lib/crispy/crispy_internal/spy_mixin.rb
+- lib/crispy/crispy_internal/stubber.rb
+- lib/crispy/crispy_internal/with_stubber.rb
+- lib/crispy/version.rb
+- test/doctest-fixtures/your_cool_class.rb
+- test/test_crispy.rb
+homepage: https://github.com/igrep/crispy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Test spy for any object in Ruby.
+test_files:
+- test/doctest-fixtures/your_cool_class.rb
+- test/test_crispy.rb