pry 0.8.4pre1-i386-mingw32 → 0.9.0-i386-mingw32

data/lib/pry/default_commands/ls.rb

@@ -1,7 +1,17 @@
 class Pry
   module DefaultCommands
 
-    Ls = Pry::CommandSet.new :ls do
+    Ls = Pry::CommandSet.new do
+
+      helpers do
+        def trim_methods(options, visibility)
+          if options[:e]
+            []
+          else
+            Object.send("#{visibility}_methods")
+          end
+        end
+      end
 
       command "ls", "Show the list of vars and methods in the current scope. Type `ls --help` for more info." do |*args|
         options = {}
@@ -59,10 +69,14 @@ Shows local and instance variables by default.
             options[:j] = true
           end
 
-          opts.on("-s", "--super", "Include superclass entries (relevant to constant and methods options).") do
+          opts.on("-s", "--super", "Include superclass entries excluding Object (relevant to constant and methods options).") do
             options[:s] = true
           end
 
+          opts.on("-e", "--everything", "Include superclass entries including Object (relevant to constant and methods options).") do
+            options[:e] = true
+          end
+
           opts.on("-a", "--all", "Display all types of entries.") do
             options[:a] = true
           end
@@ -126,19 +140,19 @@ Shows local and instance variables by default.
 
                               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["public methods"] = [Array(target.eval("public_methods(#{options[:s]})")).uniq.sort - trim_methods(options, :public), 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["protected methods"] = [Array(target.eval("protected_methods(#{options[:s]})")).sort - trim_methods(options, :protected), 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["private methods"] = [Array(target.eval("private_methods(#{options[:s]})")).sort - trim_methods(options, :private), 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["public instance methods"] = [Array(target.eval("public_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(options, :public), 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["protected instance methods"] = [Array(target.eval("protected_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(options, :protected), 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])
+                              info["private instance methods"] = [Array(target.eval("private_instance_methods(#{options[:s]})")).uniq.sort - trim_methods(options, :private), 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]
@@ -180,9 +194,9 @@ Shows local and instance variables by default.
                                 list = list.grep(options[:grep]) if list
                                 list.uniq! if list
                                 if Pry.color
-                                  text << CodeRay.scan(Pry.view(list), :ruby).term + "\n"
+                                  text << CodeRay.scan(list.inspect, :ruby).term + "\n"
                                 else
-                                  text <<  Pry.view(list) + "\n"
+                                  text <<  list.inspect + "\n"
                                 end
                                 if !options[:f]
                                   stagger_output(text)
@@ -194,6 +208,6 @@ Shows local and instance variables by default.
                             end
 
 
-      end
     end
   end
+end

data/lib/pry/default_commands/shell.rb

@@ -1,10 +1,22 @@
 class Pry
   module DefaultCommands
 
-    Shell = Pry::CommandSet.new :shell do
+    Shell = Pry::CommandSet.new do
+
+      command(/\.(.*)/, "All text following a '.' is forwarded to the shell.", :listing => ".<shell command>") do |cmd|
+        if cmd =~ /^cd\s+(.+)/i
+          dest = $1
+          begin
+            Dir.chdir File.expand_path(dest)
+          rescue Errno::ENOENT
+            output.puts "No such directory: #{dest}"
+          end
 
-      # this cannot be accessed, it's just for help purposes.
-      command ".<shell command>", "All text following a '.' is forwarded to the shell." do
+        else
+          if !system(cmd)
+            output.puts "Error: there was a problem executing system command: #{cmd}"
+          end
+        end
       end
 
       command "shell-mode", "Toggle shell mode. Bring in pwd prompt and file completion." do
@@ -22,50 +34,30 @@ class Pry
 
       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
+        opts = Slop.parse!(args) do |opt|
+          opt.on :s, :start, "Start line (defaults to start of file)Line 1 is the first line.", true, :as => Integer do |line|
+            start_line = line - 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
+          opt.on :e, :end, "End line (defaults to end of file). Line -1 is the last line", true, :as => Integer do |line|
+            end_line = line - 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
+          opt.on :l, "line-numbers", "Show line numbers."
+          opt.on :t, :type, "The specific file type for syntax higlighting (e.g ruby, python)", true, :as => Symbol
+          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+          opt.on :h, :help, "This message." do
+            output.puts opt
           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]
+        next if opts.help?
 
+        file_name = args.shift
         if !file_name
           output.puts "Must provide a file name."
           next
@@ -74,15 +66,13 @@ e.g: cat hello.rb
         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)
+          contents = syntax_highlight_by_file_type_or_specified(contents, file_name, opts[:type])
         end
 
         set_file_and_dir_locals(file_name)
-        render_output(options[:f], options[:l] ? normalized_start_line + 1 : false, contents)
+        render_output(opts.flood?, opts.l? ? normalized_start_line + 1 : false, contents)
         contents
       end
-
-
     end
 
   end

data/lib/pry/extended_commands/experimental.rb

@@ -0,0 +1,17 @@
+class Pry
+  module ExtendedCommands
+
+    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.reload
+      end
+
+    end
+  end
+end

data/lib/pry/extended_commands/user_command_api.rb

@@ -0,0 +1,22 @@
+class Pry
+  module ExtendedCommands
+
+    UserCommandAPI = Pry::CommandSet.new do
+
+      command "define-command", "Define a command in the session, use same syntax as `command` method for command API" do |arg|
+        next output.puts("Provide an arg!") if arg.nil?
+
+        prime_string = "command #{arg_string}\n"
+        command_string = Pry.active_instance.r(target, prime_string)
+
+        eval_string.replace <<-HERE
+          _pry_.commands.instance_eval do
+            #{command_string}
+          end
+        HERE
+
+      end
+
+    end
+  end
+end

data/lib/pry/helpers.rb

@@ -1,2 +1,3 @@
 require "pry/helpers/base_helpers"
 require "pry/helpers/command_helpers"
+require "pry/helpers/text"

data/lib/pry/helpers/base_helpers.rb

@@ -14,18 +14,16 @@ class Pry
         end
       end
 
-      # turn off color for duration of block
-      def no_color(&block)
-        old_color_state = Pry.color
-        Pry.color = false
-        yield
-      ensure
-        Pry.color = old_color_state
+      def find_command(name)
+        command_match = commands.find { |_, command| command.options[:listing] == name }
+
+        return command_match.last if command_match
+        nil
       end
 
       def gem_installed?(gem_name)
         require 'rubygems'
-        !!Gem.source_index.find_name(gem_name).first
+        Gem::Specification.respond_to?(:find_all_by_name) ? !Gem::Specification.find_all_by_name(gem_name).empty? : Gem.source_index.find_name(gem_name).first
       end
 
       def command_dependencies_met?(options)
@@ -47,8 +45,10 @@ class Pry
         gems_needed = Array(options[:requires_gem])
         gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
         proc do
-          output.puts "\n#{name} requires the following gems to be installed: #{(gems_needed.join(", "))}"
+          output.puts "\nThe command '#{name}' requires the following gems to be installed: #{(gems_needed.join(", "))}"
+          output.puts "-"
           output.puts "Command not available due to dependency on gems: `#{gems_not_installed.join(", ")}` not being met."
+          output.puts "-"
           output.puts "Type `install #{name}` to install the required gems and activate this command."
         end
       end
@@ -63,101 +63,12 @@ class Pry
         end
       end
 
-      #
-      # Color helpers:
-      #   gray, red, green, yellow, blue, purple, cyan, white,
-      #   and bright_red, bright_green, etc...
-      #
-      # ANSI color codes:
-      #   \033 => escape
-      #     30 => color base
-      #      1 => bright
-      #      0 => normal
-      #
-
-      COLORS = {
-        "black" => 0,
-        "red" => 1,
-        "green" => 2,
-        "yellow" => 3,
-        "blue" => 4,
-        "purple" => 5,
-        "magenta" => 5,
-        "cyan" => 6,
-        "white" => 7
-      }
-
-      COLORS.each do |color, i|
-        define_method color do |str|
-          Pry.color ? "\033[0;#{30+i}m#{str}\033[0m" : str
-        end
-
-        define_method "bright_#{color}" do |str|
-          Pry.color ? "\033[1;#{30+i}m#{str}\033[0m" : str
-        end
-      end
-
-      alias_method :grey, :bright_black
-      alias_method :gray, :bright_black
-
-      require 'set'
-      VALID_COLORS = Set.new(
-                             COLORS.keys +
-                             COLORS.keys.map{|k| "bright_#{k}" } +
-                             ["grey", "gray"]
-                             )
-
-      def bold(text)
-        Pry.color ? "\e[1m#{text}\e[0m" : text
-      end
-
-      #
-      # Colorize a string that has "color tags".
-      #
-      # Examples:
-      #    puts colorize("<light_green><magenta>*</magenta> Hey mom! I am <light_blue>SO</light_blue> colored right now.</light_green>")
-      #
-      def colorize(string)
-        stack = []
-
-        # split the string into tags and literal strings
-        tokens          = string.split(/(<\/?[\w\d_]+>)/)
-        tokens.delete_if { |token| token.size == 0 }
-
-        result        = ""
-
-        tokens.each do |token|
-
-          # token is an opening tag!
-
-          if /<([\w\d_]+)>/ =~ token and VALID_COLORS.include?($1) #valid_tag?($1)
-            stack.push $1
-
-            # token is a closing tag!
-
-          elsif /<\/([\w\d_]+)>/ =~ token and VALID_COLORS.include?($1) # valid_tag?($1)
-
-            # if this color is on the stack somwehere...
-            if pos = stack.rindex($1)
-              # close the tag by removing it from the stack
-              stack.delete_at pos
-            else
-              raise "Error: tried to close an unopened color tag -- #{token}"
-            end
-
-            # token is a literal string!
-
-          else
-
-            color = (stack.last || "white")
-            #color = BBS_COLOR_TABLE[color.to_i] if color =~ /^\d+$/
-            result << send(color, token) # colorize the result
-
-          end
-
+      def colorize_code(code)
+        if Pry.color
+          CodeRay.scan(code, :ruby).term
+        else
+          code
         end
-
-        result
       end
 
       def highlight(string, regexp, highlight_color=:bright_yellow)
@@ -190,7 +101,7 @@ class Pry
       # Try to use `less` for paging, if it fails then use
       # simple_pager. Also do not page if Pry.pager is falsey
       # FIXME! Another JRuby hack
-      def stagger_output(text)
+      def stagger_output(text, output=output())
         if text.lines.count < page_size || !Pry.pager
           output.puts text
           return

data/lib/pry/helpers/command_helpers.rb

@@ -5,15 +5,6 @@ class Pry
 
       module_function
 
-      def try_to_load_pry_doc
-
-        # YARD crashes on rbx, so do not require it
-        if !Object.const_defined?(:RUBY_ENGINE) || RUBY_ENGINE !~ /rbx/
-          require "pry-doc"
-        end
-      rescue LoadError
-      end
-
       def meth_name_from_binding(b)
         meth_name = b.eval('__method__')
         if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
@@ -23,29 +14,16 @@ class Pry
         end
       end
 
-      def add_line_numbers(lines, start_line)
-        line_array = lines.each_line.to_a
-        line_array.each_with_index.map do |line, idx|
-          adjusted_index = idx + start_line
-          if Pry.color
-            cindex = CodeRay.scan("#{adjusted_index}", :ruby).term
-            "#{cindex}: #{line}"
-          else
-            "#{idx}: #{line}"
-          end
-        end.join
-      end
-
       # if start_line is not false then add line numbers starting with start_line
-      def render_output(should_flood, start_line, doc)
+      def render_output(should_flood, start_line, text)
         if start_line
-          doc = add_line_numbers(doc, start_line)
+          text = Pry::Helpers::Text.with_line_numbers text, start_line
         end
 
         if should_flood
-          output.puts doc
+          output.puts text
         else
-          stagger_output(doc)
+          stagger_output(text)
         end
       end
 
@@ -55,31 +33,74 @@ class Pry
       end
 
       def check_for_dynamically_defined_method(meth)
-        if is_a_dynamically_defined_method?(meth)
+        file, _ = meth.source_location
+        if file =~ /(\(.*\))|<.*>/ && file != Pry.eval_path
           raise "Cannot retrieve source for dynamically defined method."
         end
       end
 
-      def check_for_dynamically_defined_method(meth)
-        file, _ = meth.source_location
-        if file =~ /(\(.*\))|<.*>/
-          raise "Cannot retrieve source for dynamically defined method."
+      ########### RBX HELPERS #############
+      def rbx_core?(meth)
+        defined?(RUBY_ENGINE) &&
+          RUBY_ENGINE =~ /rbx/ &&
+          meth.source_location &&
+          meth.source_location.first.start_with?("kernel")
+      end
+
+      def rvm_ruby?(path)
+        !!(path =~ /\.rvm/)
+      end
+
+      def rbx_core_code_for(meth)
+        rbx_core_code_or_doc_for(meth, :code)
+      end
+
+      def rbx_core_doc_for(meth)
+        rbx_core_code_or_doc_for(meth, :doc)
+      end
+
+      def rbx_core_code_or_doc_for(meth, code_or_doc)
+        path_line = rbx_core_path_line_for(meth)
+
+        case code_or_doc
+        when :code
+          MethodSource.source_helper(path_line)
+        when :doc
+          MethodSource.comment_helper(path_line)
         end
       end
 
-      def remove_first_word(text)
-        text.split.drop(1).join(' ')
+      def rbx_core_path_line_for(meth)
+        if rvm_ruby?(Rubinius::BIN_PATH)
+          rvm_rbx_core_path_line_for(meth)
+        else
+          std_rbx_core_path_line_for(meth)
+        end
       end
 
-      # turn off color for duration of block
-      def no_color(&block)
-        old_color_state = Pry.color
-        Pry.color = false
-        yield
-      ensure
-        Pry.color = old_color_state
+      def std_rbx_core_path_line_for(meth)
+        file_name = File.join(Rubinius::BIN_PATH, "..", meth.source_location.first)
+        raise "Cannot find rbx core source" if !File.exists?(file_name)
+
+        start_line = meth.source_location.last
+
+        [file_name, start_line]
       end
 
+      def rvm_rbx_core_path_line_for(meth)
+        ruby_name = File.dirname(Rubinius::BIN_PATH).split("/").last
+        source_path = File.join(File.dirname(File.dirname(File.dirname(Rubinius::BIN_PATH))),  "src", ruby_name)
+
+        file_name = File.join(source_path, meth.source_location.first)
+        raise "Cannot find rbx core source" if !File.exists?(file_name)
+
+        start_line = meth.source_location.last
+
+        [file_name, start_line]
+      end
+
+      ######### END RBX HELPERS ###############
+
       def code_and_code_type_for(meth)
         case code_type = code_type_for(meth)
         when nil
@@ -88,8 +109,18 @@ class Pry
           code = Pry::MethodInfo.info_for(meth).source
           code = strip_comments_from_c_code(code)
         when :ruby
-          code = strip_leading_whitespace(meth.source)
-          set_file_and_dir_locals(meth.source_location.first)
+          if meth.source_location.first == Pry.eval_path
+            start_line = meth.source_location.last
+            p = Pry.new(:input => StringIO.new(Pry.line_buffer[start_line..-1].join)).r(target)
+            code = strip_leading_whitespace(p)
+          else
+            if rbx_core?(meth)
+              code = strip_leading_whitespace(rbx_core_code_for(meth))
+            else
+              code = strip_leading_whitespace(meth.source)
+            end
+          end
+          set_file_and_dir_locals(path_line_for(meth).first)
         end
 
         [code, code_type]
@@ -102,9 +133,12 @@ class Pry
         when :c
           doc = Pry::MethodInfo.info_for(meth).docstring
         when :ruby
-          doc = meth.comment
-          doc = strip_leading_hash_and_whitespace_from_ruby_comments(doc)
-          set_file_and_dir_locals(meth.source_location.first)
+          if rbx_core?(meth)
+            doc = strip_leading_hash_and_whitespace_from_ruby_comments(rbx_core_doc_for(meth))
+          else
+            doc = strip_leading_hash_and_whitespace_from_ruby_comments(meth.comment)
+          end
+          set_file_and_dir_locals(path_line_for(meth).first)
         end
 
         [doc, code_type]
@@ -144,15 +178,23 @@ class Pry
         end
       end
 
+      def path_line_for(meth)
+        if rbx_core?(meth)
+          rbx_core_path_line_for(meth)
+        else
+          meth.source_location
+        end
+      end
+
       def make_header(meth, code_type, content)
-        num_lines = "Number of lines: #{bold(content.each_line.count.to_s)}"
+        num_lines = "Number of lines: #{Pry::Helpers::Text.bold(content.each_line.count.to_s)}"
         case code_type
         when :ruby
-          file, line = meth.source_location
-          "\n#{bold('From:')} #{file} @ line #{line}:\n#{num_lines}\n\n"
+          file, line = path_line_for(meth)
+          "\n#{Pry::Helpers::Text.bold('From:')} #{file} @ line #{line}:\n#{num_lines}\n\n"
         else
           file = Pry::MethodInfo.info_for(meth).file
-          "\n#{bold('From:')} #{file} in Ruby Core (C Method):\n#{num_lines}\n\n"
+          "\n#{Pry::Helpers::Text.bold('From:')} #{file} in Ruby Core (C Method):\n#{num_lines}\n\n"
         end
       end
 
@@ -161,7 +203,7 @@ class Pry
       end
 
       def should_use_pry_doc?(meth)
-        Pry.has_pry_doc && is_a_c_method?(meth)
+        Pry.config.has_pry_doc && is_a_c_method?(meth)
       end
 
       def code_type_for(meth)
@@ -232,16 +274,11 @@ class Pry
          normalized_line_number(end_line, lines_array.size)]
       end
 
-      # documentation related helpers
-      def strip_color_codes(str)
-        str.gsub(/\e\[.*?(\d)+m/, '')
-      end
-
       def process_rdoc(comment, code_type)
         comment = comment.dup
         comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
-          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { Pry.color ? "\e[32m#{$1}\e[0m": $1 }.
-          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { Pry.color ? "\e[34m#{$1}\e[0m" : $1 }.
+          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { Pry.color ? "\e[1m#{$1}\e[0m": $1 }.
+          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { Pry.color ? "\e[1m#{$1}\e[0m" : $1 }.
           gsub(/\B\+(\w*?)\+\B/)  { Pry.color ? "\e[32m#{$1}\e[0m": $1 }.
           gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
           gsub(/`(?:\s*\n)?(.*?)\s*`/) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }
@@ -251,7 +288,7 @@ class Pry
         in_tag_block = nil
         output = comment.lines.map do |v|
           if in_tag_block && v !~ /^\S/
-            strip_color_codes(strip_color_codes(v))
+            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
           elsif in_tag_block
             in_tag_block = false
             v
@@ -288,7 +325,7 @@ class Pry
       end
 
       def strip_comments_from_c_code(code)
-        code.sub /\A\s*\/\*.*?\*\/\s*/m, ''
+        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
       end
 
       def prompt(message, options="Yn")