elight-coulda 0.1.4 → 0.2.0

data/HISTORY

@@ -9,3 +9,9 @@ Corrections for github gem build process
 0.1.2 && 0.1.3
 --------------
 Cleanup
+
+0.2.0
+-----
+- Fixed issue 1 which prevented "extract method" on calls to Given/When/Then
+  - Refactored Feature and Scenario accordingly assigning more responsibility to Feature
+- No longer enforcing order/presence of Given/When/Then within Scenarios

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/coulda.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{coulda}
-  s.version = "0.1.4"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan David Light"]

data/lib/coulda/feature.rb

@@ -30,15 +30,8 @@ module Coulda
 
       def Scenario(name, &test_implementation)
         raise SyntaxError.new("A scenario requires a name") unless name
-        method_name = "test_#{name.sub(/\s/, "_").downcase}"
-        @scenarios ||= []
-        @scenarios << scenario = Scenario.new(name, &test_implementation)
-        if scenario.pending?
-          define_method(method_name) { pending }
-        else
-          define_method(method_name, &test_implementation)
-        end
-        scenario
+        create_test_method_for(name, &test_implementation)
+        create_scenario_for(name, &test_implementation)
       end
 
       def scenarios
@@ -48,6 +41,29 @@ module Coulda
       def pending?
         @scenarios.all? { |s| !s.pending? }
       end
+
+      private
+
+      def create_test_method_for(name, &test_implementation)
+        method_name = "test_#{name.sub(/\s+/, "_").downcase}"
+        @scenarios ||= []
+        if block_given?
+          define_method(method_name, &test_implementation)
+        else
+          define_method(method_name) { pending }
+        end
+      end
+
+      def create_scenario_for(name, &test_implementation)
+        @scenarios ||= []
+        if block_given?
+          scenario = Scenario.new(name, &test_implementation)
+        else
+          scenario = Scenario.new(name)
+        end
+        @scenarios << scenario
+        scenario
+      end
     end
 
     # Scenario-less features should be pending
@@ -59,7 +75,7 @@ module Coulda
   %w[Given When Then].each do |statement|
     eval <<-HERE
       def #{statement}(name, &block)
-        block.call
+        block.call if block_given?
       end
     HERE
   end

data/lib/coulda/scenario.rb

@@ -8,8 +8,7 @@ module Coulda
       @name = name.to_s
       @block = block
       @statements = []
-      check_statements
-      @pending = @statements.empty? || @statements.any? { |s| s.block.nil? }
+      @pending = !block_given?
     end
 
     %w[Given When Then].each do |statement|
@@ -23,38 +22,5 @@ module Coulda
     def pending?
       @pending
     end
-
-    private
-
-    def check_statements
-      if @block
-        instance_eval &@block
-        assert_statements
-      end
-    end
-
-    def assert_statements
-      if !pending? && @statements
-        assert_presence_of_statements
-        assert_order_of_statements
-      end
-    end
-
-    def assert_presence_of_statements
-      givens_present = @statements.any? { |s| s.type == :Given }
-      raise SyntaxError.new("No Givens are present") unless givens_present
-      whens_present = @statements.any? { |s| s.type == :When }
-      raise SyntaxError.new("No Whens are present") unless whens_present
-      thens_present = @statements.any? { |s| s.type == :Then }
-      raise SyntaxError.new("No Thens are present") unless thens_present
-    end
-
-    def assert_order_of_statements
-      stmt_types = @statements.collect { |s| s.type }
-      unless stmt_types.rindex(:Given) < stmt_types.index(:When) && 
-             stmt_types.rindex(:When) < stmt_types.index(:Then)
-        raise SyntaxError.new("Given, Whens, Thens are out of order")
-      end
-    end
   end
 end

data/test/feature_test.rb

@@ -1,18 +1,6 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class FeatureTest < Test::Unit::TestCase
-  def run_feature(feature)
-    if Object::RUBY_VERSION =~ /^1.9/
-      result = MiniTest::Unit.autorun
-    else 
-      # Assume 1.8.x
-      result = Test::Unit::TestResult.new
-      p = Proc.new {}
-      feature.suite.run(result, &p)
-    end
-    result
-  end
-
   context "A Feature class" do
     should "have Test::Unit::TestCase as an ancestor" do
       assert(Feature.ancestors.include?(Test::Unit::TestCase))
@@ -85,7 +73,7 @@ class FeatureTest < Test::Unit::TestCase
 
       should "not have any errors when run" do
         result = run_feature @feature_without_scenarios
-        Object::RUBY_VERSION =~ /^1.9/ ?  assert(result.inspect) : assert(result)
+        Object::RUBY_VERSION =~ /^1.9/ ? assert(result) : assert(result.passed?)
       end
     end
 

data/test/scenario_test.rb

@@ -22,117 +22,6 @@ class ScenarioTest < Test::Unit::TestCase
           assert(@scenario.pending?)
         end
       end
-
-      context "with a block" do
-        context "when validating the semantics of the code in the block" do
-          should "raise a DSL syntax error if no givens are present" do
-            assert_raises Coulda::SyntaxError do
-              Scenario.new "foo" do
-                When "bar"
-                Then "blech"
-              end
-            end
-          end
-
-          should "raise a DSL syntax error if no whens are present" do
-            assert_raises Coulda::SyntaxError do
-              Scenario.new "foo" do
-                Given "bar"
-                Then "blech"
-              end
-            end
-          end
-
-          should "raise a DSL syntax error if no thens are present" do
-            assert_raises Coulda::SyntaxError do
-              Scenario.new "foo" do
-                Given "bar"
-                When "blech"
-              end
-            end
-          end
-
-          context "and all givens occur before all whens" do
-            context "and all whens occur before all thens" do
-              should "not raise an error" do
-                assert_nothing_raised do
-                  Scenario.new "foo" do
-                    Given "bar"
-                    When "blech"
-                    Then "baz"
-                  end
-                end
-              end
-            end
-
-            context "and all whens do not occur before all thens" do
-              should "raise a DSL syntax error" do
-                assert_raises Coulda::SyntaxError do
-                  Scenario.new "foo" do
-                    Given "bar"
-                    When "blech"
-                    Then "baz"
-                    When "foobarblech"
-                  end
-                end
-              end
-            end
-          end
-
-          context "where not all givens occur before all whens" do
-            context "and all whens occur before all thens" do
-              should "raise a DSL syntax error" do
-                assert_raises Coulda::SyntaxError do
-                  Scenario.new "foo" do
-                    Given "bar"
-                    When "blech"
-                    Given "foobarblech"
-                    Then "baz"
-                  end
-                end
-              end
-            end
-
-            context "and all whens do not occur before all thens" do
-              should "raise a DSL syntax error" do
-                assert_raises Coulda::SyntaxError do
-                  Scenario.new "foo" do
-                    Given "bar"
-                    When "blech"
-                    Given "barblech"
-                    Then "baz"
-                    When "foobarblech"
-                  end
-                end
-              end
-            end
-          end
-
-          context "where givens, whens, are present and in the correct order" do
-            context "but a Given does not have a block" do
-              should "declare the scenario pending" do
-                scenario = Scenario.new "foo" do
-                  Given "bar" 
-                  When "blech" do; end
-                  Then "baz" do; end
-                end
-                assert(scenario.pending?)
-              end
-            end
-
-            context "and the givens, whens, and thens have blocks" do
-              should "not be pending" do
-                scenario = Scenario.new "foo" do
-                  Given "bar" do; end
-                  When "blech" do; end
-                  Then "baz" do; end
-                end
-                assert(!scenario.pending?)
-              end
-            end
-          end
-        end
-      end
     end
   end
 end

data/test/test_helper.rb

@@ -6,3 +6,23 @@ $LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
 require 'coulda'
 
 include Coulda
+
+def run_feature(feature)
+  if Object::RUBY_VERSION =~ /^1.9/
+    result = MiniTest::Unit.autorun
+  else 
+    # Assume 1.8.x
+    result = Test::Unit::TestResult.new
+    p = Proc.new {}
+    feature.suite.run(result, &p)
+  end
+  result
+end
+
+def pendings_are_errors
+  Feature.class_eval do
+    def pending
+      raise Exception.new
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: elight-coulda
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Evan David Light
@@ -48,6 +48,7 @@ files:
 - test/test_helper.rb
 has_rdoc: false
 homepage: http://evan.tiggerpalace.com/
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse