Results for: "OptionParser"

BasicSpecification is an abstract class which implements some common code used by both Specification and StubSpecification.

Gem::Server and allows users to serve gems for consumption by ‘gem –remote-install`.

gem_server starts an HTTP server on the given port and serves the following:

• “/” - Browsing of gem spec files for installed gems

• “/specs.#{Gem.marshal_version}.gz” - specs name/version/platform index

• “/latest_specs.#{Gem.marshal_version}.gz” - latest specs name/version/platform index

• “/quick/” - Individual gemspecs

• “/gems” - Direct access to download the installable gems

• “/rdoc?q=” - Search for installed rdoc documentation

Usage

gem_server = Gem::Server.new Gem.dir, 8089, false
gem_server.run

The Specification class contains the information for a Gem. Typically defined in a .gemspec file or a Rakefile, and looks like this:

Gem::Specification.new do |s|
  s.name        = 'example'
  s.version     = '0.1.0'
  s.licenses    = ['MIT']
  s.summary     = "This is an example!"
  s.description = "Much longer explanation of the example!"
  s.authors     = ["Ruby Coder"]
  s.email       = 'rubycoder@example.com'
  s.files       = ["lib/example.rb"]
  s.homepage    = 'https://rubygems.org/gems/example'
end

Starting in RubyGems 2.0, a Specification can hold arbitrary metadata. See metadata for restrictions on the format and size of metadata items you may add to a specification.

Gem::StubSpecification reads the stub: line from the gemspec. This prevents us having to eval the entire gemspec in order to find out certain information.

An HTTP Proxy server which proxies GET, HEAD and POST requests.

To create a simple proxy server:

require 'webrick'
require 'webrick/httpproxy'

proxy = WEBrick::HTTPProxyServer.new Port: 8000

trap 'INT'  do proxy.shutdown end
trap 'TERM' do proxy.shutdown end

proxy.start

See ::new for proxy-specific configuration items.

Modifying proxied responses

To modify content the proxy server returns use the :ProxyContentHandler option:

handler = proc do |req, res|
  if res['content-type'] == 'text/plain' then
    res.body << "\nThis content was proxied!\n"
  end
end

proxy =
  WEBrick::HTTPProxyServer.new Port: 8000, ProxyContentHandler: handler

An HTTP Server

Base server class

This is the base class for all XML-RPC server-types (CGI, standalone). You can add handler and set a default handler. Do not use this server, as this is/should be an abstract class.

How the method to call is found

The arity (number of accepted arguments) of a handler (method or Proc object) is compared to the given arguments submitted by the client for a RPC, or Remote Procedure Call.

A handler is only called if it accepts the number of arguments, otherwise the search for another handler will go on. When at the end no handler was found, the default_handler, XMLRPC::BasicServer#set_default_handler will be called.

With this technique it is possible to do overloading by number of parameters, but only for Proc handler, because you cannot define two methods of the same name in the same class.

Implements a CGI-based XML-RPC server.

require "xmlrpc/server"

s = XMLRPC::CGIServer.new

s.add_handler("michael.add") do |a,b|
  a + b
end

s.add_handler("michael.div") do |a,b|
  if b == 0
    raise XMLRPC::FaultException.new(1, "division by zero")
  else
    a / b
  end
end

s.set_default_handler do |name, *args|
  raise XMLRPC::FaultException.new(-99, "Method #{name} missing" +
                                   " or wrong number of parameters!")
end

s.serve

Note: Make sure that you don’t write to standard-output in a handler, or in any other part of your program, this would cause a CGI-based server to fail!

Implements a XML-RPC server, which works with Apache mod_ruby.

Use it in the same way as XMLRPC::CGIServer!

Implements a standalone XML-RPC server. The method XMLRPC::Server#serve is left if a SIGHUP is sent to the program.

 require "xmlrpc/server"

s = XMLRPC::Server.new(8080)

s.add_handler("michael.add") do |a,b|
  a + b
end

s.add_handler("michael.div") do |a,b|
  if b == 0
    raise XMLRPC::FaultException.new(1, "division by zero")
  else
    a / b
  end
end

s.set_default_handler do |name, *args|
  raise XMLRPC::FaultException.new(-99, "Method #{name} missing" +
                                   " or wrong number of parameters!")
end

s.serve

Mixin module that provides the following:

1. Access to the CGI environment variables as methods. See documentation to the CGI class for a list of these variables. The methods are exposed by removing the leading HTTP_ (if it exists) and downcasing the name. For example, auth_type will return the environment variable AUTH_TYPE, and accept will return the value for HTTP_ACCEPT.

2. Access to cookies, including the cookies attribute.

3. Access to parameters, including the params attribute, and overloading [] to perform parameter value lookup by key.

4. The initialize_query method, for initializing the above mechanisms, handling multipart forms, and allowing the class to be used in “offline” mode.

If you add a method, keep in mind two things: (1) the first argument will always be a list of nodes from which to filter. In the case of context methods (such as position), the function should return an array with a value for each child in the array. (2) all method calls from XML will have “-” replaced with “_”. Therefore, in XML, “local-name()” is identical (and actually becomes) “local_name()”

Utility methods for using the RubyGems API.

C union shell

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.