always_execute 0.1.3 → 0.2.0

data/Gemfile.lock

@@ -1,16 +1,21 @@
 PATH
   remote: .
   specs:
-    always_execute (0.1.2)
+    always_execute (0.2.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
     diff-lcs (1.1.3)
+    i18n (0.6.1)
+    metaclass (0.0.1)
     minitest (2.12.1)
-    mocha (0.9.8)
-      rake
-    rake (0.9.2.2)
+    mocha (0.12.6)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.6)
     rspec (2.9.0)
       rspec-core (~> 2.9.0)
       rspec-expectations (~> 2.9.0)
@@ -19,9 +24,14 @@ GEM
     rspec-expectations (2.9.1)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.9.0)
-    shared_should (0.8.3)
+    shared_should (0.9.0)
       shoulda
-    shoulda (2.11.3)
+    shoulda (3.1.1)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.2)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.3.0)
+      activesupport (>= 3.0.0)
 
 PLATFORMS
   ruby
@@ -31,5 +41,5 @@ DEPENDENCIES
   minitest (~> 2.12.1)
   mocha (~> 0)
   rspec (~> 2.9.0)
-  shared_should (~> 0.8.3)
-  shoulda (~> 2.11.3)
+  shared_should (~> 0.9.0)
+  shoulda (= 3.1.1)

data/Rakefile

@@ -12,5 +12,13 @@ require 'rspec/core/rake_task'
 desc "Run Rspecs"
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => [:test, :spec]
+task 'testversions' do
+  ENV['SHOULDA_VERSION'] = '2.11.3'
+  fail unless system "bundle update"
+  fail unless system "rake test"
+  ENV['SHOULDA_VERSION'] = '3.1.1'
+  fail unless system "bundle update"
+  fail unless system "rake test"
+end
 
+task :default => [:testversions, :spec]

data/always_execute.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency 'rspec', '~> 2.9.0'
-  s.add_development_dependency 'shoulda', '~> 2.11.3'
+  s.add_development_dependency('shoulda', ENV['SHOULDA_VERSION'] || "= 3.1.1") # Use SHOULDA_VERSION when testing different   
   s.add_development_dependency 'mocha', '~> 0'
   s.add_development_dependency 'minitest', '~> 2.12.1'
-  s.add_development_dependency 'shared_should', '~> 0.8.3'
+  s.add_development_dependency 'shared_should', '~> 0.9.0'
 end
 

data/docs/rspec_examples.md

@@ -6,84 +6,84 @@
 Notice in the test below there is **_setup_**, **_execute_**, and **_assert_** code all in the `it` blocks.  Different test cases are not separated by contexts, instead they're all just strewn together; it may not be immediately obvious, but we're really testing 3 different cases below (not 4 - the first 2 `it`s describe the default behavior of the dvd\_player).  It's easy to see how these problems could be much worse given a less trivial example and how these tests would not serve as the best documentation of how dvd_player#play works.
 
 ```ruby
-  describe "dvd player" do
+describe DvdPlayer do
+  before do
+    @dvd_player = DvdPlayer.new
+    @dvd = Dvd.new
+  end
+
+  it "should play movie" do
+    @dvd_player.play(@dvd)
+    @dvd_player.movie_playing?.should be_true
+  end
+
+  it "should not allow another disc to be inserted" do
+    @dvd_player.play(@dvd)
+    @dvd_player.allows_disc_insert?.should be_false
+  end
+
+  it "should not play movie with invalid region code" do
+    @dvd.region_code = 'invalid'
+    @dvd_player.play(@dvd)
+    @dvd_player.movie_playing?.should be_false
+  end
+
+  it "should resume from last played postiion with previously played dvd" do
+    @dvd.last_played_position = 123
+    @dvd_player.play(@dvd)
+    @dvd_player.movie_playing?.should be_true
+    @dvd_player.current_position.should == 123
+  end
+end
+```
+
+## With Always Execute
+
+When using always execute, you'll notice it's a lot DRYer, but more importantly all the **_setup_**, **_execute_**, and **_assert_** code is cleanly separated.  Furthermore, test cases are cleanly separated by contexts.  This makes it much easier to see that the first two should blocks apply to the default case, whereas the following contexts apply to exception cases.  It's also much easier to see what makes the exception cases different, since their **_setup_** code is cleanly spelled out, rather than lumped in with other code.
+
+```ruby
+describe DvdPlayer do
+  describe "#play" do
     before do
       @dvd_player = DvdPlayer.new
       @dvd = Dvd.new
     end
 
-    it "should play movie" do
+    execute do
       @dvd_player.play(@dvd)
+    end
+
+
+    it "should play movie" do
       @dvd_player.movie_playing?.should be_true
     end
   
     it "should not allow another disc to be inserted" do
-      @dvd_player.play(@dvd)
       @dvd_player.allows_disc_insert?.should be_false
     end
 
-    it "should not play movie with invalid region code" do
-      @dvd.region_code = 'invalid'
-      @dvd_player.play(@dvd)
-      @dvd_player.movie_playing?.should be_false
-    end
-
-    it "should resume from last played postiion with previously played dvd" do
-      @dvd.last_played_position = 123
-      @dvd_player.play(@dvd)
-      @dvd_player.movie_playing?.should be_true
-      @dvd_player.current_position.should == 123
-    end
-  end
-```
-
-## With Always Execute
-
-When using always execute, you'll notice it's a lot DRYer, but more importantly all the **_setup_**, **_execute_**, and **_assert_** code is cleanly separated.  Furthermore, test cases are cleanly separated by contexts.  This makes it much easier to see that the first two should blocks apply to the default case, whereas the following contexts apply to exception cases.  It's also much easier to see what makes the exception cases different, since their **_setup_** code is cleanly spelled out, rather than lumped in with other code.
-
-```ruby
-  describe "dvd player" do
-    context "#play" do
+    context "with invalid region code" do
       before do
-        @dvd_player = DvdPlayer.new
-        @dvd = Dvd.new
+        @dvd.region_code = 'invalid'
       end
 
-      execute do
-        @dvd_player.play(@dvd)
+      it "should not play movie" do
+        @dvd_player.movie_playing?.should be_false
       end
+    end
 
-
-      it "should play movie" do
-        @dvd_player.movie_playing?.should be_true
-      end
-    
-      it "should not allow another disc to be inserted" do
-        @dvd_player.allows_disc_insert?.should be_false
+    context "with previously played dvd" do
+      before do
+        @dvd.last_played_position = 123
       end
 
-      context "with invalid region code" do
-        before do
-          @dvd.region_code = 'invalid'
-        end
-  
-        it "should not play movie" do
-          @dvd_player.movie_playing?.should be_false
-        end
+      it "should resume from last played position" do
+        @dvd_player.movie_playing?.should be_true
+        @dvd_player.current_position.should == 123
       end
-
-      context "with previously played dvd" do
-        before do
-          @dvd.last_played_position = 123
-        end
-  
-        it "should resume from last played position" do
-          @dvd_player.movie_playing?.should be_true
-          @dvd_player.current_position.should == 123
-        end
-      end    
-    end
+    end    
   end
+end
 ```
     
 # Other Features
@@ -93,33 +93,33 @@ When using always execute, you'll notice it's a lot DRYer, but more importantly
 Often in specs, you are testing the returned value of a single function.  For connivence, the returned value of an execute block is stored in a variable called `@execute_result`.
 
 ```ruby
-  describe "dvd player" do
-    context "#current_dvd" do
-      before do
-        @dvd_player = DvdPlayer.new
-      end
+describe DvdPlayer do
+  describe "#current_dvd" do
+    before do
+      @dvd_player = DvdPlayer.new
+    end
 
-      execute do
-        @dvd_player.current_dvd
-      end
+    execute do
+      @dvd_player.current_dvd
+    end
 
-      context "without any dvd in the player" do
-        it "should return no dvd" do
-          @execute_result.should be_nil
-        end
+    context "without any dvd in the player" do
+      it "should return no dvd" do
+        @execute_result.should be_nil
       end
+    end
 
-      context "with a dvd in the player" do
-        before do
-          @dvd = Dvd.new
-          @dvd_player.insert(@dvd)
-        end
+    context "with a dvd in the player" do
+      before do
+        @dvd = Dvd.new
+        @dvd_player.insert(@dvd)
+      end
 
-        it "should return the dvd in the player" do
-          @execute_result.should == @dvd
-        end
+      it "should return the dvd in the player" do
+        @execute_result.should == @dvd
       end
     end
   end
+end
 ```
 

data/docs/shoulda_examples.md

@@ -6,37 +6,37 @@
 Notice in the test below there is **_setup_**, **_execute_**, and **_assert_** code all in the `should` blocks.  Different test cases are not separated by contexts, instead they're all just strewn together; it may not be immediately obvious, but we're really testing 3 different cases below (not 4 - the first 2 shoulds describe the default behavior of the dvd\_player).  It's easy to see how these problems could be much worse given a less trivial example and how these tests would not serve as the best documentation of how dvd_player#play works.
 
 ```ruby
-  class DvdPlayerTest
-    context "dvd player" do
-      setup do
-        @dvd_player = DvdPlayer.new
-        @dvd = Dvd.new
-      end
+class DvdPlayerTest
+  context "dvd player" do
+    setup do
+      @dvd_player = DvdPlayer.new
+      @dvd = Dvd.new
+    end
 
-      should "play movie" do
-        @dvd_player.play(@dvd)
-        assert @dvd_player.movie_playing?
-      end
-    
-      should "not allow another disc to be inserted" do
-        @dvd_player.play(@dvd)
-        assert_equal false, @dvd_player.allows_disc_insert?
-      end
+    should "play movie" do
+      @dvd_player.play(@dvd)
+      assert @dvd_player.movie_playing?
+    end
+  
+    should "not allow another disc to be inserted" do
+      @dvd_player.play(@dvd)
+      assert_equal false, @dvd_player.allows_disc_insert?
+    end
 
-      should "not play movie with invalid region code" do
-        @dvd.region_code = 'invalid'
-        @dvd_player.play(@dvd)
-        assert_equal false, @dvd_player.movie_playing?
-      end
+    should "not play movie with invalid region code" do
+      @dvd.region_code = 'invalid'
+      @dvd_player.play(@dvd)
+      assert_equal false, @dvd_player.movie_playing?
+    end
 
-      should "resume from last played postiion with previously played dvd" do
-        @dvd.last_played_position = 123
-        @dvd_player.play(@dvd)
-        assert @dvd_player.movie_playing?
-        assert_equal 123, @dvd_player.current_position
-      end
+    should "resume from last played postiion with previously played dvd" do
+      @dvd.last_played_position = 123
+      @dvd_player.play(@dvd)
+      assert @dvd_player.movie_playing?
+      assert_equal 123, @dvd_player.current_position
     end
   end
+end
 ```
 
 ## With Always Execute
@@ -44,48 +44,47 @@ Notice in the test below there is **_setup_**, **_execute_**, and **_assert_** c
 When using always execute, you'll notice it's a lot DRYer, but more importantly all the **_setup_**, **_execute_**, and **_assert_** code is cleanly separated.  Furthermore, test cases are cleanly separated by contexts.  This makes it much easier to see that the first two should blocks apply to the default case, whereas the following contexts apply to exception cases.  It's also much easier to see what makes the exception cases different, since their **_setup_** code is cleanly spelled out, rather than lumped in with other code.
 
 ```ruby
-  class DvdPlayerTest
-    context "#play" do
-      setup do
-        @dvd_player = DvdPlayer.new
-        @dvd = Dvd.new
-      end
+class DvdPlayerTest
+  context "#play" do
+    setup do
+      @dvd_player = DvdPlayer.new
+      @dvd = Dvd.new
+    end
 
-      execute do
-        @dvd_player.play(@dvd)
-      end
+    execute do
+      @dvd_player.play(@dvd)
+    end
 
+    should "play movie" do
+      assert @dvd_player.movie_playing?
+    end
+  
+    should "not allow another disc to be inserted" do
+      assert_equal false, @dvd_player.allows_disc_insert?
+    end
 
-      should "play movie" do
-        assert @dvd_player.movie_playing?
+    context "with invalid region code" do
+      setup do
+        @dvd.region_code = 'invalid'
       end
-    
-      should "not allow another disc to be inserted" do
-        assert_equal false, @dvd_player.allows_disc_insert?
+
+      should "not play movie" do
+        assert_equal false, @dvd_player.movie_playing?
       end
+    end
 
-      context "with invalid region code" do
-        setup do
-          @dvd.region_code = 'invalid'
-        end
-  
-        should "not play movie" do
-          assert_equal false, @dvd_player.movie_playing?
-        end
+    context "with previously played dvd" do
+      setup do
+        @dvd.last_played_position = 123
       end
 
-      context "with previously played dvd" do
-        setup do
-          @dvd.last_played_position = 123
-        end
-  
-        should "resume from last played position" do
-          assert @dvd_player.movie_playing?
-          assert_equal 123, @dvd_player.current_position
-        end
-      end    
-    end
+      should "resume from last played position" do
+        assert @dvd_player.movie_playing?
+        assert_equal 123, @dvd_player.current_position
+      end
+    end    
   end
+end
 ```
     
 # Other Features
@@ -95,34 +94,34 @@ When using always execute, you'll notice it's a lot DRYer, but more importantly
 Often in unit tests, you are testing the returned value of a single function.  For connivence, the returned value of an execute block is stored in a variable called `@execute_result`.
 
 ```ruby
-  class DvdPlayerTest
-    context "#current_dvd" do
-      setup do
-        @dvd_player = DvdPlayer.new
-      end
+class DvdPlayerTest
+  context "#current_dvd" do
+    setup do
+      @dvd_player = DvdPlayer.new
+    end
 
-      execute do
-        @dvd_player.current_dvd
-      end
+    execute do
+      @dvd_player.current_dvd
+    end
 
-      context "without any dvd in the player" do
-        should "return no dvd" do
-          assert_nil @execute_result
-        end
+    context "without any dvd in the player" do
+      should "return no dvd" do
+        assert_nil @execute_result
       end
+    end
 
-      context "with a dvd in the player" do
-        setup do
-          @dvd = Dvd.new
-          @dvd_player.insert(@dvd)
-        end
+    context "with a dvd in the player" do
+      setup do
+        @dvd = Dvd.new
+        @dvd_player.insert(@dvd)
+      end
 
-        should "return the dvd in the player" do
-          assert_equal @dvd, @execute_result
-        end
+      should "return the dvd in the player" do
+        assert_equal @dvd, @execute_result
       end
     end
   end
+end
 ```
 
 ## expects
@@ -130,20 +129,20 @@ Often in unit tests, you are testing the returned value of a single function.  F
 Expectations belong in the **_assert_** step of testing, but because of the nature of mocha expectations they need to be called in your `setup` block.  The `expects` block allows you to set your expectations without needing to create a new context.
 
 ```ruby
-  class DvdPlayerTest
-    context "#menu" do
-      setup do
-        @dvd_player = DvdPlayer.new
-      end
-
-      execute do
-        @dvd_player.menu
-      end
+class DvdPlayerTest
+  context "#menu" do
+    setup do
+      @dvd_player = DvdPlayer.new
+    end
 
-      expects do
-        @dvd_player.expects(:display_menu_options)
-      end    
+    execute do
+      @dvd_player.menu
     end
+
+    expects do
+      @dvd_player.expects(:display_menu_options)
+    end    
   end
+end
 ```
 

data/lib/always_execute.rb

@@ -1,11 +1,24 @@
-if defined?(Shoulda) && defined?(Shoulda::Context) && Shoulda::Context.instance_methods.include?(:should)
-  require 'shoulda_execute'
-  require 'shoulda_expects'
+require 'always_execute/version'
+
+if defined?(Shoulda::Context::Context)
+  require 'always_execute/shoulda_execute'
+  require 'always_execute/shoulda_expects'
+  
+  class Shoulda::Context::Context
+    include AlwaysExecute::ShouldaExecute
+    include AlwaysExecute::ShouldaExpects
+  end
+elsif defined?(Shoulda::Context) && Shoulda::Context.instance_methods.include?(:should)
+  require 'always_execute/shoulda_execute'
+  require 'always_execute/shoulda_expects'
+  
+  class Shoulda::Context
+    include AlwaysExecute::ShouldaExecute
+    include AlwaysExecute::ShouldaExpects
+  end
 end
 
 if defined?(RSpec)
-  require 'rspec_execute'
-  require 'rspec_expects'
+  require 'always_execute/rspec_execute'
+  require 'always_execute/rspec_expects'
 end
-
-require 'always_execute/version'

data/lib/always_execute/shoulda_execute.rb

@@ -0,0 +1,46 @@
+module AlwaysExecute
+  module ShouldaExecute
+    def self.included(klass)
+      klass.class_eval do
+        @@shoulda_execute_class = klass
+        
+        def execute(&execute_block)
+          setup do
+            @execute_block = execute_block
+          end
+        end
+
+        alias :should_without_execute :should
+
+        def should(name = nil, options = {}, &block)
+          if block.nil?
+            should_without_execute(name, options)
+          else
+            should_without_execute(name, options) do
+              if @execute_block
+                self.instance_variable_set('@execute_result', @@shoulda_execute_class.shoulda_execute_call_block(self, @execute_block))
+              end
+              @@shoulda_execute_class.shoulda_execute_call_block(self, block)
+            end
+          end
+        end
+        
+        def self.shoulda_execute_class
+          @@shoulda_execute_class
+        end
+        
+        def self.shoulda_execute_call_block(test, block)
+          if should_execute_shared_should_available?
+            test.call_block_with_shared_value(block)
+          else
+            block.bind(test).call
+          end
+        end
+
+        def self.should_execute_shared_should_available?
+          Test::Unit::TestCase.respond_to? :share_context
+        end
+      end
+    end
+  end
+end

data/lib/always_execute/shoulda_expects.rb

@@ -0,0 +1,20 @@
+module AlwaysExecute
+  module ShouldaExpects
+    def self.included(klass)
+      klass.class_eval do
+        def expects(name = nil, &expects_block)
+          context nil do
+            setup do
+              expects_block.bind(self).call
+            end
+      
+            should "meet expectation #{name}" do
+              # empty body
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/always_execute/version.rb

@@ -1,3 +1,3 @@
 module AlwaysExecute
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/test/shoulda_execute_test.rb

@@ -19,7 +19,8 @@ class ShouldaExecuteTest < Test::Unit::TestCase
       
       context "without shared_should library" do
         setup do
-          Shoulda::Context.expects(:should_execute_shared_should_available?).at_least_once.returns(false)
+         klass = defined?(Shoulda::Context::Context) ? Shoulda::Context::Context : Shoulda::Context
+         klass.shoulda_execute_class.expects(:should_execute_shared_should_available?).at_least_once.returns(false)
         end
         
         should "set execute_result to execute block return value" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: always_execute
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-01 00:00:00.000000000 Z
+date: 2012-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -32,17 +32,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
-        version: 2.11.3
+        version: 3.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
-        version: 2.11.3
+        version: 3.1.1
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +82,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -90,7 +90,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.0
 description: Adds execute and expect test blocks for added BDD test clarity.
 email:
 - michaelgpearce@yahoo.com
@@ -109,11 +109,11 @@ files:
 - docs/rspec_examples.md
 - docs/shoulda_examples.md
 - lib/always_execute.rb
+- lib/always_execute/rspec_execute.rb
+- lib/always_execute/rspec_expects.rb
+- lib/always_execute/shoulda_execute.rb
+- lib/always_execute/shoulda_expects.rb
 - lib/always_execute/version.rb
-- lib/rspec_execute.rb
-- lib/rspec_expects.rb
-- lib/shoulda_execute.rb
-- lib/shoulda_expects.rb
 - spec/execute_spec.rb
 - spec/expects_spec.rb
 - spec/spec_helper.rb

data/lib/shoulda_execute.rb

@@ -1,35 +0,0 @@
-class Shoulda::Context
-  def execute(&execute_block)
-    setup do
-      @execute_block = execute_block
-    end
-  end
-
-  alias :should_without_execute :should
-
-  def should(name = nil, options = {}, &block)
-    if block.nil?
-      should_without_execute(name, options)
-    else
-      should_without_execute(name, options) do
-        if @execute_block
-          self.instance_variable_set('@execute_result', Shoulda::Context.shoulda_execute_call_block(self, @execute_block))
-        end
-        Shoulda::Context.shoulda_execute_call_block(self, block)
-      end
-    end
-  end
-  
-  def self.shoulda_execute_call_block(test, block)
-    if should_execute_shared_should_available?
-      test.call_block_with_shared_value(block)
-    else
-      block.bind(test).call
-    end
-  end
-  
-  def self.should_execute_shared_should_available?
-    Test::Unit::TestCase.respond_to? :share_context
-  end
-end
-

data/lib/shoulda_expects.rb

@@ -1,14 +0,0 @@
-class Shoulda::Context
-  def expects(name = nil, &expects_block)
-    context nil do
-      setup do
-        expects_block.bind(self).call
-      end
-      
-      should "meet expectation #{name}" do
-        # empty body
-      end
-    end
-  end
-end
-