OpenURI is an easy-to-use wrapper for Net::HTTP, Net::HTTPS and Net::FTP.
It is possible to open an http, https or ftp URL as though it were a file:
URI.open("http://www.ruby-lang.org/") {|f| f.each_line {|line| p line} }
The opened file has several getter methods for its meta-information, as follows, since it is extended by OpenURI::Meta.
URI.open("http://www.ruby-lang.org/en") {|f| f.each_line {|line| p line} p f.base_uri # <URI::HTTP:0x40e6ef2 URL:http://www.ruby-lang.org/en/> p f.content_type # "text/html" p f.charset # "iso-8859-1" p f.content_encoding # [] p f.last_modified # Thu Dec 05 02:45:02 UTC 2002 }
Additional header fields can be specified by an optional hash argument.
URI.open("http://www.ruby-lang.org/en/", "User-Agent" => "Ruby/#{RUBY_VERSION}", "From" => "foo@bar.invalid", "Referer" => "http://www.ruby-lang.org/") {|f| # ... }
The environment variables such as http_proxy, https_proxy and ftp_proxy are in effect by default. Here we disable proxy:
URI.open("http://www.ruby-lang.org/en/", :proxy => nil) {|f| # ... }
See OpenURI::OpenRead.open and URI.open for more on available options.
URI objects can be opened in a similar way.
uri = URI.parse("http://www.ruby-lang.org/en/") uri.open {|f| # ... }
URI objects can be read directly. The returned string is also extended by OpenURI::Meta.
str = uri.read p str.base_uri
Tanaka Akira <akr@m17n.org>
Module Open3 supports creating child processes with access to their $stdin, $stdout, and $stderr streams.
Each of these methods executes a given command in a new process or subshell, or multiple commands in new processes and/or subshells:
Each of these methods executes a single command in a process or subshell, accepts a string for input to $stdin, and returns string output from $stdout, $stderr, or both:
Open3.capture2: Executes the command; returns the string from $stdout.
Open3.capture2e: Executes the command; returns the string from merged $stdout and $stderr.
Open3.capture3: Executes the command; returns strings from $stdout and $stderr.
Each of these methods executes a single command in a process or subshell, and returns pipes for $stdin, $stdout, and/or $stderr:
Open3.popen2: Executes the command; returns pipes for $stdin and $stdout.
Open3.popen2e: Executes the command; returns pipes for $stdin and merged $stdout and $stderr.
Open3.popen3: Executes the command; returns pipes for $stdin, $stdout, and $stderr.
Each of these methods executes one or more commands in processes and/or subshells, returns pipes for the first $stdin, the last $stdout, or both:
Open3.pipeline_r: Returns a pipe for the last $stdout.
Open3.pipeline_rw: Returns pipes for the first $stdin and the last $stdout.
Open3.pipeline_w: Returns a pipe for the first $stdin.
Open3.pipeline_start: Does not wait for processes to complete.
Open3.pipeline: Waits for processes to complete.
Each of the methods above accepts:
An optional hash of environment variable names and values; see Execution Environment.
A required string argument that is a command_line or exe_path; see Argument command_line or exe_path.
An optional hash of execution options; see Execution Options.
The Singleton module implements the Singleton pattern.
To use Singleton, include the module in your class.
class Klass include Singleton # ... end
This ensures that only one instance of Klass can be created.
a,b = Klass.instance, Klass.instance a == b # => true Klass.new # => NoMethodError - new is private ...
The instance is created at upon the first call of Klass.instance().
class OtherKlass include Singleton # ... end ObjectSpace.each_object(OtherKlass){} # => 0 OtherKlass.instance ObjectSpace.each_object(OtherKlass){} # => 1
This behavior is preserved under inheritance and cloning.
This above is achieved by:
Making Klass.new and Klass.allocate private.
Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the Singleton properties are kept when inherited and cloned.
Providing the Klass.instance() method that returns the same object each time it is called.
Overriding Klass._load(str) to call Klass.instance().
Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent cloning or duping.
Singleton and Marshal By default Singleton’s _dump(depth) returns the empty string. Marshalling by default will strip state information, e.g. instance variables from the instance. Classes using Singleton can provide custom _load(str) and _dump(depth) methods to retain some of the previous state of the instance.
require 'singleton' class Example include Singleton attr_accessor :keep, :strip def _dump(depth) # this strips the @strip information from the instance Marshal.dump(@keep, depth) end def self._load(str) instance.keep = Marshal.load(str) instance end end a = Example.instance a.keep = "keep this" a.strip = "get rid of this" stored_state = Marshal.dump(a) a.keep = nil a.strip = nil b = Marshal.load(stored_state) p a == b # => true p a.keep # => "keep this" p a.strip # => nil
Timeout long-running blocks
require 'timeout' status = Timeout.timeout(5) { # Something that should be interrupted if it takes more than 5 seconds... }
Timeout provides a way to auto-terminate a potentially long-running operation if it hasn’t finished in a fixed amount of time.
© 2000 Network Applied Communication Laboratory, Inc.
© 2000 Information-technology Promotion Agency, Japan
A base class for objects representing a C union
The base exception for JSON errors.
This exception is raised if the nesting of parsed data structures is too deep.
This exception is raised if a generator or unparser error occurs.
This class is used as a return value from ObjectSpace::reachable_objects_from.
When ObjectSpace::reachable_objects_from returns an object with references to an internal object, an instance of this class is returned.
You can use the type method to check the type of the internal object.
Generic error, common for all classes under OpenSSL module
General error for openssl library configuration files. Including formatting, parsing errors, etc.
OLEProperty is a helper class of Property with arguments, used by olegen.rb-generated files.
Raised when OLE processing failed.
EX:
obj = WIN32OLE.new("NonExistProgID")
raises the exception:
WIN32OLE::RuntimeError: unknown OLE server: `NonExistProgID'
HRESULT error code:0x800401f3
Invalid class string
WIN32OLE::Param objects represent param information of the OLE method.
Can be raised by IO operations when IO#timeout= is set.
Raised when the provided IP address is an invalid address.
This class is the base class for Net::HTTP response classes.
Method Net::HTTP.get_response returns an instance of one of the subclasses of Net::HTTPResponse:
Net::HTTP.get_response(uri) # => #<Net::HTTPOK 200 OK readbody=true> Net::HTTP.get_response(hostname, '/nosuch') # => #<Net::HTTPNotFound 404 Not Found readbody=true>
As does method Net::HTTP#request:
req = Net::HTTP::Get.new(uri) Net::HTTP.start(hostname) do |http| http.request(req) end # => #<Net::HTTPOK 200 OK readbody=true>
Class Net::HTTPResponse includes module Net::HTTPHeader, which provides access to response header values via (among others):
Hash-like method [].
Specific reader methods, such as content_type.
Examples:
res = Net::HTTP.get_response(uri) # => #<Net::HTTPOK 200 OK readbody=true> res['Content-Type'] # => "text/html; charset=UTF-8" res.content_type # => "text/html"
Class Net::HTTPResponse has a subclass for each HTTP status code. You can look up the response class for a given code:
Net::HTTPResponse::CODE_TO_OBJ['200'] # => Net::HTTPOK Net::HTTPResponse::CODE_TO_OBJ['400'] # => Net::HTTPBadRequest Net::HTTPResponse::CODE_TO_OBJ['404'] # => Net::HTTPNotFound
And you can retrieve the status code for a response object:
Net::HTTP.get_response(uri).code # => "200" Net::HTTP.get_response(hostname, '/nosuch').code # => "404"
The response subclasses (indentation shows class hierarchy):
Net::HTTPUnknownResponse (for unhandled HTTP extensions).
Net::HTTPContinue (100)
Net::HTTPSwitchProtocol (101)
Net::HTTPProcessing (102)
Net::HTTPEarlyHints (103)
Net::HTTPOK (200)
Net::HTTPCreated (201)
Net::HTTPAccepted (202)
Net::HTTPNoContent (204)
Net::HTTPResetContent (205)
Net::HTTPPartialContent (206)
Net::HTTPMultiStatus (207)
Net::HTTPAlreadyReported (208)
Net::HTTPIMUsed (226)
Net::HTTPMultipleChoices (300)
Net::HTTPFound (302)
Net::HTTPSeeOther (303)
Net::HTTPNotModified (304)
Net::HTTPUseProxy (305)
Net::HTTPBadRequest (400)
Net::HTTPUnauthorized (401)
Net::HTTPPaymentRequired (402)
Net::HTTPForbidden (403)
Net::HTTPNotFound (404)
Net::HTTPNotAcceptable (406)
Net::HTTPRequestTimeOut (408)
Net::HTTPConflict (409)
Net::HTTPGone (410)
Net::HTTPLengthRequired (411)
Net::HTTPLocked (423)
Net::HTTPUpgradeRequired (426)
Net::HTTPTooManyRequests (429)
Net::HTTPNotImplemented (501)
Net::HTTPBadGateway (502)
Net::HTTPGatewayTimeOut (504)
Net::HTTPLoopDetected (508)
Net::HTTPNotExtended (510)
There is also the Net::HTTPBadResponse exception which is raised when there is a protocol error.
Response class for Continue responses (status code 100).
A Continue response indicates that the server has received the request headers.
References: