facets 2.1.3 → 2.2.0

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

@@ -1,5 +1,3 @@
-require 'facets/namespace'  # FIXME
-
 class Module
 
   # An alias for #include.
@@ -8,17 +6,23 @@ class Module
   #     is Enumerable
   #   end
   #
-  alias_method :is, :include
+  #   CREDIT: Trans
 
-# TODO
-#   def is(*mods)
-#     mods.each do |mod|
-#       if mod.const_defined?(:Self)
-#         extend mod.const_get(:Self)
-#       end
-#     end
-#     include(*mods)
-#   end
+  #alias_method :is, :include
+
+  def is(*mods)
+    mods.each do |mod|
+      if mod.const_defined?(:Self)
+        extend mod::Self
+        # pass it along if module
+        if instance_of?(Module)
+          const_set(:Self, Module.new) unless const_defined?(:Self)
+          const_get(:Self).send(:include, mod::Self)
+        end
+      end
+    end
+    include(*mods)
+  end
 
   # Expirmental idea for #is.
   #
@@ -53,7 +57,9 @@ class Module
   #
   #   Y.is?(X)  #=> true
   #
-  def is?( base )
+  #   CREDIT: Trans
+
+  def is?(base)
     ancestors.slice(1..-1).include?( base )
   end
 
@@ -64,51 +70,55 @@ class Module
   #  class Y < X ; end
   #
   #   X.ancestor?(Y)
-  #
+
   def ancestor?( mod )
     ancestors.include? mod
   end
 
+  # Alias for #===. This provides a verbal method
+  # for inquery.
+  #
+  #   s = "HELLO"
+  #   s.class? String   #=> true
+  #
+  #   CREDIT: Trans
+
   alias_method :class?, :===
 
-  # Both includes and extends a module.
-  #
-  def include_and_extend(*mods)
-    include *mods
-    extend *mods
-  end
+  # DEPRECATED
+  #   # Both includes and extends a module.
+  #   #
+  #   #   NOTE: If #include and/or #extend returned thier modules then
+  #   #         one could just do:
+  #   #
+  #   #             extend(*include(M1, M2, ...))
+  #   #
+  #   #   CREDIT: Trans
+  #
+  #   def include_and_extend(*mods)
+  #     include *mods
+  #     extend *mods
+  #   end
 
   # Include module and apply module_fuction to the
   # included methods.
   #
+  #   CREDIT: Trans
+
   def include_function_module *mod
-    include *mod
-    module_function *mod.collect{|m| m.private_instance_methods & m.methods(false)}.flatten
+    include(*mod)
+    module_function(*mod.collect{|m| m.private_instance_methods & m.methods(false)}.flatten)
   end
 
-  # Include a module via a specified namespace.
-  #
-  #   module T
-  #     def t ; "HERE" ; end
-  #   end
-  #
-  #   class X
-  #     include_as :test => T
-  #     def t ; test.t ; end
-  #   end
+  # NOTE: include_as is now in more library namespace.rb.
+
+  # A macro for dynamic modules.
   #
-  #   X.new.t  #=> "HERE"
+  #    TODO: This method ecourages a bad practice, and should not be used.
+  #          It's here because Nitro uses it, but eventually it will be deprecated.
   #
-  def include_as( h )
-    h.each { |name, mod| method_space(name, mod) }
-  end
+  #  CREDIT: George Moschovitis
 
-  # A useful macro for dynamic modules.
-  #--
-  # FIXME: quick and easy implementation, should
-  # come up with something better. The name
-  # sucks too.
-  #++
   def on_included(code)
     tag = caller[0].split(' ').first.split(/\/|\\/).last.gsub(/:|\.|\(|\)/, '_')
     old = "__included_#{tag}"
@@ -130,88 +140,18 @@ module Kernel
 
   # Convenience alias for #is_a? to go along with #is.
   #
+  #   TODO: Somewhat confusing with Module#is?, should this be deprecated?
+
   alias_method :is?, :is_a?
 
 end
 
 
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestIncludeAs < Test::Unit::TestCase
-
-    module MockModule
-      def x; "X"; end
-      def y; @y; end
-    end
-
-    class MockObject
-      include_as :mod => MockModule
-
-      def initialize
-        @y = "Y"
-      end
-    end
-
-    def test_01
-      m = MockObject.new
-      assert_equal( "X", m.mod.x )
-    end
-
-    def test_02
-      m = MockObject.new
-      assert_equal( "Y", m.mod.y )
-    end
-
-  end
-
-  class TestOnInclude < Test::Unit::TestCase
-
-    module M
-      def self.check ; @@check ; end
-      on_included %{
-        @@check = 1
-      }
-    end
-
-    module Q
-      def self.check ; @@check ; end
-      on_included %{
-        @@check = 1
-      }
-      on_included %{
-        @@check = 2
-      }
-    end
-
-    class C
-      include M
-      include Q
-    end
-
-    def test_included
-      assert_equal(1, M.check)
-      assert_equal(2, Q.check)
-    end
-
-  end
-
-=end
-
 
 # demonstration
 
 =begin demo
 
-  # test
-
   module T
     def t ; p self ; end
     def r ; p self ; end

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

@@ -1,4 +1,3 @@
-
 class Module
 
   # List all instance_methods, equivalent to
@@ -6,29 +5,32 @@ class Module
   #   public_instance_methods +
   #   protected_instance_methods +
   #   private_instance_methods
+  #
+  #   CREDIT: Trans
 
-  def all_instance_methods(all=true)
-    public_instance_methods(all) +
-    protected_instance_methods(all) +
-    private_instance_methods(all)
+  def all_instance_methods(include_super=true)
+    public_instance_methods(include_super) +
+    protected_instance_methods(include_super) +
+    private_instance_methods(include_super)
   end
 
   # Query whether an instance method is defined for the module.
   #
-  #   CREDIT Noah Gibbs
-  #   CREDIT Gavin Sinclair
+  #   CREDIT: Gavin Sinclair
+  #   CREDIT: Noah Gibbs
+
 
-  def instance_method_defined?(_method)
-    instance_methods(true).find { |m| m == _method.to_s }
+  def instance_method_defined?(meth)
+    instance_methods(true).find { |m| m == meth.to_s }
   end
 
   # Query whether a normal (singleton) method is defined for the module.
   #
-  #   CREDIT Noah Gibbs
-  #   CREDIT Gavin Sinclair
+  #   CREDIT: Gavin Sinclair
+  #   CREDIT: Noah Gibbs
 
-  def module_method_defined?(_method)
-    singleton_methods(true).find { |m| m == _method.to_s }
+  def module_method_defined?(meth)
+    singleton_methods(true).find { |m| m == meth.to_s }
   end
 
 end

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

@@ -1,16 +1,3 @@
-# TITLE:
-#
-#   Module Modify
-#
-# SUMMARY:
-#
-#   Module extensions for modifying a module's methods.
-#
-# CREDITS:
-#
-#   - Thomas Sawyer
-
-#
 class Module
 
   private
@@ -49,21 +36,25 @@ class Module
   # This is like #revisal, but #revisal only
   # returns the reconstructred module. It does not
   # include it.
+  #
+  #   CREDIT: Trans
 
-  def integrate( mod, &block )
+  def integrate(mod, &block)
     #include mod.revisal( &blk )
-    m = Module.new { include mod }
-    m.class_eval &block
+    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.
+  #
+  #   CREDIT: Trans
 
-  def revisal( &blk )
+  def revisal(&blk)
     base = self
-    nm = Module.new { include base }
-    nm.class_eval &blk
+    nm = Module.new{ include base }
+    nm.class_eval(&blk)
     nm
   end
 
@@ -88,7 +79,9 @@ class Module
   #
   #   Greeter.new.hello   #=> "Hello, friend!"
   #
-  def redefine_method( sym, aka=nil, &blk )
+  #   CREDIT: Trans
+
+  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 )
@@ -127,6 +120,8 @@ class Module
   #     end
   #   end
   #
+  #   CREDIT: Trans
+
   def redirect_method( method_hash )
     method_hash.each do |targ,adv|
       define_method(targ) { |*args| send(adv,*args) }
@@ -139,6 +134,8 @@ class Module
   #
   #   rename_method( :to_method, :from_method  )
   #
+  #   CREDIT: Trans
+
   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 )
@@ -163,6 +160,8 @@ class Module
   #
   # Keep in mind that this can not be used to wrap methods
   # that take a block.
+  #
+  #   CREDIT: Trans
 
   def wrap_method( sym, &blk )
     old = instance_method(sym)
@@ -170,190 +169,5 @@ class Module
   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
+end