geminfo 0.1.0 → 0.1.1

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/history_array.rb

@@ -1,121 +0,0 @@
-class Pry
-  # A history array is an array to which you can only add elements. Older
-  # entries are removed progressively, so that the array never contains more than
-  # N elements.
-  #
-  # History arrays are used by Pry to store the output of the last commands.
-  #
-  # @example
-  #   ary = Pry::HistoryArray.new 10
-  #   ary << 1 << 2 << 3
-  #   ary[0] # => 1
-  #   ary[1] # => 2
-  #   10.times { |n| ary << n }
-  #   ary[0] # => nil
-  #   ary[-1] # => 9
-  class HistoryArray
-    include Enumerable
-
-    # @param [Integer] size Maximum amount of objects in the array
-    def initialize(size)
-      @max_size = size
-
-      @hash  = {}
-      @count = 0
-    end
-
-    # Pushes an object at the end of the array
-    # @param [Object] value Object to be added
-    def <<(value)
-      @hash[@count] = value
-
-      if @hash.size > max_size
-        @hash.delete(@count - max_size)
-      end
-
-      @count += 1
-
-      self
-    end
-
-    # @overload [](index)
-    #   @param [Integer] index Index of the item to access.
-    #   @return [Object, nil] Item at that index or nil if it has been removed.
-    # @overload [](index, size)
-    #   @param [Integer] index Index of the first item to access.
-    #   @param [Integer] size Amount of items to access
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    # @overload [](range)
-    #   @param [Range<Integer>] range Range of indices to access.
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    def [](index_or_range, size = nil)
-      if index_or_range.is_a? Integer
-        index = convert_index(index_or_range)
-
-        if size
-          end_index = index + size
-          index > @count ? nil : (index...[end_index, @count].min).map do |n|
-            @hash[n]
-          end
-        else
-          @hash[index]
-        end
-      else
-        range = convert_range(index_or_range)
-        range.begin > @count ? nil : range.map { |n| @hash[n] }
-      end
-    end
-
-    # @return [Integer] Amount of objects in the array
-    def size
-      @count
-    end
-    alias count size
-    alias length size
-
-    def empty?
-      size == 0
-    end
-
-    def each
-      ((@count - size)...@count).each do |n|
-        yield @hash[n]
-      end
-    end
-
-    def to_a
-      ((@count - size)...@count).map { |n| @hash[n] }
-    end
-
-    # Returns [Hash] copy of the internal @hash history
-    def to_h
-      @hash.dup
-    end
-
-    def pop!
-      @hash.delete @count - 1
-      @count -= 1
-    end
-
-    def inspect
-      "#<#{self.class} size=#{size} first=#{@count - size} max_size=#{max_size}>"
-    end
-
-    # @return [Integer] Maximum amount of objects in the array
-    attr_reader :max_size
-
-    private
-    def convert_index(n)
-      n >= 0 ? n : @count + n
-    end
-
-    def convert_range(range)
-      end_index = convert_index(range.end)
-      end_index += 1 unless range.exclude_end?
-
-      Range.new(convert_index(range.begin), [end_index, @count].min, true)
-    end
-  end
-end

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/hooks.rb

@@ -1,230 +0,0 @@
-class Pry
-
-  # Implements a hooks system for Pry. A hook is a callable that is
-  # associated with an event. A number of events are currently
-  # provided by Pry, these include: `:when_started`, `:before_session`, `:after_session`.
-  # A hook must have a name, and is connected with an event by the
-  # `Pry::Hooks#add_hook` method.
-  # @example Adding a hook for the `:before_session` event.
-  #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
-  #     puts "hello"
-  #   end
-  class Hooks
-
-    # Converts a hash to a `Pry::Hooks` instance. All hooks defined
-    # this way are anonymous. This functionality is primarily to
-    # provide backwards-compatibility with the old hash-based hook
-    # system in Pry versions < 0.9.8
-    # @param [Hash] hash The hash to convert to `Pry::Hooks`.
-    # @return [Pry::Hooks] The resulting `Pry::Hooks` instance.
-    def self.from_hash(hash)
-      return hash if hash.instance_of?(self)
-      instance = new
-      hash.each do |k, v|
-        instance.add_hook(k, nil, v)
-      end
-      instance
-    end
-
-    def initialize
-      @hooks = {}
-    end
-
-    # Ensure that duplicates have their @hooks object
-    def initialize_copy(orig)
-      hooks_dup = @hooks.dup
-      @hooks.each do |k, v|
-        hooks_dup[k] = v.dup
-      end
-
-      @hooks = hooks_dup
-    end
-
-    def hooks
-      @hooks
-    end
-    protected :hooks
-
-    def errors
-      @errors ||= []
-    end
-
-    # Destructively merge the contents of two `Pry:Hooks` instances.
-    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
-    # @return [Pry:Hooks] Returns the receiver.
-    # @example
-    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   Pry::Hooks.new.merge!(hooks)
-    def merge!(other)
-      @hooks.merge!(other.dup.hooks) do |key, v1, v2|
-        merge_arrays(v1, v2)
-      end
-
-      self
-    end
-
-    def merge_arrays(array1, array2)
-      uniq_keeping_last(array1 + array2, &:first)
-    end
-    private :merge_arrays
-
-    def uniq_keeping_last(input, &block)
-      hash, output = {}, []
-      input.reverse.each{ |i| hash[block[i]] ||= (output.unshift i) }
-      output
-    end
-    private :uniq_keeping_last
-
-    # Return a new `Pry::Hooks` instance containing a merge of the contents of two `Pry:Hooks` instances,
-    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
-    # @return [Pry::Hooks] The new hash.
-    # @example
-    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   Pry::Hooks.new.merge(hooks)
-    def merge(other)
-      self.dup.tap do |v|
-        v.merge!(other)
-      end
-    end
-
-    # Add a new hook to be executed for the `name` even.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook.
-    # @param [#call] callable The callable.
-    # @yield The block to use as the callable (if `callable` parameter not provided)
-    # @return [Pry:Hooks] Returns the receiver.
-    # @example
-    #   Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    def add_hook(event_name, hook_name, callable=nil, &block)
-      @hooks[event_name] ||= []
-
-      # do not allow duplicates, but allow multiple `nil` hooks
-      # (anonymous hooks)
-      if hook_exists?(event_name, hook_name) && !hook_name.nil?
-        raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
-      end
-
-      if !block && !callable
-        raise ArgumentError, "Must provide a block or callable."
-      end
-
-      # ensure we only have one anonymous hook
-      @hooks[event_name].delete_if { |h, k| h.nil? } if hook_name.nil?
-
-      if block
-        @hooks[event_name] << [hook_name, block]
-      elsif callable
-        @hooks[event_name] << [hook_name, callable]
-      end
-
-      self
-    end
-
-    # Execute the list of hooks for the `event_name` event.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Array] args The arguments to pass to each hook function.
-    # @return [Object] The return value of the last executed hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.exec_hook(:before_session) #=> OUTPUT: "hi!"
-    def exec_hook(event_name, *args, &block)
-      @hooks[event_name] ||= []
-
-      @hooks[event_name].map do |hook_name, callable|
-        begin
-          callable.call(*args, &block)
-        rescue RescuableException => e
-          errors << e
-          e
-        end
-      end.last
-    end
-
-    # Return the number of hook functions registered for the `event_name` event.
-    # @param [Symbol] event_name The name of the event.
-    # @return [Fixnum] The number of hook functions for `event_name`.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.count(:before_session) #=> 1
-    def hook_count(event_name)
-      @hooks[event_name] ||= []
-      @hooks[event_name].size
-    end
-
-    # Return a specific hook for a given event.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook
-    # @return [#call] The requested hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.get_hook(:before_session, :say_hi).call #=> "hi!"
-    def get_hook(event_name, hook_name)
-      @hooks[event_name] ||= []
-      hook = @hooks[event_name].find { |current_hook_name, callable| current_hook_name == hook_name }
-      hook.last if hook
-    end
-
-    # Return the hash of hook names / hook functions for a
-    # given event. (Note that modifying the returned hash does not
-    # alter the hooks, use add_hook/delete_hook for that).
-    # @param [Symbol] event_name The name of the event.
-    # @return [Hash] The hash of hook names / hook functions.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.get_hooks(:before_session) #=> {:say_hi=>#<Proc:0x00000101645e18@(pry):9>}
-    def get_hooks(event_name)
-      @hooks[event_name] ||= []
-      Hash[@hooks[event_name]]
-    end
-
-    # Delete a hook for an event.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook.
-    #   to delete.
-    # @return [#call] The deleted hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.delete_hook(:before_session, :say_hi)
-    def delete_hook(event_name, hook_name)
-      @hooks[event_name] ||= []
-      deleted_callable = nil
-
-      @hooks[event_name].delete_if do |current_hook_name, callable|
-        if current_hook_name == hook_name
-          deleted_callable = callable
-          true
-        else
-          false
-        end
-      end
-      deleted_callable
-    end
-
-    # Clear all hooks functions for a given event.
-    # @param [String] event_name The name of the event.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.delete_hook(:before_session)
-    def delete_hooks(event_name)
-      @hooks[event_name] = []
-    end
-
-    alias_method :clear, :delete_hooks
-
-    # Remove all events and hooks, clearing out the Pry::Hooks
-    # instance completely.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.clear_all
-    def clear_all
-      @hooks = {}
-    end
-
-    # @param [Symbol] event_name Name of the event.
-    # @param [Symbol] hook_name Name of the hook.
-    # @return [Boolean] Whether the hook by the name `hook_name`
-    def hook_exists?(event_name, hook_name)
-      !!(@hooks[event_name] && @hooks[event_name].find { |name, _| name == hook_name })
-    end
-  end
-end

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/indent.rb

@@ -1,406 +0,0 @@
-require 'coderay'
-
-class Pry
-  ##
-  # Pry::Indent is a class that can be used to indent a number of lines
-  # containing Ruby code similar as to how IRB does it (but better). The class
-  # works by tokenizing a string using CodeRay and then looping over those
-  # tokens. Based on the tokens in a line of code that line (or the next one)
-  # will be indented or un-indented by correctly.
-  #
-  class Indent
-    include Helpers::BaseHelpers
-
-    # Raised if {#module_nesting} would not work.
-    class UnparseableNestingError < StandardError; end
-
-    # @return [String] String containing the spaces to be inserted before the next line.
-    attr_reader :indent_level
-
-    # @return [Array<String>] The stack of open tokens.
-    attr_reader :stack
-
-    # The amount of spaces to insert for each indent level.
-    SPACES = '  '
-
-    # Hash containing all the tokens that should increase the indentation
-    # level. The keys of this hash are open tokens, the values the matching
-    # tokens that should prevent a line from being indented if they appear on
-    # the same line.
-    OPEN_TOKENS = {
-      'def'    => 'end',
-      'class'  => 'end',
-      'module' => 'end',
-      'do'     => 'end',
-      'if'     => 'end',
-      'unless' => 'end',
-      'while'  => 'end',
-      'until'  => 'end',
-      'for'    => 'end',
-      'case'   => 'end',
-      'begin'  => 'end',
-      '['      => ']',
-      '{'      => '}',
-      '('      => ')'
-    }
-
-    # Which tokens can either be open tokens, or appear as modifiers on
-    # a single-line.
-    SINGLELINE_TOKENS = %w(if while until unless rescue)
-
-    # Which tokens can be followed by an optional "do" keyword.
-    OPTIONAL_DO_TOKENS = %w(for while until)
-
-    # Collection of token types that should be ignored. Without this list
-    # keywords such as "class" inside strings would cause the code to be
-    # indented incorrectly.
-    #
-    # :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0
-    # classifications of "true", "false", and "nil".
-    IGNORE_TOKENS = [:space, :content, :string, :method, :ident,
-                     :constant, :pre_constant, :predefined_constant]
-
-    # Tokens that indicate the end of a statement (i.e. that, if they appear
-    # directly before an "if" indicates that that if applies to the same line,
-    # not the next line)
-    #
-    # :reserved and :keywords are the CodeRay 0.9.8 and 1.0.0 respectively
-    # classifications of "super", "next", "return", etc.
-    STATEMENT_END_TOKENS = IGNORE_TOKENS + [:regexp, :integer, :float, :keyword,
-                                            :delimiter, :reserved]
-
-    # Collection of tokens that should appear dedented even though they
-    # don't affect the surrounding code.
-    MIDWAY_TOKENS = %w(when else elsif ensure rescue)
-
-    # Clean the indentation of a fragment of ruby.
-    #
-    # @param [String] str
-    # @return [String]
-    def self.indent(str)
-      new.indent(str)
-    end
-
-    # Get the module nesting at the given point in the given string.
-    #
-    # NOTE If the line specified contains a method definition, then the nesting
-    # at the start of the method definition is used. Otherwise the nesting from
-    # the end of the line is used.
-    #
-    # @param [String] str The ruby code to analyze
-    # @param [Fixnum] line_number The line number (starting from 1)
-    # @return [Array<String>]
-    def self.nesting_at(str, line_number)
-      indent = new
-      lines = str.split("\n")
-      n = line_number - 1
-      to_indent = lines[0...n] << (lines[n] || "").split("def").first(1)
-      indent.indent(to_indent.join("\n") << "\n")
-      indent.module_nesting
-    end
-
-    def initialize
-      reset
-    end
-
-    # reset internal state
-    def reset
-      @stack = []
-      @indent_level = ''
-      @heredoc_queue = []
-      @close_heredocs = {}
-      @string_start = nil
-      @awaiting_class = false
-      @module_nesting = []
-      self
-    end
-
-    # Indents a string and returns it. This string can either be a single line
-    # or multiple ones.
-    #
-    # @example
-    #  str = <<TXT
-    #  class User
-    #  attr_accessor :name
-    #  end
-    #  TXT
-    #
-    #  # This would result in the following being displayed:
-    #  #
-    #  # class User
-    #  #   attr_accessor :name
-    #  # end
-    #  #
-    #  puts Pry::Indent.new.indent(str)
-    #
-    # @param  [String] input The input string to indent.
-    # @return [String] The indented version of +input+.
-    #
-    def indent(input)
-      output = ''
-      prefix = indent_level
-
-      input.lines.each do |line|
-
-        if in_string?
-          tokens = tokenize("#{open_delimiters_line}\n#{line}")
-          tokens = tokens.drop_while{ |token, type| !(String === token && token.include?("\n")) }
-          previously_in_string = true
-        else
-          tokens = tokenize(line)
-          previously_in_string = false
-        end
-
-        before, after = indentation_delta(tokens)
-
-        before.times{ prefix.sub! SPACES, '' }
-        new_prefix = prefix + SPACES * after
-
-        line = prefix + line.lstrip unless previously_in_string
-
-        output += line
-
-        prefix = new_prefix
-      end
-
-      @indent_level = prefix
-
-      return output
-    end
-
-    # Get the indentation for the start of the next line.
-    #
-    # This is what's used between the prompt and the cursor in pry.
-    #
-    # @return String  The correct number of spaces
-    #
-    def current_prefix
-      in_string? ? '' : indent_level
-    end
-
-    # Get the change in indentation indicated by the line.
-    #
-    # By convention, you remove indent from the line containing end tokens,
-    # but add indent to the line *after* that which contains the start tokens.
-    #
-    # This method returns a pair, where the first number is the number of closings
-    # on this line (i.e. the number of indents to remove before the line) and the
-    # second is the number of openings (i.e. the number of indents to add after
-    # this line)
-    #
-    # @param  [Array] tokens A list of tokens to scan.
-    # @return [Array[Integer]]
-    #
-    def indentation_delta(tokens)
-
-      # We need to keep track of whether we've seen a "for" on this line because
-      # if the line ends with "do" then that "do" should be discounted (i.e. we're
-      # only opening one level not two) To do this robustly we want to keep track
-      # of the indent level at which we saw the for, so we can differentiate
-      # between "for x in [1,2,3] do" and "for x in ([1,2,3].map do" properly
-      seen_for_at = []
-
-      # When deciding whether an "if" token is the start of a multiline statement,
-      # or just the middle of a single-line if statement, we just look at the
-      # preceding token, which is tracked here.
-      last_token, last_kind = [nil, nil]
-
-      # delta keeps track of the total difference from the start of each line after
-      # the given token, 0 is just the level at which the current line started for
-      # reference.
-      remove_before, add_after = [0, 0]
-
-      # If the list of tokens contains a matching closing token the line should
-      # not be indented (and thus we should return true).
-      tokens.each do |token, kind|
-        is_singleline_if  = (SINGLELINE_TOKENS.include?(token)) && end_of_statement?(last_token, last_kind)
-        is_optional_do = (token == "do" && seen_for_at.include?(add_after - 1))
-
-        last_token, last_kind = token, kind unless kind == :space
-        next if IGNORE_TOKENS.include?(kind)
-
-        track_module_nesting(token, kind)
-
-        seen_for_at << add_after if OPTIONAL_DO_TOKENS.include?(token)
-
-        if kind == :delimiter
-          track_delimiter(token)
-        elsif OPEN_TOKENS.keys.include?(token) && !is_optional_do && !is_singleline_if
-          @stack << token
-          add_after += 1
-        elsif token == OPEN_TOKENS[@stack.last]
-          popped = @stack.pop
-          track_module_nesting_end(popped)
-          if add_after == 0
-            remove_before += 1
-          else
-            add_after -= 1
-          end
-        elsif MIDWAY_TOKENS.include?(token)
-          if add_after == 0
-            remove_before += 1
-            add_after += 1
-          end
-        end
-      end
-
-      return [remove_before, add_after]
-    end
-
-    # If the code just before an "if" or "while" token on a line looks like the end of a statement,
-    # then we want to treat that "if" as a singleline, not multiline statement.
-    def end_of_statement?(last_token, last_kind)
-      (last_token =~ /^[)\]}\/]$/ || STATEMENT_END_TOKENS.include?(last_kind))
-    end
-
-    # Are we currently in the middle of a string literal.
-    #
-    # This is used to determine whether to re-indent a given line, we mustn't re-indent
-    # within string literals because to do so would actually change the value of the
-    # String!
-    #
-    # @return Boolean
-    def in_string?
-      !open_delimiters.empty?
-    end
-
-    # Given a string of Ruby code, use CodeRay to export the tokens.
-    #
-    # @param [String] string The Ruby to lex
-    # @return [Array] An Array of pairs of [token_value, token_type]
-    def tokenize(string)
-      tokens = CodeRay.scan(string, :ruby)
-      tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens) # Coderay 1.0.0
-      tokens.to_a
-    end
-
-    # Update the internal state about what kind of strings are open.
-    #
-    # Most of the complication here comes from the fact that HEREDOCs can be nested. For
-    # normal strings (which can't be nested) we assume that CodeRay correctly pairs
-    # open-and-close delimiters so we don't bother checking what they are.
-    #
-    # @param [String] token The token (of type :delimiter)
-    def track_delimiter(token)
-      case token
-      when /^<<-(["'`]?)(.*)\\1/
-        @heredoc_queue << token
-        @close_heredocs[token] = /^\s*$2/
-      when @close_heredocs[@heredoc_queue.first]
-        @heredoc_queue.shift
-      else
-        if @string_start
-          @string_start = nil
-        else
-          @string_start = token
-        end
-      end
-    end
-
-    # All the open delimiters, in the order that they first appeared.
-    #
-    # @return [String]
-    def open_delimiters
-      @heredoc_queue + [@string_start].compact
-    end
-
-    # Return a string which restores the CodeRay string status to the correct value by
-    # opening HEREDOCs and strings.
-    #
-    # @return String
-    def open_delimiters_line
-      "puts #{open_delimiters.join(", ")}"
-    end
-
-    # Update the internal state relating to module nesting.
-    #
-    # It's responsible for adding to the @module_nesting array, which looks
-    # something like:
-    #
-    # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ]
-    #
-    # A nil value in the @module_nesting array happens in two places: either
-    # when @awaiting_class is true and we're still waiting for the string to
-    # fill that space, or when a parse was rejected.
-    #
-    # At the moment this function is quite restricted about what formats it will
-    # parse, for example we disallow expressions after the class keyword. This
-    # could maybe be improved in the future.
-    #
-    # @param [String] token  a token from Coderay
-    # @param [Symbol] kind  the kind of that token
-    def track_module_nesting(token, kind)
-      if kind == :keyword && (token == "class" || token == "module")
-        @module_nesting << [token, nil]
-        @awaiting_class = true
-      elsif @awaiting_class
-        if kind == :operator && token == "<<" && @module_nesting.last[0] == "class"
-          @module_nesting.last[0] = "class <<"
-          @awaiting_class = true
-        elsif kind == :class && token =~ /\A(self|[A-Z:][A-Za-z0-9_:]*)\z/
-          @module_nesting.last[1] = token if kind == :class
-          @awaiting_class = false
-        else
-          # leave @module_nesting[-1]
-          @awaiting_class = false
-        end
-      end
-    end
-
-    # Update the internal state relating to module nesting on 'end'.
-    #
-    # If the current 'end' pairs up with a class or a module then we should
-    # pop an array off of @module_nesting
-    #
-    # @param [String] token  a token from Coderay
-    # @param [Symbol] kind  the kind of that token
-    def track_module_nesting_end(token, kind=:keyword)
-      if kind == :keyword && (token == "class" || token == "module")
-        @module_nesting.pop
-      end
-    end
-
-    # Return a list of strings which can be used to re-construct the Module.nesting at
-    # the current point in the file.
-    #
-    # Returns nil if the syntax of the file was not recognizable.
-    #
-    # @return [Array<String>]
-    def module_nesting
-      @module_nesting.map do |(kind, token)|
-        raise UnparseableNestingError, @module_nesting.inspect if token.nil?
-
-        "#{kind} #{token}"
-      end
-    end
-
-    # Return a string which, when printed, will rewrite the previous line with
-    # the correct indentation. Mostly useful for fixing 'end'.
-    #
-    # @param [String] prompt The user's prompt
-    # @param [String] code   The code the user just typed in.
-    # @param [Fixnum] overhang (0) The number of chars to erase afterwards (i.e.,
-    #   the difference in length between the old line and the new one).
-    # @return [String]
-    def correct_indentation(prompt, code, overhang=0)
-      prompt = prompt.delete("\001\002")
-      line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
-      whitespace = ' ' * overhang
-
-      _, cols = Terminal.screen_size
-
-      cols = cols.to_i
-      lines = (cols != 0 ? (line_to_measure.length / cols + 1) : 1).to_i
-
-      if Pry::Helpers::BaseHelpers.windows_ansi?
-        move_up   = "\e[#{lines}F"
-        move_down = "\e[#{lines}E"
-      else
-        move_up   = "\e[#{lines}A\e[0G"
-        move_down = "\e[#{lines}B\e[0G"
-      end
-
-      "#{move_up}#{prompt}#{colorize_code(code)}#{whitespace}#{move_down}"
-    end
-  end
-end