shared_should 0.6.0 → 0.6.1

data/README.md

@@ -0,0 +1,238 @@
+# Shared Should - Share and reuse shoulds, contexts, and setups with Shoulda - easy, schmeasy.
+
+Shared Should allows you to easily create reusable shoulds, contexts and setups with familiar looking Shoulda syntax. Inspired by Rspec's shared example groups for context reuse, Shared Should allows sharing of contexts, shoulds,
+and setup blocks. Shared Should goes even further by allowing an initialization block and parameterization to fine-tune the usage of the shared functionality.
+
+## Quick-Start Examples
+
+Some quick examples to get you started using Shared Should. The domain of the examples is customers renting and purchasing textbooks - like we do at  [BookRenter.com](http://www.bookrenter.com "BookRenter.com").
+
+### Shared Should
+
+Sharing shoulds is easy.
+
+    context "Book" do
+        context "with an in-stock book" do
+            setup { @book = Book.new(:quantity => 1, :price => 10_00 }
+            
+            ### Define a shared should
+            share_should "be available for checkout" { assert @book.available_for_checkout? }
+
+            context "with a rentable book" do
+                setup { @book.rentable = true }
+
+                ### Use the "be available for checkout" share_should
+                use_should "be available for checkout"
+            end
+
+            context "with a purchasable book" do
+                setup { @book.purchasable = true }
+
+                ### Use the "be available for checkout" share_should in this context too
+                use_should "be available for checkout"
+            end
+            
+            ### ...or DRY it up by using .when and an initialization block
+            use_should("be available for checkout").when("rentable") { @book.rentable = true }
+            use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
+        end
+    end
+
+### Shared Setup
+
+Sharing setups is easy, too.
+
+    context "Book" do
+        ### Define a shared setup
+        share_setup "for an in-stock book" { @book = Book.new(:quantity => 1, :price => 10_00) }
+        
+        context "with an in-stock rentable book" do
+            ### Use the shared setup here
+            use_setup "for an in-stock book"
+            
+            ### Do some additional setup after the shared setup
+            setup { @book.rentable = true }
+            
+            should "be available for checkout" { assert @book.available_for_checkout? }
+        end
+        
+        context "with an in-stock purchasable book" do
+            ### Use the shared setup again
+            use_setup "for an in-stock book"
+            
+            setup { @book.purchasable = true }
+            
+            should "be available for checkout" { assert @book.available_for_checkout? }
+        end
+    end
+    
+### Shared Context
+
+Sharing whole contexts? Schmeasy!
+
+    context "Book" do
+        context "with an in-stock book" do
+            setup { @book = Book.new(:quantity => 1, :price => 10_00) }
+        
+            ### Define a shared context
+            share_context "for a book available for checkout" do
+                should "be in stock" { assert @book.quantity > 0 }
+                should "have a non-negative price" { assert @book.price > 0 }
+                should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
+            end
+        
+            context "with a rentable book" do
+                setup { @book.rentable = true }
+            
+                ### Run the shoulds inside the shared context with a rentable book
+                use_context "for a book available for checkout"
+            end
+        
+            context "with a purchasable book" do
+                setup { @book.purchasable = true }
+            
+                ### Run the shoulds inside the shared context again with a purchasable book
+                use_context "for a book available for checkout"
+            end
+            
+            ### ...or DRY it up by using .when and an initialization block
+            use_context("for a book available for checkout").when("rentable") { @book.rentable = true }
+            use_context("for a book available for checkout").when("purchasable") { @book.purchasable = true }
+        end
+    end
+
+## More Information on Syntax and Usage
+
+### Finding Your Share
+
+Some rules:
+
+* When <tt>use\_should</tt>, <tt>use\_context</tt> or <tt>use\_setup</tt> is invoked, it searches up the context hierarchy to find a matching shared definition.
+* You can redefine your shares by using the same name. These shares will only be available in in the current and descendant contexts.
+* Shares defined at the root (on your TestCase) are available in all contexts.
+* If you define a shared setup at the root level, you will need to call <tt>super</tt> if you have a setup instance method for your test.
+
+### Initialization Block
+
+The shared invocation accepts an initialization block by chaining <tt>when</tt> followed by a block. This block can be used to create or modify instance variables used by the shared functionality. It always executes before the shared functionality.
+
+    context "Book" do
+        setup { @book = Book.new(:quantity => 1, :price => 10_00) }
+        
+        share_should "be available for checkout" { assert @book.available_for_checkout? }
+        
+        context "with a rentable book" do
+            # when share_should "be available for checkout" is executed, @book will have rentable equal to true
+            use_should("be available for checkout").when("rentable") { @book.rentable = true }
+        end
+        
+        context "with a purchasable book" do
+            use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
+        end
+    end
+
+### Parameterizing Shares
+
+Shared functions can also be parameterized using block parameters. This can be done for shared setups, shoulds, and the setups and shoulds contained within a shared context. The value passed to the shared function is the return value of the <tt>with</tt> parameterization block. The below example parameterizes a shared setup.
+
+    context "Book" do
+        share_setup "for an in-stock book" do |rentable|
+            @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => false)
+        end
+
+        context "with rentable book" do
+            # the return value of the block is "true" which will be passed as the block parameter "rentable"
+            use_setup("for an in-stock book").with { true }
+            
+            should "be available for checkout" { assert @book.available_for_checkout? }
+        end
+    end
+
+Here is a parameterized shared should.
+
+    context "Book" do
+        context "with in-stock book" do
+            setup { @book = Book.new(:quantity => 1) }
+        
+            share_should "be unavailable for checkout for price" do |price|
+                @book.price = price
+                assert_false @book.available_for_checkout?
+            end
+
+            use_should("be unavailable for checkout for price").with("zero") { 0 }
+            use_should("be unavailable for checkout for price").with("a negative price") { -1 }
+        end
+    end
+
+And a parameterized shared context.
+
+    context "Book" do
+        context "with in-stock book" do
+            setup { @book = Book.new(:quantity => 1) }
+
+            share_context "for a book available for checkout at price" do
+                # parameters are on the setup and shoulds, not on the context
+                setup { |price| @book.price = price }
+                
+                # we could also access price in the should blocks, but we don't need it again
+                should "be in stock" { assert @book.quantity > 0 }
+                should "have a non-negative price" { assert @book.price > 0 }
+                should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
+            end
+
+            use_context("for a book available for checkout at price").with("a positive price") { 10_00 }
+        end
+    end
+
+The shared functions also accept multiple parameters when the parameterization block returns an array.
+
+    context "Book" do
+        context "with rentable book" do
+            setup { @book = Book.new(:rentable => true) }
+    
+            share_should "be unavailable for checkout for quantity and price" do |quantity, price|
+                @book.quantity = quantity
+                @book.price = price
+                assert_false @book.available_for_checkout?
+            end
+
+            use_should("be unavailable for checkout for quantity and price").with("a zero quantity") { [0, 10_00] }
+            use_should("be unavailable for checkout for quantity and price").with("a zero price") { [1, 0] }
+        end
+    end
+
+### Creating a Library of Shared Functionality
+
+The shared functions can also be re-usable across multiple test cases.
+
+In your test helper file:
+
+    class Test::Unit::TestCase
+        share_setup "for an in-stock book" do |rentable, purchasable|
+            @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => purchasable)
+        end
+    end
+
+In your test file:
+
+    class BookTest < Test::Unit::TestCase
+        context "with an in-stock book" do
+            use_setup("for an in-stock book").with { [true, true] }
+            
+            should "be in stock" { assert @book.quantity > 0 }
+        end
+    end
+
+
+# Credits
+
+Shared Shoulda is maintained by [Michael Pearce](http://github.com/michaelgpearce) and is funded by [BookRenter.com](http://www.bookrenter.com "BookRenter.com"). Many of the ideas that have inspired Shared Should come
+from practical usage by the Bookrenter software development team and conversations with Bookrenter developers [Andrew Wheeler](http://github.com/jawheeler), [Ben Somers](http://github.com/bensomers), and [Philippe Huibonhoa](http://github.com/phuibonhoa).
+
+![BookRenter.com Logo](http://assets0.bookrenter.com/images/header/bookrenter_logo.gif "BookRenter.com")
+
+
+# Copyright
+
+Copyright (c) 2011 Michael Pearce, Bookrenter.com. See LICENSE.txt for further details.
+

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/lib/shared_should.rb

@@ -120,7 +120,7 @@ module Shoulda::SharedContext
       shared_setup_block = find_shared_setup_block(shared_name)
       setup do
         if initialization_block = shared_proxy.initialization_block
-          setup_shared_values(shared_proxy.when_description, shared_proxy.initialization_block)
+          setup_shared_values(shared_proxy.description, shared_proxy.initialization_block)
         end
         call_block_with_shared_value(shared_setup_block)
       end
@@ -310,29 +310,41 @@ end
 
 
 class Shoulda::SharedProxy
-  attr_accessor :shared_name, :when_description, :initialization_block
+  attr_accessor :shared_name, :description, :initialization_blocks
   
   def initialize(shared_name)
     self.shared_name = shared_name
+    self.initialization_blocks = []
   end
   
-  def when(when_description = nil, &initialization_block)
-    when_helper("when", when_description, &initialization_block)
+  def when(description = nil, &initialization_block)
+    when_helper("when", description, &initialization_block)
+    return self
   end
   
-  def with(with_description = nil, &initialization_block)
-    when_helper("with", with_description, &initialization_block)
+  def with(description = nil, &initialization_block)
+    when_helper("with", description, &initialization_block)
+    return nil
   end
   
   def execute(context)
     method_name = context.send(:shared_method_name, :should, shared_name)
-    context.send(method_name, when_description, &initialization_block)
+    context.send(method_name, description, &initialization_block)
+  end
+  
+  def initialization_block
+    blocks = initialization_blocks
+    return Proc.new do
+      blocks.collect {|block| block.bind(self).call}.last
+    end
   end
   
   private
   
-  def when_helper(when_name, when_description = nil, &initialization_block)
-    self.when_description = when_description ? "#{when_name} #{when_description}" : nil
-    self.initialization_block = initialization_block
+  def when_helper(conditional, description = nil, &initialization_block)
+    if description
+      self.description = "#{self.description}#{self.description.nil? ? nil : ' and '}#{conditional} #{description}"
+    end
+    self.initialization_blocks << initialization_block
   end
 end

data/shared_should.gemspec

@@ -5,23 +5,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{shared_should}
-  s.version = "0.6.0"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]
-  s.date = %q{2011-02-18}
+  s.date = %q{2011-03-02}
   s.description = %q{Share and reuse shoulds, contexts, and setup in Shoulda.}
   s.email = %q{michael.pearce@bookrenter.com}
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "lib/shared_should.rb",
@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/michaelgpearce/shared_should}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.0}
+  s.rubygems_version = %q{1.5.2}
   s.summary = %q{Share and reuse shoulds, contexts, and setup in Shoulda.}
   s.test_files = [
     "test/helper.rb",

data/test/test_shared_should.rb

@@ -64,7 +64,18 @@ class TestSharedShould < Test::Unit::TestCase
         end
       end
       
-      use_context("for a valid specified value").when("true") { true }
+      use_context("for a valid specified value").with("true") { true }
+      
+      context "with chaining" do
+        share_context "for a chained value" do
+          should "chain initialization block and be with params" do |value|
+            assert @chain
+            assert value
+          end
+        end
+        
+        use_context("for a chained value").when("using initialization chain") { @chain = true }.with("true") { true }
+      end
     end
   end
   
@@ -138,7 +149,7 @@ class TestSharedShould < Test::Unit::TestCase
       end
       
       context "with value in initializer" do
-        use_should("be a true value").with("true value") { @value = true }
+        use_should("be a true value").when("value is true") { @value = true }
       end
     end
     
@@ -151,7 +162,17 @@ class TestSharedShould < Test::Unit::TestCase
         assert_equal value, @value
       end
       
-      use_should("be a valid specified value").when("true") { true }
+      use_should("be a valid specified value").with("true") { true }
+      
+      context "with chaining" do
+        share_should "be a valid specified value" do |value|
+          assert @chain
+          assert value
+        end
+        
+        use_should("be a valid specified value").when("using initialization chain") { @chain = true }.with("true") { true }
+        use_should("be a valid specified value").when("using initialization chain xxxx") { @chain = true }.with("true") { true }
+      end
     end
   end
   
@@ -248,7 +269,7 @@ class TestSharedShould < Test::Unit::TestCase
           @value = @initialization_value
         end
   
-        use_setup("for value").with("true initialization value") { @initialization_value = true }
+        use_setup("for value").when("initialization value is true") { @initialization_value = true }
   
         should "have a true value from shared setup" do
           assert @value
@@ -256,7 +277,7 @@ class TestSharedShould < Test::Unit::TestCase
       end
     end
     
-    context "with parameterized initialization block" do
+    context "with param block" do
       share_setup "for value" do |value|
         @value = value
       end
@@ -267,12 +288,30 @@ class TestSharedShould < Test::Unit::TestCase
           @value = false
         end
       
-        use_setup("for value").with("true initialization value") { true }
+        use_setup("for value").with("true") { true }
       
         should "have a true value from shared setup" do
           assert @value
         end
       end
+      
+      context "with chaining" do
+        setup do
+          @chain = nil
+          @value = nil
+        end
+        
+        share_setup "for value" do |value|
+          @value = value
+        end
+        
+        use_setup("for value").when("using initialization chain") { @chain = true }.with("true") { true }
+        
+        should "have used share with chain and params" do
+          assert @chain
+          assert @value
+        end
+      end
     end
   end
   
@@ -394,41 +433,44 @@ class TestSharedShould < Test::Unit::TestCase
   
   # ensure test methods are created
   expected_method_names = [
-    "test: .share_context with params when true for a valid specified value should call setup in shared context. ",
-    "test: .share_context with params when true for a valid specified value should call setup in shared context. ",
-    "test: .share_context with params when true for a valid specified value should have specified value. ",
-    "test: .share_context with params when true for a valid specified value should setup @expected_value. ",
-    "test: .share_context without params with value in initializer when a true value for a valid value should call setup in shared context. ",
-    "test: .share_context without params with value in initializer when a true value for a valid value should have true value. ",
-    "test: .share_context without params with value in setup for a valid value should call setup in shared context. ",
-    "test: .share_context without params with value in setup for a valid value should have true value. ",
-    "test: .shared_context_should with params be valid for specified value should call setup in shared context. ",
-    "test: .shared_context_should with params be valid for specified value should have specified value. ",
-    "test: .shared_context_should with params be valid for specified value should setup @expected_value. ",
-    "test: .shared_context_should without params be valid should call setup in shared context. ",
-    "test: .shared_context_should without params be valid should have true value. ",
-    "test: .shared_setup with params with shared setup value should have a true value from shared setup. ",
-    "test: .shared_setup without params with shared setup value should have a true value from shared setup. ",
-    "test: .share_setup with parameterized initialization block with shared setup value should have a true value from shared setup. ",
-    "test: .share_setup without params with initialization block should have a true value from shared setup. ",
-    "test: .share_setup without params without initialization block should have a true value from shared setup. ",
-    "test: .shared_should with params should have specified value. ",
-    "test: .shared_should without params should have true value. ",
-    "test: .share_should with params when true should be a valid specified value. ",
-    "test: .share_should without params when value in initializer when value is true should be a true value. ",
-    "test: .share_should without params with value in initializer with true value should be a true value. ",
-    "test: .share_should without params with value in setup should be a true value. ",
-    "test: context directly under test class for a valid context test should have a true value. ",
-    "test: context directly under test class should be a valid should test. ",
-    "test: parameterized block with an array be valid with shared context should do something with shared_value. ",
-    "test: parameterized block with an array be valid with shared context should do something with value block param. ",
-    "test: parameterized block with an array be valid with shared context should do something with value block params. ",
-    "test: parameterized block with an array should be valid with shared should. ",
-    "test:  should be a valid should test in class. ",
-    "test: for a valid context test in class should have a true value. ",
-    "test: SharedShould should execute setup instance method. ",
-    "test: shoulda macro should be a valid macro. "
-  ].inject({}) do |hash, expected_method_name|
+      'test:  should be a valid should test in class. ',
+      'test: .share_context with params with chaining when using initialization chain and with true for a chained value should chain initialization block and be with params. ',
+      'test: .share_context with params with true for a valid specified value should call setup in shared context. ',
+      'test: .share_context with params with true for a valid specified value should have specified value. ',
+      'test: .share_context with params with true for a valid specified value should setup @expected_value. ',
+      'test: .share_context without params with value in initializer when a true value for a valid value should call setup in shared context. ',
+      'test: .share_context without params with value in initializer when a true value for a valid value should have true value. ',
+      'test: .share_context without params with value in setup for a valid value should call setup in shared context. ',
+      'test: .share_context without params with value in setup for a valid value should have true value. ',
+      'test: .share_setup with param block with chaining should have used share with chain and params. ',
+      'test: .share_setup with param block with shared setup value should have a true value from shared setup. ',
+      'test: .share_setup without params with initialization block should have a true value from shared setup. ',
+      'test: .share_setup without params without initialization block should have a true value from shared setup. ',
+      'test: .share_should with params with chaining when using initialization chain and with true should be a valid specified value. ',
+      'test: .share_should with params with chaining when using initialization chain xxxx and with true should be a valid specified value. ',
+      'test: .share_should with params with true should be a valid specified value. ',
+      'test: .share_should without params when value in initializer when value is true should be a true value. ',
+      'test: .share_should without params with value in initializer when value is true should be a true value. ',
+      'test: .share_should without params with value in setup should be a true value. ',
+      'test: .shared_context_should with params be valid for specified value should call setup in shared context. ',
+      'test: .shared_context_should with params be valid for specified value should have specified value. ',
+      'test: .shared_context_should with params be valid for specified value should setup @expected_value. ',
+      'test: .shared_context_should without params be valid should call setup in shared context. ',
+      'test: .shared_context_should without params be valid should have true value. ',
+      'test: .shared_setup with params with shared setup value should have a true value from shared setup. ',
+      'test: .shared_setup without params with shared setup value should have a true value from shared setup. ',
+      'test: .shared_should with params should have specified value. ',
+      'test: .shared_should without params should have true value. ',
+      'test: SharedShould should execute setup instance method. ',
+      'test: context directly under test class for a valid context test should have a true value. ',
+      'test: context directly under test class should be a valid should test. ',
+      'test: for a valid context test in class should have a true value. ',
+      'test: parameterized block with an array be valid with shared context should do something with shared_value. ',
+      'test: parameterized block with an array be valid with shared context should do something with value block param. ',
+      'test: parameterized block with an array be valid with shared context should do something with value block params. ',
+      'test: parameterized block with an array should be valid with shared should. ',
+      'test: shoulda macro should be a valid macro. '
+    ].inject({}) do |hash, expected_method_name|
     hash[expected_method_name] = true
     hash
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shared_should
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Michael Pearce
@@ -15,13 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-18 00:00:00 -08:00
+date: 2011-03-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: shoulda
-  type: :development
   version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,11 +29,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  prerelease: false
+  type: :development
   requirement: *id001
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: bundler
-  type: :development
   version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -47,11 +45,11 @@ dependencies:
         - 0
         - 0
         version: 1.0.0
+  prerelease: false
+  type: :development
   requirement: *id002
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: jeweler
-  type: :development
   version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -63,11 +61,11 @@ dependencies:
         - 5
         - 2
         version: 1.5.2
+  prerelease: false
+  type: :development
   requirement: *id003
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: rcov
-  type: :development
   version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -77,11 +75,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  prerelease: false
+  type: :development
   requirement: *id004
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: shoulda
-  type: :runtime
   version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -91,11 +89,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  prerelease: false
+  type: :runtime
   requirement: *id005
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: shoulda
-  type: :development
   version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -105,6 +103,8 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  prerelease: false
+  type: :development
   requirement: *id006
 description: Share and reuse shoulds, contexts, and setup in Shoulda.
 email: michael.pearce@bookrenter.com
@@ -114,13 +114,13 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE.txt
-- README.rdoc
+- README.md
 files: 
 - .document
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - lib/shared_should.rb
@@ -158,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.0
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Share and reuse shoulds, contexts, and setup in Shoulda.

data/README.rdoc

@@ -1,235 +0,0 @@
-= Shared Should - Share and reuse shoulds, contexts, and setups with Shoulda - easy, schmeasy.
-
-Shared Should allows you to easily create reusable shoulds, contexts and setups with familiar looking Shoulda syntax. Inspired by Rspec's shared example groups for context reuse, Shared Should allows sharing of contexts, shoulds,
-and setup blocks.  Shared Should goes even further by allowing an initialization block and parameterization to fine-tune the usage of the shared functionality.
-
-== Quick-Start Examples
-
-Some quick examples to get you started using Shared Should. The domain is customers renting and purchasing textbooks - like we do at Bookrenter.com.
-
-=== Shared Should
-
-Sharing shoulds is easy.
-
-  context "Book" do
-    context "with an in-stock book" do
-      setup { @book = Book.new(:quantity => 1, :price => 10_00 }
-      
-      ### Define a shared should
-      share_should "be available for checkout" { assert @book.available_for_checkout? }
-
-      context "with a rentable book" do
-        setup { @book.rentable = true }
-
-        ### Use the "be available for checkout" share_should
-        use_should "be available for checkout"
-      end
-
-      context "with a purchasable book" do
-        setup { @book.purchasable = true }
-
-        ### Use the "be available for checkout" share_should in this context too
-        use_should "be available for checkout"
-      end
-      
-      ### ...or DRY it up by using .with or .when and an initialization block
-      use_should("be available for checkout").when("rentable") { @book.rentable = true }
-      use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
-    end
-  end
-
-=== Shared Setup
-
-Sharing setups is easy, too.
-
-  context "Book" do
-    ### Define a shared setup
-    share_setup "for an in-stock book" { @book = Book.new(:quantity => 1, :price => 10_00) }
-    
-    context "with an in-stock rentable book" do
-      ### Use the shared setup here
-      use_setup "for an in-stock book"
-      
-      ### Do some additional setup after the shared setup
-      setup { @book.rentable = true }
-      
-      should "be available for checkout" { assert @book.available_for_checkout? }
-    end
-    
-    context "with an in-stock purchasable book" do
-      ### Use the shared setup again
-      use_setup "for an in-stock book"
-      
-      setup { @book.purchasable = true }
-      
-      should "be available for checkout" { assert @book.available_for_checkout? }
-    end
-  end
-  
-=== Shared Context
-
-Sharing whole contexts? Schmeasy!
-
-  context "Book" do
-    context "with an in-stock book" do
-      setup { @book = Book.new(:quantity => 1, :price => 10_00) }
-    
-      ### Define a shared context
-      share_context "for a book available for checkout" do
-        should "be in stock" { assert @book.quantity > 0 }
-        should "have a non-negative price" { assert @book.price > 0 }
-        should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
-      end
-    
-      context "with a rentable book" do
-        setup { @book.rentable = true }
-      
-        ### Run the shoulds inside the shared context with a rentable book
-        use_context "for a book available for checkout"
-      end
-    
-      context "with a purchasable book" do
-        setup { @book.purchasable = true }
-      
-        ### Run the shoulds inside the shared context again with a purchasable book
-        use_context "for a book available for checkout"
-      end
-      
-      ### ...or DRY it up by using .with or .when and an initialization block
-      use_context("for a book available for checkout").when("rentable") { @book.rentable = true }
-      use_context("for a book available for checkout").when("purchasable") { @book.purchasable = true }
-    end
-  end
-
-== More Information on Syntax and Usage
-
-=== Finding Your Share
-
-Some rules:
-* When <tt>use_should</tt>, <tt>use_context</tt> or <tt>use_setup</tt> is invoked, it searches up the context hierarchy to find a matching shared definition.
-* You can redefine your shares by using the same name. These shares will only be available in in the current and descendant contexts.
-* Shares defined at the root (on your TestCase) are available in all contexts.
-* If you define a shared setup at the root level, you will need to call <tt>super</tt> if you have a setup instance method for your test.
-
-=== Initialization Block
-
-The shared invocation accepts an initialization block by chaining <tt>when</tt> or <tt>with</tt>. This block can be used to create or modify instance variables used by the shared functionality.  It always executes before the shared functionality.
-
-  context "Book" do
-    setup { @book = Book.new(:quantity => 1, :price => 10_00) }
-    
-    share_should "be available for checkout" { assert @book.available_for_checkout? }
-    
-    context "with a rentable book" do
-      # when share_should "be available for checkout" is executed, @book will have rentable equal to true
-      use_should "be available for checkout".when("rentable") { @book.rentable = true }
-    end
-    
-    context "with a purchasable book" do
-      use_should "be available for checkout".when("purchasable") { @book.purchasable = true }
-    end
-  end
-
-=== Parameterizing Shares
-
-Shared functions can also be parameterized using block parameters. This can be done for shared setups, shoulds, and the setups and shoulds contained within a shared context. The value passed to the declared shared function is the return value of the initialization block. The below example parameterizes a shared setup.
-
-  context "Book" do
-    share_setup "for an in-stock book" do |rentable|
-      @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => false)
-    end
-
-    context "with rentable book" do
-      # the return value of the block is "true" which will be passed as the block parameter "rentable"
-      use_setup("for an in-stock book").with("a rentable book") { true }
-      
-      should "be available for checkout" { assert @book.available_for_checkout? }
-    end
-  end
-
-Here is a parameterized shared should.
-
-  context "Book" do
-    context "with in-stock book" do
-      setup { @book = Book.new(:quantity => 1) }
-    
-      share_should "be unavailable for checkout for price" do |price|
-        @book.price = price
-        assert_false @book.available_for_checkout?
-      end
-
-      use_should("be unavailable for checkout for price").when("zero") { 0 }
-      use_should("be unavailable for checkout for price").when("negative") { -1 }
-    end
-  end
-
-And a parameterized shared context.
-
-  context "Book" do
-    context "with in-stock book" do
-      setup { @book = Book.new(:quantity => 1) }
-
-      share_context "for a book available for checkout at price" do
-        # parameters are on the setup and shoulds, not on the context
-        setup { |price| @book.price = price }
-        
-        # we could also access price in the should blocks, but we don't need it again
-        should "be in stock" { assert @book.quantity > 0 }
-        should "have a non-negative price" { assert @book.price > 0 }
-        should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
-      end
-
-      use_context("for a book available for checkout at price").when("positive") { 10_00 }
-    end
-  end
-
-The shared functions also accept multiple parameters when the initialization block returns an array.
-
-  context "Book" do
-    context "with rentable book" do
-      setup { @book = Book.new(:rentable => true) }
-  
-      share_should "be unavailable for checkout for quantity and price" do |quantity, price|
-        @book.quantity = quantity
-        @book.price = price
-        assert_false @book.available_for_checkout?
-      end
-
-      use_should("be unavailable for checkout for quantity and price").when("zero quantity") { [0, 10_00] }
-      use_should("be unavailable for checkout for quantity and price").when("zero price") { [1, 0] }
-    end
-  end
-
-=== Creating a Library of Shared Functionality
-
-The shared functions can also be re-usable across multiple test cases.
-
-In your test helper file:
-
-  class Test::Unit::TestCase
-    share_setup "for an in-stock book" do |rentable, purchasable|
-      @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => purchasable)
-    end
-  end
-
-In your test file:
-
-  class BookTest < Test::Unit::TestCase
-    context "with an in-stock book" do
-      share_setup "for an in-stock book".with { [true, true] }
-      
-      should "be in stock" { assert @book.quantity > 0 }
-    end
-  end
-
-
-= Credits
-
-Shared Shoulda is maintained by Michael Pearce (michael.pearce__at__bookrenter__com) and is funded by Bookrenter.com[http://www.bookrenter.com]. Many of the ideas that have inspired Shared Should come
-from practical usage by the Bookrenter software development team and conversations with Bookrenter developers Andrew Wheeler and Philippe Huibonhoa.
-
-
-= Copyright
-
-Copyright (c) 2011 Michael Pearce, Bookrenter.com. See LICENSE.txt for further details.
-