adva 0.0.1

data/test/with/lib/with/sharing.rb

@@ -0,0 +1,29 @@
+module With
+  module Sharing
+    def share(group, name = nil, &block)
+      context = Context.new(name || group, &block)
+      context.instance_eval &block if block
+      
+      self.shared[group] ||= []
+      self.shared[group] << context
+    end
+    
+    def shared(name = nil)
+      @@shared ||= {}
+      name.nil? ? @@shared : begin
+        raise "could not find shared context #{name.inspect}" unless @@shared.has_key?(name)
+        @@shared[name].map {|context| context.clone }
+      end
+    end
+
+    def share_condition(name, &block)
+      @@conditions ||= {}
+      @@conditions[name] = block
+    end
+    
+    def condition(name)
+      @@conditions ||= {}
+      @@conditions[name]
+    end
+  end
+end

data/test/with/test/all.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/**/*_test.rb"].each { |path| require path }

data/test/with/test/context_calls_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ContextCallsTest < Test::Unit::TestCase
+  def teardown
+    With.shared.clear
+  end 
+
+  def test_registers_before
+    context = With::Context.build('foo'){ before('before'){ }}.first
+    assert_equal 'before', context.calls(:before).first.name
+  end
+  
+  def test_registers_action
+    context = With::Context.build('foo'){ action('action'){ }}.first
+    assert_equal 'action', context.calls(:action).first.name
+  end
+  
+  def test_registers_assertion
+    context = With::Context.build('foo'){ assertion('assertion'){ }}.first
+    assert_equal 'assertion', context.calls(:assertion).first.name
+  end
+  
+  def test_registers_after
+    context = With::Context.build('foo'){ after('after'){ }}.first
+    assert_equal 'after', context.calls(:after).first.name
+  end
+  
+  def test_registers_missing_method_calls_as_assertions
+    context = With::Context.build('foo'){ assert(true) }.first
+    assert_equal 'assert_true', context.calls(:assertion).first.name
+  end
+  
+  def test_wraps_explicit_call_into_shared_context
+    With.share(:bar){ }
+    contexts = With::Context.build('foo'){ assertion('assertion', :with => :bar){ }}
+    assert_equal [[['foo', :bar]]], context_names(contexts)
+  end
+  
+  def test_wraps_missing_method_call_into_shared_context
+    With.share(:bar){ }
+    contexts = With::Context.build('foo'){ assert(true, :with => :bar){ }}
+    assert_equal [[['foo', :bar]]], context_names(contexts)
+  end
+  
+  def test_registers_explicit_call_with_in_condition
+    context = With::Context.build('foo'){ before('before', :in => 'foo'){ }}.first
+    assert_equal 'foo', context.calls(:before).first.instance_variable_get(:@conditions)[:in]
+    assert context.calls(:before).first.applies?(context)
+  end
+  
+  def test_registers_missing_method_call_with_in_condition
+    context = With::Context.build('foo'){ assert(true, :in => 'foo'){ }}.first
+    assert_equal 'foo', context.calls(:assertion).first.instance_variable_get(:@conditions)[:in]
+    assert context.calls(:assertion).first.applies?(context)
+  end
+end

data/test/with/test/context_compile_test.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ContextCompileTest < Test::Unit::TestCase
+  def setup
+    Target.reset
+    With.shared.clear
+  end
+  
+  def call(context)
+    context.compile(Target)
+    target = Target.new
+
+    target.methods.select{|m| m =~ /^test/ }.sort.reverse.inject([]) do |called, method| 
+      target.send(method)
+      called << target.called.dup
+      target.called.clear
+      called
+    end
+  end
+  
+  def test_compile_simple
+    collector = lambda { (@called ||= []) << @_with_current_context }
+  
+    context = With::Context.build('foo') do 
+      before 'before_1', &collector
+      before 'before_2', &collector
+      action 'action',   &collector
+      assertion 'assertion_1', &collector
+      assertion 'assertion_2', &collector
+      after 'after_1', &collector
+      after 'after_2', &collector
+    end.first
+    
+    expected = [['before_1', 'before_2', 'action', 'assertion_1', 'assertion_2', 'after_1', 'after_2']]
+    assert_equal expected, call(context)
+  end
+  
+  def test_compile
+    collector = lambda { (@called ||= []) << @_with_current_context }
+  
+    With.share :shared, 'shared_1' do
+      before 'shared_1_before', &collector
+      assertion 'shared_1_assertion', &collector
+      after 'shared_1_after', &collector
+    end
+  
+    With.share :shared, 'shared_2' do
+      before 'shared_2_before', &collector
+      assertion 'shared_2_assertion', &collector
+      after 'shared_2_after', &collector
+    end
+    
+    context = With::Context.build('foo', :shared) do
+      before 'foo_before', &collector
+      action 'foo_action', &collector
+      assertion 'foo_assertion', &collector
+      after 'foo_after', &collector
+      
+      with ['bar', 'baz'] do
+        before "#{name}_before", &collector
+        assertion "#{name}_assertion", &collector
+        after "#{name}_after", &collector
+      end
+    end.first
+    
+    expected = [['shared_1_before', 'foo_before', 'bar_before', 
+                 'foo_action', 
+                 'shared_1_assertion', 'foo_assertion', 'bar_assertion',
+                 'shared_1_after', 'foo_after', 'bar_after'],
+                ['shared_1_before', 'foo_before', 'baz_before', 
+                 'foo_action', 
+                 'shared_1_assertion', 'foo_assertion', 'baz_assertion',
+                 'shared_1_after', 'foo_after', 'baz_after'],
+                ['shared_2_before', 'foo_before', 'bar_before', 
+                 'foo_action', 
+                 'shared_2_assertion', 'foo_assertion', 'bar_assertion',
+                 'shared_2_after', 'foo_after', 'bar_after'],
+                ['shared_2_before', 'foo_before', 'baz_before', 
+                 'foo_action', 
+                 'shared_2_assertion', 'foo_assertion', 'baz_assertion',
+                 'shared_2_after', 'foo_after', 'baz_after']]
+    assert_equal expected, call(context)
+  end
+  
+  def test_compile_with_conditions
+    collector = lambda { (@called ||= []) << @_with_current_context }
+  
+    With.share(:shared, 'shared_1') { before 'shared_1_before', &collector }
+    With.share(:shared, 'shared_2') { before 'shared_2_before', &collector }
+    
+    context = With::Context.build('foo', :shared) do
+      before 'foo_before_1', :in => 'shared_1', &collector
+      before 'foo_before_2', :in => 'shared_2', &collector
+      after 'foo_after_1', :not_in => 'shared_1', &collector
+      after 'foo_after_2', :not_in => 'foo', &collector
+      with('bar', :in => 'shared_1') do
+        before 'bar_before', &collector
+      end
+    end.first
+    
+    expected = [['shared_2_before', 'foo_before_2', 'foo_after_1'],
+                ['shared_1_before', 'foo_before_1', 'bar_before']]
+    
+    assert_equal expected, call(context)
+  end
+end

data/test/with/test/context_structure_test.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ContextStructureTest < Test::Unit::TestCase
+  def teardown
+    With.shared.clear
+  end 
+  
+  # generates 1 context, nested 3 levels deep
+  def test_nested_context
+    names = context_names With::Context.build('foo'){ with('bar') { with('baz') }}
+    assert_equal [[['foo', 'bar', 'baz']]], names
+  end
+  
+  # generates 2 contexts, nested 3 levels deep and alternates the 2. level
+  def test_and_or_and
+    names = context_names With::Context.build('foo', ['bar', 'baz'], 'buz')
+    assert_equal [[['foo', 'bar', 'buz'], ['foo', 'baz', 'buz']]], names
+  end
+  
+  # same, but additionally nests 2 more levels
+  def test_and_or_and_with_nested_context
+    names = context_names With::Context.build('foo', ['bar', 'baz'], 'buz') { with('boz') { with('bum') } }
+    assert_equal [[['foo', 'bar', 'buz', 'boz', 'bum'], ['foo', 'baz', 'buz', 'boz', 'bum']]], names
+  end
+  
+  # generates 2 contexts, nested 3 levels deep and alternates the 1. level
+  def test_or_and_and
+    names = context_names With::Context.build(['foo', 'bar'], 'baz', 'buz')
+    assert_equal [[['foo', 'baz', 'buz']], [['bar', 'baz', 'buz']]], names
+  end
+  
+  # same, but additionally nests 2 more levels
+  def test_or_and_and_with_nested_context
+    names = context_names With::Context.build(['foo', 'bar'], 'baz', 'buz') { with('boz'){ with('bum') } }
+    assert_equal [[['foo', 'baz', 'buz', 'boz', 'bum']], [['bar', 'baz', 'buz', 'boz', 'bum']]], names
+  end
+  
+  # generates 3 contexts, nested 3 levels deep and alternates the 1. level
+  def test_or_and_and_with_shared_context
+    With.share(:foo, 'foo-1')
+    With.share(:foo, 'foo-2')
+    names = context_names With::Context.build([:foo, 'bar'], 'baz', 'buz')
+    assert_equal [[['foo-1', 'baz', 'buz']], [['foo-2', 'baz', 'buz']], [['bar', 'baz', 'buz']]], names
+  end
+  
+  def test_shared_context_with_nesting
+    With.share(:foo, 'foo-1') { with('bar') { with('baz') } }
+    With.share(:foo, 'foo-2')
+    names = context_names With::Context.build(:foo, 'buz')
+    assert_equal [[['foo-1', 'bar', 'baz', 'buz']], [['foo-2', 'buz']]], names
+  end
+  
+  def test_and_with_shared_context
+    With.share(:foo, 'foo-1') { with('bar') { with('baz') } }
+    With.share(:foo, 'foo-2')
+    names = context_names With::Context.build('fam', :foo)
+    assert_equal [[['fam', 'foo-1', 'bar', 'baz'], ['fam', 'foo-2']]], names
+  end
+  
+  def test_and_or_with_shared_context
+    With.share(:foo, 'foo-1') { with('bar') { with('baz') } }
+    With.share(:foo, 'foo-2')
+    names = context_names With::Context.build('fam', [:foo, 'fum'])
+    assert_equal [[['fam', 'foo-1', 'bar', 'baz'], 
+                   ['fam', 'foo-2'], 
+                   ['fam', 'fum']]], names
+  end
+  
+  def test_or_and_and_with_shared_context_with_nesting_and_with_nested_context
+    With.share(:foo, 'foo-1') { with('bar') { with('baz') } }
+    With.share(:foo, 'foo-2')
+    names = context_names With::Context.build('fam', [:foo, 'fum'], 'buz') { with('boz') { with('bum') } }
+    assert_equal [[['fam', 'foo-1', 'bar', 'baz', 'buz', 'boz', 'bum'],
+                   ['fam', 'foo-2', 'buz', 'boz', 'bum'], 
+                   ['fam', 'fum',   'buz', 'boz', 'bum']]], names
+  end
+  
+  def test_shared_contexts_are_duplicated_so_they_can_be_reused
+    With.share(:foo, 'foo') { with('bar') }
+    With::Context.build('fam', :foo) { with('bum!') }
+    names = context_names With::Context.build(:foo) { with('baz') }
+    assert !names.flatten.include?('bum!'), "expected #{names.inspect} not to include 'bum!'"
+  end
+  
+  def test_context_with_in_condition_applies
+    context = With::Context.build('bar'){ with('foo', :in => 'bar') }.first 
+    assert_equal 'foo', context.children.first.name
+  end
+  
+  def test_context_with_in_condition_does_not_apply
+    context = With::Context.build('bar'){ with('foo', :in => 'baz') }.first 
+    assert context.children.empty?
+  end
+  
+  def test_context_with_not_in_condition_applies
+    context = With::Context.build('bar'){ with('foo', :not_in => 'bar') }.first 
+    assert context.children.empty?
+  end
+  
+  def test_context_with_not_in_condition_does_not_apply
+    context = With::Context.build('bar'){ with('foo', :not_in => 'baz') }.first 
+    assert_equal 'foo', context.children.first.name
+  end
+  
+  def test_context_with_common_parents
+    Target.with_common :common
+    Target.share(:common){}
+    names = context_names [Target.describe('bar'){ with 'foo' }]
+    assert_equal [[['bar', :common, 'foo']]], names
+  end
+  
+  def test_different_nested_contexts_with_common_shared_parent
+    With.share(:bar, 'bar') {  }
+    context = With::Context.build('foo') do 
+      with(:bar){ assertion('renders :new'){} } 
+      with(:bar){ assertion('renders :edit'){} } 
+    end.first
+    assert_equal 'renders :new', context.children[0].calls(:assertion)[0].name
+    assert_equal 'renders :edit', context.children[1].calls(:assertion)[0].name
+  end
+  
+  def test_node_knows_its_filename_and_linenumber
+    context = With::Context.build('foo'){ }.first
+    assert_equal __FILE__, context.send(:file)
+    assert_equal __LINE__ - 2, context.send(:line)
+  end
+  
+  def test_select_finds_nodes_with_a_block_matching
+    context = With::Context.build('foo'){ 
+      with('bar'){}
+    }.first.select { |block| block.send(:line) == __LINE__ - 1 }.first
+    assert_equal 'bar', context.name
+  end
+  
+  def test_implemented_at_returns_true_when_context_or_call_is_implemented_at_given_file_and_line
+    context = With::Context.build('foo'){ 
+      with('bar'){}
+    }.first
+    assert context.implemented_at?(:file => __FILE__, :line => __LINE__ - 3)
+    assert context.children.first.implemented_at?(:file => __FILE__, :line => __LINE__ - 3)
+  end
+end

data/test/with/test/demo_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/helper'
+
+class DemoTest < Test::Unit::TestCase
+  def setup
+    Target.reset
+  end
+  
+  def test_something
+    With.share(:caching) { before { @caching = true } }
+    With.share(:observers) { before { @observers = true } }
+    With.share(:login_as_admin) { before { @controller.current_user = User.new(true) } }
+    With.share(:login_as_user) { before { @controller.current_user = User.new(false) } }
+    With.share(:no_login) { before { @controller.current_user = nil }}
+    With.share(:valid_article_params) { before { @params = valid_article_params } }
+    With.share(:invalid_article_params) { before { @params = valid_article_params.except(:title) } }
+    With.share(:invalid_article_params) { before { @params = valid_article_params.except(:body) } }
+
+    Target.with_common :caching, :observers
+    
+    context = Target.describe 'POST to :create' do
+      before { @before_block_called = true }
+      action { post :create, @params }
+      
+      it "has called the before blocks" do
+        assert @caching
+        assert @observers
+        assert @before_block_called
+      end
+      
+      with :login_as_admin do
+        it_assigns :article
+    
+        it "succeeds", :with => :valid_article_params do
+          it_redirects_to { 'articles/1' }
+    
+          it "can nest assertions" do
+            assert true
+          end
+        end
+    
+        it "fails", :with => :invalid_article_params do
+          it_assigns_flash :error, /missing: (body|title)/
+        end
+      end
+    
+      with [:login_as_user, :no_login] do
+        it_redirects_to { '/login' }
+      end
+    end
+    
+    methods = Target.instance_methods.grep(/^test/)
+    #puts; puts Target.instance_methods.grep(/^test/).join(", \n  ")
+    assert_equal 5, methods.count
+
+    expected = [[['POST to :create', :caching, :observers, :login_as_admin, :valid_article_params],
+                 ['POST to :create', :caching, :observers, :login_as_admin, :invalid_article_params],
+                 ['POST to :create', :caching, :observers, :login_as_admin, :invalid_article_params],
+                 ['POST to :create', :caching, :observers, :login_as_user],
+                 ['POST to :create', :caching, :observers, :no_login]]]
+    assert_equal expected, context_names([context])
+    
+  end
+end

data/test/with/test/helper.rb

@@ -0,0 +1,68 @@
+$:.unshift File.dirname(__FILE__) + '/../lib/'
+require 'with'
+
+class Target
+  include With
+  
+  def called
+    @called ||= []
+  end
+end
+
+class Symbol
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+end
+
+class Array
+  def to_sentence
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s
+      else
+        "#{self[0...-1].join(', ')} and #{self[-1]}"
+    end
+  end
+end
+
+class Hash
+  def slice(*keys)
+    Hash[*keys.map { |key| [key, self[key]] if has_key?(key) }.flatten.compact]
+  end
+end
+
+class Test::Unit::TestCase
+  def context_names(contexts)
+    contexts.map do |context| 
+      context.leafs.map { |leaf| (leaf.parents << leaf).map(&:name) }
+    end
+  end
+end
+
+module With
+  class Node
+    def inspect
+      $_INDENT ||= 0
+      $_INDENT += 1
+      s = "\n#<Context:#{self.object_id} @name=#{name.inspect}\n"
+      s << "  @parent(#{parent.object_id})=#{parent.name.inspect}\n" unless parent.nil?
+      s << "  @calls(#{@calls.object_id})=#{@calls.inspect}\n" unless @calls.empty?
+      s << "  @children(#{@children.object_id})=#{children.inspect}" unless children.empty?
+      s << ">"
+      s = s.split(/\n/).map{|s| ' ' * $_INDENT + s }.join("\n")
+      $_INDENT -= 1
+      s
+    end
+  end
+
+  class Call
+    def inspect
+      s = "#<Call:#{self.object_id} @name=#{name.inspect}"
+      s << " @conditions=#{@conditions.inspect}" unless @conditions.empty?
+      s + '>'
+    end
+  end
+end