Ruby » Ruby master

n = ARGV[0].to_i.nonzero? || 50000

puts %Q([#{n} times iterations of `a = "1"'])

benchmark(" " + CAPTION, 7, FMTSTR) do |x|

end

benchmark do

[

]

end

end

end

def self.open(uri, config)

host.untaint

port.untaint

soc = TCPSocket.open(host, port)

def self.open_server(uri, config)

uri = 'drbssl://:0' unless uri

if host.size == 0

host = getservername

soc = open_server_inaddr_any(host, port)

def keeper

Thread.new do

loop do

sleep(@timeout)

end

end

end

def self.open(uri, config)

filename.untaint

soc = UNIXSocket.open(filename)

self.new(uri, soc, config)

end

def self.open_server(uri, config)

if filename.size == 0

soc = temp_server

filename = soc.path

end

def thread(key)

th

end

def irb(key)

irb

end

def kill(*keys)

for key in keys

IRB.fail IrbAlreadyDead unless th.alive?

th.exit

end

#

while true

end

end

def expect(name, retval, args=[])

@expected_calls[name] = { :retval => retval, :args => args }

self.class.__send__ :remove_method, name if respond_to? name

self.class.__send__(:define_method, name) { |*x|

sock = TCPServer.open(@sock.addr[3], 0)

port = sock.addr[1]

host = sock.addr[3]

return sock

end

private :makeport

# or sub-type is not given (e.g. "Content-Type: text").

def sub_type

return nil unless @header['content-type']

return nil unless sub

sub.strip

end

token = match(T_ATOM)

name = token.value.upcase

match(T_SPACE)

data = []

token = lookahead

if token.symbol == T_SPACE

def OpenURI.open_uri(name, *rest) # :nodoc:

uri = URI::Generic === name ? name : URI.parse(name)

options = rest.shift if !rest.empty? && Hash === rest.first

raise ArgumentError.new("extra arguments") if !rest.empty?

options ||= {}

# It is downcased for canonicalization.

# Content-Type parameters are stripped.

def content_type

type || 'application/octet-stream'

end

when 0 # no proxy setting anyway.

proxy_uri = nil

when 1

if k == 'http_proxy' && ENV[k.upcase] == nil

# http_proxy is safe to use because ENV is case sensitive.

proxy_uri = ENV[name]

default_style = Switch::NoArgument

default_pattern = nil

klass = nil

opts.each do |o|

# argument class

def _racc_do_parse_rb(arg, in_debug)

action_table, action_check, action_default, action_pointer,

_racc_init_sysvars

tok = act = i = nil

catch(:racc_end_parse) {

while true

def _racc_yyparse_rb(recv, mid, arg, c_debug)

action_table, action_check, action_default, action_pointer,

_racc_init_sysvars

act = nil

i = nil

catch(:racc_end_parse) {

until i = action_pointer[@racc_state[-1]]

###

def _racc_evalact(act, arg)

nerr = 0 # tmp

if act > 0 and act < shift_n

end

def _racc_do_reduce(arg, act)

goto_table, goto_check, goto_default, goto_pointer,

state = @racc_state

vstack = @racc_vstack

tstack = @racc_tstack

else

begin

ln(*args)

LN_SUPPORTED[0] = false

cp(*args)

end

end

def create_rule(*args, &block)

pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern

@rules << [pattern, deps, block]

end

fail Rake::RuleRecursionOverflowError,

"Rule Recursion Too Deep" if level >= 16

@rules.each do |pattern, extensions, block|

task = attempt_rule(task_name, extensions, block, level)

return task if task

end

rescue LoadError => ex

begin

rake_require value

raise ex

end

end

def initialize(path, entry)

@path = path

@size = size.to_i

@time = determine_time(d1, d2, d3)

end

def determine_time(d1, d2, d3)

now = self.class.time.now

if /:/ =~ d3

result = Time.parse("#{d1} #{d2} #{now.year} #{d3}")

if result > now

result = Time.parse("#{d1} #{d2} #{now.year-1} #{d3}")

def split_into_flow

res = []

current_attr = 0

str_len = @str.length

# Skips a token of +token_type+, optionally raising an error.

def skip token_type, error = true

return unless type # end of stream

\s*(\([^)]*\))([^;]|$))"xm

comment = $1

body_text = $2

remove_private_comments comment if comment

find_modifiers comment, meth_obj if comment

meth_obj.start_collecting_tokens

tk = RDoc::RubyToken::Token.new nil, 1, 1

tk.set_text body_text

def parse_attr_accessor(context, single, tk, comment)

args = parse_symbol_arg

rw = "?"

# TODO If nodoc is given, don't document any of them

def parse_meta_attr(context, single, tk, comment)

args = parse_symbol_arg

rw = "?"

# If nodoc is given, don't document any of them

@generator = gen_klass.for @options

Dir.chdir @options.op_dir do

begin

self.class.current = self

tk_c = TkLPAREN

end

@indent_stack.push tk_c

end

@OP.def_rule("[]", proc{|op, io| @lex_state == EXPR_FNAME}) do

rescue Resolv::ResolvError

raise SocketError, "Hostname not known: #{host}"

end

addrs[0...-1].each {|addr|

begin

return original_resolv_send(mesg, flags, addr, port)

def doctype

if @element

doc = @element.document

end

end

# This doesn't yet handle encodings

def bytes

to_s

end

output << " #{@long_name.inspect}" if @long_name

output << " #{@uri.inspect}" if @uri

unless @children.empty?

output << ' ['

@children.each { |child|

output << "\n"

# a.elements.add(Element.new('b')) #-> <a><b/></a>

# a.elements.add('c') #-> <a><b/><c/></a>

def add element=nil

if element.nil?

Element.new("", self, @element.context)

elsif not element.kind_of?(Element)

delete attr

return

end

unless value.kind_of? Attribute

if @element.document and @element.document.doctype

value = Text::normalize( value, @element.document.doctype )

return @element

else # the supplied attribute is a top-level one

attr = old

end

@element

end

# If compact and all children are text, and if the formatted output

# is less than the specified width, then try to print everything on

# one line

@level += @indentation

node.children.each { |child|

write( child, output )

# Kouhei fixed this too

def Functions::substring_after( string, test )

ruby_string = string(string)

return $1 if ruby_string =~ /#{test}(.*)/

""

end

@listeners.each { |sym,match,block|

block.start_document if sym == :start_document or sym.nil?

}

while true

event = @parser.pull

case event[0]

PI = /^processing-instruction\(/

def NodeTest path, parsed

#puts "NodeTest with #{path}"

case path

when /^\*/

path = $'

NUMBER = /^(\d*\.?\d+)/

NT = /^comment|text|processing-instruction|node$/

def PrimaryExpr path, parsed

case path

when VARIABLE_REFERENCE

varname = $1

results = filter(element.to_a, path)

when /^[\[!\w:]/u

# match on child

children = element.to_a

results = filter(children, path)

else

when /^\/\//u # Descendant

return axe( elements, "descendant-or-self", $' )

when /^\/?\b(\w[-\w]*)\b::/u # Axe

return axe( elements, $1, $' )

when /^\/(?=\b([:!\w][-\.\w]*:)?[-!\*\.\w]*\b([^:(]|$)|\*)/u # Child

rest = $'

sattr = [:start_attribute, nil]

eattr = [:end_attribute]

text = [:text, nil]

sattr[1] = key

#puts "Looking for #{sattr.inspect}"

m = @current.next( sattr )

return rv

else

res = []

#puts "i1 = #{i1.inspect} (#{i1.class.name})"

#puts "i2 = #{i2.inspect} (#{i2.class.name})"

i1 = norm( i1 )

def lookup_ring_any(timeout=5)

queue = Queue.new

self.lookup_ring(timeout) do |ts|

queue.push(ts)

end

when 's'

require 'rinda/tuplespace'

ts = Rinda::TupleSpace.new

$stdin.gets

when 'w'

finger = Rinda::RingFinger.new(nil)

return false unless inline_other?

return false if inline_other_xml?

return true if "text" == media_type.downcase

false

end

class Channel < ChannelBase

def to_feed(rss)

channel = Rss::Channel.new

_not_set_required_variables = not_set_required_variables

if _not_set_required_variables.empty?

rss.channel = channel

class Item < ItemBase

def to_feed(rss)

item = Rss::Channel::Item.new

_not_set_required_variables = not_set_required_variables

if _not_set_required_variables.empty?

rss.items << item

_not_set_required_variables = not_set_required_variables

if _not_set_required_variables.empty?

channel = RDF::Channel.new(@about)

channel.dc_dates.clear

rss.channel = channel

set_parent(channel, rss)

plural_name ||= "#{name}s"

full_name = "#{RSS::DC_PREFIX}_#{name}"

full_plural_name = "#{RSS::DC_PREFIX}_#{plural_name}"

plural_klass_name = "DublinCore#{Utils.to_class_name(plural_name)}"

klass.def_classed_elements(full_name, "value", plural_klass_name,

full_plural_name, name)

klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)

tags = tags.sort_by {|x| element_names.index(x) || tags_size}

end

models.each_with_index do |model, i|

if DEBUG

p "before"

"Please specify at least one gem name (e.g. gem build GEMNAME)"

end

end

##

@parser.separator " #{header}Options:"

option_list.each do |args, handler|

@parser.on(*args) do |value|

handler.call(value, @options)

end

while not f.eof? and spec = Gem::Specification.from_yaml(f)

result << spec

end

# OK

end

end

say "Verifying gem: '#{gem_name}'"

begin

Gem::Validator.new.verify_gem_file(gem_name)

alert_error "#{gem_name} is invalid."

end

end

end

versions.each do |gem_name, matching_tuples|

version

end.reverse

platforms = Hash.new { |h,version| h[version] = [] }

platforms[version] << platform if platform

end

seen = {}

if seen[version] then

true

else

if options[:versions] then

list = if platforms.empty? or options[:details] then

else

platforms.sort.reverse.map do |version, pls|

if pls == [Gem::Platform::RUBY] then

else

begin

Socket.getservbyname port

raise OptionParser::InvalidArgument, "#{port}: no such named service"

end

end

end

end

name == l_name and Gem::Platform.match platform

end

version

end.last

:formatter => RDoc::RI::Formatter,

}

end

##

# representing the data in the gem

def self.from_file_by_path(file_path, security_policy = nil)

unless File.exist?(file_path)

raise Gem::Exception, "Cannot load gem at [#{file_path}] in #{Dir.pwd}"

end

# Reference a constant defined in the .rb portion of ssl (just to

# make sure that part is loaded too).

Gem.ssl_available = true

def generate_bin_script(filename, bindir)

bin_script_path = File.join bindir, formatted_program_filename(filename)

# HACK some gems don't have #! in their executables, restore 2008/06

#if File.read(exec_path, 2) == '#!' then

say results.join("\n") if Gem.configuration.really_verbose

results = results.join "\n"

File.open('gem_make.out', 'wb') { |f| f.puts results }

end

yield [entry, Zlib::Inflate.inflate(file_data.strip.unpack("m")[0])]

end

raise Gem::Exception, errstr

end

end

begin

fetcher = Gem::SpecFetcher.fetcher

remotes = fetcher.find_matching dependency

rescue Gem::RemoteFetcher::FetchError => e

raise unless fetcher.warn_legacy e do

require 'rubygems/source_info_cache'

private :same_attributes?

def hash # :nodoc:

n = self.send(name).hash

hash_code + n

}

def to_yaml(opts = {}) # :nodoc:

return super if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?

out.map taguri, to_yaml_style do |map|

encode_with map

end

gem_names = list.collect {|gem| gem.full_name} + ["All versions"]

say

if index == list.size then

remove_all list.dup

notify "Job(%id) start imp-pipe.", @shell.debug?

rs = @shell.record_separator unless rs

_eop = true

begin

while l = @pipe_in.gets

@input_queue.push l

def start_export

notify "job(%id) start exp-pipe.", @shell.debug?

_eop = true

begin

@input.each do |l|

ProcessController::block_output_synchronize do

def sync_try_lock(mode = EX)

return unlock if mode == UN

@sync_mutex.synchronize do

end

end

def sync_lock(m = EX)

ret[:REL_URI] = rel_uri = "(?:#{net_path}|#{abs_path}|#{rel_path})(?:\\?#{query})?"

# URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]

ret[:X_ABS_URI] = "

(#{scheme}): (?# 1: scheme)

setup_header

@header_part << CRLF

@header_part.rewind

raise CGIError, "invalid CGI environment"

end

end

if @request_method == "HEAD"

# do nothing

elsif chunked?

while buf = @body[@sent_size, @buffer_size]

break if buf.empty?

data = ""

STDIN.binmode

len = sysread(STDIN, 8).to_i

out = sysread(STDIN, len)

STDOUT.reopen(open(out, "w"))

dir = File::dirname(ENV["SCRIPT_FILENAME"])

Dir::chdir dir

argv = ARGV.dup

argv << ENV["SCRIPT_FILENAME"]

exec(*argv)

private

def evaluate(erb, servlet_request, servlet_response)

Module.new.module_eval{

erb.result(binding)

}

end

private

def format(arg)

"#{arg.class}: #{arg.message}\n\t" <<

arg.backtrace.join("\n\t") << "\n"

elsif arg.respond_to?(:to_str)

io << http_resp(response.status, response.status_message,

response.header, response.body)

io << http_resp(500, "Internal Server Error")

end

end

def parse(str)

end

end