facets 1.8.54 → 2.0.0

data/lib/core/facets/module/methods.rb

@@ -0,0 +1,16 @@
+
+class Module
+
+  # List all instance_methods, equivalent to
+  #
+  #   public_instance_methods +
+  #   protected_instance_methods +
+  #   private_instance_methods
+
+  def all_instance_methods(all=true)
+    public_instance_methods(all) +
+    protected_instance_methods(all) +
+    private_instance_methods(all)
+  end
+
+end

data/lib/core/facets/module/modify.rb

@@ -0,0 +1,359 @@
+# TITLE:
+#
+#   Module Modify
+#
+# SUMMARY:
+#
+#   Module extensions for modifying a module's methods.
+#
+# CREDITS:
+#
+#   - Thomas Sawyer
+
+#
+class Module
+
+  private
+
+  # Alias for remove_method.
+  alias_method :remove, :remove_method
+
+  # Alias for undef_method.
+  alias_method :nodef, :undef_method
+
+  public
+
+  # Using integrate is just like using include except the
+  # module included is a reconstruction of the one given
+  # altered by the commands given in the block.
+  #
+  # Convenient commands available are: #rename, #redef,
+  # #remove, #nodef and #wrap. But any module method
+  # can be used.
+  #
+  #   module W
+  #     def q ; "q" ; end
+  #     def y ; "y" ; end
+  #   end
+  #
+  #   class X
+  #     integrate W do
+  #       nodef :y
+  #     end
+  #   end
+  #
+  #   x = X.new
+  #   x.q  #=> "q"
+  #   x.y  #=> missing method error
+  #
+  # This is like #revisal, but #revisal only
+  # returns the reconstructred module. It does not
+  # include it.
+
+  def integrate( mod, &block )
+    #include mod.revisal( &blk )
+    m = Module.new { include mod }
+    m.class_eval &block
+    include m
+  end
+
+  # Return a new module based on another.
+  # This includes the original module into the new one.
+
+  def revisal( &blk )
+    base = self
+    nm = Module.new { include base }
+    nm.class_eval &blk
+    nm
+  end
+
+  private
+
+  # Creates a new method for a pre-existing method.
+  #
+  # If _aka_ is given, then the method being redefined will
+  # first be aliased to this name.
+  #
+  #   class Greeter
+  #     def hello ; "Hello" ; end
+  #   end
+  #
+  #   Greeter.new.hello   #=> "Hello"
+  #
+  #   class Greeter
+  #     redefine_method( :hello, :hi ) do
+  #       hi + ", friend!"
+  #     end
+  #   end
+  #
+  #   Greeter.new.hello   #=> "Hello, friend!"
+  #
+  def redefine_method( sym, aka=nil, &blk )
+    raise ArgumentError, "method does not exist" unless method_defined?( sym )
+    alias_method( aka, sym ) if aka
+    undef_method( sym )
+    define_method( sym, &blk )
+  end
+
+  alias_method :redef, :redefine_method
+
+  # Redirect methods to other methods. This simply
+  # defines methods by the name of a hash key which
+  # calls the method with the name of the hash's value.
+  #
+  #   class Example
+  #     redirect_method :hi => :hello, :hey => :hello
+  #     def hello(name)
+  #       puts "Hello, #{name}."
+  #     end
+  #   end
+  #
+  #   e = Example.new
+  #   e.hello("Bob")    #=> "Hello, Bob."
+  #   e.hi("Bob")       #=> "Hello, Bob."
+  #   e.hey("Bob")      #=> "Hello, Bob."
+  #
+  # The above class definition is equivalent to:
+  #
+  #   class Example
+  #     def hi(*args)
+  #       hello(*args)
+  #     end
+  #     def hey(*args)
+  #       hello(*args)
+  #     end
+  #     def hello
+  #       puts "Hello"
+  #     end
+  #   end
+  #
+  def redirect_method( method_hash )
+    method_hash.each do |targ,adv|
+      define_method(targ) { |*args| send(adv,*args) }
+    end
+  end
+
+  alias_method :redirect, :redirect_method
+
+  # Aliases a method and undefines the original.
+  #
+  #   rename_method( :to_method, :from_method  )
+  #
+  def rename_method( to_sym, from_sym )
+    raise ArgumentError, "method #{from_sym} does not exist" unless method_defined?( from_sym )
+    alias_method( to_sym, from_sym )
+    undef_method( from_sym )
+  end
+
+  alias_method :rename, :rename_method
+
+  # Don't think we should bother making this private.
+  # That sort of defeats some of the AOP usefulness of this.
+  public #private
+
+  # Creates a new method wrapping the previous of
+  # the same name. Reference to the old method
+  # is passed into the new definition block
+  # as the first parameter.
+  #
+  #   wrap_method( sym ) { |old_meth, *args|
+  #     old_meth.call
+  #     ...
+  #   }
+  #
+  # Keep in mind that this can not be used to wrap methods
+  # that take a block.
+
+  def wrap_method( sym, &blk )
+    old = instance_method(sym)
+    define_method(sym) { |*args| blk.call(old.bind(self), *args) }
+  end
+
+  alias_method :wrap, :wrap_method
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  # integrate
+
+  class TestModuleModifyIntegrate < Test::Unit::TestCase
+
+    module M
+      def x ; 1 ; end
+    end
+
+    class C
+      integrate M do
+        rename :y, :x
+      end
+    end
+
+    def test_integrate
+      c = C.new
+      assert_raises( NoMethodError ) { c.x }
+      assert_equal( 1, c.y )
+    end
+
+  end
+
+  # revisal
+
+  class TestModuleModifyRevisal < Test::Unit::TestCase
+
+    module M
+      def x ; 1 ; end
+    end
+
+    class C
+      include M.revisal {
+        rename :y, :x
+      }
+    end
+
+    def test_revisal
+      c = C.new
+      assert_raises( NoMethodError ) { c.x }
+      assert_equal( 1, c.y )
+    end
+
+  end
+
+  # nodef
+
+  class TestModuleModifyNoDef < Test::Unit::TestCase
+
+    def the_undefined_method ; 'not here' ; end
+
+    nodef :the_undefined_method
+
+    def test_nodef
+      assert( ! respond_to?( :the_undefined_method ) )
+    end
+
+  end
+
+  # redef
+
+  class TestModuleModifyReDef < Test::Unit::TestCase
+
+    # redef_method
+
+    def a; "a"; end
+
+    redefine_method(:a) { nil }
+
+    def test_redefine_method
+      assert_equal( nil, a )
+    end
+
+    # redef
+
+    def b; "b"; end
+
+    redef(:b) { "x" }
+
+    def test_redef
+      assert_equal( "x", b )
+    end
+
+  end
+
+  # redirect_method
+
+  class TestModuleModifyReDirect < Test::Unit::TestCase
+
+    def red1 ; 1 ; end
+
+    redirect_method :red2 => :red1
+
+    def test_redirect
+      assert_equal( 1, red2 )
+    end
+
+    # redirect
+
+    def blue1 ; 1 ; end
+
+    redirect :blue2 => :blue1
+
+    def test_redirect
+      assert_equal( 1, blue2 )
+    end
+
+  end
+
+  # remove method
+
+  class TestModuleModifyRemove < Test::Unit::TestCase
+
+    def the_removed_method ; 'not here' ; end
+
+    remove :the_removed_method
+
+    def test_remove
+      assert( ! respond_to?( :the_removed_method ) )
+    end
+
+  end
+
+  # Rename
+
+  class TestModuleModifyRename < Test::Unit::TestCase
+
+    def a; "A" ; end
+
+    rename_method :b, :a
+
+    def test_rename_method
+      assert( ! respond_to?( :a ) )
+      assert( respond_to?( :b ) )
+    end
+
+    # rename
+
+    def c; "C" ; end
+
+    rename :d, :c
+
+    def test_rename
+      assert( ! respond_to?( :c ) )
+      assert( respond_to?( :d ) )
+    end
+
+  end
+
+  # wrap_method
+
+  class TestModuleModifyWrap < Test::Unit::TestCase
+
+    def a; "A"; end
+
+    wrap_method(:a) { |old| old.call + "B" }
+
+    def test_wrap_method
+      assert_equal( "AB", a )
+    end
+
+    # wrap
+
+    def b; "B"; end
+
+    wrap(:b) { |old| old.call + "C" }
+
+    def test_wrap
+      assert_equal( "BC", b )
+    end
+
+  end
+
+=end

data/lib/core/facets/module/name.rb

@@ -0,0 +1,186 @@
+# TITLE:
+#
+#   Name
+#
+# DESCRIPTION:
+#
+#   Extensions related to module names and namespace.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2007 Gavin Sinclair, Thomas Sawyer
+#   Distributed under the terms of the Ruby License
+#
+# AUTHORS:
+#
+#   - Gavin Sinclair
+#   - Thomas Sawyer
+
+#
+class Module
+
+  # <em>Note: the following documentation uses "class" because it's more common, but it
+  # applies to modules as well.</em>
+  #
+  # Given the _name_ of a class, returns the class itself (i.e. instance of Class).  The
+  # dereferencing starts at Object.  That is,
+  #
+  #   Class.by_name("String")
+  #
+  # is equivalent to
+  #
+  #   Object.const_get("String")
+  #
+  # The parameter _name_ is expected to be a Symbol or String, or at least to respond to
+  # <tt>to_str</tt>.
+  #
+  # An ArgumentError is raised if _name_ does not correspond to an existing class.  If _name_
+  # is not even a valid class name, the error you'll get is not defined.
+  #
+  # Examples:
+  #
+  #   Class.by_name("String")             # -> String
+  #   Class.by_name("::String")           # -> String
+  #   Class.by_name("Process::Sys")       # -> Process::Sys
+  #   Class.by_name("GorillaZ")           # -> (ArgumentError)
+  #
+  #   Class.by_name("Enumerable")         # -> Enumerable
+  #   Module.by_name("Enumerable")        # -> Enumerable
+  #
+  #--
+  # Credit for this goes to Gavin Sinclair.
+  #++
+  def by_name(name)
+    #result = Object.constant(name)
+    # ??? Does self need to be Object in the following lines?
+    const  = name.to_s.dup
+    base   = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    result = const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+
+    return result if result.kind_of?( Module )
+    raise ArgumentError, "#{name} is not a module or class"
+  end
+
+  # 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 name of module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Demo.name       #=> "Example::Demo"
+  #   Demo.dirname    #=> "Example"
+  #
+  # See also Module#basename.
+  #
+  def dirname
+    name[0...(name.rindex('::') || 0)]
+    #name.gsub(/::[^:]*$/, '')
+  end
+
+  # Returns the module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Demo.modspace    #=> Example
+  #
+  # See also Module#basename.
+  #
+  def modspace
+    space = name[ 0...(name.rindex( '::' ) || 0)]
+    space.empty? ? Object : eval(space)
+  end
+
+  #--
+  # Special thanks to Mauricio Fernandez
+  #   parent = Object.const_get(mod.to_s.sub(/::[^:]+\z/, ""))
+  #++
+  def nesting
+    n = []
+    name.split(/::/).inject(self){ |mod, name| c = mod.const_get(name) ; n << c ; c }
+    return n
+  end
+
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TestModuleName < Test::Unit::TestCase
+
+    def test_ancestor
+      assert( self.class.ancestor?(::Test::Unit::TestCase) )
+    end
+
+    def test_by_name
+      c = ::Test::Unit::TestCase.name
+      assert_equal( ::Test::Unit::TestCase, Module.by_name(c) )
+      c = "Test::Unit::TestCase"
+      assert_equal( ::Test::Unit::TestCase, Class.by_name(c) )
+    end
+
+    def test_basename
+      assert_equal( "TestCase", ::Test::Unit::TestCase.basename )
+    end
+
+    def test_dirname
+      assert_equal( 'Test::Unit', Test::Unit::TestCase.dirname )
+      assert_equal( 'Test::Unit', ::Test::Unit::TestCase.dirname )
+      assert_equal( '', Test.dirname )
+      assert_equal( '', ::Test.dirname )
+    end
+
+    def test_modspace
+      assert_equal( Test::Unit, Test::Unit::TestCase.modspace )
+      assert_equal( ::Test::Unit, ::Test::Unit::TestCase.modspace )
+      assert_equal( Object, ::Test.modspace )
+    end
+
+    module M
+      module N
+        class C
+          def n
+            self.class.nesting
+          end
+        end
+      end
+    end
+
+    def test_nesting
+      assert_equal( [TestModuleName, M, M::N, M::N::C], M::N::C.new.n )
+    end
+
+  end
+
+=end