Results for: "partition"

This module contains various utility methods as module methods.

Specifies a Specification object that should be activated. Also contains a dependency that was used to introduce this activation.

Class that parses String’s into URI’s.

It contains a Hash set of patterns and Regexp’s that match and validate.

Switch that can omit argument.

An error class raised when dynamic parts are found while computing a constant path’s full name. For example: Foo::Bar::Baz -> does not raise because all parts of the constant path are simple constants var::Bar::Baz -> raises because the first part of the constant path is a local variable

A GitSpecification represents a gem that is sourced from a git repository and is being loaded through a gem dependencies file through the git: option.

RubyVM::AbstractSyntaxTree::Location instances are created by RubyVM::AbstractSyntaxTree#locations.

This class is MRI specific.

Configuration options for dumping YAML.

Raised when the buffer cannot be allocated for some reason, or you try to use a buffer that’s not allocated.

Class for representing HTTP method OPTIONS:

require 'net/http'
uri = URI('http://example.com')
hostname = uri.hostname # => "example.com"
req = Net::HTTP::Options.new(uri) # => #<Net::HTTP::Options OPTIONS>
res = Net::HTTP.start(hostname) do |http|
  http.request(req)
end

See Request Headers.

Properties:

• Request body: optional.

• Response body: yes.

• Safe: yes.

• Idempotent: yes.

• Cacheable: no.

Related:

• Net::HTTP#options: sends OPTIONS request, returns response object.

Raised when the query given to a pattern is either invalid Ruby syntax or is using syntax that we don’t yet support.

Represents a specification retrieved via the rubygems.org API.

This is used to avoid loading the full Specification object when all we need is the name, version, and dependencies.

Represents a possible Specification object returned from IndexSet. Used to delay needed to download full Specification objects when only the name and version are needed.

An InstalledSpecification represents a gem that is already installed locally.

A LocalSpecification comes from a .gem file on the local filesystem.

The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).

A LockSpecification’s dependency information is pre-filled from the lockfile.

The Resolver::SpecSpecification contains common functionality for Resolver specifications that are backed by a Gem::Specification.

A Resolver::Specification contains a subset of the information contained in a Gem::Specification. Only the information necessary for dependency resolution in the resolver is included.

A VendorSpecification represents a gem that has been unpacked into a project and is being loaded through a gem dependencies file through the path: option.

Gem::Security default exception type

An object representation of a stack frame, initialized by Kernel#caller_locations.

For example:

# caller_locations.rb
def a(skip)
  caller_locations(skip)
end
def b(skip)
  a(skip)
end
def c(skip)
  b(skip)
end

c(0..2).map do |call|
  puts call.to_s
end

Running ruby caller_locations.rb will produce:

caller_locations.rb:2:in `a'
caller_locations.rb:5:in `b'
caller_locations.rb:8:in `c'

Here’s another example with a slightly different result:

# foo.rb
class Foo
  attr_accessor :locations
  def initialize(skip)
    @locations = caller_locations(skip)
  end
end

Foo.new(0..2).locations.map do |call|
  puts call.to_s
end

Now run ruby foo.rb and you should see:

init.rb:4:in `initialize'
init.rb:8:in `new'
init.rb:8:in `<main>'