Results for: "Logger"

Raised when a tar file is corrupt

IO wrapper that creates digests of contents written to the IO it wraps.

A header for a tar file

TarReader reads tar files and allows iteration over their items

Allows writing of tar files

A FetchError exception wraps up the various possible IO and HTTP failures that could happen while downloading from the internet.

A FetchError that indicates that the reason for not being able to fetch data was that the host could not be contacted

A semi-compatible DSL for the Bundler Gemfile and Isolate gem dependencies files.

To work with both the Bundler Gemfile and Isolate formats this implementation takes some liberties to allow compatibility with each, most notably in source.

A basic gem dependencies file will look like the following:

source 'https://rubygems.org'

gem 'rails', '3.2.14a
gem 'devise', '~> 2.1', '>= 2.1.3'
gem 'cancan'
gem 'airbrake'
gem 'pg'

RubyGems recommends saving this as gem.deps.rb over Gemfile or Isolate.

To install the gems in this Gemfile use ‘gem install -g` to install it and create a lockfile. The lockfile will ensure that when you make changes to your gem dependencies file a minimum amount of change is made to the dependencies of your gems.

RubyGems can activate all the gems in your dependencies file at startup using the RUBYGEMS_GEMDEPS environment variable or through Gem.use_gemdeps. See Gem.use_gemdeps for details and warnings.

See ‘gem help install` and `gem help gem_dependencies` for further details.

Parses a gem.deps.rb.lock file and constructs a LockSet containing the dependencies found inside. If the lock file is missing no LockSet is constructed.

Raised when a bad requirement is encountered

A set of gems for installation sourced from remote sources and local .gem files

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

A set of gems from a gem dependencies lockfile.

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

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

The local source finds gems in the current directory for fulfilling dependencies.

A Lock source wraps an installed gem’s source and sorts before other sources during dependency resolution. This allows RubyGems to prefer gems from dependency lock files.

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>'