shared_should 0.5.6 → 0.6.0

data/README.rdoc

@@ -16,25 +16,25 @@ Sharing shoulds is easy.
       setup { @book = Book.new(:quantity => 1, :price => 10_00 }
       
       ### Define a shared should
-      shared_should_be "available for checkout" { assert @book.available_for_checkout? }
+      share_should "be available for checkout" { assert @book.available_for_checkout? }
 
       context "with a rentable book" do
         setup { @book.rentable = true }
 
-        ### Use the "available for checkout" shared_should
-        should_be "available for checkout"
+        ### 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 "available for checkout" shared_should in this context too
-        should_be "available for checkout"
+        ### 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
-      should_be("available for checkout").when("rentable") { @book.rentable = true }
-      should_be("available for checkout").when("purchasable") { @book.purchasable = true }
+      use_should("be available for checkout").when("rentable") { @book.rentable = true }
+      use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
     end
   end
 
@@ -44,11 +44,11 @@ Sharing setups is easy, too.
 
   context "Book" do
     ### Define a shared setup
-    shared_setup_for "an in-stock book" { @book = Book.new(:quantity => 1, :price => 10_00) }
+    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
-      setup_for "an in-stock book"
+      use_setup "for an in-stock book"
       
       ### Do some additional setup after the shared setup
       setup { @book.rentable = true }
@@ -58,7 +58,7 @@ Sharing setups is easy, too.
     
     context "with an in-stock purchasable book" do
       ### Use the shared setup again
-      setup_for "an in-stock book"
+      use_setup "for an in-stock book"
       
       setup { @book.purchasable = true }
       
@@ -75,7 +75,7 @@ Sharing whole contexts? Schmeasy!
       setup { @book = Book.new(:quantity => 1, :price => 10_00) }
     
       ### Define a shared context
-      shared_context_for "a book available for checkout" do
+      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 }
@@ -85,19 +85,19 @@ Sharing whole contexts? Schmeasy!
         setup { @book.rentable = true }
       
         ### Run the shoulds inside the shared context with a rentable book
-        should_be "a book available for checkout"
+        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
-        should_be "a book available for checkout"
+        use_context "for a book available for checkout"
       end
       
       ### ...or DRY it up by using .with or .when and an initialization block
-      should_be("a book available for checkout").when("rentable") { @book.rentable = true }
-      should_be("a book available for checkout").when("purchasable") { @book.purchasable = true }
+      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
 
@@ -106,7 +106,7 @@ Sharing whole contexts? Schmeasy!
 === Finding Your Share
 
 Some rules:
-* When <tt>should_be</tt> or <tt>setup_for</tt> is invoked, it searches up the context hierarchy to find a matching shared definition.
+* 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.
@@ -118,15 +118,15 @@ The shared invocation accepts an initialization block by chaining <tt>when</tt>
   context "Book" do
     setup { @book = Book.new(:quantity => 1, :price => 10_00) }
     
-    shared_should_be "available for checkout" { assert @book.available_for_checkout? }
+    share_should "be available for checkout" { assert @book.available_for_checkout? }
     
     context "with a rentable book" do
-      # when shared_should_be "available for checkout" is executed, @book will have rentable equal to true
-      should_be "available for checkout".when("rentable") { @book.rentable = true }
+      # 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
-      should_be "available for checkout".when("purchasable") { @book.purchasable = true }
+      use_should "be available for checkout".when("purchasable") { @book.purchasable = true }
     end
   end
 
@@ -135,13 +135,13 @@ The shared invocation accepts an initialization block by chaining <tt>when</tt>
 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
-    shared_setup_for "an in-stock book" do |rentable|
+    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"
-      setup_for("an in-stock book").with("a rentable book") { true }
+      use_setup("for an in-stock book").with("a rentable book") { true }
       
       should "be available for checkout" { assert @book.available_for_checkout? }
     end
@@ -153,13 +153,13 @@ Here is a parameterized shared should.
     context "with in-stock book" do
       setup { @book = Book.new(:quantity => 1) }
     
-      shared_should_be "unavailable for checkout for price" do |price|
+      share_should "be unavailable for checkout for price" do |price|
         @book.price = price
         assert_false @book.available_for_checkout?
       end
 
-      should_be("unavailable for checkout for price").when("zero") { 0 }
-      should_be("unavailable for checkout for price").when("negative") { -1 }
+      use_should("be unavailable for checkout for price").when("zero") { 0 }
+      use_should("be unavailable for checkout for price").when("negative") { -1 }
     end
   end
 
@@ -169,7 +169,7 @@ And a parameterized shared context.
     context "with in-stock book" do
       setup { @book = Book.new(:quantity => 1) }
 
-      shared_context_for "a book available for checkout at price" do
+      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 }
         
@@ -179,7 +179,7 @@ And a parameterized shared context.
         should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
       end
 
-      should_be("a book available for checkout at price").when("positive") { 10_00 }
+      use_context("for a book available for checkout at price").when("positive") { 10_00 }
     end
   end
 
@@ -189,14 +189,14 @@ The shared functions also accept multiple parameters when the initialization blo
     context "with rentable book" do
       setup { @book = Book.new(:rentable => true) }
   
-      shared_should_be "unavailable for checkout for quantity and price" do |quantity, price|
+      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
 
-      should_be("unavailable for checkout for quantity and price").when("zero quantity") { [0, 10_00] }
-      should_be("unavailable for checkout for quantity and price").when("zero price") { [1, 0] }
+      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
 
@@ -207,7 +207,7 @@ The shared functions can also be re-usable across multiple test cases.
 In your test helper file:
 
   class Test::Unit::TestCase
-    shared_setup_for "an in-stock book" do |rentable, purchasable|
+    share_setup "for an in-stock book" do |rentable, purchasable|
       @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => purchasable)
     end
   end
@@ -216,7 +216,7 @@ In your test file:
 
   class BookTest < Test::Unit::TestCase
     context "with an in-stock book" do
-      shared_setup_for "an in-stock book".with { [true, true] }
+      share_setup "for an in-stock book".with { [true, true] }
       
       should "be in stock" { assert @book.quantity > 0 }
     end

data/VERSION

@@ -1 +1 @@
-0.5.6
+0.6.0

data/lib/shared_should.rb

@@ -99,25 +99,23 @@ module Shoulda::SharedContext
   end
   
   module SharedContextMethods
-    def shared_context_blocks
-       @shared_context_blocks ||= {}
-    end
-  
-    def shared_setup_blocks
-       @shared_setup_blocks ||= {}
-    end
-
     def shared_proxies
       @shared_proxies ||= []
     end
   
-    def should_be(shared_name)
+    def use_should(shared_name)
       shared_proxy = Shoulda::SharedProxy.new(shared_name)
       shared_proxies << shared_proxy
       return shared_proxy
     end
-  
-    def setup_for(shared_name)
+    
+    def use_context(shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(shared_name)
+      shared_proxies << shared_proxy
+      return shared_proxy
+    end
+    
+    def use_setup(shared_name)
       shared_proxy = Shoulda::SharedProxy.new(shared_name)
       shared_setup_block = find_shared_setup_block(shared_name)
       setup do
@@ -163,13 +161,14 @@ module Shoulda::SharedContext
       end
     end
   
+    # deprecated
     def shared_context_should(shared_context_name, &shared_context_block)
-      shared_context_for(shared_context_name, &shared_context_block)
+      share_context(shared_context_name, &shared_context_block)
     end
 
-    def shared_context_for(shared_context_name, &shared_context_block)
+    def share_context(shared_context_name, &shared_context_block)
       wrapping_shared_context_block = Proc.new do
-        context "for #{shared_context_name}" do
+        context shared_context_name do
           merge_block(&shared_context_block)
         end
       end
@@ -177,13 +176,14 @@ module Shoulda::SharedContext
       do_shared_context(shared_context_name, shared_context_for_block(shared_context_block), &wrapping_shared_context_block)
     end
 
+    # deprecated
     def shared_should(shared_should_name, &shared_should_block)
-      shared_should_be(shared_should_name, &shared_should_block)
+      share_should(shared_should_name, &shared_should_block)
     end
 
-    def shared_should_be(shared_should_name, &shared_should_block)
+    def share_should(shared_should_name, &shared_should_block)
       shared_context_block = Proc.new do
-        should "be #{shared_should_name}" do
+        should shared_should_name do
           call_block_with_shared_value(shared_should_block)
         end
       end
@@ -191,6 +191,7 @@ module Shoulda::SharedContext
       do_shared_context(shared_should_name, shared_context_for_block(shared_should_block), &shared_context_block)
     end
 
+    # deprecated
     def shared_setup(shared_name, &setup_block)
       shared_setup_block = Proc.new do
         call_block_with_shared_value(setup_block)
@@ -199,7 +200,7 @@ module Shoulda::SharedContext
       do_shared_setup(shared_name, shared_context_for_block(setup_block), &shared_setup_block)
     end
 
-    def shared_setup_for(shared_name, &setup_block)
+    def share_setup(shared_name, &setup_block)
       current_context = eval('self', setup_block.binding)
       Test::Unit::TestCase.shared_context_block_owner(current_context).shared_setup_blocks[shared_name] = setup_block
     end
@@ -208,6 +209,10 @@ module Shoulda::SharedContext
        @shared_context_blocks ||= {}
     end
 
+    def shared_should_blocks
+       @shared_should_blocks ||= {}
+    end
+
     def shared_setup_blocks
        @shared_setup_blocks ||= {}
     end
@@ -286,11 +291,11 @@ module Shoulda::SharedContext
         if shared_setup_block = Test::Unit::TestCase.shared_context_block_owner(current_context).shared_setup_blocks[shared_name]
           return shared_setup_block
         end
-        raise "Unable to find shared_setup_for('#{shared_name}')" if current_context.kind_of?(Class)
+        raise "Unable to find share_setup('#{shared_name}')" if current_context.kind_of?(Class)
         break unless current_context.kind_of?(Shoulda::Context)
         current_context = current_context.parent
       end
-      raise "Unable to find shared_setup_for('#{shared_name}')"
+      raise "Unable to find share_setup('#{shared_name}')"
     end
   end
 end

data/shared_should.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{shared_should}
-  s.version = "0.5.6"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]

data/test/test_shared_should.rb

@@ -11,9 +11,9 @@ class TestSharedShould < Test::Unit::TestCase
     assert @setup_instance_method_executed
   end
   
-  context ".shared_context_for" do
+  context ".share_context" do
     context "without params" do
-      shared_context_for "a valid value" do
+      share_context "for a valid value" do
         setup do
           @context_value = true
         end
@@ -32,11 +32,11 @@ class TestSharedShould < Test::Unit::TestCase
           @value = true
         end
   
-        should_be("a valid value")
+        use_context "for a valid value"
       end
     
       context "with value in initializer" do
-        should_be("a valid value").when("a true value") { @value = true }
+        use_context("for a valid value").when("a true value") { @value = true }
       end
     end
     
@@ -45,7 +45,7 @@ class TestSharedShould < Test::Unit::TestCase
         @value = true
       end
       
-      shared_context_for "a valid specified value" do
+      share_context "for a valid specified value" do
         setup do |value|
           @expected_value = value
           @context_value = true
@@ -64,10 +64,10 @@ class TestSharedShould < Test::Unit::TestCase
         end
       end
       
-      should_be("a valid specified value").when("true") { true }
+      use_context("for a valid specified value").when("true") { true }
     end
   end
-    
+  
   context ".shared_context_should" do
     context "without params" do
       setup do
@@ -119,9 +119,9 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  context ".shared_should_be" do
+  context ".share_should" do
     context "without params" do
-      shared_should_be "a true value" do
+      share_should "be a true value" do
         assert @value
       end
       
@@ -130,15 +130,15 @@ class TestSharedShould < Test::Unit::TestCase
           @value = true
         end
         
-        should_be("a true value")
+        use_should "be a true value"
       end
       
       context "when value in initializer" do
-        should_be("a true value").when("value is true") { @value = true }
+        use_should("be a true value").when("value is true") { @value = true }
       end
       
       context "with value in initializer" do
-        should_be("a true value").with("true value") { @value = true }
+        use_should("be a true value").with("true value") { @value = true }
       end
     end
     
@@ -147,11 +147,11 @@ class TestSharedShould < Test::Unit::TestCase
         @value = true
       end
       
-      shared_should_be "a valid specified value" do |value|
+      share_should "be a valid specified value" do |value|
         assert_equal value, @value
       end
       
-      should_be("a valid specified value").when("true") { true }
+      use_should("be a valid specified value").when("true") { true }
     end
   end
   
@@ -219,7 +219,7 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  context ".shared_setup_for" do
+  context ".share_setup" do
     context "without params" do
       context "without initialization block" do
         setup do
@@ -227,11 +227,11 @@ class TestSharedShould < Test::Unit::TestCase
           @value = false
         end
   
-        shared_setup_for "true value" do
+        share_setup "for true value" do
           @value = true
         end
   
-        setup_for("true value")
+        use_setup("for true value")
   
         should "have a true value from shared setup" do
           assert @value
@@ -244,11 +244,11 @@ class TestSharedShould < Test::Unit::TestCase
           @value = false
         end
   
-        shared_setup_for "value" do
+        share_setup "for value" do
           @value = @initialization_value
         end
   
-        setup_for("value").when("initialization value is true") { @initialization_value = true }
+        use_setup("for value").with("true initialization value") { @initialization_value = true }
   
         should "have a true value from shared setup" do
           assert @value
@@ -257,7 +257,7 @@ class TestSharedShould < Test::Unit::TestCase
     end
     
     context "with parameterized initialization block" do
-      shared_setup_for "value" do |value|
+      share_setup "for value" do |value|
         @value = value
       end
       
@@ -267,7 +267,7 @@ class TestSharedShould < Test::Unit::TestCase
           @value = false
         end
       
-        setup_for("value").when("initialization value is true") { true }
+        use_setup("for value").with("true initialization value") { true }
       
         should "have a true value from shared setup" do
           assert @value
@@ -319,47 +319,47 @@ class TestSharedShould < Test::Unit::TestCase
   end
   
   context "context directly under test class" do
-    shared_setup_for("a true value") do
+    share_setup "for a true value" do
       @value = true
     end
     
-    shared_should_be("a valid should test") do
+    share_should "be a valid should test" do
       assert @value
     end
     
-    shared_context_for("a valid context test") do
+    share_context "for a valid context test" do
       should "have a true value" do
         assert @value
       end
     end
-
-    setup_for("a true value")
+  
+    use_setup "for a true value"
     
-    should_be("a valid should test")
+    use_should "be a valid should test"
     
-    should_be("a valid context test")
+    use_context "for a valid context test"
   end
   
   # test class as context
-  shared_setup_for("a true value in class") do
+  share_setup "for a true value in class" do
     @class_value = true
   end
   
-  shared_should_be("a valid should test in class") do
+  share_should "be a valid should test in class" do
     assert @class_value
   end
   
-  shared_context_for("a valid context test in class") do
+  share_context "for a valid context test in class" do
     should "have a true value" do
       assert @class_value
     end
   end
-
-  setup_for("a true value in class")
   
-  should_be("a valid should test in class")
+  use_setup "for a true value in class"
+  
+  use_should "be a valid should test in class"
   
-  should_be("a valid context test in class")
+  use_context "for a valid context test in class"
   
   
   # ensure should macros work
@@ -394,36 +394,36 @@ class TestSharedShould < Test::Unit::TestCase
   
   # ensure test methods are created
   expected_method_names = [
-    "test: .shared_context_for with params when true for a valid specified value should call setup in shared context. ",
-    "test: .shared_context_for with params when true for a valid specified value should call setup in shared context. ",
-    "test: .shared_context_for with params when true for a valid specified value should have specified value. ",
-    "test: .shared_context_for with params when true for a valid specified value should setup @expected_value. ",
-    "test: .shared_context_for without params with value in initializer when a true value for a valid value should call setup in shared context. ",
-    "test: .shared_context_for without params with value in initializer when a true value for a valid value should have true value. ",
-    "test: .shared_context_for without params with value in setup for a valid value should call setup in shared context. ",
-    "test: .shared_context_for without params with value in setup for a valid value should have true value. ",
-    "test: .shared_context_should with params for be valid for specified value should call setup in shared context. ",
-    "test: .shared_context_should with params for be valid for specified value should have specified value. ",
-    "test: .shared_context_should with params for be valid for specified value should setup @expected_value. ",
-    "test: .shared_context_should without params for be valid should call setup in shared context. ",
-    "test: .shared_context_should without params for be valid should have true value. ",
+    "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: .shared_setup_for with parameterized initialization block with shared setup value should have a true value from shared setup. ",
-    "test: .shared_setup_for without params with initialization block should have a true value from shared setup. ",
-    "test: .shared_setup_for without params without initialization block should have a true value from shared setup. ",
-    "test: .shared_should with params should be have specified value. ",
-    "test: .shared_should without params should be have true value. ",
-    "test: .shared_should_be with params when true should be a valid specified value. ",
-    "test: .shared_should_be without params when value in initializer when value is true should be a true value. ",
-    "test: .shared_should_be without params with value in initializer with true value should be a true value. ",
-    "test: .shared_should_be without params with value in setup should be a true value. ",
+    "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 for be valid with shared context should do something with shared_value. ",
-    "test: parameterized block with an array for be valid with shared context should do something with value block param. ",
-    "test: parameterized block with an array for be valid with shared context should do something with value block params. ",
-    "test: parameterized block with an array should be be valid with shared should. ",
+    "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. ",

data/test/test_shared_should_helper.rb

@@ -6,7 +6,7 @@ class SubclassTestCase < Test::Unit::TestCase
     assert @value
   end
   
-  shared_should_be "a true value for shared should helper" do
+  share_should "be a true value for shared should helper" do
     assert @value
   end
   
@@ -23,7 +23,7 @@ class Test::Unit::TestCase
     end
   end
   
-  shared_context_for "a true value for shared context helper" do
+  share_context "for a true value for shared context helper" do
     should "be true value" do
       assert @value
     end
@@ -33,7 +33,7 @@ class Test::Unit::TestCase
     @value = true
   end
   
-  shared_setup_for "a true value for shared setup helper" do
+  share_setup "for a true value for shared setup helper" do
     @value = true
   end
 end
@@ -47,7 +47,7 @@ class TestSharedShouldHelper < SubclassTestCase
       
       should_have_true_value_for_shared_should_helper
       
-      should_be("a true value for shared should helper")
+      use_should "be a true value for shared should helper"
     end
     
     context "with shared context helper" do
@@ -57,7 +57,7 @@ class TestSharedShouldHelper < SubclassTestCase
       
       should_be_valid_for_shared_context_helper
       
-      should_be("a true value for shared context helper")
+      use_context "for a true value for shared context helper"
     end
     
     context "with shared_setup helper" do
@@ -68,8 +68,8 @@ class TestSharedShouldHelper < SubclassTestCase
       end
     end
     
-    context "with shared_setup_for helper" do
-      setup_for("a true value for shared setup helper")
+    context "with share_setup helper" do
+      use_setup "for a true value for shared setup helper"
       
       should "be true value" do
         assert @value

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 5
   - 6
-  version: 0.5.6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Michael Pearce