pry 0.10.0.pre2-universal-mingw32

data/lib/pry/commands/ls/local_names.rb

@@ -0,0 +1,35 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LocalNames < Pry::Command::Ls::Formatter
+
+      def initialize(no_user_opts, args, _pry_)
+        super(_pry_)
+        @no_user_opts = no_user_opts
+        @args = args
+        @sticky_locals = _pry_.sticky_locals
+      end
+
+      def correct_opts?
+        super || (@no_user_opts && @args.empty?)
+      end
+
+      def output_self
+        local_vars = grep.regexp[@target.eval('local_variables')]
+        output_section('locals', format(local_vars))
+      end
+
+      private
+
+      def format(locals)
+        locals.sort_by(&:downcase).map do |name|
+          if @sticky_locals.include?(name.to_sym)
+            color(:pry_var, name)
+          else
+            color(:local_var, name)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/local_vars.rb

@@ -0,0 +1,39 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LocalVars < Pry::Command::Ls::Formatter
+
+      def initialize(opts, _pry_)
+        super(_pry_)
+        @default_switch = opts[:locals]
+        @sticky_locals = _pry_.sticky_locals
+      end
+
+      def output_self
+        name_value_pairs = @target.eval('local_variables').reject { |e|
+          @sticky_locals.keys.include?(e.to_sym)
+        }.map { |name|
+          [name, (@target.eval(name.to_s))]
+        }
+        format(name_value_pairs).join('')
+      end
+
+      private
+
+      def format(name_value_pairs)
+        name_value_pairs.sort_by { |name, value|
+          value.to_s.size
+        }.reverse.map { |name, value|
+          colorized_assignment_style(name, format_value(value))
+        }
+      end
+
+      def colorized_assignment_style(lhs, rhs, desired_width = 7)
+        colorized_lhs = color(:local_var, lhs)
+        color_escape_padding = colorized_lhs.size - lhs.size
+        pad = desired_width + color_escape_padding
+        "%-#{pad}s = %s" % [color(:local_var, colorized_lhs), rhs]
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/ls_entity.rb

@@ -0,0 +1,70 @@
+require 'pry/commands/ls/grep'
+require 'pry/commands/ls/formatter'
+require 'pry/commands/ls/globals'
+require 'pry/commands/ls/constants'
+require 'pry/commands/ls/methods'
+require 'pry/commands/ls/self_methods'
+require 'pry/commands/ls/instance_vars'
+require 'pry/commands/ls/local_names'
+require 'pry/commands/ls/local_vars'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+
+    class LsEntity
+      attr_reader :_pry_
+
+      def initialize(opts)
+        @interrogatee = opts[:interrogatee]
+        @no_user_opts = opts[:no_user_opts]
+        @opts = opts[:opts]
+        @args = opts[:args]
+        @grep = Grep.new(Regexp.new(opts[:opts][:G] || '.'))
+        @_pry_ = opts.delete(:_pry_)
+      end
+
+      def entities_table
+        entities.map(&:write_out).reject { |o| !o }.join('')
+      end
+
+      private
+
+      def grep(entity)
+        entity.tap { |o| o.grep = @grep }
+      end
+
+      def globals
+        grep Globals.new(@opts, _pry_)
+      end
+
+      def constants
+        grep Constants.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def methods
+        grep(Methods.new(@interrogatee, @no_user_opts, @opts, _pry_))
+      end
+
+      def self_methods
+        grep SelfMethods.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def instance_vars
+        grep InstanceVars.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def local_names
+        grep LocalNames.new(@no_user_opts, @args, _pry_)
+      end
+
+      def local_vars
+        LocalVars.new(@opts, _pry_)
+      end
+
+      def entities
+        [globals, constants, methods, self_methods, instance_vars, local_names,
+          local_vars]
+      end
+    end
+  end
+end

data/lib/pry/commands/ls/methods.rb

@@ -0,0 +1,57 @@
+require 'pry/commands/ls/methods_helper'
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Methods < Pry::Command::Ls::Formatter
+
+      include Pry::Command::Ls::Interrogatable
+      include Pry::Command::Ls::MethodsHelper
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:methods]
+        @instance_methods_switch = opts['instance-methods']
+        @ppp_switch = opts[:ppp]
+        @jruby_switch = opts['all-java']
+        @quiet_switch = opts[:quiet]
+        @verbose_switch = opts[:verbose]
+      end
+
+      def output_self
+        methods = all_methods.group_by(&:owner)
+        # Reverse the resolution order so that the most useful information
+        # appears right by the prompt.
+        resolution_order.take_while(&below_ceiling).reverse.map do |klass|
+          methods_here = (methods[klass] || []).select { |m| grep.regexp[m.name] }
+          heading = "#{ Pry::WrappedModule.new(klass).method_prefix }methods"
+          output_section(heading, format(methods_here))
+        end.join('')
+      end
+
+      private
+
+      def correct_opts?
+        super || @instance_methods_switch || @ppp_switch || @no_user_opts
+      end
+
+
+      # Get a lambda that can be used with `take_while` to prevent over-eager
+      # traversal of the Object's ancestry graph.
+      def below_ceiling
+        ceiling = if @quiet_switch
+                    [Pry::Method.safe_send(interrogatee_mod, :ancestors)[1]] +
+                      _pry_.config.ls.ceiling
+                  elsif @verbose_switch
+                    []
+                  else
+                    _pry_.config.ls.ceiling.dup
+                  end
+        lambda { |klass| !ceiling.include?(klass) }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/methods_helper.rb

@@ -0,0 +1,46 @@
+require 'pry/commands/ls/jruby_hacks'
+
+module Pry::Command::Ls::MethodsHelper
+
+  include Pry::Command::Ls::JRubyHacks
+
+  private
+
+  # Get all the methods that we'll want to output.
+  def all_methods(instance_methods = false)
+    methods = if instance_methods || @instance_methods_switch
+                Pry::Method.all_from_class(@interrogatee)
+              else
+                Pry::Method.all_from_obj(@interrogatee)
+              end
+
+    if Pry::Helpers::BaseHelpers.jruby? && !@jruby_switch
+      methods = trim_jruby_aliases(methods)
+    end
+
+    methods.select { |method| @ppp_switch || method.visibility == :public }
+  end
+
+  def resolution_order
+    if @instance_methods_switch
+      Pry::Method.instance_resolution_order(@interrogatee)
+    else
+      Pry::Method.resolution_order(@interrogatee)
+    end
+  end
+
+  def format(methods)
+    methods.sort_by(&:name).map do |method|
+      if method.name == 'method_missing'
+        color(:method_missing, 'method_missing')
+      elsif method.visibility == :private
+        color(:private_method, method.name)
+      elsif method.visibility == :protected
+        color(:protected_method, method.name)
+      else
+        color(:public_method, method.name)
+      end
+    end
+  end
+
+end

data/lib/pry/commands/ls/self_methods.rb

@@ -0,0 +1,32 @@
+require 'pry/commands/ls/interrogatable'
+require 'pry/commands/ls/methods_helper'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class SelfMethods < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+      include Pry::Command::Ls::MethodsHelper
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+      end
+
+      def output_self
+        methods = all_methods(true).select do |m|
+          m.owner == @interrogatee && grep.regexp[m.name]
+        end
+        heading = "#{ Pry::WrappedModule.new(@interrogatee).method_prefix }methods"
+        output_section(heading, format(methods))
+      end
+
+      private
+
+      def correct_opts?
+        @no_user_opts && interrogating_a_module?
+      end
+
+    end
+  end
+end

data/lib/pry/commands/nesting.rb

@@ -0,0 +1,25 @@
+class Pry
+  class Command::Nesting < Pry::ClassCommand
+    match 'nesting'
+    group 'Navigating Pry'
+    description 'Show nesting information.'
+
+    banner <<-'BANNER'
+      Show nesting information.
+    BANNER
+
+    def process
+      output.puts 'Nesting status:'
+      output.puts '--'
+      _pry_.binding_stack.each_with_index do |obj, level|
+        if level == 0
+          output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))} (Pry top level)"
+        else
+          output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))}"
+        end
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Nesting)
+end

data/lib/pry/commands/play.rb

@@ -0,0 +1,103 @@
+class Pry
+  class Command::Play < Pry::ClassCommand
+    match 'play'
+    group 'Editing'
+    description 'Playback a string variable, method, line, or file as input.'
+
+    banner <<-'BANNER'
+      Usage: play [OPTIONS] [--help]
+
+      The play command enables you to replay code from files and methods as if they
+      were entered directly in the Pry REPL.
+
+      play --lines 149..153   # assumes current context
+      play -i 20 --lines 1..3 # assumes lines of the input expression at 20
+      play -o 4               # the output of of an expression at 4
+      play Pry#repl -l 1..-1  # play the contents of Pry#repl method
+      play -e 2               # play from specified line until end of valid expression
+      play hello.rb           # play a file
+      play Rakefile -l 5      # play line 5 of a file
+      play -d hi              # play documentation of hi method
+      play hi --open          # play hi method and leave it open
+
+      https://github.com/pry/pry/wiki/User-Input#wiki-Play
+    BANNER
+
+    def options(opt)
+      CodeCollector.inject_options(opt)
+
+      opt.on :open, 'Plays the selected content except the last line. Useful' \
+                    ' for replaying methods and leaving the method definition' \
+                    ' "open". `amend-line` can then be used to' \
+                    ' modify the method.'
+
+      opt.on :e, :expression=, 'Executes until end of valid expression', :as => Integer
+      opt.on :p, :print, 'Prints executed code'
+    end
+
+    def process
+      @cc = CodeCollector.new(args, opts, _pry_)
+
+      perform_play
+      show_input
+    end
+
+    def perform_play
+      eval_string << content_after_options
+      run "fix-indent"
+    end
+
+    def show_input
+      if opts.present?(:print) or !Pry::Code.complete_expression?(eval_string)
+        run "show-input"
+      end
+    end
+
+
+    def content_after_options
+      if opts.present?(:open)
+        restrict_to_lines(content, (0..-2))
+      elsif opts.present?(:expression)
+        content_at_expression
+      else
+        content
+      end
+    end
+
+    def content_at_expression
+      code_object.expression_at(opts[:expression])
+    end
+
+    def code_object
+      Pry::Code.new(content)
+    end
+
+    def should_use_default_file?
+      !args.first && !opts.present?(:in) && !opts.present?(:out)
+    end
+
+    def content
+      if should_use_default_file?
+        file_content
+      else
+        @cc.content
+      end
+    end
+
+    # The file to play from when no code object is specified.
+    # e.g `play --lines 4..10`
+    def default_file
+      target.eval("__FILE__") && File.expand_path(target.eval("__FILE__"))
+    end
+
+    def file_content
+      if default_file && File.exists?(default_file)
+        @cc.restrict_to_lines(File.read(default_file), @cc.line_range)
+      else
+        raise CommandError, "File does not exist! File was: #{default_file.inspect}"
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Play)
+end

data/lib/pry/commands/pry_backtrace.rb

@@ -0,0 +1,25 @@
+class Pry
+  class Command::PryBacktrace < Pry::ClassCommand
+    match 'pry-backtrace'
+    group 'Context'
+    description 'Show the backtrace for the Pry session.'
+
+    banner <<-BANNER
+      Usage: pry-backtrace [OPTIONS] [--help]
+
+      Show the backtrace for the position in the code where Pry was started. This can
+      be used to infer the behavior of the program immediately before it entered Pry,
+      just like the backtrace property of an exception.
+
+      NOTE: if you are looking for the backtrace of the most recent exception raised,
+      just type: `_ex_.backtrace` instead.
+      See: https://github.com/pry/pry/wiki/Special-Locals
+    BANNER
+
+    def process
+      _pry_.pager.page text.bold('Backtrace:') << "\n--\n" << _pry_.backtrace.join("\n")
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::PryBacktrace)
+end

data/lib/pry/commands/pry_version.rb

@@ -0,0 +1,17 @@
+class Pry
+  class Command::Version < Pry::ClassCommand
+    match 'pry-version'
+    group 'Misc'
+    description 'Show Pry version.'
+
+    banner <<-'BANNER'
+      Show Pry version.
+    BANNER
+
+    def process
+      output.puts "Pry version: #{Pry::VERSION} on Ruby #{RUBY_VERSION}."
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Version)
+end