Top Level Namespace

Defined Under Namespace

Modules: FileUtils, UN

Instance Method Summary collapse

Instance Method Details

#chmodObject

Change the mode of each FILE to OCTAL-MODE.

ruby -run -e chmod -- [OPTION] OCTAL-MODE FILE

-v          verbose


219
220
221
222
223
224
225
# File 'lib/un.rb', line 219

def chmod
  setup do |argv, options|
    mode = argv.shift
    mode = /\A\d/ =~ mode ? mode.oct : mode
    FileUtils.chmod mode, argv, **options
  end
end

#colorizeObject

Colorize ruby code.

ruby -run -e colorize -- [FILE]


384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
# File 'lib/un.rb', line 384

def colorize
  begin
    require "irb/color"
  rescue LoadError
    raise "colorize requires irb 1.1.0 or later"
  end
  setup do |argv, |
    if argv.empty?
      puts IRB::Color.colorize_code STDIN.read
      return
    end
    argv.each do |file|
      puts IRB::Color.colorize_code File.read(file)
    end
  end
end

#cpObject

Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY

ruby -run -e cp -- [OPTION] SOURCE DEST

-p          preserve file attributes if possible
-r          copy recursively
-l          make hard link instead of copying (implies -r)
-v          verbose


85
86
87
88
89
90
91
92
93
94
95
# File 'lib/un.rb', line 85

def cp
  setup("prl") do |argv, options|
    cmd = "cp"
    cmd += "_r" if options.delete :r
    cmd = "cp_lr" if options.delete :l
    options[:preserve] = true if options.delete :p
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.__send__ cmd, argv, dest, **options
  end
end

#helpObject

Display help message.

ruby -run -e help [COMMAND]


407
408
409
410
411
# File 'lib/un.rb', line 407

def help
  setup do |argv,|
    UN.help(argv)
  end
end

#httpdObject

Run WEBrick HTTP server.

ruby -run -e httpd -- [OPTION] [DocumentRoot]

--bind-address=ADDR         address to bind
--port=NUM                  listening port number
--max-clients=MAX           max number of simultaneous clients
--temp-dir=DIR              temporary directory
--do-not-reverse-lookup     disable reverse lookup
--request-timeout=SECOND    request timeout in seconds
--http-version=VERSION      HTTP version
--server-name=NAME          name of the server host
--server-software=NAME      name and version of the server
--ssl-certificate=CERT      The SSL certificate file for the server
--ssl-private-key=KEY       The SSL private key file for the server certificate
-v                          verbose


325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
# File 'lib/un.rb', line 325

def httpd
  setup("", "BindAddress=ADDR", "Port=PORT", "MaxClients=NUM", "TempDir=DIR",
        "DoNotReverseLookup", "RequestTimeout=SECOND", "HTTPVersion=VERSION",
        "ServerName=NAME", "ServerSoftware=NAME",
        "SSLCertificate=CERT", "SSLPrivateKey=KEY") do
    |argv, options|
    begin
      require 'webrick'
    rescue LoadError
      abort "webrick is not found. You may need to `gem install webrick` to install webrick."
    end
    opt = options[:RequestTimeout] and options[:RequestTimeout] = opt.to_i
    [:Port, :MaxClients].each do |name|
      opt = options[name] and (options[name] = Integer(opt)) rescue nil
    end
    if cert = options[:SSLCertificate]
      key = options[:SSLPrivateKey] or
        raise "--ssl-private-key option must also be given"
      require 'webrick/https'
      options[:SSLEnable] = true
      options[:SSLCertificate] = OpenSSL::X509::Certificate.new(File.read(cert))
      options[:SSLPrivateKey] = OpenSSL::PKey.read(File.read(key))
      options[:Port] ||= 8443   # HTTPS Alternate
    end
    options[:Port] ||= 8080     # HTTP Alternate
    options[:DocumentRoot] = argv.shift || '.'
    s = nil
    options[:StartCallback] = proc {
      logger = s.logger
      logger.info("To access this server, open this URL in a browser:")
      s.listeners.each do |listener|
        if options[:SSLEnable]
          addr = listener.addr
          addr[3] = "127.0.0.1" if addr[3] == "0.0.0.0"
          addr[3] = "::1" if addr[3] == "::"
          logger.info("    https://#{Addrinfo.new(addr).inspect_sockaddr}")
        else
          logger.info("    http://#{listener.connect_address.inspect_sockaddr}")
        end
      end
    }
    s = WEBrick::HTTPServer.new(options)
    shut = proc {s.shutdown}
    siglist = %w"TERM QUIT"
    siglist.concat(%w"HUP INT") if STDIN.tty?
    siglist &= Signal.list.keys
    siglist.each do |sig|
      Signal.trap(sig, shut)
    end
    s.start
  end
end

#installObject

Copy SOURCE to DEST.

ruby -run -e install -- [OPTION] SOURCE DEST

-p          apply access/modification times of SOURCE files to
            corresponding destination files
-m          set permission mode (as in chmod), instead of 0755
-o          set owner user id, instead of the current owner
-g          set owner group id, instead of the current group
-v          verbose


199
200
201
202
203
204
205
206
207
208
209
# File 'lib/un.rb', line 199

def install
  setup("pm:o:g:") do |argv, options|
    (mode = options.delete :m) and options[:mode] = /\A\d/ =~ mode ? mode.oct : mode
    options[:preserve] = true if options.delete :p
    (owner = options.delete :o) and options[:owner] = owner
    (group = options.delete :g) and options[:group] = group
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.install argv, dest, **options
  end
end

#lnObject

Create a link to the specified TARGET with LINK_NAME.

ruby -run -e ln -- [OPTION] TARGET LINK_NAME

-s          make symbolic links instead of hard links
-f          remove existing destination files
-v          verbose


107
108
109
110
111
112
113
114
115
116
# File 'lib/un.rb', line 107

def ln
  setup("sf") do |argv, options|
    cmd = "ln"
    cmd += "_s" if options.delete :s
    options[:force] = true if options.delete :f
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.__send__ cmd, argv, dest, **options
  end
end

#mkdirObject

Create the DIR, if they do not already exist.

ruby -run -e mkdir -- [OPTION] DIR

-p          no error if existing, make parent directories as needed
-v          verbose


162
163
164
165
166
167
168
# File 'lib/un.rb', line 162

def mkdir
  setup("p") do |argv, options|
    cmd = "mkdir"
    cmd += "_p" if options.delete :p
    FileUtils.__send__ cmd, argv, **options
  end
end

#mkmfObject

Create makefile using mkmf.

ruby -run -e mkmf -- [OPTION] EXTNAME [OPTION]

-d ARGS     run dir_config
-h ARGS     run have_header
-l ARGS     run have_library
-f ARGS     run have_func
-v ARGS     run have_var
-t ARGS     run have_type
-m ARGS     run have_macro
-c ARGS     run have_const
--vendor    install to vendor_ruby


290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
# File 'lib/un.rb', line 290

def mkmf
  setup("d:h:l:f:v:t:m:c:", "vendor") do |argv, options|
    require 'mkmf'
    opt = options[:d] and opt.split(/:/).each {|n| dir_config(*n.split(/,/))}
    opt = options[:h] and opt.split(/:/).each {|n| have_header(*n.split(/,/))}
    opt = options[:l] and opt.split(/:/).each {|n| have_library(*n.split(/,/))}
    opt = options[:f] and opt.split(/:/).each {|n| have_func(*n.split(/,/))}
    opt = options[:v] and opt.split(/:/).each {|n| have_var(*n.split(/,/))}
    opt = options[:t] and opt.split(/:/).each {|n| have_type(*n.split(/,/))}
    opt = options[:m] and opt.split(/:/).each {|n| have_macro(*n.split(/,/))}
    opt = options[:c] and opt.split(/:/).each {|n| have_const(*n.split(/,/))}
    $configure_args["--vendor"] = true if options[:vendor]
    create_makefile(*argv)
  end
end

#mvObject

Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.

ruby -run -e mv -- [OPTION] SOURCE DEST

-v          verbose


126
127
128
129
130
131
132
# File 'lib/un.rb', line 126

def mv
  setup do |argv, options|
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.mv argv, dest, **options
  end
end

#rmObject

Remove the FILE

ruby -run -e rm -- [OPTION] FILE

-f          ignore nonexistent files
-r          remove the contents of directories recursively
-v          verbose


144
145
146
147
148
149
150
151
# File 'lib/un.rb', line 144

def rm
  setup("fr") do |argv, options|
    cmd = "rm"
    cmd += "_r" if options.delete :r
    options[:force] = true if options.delete :f
    FileUtils.__send__ cmd, argv, **options
  end
end

#rmdirObject

Remove the DIR.

ruby -run -e rmdir -- [OPTION] DIR

-p          remove DIRECTORY and its ancestors.
-v          verbose


179
180
181
182
183
184
# File 'lib/un.rb', line 179

def rmdir
  setup("p") do |argv, options|
    options[:parents] = true if options.delete :p
    FileUtils.rmdir argv, **options
  end
end

#setup(options = "", *long_options) {|argv, opt_hash| ... } ⇒ Object

:nodoc:

Yields:

  • (argv, opt_hash)


37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
# File 'lib/un.rb', line 37

def setup(options = "", *long_options)
  caller = caller_locations(1, 1)[0].label
  opt_hash = {}
  argv = []
  OptionParser.new do |o|
    options.scan(/.:?/) do |s|
      opt_name = s.delete(":").intern
      o.on("-" + s.tr(":", " ")) do |val|
        opt_hash[opt_name] = val
      end
    end
    long_options.each do |s|
      opt_name, arg_name = s.split(/(?=[\s=])/, 2)
      opt_name.delete_prefix!('--')
      s = "--#{opt_name.gsub(/([A-Z]+|[a-z])([A-Z])/, '\1-\2').downcase}#{arg_name}"
      puts "#{opt_name}=>#{s}" if $DEBUG
      opt_name = opt_name.intern
      o.on(s) do |val|
        opt_hash[opt_name] = val
      end
    end
    o.on("-v") do opt_hash[:verbose] = true end
    o.on("--help") do
      UN.help([caller])
      exit
    end
    o.order!(ARGV) do |x|
      if /[*?\[{]/ =~ x
        argv.concat(Dir[x])
      else
        argv << x
      end
    end
  end
  yield argv, opt_hash
end

#touchObject

Update the access and modification times of each FILE to the current time.

ruby -run -e touch -- [OPTION] FILE

-v          verbose


235
236
237
238
239
# File 'lib/un.rb', line 235

def touch
  setup do |argv, options|
    FileUtils.touch argv, **options
  end
end

#wait_writableObject

Wait until the file becomes writable.

ruby -run -e wait_writable -- [OPTION] FILE

-n RETRY    count to retry
-w SEC      each wait time in seconds
-v          verbose


251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
# File 'lib/un.rb', line 251

def wait_writable
  setup("n:w:v") do |argv, options|
    verbose = options[:verbose]
    n = options[:n] and n = Integer(n)
    wait = (wait = options[:w]) ? Float(wait) : 0.2
    argv.each do |file|
      begin
        File.open(file, "r+b") {}
      rescue Errno::ENOENT
        break
      rescue Errno::EACCES => e
        raise if n and (n -= 1) <= 0
        if verbose
          puts e
          STDOUT.flush
        end
        sleep wait
        retry
      end
    end
  end
end