Class Pry::Code
In: lib/pry/code/loc.rb
lib/pry/code/code_range.rb
lib/pry/code.rb
Parent: Object

`Pry::Code` is a class that encapsulates lines of source code and their line numbers and formats them for terminal output. It can read from a file or method definition or be instantiated with a `String` or an `Array`.

In general, the formatting methods in `Code` return a new `Code` object which will format the text as specified when `to_s` is called. This allows arbitrary chaining of formatting methods without mutating the original object.

Methods

<<   ==   after   alter   around   before   between   comment_describing   expression_at   from_file   from_method   from_module   grep   highlighted   inspect   length   max_lineno_width   method_missing   nesting_at   new   print_to_output   push   raw   select   take_lines   to_s   with_indentation   with_line_numbers   with_marker  

Included Modules

MethodSource::CodeHelpers

Classes and Modules

Class Pry::Code::CodeRange
Class Pry::Code::LOC

Attributes

code_type  [RW]  @return [Symbol] The type of code stored in this wrapper.

Public Class methods

from_file(filename, code_type = nil)

Instantiate a `Code` object containing code loaded from a file or Pry‘s line buffer.

@param [String] filename The name of a file, or "(pry)". @param [Symbol] code_type The type of code the file contains. @return [Code]

from_method(meth, start_line = nil)

Instantiate a `Code` object containing code extracted from a `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object.

@param [::Method, UnboundMethod, Proc, Pry::Method] meth The method 

  object.

@param [Integer, nil] start_line The line number to start on, or nil to 

  use the method's original line numbers.

@return [Code]

from_module(mod, candidate_rank = 0, start_line=nil)

Attempt to extract the source code for module (or class) `mod`.

@param [Module, Class] mod The module (or class) of interest. @param [Integer] candidate_rank The module candidate (by rank) 

  to use (see `Pry::WrappedModule::Candidate` for more information).

@param [Integer, nil] start_line The line number to start on, or nil to 

  use the method's original line numbers.

@return [Code]

new(lines = [], start_line = 1, code_type = :ruby)

Instantiate a `Code` object containing code from the given `Array`, `String`, or `IO`. The first line will be line 1 unless specified otherwise. If you need non-contiguous line numbers, you can create an empty `Code` object and then use `push` to insert the lines.

@param [Array<String>, String, IO] lines @param [Integer?] start_line @param [Symbol?] code_type

Public Instance methods

<<(line, lineno = nil)

Alias for push

==(other)

Two `Code` objects are equal if they contain the same lines with the same numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.

@param [Code, Object] other @return [Boolean]

after(lineno, lines = 1)

Remove all lines except for the lines after and excluding lineno.

@param [Integer] lineno @param [Integer] lines @return [Code]

around(lineno, lines = 1)

Remove all lines except for the lines on either side of and including lineno.

@param [Integer] lineno @param [Integer] lines @return [Code]

before(lineno, lines = 1)

Remove all lines except for the lines up to and excluding lineno.

@param [Integer] lineno @param [Integer] lines @return [Code]

between(start_line, end_line = nil)

Remove all lines that aren‘t in the given range, expressed either as a `Range` object or a first and last line number (inclusive). Negative indices count from the end of the array of lines.

@param [Range, Integer] start_line @param [Integer?] end_line @return [Code]

comment_describing(line_number)

Get the comment that describes the expression on the given line number.

@param [Integer] line_number (1-based) @return [String] the code.

expression_at(line_number, consume = 0)

Get the multiline expression that starts on the given line number.

@param [Integer] line_number (1-based) @return [String] the code.

grep(pattern)

Remove all lines that don‘t match the given `pattern`.

@param [Regexp] pattern @return [Code]

highlighted()

@return [String] a (possibly highlighted) copy of the source code.

inspect()

@return [String]

length()

Return the number of lines stored.

@return [Integer]

max_lineno_width()

@return [Integer] the number of digits in the last line.

method_missing(name, *args, &block)

Forward any missing methods to the output of `to_s`.

nesting_at(line_number, top_module = Object)

Get the (approximate) Module.nesting at the give line number.

@param [Integer] line_number line number starting from 1 @param [Module] top_module the module in which this code exists @return [Array<Module>] a list of open modules.

print_to_output(output, color=false)

Writes a formatted representation (based on the configuration of the object) to the given output, which must respond to `#<<`.

push(line, lineno = nil)

Append the given line. lineno is one more than the last existing line, unless specified otherwise.

@param [String] line @param [Integer?] lineno @return [String] The inserted line.

raw()

Return an unformatted String of the code.

@return [String]

select(&block)

Filter the lines using the given block.

@yield [LOC] @return [Code]

take_lines(start_line, num_lines)

Take `num_lines` from `start_line`, forward or backwards.

@param [Integer] start_line @param [Integer] num_lines @return [Code]

to_s()

@return [String] a formatted representation (based on the configuration of 

  the object).
with_indentation(spaces = 0)

Format output with the specified number of spaces in front of every line, unless `spaces` is falsy.

@param [Integer?] spaces @return [Code]

with_line_numbers(y_n = true)

Format output with line numbers next to it, unless `y_n` is falsy.

@param [Boolean?] y_n @return [Code]

with_marker(lineno = 1)

Format output with a marker next to the given lineno, unless lineno is falsy.

@param [Integer?] lineno @return [Code]

Protected Instance methods

alter(&block)

An abstraction of the `dup.instance_eval` pattern used throughout this class.

[Validate]