facets 1.7.46 → 1.8.0

data/work/core/module/attr_xxx.rb

@@ -0,0 +1,22 @@
+
+  # These are here for little good reason.
+
+  r = instance_method(:attr_reader)
+  w = instance_method(:attr_writer)
+  a = instance_method(:attr_accessor)
+
+  define_method :attr_reader do |*args|
+    r.bind(self).call(*args)
+    args.collect{ |a| :"#{a}" }
+  end
+
+  define_method :attr_writer do |*args|
+    w.bind(self).call(*args)
+    args.collect{ |a| :"#{a}=" }
+  end
+
+  define_method :attr_accessor do |*args|
+    a.bind(self).call(*args)
+    args.collect{ |a| [:"#{a}", :"#{a}="] }.flatten
+  end
+

data/work/core/module/by_regexp.rb

@@ -0,0 +1,21 @@
+class Class
+ # usage sample:
+ # object = Class.by_name_rx(/^#{class_name}$/i).new
+
+ def by_name_rx (regex)
+   result = NilClass
+   ObjectSpace.each_object do |object|
+       if Class === object and object.name =~ regex
+           puts "I found the object: #{object.name}"
+           raise ArgumentError, "#{regex} matches multiple classes"
+if result != NilClass
+           result = object
+       end
+   end
+   if result != NilClass
+       return result
+   else
+       raise ArgumentError, "#{regex} does not match any class"
+   end
+ end
+end

data/work/core/module/cast.rb

@@ -0,0 +1,64 @@
+
+require 'facet/hash/keys_to_sym'
+
+class Module
+  #
+  # Attributing casting is useful in forcing attributes
+  # to specified types on read or write access. Though #cast
+  # is also quite general, in that any method can be cast via
+  # any other method.
+  #
+  #   require 'facet/module/cast'
+  #
+  #   class C
+  #     attr_accessor :a
+  #     cast :a => :to_s
+  #   end
+  #
+  #   c = C.new
+  #   c.a = 1
+  #   c.a  #=> "1"
+  #
+  # Other examples:
+  #
+  #   # simple type casting
+  #   cast :a => :to_s
+  #
+  #   # fancy type casting
+  #   cast :a => 'to_s.capitalize'
+  #
+  #--
+  # Planned Funtionality:
+  #
+  #   # a powerful reader!
+  #   cast :a => fn{ |x| eval x }
+  #  
+  #   # a writer that type checks (using type.rb) (NOT YET FUNCTIONAL)
+  #   cast :a= => fn{ |x| big4 x }
+  #  
+  #   # they can also be grouped (NOT YET FUNCTIONAL)
+  #   cast [:x, :y] => :to_s
+  #++
+  def cast( h )
+    h.each { |n,c|
+      alias_method( :"-#{n}", n )
+      private :"-#{n}"
+      case n.to_s[-1,1]
+      when '='
+        module_eval %{
+          def #{n}(x)
+            self.send("-#{n}", x.#{c})
+          end
+        }
+      else
+        module_eval %{
+          def #{n}(*args)
+            self.send("-#{n}", *args).#{c}
+          end
+        }
+      end
+    }
+    made = h.keys_to_sym.keys
+    return *made
+  end
+end

data/work/core/module/class_attribute_accessors.rb

@@ -0,0 +1,57 @@
+# Extends the class object with class and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
+        end
+      EOS
+    end
+  end
+  
+  def cattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/work/core/module/inherit.rb

@@ -0,0 +1,99 @@
+
+
+require 'facets/core/class/to_module'
+
+class Module
+
+  def inherit( *mods )
+    mods.each do |mod|
+      cmod = (class << mod; self; end).to_module
+      extend cmod
+      include mod
+    end
+    nil
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TCInherit1 < Test::Unit::TestCase
+
+    module Foo
+      def self.x ; 10 ; end
+      def y ; 20 ; end
+    end
+
+    module Bar ; inherit Foo ; end
+
+    class X ; inherit Bar ; end
+
+    # test
+
+    def test_001
+      assert_equal( 10, Foo.x )
+    end
+
+    def test_002
+      assert_equal( 10, Bar.x )
+    end
+
+    def test_003
+      assert_equal( 10, X.x )
+    end
+
+    def test_004
+      x = X.new
+      assert_equal( 20, x.y )
+    end
+
+    # These won't work; this solution in non-dynamic.
+
+    #def test_004
+    #  def Foo.g ; 30 ; end
+    #  assert_equal( 30, Bar.g )
+    #end
+
+    #def test_005
+    #  #def Foo.g ; 30 ; end
+    #  assert_equal( 30, X.g )
+    #end
+
+  end
+
+  class TCInherit2 < Test::Unit::TestCase
+
+    module X
+      def self.x ; self ; end
+      def x ; self ; end
+    end
+    class  Y ; inherit X ; end
+    module Z ; inherit X ; end
+    class  Q ; inherit Z ; end
+
+    def test_001
+      y = Y.new
+      assert_equal( Y, Y.x )
+      assert_equal( y, y.x )
+    end
+
+    def test_002
+      q = Q.new
+      assert_equal( Q, Q.x )
+      assert_equal( q, q.x )
+    end
+
+  end
+
+=end

data/work/core/module/inherit0.rb

@@ -0,0 +1,59 @@
+
+class ClassModule < Module
+  undef_method :singleton_method_added
+end
+
+class Module
+
+  # Be nice if this could be a constant instead.
+  def ClassModule
+    @_ClassModule_ ||= ::ClassModule.new
+  end
+    
+  def singleton_method_added( m )
+    mod = self
+    mod::ClassModule().module_eval {
+      define_method( m, &mod.method(m) )
+    }
+  end
+
+  def inherit( mod )
+    include mod
+    extend mod::ClassModule()
+  end
+  
+end
+
+
+
+#=begin test
+
+module M
+  def self.hello ; "Hello" ; end
+  def hello ; "hello" ; end
+end
+
+class X
+  inherit M
+end
+
+p X.hello
+p X.new.hello
+
+module N
+  inherit M
+end
+
+p X.hello
+p X.new.hello
+
+class Y
+  inherit N
+end
+
+p Y.hello
+p Y.new.hello
+
+
+#=end
+

data/work/core/module/let.rb

@@ -0,0 +1,51 @@
+
+require 'facets/more/functor.rb'
+
+class Module
+
+  def let
+
+    Functor.new { |op, arg|
+
+      ope = op.to_s.chomp('=')
+
+      # reader
+      if arg
+        define_method(ope) {
+          unless instance_variables.include?("@#{ope}")
+            instance_variable_set("@#{ope}",arg)
+          end
+          instance_variable_get("@#{ope}")
+        }
+      else
+        attr ope
+      end
+
+      # writer
+      attr_writer ope
+
+    }
+
+  end
+
+end
+
+
+
+class Test
+
+  class Example
+
+    let.a = 10
+    let.b = 20
+
+  end
+
+end
+
+te = Test::Example.new
+p te.a
+p te.b
+
+
+

data/work/core/module/meta_attr.rb

@@ -0,0 +1,60 @@
+require 'nano/object/meta'
+
+#--
+# This is one of the very few files in nano that contains
+# more than one method. The related files are actually just
+# stubs doe this. This is not generally done, but in this
+# case it becomes appropriate b/c of the quanitity of methods
+# involved --it borders on becomeing a Mega Module.
+#++
+
+require 'nano/module/attr_setter'
+require 'nano/module/attr_checker'
+
+class Module
+
+  public :attr, :attr_reader, :attr_writter, :attr_accessor
+
+#   # Shortcuts for creating class instance attributes.
+#   #
+#   # Concerning the naming of these emthods, since the letter 'c'
+#   # has become the convention for class variable attributes (ie. @@v),
+#   # the letter 's' was chosen and stands for 'self' or 'singleton'.
+#   #
+#   def sattr(*args)
+#     class << self
+#       attr(*args)
+#     end
+#   end
+# 
+#   def sattr_reader(*args)
+#     class << self
+#       attr_reader(*args)
+#     end
+#   end
+# 
+#   def sattr_writer(*args)
+#     class << self
+#       attr_writer(*args)
+#     end
+#   end
+# 
+#   def sattr_accessor(*args)
+#     class << self
+#       attr_accessor(*args)
+#     end
+#   end
+# 
+#   def sattr_setter(*args)
+#     class << self
+#       attr_setter(*args)
+#     end
+#   end
+# 
+#   def sattr_tester(*args)
+#     class << self
+#       attr_tester(*args)
+#     end
+#   end
+
+end

data/work/core/module/module_attribute_accessors.rb

@@ -0,0 +1,57 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Module # :nodoc:
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end