pry 0.9.12.2 → 0.14.2

data/lib/pry/helpers/base_helpers.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-
     module BaseHelpers
-
-      module_function
+      extend self
 
       def silence_warnings
         old_verbose = $VERBOSE
@@ -20,181 +20,52 @@ class Pry
       # This is required to introspect methods on objects like Net::HTTP::Get that
       # have overridden the `method` method.
       def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+        (obj.is_a?(Module) ? Module : Object).instance_method(method)
+          .bind(obj).call(*args, &block)
       end
-      public :safe_send
 
       def find_command(name, set = Pry::Commands)
         command_match = set.find do |_, command|
-          (listing = command.options[:listing]) == name && listing != nil
+          (listing = command.options[:listing]) == name && !listing.nil?
         end
         command_match.last if command_match
       end
 
       def not_a_real_file?(file)
-        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
-      end
-
-      def command_dependencies_met?(options)
-        return true if !options[:requires_gem]
-        Array(options[:requires_gem]).all? do |g|
-          Rubygem.installed?(g)
-        end
-      end
-
-      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
-
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
+        file =~ /^(\(.*\))$|^<.*>$/ || file =~ /__unknown__/ || file == "" || file == "-e"
       end
 
       def use_ansi_codes?
-        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+        Pry::Helpers::Platform.windows_ansi? ||
+          ((term = Pry::Env['TERM']) && term != "dumb")
       end
 
       def colorize_code(code)
-        if Pry.color
-          CodeRay.scan(code, :ruby).term
-        else
-          code
-        end
+        SyntaxHighlighter.highlight(code)
       end
 
-      def highlight(string, regexp, highlight_color=:bright_yellow)
-        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
+      def highlight(string, regexp, highlight_color = :bright_yellow)
+        string.gsub(regexp) do |match|
+          "<#{highlight_color}>#{match}</#{highlight_color}>"
+        end
       end
 
       # formatting
       def heading(text)
         text = "#{text}\n--"
-        Pry.color ? "\e[1m#{text}\e[0m": text
-      end
-
-      # have fun on the Windows platform.
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      end
-
-      # are we able to use ansi on windows?
-      def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON']
-      end
-
-      def jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-
-      def jruby_19?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby' &&
-          RbConfig::CONFIG['ruby_version'] == '1.9'
-      end
-
-      def rbx?
-        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
-      end
-
-      def mri_18?
-        RUBY_VERSION =~ /1.8/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+        "\e[1m#{text}\e[0m"
       end
 
-      def mri_19?
-        RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      # Try to use `less` for paging, if it fails then use
-      # simple_pager. Also do not page if Pry.pager is falsey
-      def stagger_output(text, out = nil)
-        out ||= case
-                when respond_to?(:output)
-                  # Mixin.
-                  output
-                when Pry.respond_to?(:output)
-                  # Parent.
-                  Pry.output
-                else
-                  # Sys.
-                  $stdout
-                end
-
-        if text.lines.count < Pry::Pager.page_size || !Pry.pager
-          out.puts text
+      # Send the given text through the best available pager (if Pry.config.pager is
+      # enabled). Infers where to send the output if used as a mixin.
+      # DEPRECATED.
+      def stagger_output(text, _out = nil)
+        if defined?(pry_instance) && pry_instance
+          pry_instance.pager.page text
         else
-          Pry::Pager.page(text)
+          Pry.new.pager.page text
         end
-      rescue Errno::ENOENT
-        Pry::Pager.page(text, :simple)
-      rescue Errno::EPIPE
       end
-
-      # @param [String] arg_string The object path expressed as a string.
-      # @param [Pry] _pry_ The relevant Pry instance.
-      # @param [Array<Binding>] old_stack The state of the old binding stack
-      # @return [Array<Array<Binding>, Array<Binding>>] An array
-      #   containing two elements: The new `binding_stack` and the old `binding_stack`.
-      def context_from_object_path(arg_string, _pry_=nil, old_stack=[])
-
-        # Extract command arguments. Delete blank arguments like " ", but
-        # don't delete empty strings like "".
-        path      = arg_string.split(/\//).delete_if { |a| a =~ /\A\s+\z/ }
-        stack     = _pry_.binding_stack.dup
-        state_old_stack = old_stack
-
-        # Special case when we only get a single "/", return to root.
-        if path.empty?
-          state_old_stack = stack.dup unless old_stack.empty?
-          stack = [stack.first]
-        end
-
-        path.each_with_index do |context, i|
-          begin
-            case context.chomp
-            when ""
-              state_old_stack = stack.dup
-              stack = [stack.first]
-            when "::"
-              state_old_stack = stack.dup
-              stack.push(TOPLEVEL_BINDING)
-            when "."
-              next
-            when ".."
-              unless stack.size == 1
-                # Don't rewrite old_stack if we're in complex expression
-                # (e.g.: `cd 1/2/3/../4).
-                state_old_stack = stack.dup if path.first == ".."
-                stack.pop
-              end
-            when "-"
-              unless old_stack.empty?
-                # Interchange current stack and old stack with each other.
-                stack, state_old_stack = state_old_stack, stack
-              end
-            else
-              state_old_stack = stack.dup if i == 0
-              stack.push(Pry.binding_for(stack.last.eval(context)))
-            end
-
-          rescue RescuableException => e
-            # Restore old stack to its initial values.
-            state_old_stack = old_stack
-
-            msg = [
-              "Bad object path: #{arg_string}.",
-              "Failed trying to resolve: #{context}.",
-              e.inspect
-            ].join(' ')
-
-            CommandError.new(msg).tap do |err|
-              err.set_backtrace e.backtrace
-              raise err
-            end
-          end
-        end
-        return stack, state_old_stack
-      end
-
     end
   end
 end

data/lib/pry/helpers/command_helpers.rb

@@ -1,98 +1,84 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
 class Pry
   module Helpers
-
     module CommandHelpers
       include OptionsHelpers
 
-      module_function
+      extend self
 
       # Open a temp file and yield it to the block, closing it after
       # @return [String] The path of the temp file
-      def temp_file(ext='.rb')
+      def temp_file(ext = '.rb')
         file = Tempfile.new(['pry', ext])
-        yield file
+        yield(file)
       ensure
-        file.close(true) if file
-      end
-
-      def render_output(str, opts={})
-        if opts[:flood]
-          output.puts str
-        else
-          stagger_output str
-        end
+        file.close(true)
       end
 
-      def internal_binding?(target)
-        m = target.eval("::Kernel.__method__").to_s
+      def internal_binding?(context)
+        method_name = context.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        ["__binding__", "__pry__", "class_eval"].include?(m)
+        %w[__binding__ __pry__ class_eval].include?(method_name)
+        # TODO: codehaus is dead, there was no test for this and the
+        # description for the commit doesn't exist. Probably a candidate for
+        # removal so we have a chance to introduce a regression and document it
+        # properly.
       end
 
-      def get_method_or_raise(name, target, opts={}, omit_help=false)
-        meth = Pry::Method.from_str(name, target, opts)
-
-        if name && !meth
-          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
+      def get_method_or_raise(method_name, context, opts = {})
+        method = Pry::Method.from_str(method_name, context, opts)
+        if !method && method_name
+          raise Pry::MethodNotFound, "method '#{method_name}' could not be found."
         end
 
         (opts[:super] || 0).times do
-          if meth.super
-            meth = meth.super
+          if method.super
+            method = method.super
           else
-            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
+            raise Pry::MethodNotFound,
+                  "'#{method.name_with_owner}' has no super method"
           end
         end
 
-        if !meth || (!name && internal_binding?(target))
-          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
+        if !method || (!method_name && internal_binding?(context))
+          raise Pry::MethodNotFound,
+                'no method name given, and context is not a method'
         end
 
-        set_file_and_dir_locals(meth.source_file)
-        meth
-      end
-
-      def command_error(message, omit_help, klass=CommandError)
-        message += " Type `#{command_name} --help` for help." unless omit_help
-        raise klass, message
+        set_file_and_dir_locals(method.source_file)
+        method
       end
 
-      # Remove any common leading whitespace from every line in `text`.
-      #
-      # This can be used to make a HEREDOC line up with the left margin, without
+      # Remove any common leading whitespace from every line in `text`. This
+      # can be used to make a HEREDOC line up with the left margin, without
       # sacrificing the indentation level of the source code.
       #
-      # e.g.
-      #   opt.banner unindent <<-USAGE
+      # @example
+      #   opt.banner(unindent(<<-USAGE))
       #     Lorem ipsum dolor sit amet, consectetur adipisicing elit,
       #     sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
       #       "Ut enim ad minim veniam."
       #   USAGE
       #
-      # Heavily based on textwrap.dedent from Python, which is:
-      #   Copyright (C) 1999-2001 Gregory P. Ward.
-      #   Copyright (C) 2002, 2003 Python Software Foundation.
-      #   Written by Greg Ward <gward@python.net>
-      #
-      #   Licensed under <http://docs.python.org/license.html>
-      #   From <http://hg.python.org/cpython/file/6b9f0a6efaeb/Lib/textwrap.py>
-      #
-      # @param [String] text The text from which to remove indentation
-      # @return [String] The text with indentation stripped.
-      def unindent(text, left_padding = 0)
-        # Empty blank lines
-        text = text.sub(/^[ \t]+$/, '')
-
-        # Find the longest common whitespace to all indented lines
-        # Ignore lines containing just -- or ++ as these seem to be used by
-        # comment authors as delimeters.
-        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
+      # @param [String] dirty_text The text from which to remove indentation
+      # @return [String] the text with indentation stripped
+      def unindent(dirty_text, left_padding = 0)
+        text = dirty_text.sub(/\A[ \t]+\z/, '') # Empty blank lines.
+
+        # Find the longest common whitespace to all indented lines. Ignore lines
+        # containing just -- or ++ as these seem to be used by comment authors
+        # as delimeters.
+        scanned_text = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/)
+        margin = scanned_text.inject do |current_margin, next_indent|
           if next_indent.start_with?(current_margin)
             current_margin
           elsif current_margin.start_with?(next_indent)
             next_indent
           else
-            ""
+            ''
           end
         end
 
@@ -101,7 +87,7 @@ class Pry
 
       # Restrict a string to the given range of lines (1-indexed)
       # @param [String] content The string.
-      # @param [Range, Fixnum] lines The line(s) to restrict it to.
+      # @param [Range, Integer] lines The line(s) to restrict it to.
       # @return [String] The resulting string.
       def restrict_to_lines(content, lines)
         line_range = one_index_range_or_number(lines)
@@ -109,11 +95,7 @@ class Pry
       end
 
       def one_index_number(line_number)
-        if line_number > 0
-          line_number - 1
-        else
-          line_number
-        end
+        line_number > 0 ? line_number - 1 : line_number
       end
 
       # convert a 1-index range to a 0-indexed one
@@ -149,6 +131,16 @@ class Pry
 
         Range.new(a, b)
       end
+
+      def set_file_and_dir_locals(file_name, pry = pry_instance, ctx = target)
+        return if !ctx || !file_name
+
+        pry.last_file = File.expand_path(file_name)
+        pry.inject_local("_file_", pry.last_file, ctx)
+
+        pry.last_dir = File.dirname(pry.last_file)
+        pry.inject_local("_dir_", pry.last_dir, ctx)
+      end
     end
   end
 end

data/lib/pry/helpers/documentation_helpers.rb

@@ -1,21 +1,30 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-
     # This class contains methods useful for extracting
     # documentation from methods and classes.
     module DocumentationHelpers
+      YARD_TAGS = %w[
+        param return option yield attr attr_reader attr_writer deprecate example
+        raise
+      ].freeze
 
       module_function
 
       def process_rdoc(comment)
-        return comment unless Pry.color
         comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
-          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
-          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
-          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
+        last_match_ruby = proc do
+          SyntaxHighlighter.highlight(Regexp.last_match(1))
+        end
+
+        comment.gsub(%r{<code>(?:\s*\n)?(.*?)\s*</code>}m, &last_match_ruby)
+          .gsub(%r{<em>(?:\s*\n)?(.*?)\s*</em>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(%r{<i>(?:\s*\n)?(.*?)\s*</i>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(%r{<tt>(?:\s*\n)?(.*?)\s*</tt>}m, &last_match_ruby)
+          .gsub(/\B\+(\w+?)\+\B/) { "\e[32m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(/((?:^[ \t]+(?:(?!.+\e\[)).+(?:\n+|\Z))+)/, &last_match_ruby)
+          .gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{last_match_ruby.call}`" }
       end
 
       def process_yardoc_tag(comment, tag)
@@ -34,10 +43,9 @@ class Pry
       end
 
       def process_yardoc(comment)
-        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
-                     "deprecate", "example", "raise"]
-        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
+        (YARD_TAGS - %w[example])
+          .inject(comment) { |a, v| process_yardoc_tag(a, v) }
+          .gsub(/^@(#{YARD_TAGS.join("|")})/) { "\e[33m#{Regexp.last_match(1)}\e[0m" }
       end
 
       def process_comment_markup(comment)
@@ -47,7 +55,7 @@ class Pry
       # @param [String] code
       # @return [String]
       def strip_comments_from_c_code(code)
-        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+        code.sub(%r{\A\s*/\*.*?\*/\s*}m, '')
       end
 
       # Given a string that makes up a comment in a source-code file parse out the content

data/lib/pry/helpers/options_helpers.rb

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
     module OptionsHelpers
       module_function
 
-      # Add method options to the Slop instance
+      # Add method options to the Pry::Slop instance
       def method_options(opt)
         @method_target = target
         opt.on :M, "instance-methods", "Operate on instance methods."
         opt.on :m, :methods, "Operate on methods."
-        opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors.", :as => :count
-        opt.on :c, :context, "Select object context to run under.", :argument => true do |context|
+        opt.on :s, :super, "Select the 'super' method. Can be repeated to " \
+                           "traverse the ancestors.", as: :count
+        opt.on(
+          :c, :context, "Select object context to run under.", argument: true
+        ) do |context|
           @method_target = Pry.binding_for(target.eval(context))
         end
       end
 
       # Get the method object parsed by the slop instance
       def method_object
-        @method_object ||= get_method_or_raise(args.empty? ? nil : args.join(" "), @method_target,
-                            :super => opts[:super],
-                            :instance => opts.present?(:'instance-methods') && !opts.present?(:'methods'),
-                            :methods  => opts.present?(:'methods') && !opts.present?(:'instance-methods')
-                           )
+        @method_object ||= get_method_or_raise(
+          args.empty? ? nil : args.join(" "),
+          @method_target,
+          super: opts[:super],
+          instance: opts.present?(:'instance-methods') && !opts.present?(:methods),
+          methods: opts.present?(:methods) && !opts.present?(:'instance-methods')
+        )
       end
     end
   end

data/lib/pry/helpers/platform.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class Pry
+  module Helpers
+    # Contains methods for querying the platform that Pry is running on
+    # @api public
+    # @since v0.12.0
+    module Platform
+      # @return [Boolean]
+      def self.mac_osx?
+        !!(RbConfig::CONFIG['host_os'] =~ /\Adarwin/i)
+      end
+
+      # @return [Boolean]
+      def self.linux?
+        !!(RbConfig::CONFIG['host_os'] =~ /linux/i)
+      end
+
+      # @return [Boolean] true when Pry is running on Windows with ANSI support,
+      #   false otherwise
+      def self.windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/)
+      end
+
+      # @return [Boolean]
+      def self.windows_ansi?
+        return false unless windows?
+
+        !!(defined?(Win32::Console) || Pry::Env['ANSICON'] || mri?)
+      end
+
+      # @return [Boolean]
+      def self.jruby?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+      end
+
+      # @return [Boolean]
+      def self.jruby_19?
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
+      # @return [Boolean]
+      def self.mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      # @return [Boolean]
+      def self.mri_2?
+        mri? && RUBY_VERSION.start_with?('2')
+      end
+    end
+  end
+end