pry 0.12.2 → 0.13.0

data/lib/pry/cli.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
 class Pry
   # Manage the processing of command line options
   class CLI
@@ -33,9 +37,7 @@ class Pry
 
       # Bring in options defined in plugins
       def add_plugin_options
-        Pry.plugins.values.each do |plugin|
-          plugin.load_cli_options
-        end
+        Pry.plugins.values.each(&:load_cli_options)
 
         self
       end
@@ -56,14 +58,22 @@ class Pry
 
       def parse_options(args = ARGV)
         unless options
-          raise NoOptionsError, "No command line options defined! Use Pry::CLI.add_options to add command line options."
+          raise NoOptionsError,
+                "No command line options defined! Use Pry::CLI.add_options to " \
+                "add command line options."
         end
 
-        self.input_args = args
+        @pass_argv = args.index { |cli_arg| %w[- --].include?(cli_arg) }
+        if @pass_argv
+          slop_args = args[0...@pass_argv]
+          self.input_args = args.replace(args[@pass_argv + 1..-1])
+        else
+          self.input_args = slop_args = args
+        end
 
         begin
           opts = Pry::Slop.parse!(
-            args,
+            slop_args,
             help: true,
             multiple_switches: false,
             strict: true,
@@ -72,22 +82,20 @@ class Pry
         rescue Pry::Slop::InvalidOptionError
           # Display help message on unknown switches and exit.
           puts Pry::Slop.new(&options)
-          exit
+          Kernel.exit
         end
 
         Pry.initial_session_setup
         Pry.final_session_setup
 
         # Option processors are optional.
-        if option_processors
-          option_processors.each { |processor| processor.call(opts) }
-        end
+        option_processors.each { |processor| processor.call(opts) } if option_processors
 
         opts
       end
 
       def start(opts)
-        exit if opts.help?
+        Kernel.exit if opts.help?
 
         # invoked via cli
         Pry.cli = true
@@ -95,16 +103,16 @@ class Pry
         # create the actual context
         if opts[:context]
           Pry.initial_session_setup
-          context = Pry.binding_for(eval(opts[:context]))
+          context = Pry.binding_for(eval(opts[:context])) # rubocop:disable Security/Eval
           Pry.final_session_setup
         else
           context = Pry.toplevel_binding
         end
 
-        if Pry::CLI.input_args.any? && Pry::CLI.input_args != ["pry"]
+        if !@pass_argv && Pry::CLI.input_args.any? && Pry::CLI.input_args != ["pry"]
           full_name = File.expand_path(Pry::CLI.input_args.first)
           Pry.load_file_through_repl(full_name)
-          exit
+          Kernel.exit
         end
 
         # Start the session (running any code passed with -e, if there is any)
@@ -123,20 +131,21 @@ Pry::Slop.new do
   end
 end.parse(ARGV.dup)
 
-if Pry.config.should_load_plugins
-  Pry::CLI.add_plugin_options
-end
+Pry::CLI.add_plugin_options if Pry.config.should_load_plugins
 
 # The default Pry command line options (before plugin options are included)
 Pry::CLI.add_options do
   banner(
     "Usage: pry [OPTIONS]\n" \
     "Start a Pry session.\n" \
-    "See http://pryrepl.org/ for more information.\n"
+    "See http://pryrepl.org/ for more information.\n" \
+    "Copyright (c) 2016 John Mair (banisterfiend)" \
   )
 
-  on :e, :exec=, "A line of code to execute in context before the session starts" do |input|
-    Pry.config.exec_string += "\n" if Pry.config.exec_string.length > 0
+  on(
+    :e, :exec=, "A line of code to execute in context before the session starts"
+  ) do |input|
+    Pry.config.exec_string += "\n" unless Pry.config.exec_string.empty?
     Pry.config.exec_string += input
   end
 
@@ -174,32 +183,32 @@ Pry::CLI.add_options do
     puts "Installed Plugins:"
     puts "--"
     Pry.locate_plugins.each do |plugin|
-      puts "#{plugin.name}".ljust(18) << plugin.spec.summary
+      puts plugin.name.to_s.ljust(18) << plugin.spec.summary
     end
-    exit
+    Kernel.exit
   end
 
   on "simple-prompt", "Enable simple prompt mode" do
-    Pry.config.prompt = Pry::Prompt[:simple][:value]
+    Pry.config.prompt = Pry::Prompt[:simple]
   end
 
   on "noprompt", "No prompt mode" do
-    Pry.config.prompt = Pry::Prompt[:none][:value]
+    Pry.config.prompt = Pry::Prompt[:none]
   end
 
   on :r, :require=, "`require` a Ruby script at startup" do |file|
     Pry.config.requires << file
   end
 
-  on :I=, "Add a path to the $LOAD_PATH", as: Array, delimiter: ":" do |load_path|
+  on(:I=, "Add a path to the $LOAD_PATH", as: Array, delimiter: ":") do |load_path|
     load_path.map! do |path|
-      /\A\.\// =~ path ? path : File.expand_path(path)
+      %r{\A\./} =~ path ? path : File.expand_path(path)
     end
 
     $LOAD_PATH.unshift(*load_path)
   end
 
-  on "gem", "Shorthand for -I./lib -rgemname" do |load_path|
+  on "gem", "Shorthand for -I./lib -rgemname" do |_load_path|
     $LOAD_PATH.unshift("./lib")
     Dir["./lib/*.rb"].each do |file|
       Pry.config.requires << file
@@ -208,11 +217,11 @@ Pry::CLI.add_options do
 
   on :v, :version, "Display the Pry version" do
     puts "Pry version #{Pry::VERSION} on Ruby #{RUBY_VERSION}"
-    exit
+    Kernel.exit
   end
 
-  on(:c, :context=,
-     "Start the session in the specified context. Equivalent to `context.pry` in a session.",
+  on :c, :context=,
+     "Start the session in the specified context. Equivalent to " \
+     "`context.pry` in a session.",
      default: "Pry.toplevel_binding"
-     )
 end

data/lib/pry/code.rb

@@ -1,6 +1,6 @@
-require 'pry/code/loc'
-require 'pry/code/code_range'
-require 'pry/code/code_file'
+# frozen_string_literal: true
+
+require 'method_source'
 
 class Pry
   class << self
@@ -85,11 +85,10 @@ class Pry
     # @param [Integer?] start_line
     # @param [Symbol?] code_type
     def initialize(lines = [], start_line = 1, code_type = :ruby)
-      if lines.is_a? String
-        lines = lines.lines
+      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
-      @lines = lines.each_with_index.map { |line, lineno|
-        LOC.new(line, lineno + start_line.to_i) }
       @code_type = code_type
 
       @with_marker = @with_indentation = @with_line_numbers = nil
@@ -99,14 +98,10 @@ class Pry
     # line, unless specified otherwise.
     #
     # @param [String] line
-    # @param [Integer?] lineno
-    # @return [String] The inserted line.
-    def push(line, lineno = nil)
-      if lineno.nil?
-        lineno = @lines.last.lineno + 1
-      end
-      @lines.push(LOC.new(line, lineno))
-      line
+    # @return [void]
+    def push(line)
+      line_number = @lines.any? ? @lines.last.lineno + 1 : 1
+      @lines.push(LOC.new(line, line_number))
     end
     alias << push
 
@@ -120,6 +115,16 @@ class Pry
       end
     end
 
+    # Filter the lines using the given block.
+    #
+    # @yield [LOC]
+    # @return [Code]
+    def reject(&block)
+      alter do
+        @lines = @lines.reject(&block)
+      end
+    end
+
     # 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.
@@ -243,25 +248,20 @@ class Pry
       end
     end
 
-    # @return [String]
-    def inspect
-      Object.instance_method(:to_s).bind(self).call
-    end
-
     # @return [Integer] the number of digits in the last line.
     def max_lineno_width
-      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+      !@lines.empty? ? @lines.last.lineno.to_s.length : 0
     end
 
     # @return [String] a formatted representation (based on the configuration of
     #   the object).
     def to_s
-      print_to_output("", false)
+      print_to_output(''.dup, false)
     end
 
     # @return [String] a (possibly highlighted) copy of the source code.
     def highlighted
-      print_to_output("", true)
+      print_to_output(''.dup, true)
     end
 
     # Writes a formatted representation (based on the configuration of the
@@ -332,14 +332,26 @@ class Pry
     end
 
     # Forward any missing methods to the output of `#to_s`.
-    def method_missing(name, *args, &block)
-      to_s.send(name, *args, &block)
+    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
     undef =~
 
     # Check whether String responds to missing methods.
-    def respond_to_missing?(name, include_all = false)
-      ''.respond_to?(name, include_all)
+    def respond_to_missing?(method_name, include_private = false)
+      ''.respond_to?(method_name, include_private) || super
+    end
+
+    if RUBY_VERSION.start_with?('1.9')
+      # @todo This is needed for Ruby 1.9 support where `lines` return an
+      #   Enumerator. Newer Rubies return an Array
+      def lines
+        super.to_a
+      end
     end
 
     protected

data/lib/pry/code/code_file.rb

@@ -1,29 +1,33 @@
+# frozen_string_literal: true
+
+require 'method_source'
+
 class Pry
   class CodeFile
-    DEFAULT_EXT = '.rb'
+    DEFAULT_EXT = '.rb'.freeze
 
     # List of all supported languages.
     # @return [Hash]
     EXTENSIONS = {
-      %w(.py)        => :python,
-      %w(.js)        => :javascript,
-      %w(.css)       => :css,
-      %w(.xml)       => :xml,
-      %w(.php)       => :php,
-      %w(.html)      => :html,
-      %w(.diff)      => :diff,
-      %w(.java)      => :java,
-      %w(.json)      => :json,
-      %w(.c .h)      => :c,
-      %w(.rhtml)     => :rhtml,
-      %w(.yaml .yml) => :yaml,
-      %w(.cpp .hpp .cc .h .cxx) => :cpp,
-      %w(.rb .ru .irbrc .gemspec .pryrc .rake) => :ruby,
-    }
+      %w[.py] => :python,
+      %w[.js] => :javascript,
+      %w[.css] => :css,
+      %w[.xml] => :xml,
+      %w[.php] => :php,
+      %w[.html] => :html,
+      %w[.diff] => :diff,
+      %w[.java] => :java,
+      %w[.json] => :json,
+      %w[.c .h] => :c,
+      %w[.rhtml] => :rhtml,
+      %w[.yaml .yml] => :yaml,
+      %w[.cpp .hpp .cc .h .cxx] => :cpp,
+      %w[.rb .ru .irbrc .gemspec .pryrc .rake] => :ruby
+    }.freeze
 
     FILES = {
-      %w(Gemfile Rakefile Guardfile Capfile) => :ruby
-    }
+      %w[Gemfile Rakefile Guardfile Capfile] => :ruby
+    }.freeze
 
     # Store the current working directory. This allows show-source etc. to work if
     # your process has changed directory since boot. [Issue #675]
@@ -58,16 +62,16 @@ class Pry
     #   readable for some reason.
     # @return [String] absolute path for the given `filename`.
     def abs_path
-      code_path.detect { |path| readable?(path) } or
-        raise MethodSource::SourceNotFoundError,
-              "Cannot open #{ @filename.inspect } for reading."
+      code_path.detect { |path| readable?(path) } ||
+        raise(MethodSource::SourceNotFoundError,
+              "Cannot open #{@filename.inspect} for reading.")
     end
 
     # @param [String] path
     # @return [Boolean] if the path, with or without the default ext,
     #   is a readable file then `true`, otherwise `false`.
     def readable?(path)
-      File.readable?(path) && !File.directory?(path) or
+      File.readable?(path) && !File.directory?(path) ||
         File.readable?(path << DEFAULT_EXT)
     end
 
@@ -80,8 +84,8 @@ class Pry
     # @param [String] filename
     # @param [Symbol] default (:unknown) the file type to assume if none could be
     #   detected.
-    # @return [Symbol, nil] The CodeRay type of a file from its extension, or
-    #   `nil` if `:unknown`.
+    # @return [Symbol, nil] The SyntaxHighlighter type of a file from its
+    #   extension, or `nil` if `:unknown`.
     def type_from_filename(filename, default = :unknown)
       _, @code_type = EXTENSIONS.find do |k, _|
         k.any? { |ext| ext == File.extname(filename) }

data/lib/pry/code/code_range.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   class Code
     # Represents a range of lines in a code listing.
@@ -20,9 +22,9 @@ class Pry
 
       private
 
-      def start_line; @start_line; end
+      attr_reader :start_line
 
-      def end_line; @end_line; end
+      attr_reader :end_line
 
       # If `end_line` is equal to `nil`, then calculate it from the first
       # parameter, `start_line`. Otherwise, leave it as it is.

data/lib/pry/code/loc.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Pry
   class Code
-    # Represents a line of code (which may, in fact, contain multiple lines if the
-    # entirety was eval'd as a single unit following the `edit` command).
+    # Represents a line of code (which may, in fact, contain multiple lines if
+    # the entirety was eval'd as a single unit following the `edit` command).
     #
     # A line of code is a tuple, which consists of a line and a line number. A
     # `LOC` object's state (namely, the line parameter) can be changed via
@@ -52,7 +54,7 @@ class Pry
       # @param [Symbol] code_type
       # @return [void]
       def colorize(code_type)
-        tuple[0] = CodeRay.scan(line, code_type).term
+        tuple[0] = SyntaxHighlighter.highlight(line, code_type)
       end
 
       # Prepends the line number `lineno` to the `line`.
@@ -61,9 +63,14 @@ class Pry
       # @return [void]
       def add_line_number(max_width = 0, color = false)
         padded = lineno.to_s.rjust(max_width)
-        colorized_lineno = color ? Pry::Helpers::BaseHelpers.colorize_code(padded) : padded
+        colorized_lineno =
+          if color
+            Pry::Helpers::BaseHelpers.colorize_code(padded)
+          else
+            padded
+          end
         properly_padded_line = handle_multiline_entries_from_edit_command(line, max_width)
-        tuple[0] = "#{ colorized_lineno }: #{ properly_padded_line }"
+        tuple[0] = "#{colorized_lineno}: #{properly_padded_line}"
       end
 
       # Prepends a marker "=>" or an empty marker to the +line+.
@@ -74,9 +81,9 @@ class Pry
       def add_marker(marker_lineno)
         tuple[0] =
           if lineno == marker_lineno
-            " => #{ line }"
+            " => #{line}"
           else
-            "    #{ line }"
+            "    #{line}"
           end
       end
 
@@ -85,7 +92,7 @@ class Pry
       # @param [Integer] distance
       # @return [void]
       def indent(distance)
-        tuple[0] = "#{ ' ' * distance }#{ line }"
+        tuple[0] = "#{' ' * distance}#{line}"
       end
 
       def handle_multiline_entries_from_edit_command(line, max_width)

data/lib/pry/code_object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   # This class is responsible for taking a string (identifying a
   # command/class/method/etc) and returning the relevant type of object.
@@ -42,29 +44,30 @@ class Pry
       # @note If a module defined by C was extended with a lot of methods written
       #   in Ruby, this method would fail.
       def c_module?
-        if is_a?(WrappedModule)
+        return unless is_a?(WrappedModule)
 
-          method_locations = wrapped.methods(false).map do |m|
-            wrapped.method(m).source_location
-          end
+        method_locations = wrapped.methods(false).map do |m|
+          wrapped.method(m).source_location
+        end
 
-          method_locations.concat(wrapped.instance_methods(false).map do |m|
-                                    wrapped.instance_method(m).source_location
-                                  end)
+        method_locations.concat(
+          wrapped.instance_methods(false).map do |m|
+            wrapped.instance_method(m).source_location
+          end
+        )
 
-          c_methods = method_locations.grep(nil).count
-          ruby_methods = method_locations.count - c_methods
+        c_methods = method_locations.grep(nil).count
+        ruby_methods = method_locations.count - c_methods
 
-          c_methods > ruby_methods
-        end
+        c_methods > ruby_methods
       end
     end
 
     include Pry::Helpers::CommandHelpers
 
     class << self
-      def lookup(str, _pry_, options = {})
-        co = new(str, _pry_, options)
+      def lookup(str, pry_instance, options = {})
+        co = new(str, pry_instance, options)
 
         co.default_lookup || co.method_or_class_lookup ||
           co.command_lookup || co.empty_lookup
@@ -73,24 +76,25 @@ class Pry
 
     attr_accessor :str
     attr_accessor :target
-    attr_accessor :_pry_
+    attr_accessor :pry_instance
     attr_accessor :super_level
 
-    def initialize(str, _pry_, options = {})
+    def initialize(str, pry_instance, options = {})
       options = {
-        super: 0,
+        super: 0
       }.merge!(options)
 
       @str = str
-      @_pry_ = _pry_
-      @target = _pry_.current_context
+      @pry_instance = pry_instance
+      @target = pry_instance.current_context
       @super_level = options[:super]
     end
 
+    # TODO: just make it so find_command_by_match_or_listing doesn't raise?
     def command_lookup
-      # TODO: just make it so find_command_by_match_or_listing doesn't
-      # raise?
-      _pry_.commands.find_command_by_match_or_listing(str) rescue nil
+      pry_instance.commands.find_command_by_match_or_listing(str)
+    rescue StandardError
+      nil
     end
 
     # when no paramter is given (i.e CodeObject.lookup(nil)), then we
@@ -112,8 +116,8 @@ class Pry
 
     # lookup variables and constants and `self` that are not modules
     def default_lookup
-
-      # we skip instance methods as we want those to fall through to method_or_class_lookup()
+      # we skip instance methods as we want those to fall through to
+      # method_or_class_lookup()
       if safe_to_evaluate?(str) && !looks_like_an_instance_method?(str)
         obj = target.eval(str)
 
@@ -123,22 +127,22 @@ class Pry
           Pry::Method(obj)
         elsif !obj.is_a?(Module)
           Pry::WrappedModule(obj.class)
-        else
-          nil
         end
       end
-
     rescue Pry::RescuableException
       nil
     end
 
     def method_or_class_lookup
-      obj = case str
-            when /\S+\(\)\z/
-              Pry::Method.from_str(str.sub(/\(\)\z/, ''),target) || Pry::WrappedModule.from_str(str, target)
-            else
-              Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
-            end
+      obj =
+        case str
+        when /\S+\(\)\z/
+          Pry::Method.from_str(str.sub(/\(\)\z/, ''), target) ||
+          Pry::WrappedModule.from_str(str, target)
+        else
+          Pry::WrappedModule.from_str(str, target) ||
+          Pry::Method.from_str(str, target)
+        end
 
       lookup_super(obj, super_level)
     end
@@ -182,14 +186,12 @@ class Pry
     # @param [Object] obj
     # @param [Fixnum] super_level How far up the super chain to ascend.
     def lookup_super(obj, super_level)
-      return nil if !obj
+      return unless obj
 
       sup = obj.super(super_level)
-      if !sup
-        raise Pry::CommandError, "No superclass found for #{obj.wrapped}"
-      else
-        sup
-      end
+      raise Pry::CommandError, "No superclass found for #{obj.wrapped}" unless sup
+
+      sup
     end
   end
 end