shared_should 0.6.5 → 0.6.6

data/VERSION

@@ -1 +1 @@
-0.6.5
+0.6.6

data/lib/shared_should.rb

@@ -17,7 +17,6 @@ end
 
 class Test::Unit::TestCase
   attr_accessor :shared_value
-  attr_accessor :shared_name
   @@shared_proxies_executed = {}
   @@setup_blocks = {}
 
@@ -30,7 +29,7 @@ class Test::Unit::TestCase
     # assuming 'suite' is called before executing any tests - may be a poor assumption. Find something better?
     unless @@shared_proxies_executed[self]
       shared_proxies.each do |shared_proxy|
-        shared_proxy.execute(self)
+        shared_proxy.execute
       end
       @@shared_proxies_executed[self] = true
     end
@@ -56,9 +55,8 @@ class Test::Unit::TestCase
     @@setup_blocks[self] << setup_block
   end
   
-  def setup_shared_values(name, initialization_block)
+  def setup_shared_value(initialization_block)
     self.shared_value = initialization_block.nil? ? nil : initialization_block.bind(self).call
-    self.shared_name = name
   end
   
   def call_block_with_shared_value(test_block)
@@ -110,24 +108,22 @@ module Shoulda::SharedContext
     end
   
     def use_should(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
       shared_proxies << shared_proxy
       return shared_proxy
     end
     
     def use_context(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
       shared_proxies << shared_proxy
       return shared_proxy
     end
     
     def use_setup(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
       shared_setup_block = find_shared_setup_block(shared_name)
       setup do
-        if initialization_block = shared_proxy.initialization_block
-          setup_shared_values(shared_proxy.description, shared_proxy.initialization_block)
-        end
+        shared_proxy.execute_and_set_shared_value(self)
         call_block_with_shared_value(shared_setup_block)
       end
       return shared_proxy
@@ -139,7 +135,7 @@ module Shoulda::SharedContext
           block.bind(self).call
         
           shared_proxies.each do |shared_proxy|
-            shared_proxy.execute(self)
+            shared_proxy.execute
           end
         end
         shared_proxies_executing_block.bind(eval("self", block.binding))
@@ -238,7 +234,7 @@ module Shoulda::SharedContext
 
       caller_context.context name do
         setup do
-          setup_shared_values(name, initialization_block)
+          setup_shared_value(initialization_block)
         end
 
         merge_block(&shared_context_block)
@@ -260,13 +256,13 @@ module Shoulda::SharedContext
         caller_context.send(:alias_method, without_method, :setup)
         caller_context.send(:define_method, with_method) do
           send(without_method)
-          setup_shared_values(name, setup_block)
+          setup_shared_value(setup_block)
           shared_setup_block.bind(self).call
         end
         caller_context.send(:alias_method, :setup, with_method)
       else
         caller_context.setup do
-          setup_shared_values(name, setup_block)
+          setup_shared_value(setup_block)
           shared_setup_block.bind(self).call
         end
       end
@@ -316,45 +312,71 @@ end
 
 
 class Shoulda::SharedProxy
-  attr_accessor :shared_name, :description, :initialization_blocks
+  attr_accessor :shared_name, :description, :block_configs, :context
   
-  def initialize(shared_name)
+  def initialize(context, shared_name)
+    self.context = context
     self.shared_name = shared_name
-    self.initialization_blocks = []
+    self.block_configs = []
   end
   
   def with(description = nil, &initialization_block)
-    with_helper("with", description, &initialization_block)
+    add_proxy_block(:with, "with", description, &initialization_block)
   end
   
   def when(description = nil, &initialization_block)
-    with_helper("when", description, &initialization_block)
+    add_proxy_block(:with, "when", description, &initialization_block)
   end
   
   def given(description = nil, &initialization_block)
-    with_helper("given", description, :disable_and => true, &initialization_block)
+    # given needs to execute before its with_setup
+    add_proxy_block(:given, "given", description, :disable_and => true, :insert_block_before_end => @current_action == :with_setup, &initialization_block)
+  end
+  
+  def with_setup(description)
+    initialization_block = context.send(:find_shared_setup_block, description)
+    add_proxy_block(:with_setup, "with setup", description, :disable_and => true, &initialization_block)
   end
   
-  def execute(context)
+  def execute
     method_name = context.send(:shared_method_name, :should, shared_name)
     context.send(method_name, description, &initialization_block)
   end
   
+  def execute_and_set_shared_value(test_context)
+    initialization_block.bind(test_context).call
+  end
+  
   def initialization_block
-    blocks = initialization_blocks
+    the_block_configs = block_configs
     return Proc.new do
-      blocks.collect {|block| block.bind(self).call if block}.last
+      the_block_configs.collect do |block_config|
+        block = block_config[:block]
+        if block_config[:action] == :given
+          setup_shared_value(block)
+        else
+          call_block_with_shared_value(block) if block
+        end
+      end.last
+      # # TODO: needs shared_value
+      # blocks.collect {|block| block.bind(self).call if block}.last
     end
   end
   
-  private
+private
   
-  def with_helper(conditional, description, options = {}, &initialization_block)
+  def add_proxy_block(action, conditional, description, options = {}, &block)
+    @current_action = action
     if description
       and_text = options[:disable_and] ? ' ' : ' and '
       self.description = "#{self.description}#{self.description.nil? ? nil : and_text}#{conditional} #{description}"
     end
-    self.initialization_blocks << initialization_block
+    block_config = {:block => block, :action => action}
+    if options[:insert_block_before_end]
+      self.block_configs.insert(-2, block_config)
+    else
+      self.block_configs << block_config
+    end
     return self
   end
 end

data/shared_should.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{shared_should}
-  s.version = "0.6.5"
+  s.version = "0.6.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]
-  s.date = %q{2011-03-18}
+  s.date = %q{2011-03-19}
   s.description = %q{Share and reuse shoulds, contexts, and setup in Shoulda.}
   s.email = %q{michael.pearce@bookrenter.com}
   s.extra_rdoc_files = [

data/test/test_shared_should.rb

@@ -403,7 +403,69 @@ class TestSharedShould < Test::Unit::TestCase
     use_context "for a valid context test"
   end
   
-
+  context "chaining" do
+    context "with ordering verification" do
+      setup do
+        @count = 0
+      end
+  
+      share_setup "shared setup 1" do
+        assert_equal 1, @count
+        @count += 1
+      end
+  
+      share_setup "shared setup 2" do
+        assert_equal 3, @count
+        @count += 1
+      end
+  
+      share_should "be valid shared should" do
+        assert_equal 7, @count
+      end
+  
+      use_should("be valid shared should").
+        with_setup("shared setup 1").given("setup value") { assert_equal 0, @count; @count += 1 }.
+        with_setup("shared setup 2").given("setup value") { assert_equal 2, @count; @count += 1 }.
+        with("initialization value") { assert_equal 4, @count; @count += 1 }.
+        with("initialization value") { assert_equal 5, @count; @count += 1 }.
+        given { assert_equal 6, @count; @count += 1 }
+    end
+    
+    context "with parameters" do
+      share_setup "shared setup 1" do |value|
+        assert_equal :one, value
+      end
+    
+      share_setup "shared setup 2" do |value|
+        assert_equal :two, value
+      end
+      
+      share_should "be valid shared should with parameter" do |value|
+        assert_equal :three, @value
+        assert_equal :four, value
+      end
+    
+      use_should("be valid shared should with parameter").
+        with_setup("shared setup 1").given { :one }.
+        with_setup("shared setup 2").given { :two }.
+        with("initialization value") { @value = :three }.
+        given { :four }
+        
+      # TODO: this assertion enforces that only a trailing 'given' block is used for parameter argument
+      # For legacy reasons, return value from with/when currently can also be used for parameter arguement
+      #
+      # share_should "be valid shared should without parameter" do
+      #   assert_equal :three, @value
+      #   assert_nil shared_value
+      # end
+      # 
+      # use_should("be valid shared should without parameter").
+      #   with_setup("shared setup 1").given { :one }.
+      #   with_setup("shared setup 2").given { :two }.
+      #   with("initialization value") { @value = :three }
+    end
+  end
+  
   # ensure should macros work
   def self.should_be_a_valid_macro
     should "be a valid macro" do
@@ -476,7 +538,9 @@ class TestSharedShould < Test::Unit::TestCase
           "test: .share_context with params given true for a valid specified value should have specified value. ",
           "test: .share_context with params with chaining when using initialization chain given true for a chained value should chain initialization block and be with params. ",
           "test: .share_should with params with chaining when using initialization chain given true should be a valid specified value. ",
-          "test: .share_should with params given true should be a valid specified value. "
+          "test: .share_should with params given true should be a valid specified value. ",
+          "test: chaining with parameters with setup shared setup 1 with setup shared setup 2 and with initialization value should be valid shared should with parameter. ",
+          "test: chaining with ordering verification with setup shared setup 1 given setup value with setup shared setup 2 given setup value and with initialization value and with initialization value should be valid shared should. "
         ].inject({}) do |hash, expected_method_name|
         hash[expected_method_name] = true
         hash

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shared_should
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 6
-  - 5
-  version: 0.6.5
+  - 6
+  version: 0.6.6
 platform: ruby
 authors: 
 - Michael Pearce
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-18 00:00:00 -07:00
+date: 2011-03-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency