# With English:

#

# require "English"

# $OUTPUT_FIELD_SEPARATOR = ' -- '

# "waterbuffalo" =~ /buff/

# print $LOADED_FEATURES, $POSTMATCH, $PID, "\n"

# of the contents of all the files

# given as command-line arguments, or <tt>$stdin</tt>

# (in the case where there are no

# +File+ object:

# +inmode+, +close+,

# <tt>closed?</tt>, +each+,

# +eof+, <tt>eof?</tt>, +file+,

# +filename+, +fileno+,

# +getc+, +gets+, +lineno+,

# +pos+, <tt>pos=</tt>,

# +read+, +readchar+,

# +readline+, +readlines+,

alias $MATCH $&

# The string preceding the match in the last

# the current scope. Read only. Thread local.

alias $PREMATCH $`

# The string following the match in the last

# the current scope. Read only. Thread local.

alias $POSTMATCH $'

#

# = base64.rb: methods for base64-encoding and -decoding strings

#

# Documentation:: Dave Thomas and Gavin Sinclair

#

# Until Ruby 1.8.1, these methods were defined at the top-level. Now

# The Base64 module provides for the encoding (#encode64) and decoding

# (#decode64) of binary data using a Base64 representation.

# The following particular features are also provided:

# - encode into lines of a given length (#b64encode)

# - decode the special format specified in RFC2047 for the

#

# == Example

#

# require "base64"

#

# enc = Base64.encode64('Send reinforcements')

# plain = Base64.decode64(enc)

# # -> "Send reinforcements"

#

decode64($1)

}

str = Kconv::toeuc(str)

str.gsub!(/\0/, '')

str

end

# +len+ (default 60) characters.

#

# require 'base64'

# Base64.b64encode(data)

#

# <i>Generates:</i>

encode64(bin).scan(/.{1,#{len}}/) do

print $&, "\n"

end

module Deprecated # :nodoc:

=begin

#

# $Id$

#

# Documentation by Gotoken (original RD), Lyle Johnson (RDoc conversion), and

#

=end

# require 'benchmark'

#

# puts Benchmark.measure { "a"*1_000_000 }

# On my machine (FreeBSD 3.2 on P5, 100MHz) this generates:

# 1.166667 0.050000 1.216667 ( 0.571355)

# This report shows the user CPU time, system CPU time, the sum of

# the user and system CPU times, and the elapsed real time. The unit

# of time is seconds.

# * Do some experiments sequentially using the #bm method:

#

# require 'benchmark'

# x.report { n.times do ; a = "1"; end }

# x.report { 1.upto(n) do ; a = "1"; end }

# end

# The result:

#

# user system total real

# x.report("times:") { n.times do ; a = "1"; end }

# x.report("upto:") { 1.upto(n) do ; a = "1"; end }

# end

# The result:

# user system total real

# for: 1.050000 0.000000 1.050000 ( 0.503462)

# times: 1.533333 0.016667 1.550000 ( 0.735473)

# upto: 1.500000 0.016667 1.516667 ( 0.711239)

#

# * The times for some benchmarks depend on the order in which items

# are run. These differences are due to the cost of memory

# sort an array of floats:

#

# require 'benchmark'

# array = (1..1000000).map { rand }

# Benchmark.bmbm do |x|

# x.report("sort!") { array.dup.sort! }

# x.report("sort") { array.dup.sort }

# end

# The result:

# Rehearsal -----------------------------------------

# sort! 11.928000 0.010000 11.938000 ( 12.756000)

# sort 13.048000 0.020000 13.068000 ( 13.857000)

# ------------------------------- total: 25.006000sec

# user system total real

# sort! 12.959000 0.010000 12.969000 ( 13.793000)

# sort 12.007000 0.000000 12.007000 ( 12.791000)

# using the #benchmark method:

#

# require 'benchmark'

#

# n = 50000

# Benchmark.benchmark(" "*7 + CAPTION, 7, FMTSTR, ">total:", ">avg:") do |x|

# tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end }

# [tf+tt+tu, (tf+tt+tu)/3]

# end

# The result:

# user system total real

# for: 1.016667 0.016667 1.033333 ( 0.485749)

# times: 1.450000 0.016667 1.466667 ( 0.681367)

# suitable for nearly all benchmarking requirements. See the examples in

# Benchmark, and the #bm and #bmbm methods.

#

#

# require 'benchmark'

#

# n = 50000

# Benchmark.benchmark(" "*7 + CAPTION, 7, FMTSTR, ">total:", ">avg:") do |x|

# tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end }

# [tf+tt+tu, (tf+tt+tu)/3]

# end

# <i>Generates:</i>

# user system total real

# for: 1.016667 0.016667 1.033333 ( 0.485749)

# times: 1.450000 0.016667 1.466667 ( 0.681367)

# upto: 1.533333 0.000000 1.533333 ( 0.722166)

# >total: 4.000000 0.033333 4.033333 ( 1.889282)

# >avg: 1.333333 0.011111 1.344444 ( 0.629761)

def benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) # :yield: report

sync = STDOUT.sync

print caption

results = yield(Report.new(label_width, fmtstr))

Array === results and results.grep(Tms).each {|t|

t.format(fmtstr))

}

STDOUT.sync = sync

# A simple interface to the #benchmark method, #bm is generates sequential reports

# with labels. The parameters have the same meaning as for #benchmark.

# require 'benchmark'

#

# n = 50000

# x.report("times:") { n.times do ; a = "1"; end }

# x.report("upto:") { 1.upto(n) do ; a = "1"; end }

# end

# <i>Generates:</i>

# user system total real

# for: 1.050000 0.000000 1.050000 ( 0.503462)

# times: 1.533333 0.016667 1.550000 ( 0.735473)

# calculate the required label width.

#

# require 'benchmark'

# array = (1..1000000).map { rand }

# Benchmark.bmbm do |x|

# x.report("sort!") { array.dup.sort! }

# x.report("sort") { array.dup.sort }

# end

# <i>Generates:</i>

# Rehearsal -----------------------------------------

# sort! 11.928000 0.010000 11.938000 ( 12.756000)

# sort 13.048000 0.020000 13.068000 ( 13.857000)

# ------------------------------- total: 25.006000sec

# user system total real

# sort! 12.959000 0.010000 12.969000 ( 13.793000)

# sort 12.007000 0.000000 12.007000 ( 12.791000)

ets = sum.format("total: %tsec")

printf("%s %s\n\n",

"-"*(width+CAPTION.length-ets.length-1), ets)

# take

print ' '*width, CAPTION

list = []

ary

end

# Returns the time used to execute the given block as a

# Benchmark::Tms object.

#

t0, r0 = Benchmark.times, Time.now

yield

t1, r1 = Benchmark.times, Time.now

r1.to_f - r0.to_f,

label)

end

# Usually, one doesn't call this method directly, as new

# Job objects are created by the #bmbm method.

# _width_ is a initial value for the label offset used in formatting;

def initialize(width)

@width = width

@list = []

end

alias report item

# An array of 2-element arrays, consisting of label and block pairs.

attr_reader :list

attr_reader :width

end

#

# Returns an initialized Report instance.

# Usually, one doesn't call this method directly, as new

def initialize(width = 0, fmtstr = nil)

@width, @fmtstr = width, fmtstr

end

# User CPU time

attr_reader :utime

# System CPU time

attr_reader :stime

# User CPU time of children

attr_reader :cutime

# System CPU time of children

attr_reader :cstime

# Elapsed real time

attr_reader :real

attr_reader :total

# Label

attr_reader :label

#

# Returns an initialized Tms object which has

# _cu_ as the children's user CPU time, _cs_ as the children's

# system CPU time, _real_ as the elapsed real time and _l_

def initialize(u = 0.0, s = 0.0, cu = 0.0, cs = 0.0, real = 0.0, l = nil)

@utime, @stime, @cutime, @cstime, @real, @label = u, s, cu, cs, real, l

@total = @utime + @stime + @cutime + @cstime

end

# Returns a new Tms object whose times are the sum of the times for this

# Tms object, plus the time required to execute the code block (_blk_).

def add(&blk) # :yield:

end

# An in-place version of #add.

def add!

@utime = utime + t.utime

@stime = stime + t.stime

@cutime = cutime + t.cutime

self

end

# Returns a new Tms object obtained by memberwise summation

# of the individual times for this Tms object with those of the other

# Tms object.

def +(other); memberwise(:+, other) end

#

# Returns a new Tms object obtained by memberwise subtraction

# of the individual times for the other Tms object from those of this

# Tms object.

#

def -(other); memberwise(:-, other) end

#

# Returns a new Tms object obtained by memberwise multiplication

# of the individual times for this Tms object by _x_.

#

def *(x); memberwise(:*, x) end

# Returns a new Tms object obtained by memberwise division

# of the individual times for this Tms object by _x_.

def /(x); memberwise(:/, x) end

#

#

# <tt>%u</tt>:: Replaced by the user CPU time, as reported by Tms#utime.

# <tt>%y</tt>:: Replaced by the system CPU time, as reported by #stime (Mnemonic: y of "s*y*stem")

# <tt>%Y</tt>:: Replaced by the children's system CPU time, as reported by Tms#cstime

# <tt>%t</tt>:: Replaced by the total CPU time, as reported by Tms#total

# <tt>%r</tt>:: Replaced by the elapsed real time, as reported by Tms#real

# <tt>%n</tt>:: Replaced by the label string, as reported by Tms#label (Mnemonic: n of "*n*ame")

# If _fmtstr_ is not given, FMTSTR is used as default value, detailing the

# user, system and real elapsed time.

def format(arg0 = nil, *args)

fmtstr = (arg0 || FMTSTR).dup

fmtstr.gsub!(/(%[-+\.\d]*)n/){"#{$1}s" % label}

arg0 ? Kernel::format(fmtstr, *args) : fmtstr

end

# Same as #format.

def to_s

format

end

# Returns a new 6-element array, consisting of the

# label, user CPU time, system CPU time, children's

# user CPU time, children's system CPU time and elapsed

# real time.

def to_a

[@label, @utime, @stime, @cutime, @cstime, @real]

end

# The default caption string (heading above the output times).

CAPTION = Benchmark::Tms::CAPTION

FMTSTR = Benchmark::Tms::FMTSTR

end

# cgi.rb - cgi support library

# Copyright (C) 2000 Network Applied Communication Laboratory, Inc.

# Copyright (C) 2000 Information-technology Promotion Agency, Japan

#

# Author: Wakou Aoyama <[email protected]>

#

# == Overview

#

# The Common Gateway Interface (CGI) is a simple protocol

# parameters of the request passed in either in the

# environment (GET) or via $stdin (POST), and everything

# it prints to $stdout is returned to the client.

# This file holds the +CGI+ class. This class provides

# functionality for retrieving HTTP request parameters,

# managing cookies, and generating HTML output. See the

#

#

# For each of these variables, there is a corresponding attribute with the

# +content_length+ and +server_port+ are integers; the rest are strings.

#

# === Parameters

#

# The method #params() returns a hash of all parameters in the request as

# name/value-list pairs, where the value-list is an Array of one or more

# parameter name.

#

# "favourite_colours" with the multiple values "blue" and "green". The

# following behaviour would occur:

#

#

# === Multipart requests

#

# then it may contain uploaded files. These are stored by the QueryExtension

# module in the parameters of the request. The parameter name is the name

# attribute of the file input field, as usual. However, the value is not

#

# Each HTML element has a corresponding method for generating that

# element as a String. The name of this method is the same as that

# passed in as a hash, and the body as a no-argument block that evaluates

# to a String. The HTML generation module knows which elements are

# always empty, and silently drops any passed-in body. It also knows

# as arguments, rather than via a hash.

#

# == Examples of use

# === Get form values

# require "cgi"

# cgi = CGI.new

# value = cgi['field_name'] # <== value string for 'field_name'

# # if not 'field_name' included, then return "".

# fields = cgi.keys # <== array of field names

# # returns true if form has 'field_name'

# cgi.has_key?('field_name')

# cgi.has_key?('field_name')

# cgi.include?('field_name')

# cgi.rb(included in ruby 1.6)

# === Get form values as hash

# require "cgi"

# cgi = CGI.new

# params = cgi.params

# cgi.params is a hash.

# cgi.params['new_field_name'] = ["value"] # add new param

# cgi.params['field_name'] = ["new_value"] # change value

# cgi.params.delete('field_name') # delete param

# cgi.params.clear # delete all params

# === Save form values to file

# require "pstore"

# db = PStore.new("query.db")

# db.transaction do

# db["params"] = cgi.params

# end

# === Restore form values from file

# require "pstore"

# db = PStore.new("query.db")

# db.transaction do

# cgi.params = db["params"]

# end

# === Get multipart form values

# require "cgi"

# cgi = CGI.new

# value = cgi['field_name'] # <== value string for 'field_name'

# value.local_path # <== path to local file of value

# value.original_filename # <== original filename of value

# value.content_type # <== content_type of value

# and value has StringIO or Tempfile class methods.

# === Get cookie values

# require "cgi"

# cgi = CGI.new

# values = cgi.cookies['name'] # <== array of 'name'

# # if not 'name' included, then return [].

# names = cgi.cookies.keys # <== array of cookie names

# and cgi.cookies is a hash.

# === Get cookie objects

# require "cgi"

# cgi = CGI.new

# for name, cookie in cgi.cookies

# cookie.expires = Time.now + 30

# end

# cgi.out("cookie" => cgi.cookies) {"string"}

# cgi.cookies # { "name1" => cookie1, "name2" => cookie2, ... }

# require "cgi"

# cgi = CGI.new

# cgi.cookies['name'].expires = Time.now + 30

# cgi.out("cookie" => cgi.cookies['name']) {"string"}

# === Print http header and html string to $DEFAULT_OUTPUT ($>)

# require "cgi"

# cgi = CGI.new("html3") # add HTML generation methods

# cgi.out() do

# end

# end

# end

# # add HTML generation methods

# CGI.new("html3") # html3.2

# CGI.new("html4") # html4.01 (Strict)

REVISION = '$Id$' #:nodoc:

# Path separators in different environments.

PATH_SEPARATOR = {'UNIX'=>'/', 'WINDOWS'=>'\\', 'MACINTOSH'=>':'}

# :startdoc:

ENV

end

# print CGI::unescapeElement(

# CGI::escapeHTML('<BR><A HREF="url"></A>'), "A", "IMG")

# # "&lt;BR&gt;<A HREF="url"></A>"

# print CGI::unescapeElement(

# CGI::escapeHTML('<BR><A HREF="url"></A>'), ["A", "IMG"])

# # "&lt;BR&gt;<A HREF="url"></A>"

# status:: the HTTP status code, returned as the Status header. See the

# list of available status codes below.

# server:: the server software, returned as the Server header.

# instance, "close".

# length:: the length of the content that will be sent, returned as the

# Content-Length header.

# object, returned as the Expires header.

# cookie:: a cookie or cookies, returned as one or more Set-Cookie headers.

# The value can be the literal string of the cookie; a CGI::Cookie

# hash all of whose values are literal cookie strings or Cookie objects.

# These cookies are in addition to the cookies held in the

# @output_cookies field.

#

# Other header lines can also be set; they are appended as key: value.

# header

# # Content-Type: text/html

# header("text/plain")

# # Content-Type: text/plain

# header("nph" => true,

# "status" => "OK", # == "200 OK"

# # "status" => "200 GOOD",

# "cookie" => [cookie1, cookie2],

# "my_header1" => "my_value"

# "my_header2" => "my_value")

# The status codes are:

# "OK" --> "200 OK"

# "PARTIAL_CONTENT" --> "206 Partial Content"

# "MULTIPLE_CHOICES" --> "300 Multiple Choices"

# "NOT_IMPLEMENTED" --> "501 Method Not Implemented"

# "BAD_GATEWAY" --> "502 Bad Gateway"

# "VARIANT_ALSO_VARIES" --> "506 Variant Also Negotiates"

#

def header(options = "text/html")

# # Content-Length: 6

# #

# # string

# cgi.out("text/plain") { "string" }

# # Content-Type: text/plain

# # Content-Length: 6

# #

# # string

# cgi.out("nph" => true,

# "status" => "OK", # == "200 OK"

# "server" => ENV['SERVER_SOFTWARE'],

# "cookie" => [cookie1, cookie2],

# "my_header1" => "my_value",

# "my_header2" => "my_value") { "string" }

# Content-Length is automatically calculated from the size of

# the String returned by the content block.

#

# If ENV['REQUEST_METHOD'] == "HEAD", then only the header

# is outputted (the content block is still required, but it

# is ignored).

# If the charset is "iso-2022-jp" or "euc-jp" or "shift_jis" then

# to "ja".

def out(options = "text/html") # :yield:

# 'expires' => Time.now, # optional

# 'secure' => true # optional

# )

# cgi.out("cookie" => [cookie1, cookie2]) { "string" }

# name = cookie1.name

# values = cookie1.value

# path = cookie1.path

# domain = cookie1.domain

# expires = cookie1.expires

# secure = cookie1.secure

# cookie1.name = 'name'

# cookie1.value = ['value1', 'value2', ...]

# cookie1.path = 'path'

# domain:: the domain for which this cookie applies.

# expires:: the time at which this cookie expires, as a +Time+ object.

# secure:: whether this cookie is a secure cookie or not (default to

# servers.

#

# These keywords correspond to attributes of the cookie object.

# Mixin module. It provides the follow functionality groups:

#

# documentation to the CGI class for a list of these variables.

#

# 2. Access to cookies, including the cookies attribute.

(not /MSIE/ni.match(env_table['HTTP_USER_AGENT']))

filename = CGI::unescape(filename)

end

/Content-Type: ([^\s]*)/ni.match(head)

content_type = ($1 or "")

# Get the value for the parameter with a given key.

#

# retrieved; use #params() to get the array of values.

def [](key)

params = @params[key]

# # <BODY>

# # </BODY>

# # </HTML>

# print CGI::pretty("<HTML><BODY></BODY></HTML>", "\t")

# # <HTML>

# # <BODY>

# Modules Http3, Http4, etc., contain more basic HTML-generation methods

# (:title, :center, etc.).

#

#

module HtmlExtension

end

end

#

# +href+ can either by a string, giving the base URL for the HREF

# attribute, or it can be a has of the element's attributes.

#

# checkbox("name")

# # = checkbox("NAME" => "name")

# checkbox("name", "value")

# # = checkbox("NAME" => "name", "VALUE" => "value")

# checkbox("name", "value", true)

# # = checkbox("NAME" => "name", "VALUE" => "value", "CHECKED" => true)

def checkbox(name = "", value = nil, checked = nil)

# # <INPUT TYPE="checkbox" NAME="name" VALUE="foo">foo

# # <INPUT TYPE="checkbox" NAME="name" VALUE="bar">bar

# # <INPUT TYPE="checkbox" NAME="name" VALUE="baz">baz

# checkbox_group("name", ["foo"], ["bar", true], "baz")

# # <INPUT TYPE="checkbox" NAME="name" VALUE="foo">foo

# # <INPUT TYPE="checkbox" CHECKED NAME="name" VALUE="bar">bar

# # <INPUT TYPE="checkbox" NAME="name" VALUE="baz">baz

# checkbox_group("name", ["1", "Foo"], ["2", "Bar", true], "Baz")

# # <INPUT TYPE="checkbox" NAME="name" VALUE="1">Foo

# # <INPUT TYPE="checkbox" CHECKED NAME="name" VALUE="2">Bar

# # <INPUT TYPE="checkbox" NAME="name" VALUE="Baz">Baz

# checkbox_group("NAME" => "name",

# "VALUES" => ["foo", "bar", "baz"])

# checkbox_group("NAME" => "name",

# "VALUES" => [["foo"], ["bar", true], "baz"])

# checkbox_group("NAME" => "name",

# "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"])

def checkbox_group(name = "", *values)

#

# file_field("name")

# # <INPUT TYPE="file" NAME="name" SIZE="20">

# file_field("name", 40)

# # <INPUT TYPE="file" NAME="name" SIZE="40">

# file_field("name", 40, 100)

# # <INPUT TYPE="file" NAME="name" SIZE="40" MAXLENGTH="100">

# file_field("NAME" => "name", "SIZE" => 40)

# # <INPUT TYPE="file" NAME="name" SIZE="40">

def file_field(name = "", size = 20, maxlength = nil)

#

# +method+ should be either "get" or "post", and defaults to the latter.

# +action+ defaults to the current CGI script name. +enctype+

#

# Alternatively, the attributes can be specified as a hash.

#

#

# form{ "string" }

# # <FORM METHOD="post" ENCTYPE="application/x-www-form-urlencoded">string</FORM>

# form("get") { "string" }

# # <FORM METHOD="get" ENCTYPE="application/x-www-form-urlencoded">string</FORM>

# form("get", "url") { "string" }

# # <FORM METHOD="get" ACTION="url" ENCTYPE="application/x-www-form-urlencoded">string</FORM>

# form("METHOD" => "post", "ENCTYPE" => "enctype") { "string" }

# # <FORM METHOD="post" ENCTYPE="enctype">string</FORM>

def form(method = "post", action = script_name, enctype = "application/x-www-form-urlencoded")

attributes = if method.kind_of?(String)

{ "METHOD" => method, "ACTION" => action,

else

unless method.has_key?("METHOD")

method["METHOD"] = "post"

#

# hidden("name")

# # <INPUT TYPE="hidden" NAME="name">

# hidden("name", "value")

# # <INPUT TYPE="hidden" NAME="name" VALUE="value">

# hidden("NAME" => "name", "VALUE" => "reset", "ID" => "foo")

# # <INPUT TYPE="hidden" NAME="name" VALUE="value" ID="foo">

def hidden(name = "", value = nil)

# should include the entire text of this tag, including angle brackets.

#

# The body of the html element is supplied as a block.

# html{ "string" }

# # <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><HTML>string</HTML>

# html("LANG" => "ja") { "string" }

# # <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><HTML LANG="ja">string</HTML>

# html("DOCTYPE" => false) { "string" }

# # <HTML>string</HTML>

# html("DOCTYPE" => '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">') { "string" }

# # <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"><HTML>string</HTML>

# html("PRETTY" => " ") { "<BODY></BODY>" }

# # <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">

# # <HTML>

# # <BODY>

# # </BODY>

# # </HTML>

# html("PRETTY" => "\t") { "<BODY></BODY>" }

# # <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">

# # <HTML>

# # <BODY>

# # </BODY>

# # </HTML>

# html("PRETTY") { "<BODY></BODY>" }

# # = html("PRETTY" => " ") { "<BODY></BODY>" }

# html(if $VERBOSE then "PRETTY" end) { "HTML string" }

#

def html(attributes = {}) # :yield:

# Generate an Image Button Input element as a string.

#

# is the input name. +alt+ is the alternative text for the image.

#

# Alternatively, the attributes can be specified as a hash.

# image_button("url")

# # <INPUT TYPE="image" SRC="url">

# image_button("url", "name", "string")

# # <INPUT TYPE="image" SRC="url" NAME="name" ALT="string">

# image_button("SRC" => "url", "ATL" => "string")

# # <INPUT TYPE="image" SRC="url" ALT="string">

def image_button(src = "", name = nil, alt = nil)

#

# img("src", "alt", 100, 50)

# # <IMG SRC="src" ALT="alt" WIDTH="100" HEIGHT="50">

# img("SRC" => "src", "ALT" => "alt", "WIDTH" => 100, "HEIGHT" => 50)

# # <IMG SRC="src" ALT="alt" WIDTH="100" HEIGHT="50">

def img(src = "", alt = "", width = nil, height = nil)

#

# multipart_form{ "string" }

# # <FORM METHOD="post" ENCTYPE="multipart/form-data">string</FORM>

# multipart_form("url") { "string" }

# # <FORM METHOD="post" ACTION="url" ENCTYPE="multipart/form-data">string</FORM>

def multipart_form(action = nil, enctype = "multipart/form-data")

attributes = if action == nil

elsif action.kind_of?(String)

{ "METHOD" => "post", "ACTION" => action,

else

unless action.has_key?("METHOD")

action["METHOD"] = "post"

#

# password_field("name")

# # <INPUT TYPE="password" NAME="name" SIZE="40">

# password_field("name", "value")

# # <INPUT TYPE="password" NAME="name" VALUE="value" SIZE="40">

# password_field("password", "value", 80, 200)

# # <INPUT TYPE="password" NAME="name" VALUE="value" SIZE="80" MAXLENGTH="200">

# password_field("NAME" => "name", "VALUE" => "value")

# # <INPUT TYPE="password" NAME="name" VALUE="value">

def password_field(name = "", value = nil, size = 40, maxlength = nil)

# # <OPTION VALUE="bar">bar</OPTION>

# # <OPTION VALUE="baz">baz</OPTION>

# # </SELECT>

# popup_menu("name", ["foo"], ["bar", true], "baz")

# # <SELECT NAME="name">

# # <OPTION VALUE="foo">foo</OPTION>

# # <OPTION VALUE="bar" SELECTED>bar</OPTION>

# # <OPTION VALUE="baz">baz</OPTION>

# # </SELECT>

# popup_menu("name", ["1", "Foo"], ["2", "Bar", true], "Baz")

# # <SELECT NAME="name">

# # <OPTION VALUE="1">Foo</OPTION>

# # <OPTION SELECTED VALUE="2">Bar</OPTION>

# # <OPTION VALUE="Baz">Baz</OPTION>

# # </SELECT>

# popup_menu("NAME" => "name", "SIZE" => 2, "MULTIPLE" => true,

# "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"])

# # <SELECT NAME="name" MULTIPLE SIZE="2">

#

# radio_button("name", "value")

# # <INPUT TYPE="radio" NAME="name" VALUE="value">

# radio_button("name", "value", true)

# # <INPUT TYPE="radio" NAME="name" VALUE="value" CHECKED>

# radio_button("NAME" => "name", "VALUE" => "value", "ID" => "foo")

# # <INPUT TYPE="radio" NAME="name" VALUE="value" ID="foo">

def radio_button(name = "", value = nil, checked = nil)

#

# This works the same as #checkbox_group(). However, it is not valid

# to have more than one radiobutton in a group checked.

# radio_group("name", "foo", "bar", "baz")

# # <INPUT TYPE="radio" NAME="name" VALUE="foo">foo

# # <INPUT TYPE="radio" NAME="name" VALUE="bar">bar

# # <INPUT TYPE="radio" NAME="name" VALUE="baz">baz

# radio_group("name", ["foo"], ["bar", true], "baz")

# # <INPUT TYPE="radio" NAME="name" VALUE="foo">foo

# # <INPUT TYPE="radio" CHECKED NAME="name" VALUE="bar">bar

# # <INPUT TYPE="radio" NAME="name" VALUE="baz">baz

# radio_group("name", ["1", "Foo"], ["2", "Bar", true], "Baz")

# # <INPUT TYPE="radio" NAME="name" VALUE="1">Foo

# # <INPUT TYPE="radio" CHECKED NAME="name" VALUE="2">Bar

# # <INPUT TYPE="radio" NAME="name" VALUE="Baz">Baz

# radio_group("NAME" => "name",

# "VALUES" => ["foo", "bar", "baz"])

# radio_group("NAME" => "name",

# "VALUES" => [["foo"], ["bar", true], "baz"])

# radio_group("NAME" => "name",

# "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"])

def radio_group(name = "", *values)

#

# reset

# # <INPUT TYPE="reset">

# reset("reset")

# # <INPUT TYPE="reset" VALUE="reset">

# reset("VALUE" => "reset", "ID" => "foo")

# # <INPUT TYPE="reset" VALUE="reset" ID="foo">

def reset(value = nil, name = nil)

#

# submit

# # <INPUT TYPE="submit">

# submit("ok")

# # <INPUT TYPE="submit" VALUE="ok">

# submit("ok", "button1")

# # <INPUT TYPE="submit" VALUE="ok" NAME="button1">

# submit("VALUE" => "ok", "NAME" => "button1", "ID" => "foo")

# # <INPUT TYPE="submit" VALUE="ok" NAME="button1" ID="foo">

def submit(value = nil, name = nil)

#

# text_field("name")

# # <INPUT TYPE="text" NAME="name" SIZE="40">

# text_field("name", "value")

# # <INPUT TYPE="text" NAME="name" VALUE="value" SIZE="40">

# text_field("name", "value", 80)

# # <INPUT TYPE="text" NAME="name" VALUE="value" SIZE="80">

# text_field("name", "value", 80, 200)

# # <INPUT TYPE="text" NAME="name" VALUE="value" SIZE="80" MAXLENGTH="200">

# text_field("NAME" => "name", "VALUE" => "value")

# # <INPUT TYPE="text" NAME="name" VALUE="value">

def text_field(name = "", value = nil, size = 40, maxlength = nil)

#

# This file provides the +CGI::Session+ class, which provides session

# support for CGI scripts. A session is a sequence of HTTP requests

# Information associated with the session is stored

# on the server between requests. A session id is passed between client

# and server with every request and response, transparently

class CGI

# cgi/session.rb for an introduction to HTTP sessions.

#

# == Lifecycle

# == Setting and retrieving session data.

#

# The Session class associates data with a session as key-value pairs.

# using '[]', much the same as hashes (although other hash methods

# are not supported).

#

#

# == Storing session state

#

# data with the +database_manager+ option to CGI::Session::new. The

# following storage classes are provided as part of the standard library:

#

# storage type.

# interpreter instance does.

# CGI::Session::PStore:: stores data in Marshalled format. Provided by

# and provides file-locking and transaction support.

#

# the following methods:

#

# new(session, options)

# The simplest way to do this is via cookies. The CGI::Session class

# provides transparent support for session id communication via cookies

# if the client has cookies enabled.

# If the client has cookies disabled, the session id must be included

# as a parameter of all requests sent by the client to the server. The

# CGI::Session class in conjunction with the CGI class will transparently

# add the session id as a hidden input field to all forms generated

# using the CGI#form() HTML generation method. No built-in support is

# provided for other mechanisms, such as URL re-writing. The caller is

# attribute and manually encoding it in URLs and adding it as a hidden

# input to HTML forms created by other mechanisms. Also, session expiry

# is not automatically handled.

# session = CGI::Session.new(cgi,

# 'database_manager' => CGI::Session::PStore, # use PStore

# 'session_key' => '_rb_sess_id', # custom session key

# 'prefix' => 'pstore_sid_') # PStore option

# if cgi.has_key?('user_name') and cgi['user_name'] != ''

# # string-like CGI::QueryExtension::Value

# session['user_name'] = cgi['user_name'].to_s

# elsif !session['user_name']

# cgi = CGI.new("html4")

#

# # We make sure to delete an old session if one exists,

# # from being maliciously hijacked later on.

# begin

# rescue ArgumentError # if no old session

# end

# session = CGI::Session.new(cgi, 'new_session' => true)

# The session id is an MD5 hash based upon the time,

# a random number, and a constant string. This routine

# is used internally for automatically generated

def create_new_id

require 'securerandom'

begin

# it is retrieved from the +session_key+ parameter

# of the request, or automatically generated for

# a new session.

# a new session is only created if none currently

# exists. If false, a new session is never created,

# and if none currently exists and the +session_id+

# The following options are also recognised, but only apply if the

# session id is stored in a cookie.

#

# +Time+ object. If not set, the session will terminate

# when the user's browser is closed.

# session_domain:: the hostname domain for which this session is valid.

# +option+ is also passed on to the session storage class initializer; see

# the documentation for each session storage class for the options

# they support.

# The retrieved or created session is automatically added to +request+

# as a cookie, and also to its +output_hidden+ table, which is used

#

# *WARNING* the +output_hidden+

# fields are surrounded by a <fieldset> tag in HTML 4 generation, which

# Store session data on the server. For some session storage types,

# this is a no-op.

@dbman.update

end

# For some session storage types, this is a no-op.

def close

@dbman.close

# created. The session id must only contain alphanumeric

# characters; automatically generated session ids observe

# this requirement.

# +option+ is a hash of options for the initializer. The

# following options are recognised:

#

# In-memory session storage class.

#

# Implements session storage as a global in-memory hash. Session

# instance does.

class MemoryStore

GLOBAL_HASH_TABLE = {} #:nodoc:

# cgi/session/pstore.rb - persistent storage of marshalled session data

#

# Documentation: William Webber ([email protected])

# == Overview

#

# This file provides the CGI::Session::PStore class, which builds

# created. The session id must only contain alphanumeric

# characters; automatically generated session ids observe

# this requirement.

# +option+ is a hash of options for the initializer. The

# following options are recognised:

#

end

# Save session state to the session's PStore file.

@p.transaction do

@p['hash'] = @hash

end

#

# $Release Version: 0.5 $

# $Revision: 1.3 $

# $Date: 1998/07/08 10:05:28 $

# Complex numbers can be created in the following manner:

# - <tt>Complex(a, b)</tt>

# - <tt>Complex.polar(radius, theta)</tt>

# Additionally, note the following:

# - <tt>Complex::I</tt> (the mathematical constant <i>i</i>)

# - <tt>Numeric#im</tt> (e.g. <tt>5.im -> 0+5i</tt>)

def im

Complex(0, self)

end

#

# The real part of a complex number, i.e. <i>self</i>.

#

def real

self

end

#

# The imaginary part of a complex number, i.e. 0.

#

0

end

alias imag image

#

# See Complex#arg.

#

Math.atan2!(0, self)

end

alias angle arg

#

# See Complex#polar.

#

def polar

return abs, arg

end

#

# See Complex#conjugate (short answer: returns <i>self</i>).

#

x + y

end

end

#

# Subtraction with real or complex number.

#

x - y

end

end

#

# Multiplication with real or complex number.

#

x * y

end

end

#

# Division by real or complex number.

#

x/y

end

end

def quo(other)

Complex(@real.quo(1), @image.quo(1)) / other

end

x**y

end

end

#

# Remainder after division by a real or complex number.

#

x % y

end

end

#--

# def divmod(other)

# if other.kind_of?(Complex)

# end

# end

#++

#

# Absolute value (aka modulus): distance from the zero point on the complex

# plane.

def abs

Math.hypot(@real, @image)

end

#

# Square of the absolute value.

#

def abs2

@real*@real + @image*@image

end

#

# Argument (angle from (1,0) on the complex plane).

#

Math.atan2!(@image, @real)

end

alias angle arg

#

# Returns the absolute value _and_ the argument.

#

def polar

return abs, arg

end

#

# Complex conjugate (<tt>z + z.conjugate = 2 * z.real</tt>).

#

Complex(@real, -@image)

end

alias conj conjugate

#

# Compares the absolute values of the two numbers.

#

def <=> (other)

self.abs <=> other.abs

end

#

# Test for numerical equality (<tt>a == a + 0<i>i</i></tt>).

#

def denominator

@real.denominator.lcm(@image.denominator)

end

#

# FIXME

#

Complex(@real.numerator*(cd/@real.denominator),

@image.numerator*(cd/@image.denominator))

end

#

# Standard string representation of the complex number.

#

end

end

end

#

# Returns a hash code for the complex number.

#

def hash

@real.hash ^ @image.hash

end

#

# Returns "<tt>Complex(<i>real</i>, <i>image</i>)</tt>".

#

sprintf("Complex(%s, %s)", @real.inspect, @image.inspect)

end

#

# +I+ is the imaginary number. It exists at point (0,1) on the complex plane.

#

I = Complex(0,1)

# The real part of a complex number.

attr :real

# The imaginary part of a complex number.

attr :image

alias imag image

end

class Integer

alias atan2! atan2

alias acosh! acosh

alias asinh! asinh

# Redefined to handle a Complex argument.

def sqrt(z)

end

end

end

# Redefined to handle a Complex argument.

def exp(z)

if Complex.generic?(z)

Complex(exp!(z.real) * cos!(z.image), exp!(z.real) * sin!(z.image))

end

end

# Redefined to handle a Complex argument.

def cos(z)

if Complex.generic?(z)

-sin!(z.real)*sinh!(z.image))

end

end

# Redefined to handle a Complex argument.

def sin(z)

if Complex.generic?(z)

cos!(z.real)*sinh!(z.image))

end

end

# Redefined to handle a Complex argument.

def tan(z)

if Complex.generic?(z)

sinh(z)/cosh(z)

end

end

# Redefined to handle a Complex argument.

def log(z)

if Complex.generic?(z) and z >= 0

Complex(log!(r.abs), theta)

end

end

# Redefined to handle a Complex argument.

def log10(z)

if Complex.generic?(z)

module_function :asinh

module_function :atanh!

module_function :atanh

end

# Documentation comments:

# CSV -- module for generating/parsing CSV data.

# Copyright (C) 2000-2004 NAKAMURA, Hiroshi <[email protected]>.

# $Id$

# This program is copyrighted free software by NAKAMURA, Hiroshi. You can

# redistribute it and/or modify it under the same terms of Ruby's license;

# either the dual license version in 2003, or any later version.

class CSV

class IllegalFormatError < RuntimeError; end

def CSV.read(path, length = nil, offset = nil)

CSV.parse(IO.read(path, length, offset))

end

def CSV.readlines(path, rs = nil)

reader = open_reader(path, 'r', ',', rs)

begin

end

result_str

end

# Parse a line from string. Consider using CSV.parse_line instead.

# To parse lines in CSV string, see EXAMPLE below.

#

end

return parsed_cells, idx

end

# Convert a line from cells data to string. Consider using CSV.generate_line

# instead. To generate multi-row CSV string, see EXAMPLE below.

#

end

parsed_cells

end

# Private class methods.

class << self

private

end

nil

else

writer.close_on_terminate

writer

end

last_idx = idx

return :DT_EOS, idx, cell

end

def generate_body(cell, out_dev, fs, rs)

if cell.nil?

# empty

end

end

end

def generate_separator(type, out_dev, fs, rs)

case type

when :DT_COLSEP

# Define if needed.

end

end

class StringReader < Reader

def initialize(string, fs = ',', rs = nil)

# returns char at idx if n == nil.

# returns a partial string, from idx to (idx + n) if n != nil. at EOF,

# the string size could not equal to arg n.

if idx < 0

return nil

end

end

end

alias get []

# drop a string from the stream.

# returns dropped size. at EOF, dropped size might not equals to arg n.

# Once you drop the head of the stream, access to the dropped part via []

end

size_dropped

end

def is_eos?

return idx_is_eos?(0)

end

# WARN: Do not instantiate this class directly. Define your own class

# which derives this class and define 'read' instance method.

def initialize

add_buf

@cur_buf = @buf_tail_idx

end

protected

def terminate

while (rel_buf); end

end

# protected method 'read' must be defined in derived classes.

# CAUTION: Returning a string which size is not equal to 'size' means

# EnfOfStream. When it is not at EOS, you must block the callee, try to

def read(size) # raise EOFError

raise NotImplementedError.new('Method read must be defined in a derived class.')

end

private

def buf_size(idx)

@buf_list[idx].size

end

true

end

end

def rel_buf

if (@cur_buf < 0)

return false

return true

end

end

def idx_is_eos?(idx)

(@is_eos and ((@cur_buf < 0) or (@cur_buf == @buf_tail_idx)))

end

BufSize = 1024 * 8

end

@s = s

super()

end

def close

terminate

end

def read(size)

@s.read(size)

end

def terminate

super()

end

def debug_command(file, line, id, binding)

MUTEX.lock

unless defined?($debugger_restart) and $debugger_restart

end

set_last_thread(Thread.current)

frame_pos = 0

stdout.print "Breakpoints:\n"

for b in break_points

if b[0] and b[1] == 0

end

n += 1

end

when 'end'

@frames.shift

excn_handle(file, line, id, binding)

end

@stdout.print "Already stopped.\n"

else

thread_list(@thread_list[th])

end

when /^resume\s+(\d+)/

# 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

# Elements: 4

# Non-Nil: 4

# Unique: 4

# Elements: 8

# Non-Nil: 7

# Unique: 6

#

# 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

#

# 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

target.__send__(m, *args, &block)

end

# call through \_\_getobj\_\_.

def respond_to?(m, include_private = false)

return true if super

return self.__getobj__.respond_to?(m, include_private)

#

# The Ruby standard library contains the core classes of the dRuby package.

# However, the full package also includes access control lists and the

# large number of samples. The full dRuby package can be downloaded from

# the dRuby home page (see *References*).

#

# are forwarded to the local object, as described in the discussion of

# DRbObjects. This has semantics similar to the normal Ruby

# pass-by-reference.

# The easiest way to signal that we want an otherwise marshallable

# object to be passed or returned as a DRbObject reference, rather

# than marshalled and sent as a copy, is to include the

# passed back to the remote execution context to be collected, before

# the collected values are finally returned to the local context as

# the return value of the method invocation.

# == Examples of usage

#

# For more dRuby samples, see the +samples+ directory in the full

# starting the server code first.

#

# ==== Server code

# require 'drb/drb'

# # The URI for the server to connect to

# class TimeServer

# def get_current_time

# return Time.now

# end

# end

# # The object that handles requests on the server

# FRONT_OBJECT=TimeServer.new

#

# $SAFE = 1 # disable eval() and friends

# DRb.start_service(URI, FRONT_OBJECT)

# # Wait for the drb server thread to finish before exiting.

# DRb.thread.join

#

# ==== Client code

# require 'drb/drb'

# # The URI to connect to

# SERVER_URI="druby://localhost:8787"

#

# # as soon as we pass a non-marshallable object as an argument

# # to a dRuby call.

# DRb.start_service

# timeserver = DRbObject.new_with_uri(SERVER_URI)

#

# === Remote objects under dRuby

#

# This example illustrates returning a reference to an object

# from a dRuby call. The Logger instances live in the server

# process. References to them are returned to the client process,

# executed in the server process.

#

# ==== Server code

# require 'drb/drb'

# URI="druby://localhost:8787"

# class Logger

#

# # Make dRuby send Logger instances as dRuby references,

# # not copies.

# include DRb::DRbUndumped

# def initialize(n, fname)

# @name = n

# @filename = fname

# end

# def log(message)

# File.open(@filename, "a") do |f|

# f.puts("#{Time.now}: #{@name}: #{message}")

# end

# end

# end

# # We have a central object for creating and retrieving loggers.

# # This retains a local reference to all loggers created. This

# # is so an existing logger can be looked up by name, but also

# # reference to an object is not sufficient to prevent it being

# # garbage collected!

# class LoggerFactory

# def initialize(bdir)

# @basedir = bdir

# @loggers = {}

# end

# def get_logger(name)

# if [email protected]_key? name

# # make the filename safe, then declare it to be so

# end

# return @loggers[name]

# end

# end

# FRONT_OBJECT=LoggerFactory.new("/tmp/dlog")

#

# $SAFE = 1 # disable eval() and friends

# DRb.start_service(URI, FRONT_OBJECT)

# DRb.thread.join

#

# ==== Client code

#

# require 'drb/drb'

# SERVER_URI="druby://localhost:8787"

#

# DRb.start_service

# log_service=DRbObject.new_with_uri(SERVER_URI)

# ["loga", "logb", "logc"].each do |logname|

# logger=log_service.get_logger(logname)

# logger.log("Hello, world!")

# logger.log("Goodbye, world!")

# logger.log("=== EOT ===")

# end

#

# == Security

# ro.instance_eval("`rm -rf *`")

#

# The dangers posed by instance_eval and friends are such that a

# this practice.

#

# A DRbServer can be configured with an access control list to

#

# This, the default implementation, uses an object's local ObjectSpace

# __id__ as its id. This means that an object's identification over

# within the server runtime.

#

# For alternative mechanisms, see DRb::TimerIdConv in rdb/timeridconv.rb

def to_obj(ref)

ObjectSpace._id2ref(ref)

end

# Convert an object into a reference id.

#

# This implementation returns the object's __id__ in the local

# called over drb, then the object remains in the server space

# and a reference to the object is returned, rather than the

# object being marshalled and moved into the client space.

def _dump(dummy) # :nodoc:

raise TypeError, 'can\'t dump'

end

def self._load(s) # :nodoc:

Marshal::load(s)

end

def _dump(lv) # :nodoc:

Marshal::dump(@unknown)

end

# +name+ attribute. The marshalled object is held in the +buf+

# attribute.

class DRbUnknown

# Create a new DRbUnknown object.

#

# +buf+ is a string containing a marshalled object that could not

# when the unmarshalling failed. It is used to determine the

# name of the unmarshalled object.

def initialize(err, buf)

# Attempt to load the wrapped marshalled object again.

#

# If the class of the object is now known locally, the object

# but identical DRbUnknown object will be returned.

def reload

self.class._load(@buf)

class DRbArray

def initialize(ary)

if obj.kind_of? DRbUndumped

DRbObject.new(obj)

else

rescue

raise(DRbConnError, $!.message, $!.backtrace)

end

def recv_request(stream) # :nodoc:

ref = load(stream)

ro = DRb.to_obj(ref)

# using configuration +config+. Return a

# protocol instance for this listener.

# [uri_option(uri, config)] Take a URI, possibly containing an option

# and return a [uri, option] tuple.

#

# does not identify the protocol they support (e.g. "druby:" for

# the standard Ruby protocol). This is how the DRbProtocol module,

# given a URI, determines which protocol implementation serves that

#

# The protocol instance returned by #open must have the following methods:

#

# Send a request to +ref+ with the given message id and arguments.

# This is most easily implemented by calling DRbMessage.send_request,

# providing a stream that sits on top of the current protocol.

# [recv_reply]

# Receive a reply from the server and return it as a [success-boolean,

# reply-value] pair. This is most easily implemented by calling

# current protocol.

# [alive?]

# Is this connection still alive?

# URI by raising a DRbBadScheme error. If no protocol recognises the

# URI, then a DRbBadURI error is raised. If a protocol accepts the

# URI, but an error occurs in opening it, a DRbConnError is raised.

@protocol.each do |prot|

begin

return prot.open(uri, config)

end

module_function :open

# configuration +config+.

#

# The DRbProtocol module asks each registered protocol in turn to

# error is passed on to the caller.

def open_server(uri, config, first=true)

@protocol.each do |prot|

# The DRbProtocol module asks each registered protocol in turn to

# try to parse the URI. Each protocol signals that it does not handle that

# URI by raising a DRbBadScheme error. If no protocol recognises the

def uri_option(uri, config, first=true)

@protocol.each do |prot|

begin

end

def self.open_server_inaddr_any(host, port)

Socket::AF_UNSPEC,

0,

Socket::AI_PASSIVE)

families = Hash[*infos.collect { |af, *_| af }.uniq.zip([]).flatten]

return TCPServer.open(port)

end

# configuration +config+.

def self.open_server(uri, config)

uri = 'druby://:0' unless uri

def peeraddr

@socket.peeraddr

end

# Get the socket.

def stream; @socket; end

def send_request(ref, msg_id, arg, b)

@msg.send_request(stream, ref, msg_id, arg, b)

end

# On the server side, receive a request from the client.

def recv_request

@msg.recv_request(stream)

@socket = nil

end

end

# accept a client connection and return a new instance to handle

# the server's side of this client-server session.

def accept

while true

s = @socket.accept

s.close

end

if @config[:tcp_original_host].to_s.size == 0

end

attr :option

def to_s; @option; end

def ==(other)

return false unless DRbURIOption === other

@option == other.option

end

def hash

@option.hash

end

alias eql? ==

end

# created to act as a stub for the remote referenced object.

def self._load(s)

uri, ref = Marshal.load(s)

if DRb.here?(uri)

obj = DRb.to_obj(ref)

if ((! obj.tainted?) && Thread.current[:drb_untaint])

end

# Get the URI of the remote object.

@uri

end

if DRb.here?(@uri)

obj = DRb.to_obj(@ref)

DRb.current_server.check_insecure_method(obj, msg_id)

end

succ, result = self.class.with_friend(@uri) do

def self.with_friend(uri)

friend = DRb.fetch_server(uri)

return yield() unless friend

save = Thread.current['DRb']

Thread.current['DRb'] = { 'server' => friend }

return yield

prefix = "(#{uri}) "

bt = []

result.backtrace.each do |x|

if /^\(druby:\/\// =~ x

bt.push(x)

else

def self.verbose=(on)

@@verbose = on

end

# Get the default value of the :verbose option.

def self.verbose

@@verbose

end

def self.make_config(hash={}) # :nodoc:

:idconv => @@idconv,

:verbose => @@verbose,

:tcp_acl => @@acl,

attr_reader :thread

# The front object of the DRbServer.

# This object receives remote method calls made on the server's

# URI alone, with an object id.

attr_reader :front

def any_to_s(obj)

obj.to_s + ":#{obj.class}"

rescue

end

# Check that a method is callable via dRuby.

# +obj+ is the object we want to invoke the method on. +msg_id+ is the

# method name, as a Symbol.

#

# SecurityError is thrown. If the method is private or undefined,

# a NameError is thrown.

def check_insecure_method(obj, msg_id)

return true if Proc === obj && msg_id == :__drb_yield

raise(ArgumentError, "#{any_to_s(msg_id)} is not a symbol") unless Symbol == msg_id.class

raise(SecurityError, "insecure method `#{msg_id}'") if insecure_method?(msg_id)

if obj.private_methods.include?(msg_id.to_s)

desc = any_to_s(obj)

raise NoMethodError, "private method `#{msg_id}' called for #{desc}"

end

end

public :check_insecure_method

class InvokeMethod # :nodoc:

def initialize(drb_server, client)

@drb_server = drb_server

perform_with_block

}.value

else

Thread.current['DRb'] = info

$SAFE = @safe_level

perform_without_block

end

@succ = true

if @msg_id == :to_ary && @result.class == Array

end

return @succ, @result

rescue StandardError, ScriptError, Interrupt

@argv = argv

@block = block

end

def check_insecure_method

@drb_server.check_insecure_method(@obj, @msg_id)

end

init_with_client

check_insecure_method

end

def perform_without_block

if Proc === @obj && @msg_id == :__drb_yield

if @argv.size == 1

# The primary local dRuby server.

#

attr_accessor :primary_server

module_function :primary_server=, :primary_server

# If the above rule fails to find a server, a DRbServerNotFound

# error is raised.

def current_server

raise DRbServerNotFound unless server

return server

end

DRbServer.make_config

end

module_function :config

# Get the front object of the current server.

#

# This raises a DRbServerNotFound error if there is no current server.

@server.delete(server.uri)

end

module_function :remove_server

def fetch_server(uri)

@server[uri]

end

=begin

external service

=end

require 'drb/drb'

=begin

external service manager

=end

require 'drb/drb'

def self.command=(cmd)

@@command = cmd

end

def initialize

super()

@cond = new_cond

end

self

end

def unregist(name)

synchronize do

@servers.delete(name)

end

block_value = @block.call(*x)

end

def perform_with_block

@obj.__send__(@msg_id, *@argv) do |*x|

jump_error = nil

:SSLClientCA => nil,

:SSLCACertificatePath => nil,

:SSLCACertificateFile => nil,

:SSLVerifyDepth => nil,

:SSLVerifyCallback => nil, # custom verification

:SSLCertificateStore => nil,

@ssl_ctx = nil

end

@config[key] || DEFAULT[key]

end

ssl.connect

ssl

end

def accept(tcp)

ssl = OpenSSL::SSL::SSLSocket.new(tcp, @ssl_ctx)

ssl.sync = true

ssl.accept

ssl

end

def setup_certificate

if @cert && @pkey

return

cert.not_before = Time.now

cert.not_after = Time.now + (365*24*60*60)

cert.public_key = rsa.public_key

ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)

cert.extensions = [

ef.create_extension("basicConstraints","CA:FALSE"),

cert.add_extension(ef.create_extension("nsComment", comment))

end

cert.sign(rsa, OpenSSL::Digest::SHA1.new)

@cert = cert

@pkey = rsa

end

end

port = soc.addr[1] if port == 0

@uri = "drbssl://#{host}:#{port}"

ssl_conf = SSLConfig.new(config)

ssl_conf.setup_certificate

ssl_conf.setup_ssl_context

@ssl = is_established ? soc : nil

super(uri, soc.to_io, config)

end

def stream; @ssl; end

def close

end

super

end

def accept

begin

while true

soc = @socket.accept

soc.close

end

ssl = @config.accept(soc)

end

end

end

DRbProtocol.add_protocol(DRbSSLSocket)

end

end

def add(obj)

key = obj.__id__

@curr[key] = obj

return key

end

def fetch(key, dv=@sentinel)

obj = peek(key)

if obj == @sentinel

return dv unless dv == @sentinel

end

def include?(key)

obj = peek(key)

return false if obj == @sentinel

true

end

def peek(key)

return @curr.fetch(key, @renew.fetch(key, @gc.fetch(key, @sentinel)))

end

end

class DRbUNIXSocket < DRbTCPSocket

def self.parse_uri(uri)

filename = $1

option = $3

[filename, option]

@server_mode = server_mode

@acl = nil

end

# import from tempfile.rb

Max_try = 10

private

super

cl.bind(self) unless cl == E2MM

end

# backward compatibility

def E2MM.extend_to(b)

c = eval("self", b)

# backward compatibility

alias fail! fail

def fail(err = nil, *rest)

E2MM.Fail(self, err, *rest)

rescue E2MM::ErrNotRegisteredException

super

public :fail

end

# def_e2message(c, m)

# c: exception

# m: message_form

def def_e2message(c, m)

E2MM.def_e2message(self, c, m)

end

# def_exception(n, m, s)

# n: exception_name

# m: message_form

E2MM.instance_eval{@MessageMap[[k, c]] = m}

c

end

# E2MM.def_exception(k, n, m, s)

# k: class to define exception under.

# n: exception_name

alias message e2mm_message

end

"not registerd exception(%s)")

end

# purposes of generating document information details and/or flow control.

#

# A very simple example is this:

# require 'erb'

#

# x = 42

# <tt>%q{...}</tt> to avoid trouble with the backslash.

#

# require "erb"

# # Create template.

# template = %q{

# From: James Edward Gray II <[email protected]>

# To: <%= to %>

# Subject: Addressing Needs

# <%= to[/\w+/] %>:

# Just wanted to send a quick note assuring that your needs are being

# addressed.

# I want you to know that my team will keep working on the issues,

# especially:

# <%# ignore numerous minor requests -- focus on priorities %>

# % priorities.each do |priority|

# * <%= priority %>

# % end

# Thanks for your patience.

# James Edward Gray II

# }.gsub(/^ /, '')

# message = ERB.new(template, 0, "%<>")

# # Set up template data.

# to = "Community Spokesman <spokesman@ruby_community.org>"

# priorities = [ "Run Ruby Quiz",

# "Document Modules",

# "Answer Questions on Ruby Talk" ]

# # Produce result.

# email = message.result

# puts email

# From: James Edward Gray II <[email protected]>

# To: Community Spokesman <spokesman@ruby_community.org>

# Subject: Addressing Needs

# Community:

# Just wanted to send a quick note assuring that your needs are being addressed.

# I want you to know that my team will keep working on the issues, especially:

# * Run Ruby Quiz

# * Document Modules

# * Answer Questions on Ruby Talk

# Thanks for your patience.

# James Edward Gray II

#

# === Ruby in HTML

# variables in the Product object can be resolved.

#

# require "erb"

# # Build template data class.

# class Product

# def initialize( code, name, desc, cost )

# @name = name

# @desc = desc

# @cost = cost

# @features = [ ]

# end

# def add_feature( feature )

# @features << feature

# end

# # Support templating of member data.

# def get_binding

# binding

# end

# # ...

# end

# # Create template.

# template = %{

# <html>

# <head><title>Ruby Toys -- <%= @name %></title></head>

# <body>

# <h1><%= @name %> (<%= @code %>)</h1>

# <p><%= @desc %></p>

# <ul>

# <% @features.each do |f| %>

# <li><b><%= f %></b></li>

# <% end %>

# </ul>

# <p>

# <% if @cost < 10 %>

# <b>Only <%= @cost %>!!!</b>

# Call for a price, today!

# <% end %>

# </p>

# </body>

# </html>

# }.gsub(/^ /, '')

# rhtml = ERB.new(template)

# # Set up template data.

# toy = Product.new( "TZ-1002",

# "Rubysapien",

# toy.add_feature("Karate-Chop Action!!!")

# toy.add_feature("Matz signature on left leg.")

# toy.add_feature("Gem studded eyes... Rubies, of course!")

# # Produce result.

# rhtml.run(toy.get_binding)

#

# <html>

# <head><title>Ruby Toys -- Rubysapien</title></head>

# <body>

# <h1>Rubysapien (TZ-1002)</h1>

# <p>Geek's Best Friend! Responds to Ruby commands...</p>

# <ul>

# <li><b>Listens for verbal commands in the Ruby language!</b></li>

# <li><b>Ignores Perl, Java, and all C variants.</b></li>

# <li><b>Matz signature on left leg.</b></li>

# <li><b>Gem studded eyes... Rubies, of course!</b></li>

# </ul>

# <p>

# Call for a price, today!

# </p>

# </body>

# </html>

#

# == Notes

#

# There are a variety of templating solutions available in various Ruby projects:

end

end

attr_accessor :stag

def scan(&block)

@stag = nil

if @percent

end

end

end

Scanner.regist_scanner(SimpleScanner, nil, false)

begin

def push(cmd)

@line << cmd

end

def cr

@script << (@line.join('; '))

@line = []

@script << "\n"

end

def close

return unless @line

@compiler.post_cmd.each do |x|

content = ''

scanner = make_scanner(s)

scanner.scan do |token|

next if token == ''

if scanner.stag.nil?

case token

class ERB

#

# Constructs a new ERB object with the template specified in _str_.

# An ERB object works by building a chunk of Ruby code that will output

# the completed template when run. If _safe_level_ is set to a non-nil value,

# ERB code will be run in a separate thread with <b>$SAFE</b> set to the

# provided level.

# If _trim_mode_ is passed a String containing one or more of the following

# modifiers, ERB will adjust its code generation as listed:

# % enables Ruby code processing for lines beginning with %

# <> omit newline for lines starting with <% and ending in %>

# > omit newline for lines ending in %>

# _eoutvar_ can be used to set the name of the variable ERB will build up

# its output in. This is useful when you need to run multiple ERB

# templates through the same binding and/or when you want to control where

# === Example

#

# require "erb"

# # build data class

# class Listings

# PRODUCT = { :name => "Chicken Fried Steak",

# :desc => "A well messages pattie, breaded and fried.",

# :cost => 9.95 }

# attr_reader :product, :price

# def initialize( product = "", price = "" )

# @product = product

# @price = price

# end

# def build

# b = binding

# # create and run templates, filling member data variables

# END_PRICE

# end

# end

# # setup template data

# listings = Listings.new

# listings.build

# puts listings.product + "\n" + listings.price

#

# _Generates_

#

# Chicken Fried Steak

# A well messages pattie, breaded and fried.

# Chicken Fried Steak -- 9.95

# A well messages pattie, breaded and fried.

def initialize(str, safe_level=nil, trim_mode=nil, eoutvar='_erbout')

@safe_level = safe_level

compiler = ERB::Compiler.new(trim_mode)

cmd = []

cmd.push "#{eoutvar} = ''"

compiler.pre_cmd = cmd

cmd = []

# Executes the generated ERB code to produce a completed template, returning

# the results of that code. (See ERB#new for details on how this process can

# be affected by _safe_level_.)

# _b_ accepts a Binding or Proc object which is used to set the context of

# code evaluation.

#

def result(b=TOPLEVEL_BINDING)

if @safe_level

$SAFE = @safe_level

eval(@src, b, (@filename || '(erb)'), 1)

}.call

public

#

# A utility method for escaping HTML tag characters in _s_.

# require "erb"

# include ERB::Util

# puts html_escape("is a > 0 & a < 10?")

# _Generates_

# is a &gt; 0 &amp; a &lt; 10?

#

def html_escape(s)

alias h html_escape

module_function :h

module_function :html_escape

#

# A utility method for encoding the String _s_ as a URL.

# require "erb"

# include ERB::Util

# puts url_encode("Programming Ruby: The Pragmatic Programmer's Guide")

# _Generates_

# Programming%20Ruby%3A%20%20The%20Pragmatic%20Programmer%27s%20Guide

#

def url_encode(s)

# = fileutils.rb

# Copyright (c) 2000-2006 Minero Aoki

# This program is free software.

# You can distribute/modify this program under the same terms of ruby.

# == module FileUtils

# Namespace for several file utility methods for copying, moving, removing, etc.

# === Module Functions

# cd(dir, options)

# cd(dir, options) {|dir| .... }

# pwd()

# uptodate?(file, cmp_list)

#

# == module FileUtils::Verbose

# This module has all methods of FileUtils module, but it outputs messages

# before acting. This equates to passing the <tt>:verbose</tt> flag to methods

# in FileUtils.

# == module FileUtils::NoWrite

# This module has all methods of FileUtils module, but never changes

# files/directories. This equates to passing the <tt>:noop</tt> flag to methods

# in FileUtils.

# == module FileUtils::DryRun

# This module has all methods of FileUtils module, but never changes

# files/directories. This equates to passing the <tt>:noop</tt> and

# <tt>:verbose</tt> flags to methods in FileUtils.

module FileUtils

#

# Options: verbose

# Changes the current directory to the directory +dir+.

# If this method is called with block, resumes to the old

# working directory after the block execution finished.

# FileUtils.cd('/', :verbose => true) # chdir and report it

def cd(dir, options = {}, &block) # :yield: dir

fu_check_options options, OPT_TABLE['cd']

fu_output_message "cd #{dir}" if options[:verbose]

#

# Options: (none)

# Returns true if +newer+ is newer than all +old_list+.

# Non-existent files are older than any file.

# FileUtils.uptodate?('hello.o', %w(hello.c hello.h)) or \

# system 'make hello.o'

def uptodate?(new, old_list, options = nil)

raise ArgumentError, 'uptodate? does not accept any option' if options

#

# Options: mode noop verbose

# Creates one or more directories.

# FileUtils.mkdir 'test'

# FileUtils.mkdir %w( tmp data )

# FileUtils.mkdir 'notexist', :noop => true # Does not really create.

# FileUtils.mkdir 'tmp', :mode => 0700

def mkdir(list, options = {})

fu_check_options options, OPT_TABLE['mkdir']

list = fu_list(list)

#

# Options: mode noop verbose

# Creates a directory and all its parent directories.

# For example,

# FileUtils.mkdir_p '/usr/local/lib/ruby'

# causes to make following directories, if it does not exist.

# * /usr

# * /usr/local

# * /usr/local/lib/ruby

#

# You can pass several directories at a time in a list.

def mkdir_p(list, options = {})

fu_check_options options, OPT_TABLE['mkdir_p']

list = fu_list(list)

#

# Options: noop, verbose

# Removes one or more directories.

# FileUtils.rmdir 'somedir'

# FileUtils.rmdir %w(somedir anydir otherdir)

# # Does not really remove directory; outputs message.

# FileUtils.rmdir 'somedir', :verbose => true, :noop => true

def rmdir(list, options = {})

fu_check_options options, OPT_TABLE['rmdir']

list = fu_list(list)

# If +new+ already exists and it is a directory, creates a link +new/old+.

# If +new+ already exists and it is not a directory, raises Errno::EEXIST.

# But if :force option is set, overwrite +new+.

# FileUtils.ln 'gcc', 'cc', :verbose => true

# FileUtils.ln '/usr/bin/emacs21', '/usr/bin/emacs'

# <b><tt>ln(list, destdir, options = {})</tt></b>

# Creates several hard links in a directory, with each one pointing to the

# item in +list+. If +destdir+ is not a directory, raises Errno::ENOTDIR.

# include FileUtils

# cd '/sbin'

# FileUtils.ln %w(cp mv mkdir), '/bin' # Now /sbin/cp and /bin/cp are linked.

def ln(src, dest, options = {})

fu_check_options options, OPT_TABLE['ln']

fu_output_message "ln#{options[:force] ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

# Options: force noop verbose

#

# <b><tt>ln_s(old, new, options = {})</tt></b>

# Creates a symbolic link +new+ which points to +old+. If +new+ already

# exists and it is a directory, creates a symbolic link +new/old+. If +new+

# already exists and it is not a directory, raises Errno::EEXIST. But if

# :force option is set, overwrite +new+.

# FileUtils.ln_s '/usr/bin/ruby', '/usr/local/bin/ruby'

# FileUtils.ln_s 'verylongsourcefilename.c', 'c', :force => true

# <b><tt>ln_s(list, destdir, options = {})</tt></b>

# Creates several symbolic links in a directory, with each one pointing to the

# item in +list+. If +destdir+ is not a directory, raises Errno::ENOTDIR.

#

# If +destdir+ is not a directory, raises Errno::ENOTDIR.

# FileUtils.ln_s Dir.glob('bin/*.rb'), '/home/aamine/bin'

def ln_s(src, dest, options = {})

fu_check_options options, OPT_TABLE['ln_s']

fu_output_message "ln -s#{options[:force] ? 'f' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

#

# Options: noop verbose

# Same as

# #ln_s(src, dest, :force)

def ln_sf(src, dest, options = {})

fu_check_options options, OPT_TABLE['ln_sf']

options = options.dup

# FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6'

# FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6', :verbose => true

# FileUtils.cp 'symlink', 'dest' # copy content, "dest" is not a symlink

def cp(src, dest, options = {})

fu_check_options options, OPT_TABLE['cp']

fu_output_message "cp#{options[:preserve] ? ' -p' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

#

# Options: preserve noop verbose dereference_root remove_destination

# Copies +src+ to +dest+. If +src+ is a directory, this method copies

# all its contents recursively. If +dest+ is a directory, copies

# +src+ to +dest/src+.

#

# +src+ can be a list of files.

# # Installing ruby library "mylib" under the site_ruby

# FileUtils.rm_r site_ruby + '/mylib', :force

# FileUtils.cp_r 'lib/', site_ruby + '/mylib'

# # Examples of copying several files to target directory.

# FileUtils.cp_r %w(mail.rb field.rb debug/), site_ruby + '/tmail'

# FileUtils.cp_r Dir.glob('*.rb'), '/home/aamine/lib/ruby', :noop => true, :verbose => true

# # use following code.

# FileUtils.cp_r 'src/.', 'dest' # cp_r('src', 'dest') makes src/dest,

# # but this doesn't.

def cp_r(src, dest, options = {})

fu_check_options options, OPT_TABLE['cp_r']

fu_output_message "cp -r#{options[:preserve] ? 'p' : ''}#{options[:remove_destination] ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

#

# Options: force noop verbose

# Moves file(s) +src+ to +dest+. If +file+ and +dest+ exist on the different

# disk partition, the copied file is created on the +dest+ and the original

# file removed from +src+.

# FileUtils.mv 'badname.rb', 'goodname.rb'

# FileUtils.mv 'stuff.rb', '/notexist/lib/ruby', :force => true # no error

# FileUtils.mv %w(junk.txt dust.txt), '/home/aamine/.trash/'

# FileUtils.mv Dir.glob('test*.rb'), 'test', :noop => true, :verbose => true

def mv(src, dest, options = {})

fu_check_options options, OPT_TABLE['mv']

fu_output_message "mv#{options[:force] ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

#

# Options: force noop verbose

# Remove file(s) specified in +list+. This method cannot remove directories.

# All StandardErrors are ignored when the :force option is set.

# FileUtils.rm %w( junk.txt dust.txt )

# FileUtils.rm Dir.glob('*.so')

# FileUtils.rm 'NotExistFile', :force => true # never raises exception

def rm(list, options = {})

fu_check_options options, OPT_TABLE['rm']

list = fu_list(list)

#

# Options: noop verbose

# Equivalent to

#

# #rm(list, :force => true)

#

# Options: force noop verbose secure

# remove files +list+[0] +list+[1]... If +list+[n] is a directory,

# removes its all contents recursively. This method ignores

# StandardError when :force option is set.

# FileUtils.rm_r Dir.glob('/tmp/*')

# FileUtils.rm_r '/', :force => true # :-)

#

#

# NOTE: This method calls #remove_entry_secure if :secure option is set.

# See also #remove_entry_secure.

def rm_r(list, options = {})

fu_check_options options, OPT_TABLE['rm_r']

# options[:secure] = true unless options.key?(:secure)

#

# Options: noop verbose secure

# Equivalent to

#

# #rm_r(list, :force => true)

#

# WARNING: This method causes local vulnerability.

# Read the documentation of #rm_r first.

def rm_rf(list, options = {})

fu_check_options options, OPT_TABLE['rm_rf']

options = options.dup

#

# Returns true if the contents of a file A and a file B are identical.

# FileUtils.compare_file('somefile', 'somefile') #=> true

# FileUtils.compare_file('/bin/cp', '/bin/mv') #=> maybe false

#

#

# Options: mode preserve noop verbose

# If +src+ is not same as +dest+, copies it and changes the permission

# mode to +mode+. If +dest+ is a directory, destination is +dest+/+src+.

# This method removes destination before copy.

# FileUtils.install 'ruby', '/usr/local/bin/ruby', :mode => 0755, :verbose => true

# FileUtils.install 'lib.rb', '/usr/local/lib/ruby/site_ruby', :verbose => true

def install(src, dest, options = {})

fu_check_options options, OPT_TABLE['install']

fu_output_message "install -c#{options[:preserve] && ' -p'}#{options[:mode] ? (' -m 0%o' % options[:mode]) : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]

#

# Options: noop verbose

# Changes permission bits on the named files (in +list+) to the bit pattern

# represented by +mode+.

# FileUtils.chmod 0755, 'somecommand'

# FileUtils.chmod 0644, %w(my.rb your.rb his.rb her.rb)

# FileUtils.chmod 0755, '/usr/bin/ruby', :verbose => true

def chmod(mode, list, options = {})

fu_check_options options, OPT_TABLE['chmod']

list = fu_list(list)

#

# Options: noop verbose force

# Changes permission bits on the named files (in +list+)

# to the bit pattern represented by +mode+.

# FileUtils.chmod_R 0700, "/tmp/app.#{$$}"

def chmod_R(mode, list, options = {})

fu_check_options options, OPT_TABLE['chmod_R']

list = fu_list(list)

#

# Options: noop verbose

# Changes owner and group on the named files (in +list+)

# to the user +user+ and the group +group+. +user+ and +group+

# may be an ID (Integer/String) or a name (String).

# If +user+ or +group+ is nil, this method does not change

# the attribute.

# FileUtils.chown 'root', 'staff', '/usr/local/bin/ruby'

# FileUtils.chown nil, 'bin', Dir.glob('/usr/bin/*'), :verbose => true

def chown(user, group, list, options = {})

fu_check_options options, OPT_TABLE['chown']

list = fu_list(list)

#

# Options: noop verbose force

# Changes owner and group on the named files (in +list+)

# to the user +user+ and the group +group+ recursively.

# +user+ and +group+ may be an ID (Integer/String) or

# a name (String). If +user+ or +group+ is nil, this

# method does not change the attribute.

# FileUtils.chown_R 'www', 'www', '/var/www/htdocs'

# FileUtils.chown_R 'cvs', 'cvs', '/var/cvs', :verbose => true

def chown_R(user, group, list, options = {})

fu_check_options options, OPT_TABLE['chown_R']

list = fu_list(list)

#

# Options: noop verbose

# Updates modification time (mtime) and access time (atime) of file(s) in

# +list+. Files are created if they don't exist.

# FileUtils.touch 'timestamp'

# FileUtils.touch Dir.glob('*.c'); system 'make'

def touch(list, options = {})

fu_check_options options, OPT_TABLE['touch']

list = fu_list(list)

METHODS = singleton_methods() - %w( private_module_function

commands options have_option? options_of collect_method )

# This module has all methods of FileUtils module, but it outputs messages

# before acting. This equates to passing the <tt>:verbose</tt> flag to

# methods in FileUtils.

module Verbose

include FileUtils

@fileutils_output = $stderr

end

end

# This module has all methods of FileUtils module, but never changes

# files/directories. This equates to passing the <tt>:noop</tt> flag

# to methods in FileUtils.

module NoWrite

include FileUtils

@fileutils_output = $stderr

end

end

# This module has all methods of FileUtils module, but never changes

# files/directories, with printing message before acting.

# This equates to passing the <tt>:noop</tt> and <tt>:verbose</tt> flag

# to methods in FileUtils.

module DryRun

include FileUtils

@fileutils_output = $stderr

#--

# $Release Version: 0.3$

# $Revision: 1.4 $

# $Date: 1998/02/27 05:34:33 $

#

# class Queue

# extend Forwardable

# def initialize

# @q = [ ] # prepare delegate object

# end

# # setup preferred 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

# = ftools.rb: Extra tools for the File class

#

# Author:: WATANABE, Hirofumi

# creating a directory path. See the File class for details.

#

# FileUtils contains all or nearly all the same functionality and more, and

#

# When you

#

# If +to+ is a valid directory, +from+ will be appended to +to+, adding

# and escaping backslashes as necessary. Otherwise, +to+ will be returned.

# Useful for appending +from+ to +to+ only if the filename was not specified

#

def catname(from, to)

if directory? to

# while g.next?

# puts g.next

# end

class Generator

include Enumerable

return g.next unless g.end?

g.rewind

end

# :nodoc:

# found at http://www.sra.co.jp/people/m-kasahr/ruby/getoptlong/

# The GetoptLong class allows you to parse command line options similarly to

# pure Ruby implementation.

#

# as single letter options like <tt>-f</tt>

#

# The empty option <tt>--</tt> (two minus symbols) is used to end option

# # greet user by name, if name not supplied default is John

# #

# # DIR: The directory in which to issue the greeting.

# require 'getoptlong'

# require 'rdoc/usage'

# opts = GetoptLong.new(

# [ '--help', '-h', GetoptLong::NO_ARGUMENT ],

# [ '--repeat', '-n', GetoptLong::REQUIRED_ARGUMENT ],

# [ '--name', GetoptLong::OPTIONAL_ARGUMENT ]

# )

# dir = nil

# name = nil

# repetitions = 1

# end

# end

# end

# if ARGV.length != 1

# puts "Missing dir argument (try --help)"

# exit 0

# end

# dir = ARGV.shift

# Dir.chdir(dir)

# for i in (1..repetitions)

# print "Hello"

# Set up option processing.

#

# The options to support are passed to new() as an array of arrays.

# the same meaning, and one of the following flags:

#

# GetoptLong::NO_ARGUMENT :: Option does not take an argument.

# the processing of options as follows:

#

# <b>REQUIRE_ORDER</b> :

# Options are required to occur before non-options.

#

# Processing of options ends as soon as a word is encountered that has not

# been preceded by an appropriate option flag.

#

# For example, if -a and -b are options which do not take arguments,

# processed as an option/arg pair.

#

# This is the default ordering, if the environment variable

# POSIXLY_CORRECT is set. (This is for compatibility with GNU getopt_long.)

#

# <b>PERMUTE</b> :

# default behavior.

#

# Every sequence of words which can be interpreted as an option (with or

#

# <b>RETURN_IN_ORDER</b> :

#

# preceded by a short or long option flag are passed as arguments

# with an option of '' (empty string).

#

# The method is failed if option processing has already started.

#

if @status != STATUS_YET

"invoke set_options, but option processing has already started"

end

end

#

# `@canonical_names' Hashes.

#

if canonical_name == nil

return nil

end

argument = ARGV.shift

if (ARGV[0] !~ /^-./)

terminate

return nil

#

# The block is called repeatedly with two arguments:

# The first is the option name.

# Example: ('--opt', 'value')

#

# The option name is always converted to the first (preferred)

#

# $Release Version: $

# $Revision$

# $Date$

#

# GServer implements a generic server, featuring thread pool management,

# <tt>xmlrpc/httpserver.rb</tt> in the Ruby standard library for an example of

# GServer in action.

#

#

# #

# # A server that returns the time in seconds since 1970.

# class TimeServer < GServer

# def initialize(port=10001, *args)

# super(port, *args)

# # Run the server with logging enabled (it's a separate thread).

# server = TimeServer.new

# server.audit = true # Turn logging on.