# session_path:: the path for which this session applies. Defaults

# to the directory of the CGI script.

#

# the documentation for each session storage class for the options

# they support.

#

# characters; automatically generated session ids observe

# this requirement.

#

# following options are recognised:

#

# tmpdir:: the directory to use for storing the FileStore

# characters; automatically generated session ids observe

# this requirement.

#

# following options are recognised:

#

# tmpdir:: the directory to use for storing the PStore

# <b><tt>:all</tt></b>:: All built-in converters. A combination of

# <tt>:date_time</tt> and <tt>:numeric</tt>.

#

# values to it that can be accessed by all CSV objects.

#

# To add a combo field, the value should be an Array of names. Combo fields

# Hash containing any +options+ CSV::new() understands.

#

# This method works like Ruby's open() call, in that it will pass a CSV object

# return the CSV object when no block is provided. (*Note*: This is different

# from the Ruby 1.8 CSV library which passed rows to the block. Use

# CSV::foreach() for that behavior.)

# unconverted_fields() method will be

# added to all returned rows (Array or

# CSV::Row) that will return the fields

# that <tt>:headers</tt> supplied by

# Array or String were not fields of the

# document and thus will have an empty

instance_variable_set("@#{field_name}", Array.new)

convert = method(field_name.to_s.sub(/ers\Z/, ""))

# load converters

# your class.

#

# class MyClass < DelegateClass( ClassToDelegateTo ) # Step 1

# super(obj_of_ClassToDelegateTo) # Step 2

# end

# end

#

# def build

# b = binding

# ERB.new(<<-'END_PRODUCT'.gsub(/^\s+/, ""), 0, "", "@product").result b

# <%= PRODUCT[:name] %>

# <%= PRODUCT[:desc] %>

# @q = [ ] # prepare delegate object

# end

#

# def_delegator :@q, :push, :enq

# def_delegator :@q, :shift, :deq

#

end

end

def self.def_extend_command(cmd_name, cmd_class, load_file = nil, *aliases)

case cmd_class

when Symbol

#

# $Release Version: 0.9.5$

# $Revision$

# by Keiju ISHITSUKA([email protected])

#

# $Release Version: 0.9.5$

# $Revision$

# by Keiju ISHITSUKA([email protected])

#

# $Release Version: 0.9.5$

# $Revision$

# by Keiju ISHITSUKA([email protected])

#

# $Release Version: 0.9.5$

# $Revision$

# by Keiju ISHITSUKA([email protected])

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

require 'monitor'

: key, key=((|key|))

Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.

: cert, cert=((|cert|))

Sets an OpenSSL::X509::Certificate object as client certificate

: ca_file, ca_file=((|path|))

Sets path of a CA certification file in PEM format.

return @nc[nonce]

end

def qdval(k, v)

return if k.nil? or v.nil?

if %w"username authzid realm nonce cnonce digest-uri qop".include? k

# :redirect=>false is used to disable HTTP redirects at all.

# OpenURI::HTTPRedirect exception raised on redirection.

# It is true by default.

#

def open(*rest, &block)

OpenURI.open_uri(self, *rest, &block)

#

# Directs to reject specified class argument.

#

#

# reject(t)

#

# "-x[OPTIONAL]"

# "-x"

# There is also a special form which matches character range (not full

# "-[a-z]MANDATORY"

# "-[a-z][OPTIONAL]"

# "-[a-z]"

#

# [Argument style and description:]

# switch parameter, this separate parameter can be used.

# "=MANDATORY"

# "=[OPTIONAL]"

SEPARATOR_PAT = /#{Regexp.quote File::SEPARATOR}/

end

# <i>repl</i>.

#

# If self has no extension part, <i>repl</i> is appended.

require "thread"

#

# code can store hierarchies of Ruby objects (values) into the data store file

# by name (keys). An object hierarchy may be just a single object. User code

# may later read values back from the data store or even update data, as needed.

#

# The transactional behavior ensures that any changes succeed or fail together.

# This can be used to ensure that the data store is not left in a transitory

#

# Behind the scenes, Ruby objects are stored to the data store file with

# Marshal. That carries the usual limitations. Proc objects cannot be

#

class String

rake_extension("ext") do

# the string, append the new extension to the end. If the new extension

# is not given, or is the empty string, remove any existing extension.

#

# * <b>%x</b> -- The file extension of the path. An empty string if there

# is no extension.

# * <b>%X</b> -- Everything *but* the file extension.

# the standard file separator.

# * <b>%%</b> -- A percent sign.

#

# 'a/b/c/d/file.txt'.pathmap("%-2d") => 'c/d'

#

# Also the %d, %p, $f, $n, %x, and %X operators can take a

# by a comma and are enclosed by curly braces. The replacement spec comes

# after the % character but before the operator letter. (e.g.

# "%{old,new}d"). Muliple replacement specs should be separated by

oldvalue

end

# running when the :nowrite flag is set.

#

# Example:

private :resolve_exclude

# Return a new FileList with the results of running +sub+ against each

#

# Example:

# FileList['a.c', 'b.c'].sub(/\.c$/, '.o') => ['a.o', 'b.o']

[name, args]

end

def standard_exception_handling

begin

yield

# * If you want to include extensions written in C, see RDoc::C_Parser

# * For information on the various markups available in comment blocks, see

# RDoc::Markup.

# * If you want to use the library to format text blocks into HTML, have a look

# at RDoc::Markup.

# * If you want to try writing your own HTML output template, see

# Stop and start adding new documentation elements to the current container.

# For example, if a class has a number of constants that you don't want to

# document, put a +:stopdoc:+ before the first, and a +:startdoc:+ after the

# disables documentation for the entire class or module.

#

# = Other stuff

* If you want to include extensions written in C, see RDoc::C_Parser

* For information on the various markups available in comment blocks, see

RDoc::Markup.

* If you want to use the library to format text blocks into HTML, have a look

at RDoc::Markup.

* If you want to try writing your own HTML output template, see

Stop and start adding new documentation elements to the current container.

For example, if a class has a number of constants that you don't want to

document, put a +:stopdoc:+ before the first, and a +:startdoc:+ after the

disables documentation for the entire class or module.

= Other stuff

module RDoc::Generator

##

FILE_DIR = "files"

##

CLASS_DIR = "classes"

# This is a template for RDoc that uses XHTML 1.0 Transitional and dictates a

# bit more of the appearance of the output to cascading stylesheets than the

# default. It was designed for clean inline code display, and uses DHTMl to

# link.

#

# == Authors

def process_class(from_class)

generate_class_info(from_class)

from_class.each_classmodule do |mod|

process_class(mod)

end

# RDoc::Markup is intended to be the basis for a family of tools which share

# the common requirement that simple, plain-text should be rendered in a

# variety of different output formats and media. It is envisaged that

# Wiki entries, and online FAQs.

#

# = Basic Formatting

#

# You can extend the RDoc::Markup parser to recognise new markup

# sequences, and to add special processing for text that matches a

# and also make the sequences {word} and \<no>text...</no> signify

# strike-through text. When then subclass the HTML output class to deal

# with these:

##

# Add to the sequences used to add formatting to an individual word (such

# formatters can recognize by their +name+.

def add_word_pair(start, stop, name)

attr_accessor :type

######

# types (a string) with a subclass of fragment

TYPE_MAP = {}

end

end

# doesn't work correctly under Windows NT, so we'll bypass the test under

# Windows.

# method in the HTML output. This method must be in the same source file

# as the rb_define_method.

#

# integrates C and Ruby source into one tree

#

#

# [Document-class: <i>name</i>]

# This comment block is documentation for the given class. Use this

# automatically find the method from it's declaration

#

# [call-seq: <i>text up to an empty line</i>]

# you need to document the calling sequence explicitly

#

# Ruby function is in the same source file as the rb_define_method call.

# If this isn't the case, add the comment

#

@progress = $stderr unless options.quiet

end

def scan

# remove private comment

#

# If "all" argument is true, information of all arguments are returned.

# If "modified_params" is true, list of arguments are decorated,

#

def find_arguments(args, text, all=nil, indent=nil, modified_params=nil)

return unless args || all

#

# Comments just after module or subprogram, or arguments are

#

def find_comments text

return "" unless text

# This file contains stuff stolen outright from:

#

# rtags.rb -

# ruby-token.rb - ruby tokens

# by Keiju ISHITSUKA (Nippon Rational Inc.)

#

# subdirectories.

#

# The effect of this is that if you want a file with a non-standard

def normalized_file_list(options, relative_files, force_doc = false,

exclude_pattern = nil)

attr_accessor :constants

attr_accessor :includes

def merge_in(old)

merge(@class_methods, old.class_methods)

merge(@instance_methods, old.instance_methods)

end

##

def each_name(address, &proc)

lazy_initialize

end

##

##

# The raw IPv4 address as a String.

@pairs.keys.include? key

end

# attlist_decl.each { |attribute_name, attribute_value| ... }

def each(&block)

@pairs.each(&block)

# A controversial point is whether Document should always write the XML

# declaration (<?xml version='1.0'?>) whether or not one is given by the

# user (or source document). REXML does not write one if one was not

# as XML-RPC.

#

# See also the classes in the rexml/formatters package for the proper way

# Iterates through the children, yielding for each Element that

# has a particular text set.

# text::

# over all +Element+ children that contain at least one +Text+ node.

# max::

# (optional) causes this method to return after yielding

end

alias :size :length

# nodes, not String values.

#

# doc = Document.new '<a x="1" y="2"/>'

end

end

# and value as a pair of Strings.

#

# doc = Document.new '<a x="1" y="2"/>'

end

def wrap(string, width)

return string if string.length <= width

place = string.rindex(' ', width) # Position in string with last ' ' before cutoff

return string[0,place] + "\n" + wrap(string[place+1..-1], width)

# from string then we ignore the second &

# subsequent mappings

#

# in the output. This happens if the from

# string is longer than the to string

#

end

def wrap(string, width, addnewline=false)

return string if string.length <= width

place = string.rindex(' ', width) # Position in string with last ' ' before cutoff

if addnewline then

parser.parse(path, element).flatten[0]

end

# block with the match.

# element::

# The context element

# 1. A RingServer begins listening on the broadcast UDP address.

# 2. A RingFinger sends a UDP packet containing the DRb URI where it will

# listen for a reply.

# provided DRb URI with the DRb service.

class RingServer

end

##

def self.to_a

finger.to_a

add_common_option('-V', '--[no-]verbose',

'Set the verbose level of output') do |value, options|

if Gem.configuration.verbose and value then

Gem.configuration.verbose = 1

else

class CommandManager

include UserInteraction

def self.instance

@command_manager ||= CommandManager.new

end

@commands.keys.collect {|key| key.to_s}.sort

end

def run(args)

process_args(args)

rescue StandardError, Timeout::Error => ex

Dir::glob(glob_str) do |path|

begin

cert = OpenSSL::X509::Certificate.new(File.read(path))

say cert.subject.to_s

rescue OpenSSL::X509::CertificateError

next

##

# Returns a list of pairs of gemspecs and source_uris that match

# Gem::Dependency +dep+ from both local (Dir.pwd) and remote (Gem.sources)

def find_gems_with_sources(dep)

gems_and_sources = []

@ssl_available

end

attr_writer :ssl_available

# Ensure that SSL is available. Throw an exception if it is not.

end

##

#

# version:: [Gem::Version] the version to compare against

# return:: [Boolean] true if this requirement is satisfied by

#

# Medium security policy: verify the signing certificate, verify the signing

# certificate chain all the way to the root certificate, and only trust root

#

# This security policy is reasonable, but it allows unsigned packages, so a

# malicious person could simply delete the package signature and pass the

# High security policy: only allow signed gems to be installed, verify the

# signing certificate, verify the signing certificate chain all the way to

# the root certificate, and only trust root certificates that we have

#

# This security policy is significantly more difficult to bypass, and offers

# a reasonable guarantee that the contents of the gem have not been altered.

# Gem::Server and allows users to serve gems for consumption by

# `gem --remote-install`.

#

# * "/" - Browsing of gem spec files for installed gems

# * "/Marshal" - Full SourceIndex dump of metadata for installed gems

# * "/yaml" - YAML dump of metadata for installed gems - deprecated

# SourceInfoCache stores a copy of the gem index for each gem source.

#

# There are two possible cache locations, the system cache and the user cache:

# * The user cache is used otherwise

#

# Once a cache is selected, it will be used for all operations.

# Allows deinstallation of gems with legacy platforms.

attr_accessor :original_platform # :nodoc:

# The the version number of a specification that does not specify one

# (i.e. RubyGems 0.7 or earlier).

DefaultUserInteraction.ui

end

# simple console based UserInteraction will be used automatically.

def ui=(new_ui)

DefaultUserInteraction.ui = new_ui

ask(question) if question

end

# that might have been defined.

def terminate_interaction(status = 0)

raise Gem::SystemExitException, status

@default_record_separator = rs

end

mutex_methods = ["unlock", "lock", "locked?", "synchronize", "try_lock", "exclusive_unlock"]

for m in mutex_methods

def_delegator("@debug_output_mutex", m, "debug_output_"+m.to_s)

end

end

USING_AT_EXIT_WHEN_PROCESS_EXIT = true

at_exit do

wait_to_finish_all_process_controllers unless $@

private

HopByHop = %w( connection keep-alive proxy-authenticate upgrade

proxy-authorization te trailers transfer-encoding )

ShouldNotTransfer = %w( set-cookie proxy-connection )

response = yield(http, path, header)

end

# So I will close the connection in every response.

res['proxy-connection'] = "close"

res['connection'] = "close"

end

end

if @status == 304 || @status == 204 || HTTPStatus::info?(@status)

@header.delete('content-length')

@body = ""