hooked 0.1.2 → 0.2.0

data/spec/hook_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Hooked::Hook do
+  describe "#initialize" do
+    it "sets the pointcut and creates the graph" do
+      pointcut, graph = double("pointcut"), double("graph")
+      Hooked::Graph.stub :new => graph
+      
+      obj = Hooked::Hook.new pointcut
+      obj.pointcut.should == pointcut
+      obj.graph.should == graph
+    end
+  end
+  
+  describe "#add_aspect" do
+    it "adds an aspect to the graph" do
+      args = [:before, proc {}, {:after => [proc {}]}]
+      aspect = double "aspect"
+      obj = Hooked::Hook.new double("pointcut")
+      
+      Hooked::Aspect.should_receive(:new).with(*args).and_return aspect
+      obj.graph.should_receive(:<<).with aspect
+      obj.add_aspect *args
+    end
+  end
+  
+  describe "#call" do
+    it "rebuilds the chain if it hasn't been built yet or the graph changed" do
+      obj = Hooked::Hook.new double("pointcut")
+      chain = stub "chain", :call => nil
+      
+      obj.graph.stub :changed? => false
+      obj.should_receive(:build_chain).once.and_return chain
+      obj.call
+      
+      obj.call
+      
+      obj.graph.stub :changed? => true
+      obj.should_receive(:build_chain).once.and_return chain
+      obj.call
+    end
+    
+    it "forwards to the chain" do
+      obj = Hooked::Hook.new double("pointcut")
+      
+      chain = stub "chain"
+      obj.stub :build_chain => chain
+      chain.should_receive(:call).with("foo").and_return "bar"
+      
+      obj.call("foo").should == "bar"
+    end
+  end
+  
+  describe "#build_chain" do
+    it "builds the chain" do
+      obj = Hooked::Hook.new double("pointcut")
+      
+      aspect = Struct.new :pos, :pointcut
+      obj.graph.should_receive :sort
+      obj.graph.stub :output => [aspect.new(1), aspect.new(2), aspect.new(3)]
+      chain = obj.build_chain
+      
+      chain.pos.should == 1
+      chain.pointcut.pos.should == 2
+      chain.pointcut.pointcut.pos.should == 3
+      chain.pointcut.pointcut.pointcut.should == obj.pointcut
+    end
+  end
+end

data/spec/hooked_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Hooked do
+  klass = Class.new do
+    include Hooked
+    def foo; end
+  end
+  
+  [:before, :after, :around].each do |type|
+    describe "##{type}" do
+      it "hooks the method" do
+        obj = klass.new
+        obj.stub :hooked => {:foo => double("hooked", :add_aspect => nil)}
+        
+        obj.should_receive(:hook!).with(:foo)
+        obj.send type, :foo, nil
+      end
+      
+      it "adds an aspect to the hook" do
+        obj = klass.new
+        advice, deps = stub("advice"), stub("deps")
+        
+        obj.hook! :foo
+        obj.hooked[:foo].should_receive(:add_aspect).with type, advice, deps
+        
+        obj.send type, :foo, advice, deps
+      end
+    end
+  end
+  
+  describe "#hook!" do
+    it "replaces the original method with a hook" do
+      obj = klass.new
+      args, result = ["bar", 123], stub("result")
+
+      obj.hook! :foo
+      obj.hooked[:foo].should_receive(:call).with(*args).and_return result
+      obj.foo(*args).should == result
+    end
+    
+    it "doesn't hook a method twice" do
+      obj = klass.new
+      obj.hook! :foo
+      
+      Hooked::Hook.should_not_receive :new
+      obj.hook! :foo
+    end
+  end
+  
+  describe "#unhook!" do
+    it "brings the original back in place" do
+      obj = klass.new
+      
+      obj.hook! :foo
+      hook = obj.hooked[:foo]
+      obj.unhook! :foo
+      
+      hook.should_not_receive :call
+      obj.foo
+      
+      obj.hooked[:foo].should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "bundler"
+Bundler.setup :default, :development
+
+require "hooked"
+
+require "awesome_print"

metadata

@@ -1,64 +1,32 @@
 --- !ruby/object:Gem::Specification 
 name: hooked
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-    - 0
-    - 1
-    - 2
-  version: 0.1.2
+  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors: 
-  - Lars Gierth
+- Lars Gierth
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-01-13 00:00:00 +01:00
+date: 2011-04-20 00:00:00 +02:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: depression
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :runtime
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: test-unit
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id002
-  - !ruby/object:Gem::Dependency 
-    name: mocha
-    prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id003
-description: |-
-  Hooked makes AOP a breeze. It lets you define and invoke
-                       code that gems or other parts of your application can hook
-                       onto.
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+description: Hooked lets you transparently aspectify your methods and blocks.
 email: 
-  - lars.gierth@gmail.com
+- lars.gierth@gmail.com
 executables: []
 
 extensions: []
@@ -66,23 +34,22 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-  - Gemfile
-  - LICENSE
-  - README.md
-  - Rakefile
-  - 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
-  - lib/hooked/version.rb
-  - test/container_test.rb
-  - test/controller_test.rb
-  - test/helper.rb
-  - test/hook_test.rb
-  - test/hookable_test.rb
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hooked.gemspec
+- lib/hooked.rb
+- lib/hooked/aspect.rb
+- lib/hooked/graph.rb
+- lib/hooked/hook.rb
+- lib/hooked/version.rb
+- spec/aspect_spec.rb
+- spec/graph_spec.rb
+- spec/hook_spec.rb
+- spec/hooked_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/hooked
 licenses: []
@@ -91,31 +58,31 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 208393711
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 208393711
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Ruby Library For Aspect Oriented Programming
-test_files: 
-  - test/container_test.rb
-  - test/controller_test.rb
-  - test/helper.rb
-  - test/hook_test.rb
-  - test/hookable_test.rb
+summary: Aspect Orientation Made Simple
+test_files: []
+

data/lib/hooked/container.rb

@@ -1,52 +0,0 @@
-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/context.rb

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

@@ -1,80 +0,0 @@
-module Hooked
-  Result = Struct.new(:type, :value)
-  
-  class Controller
-    attr_reader :containers, :hookables, :hooks
-    
-    def initialize(*containers)
-      @containers = []
-      @hookables = {}
-      @hooks = {}
-      
-      add(*containers)
-      refresh
-    end
-    
-    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
-        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 = nil, &block)
-      if block
-        hookable = Hookable.new(name, &block)
-      else
-        hookable = hookables[name] || raise("Unknown hookable: #{name}")
-      end
-      
-      context = Context.new(args)
-      chain = (hooks[name] || []).reverse.inject(hookable) do |next_item, item|
-        proc {|ctx| call_hook(item, next_item, ctx) }
-      end
-      
-      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
-    
-    def call_hook(hook, hookable, context)
-      wrap { hook.call(context) } if hook.before?
-      
-      wrap do
-        if hook.around?
-          hook.call(context, hookable)
-        else
-          hookable.call(context)
-        end
-      end
-      
-      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/hookable.rb

@@ -1,20 +0,0 @@
-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(context)
-      if container
-        container.instance_exec(context, &@block)
-      else
-        @block.call(context)
-      end
-    end
-  end
-end

data/test/container_test.rb

@@ -1,71 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-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