1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed Shell from the ruby repository.

Browse Source
This commit is contained in:
Hiroshi SHIBATA 2019-09-20 12:56:18 +09:00
parent 67a6662032
commit 3b56a0934f
No known key found for this signature in database
GPG Key ID: F9CF13417264FAC2
14 changed files with 2 additions and 2055 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
NEWS
View File

@ -330,6 +330,7 @@ RubyGems::
* Removed unmaintained libraries. * Removed unmaintained libraries.
* CMath * CMath
* Scanf * Scanf
* Shell
=== Stdlib compatibility issues (excluding feature bug fixes) === Stdlib compatibility issues (excluding feature bug fixes)

3
doc/maintainers.rdoc
View File

@ -220,9 +220,6 @@ Zachary Scott (zzak)
[lib/rss.rb, lib/rss/*] [lib/rss.rb, lib/rss/*]
Kouhei Sutou (kou) Kouhei Sutou (kou)
https://github.com/ruby/rss https://github.com/ruby/rss
[lib/shell.rb, lib/shell/*]
Keiju ISHITSUKA (keiju)
https://github.com/ruby/shell
[lib/sync.rb] [lib/sync.rb]
Keiju ISHITSUKA (keiju) Keiju ISHITSUKA (keiju)
https://github.com/ruby/sync https://github.com/ruby/sync

1
doc/standard_library.rdoc
View File

@ -87,7 +87,6 @@ Racc:: A LALR(1) parser generator written in Ruby.
RDoc:: Produces HTML and command-line documentation for Ruby RDoc:: Produces HTML and command-line documentation for Ruby
REXML:: An XML toolkit for Ruby REXML:: An XML toolkit for Ruby
RSS:: Family of libraries that support various formats of XML "feeds" RSS:: Family of libraries that support various formats of XML "feeds"
Shell:: An idiomatic Ruby interface for common UNIX shell commands
Synchronizer:: A module that provides a two-phase lock with a counter Synchronizer:: A module that provides a two-phase lock with a counter
ThreadsWait:: Watches for termination of multiple threads ThreadsWait:: Watches for termination of multiple threads
Tracer:: Outputs a source level execution trace of a Ruby program Tracer:: Outputs a source level execution trace of a Ruby program

462
lib/shell.rb
View File

@ -1,462 +0,0 @@
# frozen_string_literal: false
#
# shell.rb -
# $Release Version: 0.7 $
# $Revision: 1.9 $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "e2mmap"
require "forwardable"
require "shell/error"
require "shell/command-processor"
require "shell/process-controller"
require "shell/version"
# Shell implements an idiomatic Ruby interface for common UNIX shell commands.
#
# It provides users the ability to execute commands with filters and pipes,
# like +sh+/+csh+ by using native facilities of Ruby.
#
# == Examples
#
# === Temp file creation
#
# In this example we will create three +tmpFile+'s in three different folders
# under the +/tmp+ directory.
#
# sh = Shell.cd("/tmp") # Change to the /tmp directory
# sh.mkdir "shell-test-1" unless sh.exists?("shell-test-1")
# # make the 'shell-test-1' directory if it doesn't already exist
# sh.cd("shell-test-1") # Change to the /tmp/shell-test-1 directory
# for dir in ["dir1", "dir3", "dir5"]
# if !sh.exists?(dir)
# sh.mkdir dir # make dir if it doesn't already exist
# sh.cd(dir) do
# # change to the `dir` directory
# f = sh.open("tmpFile", "w") # open a new file in write mode
# f.print "TEST\n" # write to the file
# f.close # close the file handler
# end
# print sh.pwd # output the process working directory
# end
# end
#
# === Temp file creation with self
#
# This example is identical to the first, except we're using
# CommandProcessor#transact.
#
# CommandProcessor#transact executes the given block against self, in this case
# +sh+; our Shell object. Within the block we can substitute +sh.cd+ to +cd+,
# because the scope within the block uses +sh+ already.
#
# sh = Shell.cd("/tmp")
# sh.transact do
# mkdir "shell-test-1" unless exists?("shell-test-1")
# cd("shell-test-1")
# for dir in ["dir1", "dir3", "dir5"]
# if !exists?(dir)
# mkdir dir
# cd(dir) do
# f = open("tmpFile", "w")
# f.print "TEST\n"
# f.close
# end
# print pwd
# end
# end
# end
#
# === Pipe /etc/printcap into a file
#
# In this example we will read the operating system file +/etc/printcap+,
# generated by +cupsd+, and then output it to a new file relative to the +pwd+
# of +sh+.
#
# sh = Shell.new
# sh.cat("/etc/printcap") | sh.tee("tee1") > "tee2"
# (sh.cat < "/etc/printcap") | sh.tee("tee11") > "tee12"
# sh.cat("/etc/printcap") | sh.tee("tee1") >> "tee2"
# (sh.cat < "/etc/printcap") | sh.tee("tee11") >> "tee12"
#
class Shell
include Error
extend Exception2MessageMapper
# debug: true -> normal debug
# debug: 1 -> eval definition debug
# debug: 2 -> detail inspect debug
@debug = false
@verbose = true
@debug_display_process_id = false
@debug_display_thread_id = true
@debug_output_mutex = Thread::Mutex.new
@default_system_path = nil
@default_record_separator = nil
class << Shell
extend Forwardable
attr_accessor :cascade, :verbose
attr_reader :debug
alias debug? debug
alias verbose? verbose
@verbose = true
def debug=(val)
@debug = val
@verbose = val if val
end
# call-seq:
# Shell.cd(path)
#
# Creates a new Shell instance with the current working directory
# set to +path+.
def cd(path)
new(path)
end
# Returns the directories in the current shell's PATH environment variable
# as an array of directory names. This sets the system_path for all
# instances of Shell.
#
# Example: If in your current shell, you did:
#
# $ echo $PATH
# /usr/bin:/bin:/usr/local/bin
#
# Running this method in the above shell would then return:
#
# ["/usr/bin", "/bin", "/usr/local/bin"]
#
def default_system_path
if @default_system_path
@default_system_path
else
ENV["PATH"].split(":")
end
end
# Sets the system_path that new instances of Shell should have as their
# initial system_path.
#
# +path+ should be an array of directory name strings.
def default_system_path=(path)
@default_system_path = path
end
def default_record_separator
if @default_record_separator
@default_record_separator
else
$/
end
end
def default_record_separator=(rs)
@default_record_separator = rs
end
# os resource mutex
mutex_methods = ["unlock", "lock", "locked?", "synchronize", "try_lock"]
for m in mutex_methods
def_delegator("@debug_output_mutex", m, "debug_output_"+m.to_s)
end
end
# call-seq:
# Shell.new(pwd, umask) -> obj
#
# Creates a Shell object which current directory is set to the process
# current directory, unless otherwise specified by the +pwd+ argument.
def initialize(pwd = Dir.pwd, umask = nil)
@cwd = File.expand_path(pwd)
@dir_stack = []
@umask = umask
@system_path = Shell.default_system_path
@record_separator = Shell.default_record_separator
@command_processor = CommandProcessor.new(self)
@process_controller = ProcessController.new(self)
@verbose = Shell.verbose
@debug = Shell.debug
end
# Returns the command search path in an array
attr_reader :system_path
# Sets the system path (the Shell instance's PATH environment variable).
#
# +path+ should be an array of directory name strings.
def system_path=(path)
@system_path = path
rehash
end
# Returns the umask
attr_accessor :umask
attr_accessor :record_separator
attr_accessor :verbose
attr_reader :debug
def debug=(val)
@debug = val
@verbose = val if val
end
alias verbose? verbose
alias debug? debug
attr_reader :command_processor
attr_reader :process_controller
def expand_path(path)
File.expand_path(path, @cwd)
end
# Most Shell commands are defined via CommandProcessor
#
# Dir related methods
#
# Shell#cwd/dir/getwd/pwd
# Shell#chdir/cd
# Shell#pushdir/pushd
# Shell#popdir/popd
# Shell#mkdir
# Shell#rmdir
# Returns the current working directory.
attr_reader :cwd
alias dir cwd
alias getwd cwd
alias pwd cwd
attr_reader :dir_stack
alias dirs dir_stack
# call-seq:
# Shell.chdir(path)
#
# Creates a Shell object which current directory is set to +path+.
#
# If a block is given, it restores the current directory when the block ends.
#
# If called as iterator, it restores the current directory when the
# block ends.
def chdir(path = nil, verbose = @verbose)
check_point
if block_given?
notify("chdir(with block) #{path}") if verbose
cwd_old = @cwd
begin
chdir(path, nil)
yield
ensure
chdir(cwd_old, nil)
end
else
notify("chdir #{path}") if verbose
path = "~" unless path
@cwd = expand_path(path)
notify "current dir: #{@cwd}"
rehash
Void.new(self)
end
end
alias cd chdir
# call-seq:
# pushdir(path)
# pushdir(path) { &block }
#
# Pushes the current directory to the directory stack, changing the current
# directory to +path+.
#
# If +path+ is omitted, it exchanges its current directory and the top of its
# directory stack.
#
# If a block is given, it restores the current directory when the block ends.
def pushdir(path = nil, verbose = @verbose)
check_point
if block_given?
notify("pushdir(with block) #{path}") if verbose
pushdir(path, nil)
begin
yield
ensure
popdir
end
elsif path
notify("pushdir #{path}") if verbose
@dir_stack.push @cwd
chdir(path, nil)
notify "dir stack: [#{@dir_stack.join ', '}]"
self
else
notify("pushdir") if verbose
if pop = @dir_stack.pop
@dir_stack.push @cwd
chdir pop
notify "dir stack: [#{@dir_stack.join ', '}]"
self
else
Shell.Fail DirStackEmpty
end
end
Void.new(self)
end
alias pushd pushdir
# Pops a directory from the directory stack, and sets the current directory
# to it.
def popdir
check_point
notify("popdir")
if pop = @dir_stack.pop
chdir pop
notify "dir stack: [#{@dir_stack.join ', '}]"
self
else
Shell.Fail DirStackEmpty
end
Void.new(self)
end
alias popd popdir
# Returns a list of scheduled jobs.
def jobs
@process_controller.jobs
end
# call-seq:
# kill(signal, job)
#
# Sends the given +signal+ to the given +job+
def kill(sig, command)
@process_controller.kill_job(sig, command)
end
# call-seq:
# def_system_command(command, path = command)
#
# Convenience method for Shell::CommandProcessor.def_system_command.
# Defines an instance method which will execute the given shell command.
# If the executable is not in Shell.default_system_path, you must
# supply the path to it.
#
# Shell.def_system_command('hostname')
# Shell.new.hostname # => localhost
#
# # How to use an executable that's not in the default path
#
# Shell.def_system_command('run_my_program', "~/hello")
# Shell.new.run_my_program # prints "Hello from a C program!"
#
def Shell.def_system_command(command, path = command)
CommandProcessor.def_system_command(command, path)
end
# Convenience method for Shell::CommandProcessor.undef_system_command
def Shell.undef_system_command(command)
CommandProcessor.undef_system_command(command)
end
# call-seq:
# alias_command(alias, command, *opts, &block)
#
# Convenience method for Shell::CommandProcessor.alias_command.
# Defines an instance method which will execute a command under
# an alternative name.
#
# Shell.def_system_command('date')
# Shell.alias_command('date_in_utc', 'date', '-u')
# Shell.new.date_in_utc # => Sat Jan 25 16:59:57 UTC 2014
#
def Shell.alias_command(ali, command, *opts, &block)
CommandProcessor.alias_command(ali, command, *opts, &block)
end
# Convenience method for Shell::CommandProcessor.unalias_command
def Shell.unalias_command(ali)
CommandProcessor.unalias_command(ali)
end
# call-seq:
# install_system_commands(pre = "sys_")
#
# Convenience method for Shell::CommandProcessor.install_system_commands.
# Defines instance methods representing all the executable files found in
# Shell.default_system_path, with the given prefix prepended to their
# names.
#
# Shell.install_system_commands
# Shell.new.sys_echo("hello") # => hello
#
def Shell.install_system_commands(pre = "sys_")
CommandProcessor.install_system_commands(pre)
end
#
def inspect
if debug.kind_of?(Integer) && debug > 2
super
else
to_s
end
end
def self.notify(*opts)
Shell::debug_output_synchronize do
if opts[-1].kind_of?(String)
yorn = verbose?
else
yorn = opts.pop
end
return unless yorn
if @debug_display_thread_id
if @debug_display_process_id
prefix = "shell(##{Process.pid}:#{Thread.current.to_s.sub("Thread", "Th")}): "
else
prefix = "shell(#{Thread.current.to_s.sub("Thread", "Th")}): "
end
else
prefix = "shell: "
end
_head = true
STDERR.print opts.collect{|mes|
mes = mes.dup
yield mes if block_given?
if _head
_head = false
prefix + mes
else
" "* prefix.size + mes
end
}.join("\n")+"\n"
end
end
CommandProcessor.initialize
CommandProcessor.run_config
end

147
lib/shell/builtin-command.rb
View File

@ -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

668
lib/shell/command-processor.rb
View File

@ -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

26
lib/shell/error.rb
View File

@ -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

138
lib/shell/filter.rb
View File

@ -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

309
lib/shell/process-controller.rb
View File

@ -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

39
lib/shell/shell.gemspec
View File

@ -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

159
lib/shell/system-command.rb
View File

@ -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

17
lib/shell/version.rb
View File

@ -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

83
test/shell/test_command_processor.rb
View File

@ -1,83 +0,0 @@
# frozen_string_literal: false
require 'test/unit'
require 'shell'
require 'tmpdir'
class TestShell < Test::Unit::TestCase
end
class TestShell::CommandProcessor < Test::Unit::TestCase
def setup
@tmpdir = Dir.mktmpdir("test_shell")
@shell = Shell.new
@shell.system_path = [@tmpdir]
end
def teardown
Dir.rmdir(@tmpdir)
end
def catch_command_start(tc = Object.new)
@shell.process_controller.singleton_class.class_eval do
define_method(:add_schedule) {|cmd| throw tc, cmd}
end
tc
end
def exeext
RbConfig::CONFIG["EXECUTABLE_EXTS"][/\S+\z/]
end
def test_system_external
name = "foo#{exeext}"
path = File.join(@tmpdir, name)
open(path, "w", 0755) {}
cmd = assert_throw(catch_command_start) {@shell.system(name)}
assert_equal(path, cmd.command)
ensure
File.unlink(path)
end
def test_system_not_found
bug8918 = '[ruby-core:57235] [Bug #8918]'
name = "foo"
path = File.join(@tmpdir, name)
open(path, "w", 0644) {}
assert_raise(Shell::Error::CommandNotFound, bug8918) {
catch(catch_command_start) {@shell.system(name)}
}
ensure
Process.waitall
File.unlink(path)
end
def test_system_directory
bug8918 = '[ruby-core:57235] [Bug #8918]'
name = "foo#{exeext}"
path = File.join(@tmpdir, name)
Dir.mkdir(path)
assert_raise(Shell::Error::CommandNotFound, bug8918) {
catch(catch_command_start) {@shell.system(name)}
}
ensure
Process.waitall
Dir.rmdir(path)
end
def test_option_type
name = 'foo.cmd'
path = File.join(@tmpdir, name)
open(path, 'w', 0755) {}
assert_raise(TypeError) {
catch(catch_command_start) {@shell.system(name, 42)}
}
ensure
Process.waitall
File.unlink(path)
end
end

4
tool/sync_default_gems.rb
View File

@ -30,7 +30,6 @@
# * https://github.com/ruby/irb # * https://github.com/ruby/irb
# * https://github.com/ruby/sync # * https://github.com/ruby/sync
# * https://github.com/ruby/tracer # * https://github.com/ruby/tracer
# * https://github.com/ruby/shell
# * https://github.com/ruby/forwardable # * https://github.com/ruby/forwardable
# * https://github.com/ruby/thwait # * https://github.com/ruby/thwait
# * https://github.com/ruby/e2mmap # * https://github.com/ruby/e2mmap
@ -72,7 +71,6 @@ $repositories = {
irb: 'ruby/irb', irb: 'ruby/irb',
sync: 'ruby/sync', sync: 'ruby/sync',
tracer: 'ruby/tracer', tracer: 'ruby/tracer',
shell: 'ruby/shell',
forwardable: "ruby/forwardable", forwardable: "ruby/forwardable",
thwait: "ruby/thwait", thwait: "ruby/thwait",
e2mmap: "ruby/e2mmap", e2mmap: "ruby/e2mmap",
@ -218,7 +216,7 @@ def sync_default_gems(gem)
cp_r(Dir.glob("#{upstream}/ext/racc/cparse/*"), "ext/racc/cparse") cp_r(Dir.glob("#{upstream}/ext/racc/cparse/*"), "ext/racc/cparse")
cp_r("#{upstream}/test", "test/racc") cp_r("#{upstream}/test", "test/racc")
`git checkout ext/racc/cparse/README` `git checkout ext/racc/cparse/README`
when "rexml", "rss", "matrix", "irb", "csv", "shell", "logger", "ostruct", "webrick", "fileutils", "forwardable", "prime", "tracer", "ipaddr", "mutex_m", "sync" when "rexml", "rss", "matrix", "irb", "csv", "logger", "ostruct", "webrick", "fileutils", "forwardable", "prime", "tracer", "ipaddr", "mutex_m", "sync"
sync_lib gem sync_lib gem
else else
end end