Removed Shell from the ruby repository.

8 files changed, 0 insertions, 1503 deletions

diff --git a/lib/shell/builtin-command.rb b/lib/shell/builtin-command.rb
deleted file mode 100644
index a6a9d232ad..0000000000
--- a/lib/shell/builtin-command.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/builtin-command.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-require_relative "filter"
-
-class Shell
-  class BuiltInCommand < Filter
-    def wait?
-      false
-    end
-    def active?
-      true
-    end
-  end
-
-  class Void < BuiltInCommand
-    def initialize(sh, *opts)
-      super sh
-    end
-
-    def each(rs = nil)
-      # do nothing
-    end
-  end
-
-  class Echo < BuiltInCommand
-    def initialize(sh, *strings)
-      super sh
-      @strings = strings
-    end
-
-    def each(rs = nil)
-      rs =  @shell.record_separator unless rs
-      for str  in @strings
-        yield str + rs
-      end
-    end
-  end
-
-  class Cat < BuiltInCommand
-    def initialize(sh, *filenames)
-      super sh
-      @cat_files = filenames
-    end
-
-    def each(rs = nil)
-      if @cat_files.empty?
-        super
-      else
-        for src in @cat_files
-          @shell.foreach(src, rs){|l| yield l}
-        end
-      end
-    end
-  end
-
-  class Glob < BuiltInCommand
-    def initialize(sh, pattern)
-      super sh
-
-      @pattern = pattern
-    end
-
-    def each(rs = nil)
-      if @pattern[0] == ?/
-        @files = Dir[@pattern]
-      else
-        prefix = @shell.pwd+"/"
-        @files = Dir[prefix+@pattern].collect{|p| p.sub(prefix, "")}
-      end
-      rs =  @shell.record_separator unless rs
-      for f in @files
-        yield f+rs
-      end
-    end
-  end
-
-  class AppendIO < BuiltInCommand
-    def initialize(sh, io, filter)
-      super sh
-      @input = filter
-      @io = io
-    end
-
-    def input=(filter)
-      @input.input=filter
-      for l in @input
-        @io << l
-      end
-    end
-
-  end
-
-  class AppendFile < AppendIO
-    def initialize(sh, to_filename, filter)
-      @file_name = to_filename
-      io = sh.open(to_filename, "a")
-      super(sh, io, filter)
-    end
-
-    def input=(filter)
-      begin
-        super
-      ensure
-        @io.close
-      end
-    end
-  end
-
-  class Tee < BuiltInCommand
-    def initialize(sh, filename)
-      super sh
-      @to_filename = filename
-    end
-
-    def each(rs = nil)
-      to = @shell.open(@to_filename, "w")
-      begin
-        super{|l| to << l; yield l}
-      ensure
-        to.close
-      end
-    end
-  end
-
-  class Concat < BuiltInCommand
-    def initialize(sh, *jobs)
-      super(sh)
-      @jobs = jobs
-    end
-
-    def each(rs = nil)
-      while job = @jobs.shift
-        job.each{|l| yield l}
-      end
-    end
-  end
-end
diff --git a/lib/shell/command-processor.rb b/lib/shell/command-processor.rb
deleted file mode 100644
index 5fe6056560..0000000000
--- a/lib/shell/command-processor.rb
+++ /dev/null
@@ -1,668 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/command-controller.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-require "e2mmap"
-
-require_relative "error"
-require_relative "filter"
-require_relative "system-command"
-require_relative "builtin-command"
-
-class Shell
-  # In order to execute a command on your OS, you need to define it as a
-  # Shell method.
-  #
-  # Alternatively, you can execute any command via
-  # Shell::CommandProcessor#system even if it is not defined.
-  class CommandProcessor
-
-    #
-    # initialize of Shell and related classes.
-    #
-    m = [:initialize, :expand_path]
-    if Object.methods.first.kind_of?(String)
-      NoDelegateMethods = m.collect{|x| x.id2name}
-    else
-      NoDelegateMethods = m
-    end
-
-    def self.initialize
-
-      install_builtin_commands
-
-      # define CommandProcessor#methods to Shell#methods and Filter#methods
-      for m in CommandProcessor.instance_methods(false) - NoDelegateMethods
-        add_delegate_command_to_shell(m)
-      end
-
-      def self.method_added(id)
-        add_delegate_command_to_shell(id)
-      end
-    end
-
-    #
-    # include run file.
-    #
-    def self.run_config
-      rc = "~/.rb_shell"
-      begin
-        load File.expand_path(rc) if ENV.key?("HOME")
-      rescue LoadError, Errno::ENOENT
-      rescue
-        print "load error: #{rc}\n"
-        print $!.class, ": ", $!, "\n"
-        for err in $@[0, $@.size - 2]
-          print "\t", err, "\n"
-        end
-      end
-    end
-
-    def initialize(shell)
-      @shell = shell
-      @system_commands = {}
-    end
-
-    #
-    # CommandProcessor#expand_path(path)
-    #     path:   String
-    #     return: String
-    #   returns the absolute path for <path>
-    #
-    def expand_path(path)
-      @shell.expand_path(path)
-    end
-
-    # call-seq:
-    #   foreach(path, record_separator) -> Enumerator
-    #   foreach(path, record_separator) { block }
-    #
-    # See IO.foreach when +path+ is a file.
-    #
-    # See Dir.foreach when +path+ is a directory.
-    #
-    def foreach(path = nil, *rs)
-      path = "." unless path
-      path = expand_path(path)
-
-      if File.directory?(path)
-        Dir.foreach(path){|fn| yield fn}
-      else
-        IO.foreach(path, *rs){|l| yield l}
-      end
-    end
-
-    # call-seq:
-    #   open(path, mode, permissions) -> Enumerator
-    #   open(path, mode, permissions) { block }
-    #
-    # See IO.open when +path+ is a file.
-    #
-    # See Dir.open when +path+ is a directory.
-    #
-    def open(path, mode = nil, perm = 0666, &b)
-      path = expand_path(path)
-      if File.directory?(path)
-        Dir.open(path, &b)
-      else
-        if @shell.umask
-          f = File.open(path, mode, perm)
-          File.chmod(perm & ~@shell.umask, path)
-          if block_given?
-            f.each(&b)
-          end
-          f
-        else
-          File.open(path, mode, perm, &b)
-        end
-      end
-    end
-
-    # call-seq:
-    #   unlink(path)
-    #
-    # See IO.unlink when +path+ is a file.
-    #
-    # See Dir.unlink when +path+ is a directory.
-    #
-    def unlink(path)
-      @shell.check_point
-
-      path = expand_path(path)
-      if File.directory?(path)
-        Dir.unlink(path)
-      else
-        IO.unlink(path)
-      end
-      Void.new(@shell)
-    end
-
-    # See Shell::CommandProcessor#test
-    alias top_level_test test
-    # call-seq:
-    #   test(command, file1, file2) ->  true or false
-    #   [command, file1, file2] ->  true or false
-    #
-    # Tests if the given +command+ exists in +file1+, or optionally +file2+.
-    #
-    # Example:
-    #     sh[?e, "foo"]
-    #     sh[:e, "foo"]
-    #     sh["e", "foo"]
-    #     sh[:exists?, "foo"]
-    #     sh["exists?", "foo"]
-    #
-    def test(command, file1, file2=nil)
-      file1 = expand_path(file1)
-      file2 = expand_path(file2) if file2
-      command = command.id2name if command.kind_of?(Symbol)
-
-      case command
-      when Integer
-        if file2
-          top_level_test(command, file1, file2)
-        else
-          top_level_test(command, file1)
-        end
-      when String
-        if command.size == 1
-          if file2
-            top_level_test(command, file1, file2)
-          else
-            top_level_test(command, file1)
-          end
-        else
-          if file2
-            FileTest.send(command, file1, file2)
-          else
-            FileTest.send(command, file1)
-          end
-        end
-      end
-    end
-    # See Shell::CommandProcessor#test
-    alias [] test
-
-    # call-seq:
-    #   mkdir(path)
-    #
-    # Same as Dir.mkdir, except multiple directories are allowed.
-    def mkdir(*path)
-      @shell.check_point
-      notify("mkdir #{path.join(' ')}")
-
-      perm = nil
-      if path.last.kind_of?(Integer)
-        perm = path.pop
-      end
-      for dir in path
-        d = expand_path(dir)
-        if perm
-          Dir.mkdir(d, perm)
-        else
-          Dir.mkdir(d)
-        end
-        File.chmod(d, 0666 & ~@shell.umask) if @shell.umask
-      end
-      Void.new(@shell)
-    end
-
-    # call-seq:
-    #   rmdir(path)
-    #
-    # Same as Dir.rmdir, except multiple directories are allowed.
-    def rmdir(*path)
-      @shell.check_point
-      notify("rmdir #{path.join(' ')}")
-
-      for dir in path
-        Dir.rmdir(expand_path(dir))
-      end
-      Void.new(@shell)
-    end
-
-    # call-seq:
-    #   system(command, *options) -> SystemCommand
-    #
-    # Executes the given +command+ with the +options+ parameter.
-    #
-    # Example:
-    #     print sh.system("ls", "-l")
-    #     sh.system("ls", "-l") | sh.head > STDOUT
-    #
-    def system(command, *opts)
-      if opts.empty?
-        if command =~ /\*|\?|\{|\}|\[|\]|<|>|\(|\)|~|&|\||\\|\$|;|'|`|"|\n/
-          return SystemCommand.new(@shell, find_system_command("sh"), "-c", command)
-        else
-          command, *opts = command.split(/\s+/)
-        end
-      end
-      SystemCommand.new(@shell, find_system_command(command), *opts)
-    end
-
-    # call-seq:
-    #   rehash
-    #
-    # Clears the command hash table.
-    def rehash
-      @system_commands = {}
-    end
-
-    def check_point # :nodoc:
-      @shell.process_controller.wait_all_jobs_execution
-    end
-    alias finish_all_jobs check_point # :nodoc:
-
-    # call-seq:
-    #   transact { block }
-    #
-    # Executes a block as self
-    #
-    # Example:
-    #   sh.transact { system("ls", "-l") | head > STDOUT }
-    def transact(&block)
-      begin
-        @shell.instance_eval(&block)
-      ensure
-        check_point
-      end
-    end
-
-    # call-seq:
-    #   out(device) { block }
-    #
-    # Calls <code>device.print</code> on the result passing the _block_ to
-    # #transact
-    def out(dev = STDOUT, &block)
-      dev.print transact(&block)
-    end
-
-    # call-seq:
-    #   echo(*strings) ->  Echo
-    #
-    # Returns a Echo object, for the given +strings+
-    def echo(*strings)
-      Echo.new(@shell, *strings)
-    end
-
-    # call-seq:
-    #   cat(*filename) ->  Cat
-    #
-    # Returns a Cat object, for the given +filenames+
-    def cat(*filenames)
-      Cat.new(@shell, *filenames)
-    end
-
-    #   def sort(*filenames)
-    #     Sort.new(self, *filenames)
-    #   end
-    # call-seq:
-    #   glob(pattern) ->  Glob
-    #
-    # Returns a Glob filter object, with the given +pattern+ object
-    def glob(pattern)
-      Glob.new(@shell, pattern)
-    end
-
-    def append(to, filter)
-      case to
-      when String
-        AppendFile.new(@shell, to, filter)
-      when IO
-        AppendIO.new(@shell, to, filter)
-      else
-        Shell.Fail Error::CantApplyMethod, "append", to.class
-      end
-    end
-
-    # call-seq:
-    #   tee(file) ->  Tee
-    #
-    # Returns a Tee filter object, with the given +file+ command
-    def tee(file)
-      Tee.new(@shell, file)
-    end
-
-    # call-seq:
-    #   concat(*jobs) ->  Concat
-    #
-    # Returns a Concat object, for the given +jobs+
-    def concat(*jobs)
-      Concat.new(@shell, *jobs)
-    end
-
-    # %pwd, %cwd -> @pwd
-    def notify(*opts)
-      Shell.notify(*opts) {|mes|
-        yield mes if block_given?
-
-        mes.gsub!("%pwd", "#{@cwd}")
-        mes.gsub!("%cwd", "#{@cwd}")
-      }
-    end
-
-    #
-    # private functions
-    #
-    def find_system_command(command)
-      return command if /^\// =~ command
-      case path = @system_commands[command]
-      when String
-        if exists?(path)
-          return path
-        else
-          Shell.Fail Error::CommandNotFound, command
-        end
-      when false
-        Shell.Fail Error::CommandNotFound, command
-      end
-
-      for p in @shell.system_path
-        path = join(p, command)
-        begin
-          st = File.stat(path)
-        rescue SystemCallError
-          next
-        else
-          next unless st.executable? and !st.directory?
-          @system_commands[command] = path
-          return path
-        end
-      end
-      @system_commands[command] = false
-      Shell.Fail Error::CommandNotFound, command
-    end
-
-    # call-seq:
-    #   def_system_command(command, path)  ->  Shell::SystemCommand
-    #
-    # Defines a command, registering +path+ as a Shell method for the given
-    # +command+.
-    #
-    #     Shell::CommandProcessor.def_system_command "ls"
-    #       #=> Defines ls.
-    #
-    #     Shell::CommandProcessor.def_system_command "sys_sort", "sort"
-    #       #=> Defines sys_sort as sort
-    #
-    def self.def_system_command(command, path = command)
-      begin
-        eval((d = %Q[def #{command}(*opts)
-                  SystemCommand.new(@shell, '#{path}', *opts)
-               end]), nil, __FILE__, __LINE__ - 1)
-      rescue SyntaxError
-        Shell.notify "warn: Can't define #{command} path: #{path}."
-      end
-      Shell.notify "Define #{command} path: #{path}.", Shell.debug?
-      Shell.notify("Definition of #{command}: ", d,
-             Shell.debug.kind_of?(Integer) && Shell.debug > 1)
-    end
-
-    # call-seq:
-    #   undef_system_command(command) ->  self
-    #
-    # Undefines a command
-    def self.undef_system_command(command)
-      command = command.id2name if command.kind_of?(Symbol)
-      remove_method(command)
-      Shell.module_eval{remove_method(command)}
-      Filter.module_eval{remove_method(command)}
-      self
-    end
-
-    @alias_map = {}
-    # Returns a list of aliased commands
-    def self.alias_map
-      @alias_map
-    end
-    # call-seq:
-    #   alias_command(alias, command, *options) ->  self
-    #
-    # Creates a command alias at the given +alias+ for the given +command+,
-    # passing any +options+ along with it.
-    #
-    #     Shell::CommandProcessor.alias_command "lsC", "ls", "-CBF", "--show-control-chars"
-    #     Shell::CommandProcessor.alias_command("lsC", "ls"){|*opts| ["-CBF", "--show-control-chars", *opts]}
-    #
-    def self.alias_command(ali, command, *opts)
-      ali = ali.id2name if ali.kind_of?(Symbol)
-      command = command.id2name if command.kind_of?(Symbol)
-      begin
-        if block_given?
-          @alias_map[ali.intern] = proc
-
-          eval((d = %Q[def #{ali}(*opts)
-                          @shell.__send__(:#{command},
-                                          *(CommandProcessor.alias_map[:#{ali}].call *opts))
-                        end]), nil, __FILE__, __LINE__ - 1)
-
-        else
-           args = opts.collect{|opt| '"' + opt + '"'}.join(",")
-           eval((d = %Q[def #{ali}(*opts)
-                          @shell.__send__(:#{command}, #{args}, *opts)
-                        end]), nil, __FILE__, __LINE__ - 1)
-        end
-      rescue SyntaxError
-        Shell.notify "warn: Can't alias #{ali} command: #{command}."
-        Shell.notify("Definition of #{ali}: ", d)
-        raise
-      end
-      Shell.notify "Define #{ali} command: #{command}.", Shell.debug?
-      Shell.notify("Definition of #{ali}: ", d,
-             Shell.debug.kind_of?(Integer) && Shell.debug > 1)
-      self
-    end
-
-    # call-seq:
-    #   unalias_command(alias)  ->  self
-    #
-    # Unaliases the given +alias+ command.
-    def self.unalias_command(ali)
-      ali = ali.id2name if ali.kind_of?(Symbol)
-      @alias_map.delete ali.intern
-      undef_system_command(ali)
-    end
-
-    # :nodoc:
-    #
-    # Delegates File and FileTest methods into Shell, including the following
-    # commands:
-    #
-    # * Shell#blockdev?(file)
-    # * Shell#chardev?(file)
-    # * Shell#directory?(file)
-    # * Shell#executable?(file)
-    # * Shell#executable_real?(file)
-    # * Shell#exist?(file)/Shell#exists?(file)
-    # * Shell#file?(file)
-    # * Shell#grpowned?(file)
-    # * Shell#owned?(file)
-    # * Shell#pipe?(file)
-    # * Shell#readable?(file)
-    # * Shell#readable_real?(file)
-    # * Shell#setgid?(file)
-    # * Shell#setuid?(file)
-    # * Shell#size(file)/Shell#size?(file)
-    # * Shell#socket?(file)
-    # * Shell#sticky?(file)
-    # * Shell#symlink?(file)
-    # * Shell#writable?(file)
-    # * Shell#writable_real?(file)
-    # * Shell#zero?(file)
-    # * Shell#syscopy(filename_from, filename_to)
-    # * Shell#copy(filename_from, filename_to)
-    # * Shell#move(filename_from, filename_to)
-    # * Shell#compare(filename_from, filename_to)
-    # * Shell#safe_unlink(*filenames)
-    # * Shell#makedirs(*filenames)
-    # * Shell#install(filename_from, filename_to, mode)
-    #
-    # And also, there are some aliases for convenience:
-    #
-    # * Shell#cmp	<- Shell#compare
-    # * Shell#mv	<- Shell#move
-    # * Shell#cp	<- Shell#copy
-    # * Shell#rm_f	<- Shell#safe_unlink
-    # * Shell#mkpath	<- Shell#makedirs
-    #
-    def self.def_builtin_commands(delegation_class, command_specs)
-      for meth, args in command_specs
-        arg_str = args.collect{|arg| arg.downcase}.join(", ")
-        call_arg_str = args.collect{
-          |arg|
-          case arg
-          when /^(FILENAME.*)$/
-            format("expand_path(%s)", $1.downcase)
-          when /^(\*FILENAME.*)$/
-            # \*FILENAME* -> filenames.collect{|fn| expand_path(fn)}.join(", ")
-            $1.downcase + '.collect{|fn| expand_path(fn)}'
-          else
-            arg
-          end
-        }.join(", ")
-        d = %Q[def #{meth}(#{arg_str})
-                    #{delegation_class}.#{meth}(#{call_arg_str})
-                 end]
-        Shell.notify "Define #{meth}(#{arg_str})", Shell.debug?
-        Shell.notify("Definition of #{meth}: ", d,
-                     Shell.debug.kind_of?(Integer) && Shell.debug > 1)
-        eval d
-      end
-    end
-
-    # call-seq:
-    #     install_system_commands(prefix = "sys_")
-    #
-    # Defines all commands in the Shell.default_system_path as Shell method,
-    # all with given +prefix+ appended to their names.
-    #
-    # Any invalid character names are converted to +_+, and errors are passed
-    # to Shell.notify.
-    #
-    # Methods already defined are skipped.
-    def self.install_system_commands(pre = "sys_")
-      defined_meth = {}
-      for m in Shell.methods
-        defined_meth[m] = true
-      end
-      sh = Shell.new
-      for path in Shell.default_system_path
-        next unless sh.directory? path
-        sh.cd path
-        sh.foreach do
-          |cn|
-          if !defined_meth[pre + cn] && sh.file?(cn) && sh.executable?(cn)
-            command = (pre + cn).gsub(/\W/, "_").sub(/^([0-9])/, '_\1')
-            begin
-              def_system_command(command, sh.expand_path(cn))
-            rescue
-              Shell.notify "warn: Can't define #{command} path: #{cn}"
-            end
-            defined_meth[command] = command
-          end
-        end
-      end
-    end
-
-    def self.add_delegate_command_to_shell(id) # :nodoc:
-      id = id.intern if id.kind_of?(String)
-      name = id.id2name
-      if Shell.method_defined?(id)
-        Shell.notify "warn: override definition of Shell##{name}."
-        Shell.notify "warn: alias Shell##{name} to Shell##{name}_org.\n"
-        Shell.module_eval "alias #{name}_org #{name}"
-      end
-      Shell.notify "method added: Shell##{name}.", Shell.debug?
-      Shell.module_eval(%Q[def #{name}(*args, &block)
-                            begin
-                              @command_processor.__send__(:#{name}, *args, &block)
-                            rescue Exception
-                              $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
-                              $@.delete_if{|s| /^\\(eval\\):/ =~ s}
-                            raise
-                            end
-                          end], __FILE__, __LINE__)
-
-      if Shell::Filter.method_defined?(id)
-        Shell.notify "warn: override definition of Shell::Filter##{name}."
-        Shell.notify "warn: alias Shell##{name} to Shell::Filter##{name}_org."
-        Filter.module_eval "alias #{name}_org #{name}"
-      end
-      Shell.notify "method added: Shell::Filter##{name}.", Shell.debug?
-      Filter.module_eval(%Q[def #{name}(*args, &block)
-                            begin
-                              self | @shell.__send__(:#{name}, *args, &block)
-                            rescue Exception
-                              $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
-                              $@.delete_if{|s| /^\\(eval\\):/ =~ s}
-                            raise
-                            end
-                          end], __FILE__, __LINE__)
-    end
-
-    # Delegates File methods into Shell, including the following commands:
-    #
-    # * Shell#atime(file)
-    # * Shell#basename(file, *opt)
-    # * Shell#chmod(mode, *files)
-    # * Shell#chown(owner, group, *file)
-    # * Shell#ctime(file)
-    # * Shell#delete(*file)
-    # * Shell#dirname(file)
-    # * Shell#ftype(file)
-    # * Shell#join(*file)
-    # * Shell#link(file_from, file_to)
-    # * Shell#lstat(file)
-    # * Shell#mtime(file)
-    # * Shell#readlink(file)
-    # * Shell#rename(file_from, file_to)
-    # * Shell#split(file)
-    # * Shell#stat(file)
-    # * Shell#symlink(file_from, file_to)
-    # * Shell#truncate(file, length)
-    # * Shell#utime(atime, mtime, *file)
-    #
-    def self.install_builtin_commands
-      # method related File.
-      # (exclude open/foreach/unlink)
-      normal_delegation_file_methods = [
-        ["atime", ["FILENAME"]],
-        ["basename", ["fn", "*opts"]],
-        ["chmod", ["mode", "*FILENAMES"]],
-        ["chown", ["owner", "group", "*FILENAME"]],
-        ["ctime", ["FILENAMES"]],
-        ["delete", ["*FILENAMES"]],
-        ["dirname", ["FILENAME"]],
-        ["ftype", ["FILENAME"]],
-        ["join", ["*items"]],
-        ["link", ["FILENAME_O", "FILENAME_N"]],
-        ["lstat", ["FILENAME"]],
-        ["mtime", ["FILENAME"]],
-        ["readlink", ["FILENAME"]],
-        ["rename", ["FILENAME_FROM", "FILENAME_TO"]],
-        ["split", ["pathname"]],
-        ["stat", ["FILENAME"]],
-        ["symlink", ["FILENAME_O", "FILENAME_N"]],
-        ["truncate", ["FILENAME", "length"]],
-        ["utime", ["atime", "mtime", "*FILENAMES"]]]
-
-      def_builtin_commands(File, normal_delegation_file_methods)
-      alias_method :rm, :delete
-
-      # method related FileTest
-      def_builtin_commands(FileTest,
-                   FileTest.singleton_methods(false).collect{|m| [m, ["FILENAME"]]})
-
-    end
-
-  end
-end
diff --git a/lib/shell/error.rb b/lib/shell/error.rb
deleted file mode 100644
index 677c424baf..0000000000
--- a/lib/shell/error.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/error.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-require "e2mmap"
-
-class Shell
-  module Error
-    extend Exception2MessageMapper
-    def_e2message TypeError, "wrong argument type %s (expected %s)"
-
-    def_exception :DirStackEmpty, "Directory stack empty."
-    def_exception :CantDefine, "Can't define method(%s, %s)."
-    def_exception :CantApplyMethod, "This method(%s) does not apply to this type(%s)."
-    def_exception :CommandNotFound, "Command not found(%s)."
-  end
-end
-
diff --git a/lib/shell/filter.rb b/lib/shell/filter.rb
deleted file mode 100644
index caa976ae3e..0000000000
--- a/lib/shell/filter.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/filter.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-class Shell #:nodoc:
-  # Any result of command execution is a Filter.
-  #
-  # This class includes Enumerable, therefore a Filter object can use all
-  # Enumerable
-  # facilities.
-  #
-  class Filter
-    include Enumerable
-
-    def initialize(sh)
-      @shell = sh         # parent shell
-      @input = nil        # input filter
-    end
-
-    attr_reader :input
-
-    def input=(filter)
-      @input = filter
-    end
-
-    # call-seq:
-    #   each(record_separator=nil) { block }
-    #
-    # Iterates a block for each line.
-    def each(rs = nil)
-      rs = @shell.record_separator unless rs
-      if @input
-        @input.each(rs){|l| yield l}
-      end
-    end
-
-    # call-seq:
-    #   < source
-    #
-    # Inputs from +source+, which is either a string of a file name or an IO
-    # object.
-    def <(src)
-      case src
-      when String
-        cat = Cat.new(@shell, src)
-        cat | self
-      when IO
-        self.input = src
-        self
-      else
-        Shell.Fail Error::CantApplyMethod, "<", src.class
-      end
-    end
-
-    # call-seq:
-    #   > source
-    #
-    # Outputs from +source+, which is either a string of a file name or an IO
-    # object.
-    def >(to)
-      case to
-      when String
-        dst = @shell.open(to, "w")
-        begin
-          each(){|l| dst << l}
-        ensure
-          dst.close
-        end
-      when IO
-        each(){|l| to << l}
-      else
-        Shell.Fail Error::CantApplyMethod, ">", to.class
-      end
-      self
-    end
-
-    # call-seq:
-    #   >> source
-    #
-    # Appends the output to +source+, which is either a string of a file name
-    # or an IO object.
-    def >>(to)
-      begin
-        Shell.cd(@shell.pwd).append(to, self)
-      rescue CantApplyMethod
-        Shell.Fail Error::CantApplyMethod, ">>", to.class
-      end
-    end
-
-    # call-seq:
-    #   | filter
-    #
-    # Processes a pipeline.
-    def |(filter)
-      filter.input = self
-      if active?
-        @shell.process_controller.start_job filter
-      end
-      filter
-    end
-
-    # call-seq:
-    #   filter1 + filter2
-    #
-    # Outputs +filter1+, and then +filter2+ using Join.new
-    def +(filter)
-      Join.new(@shell, self, filter)
-    end
-
-    def to_a
-      ary = []
-      each(){|l| ary.push l}
-      ary
-    end
-
-    def to_s
-      str = ""
-      each(){|l| str.concat l}
-      str
-    end
-
-    def inspect
-      if @shell.debug.kind_of?(Integer) && @shell.debug > 2
-        super
-      else
-        to_s
-      end
-    end
-  end
-end
diff --git a/lib/shell/process-controller.rb b/lib/shell/process-controller.rb
deleted file mode 100644
index d54da68cb0..0000000000
--- a/lib/shell/process-controller.rb
+++ /dev/null
@@ -1,309 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/process-controller.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-require "forwardable"
-require "sync"
-
-class Shell
-  class ProcessController
-
-    @ProcessControllers = {}
-    @ProcessControllersMonitor = Thread::Mutex.new
-    @ProcessControllersCV = Thread::ConditionVariable.new
-
-    @BlockOutputMonitor = Thread::Mutex.new
-    @BlockOutputCV = Thread::ConditionVariable.new
-
-    class << self
-      extend Forwardable
-
-      def_delegator("@ProcessControllersMonitor",
-                    "synchronize", "process_controllers_exclusive")
-
-      def active_process_controllers
-        process_controllers_exclusive do
-          @ProcessControllers.dup
-        end
-      end
-
-      def activate(pc)
-        process_controllers_exclusive do
-          @ProcessControllers[pc] ||= 0
-          @ProcessControllers[pc] += 1
-        end
-      end
-
-      def inactivate(pc)
-        process_controllers_exclusive do
-          if @ProcessControllers[pc]
-            if (@ProcessControllers[pc] -= 1) == 0
-              @ProcessControllers.delete(pc)
-              @ProcessControllersCV.signal
-            end
-          end
-        end
-      end
-
-      def each_active_object
-        process_controllers_exclusive do
-          for ref in @ProcessControllers.keys
-            yield ref
-          end
-        end
-      end
-
-      def block_output_synchronize(&b)
-        @BlockOutputMonitor.synchronize(&b)
-      end
-
-      def wait_to_finish_all_process_controllers
-        process_controllers_exclusive do
-          while !@ProcessControllers.empty?
-            Shell::notify("Process finishing, but active shell exists",
-                          "You can use Shell#transact or Shell#check_point for more safe execution.")
-            if Shell.debug?
-              for pc in @ProcessControllers.keys
-                Shell::notify(" Not finished jobs in "+pc.shell.to_s)
-                for com in pc.jobs
-                  com.notify("  Jobs: %id")
-                end
-              end
-            end
-            @ProcessControllersCV.wait(@ProcessControllersMonitor)
-          end
-        end
-      end
-    end
-
-    # for shell-command complete finish at this process exit.
-    USING_AT_EXIT_WHEN_PROCESS_EXIT = true
-    at_exit do
-      wait_to_finish_all_process_controllers unless $@
-    end
-
-    def initialize(shell)
-      @shell = shell
-      @waiting_jobs = []
-      @active_jobs = []
-      @jobs_sync = Sync.new
-
-      @job_monitor = Thread::Mutex.new
-      @job_condition = Thread::ConditionVariable.new
-    end
-
-    attr_reader :shell
-
-    def jobs
-      jobs = []
-      @jobs_sync.synchronize(:SH) do
-        jobs.concat @waiting_jobs
-        jobs.concat @active_jobs
-      end
-      jobs
-    end
-
-    def active_jobs
-      @active_jobs
-    end
-
-    def waiting_jobs
-      @waiting_jobs
-    end
-
-    def jobs_exist?
-      @jobs_sync.synchronize(:SH) do
-        @active_jobs.empty? or @waiting_jobs.empty?
-      end
-    end
-
-    def active_jobs_exist?
-      @jobs_sync.synchronize(:SH) do
-        @active_jobs.empty?
-      end
-    end
-
-    def waiting_jobs_exist?
-      @jobs_sync.synchronize(:SH) do
-        @waiting_jobs.empty?
-      end
-    end
-
-    # schedule a command
-    def add_schedule(command)
-      @jobs_sync.synchronize(:EX) do
-        ProcessController.activate(self)
-        if @active_jobs.empty?
-          start_job command
-        else
-          @waiting_jobs.push(command)
-        end
-      end
-    end
-
-    # start a job
-    def start_job(command = nil)
-      @jobs_sync.synchronize(:EX) do
-        if command
-          return if command.active?
-          @waiting_jobs.delete command
-        else
-          command = @waiting_jobs.shift
-
-          return unless command
-        end
-        @active_jobs.push command
-        command.start
-
-        # start all jobs that input from the job
-        for job in @waiting_jobs.dup
-          start_job(job) if job.input == command
-        end
-      end
-    end
-
-    def waiting_job?(job)
-      @jobs_sync.synchronize(:SH) do
-        @waiting_jobs.include?(job)
-      end
-    end
-
-    def active_job?(job)
-      @jobs_sync.synchronize(:SH) do
-        @active_jobs.include?(job)
-      end
-    end
-
-    # terminate a job
-    def terminate_job(command)
-      @jobs_sync.synchronize(:EX) do
-        @active_jobs.delete command
-        ProcessController.inactivate(self)
-        if @active_jobs.empty?
-          command.notify("start_job in terminate_job(%id)", Shell::debug?)
-          start_job
-        end
-      end
-    end
-
-    # kill a job
-    def kill_job(sig, command)
-      @jobs_sync.synchronize(:EX) do
-        if @waiting_jobs.delete command
-          ProcessController.inactivate(self)
-          return
-        elsif @active_jobs.include?(command)
-          begin
-            r = command.kill(sig)
-            ProcessController.inactivate(self)
-          rescue
-            print "Shell: Warn: $!\n" if @shell.verbose?
-            return nil
-          end
-          @active_jobs.delete command
-          r
-        end
-      end
-    end
-
-    # wait for all jobs to terminate
-    def wait_all_jobs_execution
-      @job_monitor.synchronize do
-        begin
-          while !jobs.empty?
-            @job_condition.wait(@job_monitor)
-            for job in jobs
-              job.notify("waiting job(%id)", Shell::debug?)
-            end
-          end
-        ensure
-          redo unless jobs.empty?
-        end
-      end
-    end
-
-    # simple fork
-    def sfork(command)
-      pipe_me_in, pipe_peer_out = IO.pipe
-      pipe_peer_in, pipe_me_out = IO.pipe
-
-
-      pid = nil
-      pid_mutex = Thread::Mutex.new
-      pid_cv = Thread::ConditionVariable.new
-
-      Thread.start do
-        ProcessController.block_output_synchronize do
-          STDOUT.flush
-          ProcessController.each_active_object do |pc|
-            for jobs in pc.active_jobs
-              jobs.flush
-            end
-          end
-
-          pid = fork {
-            Thread.list.each do |th|
-              th.kill unless Thread.current == th
-            end
-
-            STDIN.reopen(pipe_peer_in)
-            STDOUT.reopen(pipe_peer_out)
-
-            ObjectSpace.each_object(IO) do |io|
-              if ![STDIN, STDOUT, STDERR].include?(io)
-                io.close
-              end
-            end
-
-            yield
-          }
-        end
-        pid_cv.signal
-
-        pipe_peer_in.close
-        pipe_peer_out.close
-        command.notify "job(%name:##{pid}) start", @shell.debug?
-
-        begin
-          _pid = nil
-          command.notify("job(%id) start to waiting finish.", @shell.debug?)
-          _pid = Process.waitpid(pid, nil)
-        rescue Errno::ECHILD
-          command.notify "warn: job(%id) was done already waitpid."
-          _pid = true
-        ensure
-          command.notify("Job(%id): Wait to finish when Process finished.", @shell.debug?)
-          # when the process ends, wait until the command terminates
-          if USING_AT_EXIT_WHEN_PROCESS_EXIT or _pid
-          else
-            command.notify("notice: Process finishing...",
-                           "wait for Job[%id] to finish.",
-                           "You can use Shell#transact or Shell#check_point for more safe execution.")
-            redo
-          end
-
-          @job_monitor.synchronize do
-            terminate_job(command)
-            @job_condition.signal
-            command.notify "job(%id) finish.", @shell.debug?
-          end
-        end
-      end
-
-      pid_mutex.synchronize do
-        while !pid
-          pid_cv.wait(pid_mutex)
-        end
-      end
-
-      return pid, pipe_me_in, pipe_me_out
-    end
-  end
-end
diff --git a/lib/shell/shell.gemspec b/lib/shell/shell.gemspec
deleted file mode 100644
index 85f117cdae..0000000000
--- a/lib/shell/shell.gemspec
+++ /dev/null
@@ -1,39 +0,0 @@
-begin
-  require_relative "lib/shell/version"
-rescue LoadError
-  # for Ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = "shell"
-  spec.version       = Shell::VERSION
-  spec.authors       = ["Keiju ISHITSUKA"]
-  spec.email         = ["keiju@ruby-lang.org"]
-
-  spec.summary       = %q{An idiomatic Ruby interface for common UNIX shell commands.}
-  spec.description   = %q{An idiomatic Ruby interface for common UNIX shell commands.}
-  spec.homepage      = "https://github.com/ruby/shell"
-  spec.license       = "BSD-2-Clause"
-
-  spec.files         = [
-    "Gemfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "bin/console",
-    "bin/setup",
-    "lib/shell.rb",
-    "lib/shell/builtin-command.rb",
-    "lib/shell/command-processor.rb",
-    "lib/shell/error.rb",
-    "lib/shell/filter.rb",
-    "lib/shell/process-controller.rb",
-    "lib/shell/system-command.rb",
-    "lib/shell/version.rb",
-    "shell.gemspec",
-  ]
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-end
diff --git a/lib/shell/system-command.rb b/lib/shell/system-command.rb
deleted file mode 100644
index 9d1b07e98c..0000000000
--- a/lib/shell/system-command.rb
+++ /dev/null
@@ -1,159 +0,0 @@
-# frozen_string_literal: false
-#
-#   shell/system-command.rb -
-#       $Release Version: 0.7 $
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-require_relative "filter"
-
-class Shell
-  class SystemCommand < Filter
-    def initialize(sh, command, *opts)
-      if t = opts.find{|opt| !opt.kind_of?(String) && opt.class}
-        Shell.Fail TypeError, t.class, "String"
-      end
-      super(sh)
-      @command = command
-      @opts = opts
-
-      @input_queue = Thread::Queue.new
-      @pid = nil
-
-      sh.process_controller.add_schedule(self)
-    end
-
-    attr_reader :command
-    alias name command
-
-    def wait?
-      @shell.process_controller.waiting_job?(self)
-    end
-
-    def active?
-      @shell.process_controller.active_job?(self)
-    end
-
-    def input=(inp)
-      super
-      if active?
-        start_export
-      end
-    end
-
-    def start
-      notify([@command, *@opts].join(" "))
-
-      @pid, @pipe_in, @pipe_out = @shell.process_controller.sfork(self) {
-        Dir.chdir @shell.pwd
-        $0 = @command
-        exec(@command, *@opts)
-      }
-      if @input
-        start_export
-      end
-      start_import
-    end
-
-    def flush
-      @pipe_out.flush if @pipe_out and !@pipe_out.closed?
-    end
-
-    def terminate
-      begin
-        @pipe_in.close
-      rescue IOError
-      end
-      begin
-        @pipe_out.close
-      rescue IOError
-      end
-    end
-
-    def kill(sig)
-      if @pid
-        Process.kill(sig, @pid)
-      end
-    end
-
-    def start_import
-      notify "Job(%id) start imp-pipe.", @shell.debug?
-      _eop = true
-      Thread.start {
-        begin
-          while l = @pipe_in.gets
-            @input_queue.push l
-          end
-          _eop = false
-        rescue Errno::EPIPE
-          _eop = false
-        ensure
-          if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop
-            notify("warn: Process finishing...",
-                   "wait for Job[%id] to finish pipe importing.",
-                   "You can use Shell#transact or Shell#check_point for more safe execution.")
-            redo
-          end
-          notify "job(%id}) close imp-pipe.", @shell.debug?
-          @input_queue.push :EOF
-          @pipe_in.close
-        end
-      }
-    end
-
-    def start_export
-      notify "job(%id) start exp-pipe.", @shell.debug?
-      _eop = true
-      Thread.start{
-        begin
-          @input.each do |l|
-            ProcessController::block_output_synchronize do
-              @pipe_out.print l
-            end
-          end
-          _eop = false
-        rescue Errno::EPIPE, Errno::EIO
-          _eop = false
-        ensure
-          if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop
-            notify("shell: warn: Process finishing...",
-                   "wait for Job(%id) to finish pipe exporting.",
-                   "You can use Shell#transact or Shell#check_point for more safe execution.")
-            redo
-          end
-          notify "job(%id) close exp-pipe.", @shell.debug?
-          @pipe_out.close
-        end
-      }
-    end
-
-    alias super_each each
-    def each(rs = nil)
-      while (l = @input_queue.pop) != :EOF
-        yield l
-      end
-    end
-
-    # ex)
-    #    if you wish to output:
-    #       "shell: job(#{@command}:#{@pid}) close pipe-out."
-    #    then
-    #       mes: "job(%id) close pipe-out."
-    #    yorn: Boolean(@shell.debug? or @shell.verbose?)
-    def notify(*opts)
-      @shell.notify(*opts) do |mes|
-        yield mes if block_given?
-
-        mes.gsub!("%id", "#{@command}:##{@pid}")
-        mes.gsub!("%name", "#{@command}")
-        mes.gsub!("%pid", "#{@pid}")
-        mes
-      end
-    end
-  end
-end
diff --git a/lib/shell/version.rb b/lib/shell/version.rb
deleted file mode 100644
index f48f781b2c..0000000000
--- a/lib/shell/version.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: false
-#
-#   version.rb - shell version definition file
-#       $Release Version: 0.7$
-#       $Revision$
-#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# --
-#
-#
-#
-
-class Shell # :nodoc:
-  VERSION = "0.7"
-  @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "07/03/20"
-end