facets 1.8.49 → 1.8.51

data/work/core/module/attr_xxx.rb

@@ -1,22 +0,0 @@
-
-  # 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

@@ -1,21 +0,0 @@
-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

@@ -1,64 +0,0 @@
-
-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

@@ -1,57 +0,0 @@
-# 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

@@ -1,99 +0,0 @@
-
-
-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

@@ -1,59 +0,0 @@
-
-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

@@ -1,51 +0,0 @@
-
-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

@@ -1,60 +0,0 @@
-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

@@ -1,57 +0,0 @@
-# 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