elight-coulda 0.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+coulda*.gem
+coverage/*

data/HISTORY

@@ -0,0 +1,7 @@
+0.1.0
+-----
+Initial release with basic features to generate tests from internal DSL
+
+0.1.1
+-----
+Corrections for github gem build process

data/LICENSE

@@ -0,0 +1,24 @@
+coulda
+
+MIT License
+
+Copyright (c) 2009, Evan David Light
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,48 @@
+coulda
+------
+coulda gives you Cucumber-like BDD power but with an internal DSL.  This means no "call-by-regexp" and
+no Gherkin/plain-text/external DSL.  coulda is just code -- but with a Cucumber-like take on BDD.
+
+coulda, obviously was inspired by Cucumber, Shoulda, but also Thor.  coulda believes that the best way to reuse
+code is the good ol' fashioned method.  Instead of sharing files of regexps mapped to procs, you just write
+methods.  That simple.
+
+You can define the implementation of your Given/When/Then right there with the behavior description.  Or,
+if you want to reuse some Givens/Whens/Thens, just write a method!  And if you find your Feature is getting
+too bloated or that you would like to reuse Givens/Whens/Thens between features, put them in a helper.
+
+Easy as pie.
+
+  require 'rubygems'
+  require 'coulda'
+  include Coulda
+
+  Feature "feature name" do
+    in_order_to "foo"
+    as_a "bar"
+    i_want_to "blech"
+
+    def something
+    end
+
+    def expectation
+    end
+
+    Scenario "pending scenario"
+
+    Scenario "another scenario" do
+      Given "a pending prereq"
+      When "something happens" do
+        something
+      end
+      Then "expect something else" do
+        expectation
+      end
+    end
+
+    Scenario "that is live" do
+      Given "foo" do; end
+      When "bar" do; end
+      Then "blech" do; end
+    end
+  end

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+require 'shoulda'
+
+# Test::Unit::UI::VERBOSE
+test_files_pattern = 'test/**/*_test.rb'
+src_files_pattern = 'src/**/*.rb'
+
+Rake::TestTask.new do |t|
+  src_files = Dir[src_files_pattern]
+  src_files.each { |f| puts f; require f[0...-3] }
+  t.pattern = test_files_pattern
+  t.verbose = false
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "coulda"
+    s.version = "0.1.1"
+    s.authors = ["Evan David Light"]
+    s.email = "evan@tiggerpalace.com"
+    s.summary = "Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse"
+    s.homepage = "http://evan.tiggerpalace.com/"
+    s.description = "Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+
+desc 'Default: run tests.'
+task :default => 'test'

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/coulda.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{coulda}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Evan David Light"]
+  s.date = %q{2009-09-12}
+  s.description = %q{Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse}
+  s.email = %q{evan@tiggerpalace.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "HISTORY",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "coulda.gemspec",
+     "example/sample.rb",
+     "lib/coulda.rb",
+     "lib/coulda/feature.rb",
+     "lib/coulda/scenario.rb",
+     "test/feature_test.rb",
+     "test/scenario_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://evan.tiggerpalace.com/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse}
+  s.test_files = [
+    "test/feature_test.rb",
+     "test/scenario_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.add_dependency 'jeremymcanally-pending', '>= 0.1'
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/example/sample.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'coulda'
+include Coulda
+
+Feature "feature name" do
+  in_order_to "foo"
+  as_a "bar"
+  i_want_to "blech"
+
+  def something
+  end
+
+  def expectation
+  end
+
+  Scenario "pending scenario"
+
+  Scenario "another scenario" do
+    Given "a pending prereq"
+    When "something happens" do
+      something
+    end
+    Then "expect something else" do
+      expectation
+    end
+  end
+
+  Scenario "that is live" do
+    Given "foo" do; end
+    When "bar" do; end
+    Then "blech" do; end
+  end
+end

data/lib/coulda/feature.rb

@@ -0,0 +1,68 @@
+require 'test/unit'
+
+module Coulda
+  class Feature < Test::Unit::TestCase
+    class << self
+      def in_order_to(what)
+        @in_order_to = what
+      end
+
+      def as_a(who)
+        @as_a = who
+      end
+
+      def i_want_to(what)
+        @i_want_to = what
+      end
+
+      def for_name(name)
+        klass = Class.new(Feature)
+        class_name = "Feature" + name.split(/\s/).map { |w| w.capitalize }.join
+        Object.const_set(class_name, klass)
+        klass
+      end
+
+      def assert_description
+        if @in_order_to || @as_a || @i_want_to
+          raise SyntaxError.new("Must call in_order_to if as_a and/or i_wanted_to called") unless @in_order_to
+          raise SyntaxError.new("Must call as_a if in_order_to and/or i_want_to called") unless @as_a
+          raise SyntaxError.new("Must call i_want_to if in_order_to and/or as_a called") unless @i_want_to
+        end
+      end
+
+      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
+      end
+
+      def scenarios
+        @scenarios ||= []
+      end
+
+      def pending?
+        @scenarios.all? { |s| !s.pending? }
+      end
+    end
+
+    # Allow scenario-less features not to fail
+    def default_test; end
+  end
+
+  %w[Given When Then].each do |statement|
+    eval <<-HERE
+      def #{statement}(name, &block)
+        block.call
+      end
+    HERE
+  end
+end
+
+

data/lib/coulda/scenario.rb

@@ -0,0 +1,70 @@
+module Coulda
+  class Scenario
+    attr_reader :name
+
+    Statement = Struct.new(:type, :name, :block)
+
+    def initialize(name, &block)
+      @name = name.to_s
+      @block = block
+      @statements = []
+      check_statements
+      @pending = @statements.empty? || @statements.any? { |s| s.block.nil? }
+      @last_stmt_type = nil
+    end
+
+    %w[Given When Then].each do |statement|
+      eval <<-HERE
+        def #{statement}(name, &block)
+          if @validating_semantics
+            @statements << stmt = Statement.new(:#{statement}, name, block)
+          elsif pending? 
+            # TODO
+          elseif
+            block.call
+          end
+        end
+      HERE
+    end
+
+    def pending?
+      @pending
+    end
+
+    private
+
+    def check_statements
+      @validating_semantics = true
+      if @block
+        instance_eval &@block
+        assert_statements
+      end
+      @validating_semantics = false
+      
+    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/lib/coulda.rb

@@ -0,0 +1,18 @@
+module Coulda
+  SyntaxError = Class.new(StandardError)
+end
+
+gem 'jeremymcanally-pending', '>= 0.1'
+require 'pending'
+
+require 'coulda/feature'
+require 'coulda/scenario'
+
+module Kernel
+  def Feature(name, &block)
+    f = Feature.for_name(name)
+    f.class_eval(&block)
+    f.assert_description
+    f
+  end
+end

data/test/feature_test.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class FeatureTest < Test::Unit::TestCase
+  def run_feature(feature)
+    result = Test::Unit::TestResult.new
+    p = Proc.new {}
+    feature.suite.run(result, &p)
+    result
+  end
+
+  context "A Feature class" do
+    should "have Test::Unit::TestCase as an ancestor" do
+      assert(Feature.ancestors.include?(Test::Unit::TestCase))
+    end
+
+    context "created by name" do
+      setup do 
+        @feature = Feature.for_name "foo"
+      end
+
+      should "be a subclass of Feature" do
+        assert(@feature.ancestors.include?(Feature))
+      end
+    end
+
+
+    context "that calls in_order_to, as_a, and i_want_to" do
+      should "not raise syntax error" do
+        assert_nothing_raised do 
+          Feature "one" do
+            in_order_to "foo"
+            as_a "bar"
+            i_want_to "blech"
+          end
+        end
+      end
+    end
+
+    context "that calls as_a and i_want_to" do
+      should "raise syntax error because in_order_to was not called once" do
+        assert_raise Coulda::SyntaxError do 
+          Feature "two" do
+            as_a "bar"
+            i_want_to "blech"
+          end
+        end
+      end
+    end
+
+    context "that calls in_order_to and i_want_to" do
+      should "raise syntax error because as_a was not called once" do
+        assert_raise Coulda::SyntaxError do
+          Feature "three" do
+            in_order_to "foo"
+            i_want_to "blech"
+          end
+        end
+      end
+    end
+
+    context "that calls in_order_to and as_a" do
+      should "raise syntax error because i_want_to was not called once" do
+        assert_raise Coulda::SyntaxError do
+          Feature "four" do
+            in_order_to "foo"
+            as_a "bar"
+          end
+        end
+      end
+    end
+
+    context "without scenarios" do
+      setup do
+        @feature_without_scenarios = Feature "five" do
+          in_order_to "foo"
+          as_a "bar"
+          i_want_to "blech"
+        end
+      end
+
+      should "not have any errors when run" do
+        result = run_feature @feature_without_scenarios
+        assert(result.passed?, result.inspect)
+      end
+    end
+
+    context "that does not have any errors" do
+      @@counter = 1
+      setup do
+        @feature_without_errors = Feature @@counter.to_s do
+          in_order_to "foo"
+          as_a "bar"
+          i_want_to "blech"
+        end
+        @@counter += 1
+      end
+
+      ### Integration tests
+
+      context "with a block containing a scenario" do
+        should "create a Feature instance method named 'test_<underscored_scenario_name>'" do
+          @feature_without_errors.Scenario "pending scenario"
+          assert(@feature_without_errors.instance_methods.include?("test_pending_scenario"), "Feature is missing test method from scenario")
+        end
+
+        should "create a Scenario" do
+          @feature_without_errors.Scenario "pending scenario"
+        end
+
+        should "include the created Scenario in the return value of the 'scenarios' method" do
+          scenario = @feature_without_errors.Scenario "pending scenario"
+          assert(@feature_without_errors.scenarios.include?(scenario), "feature.scenarios doesn't contain the expected Scenario object")
+        end
+      end
+    end
+  end
+end

data/test/scenario_test.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class ScenarioTest < Test::Unit::TestCase
+  context "A Scenario" do
+    setup do
+      @scenario = Scenario.new("foobar")
+    end
+
+    %w[Given When Then].each do |condition|
+      should "have a method called '#{condition}'" do
+        assert(@scenario.respond_to?(condition.to_sym))
+      end
+    end
+
+    context "when instantiated" do 
+      context "with only a String" do
+        setup do 
+          @scenario = Scenario.new("foobar")
+        end
+
+        should "be pending" do
+          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

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+require 'coulda'
+
+include Coulda

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: elight-coulda
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Evan David Light
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jeremymcanally-pending
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: 
+description: Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse
+email: evan@tiggerpalace.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- HISTORY
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- coulda.gemspec
+- example/sample.rb
+- lib/coulda.rb
+- lib/coulda/feature.rb
+- lib/coulda/scenario.rb
+- test/feature_test.rb
+- test/scenario_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://evan.tiggerpalace.com/
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+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
+test_files: 
+- test/feature_test.rb
+- test/scenario_test.rb
+- test/test_helper.rb