pry 0.12.2-java → 0.13.0-java

data/lib/pry/hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 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
@@ -10,6 +12,16 @@ class Pry
   #     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?
+
+        pry_instance.run_command('whereami --quiet')
+      end
+      hooks
+    end
+
     def initialize
       @hooks = Hash.new { |h, k| h[k] = [] }
     end
@@ -34,8 +46,9 @@ class Pry
     # @return [Pry:Hooks] The receiver.
     # @see #merge
     def merge!(other)
-      @hooks.merge!(other.dup.hooks) do |key, array, other_array|
-        temp_hash, output = {}, []
+      @hooks.merge!(other.dup.hooks) do |_key, array, other_array|
+        temp_hash = {}
+        output = []
 
         (array + other_array).reverse_each do |pair|
           temp_hash[pair.first] ||= output.unshift(pair)
@@ -54,7 +67,7 @@ class Pry
     # @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
@@ -74,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]
@@ -95,7 +106,7 @@ class Pry
     # @param [Array] args The arguments to pass to each hook function.
     # @return [Object] The return value of the last executed hook.
     def exec_hook(event_name, *args, &block)
-      @hooks[event_name.to_s].map do |hook_name, callable|
+      @hooks[event_name.to_s].map do |_hook_name, callable|
         begin
           callable.call(*args, &block)
         rescue RescuableException => e
@@ -115,7 +126,7 @@ class Pry
     # @param [Symbol] hook_name The name of the hook
     # @return [#call] a specific hook for a given event.
     def get_hook(event_name, hook_name)
-      hook = @hooks[event_name.to_s].find do |current_hook_name, callable|
+      hook = @hooks[event_name.to_s].find do |current_hook_name, _callable|
         current_hook_name == hook_name
       end
       hook.last if hook
@@ -164,8 +175,6 @@ class Pry
 
     protected
 
-    def hooks
-      @hooks
-    end
+    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
@@ -58,7 +58,7 @@ 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]
+                     :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,
@@ -73,7 +73,7 @@ class Pry
 
     # 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.
     #
@@ -101,7 +101,8 @@ class Pry
       indent.module_nesting
     end
 
-    def initialize
+    def initialize(pry_instance = Pry.new)
+      @pry_instance = pry_instance
       reset
     end
 
@@ -145,7 +146,9 @@ class Pry
       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)
@@ -166,7 +169,7 @@ class Pry
 
       @indent_level = prefix
 
-      return output
+      output
     end
 
     # Get the indentation for the start of the next line.
@@ -193,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
@@ -204,20 +206,26 @@ 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)
@@ -228,7 +236,7 @@ class Pry
 
         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]
@@ -247,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?
@@ -272,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)
@@ -292,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
 
@@ -312,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.
@@ -333,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
@@ -358,9 +364,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)
-      if kind == :keyword && (token == "class" || token == "module")
-        @module_nesting.pop
-      end
+      @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
@@ -391,7 +395,7 @@ class Pry
       line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
       whitespace = ' ' * overhang
 
-      cols = Terminal.width!
+      cols = @pry_instance.output.width
       lines = cols == 0 ? 1 : (line_to_measure.length / cols + 1).to_i
 
       if Helpers::Platform.windows_ansi?

data/lib/pry/input_completer.rb

@@ -1,265 +1,283 @@
+# frozen_string_literal: true
+
 # taken from irb
 # Implements tab completion for Readline in Pry
-class Pry::InputCompleter
-  NUMERIC_REGEXP            = /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-  ARRAY_REGEXP              = /^([^\]]*\])\.([^.]*)$/
-  SYMBOL_REGEXP             = /^(:[^:.]*)$/
-  SYMBOL_METHOD_CALL_REGEXP = /^(:[^:.]+)\.([^.]*)$/
-  REGEX_REGEXP              = /^(\/[^\/]*\/)\.([^.]*)$/
-  PROC_OR_HASH_REGEXP       = /^([^\}]*\})\.([^.]*)$/
-  TOPLEVEL_LOOKUP_REGEXP    = /^::([A-Z][^:\.\(]*)$/
-  CONSTANT_REGEXP           = /^([A-Z][A-Za-z0-9]*)$/
-  CONSTANT_OR_METHOD_REGEXP = /^([A-Z].*)::([^:.]*)$/
-  HEX_REGEXP                = /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
-  GLOBALVARIABLE_REGEXP     = /^(\$[^.]*)$/
-  VARIABLE_REGEXP           = /^([^."].*)\.([^.]*)$/
-
-  ReservedWords = [
-                   "BEGIN", "END",
-                   "alias", "and",
-                   "begin", "break",
-                   "case", "class",
-                   "def", "defined", "do",
-                   "else", "elsif", "end", "ensure",
-                   "false", "for",
-                   "if", "in",
-                   "module",
-                   "next", "nil", "not",
-                   "or",
-                   "redo", "rescue", "retry", "return",
-                   "self", "super",
-                   "then", "true",
-                   "undef", "unless", "until",
-                   "when", "while",
-                   "yield" ]
+class Pry
+  class InputCompleter
+    NUMERIC_REGEXP = /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/.freeze
+    ARRAY_REGEXP = /^([^\]]*\])\.([^.]*)$/.freeze
+    SYMBOL_REGEXP = /^(:[^:.]*)$/.freeze
+    SYMBOL_METHOD_CALL_REGEXP = /^(:[^:.]+)\.([^.]*)$/.freeze
+    REGEX_REGEXP = %r{^(/[^/]*/)\.([^.]*)$}.freeze
+    PROC_OR_HASH_REGEXP = /^([^\}]*\})\.([^.]*)$/.freeze
+    TOPLEVEL_LOOKUP_REGEXP = /^::([A-Z][^:\.\(]*)$/.freeze
+    CONSTANT_REGEXP = /^([A-Z][A-Za-z0-9]*)$/.freeze
+    CONSTANT_OR_METHOD_REGEXP = /^([A-Z].*)::([^:.]*)$/.freeze
+    HEX_REGEXP = /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/.freeze
+    GLOBALVARIABLE_REGEXP = /^(\$[^.]*)$/.freeze
+    VARIABLE_REGEXP = /^([^."].*)\.([^.]*)$/.freeze
 
-  Operators = [
-               "%", "&", "*", "**", "+", "-", "/",
-               "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
-               "[]", "[]=", "^", "!", "!=", "!~"
-              ]
+    RESERVED_WORDS = %w[
+      BEGIN END
+      alias and
+      begin break
+      case class
+      def defined do
+      else elsif end ensure
+      false for
+      if in
+      module
+      next nil not
+      or
+      redo rescue retry return
+      self super
+      then true
+      undef unless until
+      when while
+      yield
+    ].freeze
 
-  WORD_ESCAPE_STR = " \t\n\"\\'`><=;|&{("
+    WORD_ESCAPE_STR = " \t\n\"\\'`><=;|&{(".freeze
 
-  def initialize(input, pry = nil)
-    @pry = pry
-    @input = input
-    @input.basic_word_break_characters = WORD_ESCAPE_STR if @input.respond_to?(:basic_word_break_characters=)
-    @input.completion_append_character = nil if @input.respond_to?(:completion_append_character=)
-  end
+    def initialize(input, pry = nil)
+      @pry = pry
+      @input = input
+      if @input.respond_to?(:basic_word_break_characters=)
+        @input.basic_word_break_characters = WORD_ESCAPE_STR
+      end
 
-  #
-  # Return a new completion proc for use by Readline.
-  #
-  def call(str, options = {})
-    custom_completions = options[:custom_completions] || []
-    # if there are multiple contexts e.g. cd 1/2/3
-    # get new target for 1/2 and find candidates for 3
-    path, input = build_path(str)
+      return unless @input.respond_to?(:completion_append_character=)
 
-    if path.call.empty?
-      target = options[:target]
-    else
-      # Assume the user is tab-completing the 'cd' command
-      begin
-        target = Pry::ObjectPath.new(path.call, @pry.binding_stack).resolve.last
-      # but if that doesn't work, assume they're doing division with no spaces
-      rescue Pry::CommandError
-        target = options[:target]
-      end
+      @input.completion_append_character = nil
     end
 
-    begin
-      bind = target
-      # Complete stdlib symbols
-      case input
-      when REGEX_REGEXP # Regexp
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Regexp.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when ARRAY_REGEXP # Array
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Array.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when PROC_OR_HASH_REGEXP # Proc or Hash
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Proc.instance_methods.collect(&:to_s)
-        candidates |= Hash.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when SYMBOL_REGEXP # Symbol
-        if Symbol.respond_to?(:all_symbols)
-          sym        = Regexp.quote($1)
-          candidates = Symbol.all_symbols.collect { |s| ":" << s.id2name }
-          candidates.grep(/^#{sym}/)
-        else
-          []
-        end
-      when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
-        receiver = $1
-        candidates = Object.constants.collect(&:to_s)
-        candidates.grep(/^#{receiver}/).collect { |e| "::" << e }
-      when CONSTANT_REGEXP # Constant
-        message = $1
-        begin
-          context = target.eval("self")
-          context = context.class unless context.respond_to? :constants
-          candidates = context.constants.collect(&:to_s)
-        rescue
-          candidates = []
-        end
-        candidates = candidates.grep(/^#{message}/).collect(&path)
-      when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
-        receiver = $1
-        message = Regexp.quote($2)
-        begin
-          candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
-          candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
-        rescue Pry::RescuableException
-          candidates = []
-        end
-        candidates.grep(/^#{message}/).collect { |e| receiver + "::" + e }
-      when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Symbol.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when NUMERIC_REGEXP
-        # Numeric
-        receiver = $1
-        message = Regexp.quote($5)
-        begin
-          candidates = eval(receiver, bind).methods.collect(&:to_s)
-        rescue Pry::RescuableException
-          candidates = []
-        end
-        select_message(path, receiver, message, candidates)
-      when HEX_REGEXP
-        # Numeric(0xFFFF)
-        receiver = $1
-        message = Regexp.quote($2)
+    # Return a new completion proc for use by Readline.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def call(str, options = {})
+      custom_completions = options[:custom_completions] || []
+      # if there are multiple contexts e.g. cd 1/2/3
+      # get new target for 1/2 and find candidates for 3
+      path, input = build_path(str)
+
+      if path.call.empty?
+        target = options[:target]
+      else
+        # Assume the user is tab-completing the 'cd' command
         begin
-          candidates = eval(receiver, bind).methods.collect(&:to_s)
-        rescue Pry::RescuableException
-          candidates = []
+          target = Pry::ObjectPath.new(path.call, @pry.binding_stack).resolve.last
+        # but if that doesn't work, assume they're doing division with no spaces
+        rescue Pry::CommandError
+          target = options[:target]
         end
-        select_message(path, receiver, message, candidates)
-      when GLOBALVARIABLE_REGEXP # global
-        regmessage = Regexp.new(Regexp.quote($1))
-        candidates = global_variables.collect(&:to_s).grep(regmessage)
-      when VARIABLE_REGEXP # variable
-        receiver = $1
-        message = Regexp.quote($2)
-
-        gv = eval("global_variables", bind).collect(&:to_s)
-        lv = eval("local_variables", bind).collect(&:to_s)
-        cv = eval("self.class.constants", bind).collect(&:to_s)
+      end
 
-        if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
-          # foo.func and foo is local var. OR
-          # Foo::Bar.func
+      begin
+        bind = target
+        # Complete stdlib symbols
+        case input
+        when REGEX_REGEXP # Regexp
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Regexp.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when ARRAY_REGEXP # Array
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Array.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when PROC_OR_HASH_REGEXP # Proc or Hash
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Proc.instance_methods.collect(&:to_s)
+          candidates |= Hash.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when SYMBOL_REGEXP # Symbol
+          if Symbol.respond_to?(:all_symbols)
+            sym = Regexp.quote(Regexp.last_match(1))
+            candidates = Symbol.all_symbols.collect { |s| ":" + s.id2name }
+            candidates.grep(/^#{sym}/)
+          else
+            []
+          end
+        when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
+          receiver = Regexp.last_match(1)
+          candidates = Object.constants.collect(&:to_s)
+          candidates.grep(/^#{receiver}/).collect { |e| "::" + e }
+        when CONSTANT_REGEXP # Constant
+          message = Regexp.last_match(1)
+          begin
+            context = target.eval("self")
+            context = context.class unless context.respond_to? :constants
+            candidates = context.constants.collect(&:to_s)
+          rescue StandardError
+            candidates = []
+          end
+          candidates = candidates.grep(/^#{message}/).collect(&path)
+        when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
           begin
-            candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
+            candidates = eval( # rubocop:disable Security/Eval
+              "#{receiver}.constants.collect(&:to_s)", bind, __FILE__, __LINE__
+            )
+            candidates |= eval( # rubocop:disable Security/Eval
+              "#{receiver}.methods.collect(&:to_s)", bind, __FILE__, __LINE__
+            )
           rescue Pry::RescuableException
             candidates = []
           end
-        else
-          # func1.func2
-          require 'set'
-          candidates = Set.new
-          to_ignore = ignored_modules
-          ObjectSpace.each_object(Module) { |m|
-            next if (to_ignore.include?(m) rescue true)
+          candidates.grep(/^#{message}/).collect { |e| receiver + "::" + e }
+        when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Symbol.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when NUMERIC_REGEXP
+          # Numeric
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(5))
+          begin
+            # rubocop:disable Security/Eval
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+            # rubocop:enable Security/Eval
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when HEX_REGEXP
+          # Numeric(0xFFFF)
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          begin
+            # rubocop:disable Security/Eval
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+            # rubocop:enable Security/Eval
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when GLOBALVARIABLE_REGEXP # global
+          regmessage = Regexp.new(Regexp.quote(Regexp.last_match(1)))
+          candidates = global_variables.collect(&:to_s).grep(regmessage)
+        when VARIABLE_REGEXP # variable
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
 
-            # jruby doesn't always provide #instance_methods() on each
-            # object.
-            if m.respond_to?(:instance_methods)
-              candidates.merge m.instance_methods(false).collect(&:to_s)
+          gv = eval("global_variables", bind, __FILE__, __LINE__).collect(&:to_s)
+          lv = eval("local_variables", bind, __FILE__, __LINE__).collect(&:to_s)
+          cv = eval("self.class.constants", bind, __FILE__, __LINE__).collect(&:to_s)
+
+          if (gv | lv | cv).include?(receiver) || /^[A-Z]/ =~ receiver && /\./ !~ receiver
+            # foo.func and foo is local var. OR
+            # Foo::Bar.func
+            begin
+              candidates = eval( # rubocop:disable Security/Eval
+                "#{receiver}.methods", bind, __FILE__, __LINE__
+              ).collect(&:to_s)
+            rescue Pry::RescuableException
+              candidates = []
             end
-          }
-        end
-        select_message(path, receiver, message, candidates.sort)
-      when /^\.([^.]*)$/
-        # Unknown(maybe String)
-        receiver = ""
-        message = Regexp.quote($1)
-        candidates = String.instance_methods(true).collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      else
-        candidates = eval(
-                          "methods | private_methods | local_variables | " \
-                          "self.class.constants | instance_variables",
-                          bind
-                          ).collect(&:to_s)
+          else
+            # func1.func2
+            require 'set'
+            candidates = Set.new
+            to_ignore = ignored_modules
+            ObjectSpace.each_object(Module) do |m|
+              next if begin
+                        to_ignore.include?(m)
+                      rescue StandardError
+                        true
+                      end
+
+              # jruby doesn't always provide #instance_methods() on each
+              # object.
+              if m.respond_to?(:instance_methods)
+                candidates.merge m.instance_methods(false).collect(&:to_s)
+              end
+            end
+          end
+          select_message(path, receiver, message, candidates.sort)
+        when /^\.([^.]*)$/
+          # Unknown(maybe String)
+          receiver = ""
+          message = Regexp.quote(Regexp.last_match(1))
+          candidates = String.instance_methods(true).collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        else
+          candidates = eval(
+            "methods | private_methods | local_variables | " \
+            "self.class.constants | instance_variables",
+            bind, __FILE__, __LINE__ - 2
+          ).collect(&:to_s)
 
-        if eval("respond_to?(:class_variables)", bind)
-          candidates += eval("class_variables", bind).collect(&:to_s)
+          if eval("respond_to?(:class_variables)", bind, __FILE__, __LINE__)
+            candidates += eval(
+              "class_variables", bind, __FILE__, __LINE__
+            ).collect(&:to_s)
+          end
+          candidates =
+            (candidates | RESERVED_WORDS | custom_completions)
+              .grep(/^#{Regexp.quote(input)}/)
+          candidates.collect(&path)
         end
-        candidates = (candidates | ReservedWords | custom_completions).grep(/^#{Regexp.quote(input)}/)
-        candidates.collect(&path)
+      rescue Pry::RescuableException
+        []
       end
-    rescue Pry::RescuableException
-      []
     end
-  end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-  def select_message(path, receiver, message, candidates)
-    candidates.grep(/^#{message}/).collect { |e|
-      case e
-      when /^[a-zA-Z_]/
-        path.call(receiver + "." << e)
-      when /^[0-9]/
-      when *Operators
-        #receiver + " " << e
-      end
-    }.compact
-  end
+    def select_message(path, receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect do |e|
+        next unless e =~ /^[a-zA-Z_]/
 
-  # build_path seperates the input into two parts: path and input.
-  # input is the partial string that should be completed
-  # path is a proc that takes an input and builds a full path.
-  def build_path(input)
-    # check to see if the input is a regex
-    return proc { |i| i.to_s }, input if input[/\/\./]
+        path.call(receiver + "." + e)
+      end.compact
+    end
+
+    # build_path seperates the input into two parts: path and input.
+    # input is the partial string that should be completed
+    # path is a proc that takes an input and builds a full path.
+    def build_path(input)
+      # check to see if the input is a regex
+      return proc { |i| i.to_s }, input if input[%r{/\.}]
 
-    trailing_slash = input.end_with?('/')
-    contexts = input.chomp('/').split(/\//)
-    input = contexts[-1]
-    path = proc do |i|
-      p = contexts[0..-2].push(i).join('/')
-      p += '/' if trailing_slash && !i.nil?
-      p
+      trailing_slash = input.end_with?('/')
+      contexts = input.chomp('/').split(%r{/})
+      input = contexts[-1]
+      path = proc do |i|
+        p = contexts[0..-2].push(i).join('/')
+        p += '/' if trailing_slash && !i.nil?
+        p
+      end
+      [path, input]
     end
-    return path, input
-  end
 
-  def ignored_modules
-    # We could cache the result, but IRB is not loaded by default.
-    # And this is very fast anyway.
-    # By using this approach, we avoid Module#name calls, which are
-    # relatively slow when there are a lot of anonymous modules defined.
-    s = Set.new
+    def ignored_modules
+      # We could cache the result, but IRB is not loaded by default.
+      # And this is very fast anyway.
+      # By using this approach, we avoid Module#name calls, which are
+      # relatively slow when there are a lot of anonymous modules defined.
+      s = Set.new
 
-    scanner = lambda do |m|
-      next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
+      scanner = lambda do |m|
+        next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
 
-      s << m
-      m.constants(false).each do |c|
-        value = m.const_get(c)
-        scanner.call(value) if value.is_a?(Module)
+        s << m
+        m.constants(false).each do |c|
+          value = m.const_get(c)
+          scanner.call(value) if value.is_a?(Module)
+        end
       end
-    end
 
-    # FIXME: Add Pry here as well?
-    [:IRB, :SLex, :RubyLex, :RubyToken].each do |module_name|
-      next unless Object.const_defined?(module_name)
+      # FIXME: Add Pry here as well?
+      [:IRB, :SLex, :RubyLex, :RubyToken].each do |module_name|
+        next unless Object.const_defined?(module_name)
 
-      scanner.call(Object.const_get(module_name))
-    end
+        scanner.call(Object.const_get(module_name))
+      end
 
-    s.delete(IRB::Context) if defined?(IRB::Context)
-    s
+      s.delete(IRB::Context) if defined?(IRB::Context)
+      s
+    end
   end
 end