picard 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.idea
+.bundle
+*.gem
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/picard/*_test.rb']
+  t.verbose = true
+end

data/lib/picard.rb

@@ -0,0 +1,4 @@
+require "picard/version"
+
+module Picard
+end

data/lib/picard/ast_helper.rb

@@ -0,0 +1,65 @@
+require 'live_ast'
+require 'ruby2ruby'
+
+module Picard
+  class AstHelper
+    ResultItem = Struct.new(:index, :ast)
+
+    def all_statements method
+      method_ast = method.to_ast
+      body_statements = extract_statements(method_ast)[1..-1]
+      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] : []
+    end
+
+    def wrap_assertion ast
+      Sexp.new(:call, nil, :assert, Sexp.new(:arglist, ast))
+    end
+
+    def replace_statement method, index, new_ast
+      method_ast = method.to_ast
+      body_statements = extract_statements(method_ast)
+      body_statements[index + 1] = new_ast
+    end
+
+    def extract_ast method
+      method.to_ast
+    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
+    end
+
+    private
+    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_statements method_ast
+      method_ast[3][1]
+    end
+
+    def wrap_in_result_items asts
+      res = []
+      asts.each_with_index do |e, i|
+        res << ResultItem.new(i, e)
+      end
+      res
+    end
+  end
+end

data/lib/picard/class_ripper.rb

@@ -0,0 +1,17 @@
+module Picard
+  class ClassRipper
+    def test_method? method_name
+      method_name.to_s.start_with? 'test_'
+    end
+
+    def all_test_method_names clazz
+      clazz.public_instance_methods.find_all do |m|
+        test_method? m
+      end
+    end
+
+    def replace_method clazz, new_method
+      clazz.class_eval new_method
+    end
+  end
+end

data/lib/picard/expect_block.rb

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

data/lib/picard/method_ripper.rb

@@ -0,0 +1,36 @@
+require 'live_ast'
+require 'live_ast/to_ruby'
+require 'ruby2ruby'
+
+module Picard
+  class MethodRipper
+    def initialize ast_helper = AstHelper.new
+      @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)
+    end
+
+    private
+
+    def replace_all_statements_with_assertions assertions, method
+      assertions.each do |e|
+        wrapped = @ast_helper.wrap_assertion(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")
+    end
+  end
+end

data/lib/picard/preprocessor.rb

@@ -0,0 +1,44 @@
+require 'live_ast'
+require 'live_ast/to_ruby'
+require 'ruby2ruby'
+
+module Picard
+  class Preprocessor
+    def initialize class_ripper = ClassRipper.new, method_ripper = MethodRipper.new
+      @class_ripper = class_ripper
+      @method_ripper = method_ripper
+      @preprocessed_methods = []
+    end
+
+    def preprocess_class clazz
+      all_test_methods = @class_ripper.all_test_method_names(clazz)
+      all_test_methods.each do |m|
+        preprocess_method clazz, m
+      end
+    end
+
+    def preprocess_method clazz, method_name
+      return if preprocessed?(method_name)
+      return unless @class_ripper.test_method?(method_name)
+      
+      mark_as_preprocessed method_name
+      replace_method_with_preprocessed clazz, method_name
+    end
+
+    private
+
+    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
+    end
+
+    def preprocessed? method_name
+      @preprocessed_methods.include? method_name
+    end
+    
+    def mark_as_preprocessed method_name
+      @preprocessed_methods << method_name
+    end
+  end
+end

data/lib/picard/test_unit.rb

@@ -0,0 +1,23 @@
+module Picard
+  module DummyMethods
+    def given
+    end
+
+    def expect
+    end
+  end
+
+  module ClassMethods
+    def method_added name
+      @tr ||= Picard::Preprocessor.new
+      @tr.preprocess_method self, name
+    end
+  end
+
+  module TestUnit
+    def self.included clazz
+      clazz.send :include, DummyMethods
+      clazz.send :extend, ClassMethods
+    end
+  end
+end

data/lib/picard/version.rb

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

data/picard.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "picard/version"
+
+Gem::Specification.new do |s|
+  s.name        = "picard"
+  s.version     = Picard::VERSION
+  s.authors     = ["Victor Savkin"]
+  s.email       = ["vic.savkin@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Test framework inspired by Spock}
+  s.description = %q{Test framework inspired by Spock}
+
+  s.rubyforge_project = "picard"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  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'
+end

data/test/picard/ast_helper_test.rb

@@ -0,0 +1,99 @@
+require_relative '../test_helper'
+
+class Picard::AstHelperTest < Test::Unit::TestCase
+  class TestClass
+    def test_method
+      x = 10
+
+      expect
+      x == 10
+      x == 12
+
+      where
+      y = 1
+    end
+
+    def method_without_assertions
+      'dummy'
+    end
+
+    def test_method_to_replace_statements
+      'dummy'
+    end
+
+    def test_method_with_where_block
+      x = 10
+
+      where
+      y = 20
+      z = 30
+    end
+  end
+
+  def setup
+    @helper = Picard::AstHelper.new
+  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
+
+    assert_equal 2, actual[2].index
+    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 10))), actual[2].ast
+
+    assert_equal 3, actual[3].index
+    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 12))), actual[3].ast
+  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
+
+    assert_equal 2, actual[0].index
+    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 10))), actual[0].ast
+
+    assert_equal 3, actual[1].index
+    assert_equal s(:call, s(:lvar, :x), :==, s(:arglist, s(:lit, 12))), actual[1].ast
+  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
+  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
+
+  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
+  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
+  end
+
+  private
+  def s(*args)
+    Sexp.new *args
+  end
+end

data/test/picard/class_ripper_test.rb

@@ -0,0 +1,44 @@
+require_relative '../test_helper'
+
+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
+
+  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')
+  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
+  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
+  end
+
+  def test_should_replace_method_implementation
+    @ripper.replace_method(DummyClass, "def dummy\n 'replaced' \n end")
+    assert_equal 'replaced', DummyClass.new.dummy
+  end
+end
+

data/test/picard/expect_block_test.rb

@@ -0,0 +1,20 @@
+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

data/test/picard/method_ripper_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+class Picard::MethodRipperTest < Test::Unit::TestCase
+  class TestClass
+    def test_method
+      given
+      something
+      expect
+      1 == 1
+      2 == 2
+    end
+
+    def regular_method
+      1 == 1
+      2 == 2
+    end
+  end
+
+  def setup
+    @ripper = Picard::MethodRipper.new
+  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
+  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
+  end
+end

data/test/picard/preprocessor_test.rb

@@ -0,0 +1,114 @@
+require_relative '../test_helper'
+
+class Picard::PreprocessorTest < Test::Unit::TestCase
+  include RR::Adapters::RRMethods
+
+  class BaseTestClass
+    attr_reader :assert_args
+
+    def initialize
+      @assert_args = []
+    end
+
+    def given
+    end
+
+    def expect
+    end
+
+    def where
+    end
+
+    def assert arg
+      @assert_args << arg
+    end
+  end
+
+  # We need to use a class per test for test isolation
+  class TestClass < BaseTestClass
+    def test_method
+      expect
+      1 == 2
+    end
+  end
+
+  def test_should_wrap_all_assertions_after_expect_in_all_test_methods
+    tr = Picard::Preprocessor.new
+    tr.preprocess_class(TestClass)
+
+    tc = TestClass.new
+    tc.test_method
+    assert_equal [false], tc.assert_args
+  end
+
+
+  class TestClass2 < BaseTestClass
+    def test_method
+      expect
+      1 == 2
+    end
+  end
+
+  def test_should_wrap_all_assertions_in_specified_method
+    tr = Picard::Preprocessor.new
+    tr.preprocess_method(TestClass2, :test_method)
+
+    tc = TestClass2.new
+    tc.test_method
+    assert_equal [false], tc.assert_args
+  end
+
+  
+  class TestClass3 < BaseTestClass
+    def test_method
+      expect
+      1 == 2
+    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)
+
+    tc = TestClass3.new
+    tc.test_method
+    assert_equal [false], tc.assert_args
+  end
+
+
+  class TestClass4 < BaseTestClass
+    def regular_method
+      1 == 2
+    end
+  end
+
+  def test_should_ignore_non_test_methods
+    tr = Picard::Preprocessor.new
+    tr.preprocess_method(TestClass4, :regular_method)
+
+    tc = TestClass4.new
+    tc.regular_method
+    assert_equal [], tc.assert_args
+  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
+end

data/test/picard/test_unit_test.rb

@@ -0,0 +1,27 @@
+require_relative '../test_helper'
+
+class Picard::TestUnitTest < Test::Unit::TestCase
+  class TestUsingPicard
+    include Picard::TestUnit
+    attr_reader :assert_args
+
+    def test_method
+      given
+      x = 1
+
+      expect
+      x == 2
+    end
+
+    def assert arg
+      @assert_args ||= []
+      @assert_args << arg
+    end
+  end
+
+  def test_should_add_assertions_to_all_test_methods
+    test = TestUsingPicard.new
+    test.test_method
+    assert_equal [false], test.assert_args
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require 'rr'
+
+require_relative '../lib/picard/ast_helper'
+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

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: picard
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Victor Savkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-05 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: live_ast
+  requirement: &2168700440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *2168700440
+- !ruby/object:Gem::Dependency
+  name: live_ast_ripper
+  requirement: &2168699820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.6.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *2168699820
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &2168699280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        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
+description: Test framework inspired by Spock
+email:
+- vic.savkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/picard.rb
+- lib/picard/ast_helper.rb
+- lib/picard/class_ripper.rb
+- lib/picard/expect_block.rb
+- lib/picard/method_ripper.rb
+- lib/picard/preprocessor.rb
+- lib/picard/test_unit.rb
+- lib/picard/version.rb
+- picard.gemspec
+- test/picard/ast_helper_test.rb
+- test/picard/class_ripper_test.rb
+- test/picard/expect_block_test.rb
+- test/picard/method_ripper_test.rb
+- test/picard/preprocessor_test.rb
+- test/picard/test_unit_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: picard
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Test framework inspired by Spock
+test_files:
+- test/picard/ast_helper_test.rb
+- test/picard/class_ripper_test.rb
+- test/picard/expect_block_test.rb
+- test/picard/method_ripper_test.rb
+- test/picard/preprocessor_test.rb
+- test/picard/test_unit_test.rb
+- test/test_helper.rb