diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/.document | 3 | ||||
| -rw-r--r-- | lib/delegate.rb | 195 | ||||
| -rw-r--r-- | lib/forwardable.rb | 206 | ||||
| -rw-r--r-- | lib/optparse.rb | 2 | ||||
| -rw-r--r-- | lib/xmlrpc/client.rb | 2 | ||||
| -rw-r--r-- | lib/xmlrpc/server.rb | 6 | ||||
| -rw-r--r-- | lib/yaml.rb | 1 |
7 files changed, 328 insertions, 87 deletions
diff --git a/lib/.document b/lib/.document index f917e02070..8abcd21d93 100644 --- a/lib/.document +++ b/lib/.document @@ -14,8 +14,11 @@ cgi cgi.rb complex.rb date.rb +delegate.rb +erb.rb fileutils.rb find.rb +forwardable.rb generator.rb logger.rb matrix.rb diff --git a/lib/delegate.rb b/lib/delegate.rb index 83aaf292a5..b54b57d7b7 100644 --- a/lib/delegate.rb +++ b/lib/delegate.rb @@ -1,21 +1,119 @@ -# Delegation class that delegates even methods defined in super class, -# which can not be covered with normal method_missing hack. -# -# Delegator is the abstract delegation class. Need to redefine -# `__getobj__' method in the subclass. SimpleDelegator is the -# concrete subclass for simple delegation. +# = delegate -- Support for the Delegation Pattern # -# Usage: -# foo = Object.new -# foo2 = SimpleDelegator.new(foo) -# foo.hash == foo2.hash # => false +# Documentation by James Edward Gray II and Gavin Sinclair # -# Foo = DelegateClass(Array) +# == Introduction # -# class ExtArray<DelegateClass(Array) -# ... -# end +# This library provides three different ways to delegate method calls to an +# object. The easiest to use is SimpleDelegator. Pass an object to the +# constructor and all methods supported by the object will be delegated. This +# object can be changed later. +# +# Going a step further, the top level DelegateClass method allows you to easily +# setup delegation through class inheritance. This is considerably more +# flexible and thus probably the most common use for this library. +# +# Finally, if you need full control over the delegation scheme, you can inherit +# from the abstract class Delegator and customize as needed. (If you find +# yourself needing this control, have a look at _forwardable_, also in the +# standard library. It may suit your needs better.) +# +# == Notes +# +# Be advised, RDoc will not detect delegated methods. +# +# <b>delegate.rb provides full-class delegation via the +# DelegateClass() method. For single-method delegation via +# def_delegator(), see forwardable.rb.</b> +# +# == Examples +# +# === SimpleDelegator +# +# Here's a simple example that takes advantage of the fact that +# SimpleDelegator's delegation object can be changed at any time. +# +# class Stats +# def initialize +# @source = SimpleDelegator.new([]) +# end +# +# def stats( records ) +# @source.__setobj__(records) +# +# "Elements: #{@source.size}\n" + +# " Non-Nil: #{@source.compact.size}\n" + +# " Unique: #{@source.uniq.size}\n" +# end +# end +# +# s = Stats.new +# puts s.stats(%w{James Edward Gray II}) +# puts +# puts s.stats([1, 2, 3, nil, 4, 5, 1, 2]) +# +# <i>Prints:</i> +# +# Elements: 4 +# Non-Nil: 4 +# Unique: 4 +# +# Elements: 8 +# Non-Nil: 7 +# Unique: 6 +# +# === DelegateClass() +# +# Here's a sample of use from <i>tempfile.rb</i>. +# +# A _Tempfile_ object is really just a _File_ object with a few special rules +# about storage location and/or when the File should be deleted. That makes for +# an almost textbook perfect example of how to use delegation. +# +# class Tempfile < DelegateClass(File) +# # constant and class member data initialization... +# +# def initialize(basename, tmpdir=Dir::tmpdir) +# # build up file path/name in var tmpname... +# +# @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600) +# +# # ... +# +# super(@tmpfile) +# +# # below this point, all methods of File are supported... +# end +# +# # ... +# end +# +# === Delegator +# +# SimpleDelegator's implementation serves as a nice example here. +# +# class SimpleDelegator < Delegator +# def initialize(obj) +# super # pass obj to Delegator constructor, required +# @_sd_obj = obj # store obj for future use +# end +# +# def __getobj__ +# @_sd_obj # return object we are delegating to, required +# end +# +# def __setobj__(obj) +# @_sd_obj = obj # change delegation object, a feature we're providing +# end +# +# # ... +# end +# +# Delegator is an abstract class used to build delegator pattern objects from +# subclasses. Subclasses should redefine \_\_getobj\_\_. For a concrete +# implementation, see SimpleDelegator. +# class Delegator preserved = ["__id__", "object_id", "__send__", "respond_to?"] instance_methods.each do |m| @@ -23,10 +121,15 @@ class Delegator undef_method m end + # + # Pass in the _obj_ to delegate method calls to. All methods supported by + # _obj_ will be delegated to. + # def initialize(obj) __setobj__(obj) end + # Handles the magic of delegation through \_\_getobj\_\_. def method_missing(m, *args) begin target = self.__getobj__ @@ -40,42 +143,79 @@ class Delegator end end + # + # Checks for a method provided by this the delegate object by fowarding the + # call through \_\_getobj\_\_. + # def respond_to?(m) return true if super return self.__getobj__.respond_to?(m) end + # + # This method must be overridden by subclasses and should return the object + # method calls are being delegated to. + # def __getobj__ raise NotImplementedError, "need to define `__getobj__'" end + # + # This method must be overridden by subclasses and change the object delegate + # to _obj_. + # def __setobj__(obj) raise NotImplementedError, "need to define `__setobj__'" end + # Serialization support for the object returned by \_\_getobj\_\_. def marshal_dump __getobj__ end + # Reinitializes delegation from a serialized object. def marshal_load(obj) __setobj__(obj) end end +# +# A concrete implementation of Delegator, this class provides the means to +# delegate all supported method calls to the object passed into the constructor +# and even to change the object being delegated to at a later time with +# \_\_setobj\_\_ . +# class SimpleDelegator<Delegator + # Returns the current object method calls are being delegated to. def __getobj__ @_sd_obj end + # + # Changes the delegate object to _obj_. + # + # It's important to note that this does *not* cause SimpleDelegator's methods + # to change. Because of this, you probably only want to change delegation + # to objects of the same type as the original delegate. + # + # Here's an example of changing the delegation object. + # + # names = SimpleDelegator.new(%w{James Edward Gray II}) + # puts names[1] # => Edward + # names.__setobj__(%w{Gavin Sinclair}) + # puts names[1] # => Sinclair + # def __setobj__(obj) raise ArgumentError, "cannot delegate to self" if self.equal?(obj) @_sd_obj = obj end + # Clone support for the object returned by \_\_getobj\_\_. def clone copy = super copy.__setobj__(__getobj__.clone) copy end + # Duplication support for the object returned by \_\_getobj\_\_. def dup copy = super copy.__setobj__(__getobj__.dup) @@ -83,11 +223,22 @@ class SimpleDelegator<Delegator end end +# :stopdoc: # backward compatibility ^_^;;; Delegater = Delegator SimpleDelegater = SimpleDelegator +# :startdoc: # +# The primary interface to this library. Use to setup delegation when defining +# your class. +# +# class MyClass < DelegateClass( ClassToDelegateTo ) # Step 1 +# def initiaize +# super(obj_of_ClassToDelegateTo) # Step 2 +# end +# end +# def DelegateClass(superclass) klass = Class.new methods = superclass.public_instance_methods(true) @@ -97,31 +248,31 @@ def DelegateClass(superclass) "clone", "dup", "marshal_dump", "marshal_load", ] klass.module_eval { - def initialize(obj) + def initialize(obj) # :nodoc: @_dc_obj = obj end - def method_missing(m, *args) + def method_missing(m, *args) # :nodoc: unless @_dc_obj.respond_to?(m) super(m, *args) end @_dc_obj.__send__(m, *args) end - def respond_to?(m) + def respond_to?(m) # :nodoc: return true if super return @_dc_obj.respond_to?(m) end - def __getobj__ + def __getobj__ # :nodoc: @_dc_obj end - def __setobj__(obj) + def __setobj__(obj) # :nodoc: raise ArgumentError, "cannot delegate to self" if self.equal?(obj) @_dc_obj = obj end - def clone + def clone # :nodoc: super __setobj__(__getobj__.clone) end - def dup + def dup # :nodoc: super __setobj__(__getobj__.dup) end @@ -145,6 +296,8 @@ def DelegateClass(superclass) return klass end +# :enddoc: + if __FILE__ == $0 class ExtArray<DelegateClass(Array) def initialize() diff --git a/lib/forwardable.rb b/lib/forwardable.rb index b845f76ec4..3e979a3155 100644 --- a/lib/forwardable.rb +++ b/lib/forwardable.rb @@ -5,90 +5,174 @@ # $Date$ # by Keiju ISHITSUKA(keiju@ishitsuka.com) # original definition by delegator.rb -# -- -# Usage: +# Revised by Daniel J. Berger with suggestions from Florian Gross. # -# class Foo +# Documentation by James Edward Gray II and Gavin Sinclair +# +# == Introduction +# +# This library allows you delegate method calls to an object, on a method by +# method basis. +# +# == Notes +# +# Be advised, RDoc will not detect delegated methods. +# +# <b>forwardable.rb provides single-method delegation via the +# def_delegator() and def_delegators() methods. For full-class +# delegation via DelegateClass(), see delegate.rb.</b> +# +# == Examples +# +# === Forwardable +# +# Forwardable makes building a new class based on existing work, with a proper +# interface, almost trivial. We want to rely on what has come before obviously, +# but with delegation we can take just the methods we need and even rename them +# as appropriate. In many cases this is preferable to inheritance, which gives +# us the entire old interface, even if much of it isn't needed. +# +# class Queue # extend Forwardable +# +# def initialize +# @q = [ ] # prepare delegate object +# end +# +# # setup prefered interface, enq() and deq()... +# def_delegator :@q, :push, :enq +# def_delegator :@q, :shift, :deq +# +# # support some general Array methods that fit Queues well +# def_delegators :@q, :clear, :first, :push, :shift, :size +# end +# +# q = Queue.new +# q.enq 1, 2, 3, 4, 5 +# q.push 6 +# +# q.shift # => 1 +# while q.size > 0 +# puts q.deq +# end +# +# q.enq "Ruby", "Perl", "Python" +# puts q.first +# q.clear +# puts q.first # -# def_delegators("@out", "printf", "print") -# def_delegators(:@in, :gets) -# def_delegator(:@contents, :[], "content_at") +# <i>Prints:</i> +# +# 2 +# 3 +# 4 +# 5 +# 6 +# Ruby +# nil +# +# Forwardable can be used to setup delegation at the object level as well. +# +# printer = String.new +# printer.extend Forwardable # prepare object for delegation +# printer.def_delegator "STDOUT", "puts" # add delegation for STDOUT.puts() +# printer.puts "Howdy!" +# +# <i>Prints:</i> +# +# Howdy! + +# +# The Forwardable module provides delegation of specified +# methods to a designated object, using the methods #def_delegator +# and #def_delegators. +# +# For example, say you have a class RecordCollection which +# contains an array <tt>@records</tt>. You could provide the lookup method +# #record_number(), which simply calls #[] on the <tt>@records</tt> +# array, like this: +# +# class RecordCollection +# extends Forwardable +# def_delegator :@records, :[], :record_number +# end +# +# Further, if you wish to provide the methods #size, #<<, and #map, +# all of which delegate to @records, this is how you can do it: +# +# class RecordCollection +# # extends Forwardable, but we did that above +# def_delegators :@records, :size, :<<, :map # end # f = Foo.new # f.printf ... # f.gets # f.content_at(1) # -# g = Goo.new -# g.extend SingleForwardable -# g.def_delegator("@out", :puts) -# g.puts ... -# -# +# Also see the example at forwardable.rb. module Forwardable - - @debug = nil - class<<self - attr_accessor :debug + FORWARDABLE_VERSION = "1.0.0" + + # Takes a hash as its argument. The key is a symbol or an array of + # symbols. These symbols correspond to method names. The value is + # the accessor to which the methods will be delegated. + # + # :call-seq: + # delegate method => accessor + # delegate [method, method, ...] => accessor + # + def delegate(hash) + hash.each{ |methods, accessor| + methods = methods.to_s unless methods.respond_to?(:each) + methods.each{ |method| + def_instance_delegator(accessor, method) + } + } end + # + # Shortcut for defining multiple delegator methods, but with no + # provision for using a different name. The following two code + # samples have the same effect: + # + # def_delegators :@records, :size, :<<, :map + # + # def_delegator :@records, :size + # def_delegator :@records, :<< + # def_delegator :@records, :map + # def def_instance_delegators(accessor, *methods) - for method in methods + methods.delete("__send__") + methods.delete("__id__") + methods.each{ |method| def_instance_delegator(accessor, method) - end + } end + # + # Defines a method _method_ which delegates to _obj_ (i.e. it calls + # the method of the same name in _obj_). If _new_name_ is + # provided, it is used as the name for the delegate method. + # def def_instance_delegator(accessor, method, ali = method) - accessor = accessor.id2name if accessor.kind_of?(Integer) - method = method.id2name if method.kind_of?(Integer) - ali = ali.id2name if ali.kind_of?(Integer) - - module_eval(<<-EOS, "(__FORWARDABLE__)", 1) + str = %Q{ def #{ali}(*args, &block) - begin - #{accessor}.__send__(:#{method}, *args, &block) - rescue Exception - $@.delete_if{|s| /^\\(__FORWARDABLE__\\):/ =~ s} unless Forwardable::debug - Kernel::raise - end + #{accessor}.send(:#{method}, *args, &block) end - EOS - end - - alias def_delegators def_instance_delegators - alias def_delegator def_instance_delegator -end + } -module SingleForwardable - def def_singleton_delegators(accessor, *methods) - for method in methods - def_singleton_delegator(accessor, method) + # If it's not a class or module, it's an instance + begin + module_eval(str) + rescue + instance_eval(str) end end - def def_singleton_delegator(accessor, method, ali = method) - accessor = accessor.id2name if accessor.kind_of?(Integer) - method = method.id2name if method.kind_of?(Integer) - ali = ali.id2name if ali.kind_of?(Integer) - - instance_eval(<<-EOS, "(__FORWARDABLE__)", 1) - def #{ali}(*args, &block) - begin - #{accessor}.__send__(:#{method}, *args,&block) - rescue Exception - $@.delete_if{|s| /^\\(__FORWARDABLE__\\):/ =~ s} unless Forwardable::debug - Kernel::raise - end - end - EOS - end - - alias def_delegators def_singleton_delegators - alias def_delegator def_singleton_delegator + alias def_delegators def_instance_delegators + alias def_delegator def_instance_delegator end - - - +# compatibility +SingleForwardable = Forwardable diff --git a/lib/optparse.rb b/lib/optparse.rb index f1f207327d..c056ac8d25 100644 --- a/lib/optparse.rb +++ b/lib/optparse.rb @@ -352,7 +352,7 @@ class OptionParser # : (({block})) # (({yields})) at semi-error condition, instead of raises exception. # - def conv_arg(arg, val = nil) + def conv_arg(arg, val = []) if block if conv val = conv.call(*val) diff --git a/lib/xmlrpc/client.rb b/lib/xmlrpc/client.rb index 074f5014cf..dadd3279f2 100644 --- a/lib/xmlrpc/client.rb +++ b/lib/xmlrpc/client.rb @@ -500,7 +500,7 @@ module XMLRPC def do_rpc(request, async=false) header = { "User-Agent" => USER_AGENT, - "Content-Type" => "text/xml", + "Content-Type" => "text/xml; charset=utf-8", "Content-Length" => request.size.to_s, "Connection" => (async ? "close" : "keep-alive") } diff --git a/lib/xmlrpc/server.rb b/lib/xmlrpc/server.rb index 43041f343f..59a5869408 100644 --- a/lib/xmlrpc/server.rb +++ b/lib/xmlrpc/server.rb @@ -456,7 +456,7 @@ class CGIServer < BasicServer http_error(400, "Bad Request") if data.nil? or data.size != length - http_write(process(data), "Content-type" => "text/xml") + http_write(process(data), "Content-type" => "text/xml; charset=utf-8") } end @@ -531,7 +531,7 @@ class ModRubyServer < BasicServer http_error(400, "Bad Request") if data.nil? or data.size != length - http_write(process(data), 200, "Content-type" => "text/xml") + http_write(process(data), 200, "Content-type" => "text/xml; charset=utf-8") } end @@ -764,7 +764,7 @@ class WEBrickServlet < BasicServer response.status = 200 response['Content-Length'] = resp.size - response['Content-Type'] = "text/xml" + response['Content-Type'] = "text/xml; charset=utf-8" response.body = resp end end diff --git a/lib/yaml.rb b/lib/yaml.rb index 5d409cfae3..cdce7f7635 100644 --- a/lib/yaml.rb +++ b/lib/yaml.rb @@ -11,6 +11,7 @@ require 'yaml/error' require 'yaml/syck' require 'yaml/tag' require 'yaml/stream' +require 'yaml/constants' # == YAML # |