irb 1.1.0.pre.3

data/lib/irb/ext/save-history.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: false
+#   save-history.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "readline"
+
+module IRB
+  module HistorySavingAbility # :nodoc:
+  end
+
+  class Context
+    def init_save_history# :nodoc:
+      unless (class<<@io;self;end).include?(HistorySavingAbility)
+        @io.extend(HistorySavingAbility)
+      end
+    end
+
+    # A copy of the default <code>IRB.conf[:SAVE_HISTORY]</code>
+    def save_history
+      IRB.conf[:SAVE_HISTORY]
+    end
+
+    remove_method :save_history= if method_defined?(:save_history=)
+    # Sets <code>IRB.conf[:SAVE_HISTORY]</code> to the given +val+ and calls
+    # #init_save_history with this context.
+    #
+    # Will store the number of +val+ entries of history in the #history_file
+    #
+    # Add the following to your +.irbrc+ to change the number of history
+    # entries stored to 1000:
+    #
+    #     IRB.conf[:SAVE_HISTORY] = 1000
+    def save_history=(val)
+      IRB.conf[:SAVE_HISTORY] = val
+      if val
+        main_context = IRB.conf[:MAIN_CONTEXT]
+        main_context = self unless main_context
+        main_context.init_save_history
+      end
+    end
+
+    # A copy of the default <code>IRB.conf[:HISTORY_FILE]</code>
+    def history_file
+      IRB.conf[:HISTORY_FILE]
+    end
+
+    # Set <code>IRB.conf[:HISTORY_FILE]</code> to the given +hist+.
+    def history_file=(hist)
+      IRB.conf[:HISTORY_FILE] = hist
+    end
+  end
+
+  module HistorySavingAbility # :nodoc:
+    def HistorySavingAbility.extended(obj)
+      IRB.conf[:AT_EXIT].push proc{obj.save_history}
+      obj.load_history
+      obj
+    end
+
+    def load_history
+      return unless self.class.const_defined?(:HISTORY)
+      history = self.class::HISTORY
+      if history_file = IRB.conf[:HISTORY_FILE]
+        history_file = File.expand_path(history_file)
+      end
+      history_file = IRB.rc_file("_history") unless history_file
+      if File.exist?(history_file)
+        open(history_file) do |f|
+          f.each { |l|
+            l = l.chomp
+            if self.class == ReidlineInputMethod and history.last&.end_with?("\\")
+              history.last.delete_suffix!("\\")
+              history.last << "\n" << l
+            else
+              history << l
+            end
+          }
+        end
+      end
+    end
+
+    def save_history
+      return unless self.class.const_defined?(:HISTORY)
+      history = self.class::HISTORY
+      if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) > 0
+        if history_file = IRB.conf[:HISTORY_FILE]
+          history_file = File.expand_path(history_file)
+        end
+        history_file = IRB.rc_file("_history") unless history_file
+
+        # Change the permission of a file that already exists[BUG #7694]
+        begin
+          if File.stat(history_file).mode & 066 != 0
+            File.chmod(0600, history_file)
+          end
+        rescue Errno::ENOENT
+        rescue Errno::EPERM
+          return
+        rescue
+          raise
+        end
+
+        open(history_file, 'w', 0600 ) do |f|
+          hist = history.map{ |l| l.split("\n").join("\\\n") }
+          f.puts(hist[-num..-1] || hist)
+        end
+      end
+    end
+  end
+end

data/lib/irb/ext/tracer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: false
+#
+#   irb/lib/tracer.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require "tracer"
+
+module IRB
+
+  # initialize tracing function
+  def IRB.initialize_tracer
+    Tracer.verbose = false
+    Tracer.add_filter {
+      |event, file, line, id, binding, *rests|
+      /^#{Regexp.quote(@CONF[:IRB_LIB_PATH])}/ !~ file and
+        File::basename(file) != "irb.rb"
+    }
+  end
+
+  class Context
+    # Whether Tracer is used when evaluating statements in this context.
+    #
+    # See +lib/tracer.rb+ for more information.
+    attr_reader :use_tracer
+    alias use_tracer? use_tracer
+
+    # Sets whether or not to use the Tracer library when evaluating statements
+    # in this context.
+    #
+    # See +lib/tracer.rb+ for more information.
+    def use_tracer=(opt)
+      if opt
+        Tracer.set_get_line_procs(@irb_path) {
+          |line_no, *rests|
+          @io.line(line_no)
+        }
+      elsif !opt && @use_tracer
+        Tracer.off
+      end
+      @use_tracer=opt
+    end
+  end
+
+  class WorkSpace
+    alias __evaluate__ evaluate
+    # Evaluate the context of this workspace and use the Tracer library to
+    # output the exact lines of code are being executed in chronological order.
+    #
+    # See +lib/tracer.rb+ for more information.
+    def evaluate(context, statements, file = nil, line = nil)
+      if context.use_tracer? && file != nil && line != nil
+        Tracer.on
+        begin
+          __evaluate__(context, statements, file, line)
+        ensure
+          Tracer.off
+        end
+      else
+        __evaluate__(context, statements, file || __FILE__, line || __LINE__)
+      end
+    end
+  end
+
+  IRB.initialize_tracer
+end
+

data/lib/irb/ext/use-loader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: false
+#
+#   use-loader.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "../cmd/load"
+require_relative "loader"
+
+class Object
+  alias __original__load__IRB_use_loader__ load
+  alias __original__require__IRB_use_loader__ require
+end
+
+module IRB
+  module ExtendCommandBundle
+    remove_method :irb_load if method_defined?(:irb_load)
+    # Loads the given file similarly to Kernel#load, see IrbLoader#irb_load
+    def irb_load(*opts, &b)
+      ExtendCommand::Load.execute(irb_context, *opts, &b)
+    end
+    remove_method :irb_require if method_defined?(:irb_require)
+    # Loads the given file similarly to Kernel#require
+    def irb_require(*opts, &b)
+      ExtendCommand::Require.execute(irb_context, *opts, &b)
+    end
+  end
+
+  class Context
+
+    IRB.conf[:USE_LOADER] = false
+
+    # Returns whether +irb+'s own file reader method is used by
+    # +load+/+require+ or not.
+    #
+    # This mode is globally affected (irb-wide).
+    def use_loader
+      IRB.conf[:USE_LOADER]
+    end
+
+    alias use_loader? use_loader
+
+    remove_method :use_loader= if method_defined?(:use_loader=)
+    # Sets IRB.conf[:USE_LOADER]
+    #
+    # See #use_loader for more information.
+    def use_loader=(opt)
+
+      if IRB.conf[:USE_LOADER] != opt
+        IRB.conf[:USE_LOADER] = opt
+        if opt
+          if !$".include?("irb/cmd/load")
+          end
+          (class<<@workspace.main;self;end).instance_eval {
+            alias_method :load, :irb_load
+            alias_method :require, :irb_require
+          }
+        else
+          (class<<@workspace.main;self;end).instance_eval {
+            alias_method :load, :__original__load__IRB_use_loader__
+            alias_method :require, :__original__require__IRB_use_loader__
+          }
+        end
+      end
+      print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
+      opt
+    end
+  end
+end
+
+

data/lib/irb/ext/workspaces.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+#
+#   push-ws.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+module IRB # :nodoc:
+  class Context
+
+    # Size of the current WorkSpace stack
+    def irb_level
+      workspace_stack.size
+    end
+
+    # WorkSpaces in the current stack
+    def workspaces
+      if defined? @workspaces
+        @workspaces
+      else
+        @workspaces = []
+      end
+    end
+
+    # Creates a new workspace with the given object or binding, and appends it
+    # onto the current #workspaces stack.
+    #
+    # See IRB::Context#change_workspace and IRB::WorkSpace.new for more
+    # information.
+    def push_workspace(*_main)
+      if _main.empty?
+        if workspaces.empty?
+          print "No other workspace\n"
+          return nil
+        end
+        ws = workspaces.pop
+        workspaces.push @workspace
+        @workspace = ws
+        return workspaces
+      end
+
+      workspaces.push @workspace
+      @workspace = WorkSpace.new(@workspace.binding, _main[0])
+      if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
+        main.extend ExtendCommandBundle
+      end
+    end
+
+    # Removes the last element from the current #workspaces stack and returns
+    # it, or +nil+ if the current workspace stack is empty.
+    #
+    # Also, see #push_workspace.
+    def pop_workspace
+      if workspaces.empty?
+        print "workspace stack empty\n"
+        return
+      end
+      @workspace = workspaces.pop
+    end
+  end
+end
+

data/lib/irb/extend-command.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: false
+#
+#   irb/extend-command.rb - irb extend command
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+module IRB # :nodoc:
+  # Installs the default irb extensions command bundle.
+  module ExtendCommandBundle
+    EXCB = ExtendCommandBundle # :nodoc:
+
+    # See #install_alias_method.
+    NO_OVERRIDE = 0
+    # See #install_alias_method.
+    OVERRIDE_PRIVATE_ONLY = 0x01
+    # See #install_alias_method.
+    OVERRIDE_ALL = 0x02
+
+    # Quits the current irb context
+    #
+    # +ret+ is the optional signal or message to send to Context#exit
+    #
+    # Same as <code>IRB.CurrentContext.exit</code>.
+    def irb_exit(ret = 0)
+      irb_context.exit(ret)
+    end
+
+    # Displays current configuration.
+    #
+    # Modifing the configuration is achieved by sending a message to IRB.conf.
+    def irb_context
+      IRB.CurrentContext
+    end
+
+    @ALIASES = [
+      [:context, :irb_context, NO_OVERRIDE],
+      [:conf, :irb_context, NO_OVERRIDE],
+      [:irb_quit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+      [:exit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+      [:quit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+    ]
+
+    @EXTEND_COMMANDS = [
+      [
+        :irb_current_working_workspace, :CurrentWorkingWorkspace, "irb/cmd/chws",
+        [:irb_print_working_workspace, OVERRIDE_ALL],
+        [:irb_cwws, OVERRIDE_ALL],
+        [:irb_pwws, OVERRIDE_ALL],
+        [:cwws, NO_OVERRIDE],
+        [:pwws, NO_OVERRIDE],
+        [:irb_current_working_binding, OVERRIDE_ALL],
+        [:irb_print_working_binding, OVERRIDE_ALL],
+        [:irb_cwb, OVERRIDE_ALL],
+        [:irb_pwb, OVERRIDE_ALL],
+      ],
+      [
+        :irb_change_workspace, :ChangeWorkspace, "irb/cmd/chws",
+        [:irb_chws, OVERRIDE_ALL],
+        [:irb_cws, OVERRIDE_ALL],
+        [:chws, NO_OVERRIDE],
+        [:cws, NO_OVERRIDE],
+        [:irb_change_binding, OVERRIDE_ALL],
+        [:irb_cb, OVERRIDE_ALL],
+        [:cb, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_workspaces, :Workspaces, "irb/cmd/pushws",
+        [:workspaces, NO_OVERRIDE],
+        [:irb_bindings, OVERRIDE_ALL],
+        [:bindings, NO_OVERRIDE],
+      ],
+      [
+        :irb_push_workspace, :PushWorkspace, "irb/cmd/pushws",
+        [:irb_pushws, OVERRIDE_ALL],
+        [:pushws, NO_OVERRIDE],
+        [:irb_push_binding, OVERRIDE_ALL],
+        [:irb_pushb, OVERRIDE_ALL],
+        [:pushb, NO_OVERRIDE],
+      ],
+      [
+        :irb_pop_workspace, :PopWorkspace, "irb/cmd/pushws",
+        [:irb_popws, OVERRIDE_ALL],
+        [:popws, NO_OVERRIDE],
+        [:irb_pop_binding, OVERRIDE_ALL],
+        [:irb_popb, OVERRIDE_ALL],
+        [:popb, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_load, :Load, "irb/cmd/load"],
+      [
+        :irb_require, :Require, "irb/cmd/load"],
+      [
+        :irb_source, :Source, "irb/cmd/load",
+        [:source, NO_OVERRIDE],
+      ],
+
+      [
+        :irb, :IrbCommand, "irb/cmd/subirb"],
+      [
+        :irb_jobs, :Jobs, "irb/cmd/subirb",
+        [:jobs, NO_OVERRIDE],
+      ],
+      [
+        :irb_fg, :Foreground, "irb/cmd/subirb",
+        [:fg, NO_OVERRIDE],
+      ],
+      [
+        :irb_kill, :Kill, "irb/cmd/subirb",
+        [:kill, OVERRIDE_PRIVATE_ONLY],
+      ],
+
+      [
+        :irb_help, :Help, "irb/cmd/help",
+        [:help, NO_OVERRIDE],
+      ],
+
+    ]
+
+    # Installs the default irb commands:
+    #
+    # +irb_current_working_workspace+::   Context#main
+    # +irb_change_workspace+::            Context#change_workspace
+    # +irb_workspaces+::                  Context#workspaces
+    # +irb_push_workspace+::              Context#push_workspace
+    # +irb_pop_workspace+::               Context#pop_workspace
+    # +irb_load+::                        #irb_load
+    # +irb_require+::                     #irb_require
+    # +irb_source+::                      IrbLoader#source_file
+    # +irb+::                             IRB.irb
+    # +irb_jobs+::                        JobManager
+    # +irb_fg+::                          JobManager#switch
+    # +irb_kill+::                        JobManager#kill
+    # +irb_help+::                        IRB@Command+line+options
+    def self.install_extend_commands
+      for args in @EXTEND_COMMANDS
+        def_extend_command(*args)
+      end
+    end
+
+    # 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.
+    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
+        line = __LINE__; eval %[
+          def #{cmd_name}(*opts, &b)
+            require "#{load_file}"
+            arity = ExtendCommand::#{cmd_class}.instance_method(:execute).arity
+            args = (1..(arity < 0 ? ~arity : arity)).map {|i| "arg" + i.to_s }
+            args << "*opts" if arity < 0
+            args << "&block"
+            args = args.join(", ")
+            line = __LINE__; eval %[
+              def #{cmd_name}(\#{args})
+            ExtendCommand::#{cmd_class}.execute(irb_context, \#{args})
+              end
+            ], nil, __FILE__, line
+            send :#{cmd_name}, *opts, &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
+
+    # Installs alias methods for the default irb commands, see
+    # ::install_extend_commands.
+    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
+        print "irb: warn: can't alias #{to} from #{from}.\n"
+      end
+    end
+
+    def self.irb_original_method_name(method_name) # :nodoc:
+      "irb_" + method_name + "_org"
+    end
+
+    # Installs alias methods for the default irb commands on the given object
+    # using #install_alias_method.
+    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
+  end
+
+  # Extends methods for the Context module
+  module ContextExtender
+    CE = ContextExtender # :nodoc:
+
+    @EXTEND_COMMANDS = [
+      [:eval_history=, "irb/ext/history.rb"],
+      [:use_tracer=, "irb/ext/tracer.rb"],
+      [:use_loader=, "irb/ext/use-loader.rb"],
+      [:save_history=, "irb/ext/save-history.rb"],
+    ]
+
+    # Installs the default context extensions as irb commands:
+    #
+    # Context#eval_history=::   +irb/ext/history.rb+
+    # Context#use_tracer=::     +irb/ext/tracer.rb+
+    # Context#use_loader=::     +irb/ext/use-loader.rb+
+    # Context#save_history=::   +irb/ext/save-history.rb+
+    def self.install_extend_commands
+      for args in @EXTEND_COMMANDS
+        def_extend_command(*args)
+      end
+    end
+
+    # Evaluate the given +command+ from the given +load_file+ on the Context
+    # module.
+    #
+    # Will also define any given +aliases+ for the method.
+    def self.def_extend_command(cmd_name, load_file, *aliases)
+      line = __LINE__; Context.module_eval %[
+        def #{cmd_name}(*opts, &b)
+          Context.module_eval {remove_method(:#{cmd_name})}
+          require "#{load_file}"
+          send :#{cmd_name}, *opts, &b
+        end
+        for ali in aliases
+          alias_method ali, cmd_name
+        end
+      ], __FILE__, line
+    end
+
+    CE.install_extend_commands
+  end
+
+  # A convenience module for extending Ruby methods.
+  module MethodExtender
+    # Extends the given +base_method+ with a prefix call to the given
+    # +extend_method+.
+    def def_pre_proc(base_method, extend_method)
+      base_method = base_method.to_s
+      extend_method = extend_method.to_s
+
+      alias_name = new_alias_name(base_method)
+      module_eval %[
+        alias_method alias_name, base_method
+        def #{base_method}(*opts)
+          send :#{extend_method}, *opts
+          send :#{alias_name}, *opts
+        end
+      ]
+    end
+
+    # Extends the given +base_method+ with a postfix call to the given
+    # +extend_method+.
+    def def_post_proc(base_method, extend_method)
+      base_method = base_method.to_s
+      extend_method = extend_method.to_s
+
+      alias_name = new_alias_name(base_method)
+      module_eval %[
+        alias_method alias_name, base_method
+        def #{base_method}(*opts)
+          send :#{alias_name}, *opts
+          send :#{extend_method}, *opts
+        end
+      ]
+    end
+
+    # Returns a unique method name to use as an alias for the given +name+.
+    #
+    # Usually returns <code>#{prefix}#{name}#{postfix}<num></code>, example:
+    #
+    #     new_alias_name('foo') #=> __alias_of__foo__
+    #     def bar; end
+    #     new_alias_name('bar') #=> __alias_of__bar__2
+    def new_alias_name(name, prefix = "__alias_of__", postfix = "__")
+      base_name = "#{prefix}#{name}#{postfix}"
+      all_methods = instance_methods(true) + private_instance_methods(true)
+      same_methods = all_methods.grep(/^#{Regexp.quote(base_name)}[0-9]*$/)
+      return base_name if same_methods.empty?
+      no = same_methods.size
+      while !same_methods.include?(alias_name = base_name + no)
+        no += 1
+      end
+      alias_name
+    end
+  end
+end