Ruby » Ruby master

#

# Built on two universally available structures:

# 1. A collection of name/value pairs. Often referred to as an _object_, hash table, record, struct, keyed list, or associative array.

#

# To read more about JSON visit: http://json.org

#

# == Parsing JSON

#

# your existing application:

#

# require 'json'

# puts {:hello => "goodbye"}.to_json => "{\"hello\":\"goodbye\"}"

#

# <tt>JSON.generate</tt> only allows objects or arrays to be converted

#

# require 'json'

#

module JSON

class << self

# as a Ruby data structure. Otherwise generate a JSON text from the Ruby

# data structure object and return it.

#

# generate and parse for their documentation.

def [](object, opts = {})

if object.respond_to? :to_str

end

end

# JSON::Ext::Parser or JSON::Pure::Parser.

attr_reader :parser

end

# Return the constant located at _path_. The format of _path_ has to be

# level (absolute namespace path?). If there doesn't exist a constant at

# the given path, an ArgumentError is raised.

def deep_const_get(path) # :nodoc:

$VERBOSE = old

end

# either JSON::Ext::Generator or JSON::Pure::Generator.

attr_reader :generator

attr_accessor :state

# hook of a class should be called. It defaults to 'json_class'.

attr_accessor :create_id

end

# The base exception for JSON errors.

class JSONError < StandardError; end

class ParserError < JSONError; end

# deep.

class NestingError < ParserError; end

class CircularDatastructure < NestingError; end

# :startdoc:

class GeneratorError < JSONError; end

# For backwards compatibility

UnparserError = GeneratorError

class MissingUnicodeSupport < JSONError; end

module_function

# _opts_ can have the following

# keys:

# * *max_nesting*: The maximum depth of nesting allowed in the parsed data

# to 19.

# * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in

# defiance of RFC 4627 to be parsed by the Parser. This option defaults

# to false.

# * *symbolize_names*: If set to true, returns symbols for the names

# the default.

# * *create_additions*: If set to false, the Parser doesn't create

# defaults to true.

# * *object_class*: Defaults to Hash

# * *array_class*: Defaults to Array

end

# Parse the JSON document _source_ into a Ruby data structure and return it.

# for the _opts_ hash, so be sure only to parse trusted _source_ documents.

#

# _opts_ can have the following keys:

# * *max_nesting*: The maximum depth of nesting allowed in the parsed data

# structures. Enable depth checking with :max_nesting => anInteger. The parse!

# if someone wants to fill up your stack.

# * *allow_nan*: If set to true, allow NaN, Infinity, and -Infinity in

# defiance of RFC 4627 to be parsed by the Parser. This option defaults

# to true.

# * *create_additions*: If set to false, the Parser doesn't create

# defaults to true.

def parse!(source, opts = {})

opts = {

# * *object_nl*: a string that is put at the end of a JSON object (default: ''),

# * *array_nl*: a string that is put at the end of a JSON array (default: ''),

# * *allow_nan*: true if NaN, Infinity, and -Infinity should be

# encountered. This options defaults to false.

# * *max_nesting*: The maximum depth of nesting allowed in the data

# structures from which JSON is to be generated. Disable depth checking

#

# See also the fast_generate for the fastest creation method with the least

# amount of sanity checks, and the pretty_generate method for some

def generate(obj, opts = nil)

state = SAFE_STATE_PROTOTYPE.dup

if opts

# This method disables the checks for circles in Ruby objects.

#

# *WARNING*: Be careful not to pass any Ruby data structures with circles as

def fast_generate(obj, opts = nil)

state = FAST_STATE_PROTOTYPE.dup

if opts

# The returned document is a prettier form of the document returned by

# #unparse.

#

# generate method for a more detailed explanation.

def pretty_generate(obj, opts = nil)

state = PRETTY_STATE_PROTOTYPE.dup

# :startdoc:

# Load a ruby data structure from a JSON _source_ and return it. A source can

# to the read method. If _proc_ was given, it will be called with any nested

# Ruby object as an argument recursively in depth first order.

#

# Dumps _obj_ as a JSON string, i.e. calls generate on the object and returns

# the result.

#

# was given, the resulting JSON is written to it.

#

# exception is raised. This argument is similar (but not exactly the

# same!) to the _limit_ argument in Marshal.dump.

#

nil

end

# structure object and return it.

#

# generate and parse for their documentation.

def JSON(object, *args)

if object.respond_to? :to_str

# Extends any Class to include _json_creatable?_ method.

class ::Class

# from a serialised JSON string. The class has to implement a class

def json_creatable?

respond_to?(:json_create)

end

# pn.children(false)

# # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]

#

# the directory because they are not children.

#

# This method has existed since 1.8.1.

# manner. It yields a Pathname for each file under "this" directory.

#

# Since it is implemented by <tt>find.rb</tt>, <tt>Find.prune</tt> can be used

#

# If +self+ is <tt>.</tt>, yielded pathnames begin with a filename in the

# current directory, not <tt>./</tt>.

# Reads ios until pattern matches or the timeout is over. It returns

# an array with the read buffer, followed by the matches. If a block is given,

# the result is yielded to the block and returns nil. The optional timeout parameter defines,

# returns/yields nil. However, the buffer in a timeout session is kept for the next expect call.

# The default timeout is 9999999 seconds.

def expect(pat,timeout=9999999)

# 20 / 9 * 3 * 14 / 7 * 3 / 2 # => 20

#

#

# are also loaded.

#

# == Copyright

end

##

#

# 2/3*3 # => 0

# require 'mathn'

##

# When mathn is required Bignum's division and exponentiation are enhanced to

class Bignum

remove_method :/

end

##

# operations.

#

# Normal behaviour:

end

##

#

# Standard Math module behaviour:

# Math.sqrt(4/9) # => 0.0

# Math.sqrt(4.0/9.0) # => 0.666666666666667

# Math.sqrt(- 4/9) # => Errno::EDOM: Numerical argument out of domain - sqrt

#

#

# require 'mathn'

# Math.sqrt(4/9) # => 2/3

end

##

class Float

alias power! **

# Here is HTTP response class hierarchy. All classes are defined in Net

# module and are subclasses of Net::HTTPResponse.

#

# HTTPInformation:: 1xx

# HTTPContinue:: 100

# HTTPSwitchProtocol:: 101

# Creates a new Net::HTTP object, then additionally opens the TCP

# connection and HTTP session.

#

# _address_ :: hostname or IP address of the server

# _port_ :: port of the server

# _p_addr_ :: address of proxy

alias open_uri_original_open open # :nodoc:

end

#

#

#

# Since open-uri.rb provides URI::HTTP#open, URI::HTTPS#open and

# URI::FTP#open,

# http://, https:// and ftp://.

def open(name, *rest, &block) # :doc:

if name.respond_to?(:open)

name.open(*rest, &block)

#

#== Example

#

#

# open("http://www.ruby-lang.org/") {|f|

# f.each_line {|line| p line}

# }

#

#

# open("http://www.ruby-lang.org/en") {|f|

# f.each_line {|line| p line}

end

end

attr_accessor :status

attr_accessor :base_uri

# The Hash keys are downcased for canonicalization.

attr_reader :meta

meta_setup_encoding if name == 'content-type'

end

def last_modified

if v = @meta['last-modified']

Time.httpdate(v)

#

# `options' must be a hash.

#

# field for HTTP.

# I.e. it is ignored for FTP without HTTP proxy.

#

#

# [:proxy]

# Synopsis:

#

# If :content_length_proc option is specified, the option value procedure

# is called before actual transfer is started.

#

# If two or more transfer is done by HTTP redirection, the procedure

# is called only one for a last transfer.

#

# When expected content length is unknown, the procedure is called with

# nil.

#

# [:progress_proc]

# Synopsis:

#

# :ssl_verify_mode is used to specify openssl verify mode.

#

# Otherwise it yields the IO object and return the value of the block.

# The IO object is extended with OpenURI::Meta.

#

# Synopsis:

# :redirect=>bool

#

# OpenURI::HTTPRedirect exception raised on redirection.

# It is true by default.

#

def open(*rest, &block)

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

#

# An OpenStruct is a data structure, similar to a Hash, that allows the

# definition of arbitrary attributes with their accompanying values. This is

# itself.

#

# == Examples:

# method_missing and define_method.

#

# This should be a consideration if there is a concern about the performance of

#

class OpenStruct

#

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

# regular expression. Here we make WikiWords significant to the parser,

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

# with these:

#

# require 'rdoc/markup'

#

# == Encoding

#

# documents to the same output encoding. The output encoding can be set via

# RDoc::Options#encoding and defaults to Encoding.default_external.

#

# === Simple Lists

#

# If a paragraph starts with a "*", "-", "<digit>." or "<letter>.",

# the first non-space following the list start flag. Subsequent lines

# should be indented to this new margin until the list ends. For example:

#

#

# [+:nodoc:+ / <tt>:nodoc: all</tt>]

# This directive prevents documentation for the element from

# constants, and attributes directly within the affected class or

# module also will be omitted. By default, though, modules and

# turned off by adding the +all+ modifier.

#

# module MyModule # :nodoc:

attr_reader :attribute_manager

##

# structure (paragraphs, lists, and so on). Invoke an event handler as we

# identify significant chunks.

require 'rdoc/stats'

##

#

# #initialize(file_name, body, options)

#

#

# The ParseFactory is used to redirect to the correct parser given a

# filename extension. This magic works because individual parsers have to

#

# require "rdoc/parser"

#

class << self

##

#

# Use parse_files_matching to register a parser's file extensions.

# that's it's unnecessary to explicitly delete a Tempfile after use, though

# it's good practice to do so: not explicitly deleting unused Tempfiles can

# potentially leave behind large amounts of tempfiles on the filesystem

# it harder to determine a new Tempfile filename.

#

# Therefore, one should always call #unlink or close in an ensure block, like

# Wakes up all threads waiting for this lock.

#

def broadcast

waiters0 = nil

@waiters_mutex.synchronize do

waiters0 = @waiters.dup

def initialize

@que = []

@waiting = []

@waiting.taint

self.taint

@mutex = Mutex.new

require "delegate"

require 'thread'

# garbage-collected. A WeakRef may be used exactly like the object it

# references.

#

require "webrick/httpproxy"

# :ProxyContentHandler will be invoked before sending

# message if necessary).

pch = Proc.new{|req, res|