cuts 0.0.4 → 0.1.0

data/MANIFEST

@@ -1,22 +1,21 @@
-Rakefile
+lib
+meta
 test
-test/test_cut.rb
-test/test_aop.rb
-NOTES
+Rakefile
+RELEASE
 README
 HISTORY
-meta
+VERSION
+COPYING
+lib/cuts.rb
+lib/cuts
+lib/cuts/aop.rb
+lib/cuts/cut.rb
 meta/created
 meta/homepage
 meta/summary
 meta/abstract
 meta/license
-meta/requires
 meta/contact
-lib
-lib/cuts.rb
-lib/cuts
-lib/cuts/aop.rb
-lib/cuts/cut.rb
-VERSION
-COPYING
+test/test_cut.rb
+test/test_aop.rb

data/README

@@ -11,13 +11,9 @@ Cuts is an expiremental implementation of cut-based AOP for Ruby.
 
 == RELEASE NOTES
 
-Please see NOTES file.
+Please see RELEASE file.
 
 
-== RECENT CHANGES
-
-Please see CHANGES file.
-
 
 == HOW TO INSTALL
 
@@ -27,25 +23,27 @@ To install with RubyGems simply open a console and type:
 
   gem install cuts
 
-To manually installation, download the tgz package and type:
+To manually installation, you will need the Ruby Setup package
+(http://setup.rubyforge.org). Then download the tgz package
+and type:
+
+  $ tar -xvzf cuts-x.y.z.tgz
+  $ cd cuts-x.y.z.tgz
+  $ sudo setup.rb
 
-  tar -xvzf cuts-x.y.z.tgz
-  cd cuts-x.y.z.tgz
-  rake config
-  rake setup
-  rake install
 
 
 == USAGE
 
-Describe how to use your library or application here.
+Please see RDoc API documentation.
+
 
 
 == LICENSE
 
-  Copyright (c) 2008 
+Copyright (c) 2008 TigerOps
 
-  This program is ditributed unser the terms of the MIT license.
+This program is ditributed unser the terms of the LGPL license.
 
-  Please see COPYING file.
+Please see COPYING file.
 

data/RELEASE

@@ -0,0 +1,24 @@
+This release completel overhauls how cuts are
+implemented.
+
+Before, cuts where overriding the constant of the
+original class and redirecting class changes
+(define_method, alias_method, etc.) to the original
+class. This works, and is technically more true to
+the core idea of Cuts, but it is rather fragile --
+getting a handle on the Cut vs. the Cut Class b/c
+tricky.
+
+The new implementation simply creates a module for
+a cut instead, and then used #extend on objects 
+upon instantiation. The end result is less dynamic
+(cuts need to be defined up front), but it is more
+stable. As long as #new, when overriden, is done so
+properly (ie. use super or copy the cut extension
+logic) everthing will work as expected.
+
+
+### 0.1.0 / 2008-11-24
+
+* Overhauled underlying implementation.
+

data/VERSION

@@ -1 +1 @@
-cuts 0.0.4 alpha (2008-09-18)
+cuts 0.1.0 beta (2008-11-24)

data/lib/cuts/aop.rb

@@ -13,8 +13,6 @@
 #
 #    - Can JointPoint and Target be the same class?
 
-#require 'facets/kernel/object'
-#require 'facets/module/methods'
 require 'cuts/cut'
 
 #
@@ -38,7 +36,7 @@ class Aspect < Module
 
 end
 
-#
+# TODO: pass actual method instead of using instace_method ?
 
 class Joinpoint
   def initialize(object, base, method, *args, &block)
@@ -109,49 +107,52 @@ def cross_cut(klass)
   Cut.new(klass) do
     define_method :__base__ do klass end
 
-    methods = public_instance_methods + private_instance_methods + protected_instance_methods
-    methods.each do |meth|
-      undef_method(meth) unless meth.to_s =~ /(^__|initialize$|p$|class$|inspect$)/
-    end
+    def advices; @advices ||= {}; end
 
-    #def initialize(base, *args, &block)
-    #  @base     = base
-    #  @delegate = base.__new(*args, &block)
-    #  @advices  = {}
-    #end
+    def self.extended(obj)
+      base = obj.class #__base__
 
-    def method_missing(sym, *args, &blk)
-#  p "METHOD MISSING: #{sym}" #if DEBUG
+      methods = obj.methods + obj.private_methods - ['advices']
 
-      @advices ||= {}
+      methods.each do |sym|
 
-      base = __base__
+        #meth = obj.method(sym)
 
-      jp = Joinpoint.new(self, base, sym, *args, &blk)
+        define_method(sym) do |*args| #, &blk|  # TODO imporove interface mirroring
+          jp = Joinpoint.new(self, base, sym, *args) #, &blk)
 
-      # calculate advices on first use.
-      unless @advices[sym]
-        @advices[sym] = []
-        base.aspects.each do |aspect|
-          aspect.points.each do |advice, matches|
-            matches.each do |match|
-              if jp === match
-                @advices[sym] << [aspect, advice]
+          # calculate advices on first use.
+          unless advices[sym]
+            advices[sym] = []
+            base.aspects.each do |aspect|
+              aspect.points.each do |advice, matches|
+                matches.each do |match|
+                  if jp === match
+                    advices[sym] << [aspect, advice]
+                  end
+                end
               end
             end
           end
-        end
-      end
+          
+          if advices[sym].empty?
+            super
+          else
+            target = jp #Target.new(self, sym, *args, &blk)  # Target == JoinPoint ?
+            advices[sym].each do |(aspect, advice)|
+              target = Target.new(aspect, advice, target)
+            end
+            target.super
+          end
 
-      target = jp #Target.new(self, sym, *args, &blk)  # Target == JoinPoint ?
+        end
 
-      @advices[sym].each do |(aspect, advice)|
-        target = Target.new(aspect, advice, target)
       end
 
-      target.super
     end
+
   end
+
 end
 
 

data/lib/cuts/cut.rb

@@ -25,13 +25,13 @@
 #     def x; "x"; end
 #   end
 #
-#   cut :C < X do
+#   cut :Z < X do
 #     def x; '{' + super + '}'; end
 #   end
 #
 #   X.new.x  #=> "{x}"
 #
-# To use this in an AOP fashion you can define an Aspect, as a class
+# One way to use this in an AOP fashion is to define an aspect as a class
 # or function module, and tie it together with the Cut.
 #
 #   module LogAspect
@@ -41,7 +41,7 @@
 #     end
 #   end
 #
-#   cut :C < X do
+#   cut :Z < X do
 #     def x
 #       LogAspect.log(:x, r = super)
 #       return r
@@ -57,7 +57,8 @@
 # Instantiating AClass effecively instantiates ACut instead,
 # but that action is effectively transparent.
 #
-# This is the basic model of this particluar implementation:
+# This particular implementation create a module for each cut
+# and extends objects as they are created. Given the following example:
 #
 #   class Klass
 #     def x; "x"; end
@@ -67,76 +68,50 @@
 #     def x; '{' + super + '}'; end
 #   end
 #
-# We cut it like so:
+# The effect is essentially:
 #
-#   Klass = KlassCut
+#   k = Klass.new
+#   k.extend KlassCut
 #
-#   p Klass.new.x
+#   p k.x
 #
-# This is simple and relatvely robust, but not 100% transparent.
-# So we add some redirection methods to the cut to improve the
-# transparency.
-#
-# Due to limitation in meta-programming Ruby as this level, the
-# transparency isn't perfect, but it's fairly close.
-
-class Cut
-
-  def self.new(klass, &block)
-    cut = Class.new(klass, &block)  # <-- This is the actual cut.
-
-    #cut.class_eval(&block)
+# The downside to this approach is a limitation in dynamicism.
 
-    cut.send(:include, Transparency)
-    cut.extend MetaTransparency
-
-    v = $VERBOSE
-    $VERBOSE = false
-    klass.modspace::const_set(klass.basename, cut)
-    $VERBOSE = v
+class Cut < Module
+  def initialize(klass, &block)
+    klass.cuts.unshift(self)
+    module_eval(&block)
+  end
+end
 
-    return cut
+class Class
+  def cuts
+    @cuts ||= []
   end
+end
 
-  # These methods are needed to emulate full transparancy as
-  # closely as possible.
+class Object
+  class << self
+    alias_method :_new, :new
 
-  module Transparency
-    def methods(all=true)
-      self.class.superclass.instance_methods(all)
-    end
-    def public_methods(all=true)
-      self.class.superclass.public_instance_methods(all)
+    def new(*a, &b)
+      o = _new(*a, &b)
+      if !cuts.empty?
+        o.extend *cuts
+      end
+      o
     end
-    def private_methods(all=true)
-      self.class.superclass.private_instance_methods(all)
-    end
-    def protected_methods(all=true)
-      self.class.superclass.protected_instance_methods(all)
-    end
-  end
 
-  # These methods are needed to emulate full transparancy as
-  # closely as possible.
-
-  module MetaTransparency
-    #def instance_method(name) ; p "XXXX"; superclass.instance_method(name) ; end
-    def define_method(*a,&b) ; superclass.define_method(*a,&b) ; end
-    def module_eval(*a,&b)   ; superclass.module_eval(*a,&b)   ; end
-    def class_eval(*a,&b)    ; superclass.class_eval(*a,&b)    ; end
   end
-
 end
 
-
 class Symbol
   #alias :_op_lt_without_cuts :<
 
   # A little tick to simulate subclassing literal syntax.
-
   def <(klass)
     if Class === klass
-      [self,klass]
+      [self, klass]
     else
       raise NoMethodError, "undefined method `<' for :#{self}:Symbol"
       #_op_lt_without_cuts(cut_class)
@@ -144,10 +119,8 @@ class Symbol
   end
 end
 
-
 module Kernel
   # Cut convienence method.
-
   def cut(klass, &block)
     case klass
     when Array
@@ -161,52 +134,10 @@ module Kernel
     # How to handle main, but not other instance spaces?
     #klass.modspace::const_set(klass.basename, cut)
     mod = (Module === self ? self : Object)
-    mod.const_set(cutname, cut)  # <<- this is what we don't have in Cut.new
+    mod.const_set(name, cut) if name  # <<- this is what we don't have in Cut.new
 
     return cut
   end
 end
 
-class Module
-  # Returns the root name of the module/class.
-  #
-  #   module Example
-  #     class Demo
-  #     end
-  #   end
-  #
-  #   Demo.name       #=> "Example::Demo"
-  #   Demo.basename   #=> "Demo"
-  #
-  # For anonymous modules this will provide a basename
-  # based on Module#inspect.
-  #
-  #   m = Module.new
-  #   m.inspect       #=> "#<Module:0xb7bb0434>"
-  #   m.basename      #=> "Module_0xb7bb0434"
-  # 
-  def basename
-    if name and not name.empty?
-      name.gsub(/^.*::/, '')
-    else
-      nil #inspect.gsub('#<','').gsub('>','').sub(':', '_')
-    end
-  end
-
-  # Returns the module's container module.
-  #
-  #   module Example
-  #     class Demo
-  #     end
-  #   end
-  #
-  #   Example::Demo.modspace   #=> Example
-  #
-  # See also Module#basename.
-  #
-  def modspace
-    space = name[ 0...(name.rindex( '::' ) || 0)]
-    space.empty? ? Object : eval(space)
-  end
-end
 

data/test/test_cut.rb

@@ -18,12 +18,6 @@ class TestCut < Test::Unit::TestCase
 
 end
 
-
-=begin
-require 'facets/cut.rb'
-
-require 'test/unit'
-
 class TestCut1 < Test::Unit::TestCase
 
   class F
@@ -31,19 +25,18 @@ class TestCut1 < Test::Unit::TestCase
   end
 
   cut :G < F do
-    join :f => :f
-    def f(target); '<'+target.super+'>' ; end
+    #join :f => :f
+    def f; '<'+super+'>' ; end
   end
 
   def test_1_01
     f = F.new
     assert_equal( "<f>", f.f )
     assert_equal( F, f.class )
-    assert_equal( F, f.object_class )
   end
 
   def test_1_02
-    assert( G )
+    assert(G)
     assert_equal( "TestCut1::G", G.name )
   end
 
@@ -58,150 +51,35 @@ class TestCut2 < Test::Unit::TestCase
   end
 
   cut :G < F do
-    join :f => :f
-    def f(target); '<'+target.super+'>' ; end
+    #join :f => :f
+    def f; '<'+super+'>' ; end
   end
 
   cut :Q < F do
-    join :f => :f
-    def f(target); '['+target.super+']'; end
+    #join :f => :f
+    def f; '['+super+']'; end
   end
 
-  def test_2_01
-    assert_equal( [Q, G], F.cuts )
-    assert_equal( [Q, G], F.predecessors )
-  end
+  #def test_2_01
+  #  assert_equal( [Q, G], F.cuts )
+  #  assert_equal( [Q, G], F.predecessors )
+  #end
 
   def test_2_02
     f = F.new
     assert_equal( F, f.class )
-    assert_equal( F, f.object_class )
     assert_equal( "[<f>]", f.f )
   end
 
   def test_2_03
-    assert( G )
+    assert(G)
     assert_equal( "TestCut2::G", G.name )
-    assert( Q )
-    assert_equal( "TestCut2::Q", Q.name )
-  end
-
-end
-
-#
-
-class TestCut3 < Test::Unit::TestCase
-
-  class C
-    def r1; "r1"; end
-  end
-
-  cut :A < C do
-    def r1
-      b1( target( :r1 ){ super } )
-    end
-    def b1( target )
-      '(' + target.super + ')'
-    end
-  end
-
-  def test_3_01
-    c = C.new
-    assert_equal( '(r1)', c.r1 )
   end
 
-end
-
-# Test the addition of new methods and module inclusions
-# after the cut is defined with dynamic joining.
-
-class TestCut4 < Test::Unit::TestCase
-
-  class C
-    def r1; "r1"; end
-    def r2; "r2"; end
-    def j1; "j1"; end
-    def j2; "j2"; end
-  end
-
-  cut :A < C do
-
-    join :wrappy => lambda { |jp| /^r/ =~ jp }
-    join :square => :j1, :flare => :j2
-
-    def wrappy( target )
-      '{'+target.super+'}'
-    end
-
-    def square(target) '['+target.super+']' end
-    def flare(target) '*'+target.super+'*' end
-  end
-
-  class C
-    def r3; "r3"; end
-  end
-
-  module M
-    def r4 ; "r4"; end
-  end
-
-  class C
-    include M
-  end
-
-  def test_4_01
-    c = C.new
-    assert_equal( '{r1}', c.r1 )
-    assert_equal( '{r2}', c.r2 )
-    assert_equal( '{r3}', c.r3 )
-    assert_equal( '{r4}', c.r4 )
-  end
-
-  def test_4_02
-    c = C.new
-    assert_equal( '[j1]', c.j1 )
-    assert_equal( '*j2*', c.j2 )
+  def test_2_04
+    assert(Q)
+    assert_equal( "TestCut2::Q", Q.name )
   end
 
 end
 
-# Test subclassing.
-
-class TestCut5 < Test::Unit::TestCase
-
-  class C
-    def r1; "r1"; end
-    def r2; "r2"; end
-  end
-
-  cut :C1 < C do
-    join :wrap1 => [:r1, :r2]
-
-    def wrap1( target )
-      '{' + target.super + '}'
-    end
-  end
-
-  cut :C2 < C do
-    join :wrap2 => [:r1, :r2]
-
-    def wrap2( target )
-      '[' + target.super + ']'
-    end
-  end
-
-  class D < C
-    def r1; '<' + super + '>'; end
-  end
-
-  def test_5_01
-    c = C.new
-    assert_equal( '[{r1}]', c.r1 )
-    assert_equal( '[{r2}]', c.r2 )
-    d = D.new
-    assert_equal( '<[{r1}]>', d.r1 )
-    assert_equal( '[{r2}]', d.r2 )
-  end
-
-end
-=end