hooked 0.0.1 → 0.1.0

data/Gemfile

@@ -2,6 +2,4 @@ source "http://rubygems.org"
 
 gemspec
 
-group :development do
-  gem "awesome_print"
-end
+gem "awesome_print"

data/README.md

@@ -1,12 +1,181 @@
-Ruby library for Aspect Oriented Programming
+Ruby Library For Aspect Oriented Programming
 ============================================
 
-hooked makes AOP a breeze. It lets you define and invoke code that other
-gems or parts of your application can hook onto. Supported hooks are before,
-after and around.
+Hooked makes AOP a breeze. It lets you define and invoke code that gems or other
+parts of your application can hook onto.
 
-To Do
------
+Getting Started
+---------------
 
-* Skip hooks
-* Control flow (return, next, break)
+    require "hooked"
+    
+    class User
+      include Hooked::Container
+      
+      def save
+        hookable(:save_user, self)
+      end
+      
+      hookable :save_user do |ctx|
+        ctx.return(Database.save(ctx.args))
+      end
+    end
+    
+    class PermissionCheck
+      include Hooked::Container
+      
+      def has_permissions?
+        false
+      end
+      
+      before :save_user, :check_permissions do |ctx|
+        ctx.break unless has_permissions?
+      end
+    end
+    
+    user = User.new
+    hooking = Hooked::Controller.new(user, PermissionCheck.new)
+    user.save # => false
+
+Defining Hookable Code
+----------------------
+
+To be able to define hookable code (as well as hooks) you need to mixin the
+Hooked::Container module. Afterwards you can use the `::hookable` method which
+takes a symbol as the hookable's name as well as a block.
+
+    class Something
+      include Hooked::Container
+      
+      hookable :breakfast do |ctx|
+        puts "I'm having breakfast"
+      end
+    end
+
+The hookable will always be executed in the context of its container's object.
+
+Defining Hooks
+--------------
+
+For defining hooks you can use the methods `::before`, `::after` and
+`::around`. They are shortcuts to `::hook` and take the arguments
+`hookable_name` (name of the hookable you want to hook onto), `hook_name` and
+an optional hash of before/after options.
+
+    before :breakfast, :get_up do |ctx|
+      puts "I'm getting out of the bed"
+    end
+    
+    before :breakfast, :make_coffee, :after => :get_up do |ctx|
+      puts "I'm making coffee"
+    end
+
+`:before` and `:after` can be a single hook name, an array of hook names or
+`:all`. More documentation on before/after relations and how they are being
+resolved can be found in the
+[depression gem](http://rubygems.org/gems/depression).
+
+Hooks will always be executed in the context of their container's object (just
+as hookables).
+
+**Note:** Hooked will at no point guarantee that hooks will be executed in the
+order of definition. If you rely on execution order, you should use the
+`:before` and `:after` options.
+
+Hooking Controller
+------------------
+
+The controller is responsible for bringing hooks into the desired order and
+executing them correctly.
+
+    hooking = Hooked::Controller.new(container1, container2)
+    result = hooking.invoke(:my_hookable, arguments)
+
+Arguments And Return Values
+---------------------------
+
+All argument and return value stuff (and control flow) is managed through a
+context object that is being passed between the hooks as well as the hookable.
+You can pass in and out whatever you want.
+
+    after(:lowercase, :confuse_programmer) do |ctx|
+      ctx.result = ctx.args.map {|s| s.upper }
+    end
+
+    res = hooking.invoke(:lowercase, ["asdf", :foo, 123]) do |ctx|
+      ctx.result = ctx.args.map {|s| s.to_s.lower }
+    end
+    
+    p res # => ["ASDF", "FOO", "123"]
+
+Control Flow
+------------
+
+If you want to cancel the execution of a hook and immediately start with the
+next one, use `Context#next`. You would probably want to set a return value
+first with `Context#result=`. `Context#return` basically does the same thing,
+but additionally it always sets the return value to whatever you pass as an
+argument.
+    
+    # this
+    ctx.return "asd"
+    # is equal to
+    ctx.result = "asd"
+    ctx.next
+
+    # and this will result in ctx.result being nil after returning
+    ctx.result = 123
+    ctx.return
+
+If you want to cancel the whole invocation you can use `Context#break`. This
+will immediately return to where `Controller#invoke` was called. So if you call
+it before the hookable was executed, it won't be executed at all.
+
+    hookable :foo do |ctx|
+      puts "You won't see me :/"
+    end
+    
+    before :foo, :break_the_chain do |ctx|
+      ctx.break
+    end
+
+You can pass a Fixnum to `Context#next` and `Context#break` to specify the
+stack depth you want to jump. If you jump to high (e.g. you're hooking two
+invocations deep but do `ctx.break 3`) a `NameError: uncaught throw 'hooked'`
+will be raised.
+
+**NOTE** You should definitely _not_ use Ruby's control flow constructs, they
+may cause serious trouble that can be hard to debug. This may change in future
+versions of Hooked. (I appreciate Pull Requests! :>)
+
+Dependencies
+------------
+
+* [depression](https://rubygems.org/gems/depression)
+* Ruby 1.9.2
+* Possibly other versions and platforms, I didn't test any yet.
+* [mocha](https://rubygems.org/gems/mocha) and
+  [test-unit](https://rubygems.org/gems/test-unit) for development
+
+To do & Ideas
+-------------
+
+* Skipping hooks
+* Visualization of hook flow
+* Make backtraces more readable
+* Make Ruby's control flow constructs work for hooks
+
+Contributing
+------------
+
+1. Fork at [github.com/lgierth/hooked](https://github.com/lgierth/hooked)
+2. Create a new branch
+3. Commit, commit, commit!
+4. Open a Pull Request
+
+You can also open an issue for discussion first, if you like.
+
+License
+-------
+
+Hooked is subject to an MIT-style license that can be found in the LICENSE file.

data/hooked.gemspec

@@ -10,10 +10,10 @@ Gem::Specification.new do |s|
   s.authors     = ["Lars Gierth"]
   s.email       = ["lars.gierth@gmail.com"]
   s.homepage    = "http://rubygems.org/gems/hooked"
-  s.summary     = %q{Ruby library for Aspect Oriented Programming}
-  s.description = %q{hooked makes AOP a breeze. It lets you define and invoke
-                     code that other gems or parts of your application can hook
-                     onto. Supported hooks are before, after and around.}
+  s.summary     = %q{Ruby Library For Aspect Oriented Programming}
+  s.description = %q{Hooked makes AOP a breeze. It lets you define and invoke
+                     code that gems or other parts of your application can hook
+                     onto.}
   
   s.add_dependency "depression"
   

data/lib/hooked/context.rb

@@ -0,0 +1,39 @@
+module Hooked
+  class Context
+    attr_reader :args
+    attr_accessor :result
+    
+    def initialize(args)
+      @args = args
+    end
+    
+    def next(depth = 1)
+      return if depth < 1
+      throw(:hooked, {
+        :type => :next,
+        :depth => depth
+      })
+    end
+    
+    def return(result)
+      @result = result
+      self.next
+    end
+    
+    def break(depth = 1)
+      return if depth < 1
+      throw(:hooked, {
+        :type => :break,
+        :depth => depth
+      })
+    end
+    
+    def skip(*hooks)
+      raise "Not yet implemented."
+    end
+    
+    def skip_other(hookable, *hooks)
+      raise "Not yet implemented."
+    end
+  end
+end

data/lib/hooked/controller.rb

@@ -2,11 +2,9 @@ module Hooked
   Result = Struct.new(:type, :value)
   
   class Controller
-    attr_reader :name, :containers, :hookables, :hooks
+    attr_reader :containers, :hookables, :hooks
     
-    def initialize(name, *containers)
-      @name = name
-      
+    def initialize(*containers)
       @containers = []
       @hookables = {}
       @hooks = {}
@@ -18,6 +16,7 @@ module Hooked
     def add(*containers)
       @containers.push(*containers)
       containers.each do |c|
+        c.hooked = self
         c.class.hookables.each do |hkbl|
           hkbl.container = c
           hookables[hkbl.name] = hkbl
@@ -34,59 +33,48 @@ module Hooked
       hooks.each {|hkbl_name, hs| hooks[hkbl_name] = Depression.process(hs) }
     end
     
-    def invoke(name, *args, &block)
+    def invoke(name, args = nil, &block)
       if block
         hookable = Hookable.new(name, &block)
       else
         hookable = hookables[name] || raise("Unknown hookable: #{name}")
       end
       
-      result = catch(:hooked) do
-        (hooks[name] || []).reverse.inject(hookable) do |next_item, item|
-          proc {|a| call_hook(item, next_item, a) }
-        end.call(args)
+      context = Context.new(args)
+      chain = (hooks[name] || []).reverse.inject(hookable) do |next_item, item|
+        proc {|ctx| call_hook(item, next_item, ctx) }
       end
-      if (result[0] rescue nil) == :hooked_abort_chain
-        result[1]
-      else
-        result
+      
+      ctrl = catch(:hooked) { chain.call(context); nil }
+      
+      if ctrl.respond_to?(:[])
+        ctrl[:depth] -= 1
+        throw(:hooked, ctrl) if ctrl[:depth] > 0
       end
+      
+      context.result
     end
     
-    protected
-    
-    # def call_wrapped_hook(hook, hookable, args)
-    #   ret = nil
-    #   
-    #   j = (0..1).each do |i|
-    #     ret = call_hook(hook, hookable, args) if i == 0
-    #   end
-    #   unless j
-    #     throw(:hooked, :hooked_abort_chain)
-    #   end
-    #   
-    #   ret
-    # end
-    
-    def call_hook(hook, hookable, args)
-      args = hook.call(*args) if hook.before?
+    def call_hook(hook, hookable, context)
+      wrap { hook.call(context) } if hook.before?
       
-      result = catch(:hooked) do
+      wrap do
         if hook.around?
-          hook.call(hookable, *args)
+          hook.call(context, hookable)
         else
-          hookable.call(*args)
+          hookable.call(context)
         end
       end
-      if result == :hooked_abort_chain
-        throw(:hooked, [:hooked_abort_chain, args])
-      else
-        args = result
-      end
-      
-      args = hook.call(*args) if hook.after?
       
-      args
+      wrap { hook.call(context) } if hook.after?
+    end
+    
+    def wrap(&block)
+      ctrl = catch(:hooked) { block.call; nil }
+      if ctrl.respond_to?(:[]) && (
+          ctrl[:type] == :break || ctrl[:depth] > 1)
+        throw(:hooked, ctrl)
+      end
     end
   end
 end

data/lib/hooked/hook.rb

@@ -13,9 +13,9 @@ module Hooked
       @container, @block = container, block
     end
     
-    def call(*args)
+    def call(context)
       raise RuntimeError, "No container set for hook `#{name}'" unless container
-      container.instance_exec(*args, &@block)
+      container.instance_exec(context, &@block)
     end
     
     def before?

data/lib/hooked/hookable.rb

@@ -9,11 +9,11 @@ module Hooked
       @name, @container, @block = name.to_sym, container, block
     end
     
-    def call(*args)
+    def call(context)
       if container
-        container.instance_exec(*args, &@block)
+        container.instance_exec(context, &@block)
       else
-        @block.call(*args)
+        @block.call(context)
       end
     end
   end

data/lib/hooked/version.rb

@@ -1,3 +1,3 @@
 module Hooked
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/hooked.rb

@@ -1,6 +1,7 @@
 require "depression"
 
 require "hooked/container"
+require "hooked/context"
 require "hooked/controller"
 require "hooked/hook"
 require "hooked/hookable"

data/test/container_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+require File.expand_path("../helper", __FILE__)
 
 class ContainerTest < Test::Unit::TestCase
   def setup

data/test/controller_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+require File.expand_path("../helper", __FILE__)
 
 class ControllerTest < Test::Unit::TestCase
   def setup
@@ -20,15 +20,8 @@ class ControllerTest < Test::Unit::TestCase
     ].map {|c| c.new }
   end
   
-  def test_has_a_name
-    name = :foo
-    controller = Hooked::Controller.new(name)
-    
-    assert_equal name, controller.name
-  end
-  
   def test_has_containers
-    controller = Hooked::Controller.new(:foo, @containers[0])
+    controller = Hooked::Controller.new(@containers[0])
     controller.add(*@containers[1..2])
     
     assert_equal @containers, controller.containers
@@ -40,7 +33,7 @@ class ControllerTest < Test::Unit::TestCase
       @containers[0].class.hooks[:foo][0],
       @containers[1].class.hooks[:foo][0]
     ]
-    controller = Hooked::Controller.new(:baz, *@containers)
+    controller = Hooked::Controller.new(*@containers)
     
     assert_equal hookable, controller.hookables[hookable.name]
     assert_equal hooks, controller.hooks[:foo]
@@ -57,10 +50,10 @@ class ControllerTest < Test::Unit::TestCase
     end
     order = [:do_laundry, :do_something_more, :do_something_else, :do_something, :do_dishes]
     
-    controller = Hooked::Controller.new(:baz, container.new)
+    controller = Hooked::Controller.new(container.new)
     assert_equal order, controller.hooks[:foo].map {|h| h.name }
     
-    controller = Hooked::Controller.new(:baz)
+    controller = Hooked::Controller.new
     controller.add(container.new)
     assert_not_equal order, controller.hooks[:foo].map {|h| h.name }
 
@@ -70,11 +63,18 @@ class ControllerTest < Test::Unit::TestCase
   end
   
   def test_sets_the_container_on_hookables_and_hooks
-    controller = Hooked::Controller.new(:foo, *@containers[1..2])
+    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
@@ -83,7 +83,7 @@ class ControllerTest < Test::Unit::TestCase
       before(:something, :do_something_else) { scope = self }
     end.new
     
-    controller = Hooked::Controller.new(:foo, container)
+    controller = Hooked::Controller.new(container)
     controller.invoke(:something)
     
     assert_equal(container, scope)
@@ -96,14 +96,14 @@ class ControllerTest < Test::Unit::TestCase
       hookable(:something) { scope = self }
     end.new
     
-    controller = Hooked::Controller.new(:foo, container)
+    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(:foo)
+    controller = Hooked::Controller.new
     
     scope = nil
     controller.invoke(:something) { scope = self }
@@ -111,66 +111,124 @@ class ControllerTest < Test::Unit::TestCase
     assert_equal(self, scope)
   end
   
-  def test_hookables_and_hooks_can_use_next
-    pend
+  def test_passes_arguments_into_the_context
+    input = "asd"
+    args = []
     
-    called = []
     container = Class.new do
       include(Hooked::Container)
-      hookable(:something) { called << :something }
-      before(:something, :do_something_more) { called << :do_something_more }
-      before(:something, :do_something_else) { next; called << :do_something_else }
+      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)
     
-    controller = Hooked::Controller.new(:foo, container.new)
-    controller.invoke(:something)
-    assert_equal [:do_something_more, :something], called
+    assert_equal [input.object_id, input.object_id], args.map {|a| a.object_id }
   end
   
-  def test_hookables_and_hooks_can_use_return
-    pend
+  def test_returns_the_contexts_result
+    input = ["asd", "def"]
     
-    called = []
-    returned_arg = nil
     container = Class.new do
       include(Hooked::Container)
-      hookable(:something) { called << :something }
-      before(:something, :do_something_more) {|arg| return arg + 1; called << :do_something_more }
-      before(:something, :do_something_else) {|arg| returned_arg = arg; return; called << :do_something_else }
+      hookable(:something) {|ctx| ctx.result = [input[0]] }
+      after(:something, :do_something_else) {|ctx| ctx.result << input[1] }
     end
     
-    controller = Hooked::Controller.new(:foo, container.new)
-    fail("Doesn't reach the code after controller.invoke()")
-    controller.invoke(:something, 1)
-    assert_equal [:do_something_more, :asd], called
-    assert_equal 3, returned_arg
+    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_hookables_and_hooks_can_use_break
-    pend
+  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) { called << :something }
-      before(:something, :do_something_more) { called << :do_something_more }
-      before(:something, :do_something_else) { called << :do_something_else; break }
+      hookable(:something) {|ctx| ctx.next(2) }
     end
     
-    controller = Hooked::Controller.new(:foo, container.new)
-    controller.invoke(:something)
-    assert_equal [:do_something_more, :do_something_else], called
+    assert_throw(:hooked) do
+      Hooked::Controller.new(container.new).invoke(:something)
+    end
   end
   
-  def test_arguments_and_return_values_are_passed_in_and_out
+  def test_returns_from_the_current_invocation_when_it_catches_break
     container = Class.new do
       include(Hooked::Container)
-      hookable(:something) {|arg| arg += 1; arg }
-      before(:something, :do_something_more) {|arg| arg += 1; [arg] }
-      after(:something, :do_something_else) {|arg| arg += 1; arg }
+      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
-
-    controller = Hooked::Controller.new(:foo, container.new)
-    assert_equal 4, controller.invoke(:something, 1)
   end
 end

data/test/helper.rb

@@ -4,6 +4,7 @@ Bundler.setup(:default, :development)
 
 require "test/unit"
 require "mocha"
-require "awesome_print"
+
+require "awesome_print" rescue nil
 
 require "hooked"

data/test/hook_test.rb

@@ -1,6 +1,10 @@
-require File.dirname(__FILE__) + "/helper.rb"
+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) {}
@@ -65,31 +69,22 @@ class HookTest < Test::Unit::TestCase
       scope = self
     end
     
-    assert_raise(RuntimeError) { hook.call }
+    assert_raise(RuntimeError) { hook.call(context) }
     
     container = stub("container")
     hook.container = container
-    hook.call
+    hook.call(context)
     assert_equal(container, scope)
   end
   
-  def test_passes_arguments_to_the_block
-    args = [123, "asd"]
-    passed_args = nil
-    hook = Hooked::Hook.new(:before, :foo, {}, stub("container")) do |*args|
-      passed_args = args
-    end
-    
-    hook.call(args)
-    assert_equal(args, passed_args)
-  end
-  
-  def test_passes_blocks_return_to_the_caller
-    ret = 123
-    hook = Hooked::Hook.new(:before, :foo, {}, stub("container")) do
-      ret
+  def test_passes_context_to_the_block
+    ctx = context
+    ctx2 = nil
+    hook = Hooked::Hook.new(:before, :foo, {}, stub("container")) do |c|
+      ctx2 = c
     end
     
-    assert_equal(ret, hook.call)
+    hook.call(ctx)
+    assert_equal(ctx, ctx2)
   end
 end

data/test/hookable_test.rb

@@ -1,6 +1,10 @@
-require File.dirname(__FILE__) + "/helper.rb"
+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) {}
@@ -35,7 +39,7 @@ class HookableTest < Test::Unit::TestCase
       scope = self
     end
     
-    hookable.call
+    hookable.call(context)
     assert_equal container, scope
   end
   
@@ -45,27 +49,18 @@ class HookableTest < Test::Unit::TestCase
       scope = self
     end
     
-    hookable.call
+    hookable.call(context)
     assert_equal self, scope
   end
   
-  def test_passes_arguments_to_the_block
-    args = [123, "asd"]
-    passed_args = nil
-    hookable = Hooked::Hookable.new(:foo) do |*args|
-      passed_args = args
-    end
-    
-    hookable.call(args)
-    assert_equal(args, passed_args)
-  end
-  
-  def test_passes_block_return_to_the_caller
-    ret = 123
-    hookable = Hooked::Hookable.new(:foo) do
-      ret
+  def test_passes_context_to_the_block
+    ctx = context
+    ctx2 = nil
+    hookable = Hooked::Hookable.new(:foo) do |c|
+      ctx2 = c
     end
     
-    assert_equal(ret, hookable.call)
+    hookable.call(ctx)
+    assert_equal(ctx, ctx2)
   end
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: hooked
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Lars Gierth
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-25 00:00:00 +01:00
+date: 2010-12-20 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -40,7 +38,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -54,16 +51,15 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
   type: :development
   version_requirements: *id003
 description: |-
-  hooked makes AOP a breeze. It lets you define and invoke
-                       code that other gems or parts of your application can hook
-                       onto. Supported hooks are before, after and around.
+  Hooked makes AOP a breeze. It lets you define and invoke
+                       code that gems or other parts of your application can hook
+                       onto.
 email: 
 - lars.gierth@gmail.com
 executables: []
@@ -80,6 +76,7 @@ files:
 - hooked.gemspec
 - lib/hooked.rb
 - lib/hooked/container.rb
+- lib/hooked/context.rb
 - lib/hooked/controller.rb
 - lib/hooked/hook.rb
 - lib/hooked/hookable.rb
@@ -103,7 +100,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -112,7 +108,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -122,6 +117,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Ruby library for Aspect Oriented Programming
+summary: Ruby Library For Aspect Oriented Programming
 test_files: []