pry 0.10.pre.1-java → 0.10.0.pre2-java

data/lib/pry/default_commands/ls.rb

@@ -1,272 +0,0 @@
-class Pry
-  module DefaultCommands
-
-    Ls = Pry::CommandSet.new do
-
-      create_command "ls","Show the list of vars and methods in the current scope.",
-      :shellwords => false, :interpolate => false do
-
-        group "Context"
-
-        def options(opt)
-          opt.banner unindent <<-USAGE
-            Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
-                   ls [-g] [-l]
-
-            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.
-
-            The colours used are configurable using Pry.config.ls.*_color, and the separator is Pry.config.ls.separator.
-
-            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
-
-          opt.on :m, "methods", "Show public methods defined on the Object (default)"
-          opt.on :M, "instance-methods", "Show methods defined in a Module or Class"
-
-          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)"
-
-          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)"
-
-          opt.on :c, "constants", "Show constants, highlighting classes (in blue), and exceptions (in purple).\n" +
-          " " * 32 +              "Constants that are pending autoload? are also shown (in yellow)."
-
-          opt.on :i, "ivars", "Show instance variables (in blue) and class variables (in bright blue)"
-
-          opt.on :G, "grep", "Filter output by regular expression", :argument => true
-          if jruby?
-            opt.on :J, "all-java", "Show all the aliases for methods from java (default is to show only prettiest)"
-          end
-        end
-
-        def process
-          obj = args.empty? ? target_self : target.eval(args.join(" "))
-
-          # exclude -q, -v and --grep because they don't specify what the user wants to see.
-          has_opts = (opts.present?(:methods) || opts.present?(:'instance-methods') || opts.present?(:ppp) ||
-                      opts.present?(:globals) || opts.present?(:locals) || opts.present?(:constants) ||
-                      opts.present?(:ivars))
-
-          show_methods   = opts.present?(:methods) || opts.present?(:'instance-methods') || opts.present?(:ppp) || !has_opts
-          show_self_methods = (!has_opts && Module === obj)
-          show_constants = opts.present?(:constants) || (!has_opts && Module === obj)
-          show_ivars     = opts.present?(:ivars) || !has_opts
-          show_locals    = opts.present?(:locals) || (!has_opts && args.empty?)
-
-          grep_regex, grep = [Regexp.new(opts[:G] || "."), lambda{ |x| x.grep(grep_regex) }]
-
-          raise Pry::CommandError, "-l does not make sense with a specified Object" if opts.present?(:locals) && !args.empty?
-          raise Pry::CommandError, "-g does not make sense with a specified Object" if opts.present?(:globals) && !args.empty?
-          raise Pry::CommandError, "-q does not make sense with -v" if opts.present?(:quiet) && opts.present?(:verbose)
-          raise Pry::CommandError, "-M only makes sense with a Module or a Class" if opts.present?(:'instance-methods') && !(Module === obj)
-          raise Pry::CommandError, "-c only makes sense with a Module or a Class" if opts.present?(:constants) && !args.empty? && !(Module === obj)
-
-
-          if opts.present?(:globals)
-            output_section("global variables", grep[format_globals(target.eval("global_variables"))])
-          end
-
-          if show_constants
-            mod = Module === obj ? obj : Object
-            constants = mod.constants
-            constants -= (mod.ancestors - [mod]).map(&:constants).flatten unless opts.present?(:verbose)
-            output_section("constants", grep[format_constants(mod, constants)])
-          end
-
-          if show_methods
-            # methods is a hash {Module/Class => [Pry::Methods]}
-            methods = all_methods(obj).group_by(&:owner)
-
-            # reverse the resolution order so that the most useful information appears right by the prompt
-            resolution_order(obj).take_while(&below_ceiling(obj)).reverse.each do |klass|
-              methods_here = format_methods((methods[klass] || []).select{ |m| m.name =~ grep_regex })
-              output_section "#{Pry::WrappedModule.new(klass).method_prefix}methods", methods_here
-            end
-          end
-
-          if show_self_methods
-            methods = all_methods(obj, true).select{ |m| m.owner == obj && m.name =~ grep_regex }
-            output_section "#{Pry::WrappedModule.new(obj).method_prefix}methods", format_methods(methods)
-          end
-
-          if show_ivars
-            klass = (Module === obj ? obj : obj.class)
-            ivars = Pry::Method.safe_send(obj, :instance_variables)
-            kvars = Pry::Method.safe_send(klass, :class_variables)
-            output_section("instance variables", format_variables(:instance_var, ivars))
-            output_section("class variables", format_variables(:class_var, kvars))
-          end
-
-          if show_locals
-            output_section("locals", format_locals(grep[target.eval("local_variables")]))
-          end
-        end
-
-        private
-
-        # 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, instance_methods=false)
-          methods = if instance_methods || opts.present?(:'instance-methods')
-                      Pry::Method.all_from_class(obj)
-                    else
-                      Pry::Method.all_from_obj(obj)
-                    end
-
-          if jruby? && !opts.present?(:J)
-            methods = trim_jruby_aliases(methods)
-          end
-
-          methods.select{ |method| opts.present?(:ppp) || method.visibility == :public }
-        end
-
-        # JRuby creates lots of aliases for methods imported from java in an attempt to
-        # make life easier for ruby programmers.
-        # (e.g. getFooBar becomes get_foo_bar and foo_bar, and maybe foo_bar? if it
-        # returns a Boolean).
-        # The full transformations are in the assignAliases method of:
-        #   https://github.com/jruby/jruby/blob/master/src/org/jruby/javasupport/JavaClass.java
-        #
-        # This has the unfortunate side-effect of making the output of ls even more
-        # incredibly verbose than it normally would be for these objects; and so we filter
-        # out all but the nicest of these aliases here.
-        #
-        # TODO: This is a little bit vague, better heuristics could be used.
-        #       JRuby also has a lot of scala-specific logic, which we don't copy.
-        #
-        def trim_jruby_aliases(methods)
-          grouped = methods.group_by do |m|
-            m.name.sub(/\A(is|get|set)(?=[A-Z_])/, '').gsub(/[_?=]/, '').downcase
-          end
-
-          grouped.map do |key, values|
-            values = values.sort_by do |m|
-              rubbishness(m.name)
-            end
-
-            found = []
-            values.select do |x|
-              (!found.any?{ |y| x == y }) && found << x
-            end
-          end.flatten(1)
-        end
-
-        # When removing jruby aliases, we want to keep the alias that is "least rubbish"
-        # according to this metric.
-        def rubbishness(name)
-          name.each_char.map{ |x|
-            case x
-            when /[A-Z]/
-              1
-            when '?', '=', '!'
-              -2
-            else
-              0
-            end
-          }.inject(&:+) + (name.size / 100.0)
-        end
-
-        def resolution_order(obj)
-          opts.present?(:'instance-methods') ? Pry::Method.instance_resolution_order(obj) : Pry::Method.resolution_order(obj)
-        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)
-          ceiling = if opts.present?(:quiet)
-                       [opts.present?(:'instance-methods') ? obj.ancestors[1] : obj.class.ancestors[1]] + Pry.config.ls.ceiling
-                     elsif opts.present?(:verbose)
-                       []
-                     else
-                       Pry.config.ls.ceiling.dup
-                     end
-
-          lambda { |klass| !ceiling.include?(klass) }
-        end
-
-        # 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
-
-        def format_variables(type, vars)
-          vars.sort_by(&:downcase).map{ |var| color(type, var) }
-        end
-
-        def format_constants(mod, constants)
-          constants.sort_by(&:downcase).map do |name|
-            if const = (!mod.autoload?(name) && (mod.const_get(name) || true) 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
-            else
-              color(:unloaded_constant, name)
-            end
-          end
-        end
-
-        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
-
-        def format_locals(locals)
-          locals.sort_by(&:downcase).map do |name|
-            if _pry_.sticky_locals.include?(name.to_sym)
-              color(:pry_var, name)
-            else
-              color(:local_var, name)
-            end
-          end
-        end
-
-        # 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
-
-        # Color output based on config.ls.*_color
-        def color(type, str)
-          text.send(Pry.config.ls.send(:"#{type}_color"), str)
-        end
-      end
-    end
-  end
-end

data/lib/pry/default_commands/misc.rb

@@ -1,38 +0,0 @@
-class Pry
-  module DefaultCommands
-    Misc = Pry::CommandSet.new do
-
-      command "toggle-color", "Toggle syntax highlighting." do
-        Pry.color = !Pry.color
-        output.puts "Syntax highlighting #{Pry.color ? "on" : "off"}"
-      end
-
-      command "simple-prompt", "Toggle the simple prompt." do
-        case _pry_.prompt
-        when Pry::SIMPLE_PROMPT
-          _pry_.pop_prompt
-        else
-          _pry_.push_prompt Pry::SIMPLE_PROMPT
-        end
-      end
-
-      command "pry-version", "Show Pry version." do
-        output.puts "Pry version: #{Pry::VERSION} on Ruby #{RUBY_VERSION}."
-      end
-
-      command "reload-method", "Reload the source file that contains the specified method" do |meth_name|
-        meth = get_method_or_raise(meth_name, target, {}, :omit_help)
-
-        if meth.source_type == :c
-          raise CommandError, "Can't reload a C method."
-        elsif meth.dynamically_defined?
-          raise CommandError, "Can't reload an eval method."
-        else
-          file_name = meth.source_file
-          load file_name
-          output.puts "Reloaded #{file_name}."
-        end
-      end
-    end
-  end
-end

data/lib/pry/default_commands/navigating_pry.rb

@@ -1,110 +0,0 @@
-class Pry
-  module DefaultCommands
-
-    NavigatingPry = Pry::CommandSet.new do
-      command "switch-to", "Start a new sub-session on a binding in the current stack (numbered by nesting)." do |selection|
-        selection = selection.to_i
-
-        if selection < 0 || selection > _pry_.binding_stack.size - 1
-          raise CommandError, "Invalid binding index #{selection} - use `nesting` command to view valid indices."
-        else
-          Pry.start(_pry_.binding_stack[selection])
-        end
-      end
-
-      command "nesting", "Show nesting information." do
-        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
-
-      command "jump-to", "Jump to a binding further up the stack, popping all bindings below." do |break_level|
-        break_level = break_level.to_i
-        nesting_level = _pry_.binding_stack.size - 1
-
-        case break_level
-        when nesting_level
-          output.puts "Already at nesting level #{nesting_level}"
-        when (0...nesting_level)
-          _pry_.binding_stack.slice!(break_level + 1, _pry_.binding_stack.size)
-
-        else
-          max_nest_level = nesting_level - 1
-          output.puts "Invalid nest level. Must be between 0 and #{max_nest_level}. Got #{break_level}."
-        end
-      end
-
-      command "exit-all", "End the current Pry session (popping all bindings) and returning to caller. Accepts optional return value. Aliases: !!@" do
-        # calculate user-given value
-        exit_value = target.eval(arg_string)
-
-        # clear the binding stack
-        _pry_.binding_stack.clear
-
-        # break out of the repl loop
-        throw(:breakout, exit_value)
-      end
-
-      alias_command "!!@", "exit-all"
-
-      create_command "exit" do
-        description "Pop the previous binding (does NOT exit program). Aliases: quit"
-
-        banner <<-BANNER
-          Usage:   exit [OPTIONS] [--help]
-          Aliases: quit
-
-          It can be useful to exit a context with a user-provided value. For
-          instance an exit value can be used to determine program flow.
-
-          e.g: `exit "pry this"`
-          e.g: `exit`
-
-          https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
-        BANNER
-
-        command_options(
-                        :keep_retval => true
-                        )
-
-        def process
-          if _pry_.binding_stack.one?
-            _pry_.run_command "exit-all #{arg_string}"
-          else
-            # otherwise just pop a binding and return user supplied value
-            process_pop_and_return
-          end
-        end
-
-        def process_pop_and_return
-          popped_object = _pry_.binding_stack.pop.eval('self')
-
-          # return a user-specified value if given otherwise return the object
-          return target.eval(arg_string) unless arg_string.empty?
-          popped_object
-        end
-      end
-
-      alias_command "quit", "exit"
-
-      command "exit-program", "End the current program. Aliases: quit-program, !!!" do
-        Pry.save_history if Pry.config.history.should_save
-        Kernel.exit target.eval(arg_string).to_i
-      end
-
-      alias_command "quit-program", "exit-program"
-      alias_command "!!!", "exit-program"
-
-      command "!pry", "Start a Pry session on current self; this even works mid multi-line expression." do
-        target.pry
-      end
-
-    end
-  end
-end

data/lib/pry/default_commands/whereami.rb

@@ -1,92 +0,0 @@
-
-class Pry
-  module DefaultCommands
-    Whereami = Pry::CommandSet.new do
-      create_command "whereami" do
-        description "Show code surrounding the current context."
-        group 'Context'
-        banner <<-BANNER
-          Usage: whereami [-q] [N]
-
-          Describe the current location. If you use `binding.pry` inside a
-          method then whereami will print out the source for that method.
-
-          If a number is passed, then N lines before and after the current line
-          will be shown instead of the method itself.
-
-          The `-q` flag can be used to suppress error messages in the case that
-          there's no code to show. This is used by pry in the default
-          before_session hook to show you when you arrive at a `binding.pry`.
-
-          When pry was started on an Object and there is no associated method,
-          whereami will instead output a brief description of the current
-          object.
-        BANNER
-
-        def setup
-          @method = Pry::Method.from_binding(target)
-          @file = target.eval('__FILE__')
-          @line = target.eval('__LINE__')
-        end
-
-        def options(opt)
-          opt.on :q, :quiet, "Don't display anything in case of an error"
-        end
-
-        def code
-          @code ||= if show_method?
-                      Pry::Code.from_method(@method)
-                    else
-                      Pry::Code.from_file(@file).around(@line, window_size)
-                    end
-        end
-
-        def location
-          "#{@file} @ line #{show_method? ? @method.source_line : @line} #{@method && @method.name_with_owner}"
-        end
-
-        def process
-          if opts.quiet? && (internal_binding?(target) || !code?)
-            return
-          elsif internal_binding?(target)
-            if target_self == TOPLEVEL_BINDING.eval("self")
-              output.puts "At the top level."
-            else
-              output.puts "Inside #{Pry.view_clip(target_self)}."
-            end
-            return
-          end
-
-          set_file_and_dir_locals(@file)
-
-          output.puts "\n#{text.bold('From:')} #{location}:\n\n"
-          output.puts code.with_line_numbers.with_marker(@line)
-          output.puts
-        end
-
-        private
-
-        def show_method?
-          args.empty? && @method && @method.source? && @method.source_range.count < 20 &&
-          # These checks are needed in case of an eval with a binding and file/line
-          # numbers set to outside the function. As in rails' use of ERB.
-          @method.source_file == @file && @method.source_range.include?(@line)
-        end
-
-        def code?
-          !!code
-        rescue MethodSource::SourceNotFoundError
-          false
-        end
-
-        def window_size
-          if args.empty?
-            Pry.config.default_window_size
-          else
-            args.first.to_i
-          end
-        end
-      end
-    end
-  end
-end