pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-i386-mingw32

data/lib/pry/helpers/command_helpers.rb

@@ -15,53 +15,29 @@ 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
-
-      # 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 +49,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,12 +71,14 @@ 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]+$/, '')
 
         # Find the longest common whitespace to all indented lines
-        margin = text.scan(/^[ \t]*(?=[^ \t\n])/).inject do |current_margin, next_indent|
+        # Ignore lines containing just -- or ++ as these seem to be used by
+        # comment authors as delimeters.
+        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
           if next_indent.start_with?(current_margin)
             current_margin
           elsif current_margin.start_with?(next_indent)
@@ -208,7 +88,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)
@@ -261,6 +141,15 @@ 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

data/lib/pry/helpers/documentation_helpers.rb

@@ -4,14 +4,17 @@ class Pry
     # This class contains methods useful for extracting
     # documentation from methods and classes.
     module DocumentationHelpers
-      def process_rdoc(comment, code_type)
+
+      module_function
+
+      def process_rdoc(comment)
         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[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)?([^\e]*?)\s*`/) { "`#{Pry.color ? CodeRay.scan($1, code_type).term : $1}`" }
+        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" }.
+          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
+          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
+          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
       end
 
       def process_yardoc_tag(comment, tag)
@@ -33,11 +36,11 @@ 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("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
+          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
       end
 
-      def process_comment_markup(comment, code_type)
-        process_yardoc process_rdoc(comment, code_type)
+      def process_comment_markup(comment)
+        process_yardoc process_rdoc(comment)
       end
 
       # @param [String] code
@@ -46,10 +49,17 @@ class Pry
         code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
       end
 
+      # Given a string that makes up a comment in a source-code file parse out the content
+      # that the user is intended to read. (i.e. without leading indentation, #-characters
+      # or shebangs)
+      #
       # @param [String] comment
       # @return [String]
-      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
+      def get_comment_content(comment)
         comment = comment.dup
+        # Remove #!/usr/bin/ruby
+        comment.gsub!(/\A\#!.*$/, '')
+        # Remove leading empty comment lines
         comment.gsub!(/\A\#+?$/, '')
         comment.gsub!(/^\s*#/, '')
         strip_leading_whitespace(comment)

data/lib/pry/helpers/table.rb

@@ -0,0 +1,109 @@
+class Pry
+  module Helpers
+    def self.tablify_or_one_line(heading, things)
+      plain_heading = Pry::Helpers::Text.strip_color(heading)
+      attempt = Table.new(things, :column_count => things.size)
+      if attempt.fits_on_line?(Terminal.width! - plain_heading.size - 2)
+        "#{heading}: #{attempt}\n"
+      else
+        "#{heading}: \n#{tablify_to_screen_width(things, :indent => '  ')}\n"
+      end
+    end
+
+    def self.tablify_to_screen_width(things, options = {})
+      things = things.compact
+      if indent = options[:indent]
+        usable_width = Terminal.width! - indent.size
+        tablify(things, usable_width).to_s.gsub(/^/, indent)
+      else
+        tablify(things, Terminal.width!).to_s
+      end
+    end
+
+    def self.tablify(things, line_length)
+      table = Table.new(things, :column_count => things.size)
+      table.column_count -= 1 until 1 == 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

data/lib/pry/helpers/text.rb

@@ -21,11 +21,11 @@ class Pry
 
         COLORS.each_pair do |color, value|
           define_method color do |text|
-            Pry.color ? "\033[0;#{30+value}m#{text}\033[0m" : text.to_s
+            "\033[0;#{30+value}m#{text}\033[0m"
           end
 
           define_method "bright_#{color}" do |text|
-            Pry.color ? "\033[1;#{30+value}m#{text}\033[0m" : text.to_s
+            "\033[1;#{30+value}m#{text}\033[0m"
           end
         end
 
@@ -33,17 +33,16 @@ class Pry
         #
         # @param  [String, #to_s] text
         # @return [String] _text_ stripped of any color codes.
-        def strip_color text
+        def strip_color(text)
           text.to_s.gsub(/\e\[.*?(\d)+m/ , '')
         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
-          Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
+        def bold(text)
+          "\e[1m#{text}\e[0m"
         end
 
         # Returns `text` in the default foreground colour.
@@ -56,10 +55,10 @@ class Pry
         end
         alias_method :bright_default, :bold
 
-        # Executes the block with `Pry.color` set to false.
+        # Executes the block with `Pry.config.color` set to false.
         # @yield
         # @return [void]
-        def no_color &block
+        def no_color(&block)
           boolean = Pry.config.color
           Pry.config.color = false
           yield
@@ -70,7 +69,7 @@ class Pry
         # Executes the block with `Pry.config.pager` set to false.
         # @yield
         # @return [void]
-        def no_pager &block
+        def no_pager(&block)
           boolean = Pry.config.pager
           Pry.config.pager = false
           yield

data/lib/pry/history.rb

@@ -1,21 +1,33 @@
 class Pry
-  # The History class is responsible for maintaining the user's input history, both
-  # internally and within Readline.
+  # The History class is responsible for maintaining the user's input history,
+  # both internally and within Readline.
   class History
     attr_accessor :loader, :saver, :pusher, :clearer
 
-    def initialize
+    # @return [Fixnum] Number of lines in history when Pry first loaded.
+    attr_reader :original_lines
+
+    def initialize(options={})
       @history = []
-      @saved_lines = 0
+      @original_lines = 0
+      @file_path = options[:file_path]
       restore_default_behavior
     end
 
     # Assign the default methods for loading, saving, pushing, and clearing.
     def restore_default_behavior
-      @loader  = method(:read_from_file)
-      @saver   = method(:write_to_file)
-      @pusher  = method(:push_to_readline)
-      @clearer = method(:clear_readline)
+      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
     end
 
     # Load the input history using `History.loader`.
@@ -24,17 +36,8 @@ class Pry
       @loader.call do |line|
         @pusher.call(line.chomp)
         @history << line.chomp
+        @original_lines += 1
       end
-      @saved_lines = @history.length
-    end
-
-    # Write this session's history using `History.saver`.
-    # @return [Integer] The number of lines saved
-    def save
-      history_to_save = @history[@saved_lines..-1]
-      @saver.call(history_to_save)
-      @saved_lines = @history.length
-      history_to_save.length
     end
 
     # Add a line to the input history, ignoring blank and duplicate lines.
@@ -44,18 +47,27 @@ class Pry
       unless line.empty? || (@history.last && line == @history.last)
         @pusher.call(line)
         @history << line
+        @saver.call(line) if Pry.config.history.should_save
       end
       line
     end
     alias << push
 
-    # Clear all history. Anything the user entered before this point won't be
-    # saved, but anything they put in afterwards will still be appended to the
-    # history file on exit.
+    # Clear this session's history. This won't affect the contents of the
+    # history file.
     def clear
       @clearer.call
       @history = []
-      @saved_lines = 0
+    end
+
+    # @return [Fixnum] The number of lines in history.
+    def history_line_count
+      @history.count
+    end
+
+    # @return [Fixnum] The number of lines in history from just this session.
+    def session_line_count
+      @history.count - @original_lines
     end
 
     # Return an Array containing all stored history.
@@ -66,33 +78,16 @@ class Pry
     end
 
     private
+
     # The default loader. Yields lines from `Pry.history.config.file`.
     def read_from_file
-      begin
-        history_file = File.expand_path(Pry.config.history.file)
-        if File.exists?(history_file)
-          File.foreach(history_file) { |line| yield(line) }
-        end
-      rescue => error
-        unless error.message.empty?
-          warn "History file not loaded, received an error: #{error.message}"
-        end
-      end
-    end
+      filename = File.expand_path(Pry.config.history.file)
 
-    # The default saver. Appends the given lines to `Pry.history.config.file`.
-    # @param [Array<String>] lines
-    def write_to_file(lines)
-      history_file = File.expand_path(Pry.config.history.file)
-
-      begin
-        File.open(history_file, 'a') do |f|
-          lines.each { |ln| f.puts ln }
-        end
-      rescue Errno::EACCES
-        # We should probably create an option Pry.show_warnings?!?!?!
-        warn 'Unable to write to your history file, history not saved'
+      if File.exists?(filename)
+        File.foreach(filename) { |line| yield(line) }
       end
+    rescue => error
+      warn "History file not loaded: #{error.message}"
     end
 
     # The default pusher. Appends the given line to Readline::HISTORY.
@@ -105,5 +100,26 @@ class Pry
     def clear_readline
       Readline::HISTORY.shift until Readline::HISTORY.empty?
     end
+
+    # The default saver. Appends the given line to `Pry.history.config.file`.
+    def save_to_file(line)
+      history_file.puts line if history_file
+    end
+
+    # The history file, opened for appending.
+    def history_file
+      if defined?(@history_file)
+        @history_file
+      else
+        @history_file = File.open(file_path, 'a', 0600).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 file_path
+      @file_path || Pry.config.history.file
+    end
   end
 end