cuts 0.0.1 → 0.0.4

data/COPYING

@@ -1,3 +1,4 @@
+.
                       GNU GENERAL PUBLIC LICENSE
                          Version 3, 29 June 2007
 

data/HISTORY

@@ -0,0 +1,18 @@
+= Cuts Change History
+
+== 0.0.4 // 2008-03-05
+
+* Added Rakefile to run tests.
+
+== 0.0.3 // 2008-04-06
+
+* Working release.
+
+== 0.0.1 // 2008-03-05
+
+* First release.
+
+== 0.0.0 // 2008-03-04
+
+* Started project.
+

data/MANIFEST

@@ -0,0 +1,22 @@
+Rakefile
+test
+test/test_cut.rb
+test/test_aop.rb
+NOTES
+README
+HISTORY
+meta
+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

data/NOTES

@@ -1,6 +1 @@
-
-# This is a place to put release notes.
-# Like CHANGES this is also uploaded in the release process.
-# This is good place to mention major changes and things 
-# users might need to do to take them into account.
-
+This release removes all dependencies on Facets.

data/Rakefile

@@ -1,2 +1,10 @@
-require File.join(File.dirname(__FILE__), "setup.rb")
 
+desc "run tests"
+
+task :test do
+  $LOAD_PATH.unshift './lib'
+
+  Dir['test/*'].each do |testfile|
+    load testfile
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+cuts 0.0.4 alpha (2008-09-18)

data/lib/cuts.rb

@@ -1,2 +1 @@
-require 'cuts/cut.rb'
 require 'cuts/aop.rb'

data/lib/cuts/aop.rb

@@ -13,9 +13,9 @@
 #
 #    - Can JointPoint and Target be the same class?
 
-require 'facets/kernel/object'
-require 'facets/module/methods'
-require 'facets/cut'
+#require 'facets/kernel/object'
+#require 'facets/module/methods'
+require 'cuts/cut'
 
 #
 
@@ -109,7 +109,8 @@ def cross_cut(klass)
   Cut.new(klass) do
     define_method :__base__ do klass end
 
-    all_instance_methods.each do |meth|
+    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
 

data/lib/cuts/cut.rb

@@ -1,34 +1,14 @@
-# TITLE:
+# cut.rb
+# Copyright (c) 2005,2008 Thomas Sawyer
 #
-#   Cut
+# Ruby License
 #
-# SUMMARY:
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
 #
-#   By definition, a Cut is a *transparent* subclass.
-#   Thay serve as the basis of Cut-based AOP, by providing
-#   a clean wrapping mechinism.
-#
-# COPYRIGHT:
-#
-#   Copyright (c) 2005 Thomas Sawyer
-#
-# LICENSE:
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# AUTHORS:
-#
-#   - Thomas Sawyer
-
-require 'facets/module/name'
-require 'facets/kernel/silence'
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
 
 # = Cut
 #
@@ -98,8 +78,7 @@ require 'facets/kernel/silence'
 # transparency.
 #
 # Due to limitation in meta-programming Ruby as this level, the
-# transparency isn't perfect, but it's fairly close, and we continue
-# to improve it.
+# transparency isn't perfect, but it's fairly close.
 
 class Cut
 
@@ -111,10 +90,10 @@ class Cut
     cut.send(:include, Transparency)
     cut.extend MetaTransparency
 
-    # TODO Shutdown warning
-    silence_warnings do
-      klass.modspace::const_set(klass.basename, cut)
-    end
+    v = $VERBOSE
+    $VERBOSE = false
+    klass.modspace::const_set(klass.basename, cut)
+    $VERBOSE = v
 
     return cut
   end
@@ -188,3 +167,46 @@ module Kernel
   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/meta/abstract

@@ -0,0 +1,3 @@
+Cuts is an expiremental implementation of cut-based
+AOP for Ruby written in pure Ruby.
+

data/meta/contact

@@ -0,0 +1 @@
+tigerops-community@rubyforge.org

data/meta/created

@@ -0,0 +1 @@
+2008-02-12

data/meta/homepage

@@ -0,0 +1 @@
+http://cuts.rubyforge.org

data/meta/license

@@ -0,0 +1 @@
+MIT

data/meta/requires

@@ -0,0 +1 @@
+facets >=2.4.4

data/meta/summary

@@ -0,0 +1 @@
+Cut-based AOP for Ruby

data/test/test_aop.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'cuts'
+
+class TestAop < Test::Unit::TestCase
+
+  class X
+    def x; "x"; end
+    def y; "y"; end
+    def q; "<" + x + ">"; end
+  end
+
+  Xa = Aspect.new do
+    join :x do |jp|
+      jp == :x
+    end
+
+    def x(target); '{' + target.super + '}'; end
+  end
+
+  X.apply(Xa)
+
+  def setup
+    @x1 = X.new
+  end
+
+  def test_class
+    assert_equal(X, @x1.class)
+  end
+
+  def test_public_methods
+    meths = @x1.public_methods(false)
+    assert(meths.include?("y"))
+    assert(meths.include?("q"))
+    assert(meths.include?("x"))
+  end
+
+  def test_x
+    assert_equal("{x}", @x1.x)
+  end
+
+  def test_y
+    assert_equal("y", @x1.y)
+  end
+
+  def test_q
+    assert_equal("<{x}>", @x1.q)
+  end
+
+end

data/test/test_cut.rb

@@ -0,0 +1,207 @@
+require 'test/unit'
+require 'cuts'
+
+class TestCut < Test::Unit::TestCase
+
+  class X
+    def x; "x"; end
+  end
+
+  Xc = Cut.new(X) do
+    def x; '{' + super + '}'; end
+  end
+
+  def test_method_is_wrapped_by_advice
+      o = X.new
+      assert_equal("{x}", o.x)
+  end
+
+end
+
+
+=begin
+require 'facets/cut.rb'
+
+require 'test/unit'
+
+class TestCut1 < Test::Unit::TestCase
+
+  class F
+    def f ; "f" ; end
+  end
+
+  cut :G < F do
+    join :f => :f
+    def f(target); '<'+target.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_equal( "TestCut1::G", G.name )
+  end
+
+end
+
+# Test multiple cuts.
+
+class TestCut2 < Test::Unit::TestCase
+
+  class F
+    def f ; "f" ; end
+  end
+
+  cut :G < F do
+    join :f => :f
+    def f(target); '<'+target.super+'>' ; end
+  end
+
+  cut :Q < F do
+    join :f => :f
+    def f(target); '['+target.super+']'; end
+  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_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 )
+  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