# module IRB::ExtendCommandBundle

Installs the default irb extensions command bundle.

### Constants

NO_OVERRIDE

  See `install_alias_method`.

OVERRIDE_ALL

  See `install_alias_method`.

OVERRIDE_PRIVATE_ONLY

  See `install_alias_method`.

### Public Class Methods

all_commands_info() click to toggle source

    # File lib/irb/extend-command.rb, line 201
    def self.all_commands_info
      return @@commands unless @@commands.empty?
      user_aliases = IRB.CurrentContext.command_aliases.each_with_object({}) do |(alias_name, target), result|
        result[target] ||= []
        result[target] << alias_name
      end

      @EXTEND_COMMANDS.each do |cmd_name, cmd_class, load_file, *aliases|
        if !defined?(ExtendCommand) || !ExtendCommand.const_defined?(cmd_class, false)
          require_relative load_file
        end

        klass = ExtendCommand.const_get(cmd_class, false)
        aliases = aliases.map { |a| a.first }

        if additional_aliases = user_aliases[cmd_name]
          aliases += additional_aliases
        end

        display_name = aliases.shift || cmd_name
        @@commands << { display_name: display_name, description: klass.description, category: klass.category }
      end

      @@commands
    end

def_extend_command(cmd_name, cmd_class, load_file = nil, *aliases) click to toggle source

Evaluate the given `cmd_name` on the given `cmd_class` `Class`.

Will also define any given `aliases` for the method.

The optional `load_file` parameter will be required within the method definition.

    # File lib/irb/extend-command.rb, line 254
    def self.def_extend_command(cmd_name, cmd_class, load_file = nil, *aliases)
      case cmd_class
      when Symbol
        cmd_class = cmd_class.id2name
      when String
      when Class
        cmd_class = cmd_class.name
      end

      if load_file
        kwargs = ", **kwargs" if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.7.0"
        line = __LINE__; eval %[
          def #{cmd_name}(*opts#{kwargs}, &b)
            require_relative "#{load_file}"
            arity = ExtendCommand::#{cmd_class}.instance_method(:execute).arity
            args = (1..(arity < 0 ? ~arity : arity)).map {|i| "arg" + i.to_s }
            args << "*opts#{kwargs}" if arity < 0
            args << "&block"
            args = args.join(", ")
            line = __LINE__; eval %[
              unless singleton_class.class_variable_defined?(:@@#{cmd_name}_)
                singleton_class.class_variable_set(:@@#{cmd_name}_, true)
                def self.#{cmd_name}_(\#{args})
                  ExtendCommand::#{cmd_class}.execute(irb_context, \#{args})
                end
              end
            ], nil, __FILE__, line
            __send__ :#{cmd_name}_, *opts#{kwargs}, &b
          end
        ], nil, __FILE__, line
      else
        line = __LINE__; eval %[
          def #{cmd_name}(*opts, &b)
            ExtendCommand::#{cmd_class}.execute(irb_context, *opts, &b)
          end
        ], nil, __FILE__, line
      end

      for ali, flag in aliases
        @ALIASES.push [ali, cmd_name, flag]
      end
    end

extend_object(obj) click to toggle source

Installs alias methods for the default irb commands on the given object using `install_alias_method`.

Calls superclass method

    # File lib/irb/extend-command.rb, line 325
    def self.extend_object(obj)
      unless (class << obj; ancestors; end).include?(EXCB)
        super
        for ali, com, flg in @ALIASES
          obj.install_alias_method(ali, com, flg)
        end
      end
    end

install_extend_commands() click to toggle source

Installs the default irb commands.

    # File lib/irb/extend-command.rb, line 242
    def self.install_extend_commands
      for args in @EXTEND_COMMANDS
        def_extend_command(*args)
      end
    end

load_command(command) click to toggle source

Convert a command name to its implementation class if such command exists

    # File lib/irb/extend-command.rb, line 228
    def self.load_command(command)
      command = command.to_sym
      @EXTEND_COMMANDS.each do |cmd_name, cmd_class, load_file, *aliases|
        next if cmd_name != command && aliases.all? { |alias_name, _| alias_name != command }

        if !defined?(ExtendCommand) || !ExtendCommand.const_defined?(cmd_class, false)
          require_relative load_file
        end
        return ExtendCommand.const_get(cmd_class, false)
      end
      nil
    end

### Public Instance Methods

install_alias_method(to, from, override = NO_OVERRIDE) click to toggle source

Installs alias methods for the default irb commands, see `::install_extend_commands`.

    # File lib/irb/extend-command.rb, line 299
    def install_alias_method(to, from, override = NO_OVERRIDE)
      to = to.id2name unless to.kind_of?(String)
      from = from.id2name unless from.kind_of?(String)

      if override == OVERRIDE_ALL or
          (override == OVERRIDE_PRIVATE_ONLY) && !respond_to?(to) or
          (override == NO_OVERRIDE) &&  !respond_to?(to, true)
        target = self
        (class << self; self; end).instance_eval{
          if target.respond_to?(to, true) &&
            !target.respond_to?(EXCB.irb_original_method_name(to), true)
            alias_method(EXCB.irb_original_method_name(to), to)
          end
          alias_method to, from
        }
      else
        Kernel.print "irb: warn: can't alias #{to} from #{from}.\n"
      end
    end

irb_context() click to toggle source

Displays current configuration.

Modifying the configuration is achieved by sending a message to `IRB.conf`.

    # File lib/irb/extend-command.rb, line 36
    def irb_context
      IRB.CurrentContext
    end

irb_exit(ret = 0) click to toggle source

Quits the current irb context

`ret` is the optional signal or message to send to `Context#exit`

Same as `IRB.CurrentContext.exit`.

    # File lib/irb/extend-command.rb, line 29
    def irb_exit(ret = 0)
      irb_context.exit(ret)
    end

irb_load(*opts, &b) click to toggle source

Loads the given file similarly to `Kernel#load`, see `IrbLoader#irb_load`

    # File lib/irb/ext/use-loader.rb, line 25
    def irb_load(*opts, &b)
      ExtendCommand::Load.execute(irb_context, *opts, &b)
    end

irb_require(*opts, &b) click to toggle source

Loads the given file similarly to `Kernel#require`

    # File lib/irb/ext/use-loader.rb, line 30
    def irb_require(*opts, &b)
      ExtendCommand::Require.execute(irb_context, *opts, &b)
    end