facets 1.2.1 → 1.3.0

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

@@ -13,7 +13,7 @@ class Module
     #include mod.revisal( &blk )
     m = Module.new { include mod }
     m.class_eval &blk
-    include m 
+    include m
   end
 
 end

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

@@ -0,0 +1,55 @@
+
+require 'facets/more/functor'
+
+# class X
+#
+#  let.x = 10
+#  let.x = "Hello"
+#
+# end
+
+class Module
+
+  def let
+    klass = self
+    Functor.new do |op, *args|
+      case op.to_s[-1,1]
+      when '='
+        op = op.to_s.chomp('=')
+        define_method( op ) do
+          r = instance_variable_set( "@#{op}", args[0] )
+          klass.class.class_eval %{
+            def #{op}; @#{op}; end
+          }
+          r
+        end
+      else
+        klass.class_eval %{
+          def #{op}; @#{op}; end
+        }
+      end
+    end
+  end
+
+end
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TCthis < Test::Unit::TestCase
+
+    class Foo
+      let.bar = 10
+    end
+
+    def test01
+      x = Foo.new
+      assert_equal( 10, x.bar )
+    end
+
+  end
+
+=end
+

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

@@ -0,0 +1,180 @@
+
+class Module
+
+  # Creates a class instance variable attribute that can
+  # be accessed both on an instance and class level.
+
+  def mattr( *syms )
+    writer = false
+    syms.reject! do |s|
+      case s
+      when TrueClass
+        writer = true
+      when FalseClass, NilClass
+        true
+      else
+        false
+      end
+    end
+    if writer
+      mattr_accessor( *syms )
+    else
+      mattr_reader( *syms )
+    end
+  end
+
+  # Creates a class instance variable attr_reader
+  # accessable both on an instance and class level.
+  #
+  #   class MyClass
+  #     mattr_reader :a
+  #     def self.set ; @a = 10 ; end
+  #   end
+  #
+  #   MyClass.set
+  #   MyClass.a           #=> 10
+  #   mc = MyClass
+  #   mc.a                #=> 10
+  #
+  def mattr_reader( *syms )
+    hsyms = ( syms.last.is_a?(Hash) ? syms.pop : {} )
+    hsyms.update( Hash[*(syms.zip([nil]*syms.size).flatten)] )
+    hsyms.each_pair do |sym, val|
+      class_eval <<-EOS
+        if ! defined? @#{sym}
+          @#{sym} = val
+        end
+        def self.#{sym}
+          @#{sym}
+        end
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+    return hsyms.keys
+  end
+
+  # Creates a class instance variable attr_writer
+  # accessable both on an instance and class level.
+  #
+  #   class MyClass
+  #     mattr_writer :a
+  #     def self.show ; @a ; end
+  #   end
+  #
+  #   MyClass.a = 10
+  #   MyClass.show         #=> 10
+  #   m = MyClass.new
+  #   m.a = 29
+  #   MyClass.show         #=> 29
+  #
+  def mattr_writer(*syms)
+    hsyms = ( syms.last.is_a?(Hash) ? syms.pop : {} )
+    hsyms.update( Hash[*(syms.zip([nil]*syms.size).flatten)] )
+    hsyms.each_pair do |sym, val|
+      class_eval <<-EOS
+        if ! defined? @#{sym}
+          @#{sym} = val
+        end
+        def self.#{sym}=(obj)
+          @#{sym} = obj
+        end
+        def #{sym}=(obj)
+          self.class.#{sym}=(obj)
+        end
+      EOS
+    end
+    return hsyms.keys
+  end
+
+  # Creates a class instance variable attr_accessor
+  # accessable both on an instance and class level.
+  #
+  #   class MyClass
+  #     mattr_accessor :a
+  #   end
+  #
+  #   MyClass.a = 10
+  #   MyClass.a           #=> 10
+  #   mc = MyClass.new
+  #   mc.a                #=> 10
+  #   mc.a = 20
+  #   mc.a                #=> 20
+  #   MyClass.a           #=> 20
+  #
+  def mattr_accessor(*syms)
+    m = []
+    m.concat( mattr_reader(*syms) )
+    m.concat( mattr_writer(*syms) )
+    m
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    class M
+      def self.setup
+        @a = 10
+      end
+      # for testing writer
+      def b
+        self.class.instance_eval { @b }
+      end
+    end
+
+    def setup
+      M.setup
+    end
+
+    def test_mattr
+      assert_nothing_raised {
+        M.class_eval { mattr :a }
+      }
+      t = M.new
+      assert_equal( 10, M.a )
+      assert_equal( 10, t.a )
+    end
+
+    def test_mattr_reader
+      assert_nothing_raised {
+        M.class_eval { mattr_reader :a }
+      }
+      t = M.new
+      assert_equal( 10, t.a )
+    end
+
+    def test_mattr_writer
+      assert_nothing_raised {
+        M.class_eval { mattr_writer :b }
+      }
+      t = M.new
+      t.b = 5
+      assert_equal( 5, t.b )
+    end
+
+    def test_mattr_accessor
+      assert_nothing_raised {
+        M.class_eval { mattr_accessor :c }
+      }
+      t = M.new
+      t.c = 50
+      assert_equal( 50, t.c )
+    end
+
+  end
+
+=end

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

@@ -1,4 +1,6 @@
+#--
 # George Moschovitis <gm@navel.gr>
+#++
 
 class Module
 
@@ -45,4 +47,4 @@ class C
   include Q
 end
 
-=end
+=end

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

@@ -0,0 +1,23 @@
+
+class Module
+
+  # Creates a new module by copying the methods of the class.
+
+  #--
+  # This is unfortuate. Class#to_module would be mcuh better,
+  # but doesn't look easily possible. Sigh.
+  #++
+
+  def singleton_to_module #( include_ancestors=false )
+    new_module = Module.new
+    klass = self
+    meths = singleton_methods(true) #-= ['included']
+    meths.each do |m|
+      new_module.class_eval do
+        define_method(m, &(klass.method(m)))
+      end
+    end
+    new_module
+  end
+
+end

data/lib/facets/core/nilclass.rb

@@ -2,6 +2,8 @@ require 'facets/core/nilclass/blank'
 require 'facets/core/nilclass/empty'
 require 'facets/core/nilclass/include'
 require 'facets/core/nilclass/length'
+require 'facets/core/nilclass/op_cmp'
 require 'facets/core/nilclass/op_fetch'
 require 'facets/core/nilclass/size'
+require 'facets/core/nilclass/succ'
 require 'facets/core/nilclass/to_h'

data/lib/facets/core/string/methodize.rb

@@ -4,16 +4,17 @@ class String
   # Converts a string into a valid ruby method name
   # This method is geared toward code reflection.
   #
-  # See : String#modulize, String#pathize
   #
   #   "MyModule::MyClass".methodize  #=> "my_module__my_class"
   #
-  # TODO :
+  # See also String#modulize, String#pathize
+  #
+  # == TODO
   #
   # * Make sure that all scenarios return a valid ruby class name
   # * Make sure it is revertible
   #
-  #
+
   def methodize
     to_s.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/,'').gsub(/(::|\/)_?/, '__')
   end

data/lib/facets/core/string/modulize.rb

@@ -4,11 +4,11 @@ class String
   # Converts a string into a valid ruby class or module name
   # This method is geared toward code reflection.
   #
-  # See : String#methodize, String#pathize
-  #
   #   "my_module__my_path".modulize  #=> "MyModule::MyPath"
   #
-  # TODO :
+  # See also String#methodize, String#pathize
+  #
+  # TODO
   #
   # * Make sure that all scenarios return a valid ruby class name
   # * Make sure it is revertible

data/lib/facets/more/ansicode.rb

@@ -52,7 +52,7 @@
 #
 # == Synopsis
 #
-#   include ANSICode
+#   include Console::ANSICode
 #
 #   p red, "Hello", blue, "World"   
 #   => "\e[31mHello\e[34mWorld"

data/lib/facets/more/aspects.rb

@@ -1,4 +1,4 @@
-require 'facets/more/inheritor'
+require 'facet/inheritor'
 
 module Glue
 

data/lib/facets/more/basicobject.rb

@@ -16,17 +16,20 @@
 # ==========================================================================
 #  Revision History
 # ==========================================================================
+#  2006.04.03
+#  * added #instance method.
+#
 #  2005.10.26
 #  * preserved a few addtional methods --everyhting ending in ?, dup and
 #    object_id.
 #  * changed name from BlankSlate to BasicObject
 #
 #  2005.04.28  trans
-#  * ported to mega and added __class__
+#  * ported from BlankSlate and added __class__
 # ==========================================================================
 #
-# TODO Would be nice it there were a factory method to alter which methods
-#      were excluded.
+# TODO Might be nice it there were a factory method to alter which methods
+#      were excluded. But probably too dangerous.
 #
 #++
 
@@ -48,10 +51,22 @@ require 'facets/core/kernel/__class__'
 #
 # By default these are the reserved methods:
 #
-#   __id__ __class__ __send__ dup eql? equal? frozen? inspect instance_eval
+#   __id__ __class__ __self__ __send__ dup eql? equal? frozen? inspect instance_eval
 #   instance_of? instance_variable_get instance_variable_set instance_variables
 #   is_a? kind_of? nil? null object_id respond_to? tainted?
 #
+# The special method #__self__ allows access to the underlying object via a
+# specialized Functor-style class called, BasicObject::Self. This binds the
+# actual self to the subsequently called methods of Object instancea methods.
+# So even though a method may no longer be defined for BasicObject it can still
+# be called via this interface.
+#
+#   class A < BasicObject
+#   end
+#
+#   a.__self__.class  #=> A
+#   a.class           #=> NoMethodError
+#
 
 class BasicObject
 
@@ -67,6 +82,16 @@ class BasicObject
 
   instance_methods.each { |m| hide(m) }
 
+  class Self < self
+    define_method( :method_missing ) do |meth, *args|  # &blk|
+      Object.instance_method(meth).bind(self).call(*args) # ,&blk)
+    end
+  end
+
+  def __self__
+    @__self__ ||= Self.new
+  end
+
 end
 
 # Since Ruby is very dynamic, methods added to the ancestors of
@@ -76,26 +101,26 @@ end
 
 module Kernel
   class << self
-    #alias_method :blank_slate_method_added, :method_added
-    #def method_added(name)
-    #  return if name == :blank_slate_method_added
-    #  blank_slate_method_added(name)
-    madded = instance_method(:method_added)
+    madded = method(:method_added)
     define_method(:method_added) do |name|
-      madded.bind(self).call(name)
+      #return if name == :kernel_method_added
+      r = madded.call(name)
       return if self != Kernel
       BasicObject.hide(name)
+      r
     end
   end
 end
 
 class Object
   class << self
-    madded = instance_method(:method_added)
+    madded = method(:method_added)
     define_method(:method_added) do |name|
-      madded.bind(self).call(name)
+      #return if name == :object_method_added
+      r = madded.call(name)
       return if self != Object
       BasicObject.hide(name)
+      r
     end
   end
 end
@@ -108,26 +133,46 @@ end
 #   |_|\___||___/\__|
 #
 
-# TODO
-
-=begin #test
+=begin test
 
   require 'test/unit'
 
-  class TC_Kernelless < Test::Unit::TestCase
+  class TCBasicObject < Test::Unit::TestCase
+
+    class A < BasicObject
+    end
 
-    class A
-      include Kernelless
+    def setup
+      @a = A.new
     end
 
     def test_001
-      p A.instance_methods
+      assert(
+        @a.__class__.instance_methods.all? do |m|
+          m =~ BasicObject::EXCLUDE or m == 'instance'
+        end
+      )
     end
 
     def test_002
-      Kernel.class_eval {
-        def xxx ; end
-      }
+      Kernel.module_eval { def xxx ; end }
+      assert( ! @a.__class__.method_defined?( :xxx ) )
+    end
+
+    def test_003
+      Object.class_eval { def yyy ; end }
+      assert( ! @a.__class__.method_defined?( :yyy ) )
+    end
+
+    def test_004
+      Object.class_eval { def yyy ; end }
+      assert( ! @a.__self__.methods.include?( 'yyy' ) )
+    end
+
+    def test_005
+      assert( @a.__self__.methods.include?( '__id__' ) )
+      assert( @a.__self__.methods.include?( '__send__' ) )
+      assert( @a.__self__.methods.include?( '__class__' ) )
     end
 
   end