irb 0.9.6

data/lib/irb/cmd/chws.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: false
+#
+#   change-ws.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/change-ws"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+
+    class CurrentWorkingWorkspace < Nop
+      def execute(*obj)
+        irb_context.main
+      end
+    end
+
+    class ChangeWorkspace < Nop
+      def execute(*obj)
+        irb_context.change_workspace(*obj)
+        irb_context.main
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/fork.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+#
+#   fork.rb -
+#   	$Release Version: 0.9.6 $
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Fork < Nop
+      def execute
+        pid = send ExtendCommand.irb_original_method_name("fork")
+        unless pid
+          class << self
+            alias_method :exit, ExtendCommand.irb_original_method_name('exit')
+          end
+          if iterator?
+            begin
+              yield
+            ensure
+              exit
+            end
+          end
+        end
+        pid
+      end
+    end
+  end
+end
+# :startdoc:
+
+

data/lib/irb/cmd/help.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: false
+#
+#   help.rb - helper using ri
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#
+# --
+#
+#
+#
+
+require 'rdoc/ri/driver'
+
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Help < Nop
+      begin
+        Ri = RDoc::RI::Driver.new
+      rescue SystemExit
+      else
+        def execute(*names)
+          if names.empty?
+            Ri.interactive
+            return
+          end
+          names.each do |name|
+            begin
+              Ri.display_name(name.to_s)
+            rescue RDoc::RI::Error
+              puts $!.message
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/load.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+#
+#   load.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/loader"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Load < Nop
+      include IrbLoader
+
+      def execute(file_name, priv = nil)
+        return irb_load(file_name, priv)
+      end
+    end
+
+    class Require < Nop
+      include IrbLoader
+
+      def execute(file_name)
+
+        rex = Regexp.new("#{Regexp.quote(file_name)}(\.o|\.rb)?")
+        return false if $".find{|f| f =~ rex}
+
+        case file_name
+        when /\.rb$/
+          begin
+            if irb_load(file_name)
+              $".push file_name
+              return true
+            end
+          rescue LoadError
+          end
+        when /\.(so|o|sl)$/
+          return ruby_require(file_name)
+        end
+
+        begin
+          irb_load(f = file_name + ".rb")
+          $".push f
+          return true
+        rescue LoadError
+          return ruby_require(file_name)
+        end
+      end
+    end
+
+    class Source < Nop
+      include IrbLoader
+      def execute(file_name)
+        source_file(file_name)
+      end
+    end
+  end
+
+end
+# :startdoc:

data/lib/irb/cmd/nop.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+#
+#   nop.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Nop
+
+
+      def self.execute(conf, *opts)
+        command = new(conf)
+        command.execute(*opts)
+      end
+
+      def initialize(conf)
+        @irb_context = conf
+      end
+
+      attr_reader :irb_context
+
+      def irb
+        @irb_context.irb
+      end
+
+      def execute(*opts)
+        #nop
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/pushws.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: false
+#
+#   change-ws.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/workspaces"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Workspaces < Nop
+      def execute(*obj)
+        irb_context.workspaces.collect{|ws| ws.main}
+      end
+    end
+
+    class PushWorkspace < Workspaces
+      def execute(*obj)
+        irb_context.push_workspace(*obj)
+        super
+      end
+    end
+
+    class PopWorkspace < Workspaces
+      def execute(*obj)
+        irb_context.pop_workspace(*obj)
+        super
+      end
+    end
+  end
+end
+# :startdoc:
+

data/lib/irb/cmd/subirb.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: false
+#   multi.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/multi-irb"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class IrbCommand < Nop
+      def execute(*obj)
+        IRB.irb(nil, *obj)
+      end
+    end
+
+    class Jobs < Nop
+      def execute
+        IRB.JobManager
+      end
+    end
+
+    class Foreground < Nop
+      def execute(key)
+        IRB.JobManager.switch(key)
+      end
+    end
+
+    class Kill < Nop
+      def execute(*keys)
+        IRB.JobManager.kill(*keys)
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/completion.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: false
+#
+#   irb/completion.rb -
+#   	$Release Version: 0.9$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#       From Original Idea of shugo@ruby-lang.org
+#
+
+require "readline"
+
+module IRB
+  module InputCompletor # :nodoc:
+
+
+    # Set of reserved words used by Ruby, you should not use these for
+    # constants or variables
+    ReservedWords = %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
+    ]
+
+    CompletionProc = proc { |input|
+      bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+
+      case input
+      when /^((["'`]).*\2)\.([^.]*)$/
+        # String
+        receiver = $1
+        message = Regexp.quote($3)
+
+        candidates = String.instance_methods.collect{|m| m.to_s}
+        select_message(receiver, message, candidates)
+
+      when /^(\/[^\/]*\/)\.([^.]*)$/
+        # Regexp
+        receiver = $1
+        message = Regexp.quote($2)
+
+        candidates = Regexp.instance_methods.collect{|m| m.to_s}
+        select_message(receiver, message, candidates)
+
+      when /^([^\]]*\])\.([^.]*)$/
+        # Array
+        receiver = $1
+        message = Regexp.quote($2)
+
+        candidates = Array.instance_methods.collect{|m| m.to_s}
+        select_message(receiver, message, candidates)
+
+      when /^([^\}]*\})\.([^.]*)$/
+        # Proc or Hash
+        receiver = $1
+        message = Regexp.quote($2)
+
+        candidates = Proc.instance_methods.collect{|m| m.to_s}
+        candidates |= Hash.instance_methods.collect{|m| m.to_s}
+        select_message(receiver, message, candidates)
+
+      when /^(:[^:.]*)$/
+        # Symbol
+        if Symbol.respond_to?(:all_symbols)
+          sym = $1
+          candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+          candidates.grep(/^#{Regexp.quote(sym)}/)
+        else
+          []
+        end
+
+      when /^::([A-Z][^:\.\(]*)$/
+        # Absolute Constant or class methods
+        receiver = $1
+        candidates = Object.constants.collect{|m| m.to_s}
+        candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+
+      when /^([A-Z].*)::([^:.]*)$/
+        # Constant or class methods
+        receiver = $1
+        message = Regexp.quote($2)
+        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, "::")
+
+      when /^(:[^:.]+)(\.|::)([^.]*)$/
+        # Symbol
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        candidates = Symbol.instance_methods.collect{|m| m.to_s}
+        select_message(receiver, message, candidates, sep)
+
+      when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)(\.|::)([^.]*)$/
+        # Numeric
+        receiver = $1
+        sep = $5
+        message = Regexp.quote($6)
+
+        begin
+          candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+        rescue Exception
+          candidates = []
+        end
+        select_message(receiver, message, candidates, sep)
+
+      when /^(-?0x[0-9a-fA-F_]+)(\.|::)([^.]*)$/
+        # Numeric(0xFFFF)
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        begin
+          candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+        rescue Exception
+          candidates = []
+        end
+        select_message(receiver, message, candidates, sep)
+
+      when /^(\$[^.]*)$/
+        # global var
+        regmessage = Regexp.new(Regexp.quote($1))
+        candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+
+      when /^([^."].*)(\.|::)([^.]*)$/
+        # variable.func or func.func
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        gv = eval("global_variables", bind).collect{|m| m.to_s}
+        lv = eval("local_variables", bind).collect{|m| m.to_s}
+        iv = eval("instance_variables", bind).collect{|m| m.to_s}
+        cv = eval("self.class.constants", bind).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 = []
+          to_ignore = ignored_modules
+          ObjectSpace.each_object(Module){|m|
+            next if (to_ignore.include?(m) rescue true)
+            candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+          }
+          candidates.sort!
+          candidates.uniq!
+        end
+        select_message(receiver, message, candidates, sep)
+
+      when /^\.([^.]*)$/
+        # unknown(maybe String)
+
+        receiver = ""
+        message = Regexp.quote($1)
+
+        candidates = String.instance_methods(true).collect{|m| m.to_s}
+        select_message(receiver, message, candidates)
+
+      else
+        candidates = eval("methods | private_methods | local_variables | instance_variables | self.class.constants", bind).collect{|m| m.to_s}
+
+        (candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
+      end
+    }
+
+    # Set of available operators in Ruby
+    Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
+
+    def self.select_message(receiver, message, candidates, sep = ".")
+      candidates.grep(/^#{message}/).collect do |e|
+        case e
+        when /^[a-zA-Z_]/
+          receiver + sep + e
+        when /^[0-9]/
+        when *Operators
+          #receiver + " " + e
+        end
+      end
+    end
+
+    def self.ignored_modules
+      # We could cache the result, but this is very fast already.
+      # By using this approach, we avoid Module#name calls, which are
+      # relatively slow when there are a lot of anonymous modules defined.
+      s = {}
+
+      scanner = lambda do |m|
+        next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
+        s[m] = true
+        m.constants(false).each do |c|
+          value = m.const_get(c)
+          scanner.call(value) if value.is_a?(Module)
+        end
+      end
+
+      %i(IRB SLex RubyLex RubyToken).each do |sym|
+        next unless Object.const_defined?(sym)
+        scanner.call(Object.const_get(sym))
+      end
+
+      s.delete(IRB::Context) if defined?(IRB::Context)
+
+      s
+    end
+  end
+end
+
+if Readline.respond_to?("basic_word_break_characters=")
+  Readline.basic_word_break_characters= " \t\n`><=;|&{("
+end
+Readline.completion_append_character = nil
+Readline.completion_proc = IRB::InputCompletor::CompletionProc