class Pry::Code

`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.

Attributes

code_type[RW]

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

Public Class Methods

from_file(filename, code_type = nil) click to toggle source

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]

# File lib/pry/code.rb, line 42
def from_file(filename, code_type = nil)
  code_file = CodeFile.new(filename, code_type)
  new(code_file.code, 1, code_file.code_type)
end
from_method(meth, start_line = nil) click to toggle source

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]

# File lib/pry/code.rb, line 55
def from_method(meth, start_line = nil)
  meth = Pry::Method(meth)
  start_line ||= meth.source_line || 1
  new(meth.source, start_line, meth.source_type)
end
from_module(mod, candidate_rank = 0, start_line = nil) click to toggle source

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]

# File lib/pry/code.rb, line 69
def from_module(mod, candidate_rank = 0, start_line = nil)
  candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
  start_line ||= candidate.line
  new(candidate.source, start_line, :ruby)
end
new(lines = [], start_line = 1, code_type = :ruby) click to toggle source

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

# File lib/pry/code.rb, line 87
def initialize(lines = [], start_line = 1, code_type = :ruby)
  lines = lines.lines if lines.is_a? String
  @lines = lines.each_with_index.map do |line, lineno|
    LOC.new(line, lineno + start_line.to_i)
  end
  @code_type = code_type

  @with_marker = @with_indentation = @with_line_numbers = nil
end

Public Instance Methods

<<(line)
Alias for: push
==(other) click to toggle source

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]

# File lib/pry/code.rb, line 325
def ==(other)
  if other.is_a?(Code)
    other_lines = other.instance_variable_get(:@lines)
    @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
  else
    to_s.chomp == other.to_s.chomp
  end
end
after(lineno, lines = 1) click to toggle source

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

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

# File lib/pry/code.rb, line 195
def after(lineno, lines = 1)
  return self unless lineno

  select do |loc|
    loc.lineno > lineno && loc.lineno <= lineno + lines
  end
end
around(lineno, lines = 1) click to toggle source

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

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

# File lib/pry/code.rb, line 182
def around(lineno, lines = 1)
  return self unless lineno

  select do |loc|
    loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
  end
end
before(lineno, lines = 1) click to toggle source

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

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

# File lib/pry/code.rb, line 168
def before(lineno, lines = 1)
  return self unless lineno

  select do |loc|
    loc.lineno >= lineno - lines && loc.lineno < lineno
  end
end
between(start_line, end_line = nil) click to toggle source

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]

# File lib/pry/code.rb, line 135
def between(start_line, end_line = nil)
  return self unless start_line

  code_range = CodeRange.new(start_line, end_line)

  alter do
    @lines = @lines[code_range.indices_range(@lines)] || []
  end
end
comment_describing(line_number) click to toggle source

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

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

# File lib/pry/code.rb, line 286
def comment_describing(line_number)
  self.class.comment_describing(raw, line_number)
end
expression_at(line_number, consume = 0) click to toggle source

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

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

# File lib/pry/code.rb, line 294
def expression_at(line_number, consume = 0)
  self.class.expression_at(raw, line_number, consume: consume)
end
grep(pattern) click to toggle source

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

@param [Regexp] pattern @return [Code]

# File lib/pry/code.rb, line 207
def grep(pattern)
  return self unless pattern

  pattern = Regexp.new(pattern)

  select do |loc|
    loc.line =~ pattern
  end
end
highlighted() click to toggle source

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

# File lib/pry/code.rb, line 263
def highlighted
  print_to_output(''.dup, true)
end
length() click to toggle source

Return the number of lines stored.

@return [Integer]

# File lib/pry/code.rb, line 316
def length
  @lines ? @lines.length : 0
end
lines() click to toggle source

@todo This is needed for Ruby 1.9 support where `lines` return an

Enumerator. Newer Rubies return an Array
Calls superclass method
# File lib/pry/code.rb, line 352
def lines
  super.to_a
end
max_lineno_width() click to toggle source

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

# File lib/pry/code.rb, line 252
def max_lineno_width
  !@lines.empty? ? @lines.last.lineno.to_s.length : 0
end
method_missing(method_name, *args, &block) click to toggle source

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

Calls superclass method
# File lib/pry/code.rb, line 335
def method_missing(method_name, *args, &block)
  if (string = to_s).respond_to?(method_name)
    string.__send__(method_name, *args, &block)
  else
    super
  end
end
nesting_at(line_number) click to toggle source

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

@param [Integer] line_number line number starting from 1 @return [Array<Module>] a list of open modules.

# File lib/pry/code.rb, line 302
def nesting_at(line_number)
  Pry::Indent.nesting_at(raw, line_number)
end
print_to_output(output, color = false) click to toggle source

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

push(line) click to toggle source

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

@param [String] line @return [void]

# File lib/pry/code.rb, line 102
def push(line)
  line_number = @lines.any? ? @lines.last.lineno + 1 : 1
  @lines.push(LOC.new(line, line_number))
end
Also aliased as: <<
raw() click to toggle source

Return an unformatted String of the code.

@return [String]

# File lib/pry/code.rb, line 309
def raw
  @lines.map(&:line).join("\n") << "\n"
end
reject(&block) click to toggle source

Filter the lines using the given block.

@yield [LOC] @return [Code]

# File lib/pry/code.rb, line 122
def reject(&block)
  alter do
    @lines = @lines.reject(&block)
  end
end
respond_to_missing?(method_name, include_private = false) click to toggle source

Check whether String responds to missing methods.

Calls superclass method
# File lib/pry/code.rb, line 345
def respond_to_missing?(method_name, include_private = false)
  ''.respond_to?(method_name, include_private) || super
end
select(&block) click to toggle source

Filter the lines using the given block.

@yield [LOC] @return [Code]

# File lib/pry/code.rb, line 112
def select(&block)
  alter do
    @lines = @lines.select(&block)
  end
end
take_lines(start_line, num_lines) click to toggle source

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

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

# File lib/pry/code.rb, line 150
def take_lines(start_line, num_lines)
  start_idx =
    if start_line >= 0
      @lines.index { |loc| loc.lineno >= start_line } || @lines.length
    else
      [@lines.length + start_line, 0].max
    end

  alter do
    @lines = @lines.slice(start_idx, num_lines)
  end
end
to_s() click to toggle source

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

the object).
# File lib/pry/code.rb, line 258
def to_s
  print_to_output(''.dup, false)
end
with_indentation(spaces = 0) click to toggle source

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

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

# File lib/pry/code.rb, line 244
def with_indentation(spaces = 0)
  alter do
    @with_indentation = !!spaces
    @indentation_num  = spaces
  end
end
with_line_numbers(y_n = true) click to toggle source

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

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

# File lib/pry/code.rb, line 221
def with_line_numbers(y_n = true)
  alter do
    @with_line_numbers = y_n
  end
end
with_marker(lineno = 1) click to toggle source

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

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

# File lib/pry/code.rb, line 232
def with_marker(lineno = 1)
  alter do
    @with_marker   = !!lineno
    @marker_lineno = lineno
  end
end

Protected Instance Methods

alter(&block) click to toggle source

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

# File lib/pry/code.rb, line 361
def alter(&block)
  dup.tap { |o| o.instance_eval(&block) }
end