pry 0.9.12.2 → 0.14.2

data/lib/pry/helpers/table.rb

@@ -1,36 +1,42 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-    def self.tablify_or_one_line(heading, things)
+    def self.tablify_or_one_line(heading, things, pry_instance = Pry.new)
       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)
+      attempt = Table.new(things, column_count: things.size)
+      if attempt.fits_on_line?(pry_instance.output.width - plain_heading.size - 2)
         "#{heading}: #{attempt}\n"
       else
-        "#{heading}: \n#{tablify_to_screen_width(things, :indent => '  ')}\n"
+        content = tablify_to_screen_width(things, { indent: '  ' }, pry_instance)
+        "#{heading}: \n#{content}\n"
       end
     end
 
-    def self.tablify_to_screen_width(things, options = {})
+    def self.tablify_to_screen_width(things, options, pry_instance = Pry.new)
+      options ||= {}
       things = things.compact
-      if indent = options[:indent]
-        usable_width = Terminal.width! - indent.size
-        tablify(things, usable_width).to_s.gsub(/^/, indent)
+      if (indent = options[:indent])
+        usable_width = pry_instance.output.width - indent.size
+        tablify(things, usable_width, pry_instance).to_s.gsub(/^/, indent)
       else
-        tablify(things, Terminal.width!).to_s
+        tablify(things, pry_instance.output.width, pry_instance).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)
+    def self.tablify(things, line_length, pry_instance = Pry.new)
+      table = Table.new(things, { column_count: things.size }, pry_instance)
+      until (table.column_count == 1) || table.fits_on_line?(line_length)
+        table.column_count -= 1
+      end
       table
     end
 
     class Table
       attr_reader :items, :column_count
-      def initialize items, args = {}
+      def initialize(items, args, pry_instance = Pry.new)
         @column_count = args[:column_count]
+        @config = pry_instance.config
         self.items = items
       end
 
@@ -38,44 +44,50 @@ class Pry
         rows_to_s.join("\n")
       end
 
-      def rows_to_s style = :color_on
-        widths = columns.map{|e| _max_width(e)}
+      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|
+          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
+            item.sub! e, _recall_color_for(e) if style == :color_on
             padded << item
           end
-          padded.join(Pry.config.ls.separator)
+          padded.join(@config.ls.separator)
         end
       end
 
-      def items= items
+      def items=(items)
         @items = items
         _rebuild_colorless_cache
         _recolumn
-        items
       end
 
-      def column_count= n
-        @column_count = n
+      def column_count=(count)
+        @column_count = count
         _recolumn
       end
 
-      def fits_on_line? line_length
-        _max_width(rows_to_s :no_color) <= line_length
+      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
+      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
@@ -93,17 +105,17 @@ class Pry
       def _recolumn
         @rows_without_colors = []
         return if items.size.zero?
-        row_count = (items.size.to_f/column_count).ceil
+
+        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]}
+          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
+      def _recall_color_for(thing)
         @colorless_cache[thing]
       end
     end
-
   end
 end

data/lib/pry/helpers/text.rb

@@ -1,108 +1,118 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-
-    # The methods defined on {Text} are available to custom commands via {Pry::Command#text}.
+    # The methods defined on {Text} are available to custom commands via
+    # {Pry::Command#text}.
     module Text
+      extend self
 
-      COLORS =
-      {
-        "black"   => 0,
-        "red"     => 1,
-        "green"   => 2,
-        "yellow"  => 3,
-        "blue"    => 4,
-        "purple"  => 5,
+      COLORS = {
+        "black" => 0,
+        "red" => 1,
+        "green" => 2,
+        "yellow" => 3,
+        "blue" => 4,
+        "purple" => 5,
         "magenta" => 5,
-        "cyan"    => 6,
-        "white"   => 7
-      }
+        "cyan" => 6,
+        "white" => 7
+      }.freeze
 
-      class << self
+      COLORS.each_pair do |color, value|
+        define_method color do |text|
+          "\033[0;#{30 + value}m#{text}\033[0m"
+        end
 
-        COLORS.each_pair do |color, value|
-          define_method color do |text|
-            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"
+        end
 
-          define_method "bright_#{color}" do |text|
-            Pry.color ? "\033[1;#{30+value}m#{text}\033[0m" : text.to_s
+        COLORS.each_pair do |bg_color, bg_value|
+          define_method "#{color}_on_#{bg_color}" do |text|
+            "\033[0;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
           end
-        end
 
-        # Remove any color codes from _text_.
-        #
-        # @param  [String, #to_s] text
-        # @return [String] _text_ stripped of any color codes.
-        def strip_color(text)
-          text.to_s.gsub(/\e\[.*?(\d)+m/ , '')
+          define_method "bright_#{color}_on_#{bg_color}" do |text|
+            "\033[1;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
+          end
         end
+      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
-        end
+      # Remove any color codes from _text_.
+      #
+      # @param  [String, #to_s] text
+      # @return [String] _text_ stripped of any color codes.
+      def strip_color(text)
+        text.to_s.gsub(/(\001)?(\e\[(\d[;\d]?)*m)(\002)?/, '')
+      end
 
-        # Returns `text` in the default foreground colour.
-        # Use this instead of "black" or "white" when you mean absence of colour.
-        #
-        # @param [String, #to_s] text
-        # @return [String]
-        def default(text)
-          text.to_s
-        end
-        alias_method :bright_default, :bold
+      # Returns _text_ as bold text for use on a terminal.
+      #
+      # @param [String, #to_s] text
+      # @return [String] _text_
+      def bold(text)
+        "\e[1m#{text}\e[0m"
+      end
 
-        # Executes the block with `Pry.color` set to false.
-        # @yield
-        # @return [void]
-        def no_color(&block)
-          boolean = Pry.config.color
-          Pry.config.color = false
-          yield
-        ensure
-          Pry.config.color = boolean
-        end
+      # Returns `text` in the default foreground colour.
+      # Use this instead of "black" or "white" when you mean absence of colour.
+      #
+      # @param [String, #to_s] text
+      # @return [String]
+      def default(text)
+        text.to_s
+      end
 
-        # Executes the block with `Pry.config.pager` set to false.
-        # @yield
-        # @return [void]
-        def no_pager(&block)
-          boolean = Pry.config.pager
-          Pry.config.pager = false
-          yield
-        ensure
-          Pry.config.pager = boolean
-        end
+      #
+      # @yield
+      #   Yields a block with color turned off.
+      #
+      # @return [void]
+      #
+      def no_color
+        boolean = Pry.config.color
+        Pry.config.color = false
+        yield
+      ensure
+        Pry.config.color = boolean
+      end
 
-        # Returns _text_ in a numbered list, beginning at _offset_.
-        #
-        # @param  [#each_line] text
-        # @param  [Fixnum] offset
-        # @return [String]
-        def with_line_numbers(text, offset, color=:blue)
-          lines = text.each_line.to_a
-          max_width = (offset + lines.count).to_s.length
-          lines.each_with_index.map do |line, index|
-            adjusted_index = (index + offset).to_s.rjust(max_width)
-            "#{self.send(color, adjusted_index)}: #{line}"
-          end.join
-        end
+      #
+      # @yield
+      #   Yields a block with paging turned off.
+      #
+      # @return [void]
+      #
+      def no_pager
+        boolean = Pry.config.pager
+        Pry.config.pager = false
+        yield
+      ensure
+        Pry.config.pager = boolean
+      end
 
-        # Returns _text_ indented by _chars_ spaces.
-        #
-        # @param [String] text
-        # @param [Fixnum] chars
-        def indent(text, chars)
-          text.lines.map { |l| "#{' ' * chars}#{l}" }.join
-        end
+      # Returns _text_ in a numbered list, beginning at _offset_.
+      #
+      # @param  [#each_line] text
+      # @param  [Fixnum] offset
+      # @return [String]
+      def with_line_numbers(text, offset, color = :blue)
+        lines = text.each_line.to_a
+        max_width = (offset + lines.count).to_s.length
+        lines.each_with_index.map do |line, index|
+          adjusted_index = (index + offset).to_s.rjust(max_width)
+          "#{send(color, adjusted_index)}: #{line}"
+        end.join
       end
 
+      # Returns _text_ indented by _chars_ spaces.
+      #
+      # @param [String] text
+      # @param [Fixnum] chars
+      def indent(text, chars)
+        text.lines.map { |l| "#{' ' * chars}#{l}" }.join
+      end
     end
-
   end
 end
-

data/lib/pry/helpers.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "pry/helpers/base_helpers"
 require "pry/helpers/options_helpers"
 require "pry/helpers/command_helpers"
 require "pry/helpers/text"
 require "pry/helpers/table"
+require "pry/helpers/platform"

data/lib/pry/history.rb

@@ -1,122 +1,153 @@
+# frozen_string_literal: true
+
 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 self.default_file
+      history_file =
+        if (xdg_home = Pry::Env['XDG_DATA_HOME'])
+          # See XDG Base Directory Specification at
+          # https://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
+          xdg_home + '/pry/pry_history'
+        elsif File.exist?(File.expand_path('~/.pry_history'))
+          '~/.pry_history'
+        else
+          '~/.local/share/pry/pry_history'
+        end
+      File.expand_path(history_file)
+    end
+
+    attr_accessor :loader, :saver
 
     # @return [Fixnum] Number of lines in history when Pry first loaded.
     attr_reader :original_lines
 
-    def initialize
-      @history = []
-      @saved_lines = 0
-      @original_lines = 0
-      restore_default_behavior
-    end
+    # @return [Integer] total number of lines, including original lines
+    attr_reader :history_line_count
 
-    # 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)
+    def initialize(options = {})
+      @history = options[:history] || []
+      @history_line_count = @history.count
+      @file_path = options[:file_path]
+      @original_lines = 0
+      @loader = method(:read_from_file)
+      @saver = method(:save_to_file)
     end
 
     # Load the input history using `History.loader`.
     # @return [Integer] The number of lines loaded
     def load
       @loader.call do |line|
-        @pusher.call(line.chomp)
+        next if invalid_readline_line?(line)
+
         @history << line.chomp
+        @original_lines += 1
+        @history_line_count += 1
       end
-      @saved_lines = @original_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.
     # @param [String] line
     # @return [String] The same line that was passed in
     def push(line)
-      unless line.empty? || (@history.last && line == @history.last)
-        @pusher.call(line)
-        @history << line
+      return line if line.empty? || invalid_readline_line?(line)
+
+      begin
+        last_line = @history[-1]
+      rescue IndexError
+        last_line = nil
       end
+
+      return line if line == last_line
+
+      @history << line
+      @history_line_count += 1
+      @saver.call(line) if !should_ignore?(line) && Pry.config.history_save
+
       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
+      @history.clear
+      @history_line_count = 0
+      @original_lines = 0
     end
 
+    # @return [Fixnum] The number of lines in history from just this session.
     def session_line_count
-      @history.count - @original_lines
+      @history_line_count - @original_lines
     end
 
     # Return an Array containing all stored history.
     # @return [Array<String>] An Array containing all lines of history loaded
     #   or entered by the user in the current session.
     def to_a
-      @history.dup
+      @history.to_a
+    end
+
+    # Filter the history with the histignore options
+    # @return [Array<String>] An array containing all the lines that are not
+    #   included in the histignore.
+    def filter(history)
+      history.select { |l| l unless should_ignore?(l) }
     end
 
     private
-    # The default loader. Yields lines from `Pry.history.config.file`.
+
+    # Check if the line match any option in the histignore
+    # [Pry.config.history_ignorelist]
+    # @return [Boolean] a boolean that notifies if the line was found in the
+    #   histignore array.
+    def should_ignore?(line)
+      hist_ignore = Pry.config.history_ignorelist
+      return false if hist_ignore.nil? || hist_ignore.empty?
+
+      hist_ignore.any? { |p| line.to_s.match(p) }
+    end
+
+    # The default loader. Yields lines from `Pry.config.history_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
+      path = history_file_path
+
+      File.foreach(path) { |line| yield(line) } if File.exist?(path)
+    rescue SystemCallError => error
+      warn "Unable to read history file: #{error.message}"
     end
 
-    # 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)
+    # The default saver. Appends the given line to `Pry.config.history_file`.
+    def save_to_file(line)
+      history_file.puts line if history_file
+    end
 
-      begin
-        File.open(history_file, 'a') do |f|
-          lines.each { |ln| f.puts ln }
+    # The history file, opened for appending.
+    def history_file
+      if defined?(@history_file)
+        @history_file
+      else
+        unless File.exist?(history_file_path)
+          FileUtils.mkdir_p(File.dirname(history_file_path))
+        end
+        @history_file = File.open(history_file_path, 'a', 0o600).tap do |file|
+          file.sync = true
         end
-      rescue Errno::EACCES
-        # We should probably create an option Pry.show_warnings?!?!?!
-        warn 'Unable to write to your history file, history not saved'
       end
+    rescue SystemCallError => error
+      warn "Unable to write history file: #{error.message}"
+      @history_file = false
     end
 
-    # The default pusher. Appends the given line to Readline::HISTORY.
-    # @param [String] line
-    def push_to_readline(line)
-      Readline::HISTORY << line
+    def history_file_path
+      File.expand_path(@file_path || Pry.config.history_file)
     end
 
-    # The default clearer. Clears Readline::HISTORY.
-    def clear_readline
-      Readline::HISTORY.shift until Readline::HISTORY.empty?
+    def invalid_readline_line?(line)
+      # `Readline::HISTORY << line` raises an `ArgumentError` if `line`
+      # includes a null byte
+      line.include?("\0")
     end
   end
 end