facets 1.7.46 → 1.8.0

data/work/core/join_with.rb

@@ -0,0 +1,13 @@
+
+class Array
+  def join_with( sep, fin=nil )
+    s = join(sep)
+    if fin
+      rsep = Regexp.escape(sep.to_s)
+      rlast = Regexp.escape(last.to_s)
+      s.sub!(/#{rsep}#{rlast}$/,"#{fin}#{last}")
+    end
+    return s
+  end
+end
+

data/work/core/kernel/call_line.rb

@@ -0,0 +1,15 @@
+module Kernel
+  # FIX ME!!!
+  # Return a string representing the line at the given call level,
+  # where level is the line desired, relative to the the method
+  # that called call_line.
+  def call_line(level=1)
+    dir = File.dirname(File.expand_path($0, Dir.getwd))
+    file, lineno, method = call_stack(level)
+    File.open(File.expand_path(file, dir)) do |input|
+      (lineno.to_i - 1).times { input.gets }
+      return input.gets
+    end
+  end
+end
+ 

data/work/core/kernel/does.rb

@@ -0,0 +1,7 @@
+# Yet another alias for proc.
+# This one would preferably be called just #do,
+# but that conflicts with Ruby's keyword.
+# (This should be in Kernel)
+def does(&blk)
+  return proc(&blk)
+end

data/work/core/kernel/message.rb

@@ -0,0 +1,6 @@
+module Kernel
+  # Like Kernel#called but would return [:meth, arg1, arg2 ...]
+  def message
+  
+  end
+end

data/work/core/kernel/query.rb

@@ -0,0 +1,15 @@
+class Object
+  def self.query( classes=nil, &blk )
+    objs = []
+    if mod
+      ObjectSpace.each_object(mod) do |o|
+        objs << o if blk.call(o)
+      end
+    else
+      ObjectSpace.each_object do |o|
+        objs << o if blk.call(o)
+      end
+    end
+    return objs
+  end
+end 

data/work/core/kernel/taint.rb

@@ -0,0 +1,10 @@
+$TAINT = {}
+module Kernel
+
+  #alias :req :require
+  def request( file, level )
+    $TAINT[file] = [Time.now, level]
+    require(file)
+  end
+
+end 

data/work/core/logger/clean_logger.rb

@@ -0,0 +1,10 @@
+require 'logger'
+
+class Logger #:nodoc:
+  private
+    remove_const "Format"
+    Format = "%s\n"
+    def format_message(severity, timestamp, msg, progname)
+      Format % [msg]
+    end
+end

data/work/core/module/attr-old.rb

@@ -0,0 +1,308 @@
+=begin
+ 
+$Title: Accessors $
+$Author: transami $
+$Date: 2004-10-06 13:56:57 $
+
+= Description
+
+  The Bill wants more from attributes.
+
+= Usage
+
+== Using Cast Attribute Accessors
+
+  
+== Using Accessor Shorthand
+
+  A nice shorthand is provided.
+
+    attr :r, :a, :a=, :w=, q?
+  
+  This is the same as doing
+  
+    attr_reader :r
+    attr_accessor :a
+    attr_writer :w
+    attr_tester :q
+    
+    def b?
+      @b ? true : @b
+    end
+  
+  The shorthand notation can be used with casting too.
+
+    attr :a => :to_s
+    init :a => 0
+
+== Using Return Value
+
+  Attribute methods now return a list of the methods created. 
+  This can then be passed to other useful methods.
+  
+    private attr :a
+
+= Authenticate
+  
+  Copyright (C) 2002 T. Sawyer
+  Ruby Distribute License
+  
+  This program is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby Distribute License.
+    
+=end
+
+require 'facet/hash/keys_to_sym'
+
+# Modify module attribute methods.
+# *add define_attribute
+# *redefine old attr_* methods
+# *add attr_setter
+
+class Module
+  
+  # Create an attribute method for reading an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_reader.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_reader :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a
+  #     @a.to_s
+  #   end
+  #
+  def attr_reader(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,d|
+      a = a.to_s.strip
+      #c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %{
+        def #{a}
+          @#{a} = #{d} unless defined?( @a )
+          @#{a}
+        end
+      }
+      made << "#{a}".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for writing to an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_writer.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_writer :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a=(x)
+  #     @a = x.to_s
+  #   end
+  #
+  def attr_writer(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('=').chomp('!')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}=(x); @#{a}=x#{c}; end }
+      made << "#{a}=".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for writing to an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_writer.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_accessor :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a
+  #     @a.to_s
+  #   end
+  #
+  #   def a=(x)
+  #     @a = x.to_s
+  #   end
+  #
+  def attr_accessor(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('=')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}; @#{a}#{c} ; end }
+      module_eval %Q{ def #{a}=(x); @#{a}=x#{c}; end }
+      made << "#{a}".to_sym
+      made << "#{a}=".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for boolean testing
+  # of an instance variable in the form of _var?_.
+  #
+  #   require 'facet/module/attr_tester'
+  #
+  #   attr_tester :a
+  #
+  # _is equivalent to_
+  #
+  #   def a?
+  #     @a ? true : @a
+  #   end
+  #
+  # Casting is also supported (see attr_reader).
+  #
+  #   attr_tester :a => :evaluate
+  #
+  # _is equivalent to_
+  #
+  #   def a?
+  #     @a.evaluate ? true : @a
+  #   end
+  #
+  def attr_tester(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('?')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}?; @#{a}#{c} ? true : @#{a}#{c}; end }
+      made << "#{a}?".to_sym
+    }
+    (@__atributes__ ||= []).concat made
+    return *made
+  end
+
+  # Create an attribute method for getting and setting an
+  # instance variable.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_setter :a
+  #
+  # _is equivalent to_
+  #
+  #   def a(*args)
+  #     if args.size > 0
+  #       @a = args[0]
+  #       self
+  #     else
+  #       @a
+  #     end
+  #   end
+  #
+  # Casting is supported on both getting and setting.
+  #
+  #   attr_setter :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a(*args)
+  #     @a = args[0].to_s if args.size > 0
+  #     @a.to_s
+  #   end
+  #
+  def attr_setter(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{
+        def #{a}(*args)
+          args.size > 0 ? ( @#{a}=args[0]#{c} ; self ) : @#{a}#{c}
+        end
+      }
+      made << "#{a}".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+  
+  def attr(*args)
+    # Allows compatibility with old definition, while also
+    # extending the capabilites to allow multiple parameters.
+    # Defaults do not work with the backward compatible form.
+    if TrueClass === args.last or FalseClass === args.last or NilClass === args.last
+      if args.pop
+        args.concat( args.collect{ |a|
+          a = a.to_s.strip
+          case a[-1,1]
+          when '=' 
+            a[0..-2]
+          when '?' 
+            "#{a[0..-2]}="
+          else
+            "#{a}="
+          end
+        } )
+      end
+    end
+    # main routine
+    made = []
+    args.each do |a|
+      a = a.to_s.strip
+      m = a.chomp('!').chomp('=').chomp('?')
+      case a.slice(-1,1)
+      when '='
+        module_eval %Q{ def #{m}=(x) ; @#{m}=x ; end }
+        made << :"#{m}="
+      when '?'
+        module_eval %Q{ def #{m}? ; @#{m} ? true : @#{m} ; end }
+        made << :"#{m}?"
+      else
+        module_eval %Q{ def #{m} ; @#{m} ; end }
+        made << :"#{m}"
+      end
+    end
+    return *made
+  end
+
+end

data/work/core/module/attr.rb

@@ -0,0 +1,98 @@
+require 'mega/preinitialize'
+
+class Module
+
+  # Shorthand notation for creating attributes.
+  #
+  #   attr :r, :w!, :a=
+  #
+  # is equivalent to
+  #
+  #   attr_reader :r
+  #   attr_writer :w
+  #   attr_accessor :a
+  #
+  # A pure writer notation is not provided b/c it is so rare.
+  # A "tester" shorthand is also provided (see #attr_checker)
+  #
+  #   attr :q?
+  #
+  # translates into
+  #
+  #   def q?
+  #     @q ? true : @q
+  #   end
+  #--
+  # :NOTE: Add this?
+  #   def q!(b=true)
+  #     @q = (b ? true : b)
+  #   end
+  #++
+  #
+  # Default values are also now possible using a hash.
+  #
+  #   cattr :a, :b => 10
+  #
+  # In this example @b will be initialized to 10 prior to running the
+  # initilaize routine. Attributes with default values must always
+  # appear at the end of the list.
+  #
+  # Compatability is maintained with the old version of #attr.
+  # So it is still possible to write:
+  #
+  #   attr :a, true
+  #
+  # It has been expanded to allow multiple names as well:
+  #
+  #   attr :a, :b, :c, true
+  #
+  def attr(*args)
+
+    # Allows compatibility with old definition, while also
+    # extending the capabilites to allow multiple parameters.
+    if TrueClass === args.last or FalseClass === args.last or NilClass === args.last
+      if args.pop
+        args.concat( args.collect{ |a|
+          a = a.to_s.strip
+          case a.slice(-1,1)
+          when '='
+            a[0..-2]
+          when '?'
+            "#{a[0..-2]}="
+          else
+            "#{a}="
+          end
+        } )
+      end
+    end
+
+    # for default values
+    hargs = {}
+    hargs = args.pop if Hash===args.last
+    unless hargs.empty?
+      (class << self; self; end).instance_eval do
+        default_instance_variables.update(hargs)
+      end
+    end
+
+    make = {}
+    (args.flatten+hargs.keys).each { |a|
+      t = a.to_s.slice(-1,1)
+      n = a.to_s.chomp('?').chomp('=').to_sym
+      m = a.to_sym
+      case t
+      when '?'
+        make[m] = %{ def #{n}? ; @#{n} ? true : @#{n} ; end }
+      when '='
+        make[m] = %{ def #{n}=(x) ; @#{n} = x ; end }
+        make[n] = %{ def #{n} ; @#{n} ; end }
+      else
+        make[m] = %{ def #{n} ; @#{n} ; end }
+      end
+    }
+    class_eval make.values.join("\n")
+
+    return make.keys
+  end
+
+end #Module