pry 0.10.2-i386-mingw32 → 1.0.0.pre1-i386-mingw32

data/lib/pry/helpers/command_helpers.rb

@@ -15,6 +15,14 @@ class Pry
         file.close(true) if file
       end
 
+      def render_output(str, opts={})
+        if opts[:flood]
+          output.puts str
+        else
+          stagger_output str
+        end
+      end
+
       def internal_binding?(target)
         m = target.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
@@ -141,16 +149,6 @@ class Pry
 
         Range.new(a, b)
       end
-
-      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
-
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
-      end
     end
-
   end
 end

data/lib/pry/helpers/documentation_helpers.rb

@@ -8,6 +8,7 @@ class Pry
       module_function
 
       def process_rdoc(comment)
+        return comment unless Pry.color
         comment = comment.dup
         comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
           gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
@@ -36,7 +37,7 @@ class Pry
         yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
                      "deprecate", "example", "raise"]
         (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
+          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
       end
 
       def process_comment_markup(comment)

data/lib/pry/helpers/text.rb

@@ -21,11 +21,11 @@ class Pry
 
         COLORS.each_pair do |color, value|
           define_method color do |text|
-            "\033[0;#{30+value}m#{text}\033[0m"
+            Pry.color ? "\033[0;#{30+value}m#{text}\033[0m" : text.to_s
           end
 
           define_method "bright_#{color}" do |text|
-            "\033[1;#{30+value}m#{text}\033[0m"
+            Pry.color ? "\033[1;#{30+value}m#{text}\033[0m" : text.to_s
           end
         end
 
@@ -38,11 +38,12 @@ class Pry
         end
 
         # Returns _text_ as bold text for use on a terminal.
+        # _Pry.color_ must be true for this method to perform any transformations.
         #
         # @param [String, #to_s] text
         # @return [String] _text_
         def bold(text)
-          "\e[1m#{text}\e[0m"
+          Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
         end
 
         # Returns `text` in the default foreground colour.
@@ -55,7 +56,7 @@ class Pry
         end
         alias_method :bright_default, :bold
 
-        # Executes the block with `Pry.config.color` set to false.
+        # Executes the block with `Pry.color` set to false.
         # @yield
         # @return [void]
         def no_color(&block)

data/lib/pry/history.rb

@@ -16,18 +16,10 @@ class Pry
 
     # Assign the default methods for loading, saving, pushing, and clearing.
     def restore_default_behavior
-      Pry.config.input # force Readline to load if applicable
-
-      @loader = method(:read_from_file)
-      @saver  = method(:save_to_file)
-
-      if defined?(Readline)
-        @pusher  = method(:push_to_readline)
-        @clearer = method(:clear_readline)
-      else
-        @pusher  = proc { }
-        @clearer = proc { }
-      end
+      @loader  = method(:read_from_file)
+      @saver   = method(:save_to_file)
+      @pusher  = method(:push_to_readline)
+      @clearer = method(:clear_readline)
     end
 
     # Load the input history using `History.loader`.
@@ -36,7 +28,6 @@ class Pry
       @loader.call do |line|
         @pusher.call(line.chomp)
         @history << line.chomp
-        @original_lines += 1
       end
     end
 
@@ -81,10 +72,10 @@ class Pry
 
     # The default loader. Yields lines from `Pry.history.config.file`.
     def read_from_file
-      path = history_file_path
+      filename = File.expand_path(Pry.config.history.file)
 
-      if File.exists?(path)
-        File.foreach(path) { |line| yield(line) }
+      if File.exists?(filename)
+        File.foreach(filename) { |line| yield(line) }
       end
     rescue => error
       warn "History file not loaded: #{error.message}"
@@ -111,17 +102,15 @@ class Pry
       if defined?(@history_file)
         @history_file
       else
-        @history_file = File.open(history_file_path, 'a', 0600).tap do |file|
-          file.sync = true
-        end
+        @history_file = File.open(file_path, 'a').tap { |f| f.sync = true }
       end
     rescue Errno::EACCES
       warn 'History not saved; unable to open your history file for writing.'
       @history_file = false
     end
 
-    def history_file_path
-      File.expand_path(@file_path || Pry.config.history.file)
+    def file_path
+      @file_path || Pry.config.history.file
     end
   end
 end

data/lib/pry/history_array.rb

@@ -89,11 +89,6 @@ class Pry
       ((@count - size)...@count).map { |n| @hash[n] }
     end
 
-    # Returns [Hash] copy of the internal @hash history
-    def to_h
-      @hash.dup
-    end
-
     def pop!
       @hash.delete @count - 1
       @count -= 1

data/lib/pry/hooks.rb

@@ -18,11 +18,11 @@ class Pry
     # @param [Hash] hash The hash to convert to `Pry::Hooks`.
     # @return [Pry::Hooks] The resulting `Pry::Hooks` instance.
     def self.from_hash(hash)
-      return hash if hash.instance_of?(self)
       instance = new
       hash.each do |k, v|
         instance.add_hook(k, nil, v)
       end
+
       instance
     end
 
@@ -49,6 +49,22 @@ class Pry
       @errors ||= []
     end
 
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    def [](event_name)
+      warn "`Pry.hooks[]` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+
+      get_hook(event_name, nil)
+    end
+
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    def []=(event_name, callable)
+      warn "`Pry.hooks[]=` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+
+      add_hook(event_name, nil, callable)
+    end
+
     # Destructively merge the contents of two `Pry:Hooks` instances.
     # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
     # @return [Pry:Hooks] Returns the receiver.
@@ -130,14 +146,18 @@ class Pry
     def exec_hook(event_name, *args, &block)
       @hooks[event_name] ||= []
 
-      @hooks[event_name].map do |hook_name, callable|
-        begin
-          callable.call(*args, &block)
-        rescue RescuableException => e
-          errors << e
-          e
-        end
-      end.last
+      # silence warnings to get rid of 1.8's "warning: multiple values
+      # for a block parameter" warnings
+      Pry::Helpers::BaseHelpers.silence_warnings do
+        @hooks[event_name].map do |hook_name, callable|
+          begin
+            callable.call(*args, &block)
+          rescue RescuableException => e
+            errors << e
+            e
+          end
+        end.last
+      end
     end
 
     # Return the number of hook functions registered for the `event_name` event.

data/lib/pry/indent.rb

@@ -94,8 +94,8 @@ class Pry
       indent = new
       lines = str.split("\n")
       n = line_number - 1
-      to_indent = lines[0...n] << (lines[n] || "").split("def").first(1)
-      indent.indent(to_indent.join("\n") << "\n")
+      to_indent = lines[0...n] + (lines[n] || "").split("def").first(1)
+      indent.indent(to_indent.join("\n") + "\n")
       indent.module_nesting
     end
 
@@ -320,7 +320,7 @@ class Pry
     # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ]
     #
     # A nil value in the @module_nesting array happens in two places: either
-    # when @awaiting_class is true and we're still waiting for the string to
+    # when @awaiting_token is true and we're still waiting for the string to
     # fill that space, or when a parse was rejected.
     #
     # At the moment this function is quite restricted about what formats it will
@@ -341,7 +341,7 @@ class Pry
           @module_nesting.last[1] = token if kind == :class
           @awaiting_class = false
         else
-          # leave @module_nesting[-1]
+          # leave @nesting[-1][
           @awaiting_class = false
         end
       end
@@ -384,7 +384,7 @@ class Pry
     # @return [String]
     def correct_indentation(prompt, code, overhang=0)
       prompt = prompt.delete("\001\002")
-      line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
+      line_to_measure = Pry::Helpers::Text.strip_color(prompt) + code
       whitespace = ' ' * overhang
 
       _, cols = Terminal.screen_size
@@ -402,5 +402,10 @@ class Pry
 
       "#{move_up}#{prompt}#{colorize_code(code)}#{whitespace}#{move_down}"
     end
+
+    # Given the current Pry environment, should we try to correct indentation?
+    def should_correct_indentation?
+      Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
+    end
   end
 end

data/lib/pry/method.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'pry/helpers/documentation_helpers'
 
 class Pry
@@ -18,10 +19,10 @@ class Pry
   class Method
     require 'pry/method/weird_method_locator'
     require 'pry/method/disowned'
-    require 'pry/method/patcher'
 
     extend Helpers::BaseHelpers
     include Helpers::BaseHelpers
+    include RbxMethod if rbx?
     include Helpers::DocumentationHelpers
     include CodeObject::Helpers
 
@@ -30,7 +31,8 @@ class Pry
       # search in, find and return the requested method wrapped in a `Pry::Method`
       # instance.
       #
-      # @param [String] name The name of the method to retrieve.
+      # @param [String, nil] name The name of the method to retrieve, or `nil` to
+      #   delegate to `from_binding` instead.
       # @param [Binding] target The context in which to search for the method.
       # @param [Hash] options
       # @option options [Boolean] :instance Look for an instance method if `name` doesn't
@@ -38,16 +40,13 @@ class Pry
       # @option options [Boolean] :methods Look for a bound/singleton method if `name` doesn't
       #   contain any context.
       # @return [Pry::Method, nil] A `Pry::Method` instance containing the requested
-      #   method, or `nil` if name is `nil` or no method could be located matching the parameters.
+      #   method, or `nil` if no method could be located matching the parameters.
       def from_str(name, target=TOPLEVEL_BINDING, options={})
         if name.nil?
-          nil
+          from_binding(target)
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
           context, meth_name = $1, $2
           from_module(target.eval(context), meth_name, target)
-        elsif name.to_s =~ /(.+)(\[\])\Z/
-          context, meth_name = $1, $2
-          from_obj(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
           context, meth_name = $1, $3
           from_obj(target.eval(context), meth_name, target)
@@ -140,34 +139,15 @@ class Pry
       # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
       def all_from_class(klass, include_super=true)
-        %w(public protected private).map do |visibility|
-          safe_send(klass, :"#{visibility}_instance_methods", include_super).map do |method_name|
-            new(safe_send(klass, :instance_method, method_name), :visibility => visibility.to_sym)
-          end
-        end.flatten(1)
+        all_from_common(klass, :instance_method, include_super)
       end
 
-      #
       # Get all of the methods on an `Object`
-      #
       # @param [Object] obj
-      #
-      # @param [Boolean] include_super
-      #   indicates whether or not to include methods from ancestors.
-      #
+      # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
-      #
       def all_from_obj(obj, include_super=true)
-        all_from_class(singleton_class_of(obj), include_super)
-      end
-
-      #
-      # @deprecated
-      #  please use {#all_from_obj} instead.
-      #  the `method_type` argument is ignored.
-      #
-      def all_from_common(obj, method_type = nil, include_super=true)
-        all_from_obj(obj, include_super)
+        all_from_common(obj, :method, include_super)
       end
 
       # Get every `Class` and `Module`, in order, that will be checked when looking
@@ -178,7 +158,7 @@ class Pry
         if Class === obj
           singleton_class_resolution_order(obj) + instance_resolution_order(Class)
         else
-          klass = singleton_class_of(obj) rescue obj.class
+          klass = singleton_class(obj) rescue obj.class
           instance_resolution_order(klass)
         end
       end
@@ -199,11 +179,26 @@ class Pry
       end
 
       def singleton_method_definition?(name, definition_line)
-        /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*self\.#{Regexp.escape(name)}/ =~ definition_line.strip
+        /^define_singleton_method\(?\s*[:\"\']#{name}|^def\s*self\.#{name}/ =~ definition_line.strip
       end
 
       def instance_method_definition?(name, definition_line)
-        /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*#{Regexp.escape(name)}/ =~ definition_line.strip
+        /^define_method\(?\s*[:\"\']#{name}|^def\s*#{name}/ =~ definition_line.strip
+      end
+
+      private
+
+      # See all_from_class and all_from_obj.
+      # If method_type is :instance_method, obj must be a `Class` or a `Module`
+      # If method_type is :method, obj can be any `Object`
+      #
+      # N.B. we pre-cache the visibility here to avoid O(N²) behaviour in "ls".
+      def all_from_common(obj, method_type, include_super=true)
+        %w(public protected private).map do |visibility|
+          safe_send(obj, :"#{visibility}_#{method_type}s", include_super).map do |method_name|
+            new(safe_send(obj, method_type, method_name), :visibility => visibility.to_sym)
+          end
+        end.flatten(1)
       end
 
       # Get the singleton classes of superclasses that could define methods on
@@ -211,21 +206,14 @@ class Pry
       # If a module is included at multiple points in the ancestry, only
       # the lowest copy will be returned.
       def singleton_class_resolution_order(klass)
-        ancestors = Pry::Method.safe_send(klass, :ancestors)
-        resolution_order = ancestors.grep(Class).map do |anc|
-          [singleton_class_of(anc), *singleton_class_of(anc).included_modules]
-        end.flatten(1)
+        resolution_order = Pry::Method.safe_send(klass, :ancestors).map do |anc|
+          [singleton_class(anc)] + singleton_class(anc).included_modules if anc.is_a?(Class)
+        end.compact.flatten(1)
 
         resolution_order.reverse.uniq.reverse - Class.included_modules
       end
 
-      def singleton_class_of(obj)
-        begin
-          class << obj; self; end
-        rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
-          obj.class
-        end
-      end
+      def singleton_class(obj); class << obj; self; end end
     end
 
     # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
@@ -275,18 +263,26 @@ class Pry
     def source
       @source ||= case source_type
                   when :c
-                    c_source
+                    info = pry_doc_info
+                    if info and info.source
+                      code = strip_comments_from_c_code(info.source)
+                    end
                   when :ruby
-                    ruby_source
+                    # clone of MethodSource.source_helper that knows to use our
+                    # hacked version of source_location for rbx core methods, and
+                    # our input buffer for methods defined in (pry)
+                    file, line = *source_location
+                    raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
+
+                    begin
+                      code = Pry::Code.from_file(file).expression_at(line)
+                    rescue SyntaxError => e
+                      raise MethodSource::SourceNotFoundError.new(e.message)
+                    end
+                    strip_leading_whitespace(code)
                   end
     end
 
-    # Update the live copy of the method's source.
-    def redefine(source)
-      Patcher.new(self).patch_in_ram source
-      Pry::Method(owner.instance_method(name))
-    end
-
     # Can we get the source code for this method?
     # @return [Boolean]
     def source?
@@ -297,13 +293,20 @@ class Pry
 
     # @return [String, nil] The documentation for the method, or `nil` if it's
     #   unavailable.
+    # @raise [CommandError] Raises when the method was defined in the REPL.
     def doc
       @doc ||= case source_type
         when :c
           info = pry_doc_info
           info.docstring if info
         when :ruby
-          get_comment_content(comment)
+          if rbx? && !pry_method?
+            get_comment_content(core_doc)
+          elsif pry_method?
+            get_comment_content(doc_for_pry_method)
+          else
+            get_comment_content(@method.comment)
+          end
         end
     end
 
@@ -313,6 +316,15 @@ class Pry
       source_location.nil? ? :c : :ruby
     end
 
+    def source_location
+      if @method.source_location && rbx?
+        file, line = @method.source_location
+        [RbxPath.convert_path_to_full(file), line]
+      else
+        @method.source_location
+      end
+    end
+
     # @return [String, nil] The name of the file the method is defined in, or
     #   `nil` if the filename is unavailable.
     def source_file
@@ -422,14 +434,15 @@ class Pry
     end
 
     # @return [Array<String>] All known aliases for the method.
+    # @note On Ruby 1.8 this method always returns an empty Array for methods
+    #   implemented in C.
     def aliases
       owner = @method.owner
       # Avoid using `to_sym` on {Method#name}, which returns a `String`, because
       # it won't be garbage collected.
       name = @method.name
 
-      all_methods_to_compare = owner.instance_methods | owner.private_instance_methods
-      alias_list = all_methods_to_compare.combination(2).select do |pair|
+      alias_list = owner.instance_methods.combination(2).select do |pair|
         pair.include?(name) &&
           owner.instance_method(pair.first) == owner.instance_method(pair.last)
       end.flatten
@@ -470,10 +483,6 @@ class Pry
       @method.send(method_name, *args, &block)
     end
 
-    def comment
-      Pry::Code.from_file(source_file).comment_describing(source_line)
-    end
-
     private
 
     # @return [YARD::CodeObjects::MethodObject]
@@ -483,13 +492,31 @@ class Pry
         Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
       else
         fail_msg = "Cannot locate this method: #{name}."
-        if mri?
+        if mri_18? || mri_19?
           fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
         end
         raise CommandError, fail_msg
       end
     end
 
+    # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
+    def doc_for_pry_method
+      _, line_num = source_location
+
+      buffer = ""
+      Pry.line_buffer[0..(line_num - 1)].each do |line|
+        # Add any line that is a valid ruby comment,
+        # but clear as soon as we hit a non comment line.
+        if (line =~ /^\s*#/) || (line =~ /^\s*$/)
+          buffer << line.lstrip
+        else
+          buffer.replace("")
+        end
+      end
+
+      buffer
+    end
+
     # @param [Class, Module] ancestors The ancestors to investigate
     # @return [Method] The unwrapped super-method
     def super_using_ancestors(ancestors, times=1)
@@ -520,27 +547,5 @@ class Pry
 
       nil
     end
-
-    def c_source
-      info = pry_doc_info
-      if info and info.source
-        strip_comments_from_c_code(info.source)
-      end
-    end
-
-    def ruby_source
-      # clone of MethodSource.source_helper that knows to use our
-      # hacked version of source_location for rbx core methods, and
-      # our input buffer for methods defined in (pry)
-      file, line = *source_location
-      raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
-
-      begin
-        code = Pry::Code.from_file(file).expression_at(line)
-      rescue SyntaxError => e
-        raise MethodSource::SourceNotFoundError.new(e.message)
-      end
-      strip_leading_whitespace(code)
-    end
   end
 end