hooked 0.1.2 → 0.2.0

data/test/controller_test.rb

@@ -1,234 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class ControllerTest < Test::Unit::TestCase
-  def setup
-    @containers = [
-      Class.new do
-        include Hooked::Container
-        before :foo, :do_something do |*args|; end
-      end,
-      Class.new do
-        include Hooked::Container
-        around :foo, :do_something_else do |h, *args|
-          h.call(*args)
-        end
-      end,
-      Class.new do
-        include Hooked::Container
-        hookable :foo do |*args|; end
-      end
-    ].map {|c| c.new }
-  end
-  
-  def test_has_containers
-    controller = Hooked::Controller.new(@containers[0])
-    controller.add(*@containers[1..2])
-    
-    assert_equal @containers, controller.containers
-  end
-  
-  def test_collects_hookables_and_hooks_from_containers
-    hookable = @containers[2].class.hookables[0]
-    hooks = [
-      @containers[0].class.hooks[:foo][0],
-      @containers[1].class.hooks[:foo][0]
-    ]
-    controller = Hooked::Controller.new(*@containers)
-    
-    assert_equal hookable, controller.hookables[hookable.name]
-    assert_equal hooks, controller.hooks[:foo]
-  end
-  
-  def test_sorts_hooks
-    container = Class.new do
-      include(Hooked::Container)
-      before(:foo, :do_something) {}
-      before(:foo, :do_dishes, :after => :all) {}
-      around(:foo, :do_something_more, :before => :do_something) {}
-      after(:foo, :do_something_else, :after => :do_something_more, :before => :do_something) {}
-      around(:foo, :do_laundry, :before => :all) {}
-    end
-    order = [:do_laundry, :do_something_more, :do_something_else, :do_something, :do_dishes]
-    
-    controller = Hooked::Controller.new(container.new)
-    assert_equal order, controller.hooks[:foo].map {|h| h.name }
-    
-    controller = Hooked::Controller.new
-    controller.add(container.new)
-    assert_not_equal order, controller.hooks[:foo].map {|h| h.name }
-
-    controller.hooks[:foo].shuffle!
-    controller.refresh
-    assert_equal order, controller.hooks[:foo].map {|h| h.name }
-  end
-  
-  def test_sets_the_container_on_hookables_and_hooks
-    controller = Hooked::Controller.new(*@containers[1..2])
-    assert_equal @containers[1], controller.hooks[:foo][0].container
-    assert_equal @containers[2], controller.hookables[:foo].container
-  end
-  
-  def test_containers_are_aware_of_their_controller
-    controller = Hooked::Controller.new(*@containers)
-    @containers.each do |c|
-      assert_equal controller, c.hooked
-    end
-  end
-  
-  def test_invokes_hooks_in_their_containers_scope
-    scope = nil
-    container = Class.new do
-      include(Hooked::Container)
-      hookable(:something) {}
-      before(:something, :do_something_else) { scope = self }
-    end.new
-    
-    controller = Hooked::Controller.new(container)
-    controller.invoke(:something)
-    
-    assert_equal(container, scope)
-  end
-  
-  def test_invokes_hookables_in_their_containers_scope
-    scope = nil
-    container = Class.new do
-      include(Hooked::Container)
-      hookable(:something) { scope = self }
-    end.new
-    
-    controller = Hooked::Controller.new(container)
-    controller.invoke(:something)
-    
-    assert_equal(container, scope)
-  end
-  
-  def test_invokes_dynamic_hookables_in_their_original_scope
-    controller = Hooked::Controller.new
-    
-    scope = nil
-    controller.invoke(:something) { scope = self }
-    
-    assert_equal(self, scope)
-  end
-  
-  def test_passes_arguments_into_the_context
-    input = "asd"
-    args = []
-    
-    container = Class.new do
-      include(Hooked::Container)
-      before(:something, :do_something_else) {|ctx| args << ctx.args}
-      hookable(:something) {|ctx| args << ctx.args }
-    end
-
-    controller = Hooked::Controller.new(container.new)
-    controller.invoke(:something, input)
-    
-    assert_equal [input.object_id, input.object_id], args.map {|a| a.object_id }
-  end
-  
-  def test_returns_the_contexts_result
-    input = ["asd", "def"]
-    
-    container = Class.new do
-      include(Hooked::Container)
-      hookable(:something) {|ctx| ctx.result = [input[0]] }
-      after(:something, :do_something_else) {|ctx| ctx.result << input[1] }
-    end
-    
-    controller = Hooked::Controller.new(container.new)
-    result = controller.invoke(:something)
-    
-    assert_equal(input.map {|i| i.object_id }, result.map {|r| r.object_id })
-  end
-  
-  def test_jumps_to_the_next_hook_or_hookable_when_it_catches_next
-    container = Class.new do
-      include(Hooked::Container)
-      before(:something, :asd, :before => :foo) {|ctx| ctx.result = [] }
-      before(:something, :foo) {|ctx| ctx.next; ctx.result << :foo }
-      hookable(:something) {|ctx| ctx.result << :something }
-      after(:something, :bar) {|ctx| ctx.result << :bar }
-    end
-    
-    result = Hooked::Controller.new(container.new).invoke(:something)
-    assert_equal [:something, :bar], result
-  end
-  
-  def test_next_can_jump_out_of_the_current_invocation
-    called = []
-    
-    container1 = Class.new do
-      include(Hooked::Container)
-      hookable(:something) do |ctx|
-        hookable(:something_else)
-        called << :something
-      end
-      after(:something, :bar) {|ctx| called << :bar }
-    end
-    container2 = Class.new do
-      include(Hooked::Container)
-      before(:something_else, :foo_else) {|ctx| called << :foo_else }
-      hookable(:something_else) {|ctx| ctx.next(2); called << :something_else }
-    end
-    
-    Hooked::Controller.new(container1.new, container2.new).invoke(:something)
-    assert_equal [:foo_else, :bar], called
-  end
-  
-  def test_crashes_if_next_depth_is_bigger_than_invocation_depth
-    container = Class.new do
-      include(Hooked::Container)
-      hookable(:something) {|ctx| ctx.next(2) }
-    end
-    
-    assert_throw(:hooked) do
-      Hooked::Controller.new(container.new).invoke(:something)
-    end
-  end
-  
-  def test_returns_from_the_current_invocation_when_it_catches_break
-    container = Class.new do
-      include(Hooked::Container)
-      before(:something, :asd, :before => :foo) {|ctx| ctx.result = [] }
-      before(:something, :foo) {|ctx| ctx.result << :foo; ctx.break }
-      hookable(:something) {|ctx| ctx.result << :something }
-      after(:something, :bar) {|ctx| ctx.result << :bar }
-    end
-    
-    result = Hooked::Controller.new(container.new).invoke(:something)
-    assert_equal [:foo], result
-  end
-  
-  def test_break_can_jump_out_of_the_current_invocation
-    called = []
-    
-    container1 = Class.new do
-      include(Hooked::Container)
-      hookable(:something) do |ctx|
-        hookable(:something_else)
-        called << :something
-      end
-      after(:something, :bar) {|ctx| called << :bar }
-    end
-    container2 = Class.new do
-      include(Hooked::Container)
-      before(:something_else, :foo_else) {|ctx| called << :foo_else }
-      hookable(:something_else) {|ctx| ctx.break(2); called << :something_else }
-    end
-    
-    Hooked::Controller.new(container1.new, container2.new).invoke(:something)
-    assert_equal [:foo_else], called
-  end
-  
-  def test_crashes_if_break_depth_is_bigger_than_invocation_depth
-    container = Class.new do
-      include(Hooked::Container)
-      hookable(:something) {|ctx| ctx.break(2) }
-    end
-    
-    assert_throw(:hooked) do
-      Hooked::Controller.new(container.new).invoke(:something)
-    end
-  end
-end

data/test/helper.rb

@@ -1,10 +0,0 @@
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :development)
-
-require "test/unit"
-require "mocha"
-
-require "awesome_print" rescue nil
-
-require "hooked"

data/test/hook_test.rb

@@ -1,90 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class HookTest < Test::Unit::TestCase
-  def context
-    Hooked::Context
-  end
-  
-  def test_has_a_name
-    name = :foo
-    hook = Hooked::Hook.new(:before, name) {}
-    
-    assert_equal name, hook.name
-  end
-  
-  def test_has_a_type
-    build_hook = proc do |type|
-      Hooked::Hook.new(type, :foo) {}
-    end
-    
-    hook = build_hook.call(:before)
-    assert_equal :before, hook.type
-    
-    assert hook.before?
-    assert build_hook.call(:after).after?
-    assert build_hook.call(:around).around?
-    
-    assert_raise(ArgumentError) do
-      build_hook.call(:asdas)
-    end
-  end
-  
-  def test_has_relations
-    relations = {
-      :before => 123
-    }
-    hook = Hooked::Hook.new(:before, :foo, relations) {}
-    assert_equal(123, hook.relations[:before])
-    
-    hook.relations[:before] = 456
-    assert_equal(456, hook.relations[:before])
-    
-    hook.relations[:after] = "asd"
-    assert_equal("asd", hook.relations[:after])
-  end
-  
-  def test_has_a_container
-    container = stub("container")
-    hook = Hooked::Hook.new(:before, :foo, {}, container) {}
-    assert_equal container, hook.container
-    
-    container2 = stub("container2")
-    hook.container = container2
-    assert_equal container2, hook.container
-  end
-  
-  def test_expects_a_block
-    assert_nothing_raised do
-      Hooked::Hook.new(:before, :foo) {}
-    end
-    
-    assert_raise(ArgumentError) do
-      Hooked::Hook.new(:before, :foo)
-    end
-  end
-  
-  def test_executes_block_in_the_containers_scope
-    scope = nil
-    hook = Hooked::Hook.new(:before, :foo) do
-      scope = self
-    end
-    
-    assert_raise(RuntimeError) { hook.call(context) }
-    
-    container = stub("container")
-    hook.container = container
-    hook.call(context)
-    assert_equal(container, scope)
-  end
-  
-  def test_passes_context_to_the_block
-    ctx = context
-    ctx2 = nil
-    hook = Hooked::Hook.new(:before, :foo, {}, stub("container")) do |c|
-      ctx2 = c
-    end
-    
-    hook.call(ctx)
-    assert_equal(ctx, ctx2)
-  end
-end

data/test/hookable_test.rb

@@ -1,66 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class HookableTest < Test::Unit::TestCase
-  def context
-    Hooked::Context
-  end
-  
-  def test_has_a_name
-    name = :foo
-    hookable = Hooked::Hookable.new(name) {}
-    
-    assert_equal name, hookable.name
-  end
-  
-  def test_can_have_a_container
-    container = Object.new
-    hookable = Hooked::Hookable.new(:foo, container) {}
-    
-    assert_equal container, hookable.container
-    
-    assert_nil Hooked::Hookable.new(:foo) {}.container
-  end
-  
-  def test_expects_a_block
-    assert_nothing_raised do
-      Hooked::Hookable.new(:foo) {}
-    end
-    
-    assert_raise(ArgumentError) do
-      Hooked::Hookable.new(:foo)
-    end
-  end
-  
-  def test_executes_block_in_the_containers_scope
-    container = Object.new
-    
-    scope = nil
-    hookable = Hooked::Hookable.new(:foo, container) do
-      scope = self
-    end
-    
-    hookable.call(context)
-    assert_equal container, scope
-  end
-  
-  def test_executes_block_in_its_original_scope_if_no_container_given
-    scope = nil
-    hookable = Hooked::Hookable.new(:foo) do
-      scope = self
-    end
-    
-    hookable.call(context)
-    assert_equal self, scope
-  end
-  
-  def test_passes_context_to_the_block
-    ctx = context
-    ctx2 = nil
-    hookable = Hooked::Hookable.new(:foo) do |c|
-      ctx2 = c
-    end
-    
-    hookable.call(ctx)
-    assert_equal(ctx, ctx2)
-  end
-end