pry 0.8.3 → 0.8.4pre1

data/lib/pry/default_commands/input.rb

@@ -0,0 +1,38 @@
+class Pry
+  module DefaultCommands
+
+    Input = Pry::CommandSet.new :input do
+
+      command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop." do
+        output.puts "Input buffer cleared!"
+        opts[:eval_string].clear
+      end
+
+      command "hist", "Show and replay Readline history. When given no args history is displayed.\nType `hist --help` for more info." do |*args|
+        hist_array = Readline::HISTORY.to_a
+
+        if args.empty?
+          text = add_line_numbers(hist_array.join("\n"), 0)
+          stagger_output(text)
+          next
+        end
+
+        opts = Slop.parse(args) do |opt|
+          opt.banner "Usage: hist [--replay START..END]\nView and replay history\nWhen given no args, history is displayed.\ne.g hist --replay 2..8"
+          opt.on :r, :replay, 'The line (or range of lines) to replay.', true, :as => Range
+          opt.on :h, :help, 'Show this message.', :tail => true do
+            output.puts opt.help
+          end
+        end
+
+        next if opts.h?
+
+        actions = Array(hist_array[opts[:replay]]).join("\n") + "\n"
+        Pry.active_instance.input = StringIO.new(actions)
+      end
+
+
+    end
+
+  end
+end

data/lib/pry/default_commands/introspection.rb

@@ -0,0 +1,190 @@
+class Pry
+  module DefaultCommands
+
+    Introspection = Pry::CommandSet.new :introspection do
+
+      command "show-method", "Show the source for METH. Type `show-method --help` for more info. Aliases: $, show-source" do |*args|
+        target = target()
+
+        opts = Slop.parse!(args) do |opts|
+          opts.banner %{Usage: show-method [OPTIONS] [METH]
+Show the source for method METH. Tries instance methods first and then methods by default.
+e.g: show-method hello_method
+--
+}
+          opts.on :l, "line-numbers", "Show line numbers."
+          opts.on :M, "instance-methods", "Operate on instance methods."
+          opts.on :m, :methods, "Operate on methods."
+          opts.on :f, :flood, "Do not use a pager to view text longer than one screen."
+          opts.on :c, :context, "Select object context to run under.", true do |context|
+            target = Pry.binding_for(target.eval(context))
+          end
+          opts.on :h, :help, "This message." do
+            output.puts opts
+          end
+        end
+
+        next if opts.help?
+
+        meth_name = args.shift
+        if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+          output.puts "Invalid method name: #{meth_name}. Type `show-method --help` for help"
+          next
+        end
+
+        code, code_type = code_and_code_type_for(meth)
+        next if !code
+
+        output.puts make_header(meth, code_type, code)
+        if Pry.color
+          code = CodeRay.scan(code, code_type).term
+        end
+
+        start_line = false
+        if opts.l?
+          start_line = meth.source_location ? meth.source_location.last : 1
+        end
+
+        render_output(opts.flood?, start_line, code)
+        code
+      end
+
+      alias_command "show-source", "show-method", ""
+      alias_command "$", "show-method", ""
+
+      command "show-command", "Show the source for CMD. Type `show-command --help` for more info." do |*args|
+        options = {}
+        target = target()
+        command_name = nil
+
+        OptionParser.new do |opts|
+          opts.banner = %{Usage: show-command [OPTIONS] [CMD]
+Show the source for command CMD.
+e.g: show-command show-method
+--
+}
+          opts.on("-l", "--line-numbers", "Show line numbers.") do |line|
+            options[:l] = true
+          end
+
+          opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
+            options[:f] = true
+          end
+
+          opts.on_tail("-h", "--help", "This message.") do
+            output.puts opts
+            options[:h] = true
+          end
+        end.order(args) do |v|
+          command_name = v
+        end
+
+        next if options[:h]
+
+        if !command_name
+          output.puts "You must provide a command name."
+          next
+        end
+
+        if commands[command_name]
+          meth = commands[command_name].block
+
+          code = strip_leading_whitespace(meth.source)
+          file, line = meth.source_location
+          set_file_and_dir_locals(file)
+          check_for_dynamically_defined_method(meth)
+
+          output.puts make_header(meth, :ruby, code)
+
+          if Pry.color
+            code = CodeRay.scan(code, :ruby).term
+          end
+
+          render_output(options[:f], options[:l] ? meth.source_location.last : false, code)
+          code
+        else
+          output.puts "No such command: #{command_name}."
+        end
+      end
+
+      command "edit-method", "Edit a method. Type `edit-method --help` for more info." do |*args|
+        target = target()
+
+        opts = Slop.parse!(args) do |opts|
+          opts.banner %{Usage: edit-method [OPTIONS] [METH]
+Edit the method METH in an editor.
+Ensure #{bold("Pry.editor")} is set to your editor of choice.
+e.g: edit-method hello_method
+--
+}
+          opts.on :M, "instance-methods", "Operate on instance methods."
+          opts.on :m, :methods, "Operate on methods."
+          opts.on "no-reload", "Do not automatically reload the method's file after editting."
+          opts.on :n, "no-jump", "Do not fast forward editor to first line of method."
+          opts.on :c, :context, "Select object context to run under.", true do |context|
+            target = Pry.binding_for(target.eval(context))
+          end
+          opts.on :h, :help, "This message." do
+            output.puts opts
+          end
+        end
+
+        next if opts.help?
+
+        meth_name = args.shift
+        if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+          output.puts "Invalid method name: #{meth_name}."
+          next
+        end
+
+        next output.puts "Error: No editor set!\nEnsure that #{bold("Pry.editor")} is set to your editor of choice." if !Pry.editor
+
+        if is_a_c_method?(meth)
+          output.puts "Error: Can't edit a C method."
+        elsif is_a_dynamically_defined_method?(meth)
+          output.puts "Error: Can't edit an eval method."
+
+          # editor is invoked here
+        else
+          file, line = meth.source_location
+          set_file_and_dir_locals(file)
+
+          if Pry.editor.respond_to?(:call)
+            editor_invocation = Pry.editor.call(file, line)
+          else
+            # only use start line if -n option is not used
+            start_line_syntax = opts.n? ? "" : start_line_for_editor(line)
+            editor_invocation = "#{Pry.editor} #{start_line_syntax} #{file}"
+          end
+
+          run ".#{editor_invocation}"
+          silence_warnings do
+            load file if !opts["no-reload"]
+          end
+        end
+      end
+
+
+      helpers do
+
+        def start_line_for_editor(line_number)
+          case Pry.editor
+          when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
+            "+#{line_number}"
+          when /^mate/, /^geany/
+            "-l #{line_number}"
+          else
+            if RUBY_PLATFORM =~ /mswin|mingw/
+              ""
+            else
+              "+#{line_number}"
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/pry/default_commands/ls.rb

@@ -0,0 +1,199 @@
+class Pry
+  module DefaultCommands
+
+    Ls = Pry::CommandSet.new :ls do
+
+      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 (relevant to constant and methods options).") do
+            options[:s] = true
+          end
+
+          opts.on("-a", "--all", "Display all types of entries.") do
+            options[:a] = true
+          end
+
+          opts.on("-v", "--verbose", "Verbose ouput.") do
+            options[:v] = true
+          end
+
+          opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
+            options[:f] = true
+          end
+
+          opts.on("--grep REG", "Regular expression to be used.") do |reg|
+            options[:grep] = Regexp.new(reg)
+          end
+
+          opts.on_tail("-h", "--help", "Show this message.") do
+            output.puts opts
+            options[:h] = true
+          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])
+
+        options[:grep] = // if !options[:grep]
+
+
+                              # 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])
+
+                              info = {}
+                              target_self = target.eval('self')
+
+                              # ensure we have a real boolean and not a `nil` (important when
+                              # interpolating in the string)
+                              options[:s] = !!options[:s]
+
+                              # Numbers (e.g 0, 1, 2) are for ordering the hash values in Ruby 1.8
+                              i = -1
+
+                              # 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]
+
+                              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]
+
+                              info["global variables"] = [Array(target.eval("global_variables")).sort, i += 1] if options[:g] || options[:a]
+
+                              info["public methods"] = [Array(target.eval("public_methods(#{options[:s]})")).uniq.sort, i += 1] if (options[:m] && options[:P]) || options[:a]
+
+                              info["protected methods"] = [Array(target.eval("protected_methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:r]) || options[:a]
+
+                              info["private methods"] = [Array(target.eval("private_methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:p]) || options[:a]
+
+                              info["just singleton methods"] = [Array(target.eval("methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:j]) || options[:a]
+
+                              info["public instance methods"] = [Array(target.eval("public_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:P]) || options[:a])
+
+                              info["protected instance methods"] = [Array(target.eval("protected_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:r]) || options[:a])
+
+                              info["private instance methods"] = [Array(target.eval("private_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:p]) || options[:a])
+
+                              # dealing with 1.8/1.9 compatibility issues :/
+                              csuper = options[:s]
+                              if Module.method(:constants).arity == 0
+                                csuper = nil
+                              end
+
+                              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]
+
+                              text = ""
+
+                              # 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]
+                if Pry.color
+                  text << CodeRay.scan(Pry.view(filtered_list), :ruby).term + "\n"
+                else
+                  text << Pry.view(filtered_list) + "\n"
+                end
+                text << "\n\n"
+              end
+            end
+
+                                if !options[:f]
+                                  stagger_output(text)
+                                else
+                                  output.puts text
+                                end
+
+                                # plain
+                              else
+                                list = info.values.sort_by(&:last).map(&:first).inject(&:+)
+                                list = list.grep(options[:grep]) if list
+                                list.uniq! if list
+                                if Pry.color
+                                  text << CodeRay.scan(Pry.view(list), :ruby).term + "\n"
+                                else
+                                  text <<  Pry.view(list) + "\n"
+                                end
+                                if !options[:f]
+                                  stagger_output(text)
+                                else
+                                  output.puts text
+                                end
+                                list
+                              end
+                            end
+
+
+      end
+    end
+  end

data/lib/pry/default_commands/shell.rb

@@ -0,0 +1,90 @@
+class Pry
+  module DefaultCommands
+
+    Shell = Pry::CommandSet.new :shell do
+
+      # this cannot be accessed, it's just for help purposes.
+      command ".<shell command>", "All text following a '.' is forwarded to the shell." do
+      end
+
+      command "shell-mode", "Toggle shell mode. Bring in pwd prompt and file completion." do
+        case Pry.active_instance.prompt
+        when Pry::SHELL_PROMPT
+          Pry.active_instance.pop_prompt
+          Pry.active_instance.custom_completions = Pry::DEFAULT_CUSTOM_COMPLETIONS
+        else
+          Pry.active_instance.push_prompt Pry::SHELL_PROMPT
+          Pry.active_instance.custom_completions = Pry::FILE_COMPLETIONS
+          Readline.completion_proc = Pry::InputCompleter.build_completion_proc target,
+          Pry.active_instance.instance_eval(&Pry::FILE_COMPLETIONS)
+        end
+      end
+
+      alias_command "file-mode", "shell-mode", ""
+
+
+      command "cat", "Show output of file FILE. Type `cat --help` for more information." do |*args|
+        options= {}
+        file_name = nil
+        start_line = 0
+        end_line = -1
+        file_type = nil
+
+        OptionParser.new do |opts|
+          opts.banner = %{Usage: cat [OPTIONS] FILE
+Cat a file. Defaults to displaying whole file. Syntax highlights file if type is recognized.
+e.g: cat hello.rb
+--
+}
+          opts.on("-l", "--line-numbers", "Show line numbers.") do |line|
+            options[:l] = true
+          end
+
+          opts.on("-s", "--start LINE", "Start line (defaults to start of file). Line 1 is the first line.") do |line|
+            start_line = line.to_i - 1
+          end
+
+          opts.on("-e", "--end LINE", "End line (defaults to end of file). Line -1 is the last line.") do |line|
+            end_line = line.to_i - 1
+          end
+
+          opts.on("-t", "--type TYPE", "The specific file type for syntax higlighting (e.g ruby, python, cpp, java)") do |type|
+            file_type = type.to_sym
+          end
+
+          opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
+            options[:f] = true
+          end
+
+          opts.on_tail("-h", "--help", "This message.") do
+            output.puts opts
+            options[:h] = true
+          end
+        end.order(args) do |v|
+          file_name = v
+        end
+
+        next if options[:h]
+
+        if !file_name
+          output.puts "Must provide a file name."
+          next
+        end
+
+        contents, normalized_start_line, _ = read_between_the_lines(file_name, start_line, end_line)
+
+        if Pry.color
+          contents = syntax_highlight_by_file_type_or_specified(contents, file_name, file_type)
+        end
+
+        set_file_and_dir_locals(file_name)
+        render_output(options[:f], options[:l] ? normalized_start_line + 1 : false, contents)
+        contents
+      end
+
+
+    end
+
+  end
+end
+