pry 0.9.10pre1-i386-mingw32 → 0.9.11-i386-mingw32

data/lib/pry/helpers.rb

@@ -2,3 +2,4 @@ require "pry/helpers/base_helpers"
 require "pry/helpers/options_helpers"
 require "pry/helpers/command_helpers"
 require "pry/helpers/text"
+require "pry/helpers/table"

data/lib/pry/helpers/base_helpers.rb

@@ -15,16 +15,20 @@ class Pry
         end
       end
 
-      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::Specification.respond_to?(:find_all_by_name) ? !Gem::Specification.find_all_by_name(gem_name).empty? : Gem.source_index.find_name(gem_name).first
+      # Acts like send but ignores any methods defined below Object or Class in the
+      # inheritance hierarchy.
+      # This is required to introspect methods on objects like Net::HTTP::Get that
+      # have overridden the `method` method.
+      def safe_send(obj, method, *args, &block)
+        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+      end
+      public :safe_send
+
+      def find_command(name, set = Pry::Commands)
+        command_match = set.find do |_, command|
+          (listing = command.options[:listing]) == name && listing != nil
+        end
+        command_match.last if command_match
       end
 
       def not_a_real_file?(file)
@@ -34,11 +38,11 @@ class Pry
       def command_dependencies_met?(options)
         return true if !options[:requires_gem]
         Array(options[:requires_gem]).all? do |g|
-          gem_installed?(g)
+          Rubygem.installed?(g)
         end
       end
 
-      def set_file_and_dir_locals(file_name)
+      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)
@@ -47,30 +51,8 @@ class Pry
         _pry_.inject_local("_dir_", _pry_.last_dir, target)
       end
 
-      def stub_proc(name, options)
-        gems_needed = Array(options[:requires_gem])
-        gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
-        proc do
-          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
-
-      def create_command_stub(names, description, options, block)
-        Array(names).each do |name|
-          commands[name] = {
-            :description => "Not available. Execute #{(name)} command for more information.",
-            :action => stub_proc(name, options),
-            :stub_info => options
-          }
-        end
-      end
-
       def use_ansi_codes?
-         windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
       end
 
       def colorize_code(code)
@@ -91,10 +73,6 @@ class Pry
         Pry.color ? "\e[1m#{text}\e[0m": text
       end
 
-      def page_size
-        27
-      end
-
       # have fun on the Windows platform.
       def windows?
         RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
@@ -123,103 +101,95 @@ class Pry
         RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
       end
 
-      # a simple pager for systems without `less`. A la windows.
-      def simple_pager(text, output=output())
-        text_array = text.lines.to_a
-        text_array.each_slice(page_size) do |chunk|
-          output.puts chunk.join
-          break if chunk.size < page_size
-          if text_array.size > page_size
-            output.puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
-            break if $stdin.gets.chomp == "q"
-          end
-        end
-      end
-
       # 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, out = nil)
         out ||= case
-        when respond_to?(:output)
-          # Mixin.
-          output
-        when Pry.respond_to?(:output)
-          # Parent.
-          Pry.output
-        else
-          # Sys.
-          $stdout
-        end
-
-        if text.lines.count < page_size || !Pry.pager
+                when respond_to?(:output)
+                  # Mixin.
+                  output
+                when Pry.respond_to?(:output)
+                  # Parent.
+                  Pry.output
+                else
+                  # Sys.
+                  $stdout
+                end
+
+        if text.lines.count < Pry::Pager.page_size || !Pry.pager
           out.puts text
-          return
-        end
-
-        # FIXME! Another JRuby hack
-        if jruby?
-          simple_pager(text, out)
         else
-          lesspipe { |less| less.puts text }
+          Pry::Pager.page(text)
         end
       rescue Errno::ENOENT
-        simple_pager(text, out)
+        Pry::Pager.page(text, :simple)
       rescue Errno::EPIPE
       end
 
-      #
-      # Create scrollable output via less!
-      #
-      # This command runs `less` in a subprocess, and gives you the IO to its STDIN pipe
-      # so that you can communicate with it.
-      #
-      # Example:
-      #
-      #   lesspipe do |less|
-      #     50.times { less.puts "Hi mom!" }
-      #   end
-      #
-      # The default less parameters are:
-      # * Allow colour
-      # * Don't wrap lines longer than the screen
-      # * Quit immediately (without paging) if there's less than one screen of text.
-      #
-      # You can change these options by passing a hash to `lesspipe`, like so:
-      #
-      #   lesspipe(:wrap=>false) { |less| less.puts essay.to_s }
-      #
-      # It accepts the following boolean options:
-      #    :color  => Allow ANSI colour codes?
-      #    :wrap   => Wrap long lines?
-      #    :always => Always page, even if there's less than one page of text?
-      #
-      def lesspipe(*args)
-        if args.any? and args.last.is_a?(Hash)
-          options = args.pop
-        else
-          options = {}
-        end
+      # @param [String] arg_string The object path expressed as a string.
+      # @param [Pry] _pry_ The relevant Pry instance.
+      # @param [Array<Binding>] old_stack The state of the old binding stack
+      # @return [Array<Array<Binding>, Array<Binding>>] An array
+      #   containing two elements: The new `binding_stack` and the old `binding_stack`.
+      def context_from_object_path(arg_string, _pry_=nil, old_stack=[])
 
-        output = args.first if args.any?
+        # Extract command arguments. Delete blank arguments like " ", but
+        # don't delete empty strings like "".
+        path      = arg_string.split(/\//).delete_if { |a| a =~ /\A\s+\z/ }
+        stack     = _pry_.binding_stack.dup
+        state_old_stack = old_stack
 
-        params = []
-        params << "-R" unless options[:color] == false
-        params << "-S" unless options[:wrap] == true
-        params << "-F" unless options[:always] == true
-        if options[:tail] == true
-          params << "+\\>"
-          $stderr.puts "Seeking to end of stream..."
+        # Special case when we only get a single "/", return to root.
+        if path.empty?
+          state_old_stack = stack.dup unless old_stack.empty?
+          stack = [stack.first]
         end
-        params << "-X"
 
-        IO.popen("less #{params * ' '}", "w") do |less|
-          if output
-            less.puts output
-          else
-            yield less
+        path.each_with_index do |context, i|
+          begin
+            case context.chomp
+            when ""
+              state_old_stack = stack.dup
+              stack = [stack.first]
+            when "::"
+              state_old_stack = stack.dup
+              stack.push(TOPLEVEL_BINDING)
+            when "."
+              next
+            when ".."
+              unless stack.size == 1
+                # Don't rewrite old_stack if we're in complex expression
+                # (e.g.: `cd 1/2/3/../4).
+                state_old_stack = stack.dup if path.first == ".."
+                stack.pop
+              end
+            when "-"
+              unless old_stack.empty?
+                # Interchange current stack and old stack with each other.
+                stack, state_old_stack = state_old_stack, stack
+              end
+            else
+              state_old_stack = stack.dup if i == 0
+              stack.push(Pry.binding_for(stack.last.eval(context)))
+            end
+
+          rescue RescuableException => e
+            # Restore old stack to its initial values.
+            state_old_stack = old_stack
+
+            msg = [
+              "Bad object path: #{arg_string}.",
+              "Failed trying to resolve: #{context}.",
+              e.inspect
+            ].join(' ')
+
+            CommandError.new(msg).tap do |err|
+              err.set_backtrace e.backtrace
+              raise err
+            end
           end
         end
+        return stack, state_old_stack
       end
 
     end

data/lib/pry/helpers/command_helpers.rb

@@ -23,45 +23,29 @@ class Pry
         end
       end
 
-      # Return the file and line for a Binding.
-      # @param [Binding] target The binding
-      # @return [Array] The file and line
-      def file_and_line_from_binding(target)
-        file = target.eval('__FILE__')
-        line_num = target.eval('__LINE__')
-        if rbx?
-          if !target.instance_variable_defined?(:@__actual_file__)
-            target.instance_variable_set(:@__actual_file__, RbxPath.convert_path_to_full(target.variables.method.file.to_s))
-          end
-          file = target.instance_variable_get(:@__actual_file__).to_s
-        end
-
-        [file, line_num]
-      end
-
       def internal_binding?(target)
-        m = target.eval("__method__").to_s
+        m = target.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        ["__binding__", "__binding_impl__", "class_eval"].include?(m)
+        ["__binding__", "__pry__", "class_eval"].include?(m)
       end
 
       def get_method_or_raise(name, target, opts={}, omit_help=false)
         meth = Pry::Method.from_str(name, target, opts)
 
         if name && !meth
-          command_error("The method '#{name}' could not be found.", omit_help)
+          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
         end
 
         (opts[:super] || 0).times do
           if meth.super
             meth = meth.super
           else
-            command_error("'#{meth.name_with_owner}' has no super method.", omit_help)
+            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
           end
         end
 
         if !meth || (!name && internal_binding?(target))
-          command_error("No method name given, and context is not a method.", omit_help, NonMethodContextError)
+          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
         end
 
         set_file_and_dir_locals(meth.source_file)
@@ -73,104 +57,6 @@ class Pry
         raise klass, message
       end
 
-      def make_header(meth, content=meth.source)
-        header = "\n#{Pry::Helpers::Text.bold('From:')} #{meth.source_file} "
-
-        if meth.source_type == :c
-          header << "(C Method):\n"
-        else
-          header << "@ line #{meth.source_line}:\n"
-        end
-
-        header << "#{Pry::Helpers::Text.bold("Number of lines:")} #{content.each_line.count.to_s}\n"
-      end
-
-      def invoke_editor(file, line, reloading)
-        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
-        if Pry.config.editor.respond_to?(:call)
-          args = [file, line, reloading][0...(Pry.config.editor.arity)]
-          editor_invocation = Pry.config.editor.call(*args)
-        else
-          editor_invocation = "#{Pry.config.editor} #{blocking_flag_for_editor(reloading)} #{start_line_syntax_for_editor(file, line)}"
-        end
-        return nil unless editor_invocation
-
-        if jruby?
-          begin
-            require 'spoon'
-            pid = Spoon.spawnp(*editor_invocation.split)
-            Process.waitpid(pid)
-          rescue FFI::NotFoundError
-            system(editor_invocation)
-          end
-        else
-          # Note we dont want to use Pry.config.system here as that
-          # may be invoked non-interactively (i.e via Open4), whereas we want to
-          # ensure the editor is always interactive
-          system(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
-        end
-      end
-
-      # Some editors that run outside the terminal allow you to control whether or
-      # not to block the process from which they were launched (in this case, Pry).
-      # For those editors, return the flag that produces the desired behavior.
-      def blocking_flag_for_editor(block)
-        case editor_name
-        when /^emacsclient/
-          '--no-wait' unless block
-        when /^[gm]vim/
-          '--nofork' if block
-        when /^jedit/
-          '-wait' if block
-        when /^mate/, /^subl/
-          '-w' if block
-        end
-      end
-
-      # Return the syntax for a given editor for starting the editor
-      # and moving to a particular line within that file
-      def start_line_syntax_for_editor(file_name, line_number)
-        if windows?
-          file_name = file_name.gsub(/\//, '\\')
-        end
-
-        # special case for 1st line
-        return file_name if line_number <= 1
-
-        case editor_name
-        when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-          "+#{line_number} #{file_name}"
-        when /^mate/, /^geany/
-          "-l #{line_number} #{file_name}"
-        when /^subl/
-          "#{file_name}:#{line_number}"
-        when /^uedit32/
-          "#{file_name}/#{line_number}"
-        when /^jedit/
-          "#{file_name} +line:#{line_number}"
-        else
-          if windows?
-            "#{file_name}"
-          else
-            "+#{line_number} #{file_name}"
-          end
-        end
-      end
-
-      # Get the name of the binary that Pry.config.editor points to.
-      #
-      # This is useful for deciding which flags we pass to the editor as
-      # we can just use the program's name and ignore any absolute paths.
-      #
-      # @example
-      #   Pry.config.editor="/home/conrad/bin/textmate -w"
-      #   editor_name
-      #   # => textmate
-      #
-      def editor_name
-        File.basename(Pry.config.editor).split(" ").first
-      end
-
       # Remove any common leading whitespace from every line in `text`.
       #
       # This can be used to make a HEREDOC line up with the left margin, without
@@ -193,7 +79,7 @@ class Pry
       #
       # @param [String] text The text from which to remove indentation
       # @return [String] The text with indentation stripped.
-      def unindent(text)
+      def unindent(text, left_padding = 0)
         # Empty blank lines
         text = text.sub(/^[ \t]+$/, '')
 
@@ -208,7 +94,7 @@ class Pry
           end
         end
 
-        text.gsub(/^#{margin}/, '')
+        text.gsub(/^#{margin}/, ' ' * left_padding)
       end
 
       # Restrict a string to the given range of lines (1-indexed)
@@ -262,6 +148,5 @@ class Pry
         Range.new(a, b)
       end
     end
-
   end
 end

data/lib/pry/helpers/table.rb

@@ -0,0 +1,100 @@
+class Pry
+  module Helpers
+    def self.tablify_to_screen_width(things)
+      things = things.compact
+
+      if TerminalInfo.screen_size.nil?
+        return things.join(Pry.config.ls.separator)
+      end
+
+      screen_width = (TerminalInfo.screen_size || [25, 80])[1]
+      tablify(things, screen_width)
+    end
+
+    def self.tablify(things, line_length)
+      table = Table.new(things, :column_count => things.size)
+      table.column_count -= 1 until 0 == table.column_count or
+        table.fits_on_line?(line_length)
+      table
+    end
+
+    class Table
+      attr_reader :items, :column_count
+      def initialize items, args = {}
+        @column_count = args[:column_count]
+        self.items = items
+      end
+
+      def to_s
+        rows_to_s.join("\n")
+      end
+
+      def rows_to_s style = :color_on
+        widths = columns.map{|e| _max_width(e)}
+        @rows_without_colors.map do |r|
+          padded = []
+          r.each_with_index do |e,i|
+            next unless e
+            item = e.ljust(widths[i])
+            item.sub! e, _recall_color_for(e) if :color_on == style
+            padded << item
+          end
+          padded.join(Pry.config.ls.separator)
+        end
+      end
+
+      def items= items
+        @items = items
+        _rebuild_colorless_cache
+        _recolumn
+        items
+      end
+
+      def column_count= n
+        @column_count = n
+        _recolumn
+      end
+
+      def fits_on_line? line_length
+        _max_width(rows_to_s :no_color) <= line_length
+      end
+
+      def columns
+        @rows_without_colors.transpose
+      end
+
+      def ==(other); items == other.to_a end
+      def to_a; items.to_a end
+
+      private
+      def _max_width(things)
+        things.compact.map(&:size).max || 0
+      end
+
+      def _rebuild_colorless_cache
+        @colorless_cache = {}
+        @plain_items = []
+        items.map do |e|
+          plain = Pry::Helpers::Text.strip_color(e)
+          @colorless_cache[plain] = e
+          @plain_items << plain
+        end
+      end
+
+      def _recolumn
+        @rows_without_colors = []
+        return if items.size.zero?
+        row_count = (items.size.to_f/column_count).ceil
+        row_count.times do |i|
+          row_indices = (0...column_count).map{|e| row_count*e+i}
+          @rows_without_colors << row_indices.map{|e| @plain_items[e]}
+        end
+      end
+
+      def _recall_color_for thing
+        @colorless_cache[thing]
+      end
+    end
+
+  end
+end