pry 0.9.6-i386-mingw32 → 0.9.6.1-i386-mingw32

data/lib/pry/default_commands/shell.rb

@@ -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

data/lib/pry/extended_commands/experimental.rb

@@ -4,12 +4,8 @@ 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.reload
+        meth = get_method_or_print_error(meth_name, target, {}, :no_cmd)
+        meth.reload if meth
       end
     end
   end

data/lib/pry/helpers/base_helpers.rb

@@ -35,7 +35,7 @@ class Pry
       end
 
       def set_file_and_dir_locals(file_name)
-        return if !target
+        return if !target or !file_name
         _pry_.last_file = File.expand_path(file_name)
         _pry_.inject_local("_file_", _pry_.last_file, target)
 

data/lib/pry/helpers/command_helpers.rb

@@ -5,15 +5,6 @@ class Pry
 
       module_function
 
-      def meth_name_from_binding(b)
-        meth_name = b.eval('__method__')
-        if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
-          nil
-        else
-          meth_name
-        end
-      end
-
       # if start_line is not false then add line numbers starting with start_line
       def render_output(should_flood, start_line, text, color=:blue)
         if start_line
@@ -27,18 +18,6 @@ class Pry
         end
       end
 
-      def is_a_dynamically_defined_method?(meth)
-        file, _ = meth.source_location
-        !!(file =~ /(\(.*\))|<.*>/)
-      end
-
-      def check_for_dynamically_defined_method(meth)
-        file, _ = meth.source_location
-        if file =~ /(\(.*\))|<.*>/ && file != Pry.eval_path
-          raise "Cannot retrieve source for dynamically defined method."
-        end
-      end
-
       # Open a temp file and yield it to the block, closing it after
       # @return [String] The path of the temp file
       def temp_file
@@ -48,225 +27,28 @@ class Pry
         file.close
       end
 
-      ########### RBX HELPERS #############
-      def is_core_rbx_path?(path)
-        rbx? &&
-          path.start_with?("kernel")
-      end
-
-      def rbx_core?(meth)
-          meth.source_location &&
-          is_core_rbx_path?(meth.source_location.first)
-      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 rbx_convert_path_to_full(path)
-        if rvm_ruby?(Rubinius::BIN_PATH)
-          rbx_rvm_convert_path_to_full(path)
-        else
-          rbx_std_convert_path_to_full(path)
-        end
-      end
-
-      def rbx_rvm_convert_path_to_full(path)
-          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, path)
-        raise "Cannot find rbx core source" if !File.exists?(file_name)
-        file_name
-      end
-
-      def rbx_std_convert_path_to_full(path)
-        file_name = File.join(Rubinius::BIN_PATH, "..", path)
-        raise "Cannot find rbx core source" if !File.exists?(file_name)
-        file_name
-      end
-
-      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
-
-      def std_rbx_core_path_line_for(meth)
-        file_name  = rbx_std_convert_path_to_full(meth.source_location.first)
-        start_line = meth.source_location.last
-
-        [file_name, start_line]
-      end
-
-      def rvm_rbx_core_path_line_for(meth)
-        file_name  = rbx_rvm_convert_path_to_full(meth.source_location.first)
-        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
-          return nil
-        when :c
-          code = Pry::MethodInfo.info_for(meth).source
-          code = strip_comments_from_c_code(code)
-        when :ruby
-          if meth.source_location.first == Pry.eval_path
-            start_line = meth.source_location.last
-
-            # FIXME this line below needs to be refactored, WAY too
-            # much of a hack. We pass nothing to prompt because if
-            # prompt uses #inspect (or #pretty_inspect) on the context
-            # it can hang the session if the object being inspected on
-            # is enormous see: https://github.com/pry/pry/issues/245
-            p = Pry.new(:input => StringIO.new(Pry.line_buffer[start_line..-1].join), :prompt => proc {""}, :hooks => {}).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]
-      end
-
-      def doc_and_code_type_for(meth)
-        case code_type = code_type_for(meth)
-        when nil
-          return nil
-        when :c
-          doc = Pry::MethodInfo.info_for(meth).docstring
-        when :ruby
-          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]
-      end
-
-      def get_method_object(meth_name, target=nil, options={})
-        get_method_object_from_target(*get_method_attributes(meth_name, target, options)) rescue nil
-      end
-
-      def get_method_attributes(meth_name, target=nil, options={})
-        if meth_name
-          if meth_name =~ /(\S+)\#(\S+)\Z/
-            context, meth_name = $1, $2
-            target = Pry.binding_for(target.eval(context))
-            type = :instance
-          elsif meth_name =~ /(\S+)\.(\S+)\Z/
-            context, meth_name = $1, $2
-            target = Pry.binding_for(target.eval(context))
-            type = :singleton
-          elsif options["instance_methods"]
-            type = :instance
-          elsif options[:methods]
-            type = :singleton
-          else
-            type = nil
-          end
+      def get_method_or_print_error(name, target, opts={}, omit_cmd=false)
+        if (meth = Pry::Method.from_str(name, target, opts))
+          set_file_and_dir_locals(meth.source_file)
+          meth
         else
-          meth_name = meth_name_from_binding(target)
-          type = nil
+          # FIXME: better/more accurate error handling
+          output.print "Invalid method name: #{name}."
+          output.print " Type `#{command_name} --help` for help." unless omit_cmd
+          output.puts
         end
-        [meth_name, target, type]
       end
 
-      def get_method_object_from_target(meth_name, target, type=nil)
-        case type
-        when :instance
-          target.eval("instance_method(:#{meth_name})") rescue nil
-        when :singleton
-          target.eval("method(:#{meth_name})") rescue nil
-        else
-          get_method_object_from_target(meth_name, target, :instance) ||
-            get_method_object_from_target(meth_name, target, :singleton)
-        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)
+      def make_header(meth, content=meth.source)
+        code_type = meth.source_type
         num_lines = "Number of lines: #{Pry::Helpers::Text.bold(content.each_line.count.to_s)}"
         case code_type
-        when :ruby
-          file, line = path_line_for(meth)
-          "\n#{Pry::Helpers::Text.bold('From:')} #{file} @ line #{line}:\n#{num_lines}\n\n"
-        else
+        when :c
           file = Pry::MethodInfo.info_for(meth).file
           "\n#{Pry::Helpers::Text.bold('From:')} #{file} in Ruby Core (C Method):\n#{num_lines}\n\n"
         end
       end
 
-      def is_a_c_method?(meth)
-        meth.source_location.nil?
-      end
-
-      def should_use_pry_doc?(meth)
-        Pry.config.has_pry_doc && is_a_c_method?(meth)
-      end
-
-      def code_type_for(meth)
-        # only C methods
-        if should_use_pry_doc?(meth)
-          info = Pry::MethodInfo.info_for(meth)
-          if info && info.source
-            code_type = :c
-          else
-            output.puts "Cannot find C method: #{meth.name}"
-            code_type = nil
-          end
-        else
-          if is_a_c_method?(meth)
-            output.puts "Cannot locate this method: #{meth.name}. Try `gem install pry-doc` to get access to Ruby Core documentation."
-            code_type = nil
-          else
-            check_for_dynamically_defined_method(meth)
-            code_type = :ruby
-          end
-        end
-        code_type
-      end
-
       def file_map
         {
           [".c", ".h"] => :c,
@@ -357,24 +139,6 @@ class Pry
         process_yardoc process_rdoc(comment, code_type)
       end
 
-      # strip leading whitespace but preserve indentation
-      def strip_leading_whitespace(text)
-        return text if text.empty?
-        leading_spaces = text.lines.first[/^(\s+)/, 1]
-        text.gsub(/^#{leading_spaces}/, '')
-      end
-
-      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
-        comment = comment.dup
-        comment.gsub!(/\A\#+?$/, '')
-        comment.gsub!(/^\s*#/, '')
-        strip_leading_whitespace(comment)
-      end
-
-      def strip_comments_from_c_code(code)
-        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
-      end
-
       def invoke_editor(file, line)
         if Pry.config.editor.respond_to?(:call)
           editor_invocation = Pry.config.editor.call(file, line)

data/lib/pry/method.rb

@@ -0,0 +1,184 @@
+class Pry
+  class Method
+    include RbxMethod if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+
+    class << self
+      def from_str(str, target=TOPLEVEL_BINDING, options={})
+        if str.nil?
+          from_binding(target)
+        elsif str.to_s =~ /(\S+)\#(\S+)\Z/
+          context, meth_name = $1, $2
+          from_module(target.eval(context), meth_name)
+        elsif str.to_s =~ /(\S+)\.(\S+)\Z/
+          context, meth_name = $1, $2
+          from_obj(target.eval(context), meth_name)
+        elsif options[:instance]
+          new(target.eval("instance_method(:#{str})")) rescue nil
+        elsif options[:methods]
+          new(target.eval("method(:#{str})")) rescue nil
+        else
+          from_str(str, target, :instance => true) ||
+            from_str(str, target, :methods => true)
+        end
+      end
+
+      def from_binding(b)
+        meth_name = b.eval('__method__')
+        if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
+          nil
+        else
+          new(b.eval("method(:#{meth_name})"))
+        end
+      end
+
+      def from_module(nodule, name)
+        new(nodule.instance_method(name)) rescue nil
+      end
+      alias from_class from_module
+
+      def from_obj(obj, name)
+        new(obj.method(name)) rescue nil
+      end
+    end
+
+    def initialize(method)
+      @method = method
+    end
+
+    def source
+      @source ||= case source_type
+        when :c
+          info = pry_doc_info
+          if info and info.source
+            code = strip_comments_from_c_code(info.source)
+          end
+        when :rbx
+          strip_leading_whitespace(core_code)
+        when :ruby
+          if pry_method?
+            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => {}).r
+          else
+            code = @method.source
+          end
+          strip_leading_whitespace(code)
+        end
+    end
+
+    def doc
+      @doc ||= case source_type
+        when :c
+          info = pry_doc_info
+          info.docstring if info
+        when :rbx
+          strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
+        when :ruby
+          if pry_method?
+            raise "Error: Can't view doc for a REPL-defined method."
+          else
+            strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
+          end
+        end
+    end
+
+    def source_type
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+        if core? then :rbx else :ruby end
+      else
+        if source_location.nil? then :c else :ruby end
+      end
+    end
+
+    def source_file
+      source_location.nil? ? nil : source_location.first
+    end
+
+    def source_line
+      source_location.nil? ? nil : source_location.last
+    end
+
+    def visibility
+      if owner.public_instance_methods.include?(name)
+        :public
+      elsif owner.protected_instance_methods.include?(name)
+        :protected
+      elsif owner.private_instance_methods.include?(name)
+        :private
+      else
+        :none
+      end
+    end
+
+    # paraphrased from awesome_print gem
+    def signature
+      if respond_to?(:parameters)
+        args = parameters.inject([]) do |arr, (type, name)|
+          name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
+          arr << case type
+                 when :req        then name.to_s
+                 when :opt, :rest then "*#{name}"
+                 when :block      then "&#{name}"
+                 else '?'
+                 end
+        end
+      else
+        args = (1..arity.abs).map { |i| "arg#{i}" }
+        args[-1] = "*#{args[-1]}" if arity < 0
+      end
+
+      "#{name}(#{args.join(', ')})"
+    end
+
+    def dynamically_defined?
+      source_file ? !!(source_file =~ /(\(.*\))|<.*>/) : nil
+    end
+
+    def pry_method?
+      source_file == Pry.eval_path
+    end
+
+    def ==(obj)
+      if obj.is_a? Pry::Method
+        super
+      else
+        @method == obj
+      end
+    end
+
+    def is_a?(klass)
+      klass == Pry::Method or @method.is_a?(klass)
+    end
+    alias kind_of? is_a?
+
+    def respond_to?(method_name)
+      super or @method.respond_to?(method_name)
+    end
+
+    def method_missing(method_name, *args, &block)
+      @method.send(method_name, *args, &block)
+    end
+
+    private
+      def pry_doc_info
+        if Pry.config.has_pry_doc
+          Pry::MethodInfo.info_for(@method) or output.puts "Cannot find C method: #{name}"
+        else
+          output.puts "Cannot locate this method: #{name}. Try `gem install pry-doc` to get access to Ruby Core documentation."
+        end
+      end
+
+      def strip_comments_from_c_code(code)
+        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+      end
+
+      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
+        comment = comment.dup
+        comment.gsub!(/\A\#+?$/, '')
+        comment.gsub!(/^\s*#/, '')
+        strip_leading_whitespace(comment)
+      end
+
+      def strip_leading_whitespace(text)
+        Pry::Helpers::CommandHelpers.unindent(text)
+      end
+  end
+end