pry 0.10.3 → 0.14.2

data/lib/pry/hooks.rb

@@ -1,37 +1,33 @@
-class Pry
+# frozen_string_literal: true
 
-  # 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.
+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.
+  #
   # @example Adding a hook for the `:before_session` event.
   #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
   #     puts "hello"
   #   end
   class Hooks
+    def self.default
+      hooks = new
+      hooks.add_hook(:before_session, :default) do |_out, _target, pry_instance|
+        next if pry_instance.quiet?
 
-    # 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)
+        pry_instance.run_command('whereami --quiet')
       end
-      instance
+      hooks
     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 +36,50 @@ 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|
+      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)
@@ -104,12 +87,10 @@ class Pry
         raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
       end
 
-      if !block && !callable
-        raise ArgumentError, "Must provide a block or callable."
-      end
+      raise ArgumentError, "Must provide a block or callable." if !block && !callable
 
       # ensure we only have one anonymous hook
-      @hooks[event_name].delete_if { |h, k| h.nil? } if hook_name.nil?
+      @hooks[event_name].delete_if { |h, _k| h.nil? } if hook_name.nil?
 
       if block
         @hooks[event_name] << [hook_name, block]
@@ -124,13 +105,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 +116,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 +159,22 @@ 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
+
+    attr_reader :hooks
   end
 end

data/lib/pry/indent.rb

@@ -1,4 +1,4 @@
-require 'coderay'
+# frozen_string_literal: true
 
 class Pry
   ##
@@ -21,35 +21,35 @@ class Pry
     attr_reader :stack
 
     # The amount of spaces to insert for each indent level.
-    SPACES = '  '
+    SPACES = '  '.freeze
 
     # Hash containing all the tokens that should increase the indentation
     # level. The keys of this hash are open tokens, the values the matching
     # tokens that should prevent a line from being indented if they appear on
     # the same line.
     OPEN_TOKENS = {
-      'def'    => 'end',
-      'class'  => 'end',
+      'def' => 'end',
+      'class' => 'end',
       'module' => 'end',
-      'do'     => 'end',
-      'if'     => 'end',
+      'do' => 'end',
+      'if' => 'end',
       'unless' => 'end',
-      'while'  => 'end',
-      'until'  => 'end',
-      'for'    => 'end',
-      'case'   => 'end',
-      'begin'  => 'end',
-      '['      => ']',
-      '{'      => '}',
-      '('      => ')'
-    }
+      'while' => 'end',
+      'until' => 'end',
+      'for' => 'end',
+      'case' => 'end',
+      'begin' => 'end',
+      '[' => ']',
+      '{' => '}',
+      '(' => ')'
+    }.freeze
 
     # Which tokens can either be open tokens, or appear as modifiers on
     # a single-line.
-    SINGLELINE_TOKENS = %w(if while until unless rescue)
+    SINGLELINE_TOKENS = %w[if while until unless rescue].freeze
 
     # Which tokens can be followed by an optional "do" keyword.
-    OPTIONAL_DO_TOKENS = %w(for while until)
+    OPTIONAL_DO_TOKENS = %w[for while until].freeze
 
     # Collection of token types that should be ignored. Without this list
     # keywords such as "class" inside strings would cause the code to be
@@ -57,8 +57,8 @@ class Pry
     #
     # :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0
     # classifications of "true", "false", and "nil".
-    IGNORE_TOKENS = [:space, :content, :string, :method, :ident,
-                     :constant, :pre_constant, :predefined_constant]
+    IGNORE_TOKENS = %i[space content string method ident
+                       constant pre_constant predefined_constant].freeze
 
     # Tokens that indicate the end of a statement (i.e. that, if they appear
     # directly before an "if" indicates that that if applies to the same line,
@@ -66,12 +66,14 @@ 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 + %i[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.
-    MIDWAY_TOKENS = %w(when else elsif ensure rescue)
+    MIDWAY_TOKENS = %w[when else elsif ensure rescue].freeze
 
     # Clean the indentation of a fragment of ruby.
     #
@@ -99,14 +101,15 @@ class Pry
       indent.module_nesting
     end
 
-    def initialize
+    def initialize(pry_instance = Pry.new)
+      @pry_instance = pry_instance
       reset
     end
 
     # reset internal state
     def reset
       @stack = []
-      @indent_level = ''
+      @indent_level = String.new # rubocop:disable Style/EmptyLiteral
       @heredoc_queue = []
       @close_heredocs = {}
       @string_start = nil
@@ -141,10 +144,11 @@ 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 do |token, _type|
+            !(token.is_a?(String) && token.include?("\n"))
+          end
           previously_in_string = true
         else
           tokens = tokenize(line)
@@ -153,7 +157,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
@@ -165,7 +169,7 @@ class Pry
 
       @indent_level = prefix
 
-      return output
+      output
     end
 
     # Get the indentation for the start of the next line.
@@ -192,7 +196,6 @@ class Pry
     # @return [Array[Integer]]
     #
     def indentation_delta(tokens)
-
       # We need to keep track of whether we've seen a "for" on this line because
       # if the line ends with "do" then that "do" should be discounted (i.e. we're
       # only opening one level not two) To do this robustly we want to keep track
@@ -203,29 +206,37 @@ class Pry
       # When deciding whether an "if" token is the start of a multiline statement,
       # or just the middle of a single-line if statement, we just look at the
       # preceding token, which is tracked here.
-      last_token, last_kind = [nil, nil]
+      last_token = nil
+      last_kind = nil
 
       # delta keeps track of the total difference from the start of each line after
       # the given token, 0 is just the level at which the current line started for
       # reference.
-      remove_before, add_after = [0, 0]
+      remove_before = 0
+      add_after = 0
 
       # 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
+        unless kind == :space
+          last_token = token
+          last_kind = kind
+        end
         next if IGNORE_TOKENS.include?(kind)
 
         track_module_nesting(token, kind)
 
         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
+        elsif OPEN_TOKENS.key?(token) && !is_optional_do && !is_singleline_if
           @stack << token
           add_after += 1
         elsif token == OPEN_TOKENS[@stack.last]
@@ -244,20 +255,21 @@ class Pry
         end
       end
 
-      return [remove_before, add_after]
+      [remove_before, add_after]
     end
 
-    # If the code just before an "if" or "while" token on a line looks like the end of a statement,
-    # then we want to treat that "if" as a singleline, not multiline statement.
+    # If the code just before an "if" or "while" token on a line looks like the
+    # end of a statement, then we want to treat that "if" as a singleline, not
+    # multiline statement.
     def end_of_statement?(last_token, last_kind)
-      (last_token =~ /^[)\]}\/]$/ || STATEMENT_END_TOKENS.include?(last_kind))
+      (last_token =~ %r{^[)\]\}/]$} || STATEMENT_END_TOKENS.include?(last_kind))
     end
 
     # Are we currently in the middle of a string literal.
     #
-    # This is used to determine whether to re-indent a given line, we mustn't re-indent
-    # within string literals because to do so would actually change the value of the
-    # String!
+    # This is used to determine whether to re-indent a given line, we mustn't
+    # re-indent within string literals because to do so would actually change
+    # the value of the String!
     #
     # @return Boolean
     def in_string?
@@ -269,16 +281,17 @@ class Pry
     # @param [String] string The Ruby to lex
     # @return [Array] An Array of pairs of [token_value, token_type]
     def tokenize(string)
-      tokens = CodeRay.scan(string, :ruby)
+      tokens = SyntaxHighlighter.tokenize(string)
       tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens) # Coderay 1.0.0
       tokens.to_a
     end
 
     # Update the internal state about what kind of strings are open.
     #
-    # Most of the complication here comes from the fact that HEREDOCs can be nested. For
-    # normal strings (which can't be nested) we assume that CodeRay correctly pairs
-    # open-and-close delimiters so we don't bother checking what they are.
+    # Most of the complication here comes from the fact that HEREDOCs can be
+    # nested. For normal strings (which can't be nested) we assume that CodeRay
+    # correctly pairs open-and-close delimiters so we don't bother checking what
+    # they are.
     #
     # @param [String] token The token (of type :delimiter)
     def track_delimiter(token)
@@ -289,11 +302,7 @@ class Pry
       when @close_heredocs[@heredoc_queue.first]
         @heredoc_queue.shift
       else
-        if @string_start
-          @string_start = nil
-        else
-          @string_start = token
-        end
+        @string_start = @string_start ? nil : token
       end
     end
 
@@ -309,7 +318,7 @@ class Pry
     #
     # @return String
     def open_delimiters_line
-      "puts #{open_delimiters.join(", ")}"
+      "puts #{open_delimiters.join(', ')}"
     end
 
     # Update the internal state relating to module nesting.
@@ -330,7 +339,7 @@ class Pry
     # @param [String] token  a token from Coderay
     # @param [Symbol] kind  the kind of that token
     def track_module_nesting(token, kind)
-      if kind == :keyword && (token == "class" || token == "module")
+      if kind == :keyword && %w[class module].include?(token)
         @module_nesting << [token, nil]
         @awaiting_class = true
       elsif @awaiting_class
@@ -354,10 +363,8 @@ 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)
-      if kind == :keyword && (token == "class" || token == "module")
-        @module_nesting.pop
-      end
+    def track_module_nesting_end(token, kind = :keyword)
+      @module_nesting.pop if kind == :keyword && %w[class module].include?(token)
     end
 
     # Return a list of strings which can be used to re-construct the Module.nesting at
@@ -378,25 +385,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 = @pry_instance.output.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