pry 0.10.3 → 0.12.2

data/lib/pry/helpers/text.rb

@@ -1,9 +1,8 @@
 class Pry
   module Helpers
-
     # The methods defined on {Text} are available to custom commands via {Pry::Command#text}.
     module Text
-
+      extend self
       COLORS =
       {
         "black"   => 0,
@@ -17,91 +16,100 @@ class Pry
         "white"   => 7
       }
 
-      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|
-            "\033[0;#{30+value}m#{text}\033[0m"
-          end
+        define_method "bright_#{color}" do |text|
+          "\033[1;#{30 + value}m#{text}\033[0m"
+        end
 
-          define_method "bright_#{color}" do |text|
-            "\033[1;#{30+value}m#{text}\033[0m"
+        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.
-        #
-        # @param [String, #to_s] text
-        # @return [String] _text_
-        def bold(text)
-          "\e[1m#{text}\e[0m"
-        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)+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.config.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)
+          "#{self.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

@@ -3,3 +3,4 @@ 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

@@ -7,7 +7,7 @@ class Pry
     # @return [Fixnum] Number of lines in history when Pry first loaded.
     attr_reader :original_lines
 
-    def initialize(options={})
+    def initialize(options = {})
       @history = []
       @original_lines = 0
       @file_path = options[:file_path]
@@ -25,8 +25,8 @@ class Pry
         @pusher  = method(:push_to_readline)
         @clearer = method(:clear_readline)
       else
-        @pusher  = proc { }
-        @clearer = proc { }
+        @pusher  = proc {}
+        @clearer = proc {}
       end
     end
 
@@ -34,6 +34,8 @@ class Pry
     # @return [Integer] The number of lines loaded
     def load
       @loader.call do |line|
+        next if invalid_readline_line?(line)
+
         @pusher.call(line.chomp)
         @history << line.chomp
         @original_lines += 1
@@ -44,10 +46,14 @@ class Pry
     # @param [String] line
     # @return [String] The same line that was passed in
     def push(line)
-      unless line.empty? || (@history.last && line == @history.last)
+      empty_or_invalid_line = line.empty? || invalid_readline_line?(line)
+
+      unless empty_or_invalid_line || (@history.last && line == @history.last)
         @pusher.call(line)
         @history << line
-        @saver.call(line) if Pry.config.history.should_save
+        if !should_ignore?(line) && Pry.config.history.should_save
+          @saver.call(line)
+        end
       end
       line
     end
@@ -57,6 +63,7 @@ class Pry
     # history file.
     def clear
       @clearer.call
+      @original_lines = 0
       @history = []
     end
 
@@ -77,17 +84,35 @@ class Pry
       @history.dup
     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
 
+    # Check if the line match any option in the histignore
+    # [Pry.config.history.histignore]
+    # @return [Boolean] a boolean that notifies if the line was found in the
+    #   histignore array.
+    def should_ignore?(line)
+      hist_ignore = Pry.config.history.histignore
+      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.history.config.file`.
     def read_from_file
       path = history_file_path
 
-      if File.exists?(path)
+      if File.exist?(path)
         File.foreach(path) { |line| yield(line) }
       end
-    rescue => error
-      warn "History file not loaded: #{error.message}"
+    rescue SystemCallError => error
+      warn "Unable to read history file: #{error.message}"
     end
 
     # The default pusher. Appends the given line to Readline::HISTORY.
@@ -111,17 +136,26 @@ class Pry
       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', 0600).tap do |file|
           file.sync = true
         end
       end
-    rescue Errno::EACCES
-      warn 'History not saved; unable to open your history file for writing.'
+    rescue SystemCallError => error
+      warn "Unable to write history file: #{error.message}"
       @history_file = false
     end
 
     def history_file_path
       File.expand_path(@file_path || Pry.config.history.file)
     end
+
+    def invalid_readline_line?(line)
+      # `Readline::HISTORY << line` raises an `ArgumentError` if `line`
+      # includes a null byte
+      line.include?("\0")
+    end
   end
 end

data/lib/pry/hooks.rb

@@ -1,37 +1,21 @@
 class Pry
-
-  # Implements a hooks system for Pry. A hook is a callable that is
-  # associated with an event. A number of events are currently
-  # provided by Pry, these include: `:when_started`, `:before_session`, `:after_session`.
-  # A hook must have a name, and is connected with an event by the
-  # `Pry::Hooks#add_hook` method.
+  # Implements a hooks system for Pry. A hook is a callable that is associated
+  # with an event. A number of events are currently provided by Pry, these
+  # include: `:when_started`, `:before_session`, `:after_session`.  A hook must
+  # have a name, and is connected with an event by the `Pry::Hooks#add_hook`
+  # method.
+  #
   # @example Adding a hook for the `:before_session` event.
   #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
   #     puts "hello"
   #   end
   class Hooks
-
-    # Converts a hash to a `Pry::Hooks` instance. All hooks defined
-    # this way are anonymous. This functionality is primarily to
-    # provide backwards-compatibility with the old hash-based hook
-    # system in Pry versions < 0.9.8
-    # @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
-
     def initialize
-      @hooks = {}
+      @hooks = Hash.new { |h, k| h[k] = [] }
     end
 
-    # Ensure that duplicates have their @hooks object
-    def initialize_copy(orig)
+    # Ensure that duplicates have their @hooks object.
+    def initialize_copy(_orig)
       hooks_dup = @hooks.dup
       @hooks.each do |k, v|
         hooks_dup[k] = v.dup
@@ -40,63 +24,49 @@ class Pry
       @hooks = hooks_dup
     end
 
-    def hooks
-      @hooks
-    end
-    protected :hooks
-
     def errors
       @errors ||= []
     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.
-    # @example
-    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   Pry::Hooks.new.merge!(hooks)
+    # @return [Pry:Hooks] The receiver.
+    # @see #merge
     def merge!(other)
-      @hooks.merge!(other.dup.hooks) do |key, v1, v2|
-        merge_arrays(v1, v2)
-      end
+      @hooks.merge!(other.dup.hooks) do |key, array, other_array|
+        temp_hash, output = {}, []
 
-      self
-    end
+        (array + other_array).reverse_each do |pair|
+          temp_hash[pair.first] ||= output.unshift(pair)
+        end
 
-    def merge_arrays(array1, array2)
-      uniq_keeping_last(array1 + array2, &:first)
-    end
-    private :merge_arrays
+        output
+      end
 
-    def uniq_keeping_last(input, &block)
-      hash, output = {}, []
-      input.reverse.each{ |i| hash[block[i]] ||= (output.unshift i) }
-      output
+      self
     end
-    private :uniq_keeping_last
 
-    # Return a new `Pry::Hooks` instance containing a merge of the contents of two `Pry:Hooks` instances,
-    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
-    # @return [Pry::Hooks] The new hash.
     # @example
     #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
     #   Pry::Hooks.new.merge(hooks)
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the
+    #   contents of two `Pry:Hooks` instances.
     def merge(other)
       self.dup.tap do |v|
         v.merge!(other)
       end
     end
 
-    # Add a new hook to be executed for the `name` even.
+    # Add a new hook to be executed for the `event_name` event.
     # @param [Symbol] event_name The name of the event.
     # @param [Symbol] hook_name The name of the hook.
     # @param [#call] callable The callable.
-    # @yield The block to use as the callable (if `callable` parameter not provided)
-    # @return [Pry:Hooks] Returns the receiver.
-    # @example
-    #   Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    def add_hook(event_name, hook_name, callable=nil, &block)
-      @hooks[event_name] ||= []
+    # @yield The block to use as the callable (if no `callable` provided).
+    # @return [Pry:Hooks] The receiver.
+    def add_hook(event_name, hook_name, callable = nil, &block)
+      event_name = event_name.to_s
 
       # do not allow duplicates, but allow multiple `nil` hooks
       # (anonymous hooks)
@@ -124,13 +94,8 @@ class Pry
     # @param [Symbol] event_name The name of the event.
     # @param [Array] args The arguments to pass to each hook function.
     # @return [Object] The return value of the last executed hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.exec_hook(:before_session) #=> OUTPUT: "hi!"
     def exec_hook(event_name, *args, &block)
-      @hooks[event_name] ||= []
-
-      @hooks[event_name].map do |hook_name, callable|
+      @hooks[event_name.to_s].map do |hook_name, callable|
         begin
           callable.call(*args, &block)
         rescue RescuableException => e
@@ -140,56 +105,38 @@ class Pry
       end.last
     end
 
-    # Return the number of hook functions registered for the `event_name` event.
     # @param [Symbol] event_name The name of the event.
     # @return [Fixnum] The number of hook functions for `event_name`.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.count(:before_session) #=> 1
     def hook_count(event_name)
-      @hooks[event_name] ||= []
-      @hooks[event_name].size
+      @hooks[event_name.to_s].size
     end
 
-    # Return a specific hook for a given event.
     # @param [Symbol] event_name The name of the event.
     # @param [Symbol] hook_name The name of the hook
-    # @return [#call] The requested hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.get_hook(:before_session, :say_hi).call #=> "hi!"
+    # @return [#call] a specific hook for a given event.
     def get_hook(event_name, hook_name)
-      @hooks[event_name] ||= []
-      hook = @hooks[event_name].find { |current_hook_name, callable| current_hook_name == hook_name }
+      hook = @hooks[event_name.to_s].find do |current_hook_name, callable|
+        current_hook_name == hook_name
+      end
       hook.last if hook
     end
 
-    # Return the hash of hook names / hook functions for a
-    # given event. (Note that modifying the returned hash does not
-    # alter the hooks, use add_hook/delete_hook for that).
     # @param [Symbol] event_name The name of the event.
     # @return [Hash] The hash of hook names / hook functions.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.get_hooks(:before_session) #=> {:say_hi=>#<Proc:0x00000101645e18@(pry):9>}
+    # @note Modifying the returned hash does not alter the hooks, use
+    # `add_hook`/`delete_hook` for that.
     def get_hooks(event_name)
-      @hooks[event_name] ||= []
-      Hash[@hooks[event_name]]
+      Hash[@hooks[event_name.to_s]]
     end
 
-    # Delete a hook for an event.
     # @param [Symbol] event_name The name of the event.
     # @param [Symbol] hook_name The name of the hook.
     #   to delete.
     # @return [#call] The deleted hook.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.delete_hook(:before_session, :say_hi)
     def delete_hook(event_name, hook_name)
-      @hooks[event_name] ||= []
       deleted_callable = nil
 
-      @hooks[event_name].delete_if do |current_hook_name, callable|
+      @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
         if current_hook_name == hook_name
           deleted_callable = callable
           true
@@ -201,30 +148,24 @@ class Pry
     end
 
     # Clear all hooks functions for a given event.
+    #
     # @param [String] event_name The name of the event.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.delete_hook(:before_session)
-    def delete_hooks(event_name)
-      @hooks[event_name] = []
-    end
-
-    alias_method :clear, :delete_hooks
-
-    # Remove all events and hooks, clearing out the Pry::Hooks
-    # instance completely.
-    # @example
-    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   my_hooks.clear_all
-    def clear_all
-      @hooks = {}
+    # @return [void]
+    def clear_event_hooks(event_name)
+      @hooks[event_name.to_s] = []
     end
 
     # @param [Symbol] event_name Name of the event.
     # @param [Symbol] hook_name Name of the hook.
-    # @return [Boolean] Whether the hook by the name `hook_name`
+    # @return [Boolean] Whether the hook by the name `hook_name`.
     def hook_exists?(event_name, hook_name)
-      !!(@hooks[event_name] && @hooks[event_name].find { |name, _| name == hook_name })
+      @hooks[event_name.to_s].map(&:first).include?(hook_name)
+    end
+
+    protected
+
+    def hooks
+      @hooks
     end
   end
 end

data/lib/pry/indent.rb

@@ -66,8 +66,10 @@ class Pry
     #
     # :reserved and :keywords are the CodeRay 0.9.8 and 1.0.0 respectively
     # classifications of "super", "next", "return", etc.
-    STATEMENT_END_TOKENS = IGNORE_TOKENS + [:regexp, :integer, :float, :keyword,
-                                            :delimiter, :reserved]
+    STATEMENT_END_TOKENS = IGNORE_TOKENS + [:regexp, :integer, :float,
+                                            :keyword, :delimiter, :reserved,
+                                            :instance_variable,
+                                            :class_variable, :global_variable]
 
     # Collection of tokens that should appear dedented even though they
     # don't affect the surrounding code.
@@ -141,10 +143,9 @@ class Pry
       prefix = indent_level
 
       input.lines.each do |line|
-
         if in_string?
           tokens = tokenize("#{open_delimiters_line}\n#{line}")
-          tokens = tokens.drop_while{ |token, type| !(String === token && token.include?("\n")) }
+          tokens = tokens.drop_while { |token, type| !(String === token && token.include?("\n")) }
           previously_in_string = true
         else
           tokens = tokenize(line)
@@ -153,7 +154,7 @@ class Pry
 
         before, after = indentation_delta(tokens)
 
-        before.times{ prefix.sub! SPACES, '' }
+        before.times { prefix.sub! SPACES, '' }
         new_prefix = prefix + SPACES * after
 
         line = prefix + line.lstrip unless previously_in_string
@@ -213,7 +214,7 @@ class Pry
       # If the list of tokens contains a matching closing token the line should
       # not be indented (and thus we should return true).
       tokens.each do |token, kind|
-        is_singleline_if  = (SINGLELINE_TOKENS.include?(token)) && end_of_statement?(last_token, last_kind)
+        is_singleline_if = (SINGLELINE_TOKENS.include?(token)) && end_of_statement?(last_token, last_kind)
         is_optional_do = (token == "do" && seen_for_at.include?(add_after - 1))
 
         last_token, last_kind = token, kind unless kind == :space
@@ -223,6 +224,8 @@ class Pry
 
         seen_for_at << add_after if OPTIONAL_DO_TOKENS.include?(token)
 
+        next if is_singleline_if
+
         if kind == :delimiter
           track_delimiter(token)
         elsif OPEN_TOKENS.keys.include?(token) && !is_optional_do && !is_singleline_if
@@ -354,7 +357,7 @@ class Pry
     #
     # @param [String] token  a token from Coderay
     # @param [Symbol] kind  the kind of that token
-    def track_module_nesting_end(token, kind=:keyword)
+    def track_module_nesting_end(token, kind = :keyword)
       if kind == :keyword && (token == "class" || token == "module")
         @module_nesting.pop
       end
@@ -378,25 +381,24 @@ class Pry
     # the correct indentation. Mostly useful for fixing 'end'.
     #
     # @param [String] prompt The user's prompt
-    # @param [String] code   The code the user just typed in.
-    # @param [Fixnum] overhang (0) The number of chars to erase afterwards (i.e.,
-    #   the difference in length between the old line and the new one).
-    # @return [String]
-    def correct_indentation(prompt, code, overhang=0)
+    # @param [String] code The code the user just typed in
+    # @param [Integer] overhang The number of characters to erase afterwards (the
+    #   the difference in length between the old line and the new one)
+    #
+    # @return [String] correctly indented line
+    def correct_indentation(prompt, code, overhang = 0)
       prompt = prompt.delete("\001\002")
       line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
       whitespace = ' ' * overhang
 
-      _, cols = Terminal.screen_size
-
-      cols = cols.to_i
-      lines = (cols != 0 ? (line_to_measure.length / cols + 1) : 1).to_i
+      cols = Terminal.width!
+      lines = cols == 0 ? 1 : (line_to_measure.length / cols + 1).to_i
 
-      if Pry::Helpers::BaseHelpers.windows_ansi?
-        move_up   = "\e[#{lines}F"
+      if Helpers::Platform.windows_ansi?
+        move_up = "\e[#{lines}F"
         move_down = "\e[#{lines}E"
       else
-        move_up   = "\e[#{lines}A\e[0G"
+        move_up = "\e[#{lines}A\e[0G"
         move_down = "\e[#{lines}B\e[0G"
       end