hooked 0.0.1

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "awesome_print"
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Lars Gierth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+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.
+
+To Do
+-----
+
+* Skip hooks
+* Control flow (return, next, break)

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.test_files = FileList["test/*_test.rb"]
+end

data/hooked.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hooked/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hooked"
+  s.version     = Hooked::VERSION
+  s.date        = Date.today.to_s
+  s.platform    = Gem::Platform::RUBY
+  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.add_dependency "depression"
+  
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "mocha"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc"]
+  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"]
+end

data/lib/hooked.rb

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

data/lib/hooked/container.rb

@@ -0,0 +1,52 @@
+module Hooked
+  module Container
+    attr_accessor :hooked
+    
+    def hookable(name, *args, &block)
+      hooked.invoke(name, *args, &block)
+    end
+    
+    module ClassMethods
+      attr_reader :hookables, :hooks
+      
+      def hookable(name, &block)
+        @hookables << Hookable.new(name, &block)
+      end
+      
+      def hook(type, hookable, name, opts = {}, &block)
+        opts[:before] ||= []
+        unless opts[:before].respond_to?(:each) or opts[:before] == :all
+          opts[:before] = [opts[:before]]
+        end
+        
+        opts[:after] ||= []
+        unless opts[:after].respond_to?(:each) or opts[:after] == :all
+          opts[:after] = [opts[:after]]
+        end
+        
+        @hooks[hookable] ||= []
+        @hooks[hookable] << Hook.new(type, name, opts, &block)
+      end
+      
+      def before(*args, &block)
+        hook(:before, *args, &block)
+      end
+      
+      def around(*args, &block)
+        hook(:around, *args, &block)
+      end
+      
+      def after(*args, &block)
+        hook(:after, *args, &block)
+      end
+    end
+    
+    def self.included(klass)
+      klass.class_eval do
+        extend(ClassMethods)
+        @hookables = []
+        @hooks = {}
+      end
+    end
+  end
+end

data/lib/hooked/controller.rb

@@ -0,0 +1,92 @@
+module Hooked
+  Result = Struct.new(:type, :value)
+  
+  class Controller
+    attr_reader :name, :containers, :hookables, :hooks
+    
+    def initialize(name, *containers)
+      @name = name
+      
+      @containers = []
+      @hookables = {}
+      @hooks = {}
+      
+      add(*containers)
+      refresh
+    end
+    
+    def add(*containers)
+      @containers.push(*containers)
+      containers.each do |c|
+        c.class.hookables.each do |hkbl|
+          hkbl.container = c
+          hookables[hkbl.name] = hkbl
+        end
+        c.class.hooks.each do |hkbl_name, hs|
+          hs.each {|h| h.container = c }
+          @hooks[hkbl_name] ||= []
+          @hooks[hkbl_name].push(*hs)
+        end
+      end
+    end
+    
+    def refresh
+      hooks.each {|hkbl_name, hs| hooks[hkbl_name] = Depression.process(hs) }
+    end
+    
+    def invoke(name, *args, &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)
+      end
+      if (result[0] rescue nil) == :hooked_abort_chain
+        result[1]
+      else
+        result
+      end
+    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?
+      
+      result = catch(:hooked) do
+        if hook.around?
+          hook.call(hookable, *args)
+        else
+          hookable.call(*args)
+        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
+    end
+  end
+end

data/lib/hooked/hook.rb

@@ -0,0 +1,33 @@
+module Hooked
+  class Hook
+    attr_reader :type, :name, :relations
+    attr_accessor :container, :weight
+    
+    def initialize(type, name, relations = {}, container = nil, &block)
+      raise ArgumentError, "Invalid hook type `#{type}'" unless [
+        :before, :after, :around
+      ].include?(type.to_sym)
+      @type, @name, @relations = type.to_sym, name.to_sym, relations
+
+      raise ArgumentError, "Hooked::Hookable.new expects a block." unless block
+      @container, @block = container, block
+    end
+    
+    def call(*args)
+      raise RuntimeError, "No container set for hook `#{name}'" unless container
+      container.instance_exec(*args, &@block)
+    end
+    
+    def before?
+      type == :before
+    end
+    
+    def after?
+      type == :after
+    end
+    
+    def around?
+      type == :around
+    end
+  end
+end

data/lib/hooked/hookable.rb

@@ -0,0 +1,20 @@
+module Hooked
+  class Hookable
+    attr_reader :name
+    attr_accessor :container
+    
+    def initialize(name, container = nil, &block)
+      raise ArgumentError, "Hooked::Hookable.new expects a block." unless block
+      
+      @name, @container, @block = name.to_sym, container, block
+    end
+    
+    def call(*args)
+      if container
+        container.instance_exec(*args, &@block)
+      else
+        @block.call(*args)
+      end
+    end
+  end
+end

data/lib/hooked/version.rb

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

data/test/container_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class ContainerTest < Test::Unit::TestCase
+  def setup
+    @container = Class.new { include(Hooked::Container) }
+  end
+  
+  def teardown
+    Mocha::Mockery.instance.teardown
+  end
+  
+  def test_has_hookables
+    block = proc {}
+    @container.hookable(:foo, &block)
+    
+    assert_equal :foo, @container.hookables[0].name
+    assert @container.hookables[0].respond_to?(:call)
+  end
+  
+  def test_has_a_shorthand_method_for_invoking_hookables
+    container = @container.new
+    container.hooked = stub("controller") do
+      expects(:invoke).once.with(:foo, 123).returns("asdf")
+    end
+    
+    assert_equal "asdf", container.hookable(:foo, 123)
+  end
+  
+  def test_has_hooks
+    block = proc {}
+    @container.hook(:after, :work, :start_revolution, {
+      :before => :utopia
+    }, &block)
+    @container.hook(:around, :foo, :do_something, {
+      :before => :all,
+      :after => [:do_something_else, :snooze]
+    }, &block)
+    
+    h = @container.hooks[:work][0]
+    assert_equal :after, h.type
+    assert_equal :start_revolution, h.name
+    assert_equal({
+      :before => [:utopia],
+      :after => []
+    }, h.relations)
+    assert h.respond_to?(:call)
+    assert h.respond_to?(:container=)
+    
+    h = @container.hooks[:foo][0]
+    assert_equal :around, h.type
+    assert_equal :do_something, h.name
+    assert_equal({
+      :before => :all,
+      :after => [:do_something_else, :snooze]
+    }, h.relations)
+  end
+  
+  def test_has_shorthand_methods_for_before_around_and_after
+    args = [:foo, :bar, {:before => :all}]
+    block = proc {}
+    
+    @container.expects(:hook).once.with(:before, *args)
+    @container.before(*args, &block)
+    
+    @container.expects(:hook).once.with(:around, *args)
+    @container.around(*args, &block)
+    
+    @container.expects(:hook).once.with(:after, *args)
+    @container.after(*args, &block)
+  end
+end

data/test/controller_test.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+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_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.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(:baz, *@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(:baz, container.new)
+    assert_equal order, controller.hooks[:foo].map {|h| h.name }
+    
+    controller = Hooked::Controller.new(:baz)
+    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(:foo, *@containers[1..2])
+    assert_equal @containers[1], controller.hooks[:foo][0].container
+    assert_equal @containers[2], controller.hookables[:foo].container
+  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(:foo, 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(:foo, container)
+    controller.invoke(:something)
+    
+    assert_equal(container, scope)
+  end
+  
+  def test_invokes_dynamic_hookables_in_their_original_scope
+    controller = Hooked::Controller.new(:foo)
+    
+    scope = nil
+    controller.invoke(:something) { scope = self }
+    
+    assert_equal(self, scope)
+  end
+  
+  def test_hookables_and_hooks_can_use_next
+    pend
+    
+    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 }
+    end
+    
+    controller = Hooked::Controller.new(:foo, container.new)
+    controller.invoke(:something)
+    assert_equal [:do_something_more, :something], called
+  end
+  
+  def test_hookables_and_hooks_can_use_return
+    pend
+    
+    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 }
+    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
+  end
+  
+  def test_hookables_and_hooks_can_use_break
+    pend
+    
+    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) { called << :do_something_else; break }
+    end
+    
+    controller = Hooked::Controller.new(:foo, container.new)
+    controller.invoke(:something)
+    assert_equal [:do_something_more, :do_something_else], called
+  end
+  
+  def test_arguments_and_return_values_are_passed_in_and_out
+    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 }
+    end
+
+    controller = Hooked::Controller.new(:foo, container.new)
+    assert_equal 4, controller.invoke(:something, 1)
+  end
+end

data/test/helper.rb

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

data/test/hook_test.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + "/helper.rb"
+
+class HookTest < Test::Unit::TestCase
+  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 }
+    
+    container = stub("container")
+    hook.container = container
+    hook.call
+    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
+    end
+    
+    assert_equal(ret, hook.call)
+  end
+end

data/test/hookable_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + "/helper.rb"
+
+class HookableTest < Test::Unit::TestCase
+  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
+    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
+    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
+    end
+    
+    assert_equal(ret, hookable.call)
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: hooked
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: depression
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    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.
+email: 
+- lars.gierth@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hooked.gemspec
+- lib/hooked.rb
+- lib/hooked/container.rb
+- lib/hooked/controller.rb
+- lib/hooked/hook.rb
+- lib/hooked/hookable.rb
+- lib/hooked/version.rb
+- test/container_test.rb
+- test/controller_test.rb
+- test/helper.rb
+- test/hook_test.rb
+- test/hookable_test.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/hooked
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby library for Aspect Oriented Programming
+test_files: []
+