Class: IRB::RegexpCompletor

Inherits:

BaseCompletor

• Object
• BaseCompletor
• IRB::RegexpCompletor

Defined in:

lib/irb/completion.rb

Overview

:nodoc:

Constant Summary

Operators =

Set of available operators in Ruby

%w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]

Constants inherited from BaseCompletor

BaseCompletor::GEM_PATHS, BaseCompletor::HELP_COMMAND_PREPOSING, BaseCompletor::ReservedWords

Instance Method Summary

• #complete_require_path(target, preposing, postposing) ⇒ Object
• #completion_candidates(preposing, target, postposing, bind:) ⇒ Object
• #doc_namespace(_preposing, matched, _postposing, bind:) ⇒ Object
• #inspect ⇒ Object
• #retrieve_completion_data(input, bind:, doc_namespace:) ⇒ Object
• #select_message(receiver, message, candidates, sep = ".") ⇒ Object

Methods inherited from BaseCompletor

#command_candidates, #retrieve_files_to_require_from_load_path, #retrieve_files_to_require_relative_from_current_dir, #retrieve_gem_and_system_load_path

Instance Method Details

#complete_require_path(target, preposing, postposing) ⇒ Object

# File 'lib/irb/completion.rb', line 168

def complete_require_path(target, preposing, postposing)
  if target =~ /\A(['"])([^'"]+)\Z/
    quote = $1
    actual_target = $2
  else
    return nil # It's not String literal
  end
  tokens = RubyLex.ripper_lex_without_warning(preposing.gsub(/\s*\z/, ''))
  tok = nil
  tokens.reverse_each do |t|
    unless [:on_lparen, :on_sp, :on_ignored_sp, :on_nl, :on_ignored_nl, :on_comment].include?(t.event)
      tok = t
      break
    end
  end
  return unless tok&.event == :on_ident && tok.state == Ripper::EXPR_CMDARG

  case tok.tok
  when 'require'
    retrieve_files_to_require_from_load_path.select { |path|
      path.start_with?(actual_target)
    }.map { |path|
      quote + path
    }
  when 'require_relative'
    retrieve_files_to_require_relative_from_current_dir.select { |path|
      path.start_with?(actual_target)
    }.map { |path|
      quote + path
    }
  end
end

#completion_candidates(preposing, target, postposing, bind:) ⇒ Object

# File 'lib/irb/completion.rb', line 201

def completion_candidates(preposing, target, postposing, bind:)
  if result = complete_require_path(target, preposing, postposing)
    return result
  end

  commands = command_candidates(target)

  # When completing the argument of `help` command, only commands should be candidates
  return commands if preposing.match?(HELP_COMMAND_PREPOSING)

  # It doesn't make sense to propose commands with other preposing
  commands = [] unless preposing.empty?

  completion_data = retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.map{ |i| i.encode(Encoding.default_external) }
  commands | completion_data
end

#doc_namespace(_preposing, matched, _postposing, bind:) ⇒ Object

# File 'lib/irb/completion.rb', line 218

def doc_namespace(_preposing, matched, _postposing, bind:)
  retrieve_completion_data(matched, bind: bind, doc_namespace: true)
end

#inspect ⇒ Object

# File 'lib/irb/completion.rb', line 164

def inspect
  'RegexpCompletor'
end

#retrieve_completion_data(input, bind:, doc_namespace:) ⇒ Object

# File 'lib/irb/completion.rb', line 222

def retrieve_completion_data(input, bind:, doc_namespace:)
  case input
  # this regexp only matches the closing character because of irb's Reline.completer_quote_characters setting
  # details are described in: https://github.com/ruby/irb/pull/523
  when /^(.*["'`])\.([^.]*)$/
    # String
    receiver = $1
    message = $2

    if doc_namespace
      "String.#{message}"
    else
      candidates = String.instance_methods.collect{|m| m.to_s}
      select_message(receiver, message, candidates)
    end

  # this regexp only matches the closing character because of irb's Reline.completer_quote_characters setting
  # details are described in: https://github.com/ruby/irb/pull/523
  when /^(.*\/)\.([^.]*)$/
    # Regexp
    receiver = $1
    message = $2

    if doc_namespace
      "Regexp.#{message}"
    else
      candidates = Regexp.instance_methods.collect{|m| m.to_s}
      select_message(receiver, message, candidates)
    end

  when /^([^\]]*\])\.([^.]*)$/
    # Array
    receiver = $1
    message = $2

    if doc_namespace
      "Array.#{message}"
    else
      candidates = Array.instance_methods.collect{|m| m.to_s}
      select_message(receiver, message, candidates)
    end

  when /^([^\}]*\})\.([^.]*)$/
    # Hash or Proc
    receiver = $1
    message = $2

    if doc_namespace
      ["Hash.#{message}", "Proc.#{message}"]
    else
      hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
      proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
      select_message(receiver, message, hash_candidates | proc_candidates)
    end

  when /^(:[^:.]+)$/
    # Symbol
    if doc_namespace
      nil
    else
      sym = $1
      candidates = Symbol.all_symbols.collect do |s|
        s.inspect
      rescue EncodingError
        # ignore
      end
      candidates.grep(/^#{Regexp.quote(sym)}/)
    end
  when /^::([A-Z][^:\.\(\)]*)$/
    # Absolute Constant or class methods
    receiver = $1

    candidates = Object.constants.collect{|m| m.to_s}

    if doc_namespace
      candidates.find { |i| i == receiver }
    else
      candidates.grep(/^#{Regexp.quote(receiver)}/).collect{|e| "::" + e}
    end

  when /^([A-Z].*)::([^:.]*)$/
    # Constant or class methods
    receiver = $1
    message = $2

    if doc_namespace
      "#{receiver}::#{message}"
    else
      begin
        candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
        candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
      rescue Exception
        candidates = []
      end

      select_message(receiver, message, candidates.sort, "::")
    end

  when /^(:[^:.]+)(\.|::)([^.]*)$/
    # Symbol
    receiver = $1
    sep = $2
    message = $3

    if doc_namespace
      "Symbol.#{message}"
    else
      candidates = Symbol.instance_methods.collect{|m| m.to_s}
      select_message(receiver, message, candidates, sep)
    end

  when /^(?<num>-?(?:0[dbo])?[0-9_]+(?:\.[0-9_]+)?(?:(?:[eE][+-]?[0-9]+)?i?|r)?)(?<sep>\.|::)(?<mes>[^.]*)$/
    # Numeric
    receiver = $~[:num]
    sep = $~[:sep]
    message = $~[:mes]

    begin
      instance = eval(receiver, bind)

      if doc_namespace
        "#{instance.class.name}.#{message}"
      else
        candidates = instance.methods.collect{|m| m.to_s}
        select_message(receiver, message, candidates, sep)
      end
    rescue Exception
      if doc_namespace
        nil
      else
        []
      end
    end

  when /^(-?0x[0-9a-fA-F_]+)(\.|::)([^.]*)$/
    # Numeric(0xFFFF)
    receiver = $1
    sep = $2
    message = $3

    begin
      instance = eval(receiver, bind)
      if doc_namespace
        "#{instance.class.name}.#{message}"
      else
        candidates = instance.methods.collect{|m| m.to_s}
        select_message(receiver, message, candidates, sep)
      end
    rescue Exception
      if doc_namespace
        nil
      else
        []
      end
    end

  when /^(\$[^.]*)$/
    # global var
    gvar = $1
    all_gvars = global_variables.collect{|m| m.to_s}

    if doc_namespace
      all_gvars.find{ |i| i == gvar }
    else
      all_gvars.grep(Regexp.new(Regexp.quote(gvar)))
    end

  when /^([^.:"].*)(\.|::)([^.]*)$/
    # variable.func or func.func
    receiver = $1
    sep = $2
    message = $3

    gv = bind.eval_global_variables.collect{|m| m.to_s}.push("true", "false", "nil")
    lv = bind.local_variables.collect{|m| m.to_s}
    iv = bind.eval_instance_variables.collect{|m| m.to_s}
    cv = bind.eval_class_constants.collect{|m| m.to_s}

    if (gv | lv | iv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
      # foo.func and foo is var. OR
      # foo::func and foo is var. OR
      # foo::Const and foo is var. OR
      # Foo::Bar.func
      begin
        candidates = []
        rec = eval(receiver, bind)
        if sep == "::" and rec.kind_of?(Module)
          candidates = rec.constants.collect{|m| m.to_s}
        end
        candidates |= rec.methods.collect{|m| m.to_s}
      rescue Exception
        candidates = []
      end
    else
      # func1.func2
      candidates = []
    end

    if doc_namespace
      rec_class = rec.is_a?(Module) ? rec : rec.class
      "#{rec_class.name}#{sep}#{candidates.find{ |i| i == message }}" rescue nil
    else
      select_message(receiver, message, candidates, sep)
    end

  when /^\.([^.]*)$/
    # unknown(maybe String)

    receiver = ""
    message = $1

    candidates = String.instance_methods(true).collect{|m| m.to_s}

    if doc_namespace
      "String.#{candidates.find{ |i| i == message }}"
    else
      select_message(receiver, message, candidates.sort)
    end
  when /^\s*$/
    # empty input
    if doc_namespace
      nil
    else
      []
    end
  else
    if doc_namespace
      vars = (bind.local_variables | bind.eval_instance_variables).collect{|m| m.to_s}
      perfect_match_var = vars.find{|m| m.to_s == input}
      if perfect_match_var
        eval("#{perfect_match_var}.class.name", bind) rescue nil
      else
        candidates = (bind.eval_methods | bind.eval_private_methods | bind.local_variables | bind.eval_instance_variables | bind.eval_class_constants).collect{|m| m.to_s}
        candidates |= ReservedWords
        candidates.find{ |i| i == input }
      end
    else
      candidates = (bind.eval_methods | bind.eval_private_methods | bind.local_variables | bind.eval_instance_variables | bind.eval_class_constants).collect{|m| m.to_s}
      candidates |= ReservedWords
      candidates.grep(/^#{Regexp.quote(input)}/).sort
    end
  end
end

#select_message(receiver, message, candidates, sep = ".") ⇒ Object

# File 'lib/irb/completion.rb', line 469

def select_message(receiver, message, candidates, sep = ".")
  candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
    case e
    when /^[a-zA-Z_]/
      receiver + sep + e
    when /^[0-9]/
    when *Operators
      #receiver + " " + e
    end
  end
end