pry 0.9.6.2-i386-mingw32 → 0.9.7-i386-mingw32

data/lib/pry/default_commands/ls.rb

@@ -4,226 +4,215 @@ class Pry
     Ls = Pry::CommandSet.new do
 
       helpers do
-        def should_trim?(target, options)
-          if target.eval('self').is_a? Module
-            options[:e] || target.eval('self') >= Object
-          else
-            options[:e]
-          end
-        end
 
-        def trim_methods(target, options, visibility)
-          if should_trim?(target, options)
-            []
-          else
-            Object.send("#{visibility}_instance_methods")
-          end
+        # http://ruby.runpaint.org/globals, and running "puts global_variables.inspect".
+        BUILTIN_GLOBALS = %w($" $$ $* $, $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w $. $/ $\\
+                             $: $; $< $= $> $0 $ARGV $CONSOLE $DEBUG $DEFAULT_INPUT $DEFAULT_OUTPUT
+                             $FIELD_SEPARATOR $FILENAME $FS $IGNORECASE $INPUT_LINE_NUMBER
+                             $INPUT_RECORD_SEPARATOR $KCODE $LOADED_FEATURES $LOAD_PATH $NR $OFS
+                             $ORS $OUTPUT_FIELD_SEPARATOR $OUTPUT_RECORD_SEPARATOR $PID $PROCESS_ID
+                             $PROGRAM_NAME $RS $VERBOSE $deferr $defout $stderr $stdin $stdout)
+
+        # $SAFE and $? are thread-local, the exception stuff only works in a rescue clause,
+        # everything else is basically a local variable with a $ in its name.
+        PSEUDO_GLOBALS = %w($! $' $& $` $@ $? $+ $_ $~ $1 $2 $3 $4 $5 $6 $7 $8 $9
+                           $CHILD_STATUS $SAFE $ERROR_INFO $ERROR_POSITION $LAST_MATCH_INFO
+                           $LAST_PAREN_MATCH $LAST_READ_LINE $MATCH $POSTMATCH $PREMATCH)
+
+        # Get all the methods that we'll want to output
+        def all_methods(obj, opts)
+          opts.M? ? Pry::Method.all_from_class(obj) : Pry::Method.all_from_obj(obj)
         end
 
-        def ls_color_map
-          {
-            "local variables" => Pry.config.ls.local_var_color,
-            "instance variables" => Pry.config.ls.instance_var_color,
-            "class variables" => Pry.config.ls.class_var_color,
-            "global variables" => Pry.config.ls.global_var_color,
-            "just singleton methods" => Pry.config.ls.method_color,
-            "public methods" => Pry.config.ls.method_color,
-            "private methods" => Pry.config.ls.method_color,
-            "protected methods" => Pry.config.ls.method_color,
-            "public instance methods" => Pry.config.ls.instance_method_color,
-            "private instance methods" => Pry.config.ls.instance_method_color,
-            "protected instance methods" => Pry.config.ls.instance_method_color,
-            "constants" => Pry.config.ls.constant_color
-          }
+        def resolution_order(obj, opts)
+          opts.M? ? Pry::Method.instance_resolution_order(obj) : Pry::Method.resolution_order(obj)
         end
-      end
-
-      command "ls", "Show the list of vars and methods in the current scope. Type `ls --help` for more info." do |*args|
-        options = {}
-        # Set target local to the default -- note that we can set a different target for
-        # ls if we like: e.g ls my_var
-        target = target()
-
-        OptionParser.new do |opts|
-          opts.banner = %{Usage: ls [OPTIONS] [VAR]\n\
-List information about VAR (the current context by default).
-Shows local and instance variables by default.
---
-}
-          opts.on("-g", "--globals", "Display global variables.") do
-            options[:g] = true
-          end
 
-          opts.on("-c", "--constants", "Display constants.") do
-            options[:c] = true
-          end
-
-          opts.on("-l", "--locals", "Display locals.") do
-            options[:l] = true
-          end
-
-          opts.on("-i", "--ivars", "Display instance variables.") do
-            options[:i] = true
-          end
-
-          opts.on("-k", "--class-vars", "Display class variables.") do
-            options[:k] = true
-          end
-
-          opts.on("-m", "--methods", "Display methods (public methods by default).") do
-            options[:m] = true
-          end
-
-          opts.on("-M", "--instance-methods", "Display instance methods (only relevant to classes and modules).") do
-            options[:M] = true
-          end
-
-          opts.on("-P", "--public", "Display public methods (with -m).") do
-            options[:P] = true
-          end
-
-          opts.on("-r", "--protected", "Display protected methods (with -m).") do
-            options[:r] = true
-          end
-
-          opts.on("-p", "--private", "Display private methods (with -m).") do
-            options[:p] = true
-          end
-
-          opts.on("-j", "--just-singletons", "Display just the singleton methods (with -m).") do
-            options[:j] = true
-          end
-
-          opts.on("-s", "--super", "Include superclass entries excluding Object (relevant to constant and methods options).") do
-            options[:s] = true
+        # Get the name of the klass for pretty display in the title column of ls -m
+        # as there can only ever be one singleton class of a non-class, we just call
+        # that "self".
+        def class_name(klass)
+          if klass == klass.ancestors.first
+            (klass.name || "") == "" ? klass.to_s : klass.name
+          elsif klass.ancestors.include?(Module)
+            begin
+              "#{class_name(ObjectSpace.each_object(klass).detect{ |x| class << x; self; end == klass })}.self"
+            rescue # ObjectSpace is not enabled by default in jruby
+              klass.to_s.sub(/#<Class:(.*)>/, '\1.self')
+            end
+          else
+            "self"
           end
+        end
 
-          opts.on("-e", "--everything", "Include superclass entries including Object (must be combined with -s switch).") do
-            options[:e] = true
-          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(obj, opts)
+          ceiling = if opts.q?
+                       [opts.M? ? obj.ancestors[1] : obj.class.ancestors[1]] + Pry.config.ls.ceiling
+                     elsif opts.v?
+                       []
+                     else
+                       Pry.config.ls.ceiling.dup
+                     end
+
+          lambda { |klass| !ceiling.include?(klass) }
+        end
 
-          opts.on("-a", "--all", "Display all types of entries.") do
-            options[:a] = true
+        # Format and colourise a list of methods.
+        def format_methods(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
 
-          opts.on("-v", "--verbose", "Verbose ouput.") do
-            options[:v] = true
-          end
+        def format_variables(type, vars)
+          vars.sort_by(&:downcase).map{ |var| color(type, var) }
+        end
 
-          opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
-            options[:f] = true
+        def format_constants(mod, constants)
+          constants.sort_by(&:downcase).map do |name|
+            if const = (!mod.autoload?(name) && mod.const_get(name) rescue nil)
+              if (const < Exception rescue false)
+                color(:exception_constant, name)
+              elsif (Module === mod.const_get(name) rescue false)
+                color(:class_constant, name)
+              else
+                color(:constant, name)
+              end
+            end
           end
+        end
 
-          opts.on("--grep REG", "Regular expression to be used.") do |reg|
-            options[:grep] = Regexp.new(reg)
+        def format_globals(globals)
+          globals.sort_by(&:downcase).map do |name|
+            if PSEUDO_GLOBALS.include?(name)
+              color(:pseudo_global, name)
+            elsif BUILTIN_GLOBALS.include?(name)
+              color(:builtin_global, name)
+            else
+              color(:global_var, name)
+            end
           end
+        end
 
-          opts.on_tail("-h", "--help", "Show this message.") do
-            output.puts opts
-            options[:h] = true
+        def format_locals(locals)
+          locals.sort_by(&:downcase).map do |name|
+            if _pry_.special_locals.include?(name.to_sym)
+              color(:pry_var, name)
+            else
+              color(:local_var, name)
+            end
           end
-        end.order(args) do |new_target|
-          target = Pry.binding_for(target.eval("#{new_target}")) if !options[:h]
         end
 
-        # exit if we've displayed help
-        next if options[:h]
-
-        # default is locals/ivars/class vars.
-        # Only occurs when no options or when only option is verbose
-        options.merge!({
-                         :l => true,
-                         :i => true,
-                         :k => true
-                       }) if options.empty? || (options.size == 1 && options[:v]) || (options.size == 1 && options[:grep])
+        # Add a new section to the output. Outputs nothing if the section would be empty.
+        def output_section(heading, body)
+          return if body.compact.empty?
+          output.puts "#{text.bold(color(:heading, heading))}: #{body.compact.join(Pry.config.ls.separator)}"
+        end
 
-        options[:grep] = // if !options[:grep]
+        # Color output based on config.ls.*_color
+        def color(type, str)
+          text.send(Pry.config.ls.send(:"#{type}_color"), str)
+        end
+      end
 
+      command "ls", "Show the list of vars and methods in the current scope. Type `ls --help` for more info.",
+              :shellwords => false, :interpolate => false do |*args|
 
-                              # Display public methods by default if -m or -M switch is used.
-                              options[:P] = true if (options[:m] || options[:M]) && !(options[:p] || options[:r] || options[:j])
+        opts = Slop.parse!(args, :strict => true) do |opt|
+          opt.banner unindent <<-USAGE
+            Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
+                   ls [-g] [-l]
 
-                              info = {}
-                              target_self = target.eval('self')
+            ls shows you which methods, constants and variables are accessible to Pry. By default it shows you the local variables defined in the current shell, and any public methods or instance variables defined on the current object.
 
-                              # ensure we have a real boolean and not a `nil` (important when
-                              # interpolating in the string)
-                              options[:s] = !!options[:s]
+            The colours used are configurable using Pry.config.ls.*_color, and the separator is Pry.config.ls.separator.
 
-                              # Numbers (e.g 0, 1, 2) are for ordering the hash values in Ruby 1.8
-                              i = -1
+            Pry.config.ls.ceiling is used to hide methods defined higher up in the inheritance chain, this is by default set to [Object, Module, Class] so that methods defined on all Objects are omitted. The -v flag can be used to ignore this setting and show all methods, while the -q can be used to set the ceiling much lower and show only methods defined on the object or its direct class.
+          USAGE
 
-                              # Start collecting the entries selected by the user
-                              info["local variables"] = [Array(target.eval("local_variables")).sort, i += 1] if options[:l] || options[:a]
-                              info["instance variables"] = [Array(target.eval("instance_variables")).sort, i += 1] if options[:i] || options[:a]
+          opt.on :m, "methods", "Show public methods defined on the Object (default)"
+          opt.on :M, "module", "Show methods defined in a Module or Class"
 
-                              info["class variables"] = [if target_self.is_a?(Module)
-                                                           Array(target.eval("class_variables")).sort
-                                                         else
-                                                           Array(target.eval("self.class.class_variables")).sort
-                                                         end, i += 1] if options[:k] || options[:a]
+          opt.on :p, "ppp", "Show public, protected (in yellow) and private (in green) methods"
+          opt.on :q, "quiet", "Show only methods defined on object.singleton_class and object.class"
+          opt.on :v, "verbose", "Show methods and constants on all super-classes (ignores Pry.config.ls.ceiling)"
 
-                              info["global variables"] = [Array(target.eval("global_variables")).sort, i += 1] if options[:g] || options[:a]
+          opt.on :g, "globals", "Show global variables, including those builtin to Ruby (in cyan)"
+          opt.on :l, "locals", "Show locals, including those provided by Pry (in red)"
 
-                              info["public methods"] = [Array(target.eval("public_methods(#{options[:s]})")).uniq.sort - trim_methods(target, options, :public), i += 1] if (options[:m] && options[:P]) || options[:a]
+          opt.on :c, "constants", "Show constants, highlighting classes (in blue), and exceptions (in purple)"
 
-                              info["protected methods"] = [Array(target.eval("protected_methods(#{options[:s]})")).sort - trim_methods(target, options, :protected), i += 1] if (options[:m] && options[:r]) || options[:a]
+          opt.on :i, "ivars", "Show instance variables (in blue) and class variables (in bright blue)"
 
-                              info["private methods"] = [Array(target.eval("private_methods(#{options[:s]})")).sort - trim_methods(target, options, :private), i += 1] if (options[:m] && options[:p]) || options[:a]
+          opt.on :G, "grep", "Filter output by regular expression", :optional => false
 
-                              info["just singleton methods"] = [Array(target.eval("methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:j]) && !options[:a]
+          opt.on :h, "help", "Show help"
+        end
 
-                              info["public instance methods"] = [Array(target.eval("public_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(target, options, :public), i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:P]) || options[:a])
+        next output.puts(opts) if opts.h?
 
-                              info["protected instance methods"] = [Array(target.eval("protected_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(target, options, :protected), i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:r]) || options[:a])
+        obj = args.empty? ? target_self : target.eval(args.join(" "))
 
-                              info["private instance methods"] = [Array(target.eval("private_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(target, options, :private), i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:p]) || options[:a])
+        # exclude -q, -v and --grep because they don't specify what the user wants to see.
+        has_opts = (opts.m? || opts.M? || opts.p? || opts.g? || opts.l? || opts.c? || opts.i?)
 
-                              # dealing with 1.8/1.9 compatibility issues :/
-                              csuper = options[:s]
-                              if Module.method(:constants).arity == 0
-                                csuper = nil
-                              end
+        show_methods   = opts.m? || opts.M? || opts.p? || !has_opts
+        show_constants = opts.c? || (!has_opts && Module === obj)
+        show_ivars     = opts.i? || !has_opts
+        show_locals    = opts.l? || (!has_opts && args.empty?)
 
-                              info["constants"] = [Array(target_self.is_a?(Module) ? target.eval("constants(#{csuper})") :
-                                                         target.eval("self.class.constants(#{csuper})")).uniq.sort, i += 1] if options[:c] || options[:a]
+        grep_regex, grep = [Regexp.new(opts[:G] || "."), lambda{ |x| x.grep(grep_regex) }]
 
-                              text = ""
+        raise Pry::CommandError, "-l does not make sense with a specified Object" if opts.l? && !args.empty?
+        raise Pry::CommandError, "-g does not make sense with a specified Object" if opts.g? && !args.empty?
+        raise Pry::CommandError, "-q does not make sense with -v" if opts.q? && opts.v?
+        raise Pry::CommandError, "-M only makes sense with a Module or a Class" if opts.M? && !(Module === obj)
+        raise Pry::CommandError, "-c only makes sense with a Module or a Class" if opts.c? && !args.empty? && !(Module === obj)
 
-                              # verbose output?
-                              if options[:v]
-                                # verbose
 
-                                info.sort_by { |k, v| v.last }.each do |k, v|
-              if !v.first.empty?
-                text <<  "#{k}:\n--\n"
-                filtered_list = v.first.grep options[:grep]
-                text << text().send(ls_color_map[k], (filtered_list.join(Pry.config.ls.separator)))
-                text << "\n\n"
-              end
-            end
+        if opts.g?
+          output_section("global variables", grep[format_globals(target.eval("global_variables"))])
+        end
 
-                                if !options[:f]
-                                  stagger_output(text)
-                                else
-                                  output.puts text
-                                end
+        if show_constants
+          mod = Module === obj ? obj : Object
+          constants = mod.constants
+          constants -= (mod.ancestors - [mod]).map(&:constants).flatten unless opts.v?
+          output_section("constants", grep[format_constants(mod, constants)])
+        end
 
-                                # plain
-                              else
-                                list = info.sort_by { |k, v| v.last }.map { |k, v| [k, [v.first.grep(options[:grep])], v.last] }
-                                list = list.each { |k, v| text << text().send(ls_color_map[k], v.first.join(Pry.config.ls.separator)); text << Pry.config.ls.separator }
+        if show_methods
+          # methods is a hash {Module/Class => [Pry::Methods]}
+          methods = all_methods(obj, opts).select{ |method| opts.p? || method.visibility == :public }.group_by(&:owner)
 
-                                if !options[:f]
-                                  stagger_output(text)
-                                else
-                                  output.puts text
-                                end
-                                list
-                              end
-                            end
+          # reverse the resolution order so that the most useful information appears right by the prompt
+          resolution_order(obj, opts).take_while(&below_ceiling(obj, opts)).reverse.each do |klass|
+            methods_here = format_methods((methods[klass] || []).select{ |m| m.name =~ grep_regex })
+            output_section "#{class_name(klass)} methods", methods_here
+          end
+        end
 
+        if show_ivars
+          klass = (Module === obj ? obj : obj.class)
+          output_section("instance variables", format_variables(:instance_var, grep[obj.__send__(:instance_variables)]))
+          output_section("class variables", format_variables(:class_var, grep[klass.__send__(:class_variables)]))
+        end
 
+        if show_locals
+          output_section("locals", format_locals(grep[target.eval("local_variables")]))
+        end
+      end
     end
   end
 end

data/lib/pry/default_commands/shell.rb

@@ -9,7 +9,7 @@ class Pry
           begin
             Dir.chdir File.expand_path(dest)
           rescue Errno::ENOENT
-            output.puts "No such directory: #{dest}"
+            raise CommandError, "No such directory: #{dest}"
           end
         else
           Pry.config.system.call(output, cmd, _pry_)
@@ -61,8 +61,8 @@ class Pry
             start_line = (ex_line - 1) - window_size
             start_line = start_line < 0 ? 0 : start_line
             end_line = (ex_line - 1) + window_size
-            if ex_file && is_core_rbx_path?(ex_file)
-              file_name = rbx_convert_path_to_full(ex_file)
+            if ex_file && RbxPath.is_core_path?(ex_file)
+              file_name = RbxPath.convert_path_to_full(ex_file)
             else
               file_name = ex_file
             end
@@ -79,22 +79,22 @@ class Pry
         next if opts.help?
 
         if opts.ex?
-          next output.puts "No Exception or Exception has no associated file." if file_name.nil?
+          if file_name.nil?
+            raise CommandError, "No Exception or Exception has no associated file."
+          end
         else
           file_name = args.shift
         end
 
         if !file_name
-          output.puts "Must provide a file name."
-          next
+          raise CommandError, "Must provide a file name."
         end
 
         begin
           contents, _, _ = read_between_the_lines(file_name, start_line, end_line)
           contents = syntax_highlight_by_file_type_or_specified(contents, file_name, opts[:type])
         rescue Errno::ENOENT
-          output.puts "Could not find file: #{file_name}"
-          next
+          raise CommandError, "Could not find file: #{file_name}"
         end
 
         if opts.l?

data/lib/pry/extended_commands/experimental.rb

@@ -4,11 +4,7 @@ class Pry
     Experimental = Pry::CommandSet.new do
 
       command "reload-method", "Reload the source specifically for a method", :requires_gem => "method_reload" do |meth_name|
-        if (meth = get_method_object(meth_name, target, {})).nil?
-          output.puts "Invalid method name: #{meth_name}."
-          next
-        end
-
+        meth = get_method_or_raise(meth_name, target, {}, :omit_help)
         meth.reload
       end
     end