picard 0.0.2 → 0.0.3

data/README.rdoc

@@ -0,0 +1,15 @@
+== Test Framework "Picard"
+
+Picard is a test framework heavily inspired by "Spock" (an excellent test framework for the Groovy programming language). It does some AST manipulation to make the structure of your test explicit:
+
+    def test_method
+      given
+        x = 1
+
+      expect
+        x == 1
+    end
+
+The "given" block is a setup you do for your test. Every line in the "expect" block is an assertion.
+
+

data/lib/picard.rb

@@ -1,4 +1,12 @@
 require "picard/version"
 
-module Picard
-end
+require_relative 'picard/extensions'
+require_relative 'picard/context'
+require_relative 'picard/error_message_formatter'
+require_relative 'picard/ast_helper'
+require_relative 'picard/assertion_wrapper'
+require_relative 'picard/s_expression_sugar'
+require_relative 'picard/class_ripper'
+require_relative 'picard/preprocessor'
+require_relative 'picard/method_ripper'
+require_relative 'picard/test_unit'

data/lib/picard/assertion_wrapper.rb

@@ -0,0 +1,56 @@
+require 'live_ast'
+require 'ruby2ruby'
+require_relative 's_expression_sugar'
+
+module Picard
+  class AssertionWrapper
+    include Picard::SExpressionSugar
+
+    def initialize formatter = ErrorMessageFormatter.new
+      @formatter = formatter
+    end
+
+    def wrap_assertion ast, context
+      line = ast_to_str(ast)
+      message = @formatter.format_message(line, context)
+      
+      if equal_to_assertion? ast
+        s(:call, nil,
+                 :assert_equal,
+                 s(:arglist,
+                    extract_argument(ast),
+                    extract_receiver(ast),
+                    s(:str, message)))
+      else
+        s(:call, nil, :assert, s(:arglist,ast, s(:str, message)))
+      end
+    end
+
+    private
+
+    def equal_to_assertion? ast
+      ast[0] == :call and ast[2] == :==
+    end
+
+    def extract_argument ast
+      ast[3][1]
+    end
+
+    def extract_receiver ast
+      ast[1]
+    end
+
+    def ast_to_str ast
+      copy = Sexp.from_array(ast.to_a)
+      Ruby2Ruby.new.process copy
+    end
+  end
+
+  class SimpleAssertionWrapper
+    include Picard::SExpressionSugar
+
+    def wrap_assertion ast, context
+      s(:call, nil,:assert,s(:arglist,ast))
+    end
+  end
+end

data/lib/picard/ast_helper.rb

@@ -5,51 +5,66 @@ module Picard
   class AstHelper
     ResultItem = Struct.new(:index, :ast)
 
+    def initialize wrapper = Picard::AssertionWrapper.new
+      @wrapper = wrapper
+    end
+
     def all_statements method
       method_ast = method.to_ast
-      body_statements = extract_statements(method_ast)[1..-1]
+      body_statements = extract_body_statements(method_ast)
       wrap_in_result_items body_statements
     end
 
-    def find_all_statements_in_block items, block_name
-      start_index = find_index_of_statements_calling(items, block_name)
-      end_index = find_index_of_statements_calling(items, :where)
-      end_index = -1 unless end_index
-      start_index ? items[start_index + 1 ... end_index] : []
+    def all_statements_in_block method, block_name
+      statements = all_statements(method)
+
+      start_index = find_index_of_statements_calling(statements, block_name)
+      start_index ? statements[start_index + 1 .. -1] : []
     end
 
-    def wrap_assertion ast
-      Sexp.new(:call, nil, :assert, Sexp.new(:arglist, ast))
+    def wrap_assertion method, ast
+      context = Picard::Context.new(method.source_location[0], ast.line)
+      @wrapper.wrap_assertion ast, context
     end
 
-    def replace_statement method, index, new_ast
+    def replace_statement method, index, new_statement_ast
       method_ast = method.to_ast
       body_statements = extract_statements(method_ast)
-      body_statements[index + 1] = new_ast
+      body_statements[index + 1] = new_statement_ast
     end
 
-    def extract_ast method
-      method.to_ast
+    def method_to_string method
+      ast = method.to_ast
+      str = ast_to_str ast
+      remove_spaces str
     end
 
-    def find_all_local_variables_in_block items, block_name
-      index = find_index_of_statements_calling(items, block_name)
-      return [] unless index
-      items[index + 1 .. -1].find_all do |e|
-        e.ast[0] == :lasgn
-      end.collect do |e|
-        e.ast[1]
-      end
+    private
+
+    def ast_to_str ast
+      Ruby2Ruby.new.process ast
     end
 
-    private
-    def find_index_of_statements_calling(items, method_name)
+    def remove_spaces str
+      str.gsub(/\n\s+/, "\n")
+    end
+
+    def find_index_of_statements_calling items, method_name
       items.index do |item|
         ast = item.ast
         ast[0] == :call and ast[2] == method_name
       end
     end
 
+    def extract_body_statements method_ast
+      st = extract_statements(method_ast)
+      remove_prefix_statement st
+    end
+
+    def remove_prefix_statement statements
+      statements[1..-1]
+    end
+
     def extract_statements method_ast
       method_ast[3][1]
     end

data/lib/picard/class_ripper.rb

@@ -9,9 +9,5 @@ module Picard
         test_method? m
       end
     end
-
-    def replace_method clazz, new_method
-      clazz.class_eval new_method
-    end
   end
 end

data/lib/picard/context.rb

@@ -0,0 +1,3 @@
+module Picard
+  Context = Struct.new(:file, :lineno)
+end

data/lib/picard/error_message_formatter.rb

@@ -0,0 +1,28 @@
+module Picard
+  class ErrorMessageFormatter
+     def format_message message, context
+      location = "File: #{context.file}, Line: #{context.lineno}"
+      new_message = "Failed Assertion: #{message}"
+
+      lines = make_same_size(location, new_message)
+      border = '-' * (lines.first.length + 4) #4 = 2 pipes + 2 spaces
+      "#{border}\n| #{lines[0]} |\n| #{lines[1]} |\n#{border}"
+    end
+
+    private
+    def make_same_size a, b
+      return make_same_size(b, a) if a.length < b.length
+      if a.length > b.length
+        [a, b + ' ' * (a.length - b.length)]
+      else
+        [a + ' ' * (b.length - a.length), b]
+      end
+    end
+  end
+
+  class SimpleErrorMessageFormatter
+    def format_message message, context
+      message
+    end
+  end
+end

data/lib/picard/extensions.rb

@@ -0,0 +1,10 @@
+module Picard
+  class ::Object
+    def metaclass; class << self; self; end; end
+    def meta_eval &blk; metaclass.instance_eval &blk; end
+
+    def meta_def name, &blk
+      meta_eval { define_method name, &blk }
+    end
+  end
+end

data/lib/picard/method_ripper.rb

@@ -1,6 +1,4 @@
 require 'live_ast'
-require 'live_ast/to_ruby'
-require 'ruby2ruby'
 
 module Picard
   class MethodRipper
@@ -8,29 +6,24 @@ module Picard
       @ast_helper = ast_helper
     end
 
-    def wrap_all_assertions method
-      all_statements = @ast_helper.all_statements(method)
-      assertions = @ast_helper.find_all_statements_in_block(all_statements, :expect)
-      replace_all_statements_with_assertions assertions, method
-      ast_to_str @ast_helper.extract_ast(method)
+    def wrap_all_assertions! method
+      assertions = @ast_helper.all_statements_in_block(method, :expect)
+      replace_all_statements_with_assertions! assertions, method
+      replace_method_implementation_in_owner! method
     end
 
     private
 
-    def replace_all_statements_with_assertions assertions, method
+    def replace_all_statements_with_assertions! assertions, method
       assertions.each do |e|
-        wrapped = @ast_helper.wrap_assertion(e.ast)
+        wrapped = @ast_helper.wrap_assertion(method, e.ast)
         @ast_helper.replace_statement(method, e.index, wrapped)
       end
     end
 
-    def ast_to_str ast
-      str = Ruby2Ruby.new.process(ast)
-      remove_spaces str
-    end
-
-    def remove_spaces str
-      str.gsub(/\n\s+/, "\n")
+    def replace_method_implementation_in_owner! method
+      new_method_str = @ast_helper.method_to_string(method)
+      method.owner.class_eval new_method_str
     end
   end
 end

data/lib/picard/preprocessor.rb

@@ -22,15 +22,14 @@ module Picard
       return unless @class_ripper.test_method?(method_name)
       
       mark_as_preprocessed method_name
-      replace_method_with_preprocessed clazz, method_name
+      replace_method_with_preprocessed! clazz, method_name
     end
 
     private
 
-    def replace_method_with_preprocessed clazz, method_name
+    def replace_method_with_preprocessed! clazz, method_name
       method = clazz.instance_method(method_name)
-      new_method_str = @method_ripper.wrap_all_assertions(method)
-      @class_ripper.replace_method clazz, new_method_str
+      @method_ripper.wrap_all_assertions!(method)
     end
 
     def preprocessed? method_name

data/lib/picard/s_expression_sugar.rb

@@ -0,0 +1,7 @@
+module Picard
+  module SExpressionSugar
+    def s *args
+      Sexp.new *args
+    end
+  end
+end

data/lib/picard/test_unit.rb

@@ -1,5 +1,7 @@
 module Picard
-  module DummyMethods
+  PREPROCESSOR = Picard::Preprocessor.new
+  
+  module InstanceMethods
     def given
     end
 
@@ -9,14 +11,18 @@ module Picard
 
   module ClassMethods
     def method_added name
-      @tr ||= Picard::Preprocessor.new
-      @tr.preprocess_method self, name
+      preprocess_add_method name
+    end
+
+    private
+    def preprocess_add_method name
+      Picard::PREPROCESSOR.preprocess_method self, name
     end
   end
 
   module TestUnit
     def self.included clazz
-      clazz.send :include, DummyMethods
+      clazz.send :include, InstanceMethods
       clazz.send :extend, ClassMethods
     end
   end

data/lib/picard/version.rb

@@ -1,3 +1,3 @@
 module Picard
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/picard.gemspec

@@ -20,6 +20,5 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'live_ast', '= 1.0.2'
   s.add_dependency 'live_ast_ripper', '= 0.6.5'
-  s.add_development_dependency 'rr'
-  s.add_development_dependency 'picard', '= 0.0.1'
+  s.add_development_dependency 'flexmock'
 end

data/test/picard/assertion_wrapper_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class Picard::AssertionWrapperTest < Test::Unit::TestCase
+  include Picard::TestUnit
+  include Picard::SExpressionSugar
+
+  def setup
+    @formatter = flexmock('formatter')
+    @wrapper = Picard::AssertionWrapper.new @formatter
+  end
+
+  def test_should_wrap_simple_assertions
+    given
+      ast = s(:lit, true)
+      context = flexmock(:file => 'file', :lineno => 1)
+      @formatter.should_receive(:format_message).with('true', context).and_return('generated error message')
+
+    expect
+      @wrapper.wrap_assertion(ast, context) == s(:call, nil,
+                  :assert,
+                  s(:arglist,
+                    s(:lit, true),
+                    s(:str, 'generated error message')))
+  end
+
+  def test_should_wrap_equal_to_assertions
+    given
+      ast = s(:call, s(:lit, 1), :==, s(:arglist, s(:lit, 2)))
+      context = flexmock(:file => 'file', :lineno => 1)
+      @formatter.should_receive(:format_message).with('(1 == 2)', context).and_return('generated error message')
+
+    expect
+      @wrapper.wrap_assertion(ast, context) == s(:call, nil,
+                  :assert_equal,
+                  s(:arglist,
+                    s(:lit, 2),
+                    s(:lit, 1),
+                    s(:str, 'generated error message')))
+  end
+end

data/test/picard/ast_helper_test.rb

@@ -1,99 +1,117 @@
-require_relative '../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class Picard::AstHelperTest < Test::Unit::TestCase
-  class TestClass
-    def test_method
-      x = 10
+  include Picard::TestUnit
+  include Picard::SExpressionSugar
 
-      expect
-      x == 10
-      x == 12
+  def setup
+    @wrapper = flexmock('wrapper')
+    @helper = Picard::AstHelper.new @wrapper
+  end
 
-      where
-      y = 1
-    end
 
-    def method_without_assertions
-      'dummy'
+  class TestClass1
+    def test_method
+      one
+      two
     end
+  end
 
-    def test_method_to_replace_statements
-      'dummy'
-    end
+  def test_should_return_all_statements_of_method
+    given
+      method = TestClass1.instance_method(:test_method)
+      actual = @helper.all_statements(method)
+
+    expect
+      actual[0].index == 0
+      actual[0].ast == s(:call, nil, :one, s(:arglist))
+
+      actual[1].index == 1
+      actual[1].ast == s(:call, nil, :two, s(:arglist))
+  end
 
-    def test_method_with_where_block
-      x = 10
 
-      where
-      y = 20
-      z = 30
+  class TestClass2
+    def test_method
+      one
+      expect
+      two
     end
   end
 
-  def setup
-    @helper = Picard::AstHelper.new
+  def test_should_find_all_statements_in_specified_block
+    given
+      method = TestClass2.instance_method(:test_method)
+      actual = @helper.all_statements_in_block(method, :expect)
+
+    expect
+      actual.size == 1
+      actual[0].index == 2
+      actual[0].ast == s(:call, nil, :two, s(:arglist))
   end
 
-  def test_should_return_all_statements_of_method
-    method = TestClass.instance_method(:test_method)
-    actual = @helper.all_statements(method)
-    
-    assert_equal 0, actual[0].index
-    assert_equal s(:lasgn, :x, s(:lit, 10)), actual[0].ast
 
-    assert_equal 1, actual[1].index
-    assert_equal s(:call, nil, :expect, s(:arglist)), actual[1].ast
+  class TestClass3
+    def test_method
+      one
+      two
+    end
+  end
 
-    assert_equal 2, actual[2].index
-    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 10))), actual[2].ast
+  def test_should_return_empty_array_if_block_is_not_found
+    given
+      method = TestClass3.instance_method(:test_method)
 
-    assert_equal 3, actual[3].index
-    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 12))), actual[3].ast
+    expect
+      @helper.all_statements_in_block(method, :where) == []
   end
 
-  def test_should_find_all_statements_in_specified_block
-    method = TestClass.instance_method(:test_method)
-    all_statements = @helper.all_statements(method)
-    actual = @helper.find_all_statements_in_block(all_statements, :expect)
 
-    assert_equal 2, actual.size
+  class TestClass4
+    def test_method
+      false
+    end
+  end
 
-    assert_equal 2, actual[0].index
-    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 10))), actual[0].ast
+  def test_should_replace_statement
+    given
+      method = TestClass4.instance_method(:test_method)
+      @helper.replace_statement(method, 0, s(:lit, true))
+      all_statements = @helper.all_statements(method)
 
-    assert_equal 3, actual[1].index
-    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 12))), actual[1].ast
+    expect
+      all_statements[0].ast == s(:lit, true)
   end
 
-  def test_should_return_empty_array_if_specified_method_call_was_not_found
-    method = TestClass.instance_method(:method_without_assertions)
-    all_statements = @helper.all_statements(method)
-    actual = @helper.find_all_statements_in_block(all_statements, :expect)
-    assert_equal [], actual
+
+  class TestClass5
+    def method
+    end
   end
 
   def test_should_wrap_assertion
-    result = @helper.wrap_assertion(s(:lit, true))
-    assert_equal s(:call, nil, :assert, s(:arglist, s(:lit, true))), result
-  end
+    given
+      method = TestClass5.instance_method(:method)
+      ast = s(:lit, true)
+      @wrapper.should_receive(:wrap_assertion).and_return('wrapped ast')
 
-  def test_should_replace_statement
-    method = TestClass.instance_method(:test_method_to_replace_statements)
-    @helper.replace_statement(method, 0, s(:lit, true))
-    
-    all_statements = @helper.all_statements(method)
-    assert_equal s(:lit, true), all_statements[0].ast
+    expect
+      @helper.wrap_assertion(method, ast) == 'wrapped ast'
   end
 
-  def test_should_return_list_of_all_local_variables_defined_after_specified_method_call
-    method = TestClass.instance_method(:test_method_with_where_block)
-    all_statements = @helper.all_statements(method)
-    actual = @helper.find_all_local_variables_in_block(all_statements, :where)
-    assert_equal [:y, :z], actual
+
+  class TestClass5
+    def method
+      false
+    end
   end
 
-  private
-  def s(*args)
-    Sexp.new *args
+  def test_should_return_string_representation_of_a_method_reflecting_updated_ast
+    given
+      method = TestClass5.instance_method(:method)
+      @helper.replace_statement(method, 0, s(:lit, true))
+
+    expect
+      @helper.method_to_string(method) == "def method\ntrue\nend"
   end
 end

data/test/picard/class_ripper_test.rb

@@ -1,44 +1,39 @@
-require_relative '../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class Picard::ClassRipperTest < Test::Unit::TestCase
-  class TestClass
-    def test_one; end
-    def test_two; end
-    def three; end
-  end
-
-  class TestClassWithoutTestMethods
-    def method1; end
-  end
-
-  class DummyClass
-    def dummy
-      'dummy'
-    end
-  end
+  include Picard::TestUnit
 
   def setup
     @ripper = Picard::ClassRipper.new
   end
+  
 
-  def test_should_return_if_method_is_test_method
-    assert @ripper.test_method?('test_method')
-    assert !@ripper.test_method?('regular_method')
+  def test_should_tell_if_method_name_is_test_method_name
+    expect
+      @ripper.test_method?('test_method')
+      !@ripper.test_method?('regular_method')
+  end
+
+  
+  class TestClass1
+    def test_one; end
+    def test_two; end
+    def three; end
   end
 
   def test_should_return_list_of_all_test_methods
-    test_methods = @ripper.all_test_method_names(TestClass)
-    assert_equal [:test_one, :test_two], test_methods
+    expect
+      @ripper.all_test_method_names(TestClass1) == [:test_one, :test_two]
   end
 
-  def test_should_return_empty_list_if_there_are_no_test_methods
-    test_methods = @ripper.all_test_method_names(TestClassWithoutTestMethods)
-    assert_equal [], test_methods
+
+  class TestClass2
+    def method1; end
   end
 
-  def test_should_replace_method_implementation
-    @ripper.replace_method(DummyClass, "def dummy\n 'replaced' \n end")
-    assert_equal 'replaced', DummyClass.new.dummy
+  def test_should_return_empty_list_if_there_are_no_test_methods
+    expect
+      @ripper.all_test_method_names(TestClass2) == []
   end
 end
 

data/test/picard/demo_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../../test_helper", __FILE__)
+require 'live_ast'
+
+module Picard
+  class DemoTest < Test::Unit::TestCase
+    include Picard::TestUnit
+    #
+    #def test_one
+    #  expect
+    #    1 == 2
+    #end
+    #def regular_method
+    #  method 1, 2
+    #end
+    #
+    #def test_two
+    #  ast = DemoTest.instance_method(:regular_method).to_ast
+    #  puts ast.class.name
+    #end
+  end
+end

data/test/picard/error_message_formatter_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class Picard::ErrorMessageFormatterTest < Test::Unit::TestCase
+  include Picard::TestUnit
+
+  def test_should_wrap_error_message
+    given
+      formatter = Picard::ErrorMessageFormatter.new
+      expected = <<str
+-----------------------------
+| Failed Assertion: message |
+| File: file, Line: 1       |
+-----------------------------
+str
+
+    expect
+      formatter.format_message('message', create_context('file', 1)) == expected.chomp
+  end
+
+  private
+  def create_context(filename, lineno)
+    Struct.new(:file, :lineno).new(filename, lineno)
+  end
+end

data/test/picard/method_ripper_test.rb

@@ -1,34 +1,51 @@
-require_relative '../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class Picard::MethodRipperTest < Test::Unit::TestCase
+  include Picard::TestUnit
+  
   class TestClass
+    attr_reader :assert_args
+    
     def test_method
-      given
-      something
       expect
-      1 == 1
-      2 == 2
+      false
     end
 
     def regular_method
-      1 == 1
-      2 == 2
+      false
+    end
+
+    def expect; end
+
+    def assert arg
+      @assert_args ||= []
+      @assert_args << arg
     end
   end
 
   def setup
-    @ripper = Picard::MethodRipper.new
+    wrapper = Picard::SimpleAssertionWrapper.new
+    helper = Picard::AstHelper.new(wrapper)
+    @ripper = Picard::MethodRipper.new(helper)
   end
 
   def test_should_wrap_all_assertions_after_expect_method_call
-    method = TestClass.instance_method(:test_method)
-    new_method_str = @ripper.wrap_all_assertions(method)
-    assert_equal "def test_method\ngiven\nsomething\nexpect\nassert((1 == 1))\nassert((2 == 2))\nend", new_method_str
+    given
+      method = TestClass.instance_method(:test_method)
+      @ripper.wrap_all_assertions!(method)
+      tc = TestClass.new
+      tc.test_method
+
+    expect
+      tc.assert_args == [false]
   end
 
-  def test_should_return_existing_implementation_if_there_was_no_expect_method_call
-    method = TestClass.instance_method(:regular_method)
-    new_method_str = @ripper.wrap_all_assertions(method)
-    assert_equal "def regular_method\n(1 == 1)\n(2 == 2)\nend", new_method_str
+  def test_should_not_change_method_if_no_expect_block
+    given
+      method = TestClass.instance_method(:regular_method)
+      @ripper.wrap_all_assertions! method
+
+    expect
+      TestClass.new.regular_method == false
   end
 end

data/test/picard/preprocessor_test.rb

@@ -1,114 +1,129 @@
-require_relative '../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class Picard::PreprocessorTest < Test::Unit::TestCase
-  include RR::Adapters::RRMethods
+  include Picard::TestUnit
 
   class BaseTestClass
     attr_reader :assert_args
 
-    def initialize
-      @assert_args = []
-    end
-
-    def given
-    end
+    def given; end
+    def expect; end
+    def where; end
+    def picard_format_error_message(m,l); end
 
-    def expect
-    end
-
-    def where
-    end
 
-    def assert arg
+    def assert arg, message
+      @assert_args ||= []
       @assert_args << arg
     end
   end
 
-  # We need to use a class per test for test isolation
-  class TestClass < BaseTestClass
+  def setup
+    @pr = Picard::Preprocessor.new
+  end
+
+  class TestClass1 < BaseTestClass
     def test_method
       expect
-      1 == 2
+      false
     end
   end
 
-  def test_should_wrap_all_assertions_after_expect_in_all_test_methods
-    tr = Picard::Preprocessor.new
-    tr.preprocess_class(TestClass)
+  def test_should_wrap_assertions_after_expect_in_all_test_methods
+    given
+      @pr.preprocess_class(TestClass1)
+      tc = TestClass1.new
+      tc.test_method
 
-    tc = TestClass.new
-    tc.test_method
-    assert_equal [false], tc.assert_args
+    expect
+      tc.assert_args == [false]
   end
 
 
   class TestClass2 < BaseTestClass
     def test_method
       expect
-      1 == 2
+      false
     end
   end
 
   def test_should_wrap_all_assertions_in_specified_method
-    tr = Picard::Preprocessor.new
-    tr.preprocess_method(TestClass2, :test_method)
+    given
+      @pr.preprocess_method(TestClass2, :test_method)
+      tc = TestClass2.new
+      tc.test_method
 
-    tc = TestClass2.new
-    tc.test_method
-    assert_equal [false], tc.assert_args
+    expect
+      tc.assert_args == [false]
   end
 
   
   class TestClass3 < BaseTestClass
     def test_method
       expect
-      1 == 2
+      false
     end
   end
 
-  def test_should_not_preprocess_the_same_method_twice
-    tr = Picard::Preprocessor.new
-    tr.preprocess_method(TestClass3, :test_method)
-    tr.preprocess_method(TestClass3, :test_method)
+  def test_should_be_idempotent
+    given
+      @pr.preprocess_method(TestClass3, :test_method)
+      @pr.preprocess_method(TestClass3, :test_method)
+
+      tc = TestClass3.new
+      tc.test_method
 
-    tc = TestClass3.new
-    tc.test_method
-    assert_equal [false], tc.assert_args
+    expect
+      tc.assert_args == [false]
   end
 
 
   class TestClass4 < BaseTestClass
     def regular_method
-      1 == 2
+      false
     end
   end
 
   def test_should_ignore_non_test_methods
-    tr = Picard::Preprocessor.new
-    tr.preprocess_method(TestClass4, :regular_method)
+    given
+      @pr.preprocess_method(TestClass4, :regular_method)
+      tc = TestClass4.new
+      tc.regular_method
+
+    expect
+      tc.assert_args == nil
+  end
 
-    tc = TestClass4.new
-    tc.regular_method
-    assert_equal [], tc.assert_args
+
+  class TestClass5 < BaseTestClass
+    def test_empty
+    end
+  end
+
+  def test_should_successfully_transform_empty_methods
+    given
+      @pr.preprocess_method(TestClass5, :test_empty)
+      tc = TestClass5.new
+      tc.test_empty
+
+    expect
+      tc.assert_args == nil
   end
 
 
-  #class TestClass5 < BaseTestClass
-  #  def test_method
-  #    expect
-  #    x == 1
-  #
-  #    where
-  #    x = 2
-  #  end
-  #end
-  #
-  #def test_should_use_local_variables_from_where_block
-  #  tr = Picard::Preprocessor.new ClassRipper.new,
-  #  tr.preprocess_method(TestClass5, :test_method)
-  #
-  #  tc = TestClass5.new
-  #  tc.test_method
-  #  assert_equal [false], tc.assert_args
-  #end
+  class TestClass6 < BaseTestClass
+    def test_empty
+      expect
+    end
+  end
+
+  def test_should_successfully_transform_methods_with_empty_expect_block
+    given
+      @pr.preprocess_method(TestClass6, :test_empty)
+      tc = TestClass6.new
+      tc.test_empty
+
+    expect
+      tc.assert_args == nil
+  end
 end

data/test/picard/test_unit_test.rb

@@ -1,27 +1,40 @@
-require_relative '../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class Picard::TestUnitTest < Test::Unit::TestCase
+  include Picard::TestUnit
+
   class TestUsingPicard
     include Picard::TestUnit
-    attr_reader :assert_args
+    attr_reader :assert_arg, :assert_message
 
     def test_method
-      given
-      x = 1
-
       expect
-      x == 2
+      false
     end
 
-    def assert arg
-      @assert_args ||= []
-      @assert_args << arg
+    def assert arg, message
+      @assert_arg = arg
+      @assert_message = message
     end
   end
 
   def test_should_add_assertions_to_all_test_methods
-    test = TestUsingPicard.new
-    test.test_method
-    assert_equal [false], test.assert_args
+    given
+      test = TestUsingPicard.new
+      test.test_method
+
+    expect
+      test.assert_arg == false
+  end
+
+  def test_should_use_specific_messages
+    given
+      test = TestUsingPicard.new
+      test.test_method
+
+    expect
+      test.assert_message.split("\n")[2] =~ /Failed Assertion: false/
+      test.assert_message.split("\n")[1]  =~ /test_unit_test.rb/
+      test.assert_message.split("\n")[1]  =~ /Line: 13/ #TODO fixit, it must be Line: 12
   end
 end

data/test/test_helper.rb

@@ -1,9 +1,13 @@
 require 'test/unit'
-require 'rr'
+require 'flexmock/test_unit'
 
+require_relative '../lib/picard/extensions'
+require_relative '../lib/picard/context'
+require_relative '../lib/picard/error_message_formatter'
 require_relative '../lib/picard/ast_helper'
+require_relative '../lib/picard/assertion_wrapper'
+require_relative '../lib/picard/s_expression_sugar'
 require_relative '../lib/picard/class_ripper'
 require_relative '../lib/picard/preprocessor'
 require_relative '../lib/picard/method_ripper'
-require_relative '../lib/picard/expect_block'
 require_relative '../lib/picard/test_unit'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: picard
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-05 00:00:00.000000000 -04:00
+date: 2011-10-02 00:00:00.000000000 -04:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: live_ast
-  requirement: &2168700440 !ruby/object:Gem::Requirement
+  requirement: &2169351160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.2
   type: :runtime
   prerelease: false
-  version_requirements: *2168700440
+  version_requirements: *2169351160
 - !ruby/object:Gem::Dependency
   name: live_ast_ripper
-  requirement: &2168699820 !ruby/object:Gem::Requirement
+  requirement: &2169350560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -33,10 +33,10 @@ dependencies:
         version: 0.6.5
   type: :runtime
   prerelease: false
-  version_requirements: *2168699820
+  version_requirements: *2169350560
 - !ruby/object:Gem::Dependency
-  name: rr
-  requirement: &2168699280 !ruby/object:Gem::Requirement
+  name: flexmock
+  requirement: &2169350180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,18 +44,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2168699280
-- !ruby/object:Gem::Dependency
-  name: picard
-  requirement: &2168698520 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - =
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-  type: :development
-  prerelease: false
-  version_requirements: *2168698520
+  version_requirements: *2169350180
 description: Test framework inspired by Spock
 email:
 - vic.savkin@gmail.com
@@ -66,19 +55,26 @@ files:
 - .gitignore
 - Gemfile
 - Gemfile.lock
+- README.rdoc
 - Rakefile
 - lib/picard.rb
+- lib/picard/assertion_wrapper.rb
 - lib/picard/ast_helper.rb
 - lib/picard/class_ripper.rb
-- lib/picard/expect_block.rb
+- lib/picard/context.rb
+- lib/picard/error_message_formatter.rb
+- lib/picard/extensions.rb
 - lib/picard/method_ripper.rb
 - lib/picard/preprocessor.rb
+- lib/picard/s_expression_sugar.rb
 - lib/picard/test_unit.rb
 - lib/picard/version.rb
 - picard.gemspec
+- test/picard/assertion_wrapper_test.rb
 - test/picard/ast_helper_test.rb
 - test/picard/class_ripper_test.rb
-- test/picard/expect_block_test.rb
+- test/picard/demo_test.rb
+- test/picard/error_message_formatter_test.rb
 - test/picard/method_ripper_test.rb
 - test/picard/preprocessor_test.rb
 - test/picard/test_unit_test.rb
@@ -109,9 +105,11 @@ signing_key:
 specification_version: 3
 summary: Test framework inspired by Spock
 test_files:
+- test/picard/assertion_wrapper_test.rb
 - test/picard/ast_helper_test.rb
 - test/picard/class_ripper_test.rb
-- test/picard/expect_block_test.rb
+- test/picard/demo_test.rb
+- test/picard/error_message_formatter_test.rb
 - test/picard/method_ripper_test.rb
 - test/picard/preprocessor_test.rb
 - test/picard/test_unit_test.rb

data/lib/picard/expect_block.rb

@@ -1,7 +0,0 @@
-module Picard
-  class ExpectBlock
-    def self.invoke *args
-      yield *args
-    end
-  end
-end

data/test/picard/expect_block_test.rb

@@ -1,20 +0,0 @@
-require_relative '../test_helper'
-
-class Picard::ExpectBlockTest < Test::Unit::TestCase
-
-  def test_should_call_passed_block
-    res = nil
-    Picard::ExpectBlock.invoke do
-      res = true
-    end
-    assert res
-  end
-
-  def test_should_use_passed_variables_in_block
-    res = nil
-    Picard::ExpectBlock.invoke(true) do |x|
-      res = x
-    end
-    assert res
-  end
-end