teejayvanslyke-gazer 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-02-14
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/gazer.rb
+script/console
+script/destroy
+script/generate
+spec/gazer_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on gazer, see http://gazer.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,79 @@
+= gazer
+
+* http://github.com/teejayvanslyke/gazer
+
+== DESCRIPTION:
+
+Poor man's aspect-oriented programming for Ruby.
+
+== FEATURES/PROBLEMS:
+
+* Elegant DSL
+* before & after pointcuts.
+* Rails integration.
+
+== ROADMAP:
+
+* Locking down Object monkeypatching scheme.
+* More selectors and pointcuts.
+* Regular-expression-based pointcuts.
+* <tt>:only</tt> and <tt>except</tt> options for Rails helper.
+
+== SYNOPSIS:
+
+Gazer's DSL is accessible to subclasses of Gazer::Aspect::Base.
+
+  class LoggingAspect < Gazer::Aspect::Base
+
+    before instances_of(Article) => :create do |point|
+      puts "Creating article"
+    end
+
+    after instances_of([Article, Comment]) => :save do |point|
+      puts "Saved #{point.object}."
+    end
+
+  end
+
+I have also provided a Rails generator for generating aspects for 
+your project.  Simply execute the following:
+
+  $ script/generate aspect logging
+
+A template will be created at <tt>app/aspects/logging_aspect.rb</tt> 
+for your aspect-oriented pleasure.
+
+To include an aspect for a given controller, use the aspect class method:
+
+  class MyController < ApplicationController
+    aspect :logging
+  end
+
+== INSTALL:
+
+  $ sudo gem install teejayvanslyke-gazer
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 T.J. VanSlyke
+
+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/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 0

data/lib/gazer.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+module Gazer
+  VERSION = '0.0.1'
+end
+
+require 'gazer/object_extensions'
+require 'gazer/aspect'
+require 'gazer/rails' if defined?(RAILS_ENV)
+

data/lib/gazer/aspect.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'aspect/join_point'
+require 'aspect/pointcut'
+require 'aspect/base'
+require 'aspect/filter'
+require 'aspect/instance_of'
+

data/lib/gazer/aspect/base.rb

@@ -0,0 +1,38 @@
+
+module Gazer
+  module Aspect
+    class Base
+
+      class << self
+
+        def add_pointcut(pointcut)
+          @pointcuts ||= []
+          @pointcuts << pointcut
+        end
+
+        attr_accessor :pointcuts
+
+        def instances_of(klass)
+          InstancesOf.new(klass)
+        end
+
+        def apply!
+          pointcuts.each do |pc| pc.apply! end
+        end
+
+        def before(selector, &block)
+          add_pointcut BeforePointcut.new(selector, &block)
+        end
+
+        def after(selector, &block)
+          add_pointcut AfterPointcut.new(selector, &block)
+        end
+
+        def around(selector, &block)
+          add_pointcut AroundPointcut.new(selector, &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/gazer/aspect/filter.rb

@@ -0,0 +1,38 @@
+module Gazer
+  module Aspect
+    class Filter
+      def initialize(expr)
+        if expr.is_a?(Array)
+          @types = expr
+        else
+          @types = [ expr ]
+        end
+      end
+
+      def advise_before(sym, &block)
+        @types.each {|t| t.advise_before(sym, &block)}
+      end
+
+      def advise_around(sym, &block)
+        @types.each {|t| t.advise_around(sym, &block)}
+      end
+
+      def advise_after(sym, &block)
+        @types.each {|t| t.advise_after(sym, &block)}
+      end
+
+      def advise_instances_before(sym, &block)
+        @types.each {|t| t.advise_instances_before(sym, &block)}
+      end
+
+      def advise_instances_around(sym, &block)
+        @types.each {|t| t.advise_instances_around(sym, &block)}
+      end
+
+      def advise_instances_after(sym, &block)
+        @types.each {|t| t.advise_instances_after(sym, &block)}
+      end
+    end
+  end
+end
+

data/lib/gazer/aspect/instance_of.rb

@@ -0,0 +1,21 @@
+module Gazer
+  module Aspect
+    class InstancesOf
+      def initialize(filter)
+        @filter = Filter.new(filter)
+      end
+
+      def advise_before(sym, &block)
+        @filter.advise_instances_before(sym, &block)
+      end
+
+      def advise_around(sym, &block)
+        @filter.advise_instances_around(sym, &block)
+      end
+
+      def advise_after(sym, &block)
+        @filter.advise_instances_after(sym, &block)
+      end
+    end
+  end
+end

data/lib/gazer/aspect/join_point.rb

@@ -0,0 +1,8 @@
+require 'ostruct'
+
+module Gazer
+  module Aspect
+    class JoinPoint < OpenStruct; end
+  end
+end
+

data/lib/gazer/aspect/pointcut.rb

@@ -0,0 +1,34 @@
+module Gazer
+  module Aspect
+    class Pointcut
+      def initialize(selector, &block)
+        @selector = selector
+        @block    = block
+      end
+    end
+
+    class BeforePointcut < Pointcut
+      def apply!
+        @selector.keys.each do |key|
+          Filter.new(key).advise_before(@selector[key], &@block)
+        end
+      end
+    end
+
+    class AfterPointcut < Pointcut
+      def apply!
+        @selector.keys.each do |key|
+          Filter.new(key).advise_after(@selector[key], &@block)
+        end
+      end
+    end
+
+    class AroundPointcut < Pointcut
+      def apply!
+        @selector.keys.each do |key|
+          Filter.new(key).advise_around(@selector[key], &@block)
+        end
+      end
+    end
+  end
+end

data/lib/gazer/object_extensions.rb

@@ -0,0 +1,141 @@
+module Gazer
+
+  module ObjectExtensions
+
+    module ClassMethods
+      def advise(sym, block)
+        @advice ||= {}
+        @advice[sym] ||= []
+        @advice[sym] << block
+      end
+
+      def advice
+        @advice ||= {}
+      end
+
+      def advice_for(sym)
+        @advice[sym]
+      end
+
+      def backup_method(sym)
+        id = "__#{sym}_#{backup_methods_for(sym).size}__"
+        alias_method id, sym        # Backup original method
+        private id                  # Make backup private
+        @backup_methods_for ||= {}
+        @backup_methods_for[sym] ||= []
+        @backup_methods_for[sym] << id
+        return id
+      end
+
+      def backup_methods_for(sym)
+        @backup_methods_for ||= {}
+        @backup_methods_for[sym] ||= []
+      end
+
+      def unadvise_all
+        advice.each do |sym, arr|
+          code = <<-CODE
+            class << self
+              alias_method #{sym.inspect}, '__#{sym}_0__'
+              public #{sym.inspect}
+            end
+          CODE
+          instance_eval(code)
+        end
+      end
+
+      def advise_before(sym, &block)
+        return unless respond_to?(sym)
+        advise(sym, block)
+        code = <<-CODE
+          class << self
+            hook = backup_method(#{sym.inspect})
+            define_method #{sym.inspect} do |*args|    
+              self.advice_for(#{sym.inspect}).last.call(
+                Gazer::Aspect::JoinPoint.new(:object => self,
+                              :method => #{sym.inspect}, 
+                              :args   => args))
+              __send__ hook, *args  # Invoke backup
+            end
+          end
+        CODE
+        instance_eval(code)
+      end
+
+      def advise_around(sym, &block)
+        return unless respond_to?(sym)
+        advise(sym, block)
+        code = <<-CODE
+          class << self
+            hook = backup_method(#{sym.inspect})
+            define_method #{sym.inspect} do |*args|    
+              self.advice_for(#{sym.inspect}).last.call(
+                Gazer::Aspect::JoinPoint.new(:object => self,
+                              :method => #{sym.inspect}, 
+                              :args   => args))
+              __send__ hook, *args  # Invoke backup
+            end
+          end
+        CODE
+        instance_eval(code)
+      end
+
+      def advise_after(sym, &block)
+        return unless respond_to?(sym)
+        advise(sym, block)
+        code = <<-CODE
+          class << self
+            hook = backup_method(#{sym.inspect})
+            define_method #{sym.inspect} do |*args|    
+              rval = __send__ hook, *args  # Invoke backup
+              self.advice_for(#{sym.inspect}).last.call(
+                Gazer::Aspect::JoinPoint.new(:object => self,
+                              :method => #{sym.inspect}, 
+                              :args   => args))
+              return rval
+            end
+          end
+        CODE
+        instance_eval(code)
+      end
+
+      def advise_instances_before(sym, &block)
+        hook = backup_method(sym)
+        define_method sym do |*args|    
+          block.call(
+            Gazer::Aspect::JoinPoint.new(:object => self,
+                          :method => sym, 
+                          :args   => args))
+          __send__ hook, *args  # Invoke backup
+        end
+      end
+
+      def advise_instances_around(sym, &block)
+        hook = backup_method(sym)
+        define_method sym do |*args|    
+          block.call(
+            Gazer::Aspect::JoinPoint.new(:object => self,
+                          :method => sym, 
+                          :args   => args))
+          __send__ hook, *args  
+        end
+      end
+
+      def advise_instances_after(sym, &block)
+        hook = backup_method(sym)
+        define_method sym do |*args|    # Replace method
+          rval = __send__ hook, *args  # Invoke backup
+          block.call(
+            Gazer::Aspect::JoinPoint.new(:object => self,
+                          :method => sym, 
+                          :args   => args))
+          return rval
+        end
+      end
+    end
+
+  end
+
+end
+
+Object.extend(Gazer::ObjectExtensions::ClassMethods)

data/lib/gazer/rails.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rails/action_controller'

data/lib/gazer/rails/action_controller.rb

@@ -0,0 +1,19 @@
+module Gazer
+  module Rails
+    module ActionController
+      module ClassMethods
+        def aspect(*args)
+          args.each do |aspect|
+            define_method "__apply_#{aspect}_aspect__" do
+              eval("#{aspect.to_s.classify}Aspect.apply!")
+            end
+
+            before_filter "__apply_#{aspect}_aspect__"
+          end
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.extend(Gazer::Rails::ActionController::ClassMethods)

data/spec/gazer_spec.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+
+def message(text) end
+describe Gazer do
+
+  include Gazer
+
+  class Dog
+
+    def self.create
+      new
+    end
+
+    def bark!
+      "woof!"
+    end
+
+  end
+
+  class Cat
+    def hiss!
+    end
+
+    def run_away!
+    end
+
+    def self.get_scared
+    end
+  end
+
+  describe "advising instance methods" do
+
+    describe "before the method call" do
+
+      it "executes the advice provided before the method is executed" do
+
+        @cat = Cat.new
+
+        Dog.advise_instances_before(:bark!) do |point|
+          @cat.hiss!
+        end
+
+        @dog = Dog.new
+        @cat.should_receive(:hiss!)
+        @dog.bark! 
+
+      end
+
+    end
+
+    describe "after the method call" do
+
+      it "executes the advice provided after the method is executed" do
+
+        @cat = Cat.new
+
+        Dog.advise_instances_after(:bark!) do |point|
+          @cat.run_away!
+        end
+
+        @dog = Dog.new
+        @cat.should_receive(:run_away!)
+        @dog.bark! 
+      end
+
+    end
+
+  end
+
+  describe "advising class methods" do
+
+    describe "before the method call" do
+
+      it "executes the advice provided before the method is executed" do
+
+        Dog.unadvise_all
+        Cat.unadvise_all
+
+        Dog.advise_before(:create) do |point|
+          Cat.get_scared
+        end
+
+        Cat.should_receive(:get_scared)
+        @dog = Dog.create
+
+      end
+
+    end
+
+    describe "after the method call" do
+
+      it "executes the advice provided after the method is executed" do
+
+        Dog.unadvise_all
+
+        Dog.advise_after(:create) do |point|
+          Cat.get_scared
+        end
+
+        Cat.should_receive(:get_scared)
+        @dog = Dog.create
+
+      end
+
+    end
+
+    describe "after instantiating an instance already" do
+
+      before :each do
+        Dog.unadvise_all
+        Cat.unadvise_all
+
+        @dog = Dog.new
+        @cat = Cat.new
+      end
+
+      it "does not execute the advice if none has been defined" do
+        @cat.should_not_receive(:hiss!)
+        @dog.bark!
+      end
+
+      it "executes the advice provided on the already-instantiated instance" do
+        Dog.advise_instances_after(:bark!) do |point|
+          @cat.hiss!
+        end
+
+        @cat.should_receive(:hiss!)
+        @dog.bark!
+      end
+
+    end
+
+  end
+
+  describe "aspect DSL" do
+    class TestAspect < Gazer::Aspect::Base
+      before instances_of(Dog) => :bark! do |point|
+        Cat.get_scared
+      end
+
+      after instances_of(Cat) => :hiss! do |point|
+        Dog.new
+      end
+
+      before Dog => :create do |point|
+        message("creating #{point.object.name}")
+      end
+
+      def self.message(text)
+      end
+    end
+
+    before :all do
+      TestAspect.apply!
+    end
+
+    before :each do 
+      @dog = Dog.new
+      @cat = Cat.new
+
+    end
+
+    it "makes the cat run away before the dog barks" do
+      Cat.should_receive(:get_scared)
+      @dog.bark!
+    end
+
+    it "creates a new dog after the cat hisses" do
+      Dog.should_receive(:new)
+      @cat.hiss!
+    end
+
+    it "messages that we are creating a new Dog" do
+      TestAspect.should_receive(:message).with("creating Dog")
+      Dog.create
+    end
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'gazer'

data/test/test_aspect_generator.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), "test_generator_helper.rb")
+
+require 'rails_generator'
+
+class TestAspectGenerator < Test::Unit::TestCase
+  include RubiGen::GeneratorTestHelper
+
+  def setup
+    bare_setup
+  end
+
+  def teardown
+    bare_teardown
+  end
+
+  # Some generator-related assertions:
+  #   assert_generated_file(name, &block) # block passed the file contents
+  #   assert_directory_exists(name)
+  #   assert_generated_class(name, &block)
+  #   assert_generated_module(name, &block)
+  #   assert_generated_test_for(name, &block)
+  # The assert_generated_(class|module|test_for) &block is passed the body of the class/module within the file
+  #   assert_has_method(body, *methods) # check that the body has a list of methods (methods with parentheses not supported yet)
+  #
+  # Other helper methods are:
+  #   app_root_files - put this in teardown to show files generated by the test method (e.g. p app_root_files)
+  #   bare_setup - place this in setup method to create the APP_ROOT folder for each test
+  #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or APP_ROOT folder after each test
+
+  def test_generator_without_options
+    name = "myapp"
+    run_generator('aspect', [name], sources)
+    assert_directory_exists "some/directory"
+    assert_generated_file   "some_file"
+  end
+
+  private
+  def sources
+    [RubiGen::PathSource.new(:test, File.join(File.dirname(__FILE__),"..", generator_path))
+    ]
+  end
+
+  def generator_path
+    "rails_generators"
+  end
+end

data/test/test_generator_helper.rb

@@ -0,0 +1,29 @@
+begin
+  require File.dirname(__FILE__) + '/test_helper'
+rescue LoadError
+  require 'test/unit'
+end
+require 'fileutils'
+
+# Must set before requiring generator libs.
+TMP_ROOT = File.dirname(__FILE__) + "/tmp" unless defined?(TMP_ROOT)
+PROJECT_NAME = "myproject" unless defined?(PROJECT_NAME)
+app_root = File.join(TMP_ROOT, PROJECT_NAME)
+if defined?(APP_ROOT)
+  APP_ROOT.replace(app_root)
+else
+  APP_ROOT = app_root
+end
+if defined?(RAILS_ROOT)
+  RAILS_ROOT.replace(app_root)
+else
+  RAILS_ROOT = app_root
+end
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/helpers/generator_test_helper'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: teejayvanslyke-gazer
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- T.J. VanSlyke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-17 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: poor man's aspect-oriented programming for Ruby
+email: T.J. VanSlyke
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- VERSION.yml
+- lib/gazer
+- lib/gazer/aspect
+- lib/gazer/aspect/base.rb
+- lib/gazer/aspect/filter.rb
+- lib/gazer/aspect/instance_of.rb
+- lib/gazer/aspect/join_point.rb
+- lib/gazer/aspect/pointcut.rb
+- lib/gazer/aspect.rb
+- lib/gazer/object_extensions.rb
+- lib/gazer/rails
+- lib/gazer/rails/action_controller.rb
+- lib/gazer/rails.rb
+- lib/gazer.rb
+- test/test_aspect_generator.rb
+- test/test_generator_helper.rb
+- spec/gazer_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/teejayvanslyke/gazer
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: poor man's aspect-oriented programming for Ruby
+test_files: []
+