Module: ShellHelpers::Utils

Extended by:
Utils
Included in:
ShellHelpers, Utils
Defined in:
lib/shell_helpers/utils.rb

Class Attribute Summary collapse

Instance Method Summary collapse

Class Attribute Details

.orig_stderr ⇒ Object

Returns the value of attribute orig_stderr.



38
39
40
 
# File 'lib/shell_helpers/utils.rb', line 38

def orig_stderr
  @orig_stderr
end

.orig_stdin ⇒ Object

Returns the value of attribute orig_stdin.



38
39
40
 
# File 'lib/shell_helpers/utils.rb', line 38

def orig_stdin
  @orig_stdin
end

.orig_stdout ⇒ Object

Returns the value of attribute orig_stdout.



38
39
40
 
# File 'lib/shell_helpers/utils.rb', line 38

def orig_stdout
  @orig_stdout
end

Instance Method Details

#capture_stdout ⇒ Object 



310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/shell_helpers/utils.rb', line 310

def capture_stdout
  old_stdout = $stdout
  $stdout = StringIO.new('','w')
  if block_given?
    begin
      yield
      output=$stdout.string
    ensure
      $stdout = old_stdout
    end
    return output
  else
    return old_stdout
  end
end

#escape_pager(mode = nil) ⇒ Object

inside run_pager, escape from the pager does not work :-(



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/shell_helpers/utils.rb', line 138

def escape_pager(mode=nil)
  case mode
  when :orig
    stdout=ShellUtils.orig_stdout
    stderr=ShellUtils.orig_stderr
    stdin=ShellUtils.orig_stdin
  else
    stdout=STDOUT
    stderr=STDERR
    stdin=STDIN
  end
  $stdout.reopen(stdout)
  $stderr.reopen(stderr)
  $stdin.reopen(stdin)
end

#eval_shell(r, shell: :puts) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/shell_helpers/utils.rb', line 19

def eval_shell(r, shell: :puts)
  return r if r.nil? or r.empty?
  case (shell||"").to_sym
  when :puts
    puts r
  when :eval
    r+=";" if r && !r.end_with?(';')
    print r
  when :exec
    require 'shell_helpers/sh'
    return ShLog.sh(r)
  when :exec_quiet
    require 'shell_helpers/sh'
    return Sh.sh(*r)
  end
  return r
end

#find(*bases, filter: nil, prune: nil, follow_symlink: false, depth: false, max_depth: nil, chdir: false) ⇒ Object

An improved find from Find::find that takes in the block the absolute and relative name of the files (+the directory where the relative file is from), and has filter options Returns ::Pathname, except when the value is a SH::Pathname where it returns a SH::Pathname



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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/shell_helpers/utils.rb', line 47

def find(*bases, filter: nil, prune: nil, follow_symlink: false, depth: false, max_depth: nil, chdir: false)
  block_given? or return enum_for(__method__, *bases, filter: filter, follow_symlink: follow_symlink, depth: depth, max_depth: max_depth, chdir: chdir)
  bases.collect!{|d| raise Errno::ENOENT unless File.exist?(d); d.dup}.each do |base|
    klass=base.is_a?(::Pathname) ? base.class : ::Pathname
    base=klass.new(base)

    test_filter=lambda do |filter,*files|
      case filter
      when Proc
        filter.call(*files)
      when Array
        file=files.first
        filter.any? do |test|
          case test
          when :directory? #special case
            file.directory? && !file.symlink?
          else
            file.send(test)
          end
        end
      end
    end

    yield_files=lambda do |*files|
      unless test_filter.(filter,*files)
        files.map! {|f| f.dup.taint}
        if chdir
          Dir.chdir(base) do
            yield(*files, base)
          end
        else
          yield(*files, base)
        end
      end
    end

    do_find=lambda do |*files|
      file,filerel=*files
      catch(:prune) do #use throw(:prune) to skip a path (recursively)
        unless test_filter.(prune,*files)
          yield_files.(*files) unless depth
          if file.directory? and (max_depth.nil? or (filerel.to_s=="." and max_depth>0) or filerel.each_filename.to_a.size < max_depth)
            next if !follow_symlink && file.symlink?
            file.children(false).sort.reverse_each do |f|
              fj = file + f
              f = filerel + f
              do_find.(fj.untaint,f.untaint)
            end
            yield_files.(*files) if depth
          end
        end
      end
    end
    do_find.call(base, klass.new('.'))
  end
end

#find_executable(bin, path = nil, exts: nil) ⇒ Object

Stolen from mkmf: Searches for the executable +bin+ on +path+. The default path is your +PATH+ environment variable. If that isn't defined, it will resort to searching /usr/local/bin, /usr/ucb, /usr/bin and /bin. If found, it will return the full path, including the executable name, of where it was found. exts: an array of extensions to add



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/shell_helpers/utils.rb', line 166

def find_executable(bin, path = nil, exts: nil)
  executable_file = lambda do |name|
    name=Pathname.new(name)
    return name if name.file? and name.executable?
  end
  #we use Proc so that 'return' escapes the block
  try_executable = Proc.new do |file|
    return file if executable_file.call(file)
    exts && exts.each {|ext| executable_file.call(ext = file.append_name(ext)) and return ext}
    nil
  end

  bin=Pathname.new(bin)
  if bin.absolute?
    try_executable.call(bin)
  else
    path ||= ENV['PATH'] || %w[/usr/local/bin /usr/bin /bin]
    path = path.split(File::PATH_SEPARATOR) unless path.kind_of?(Array)
    path.each do |dir|
      dir=Pathname.new(dir)
      try_executable.call(dir+bin)
    end
  end
  nil
end

#find_file(file, path) ⇒ Object 



192
193
194
195
196
197
198
199
 
# File 'lib/shell_helpers/utils.rb', line 192

def find_file(file,path)
  path.each do |dir|
    dir=Pathname.new(dir)
    path=dir+file
    return path if path.file?
  end
  return nil
end

#find_files(pattern, path) ⇒ Object 



201
202
203
 
# File 'lib/shell_helpers/utils.rb', line 201

def find_files(pattern,path)
  path.map { |dir| Pathname.glob(dir+pattern) }.flatten
end

#output_list(s, split: "\n") ⇒ Object 



154
155
156
157
 
# File 'lib/shell_helpers/utils.rb', line 154

def output_list(s, split: "\n")
  s=s.shelljoin if s.kind_of?(Array)
  return open("| #{s}").read.split(split)
end

#rsync(*files, out, default_opts: "-vczz", preserve: true, partial: true, keep_dirlinks: false, backup: false, relative: false, delete: false, clean_out: false, clobber: true, expected: 23, chown: nil, sshcommand: nil, exclude: [], **opts, &b) ⇒ Object 



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/shell_helpers/utils.rb', line 205

def rsync(*files, out, default_opts: "-vczz", preserve: true, partial: true, keep_dirlinks: false, backup: false, relative: false, delete: false, clean_out: false, clobber: true, expected: 23, chown: nil, sshcommand: nil, exclude: [], **opts, &b)
  require 'shell_helpers/sh'
  rsync_opts=[*opts.delete(:rsync_opts)] || []
  rsync_opts << default_opts
  rsync_opts << "-a" if preserve
  rsync_opts << "-P" if partial #--partial --progress
  rsync_opts+=%w(--no-owner --no-group) if preserve==:nochown
  rsync_opts+=["--chown", chown] if chown
  rsync_opts << "--ignore-existing" unless clobber
  #on dest: do not replace a symlink to a directory with the real directory
  #use --copy-dirlinks for the same usage on source
  rsync_opts << "--keep-dirlinks" if keep_dirlinks
  exclude.each do |ex|
    rsync_opts += ["--exclude", ex.shellescape]
  end
  if relative
    rsync_opts << "--relative"
    rsync_opts << "--no-implied-dirs"
  end
  rsync_opts << "--delete" if delete
  if clean_out
    out=Pathname.new(out)
    out.rmtree
    out.mkpath
  end
  opts[:log]||=true
  opts[:log_level_execute]||=:info
  if backup
    rsync_opts << "--backup"
    rsync_opts << (backup.to_s[-1]=="/" ? "--backup-dir=#{backup}" : "--suffix=#{backup}") unless backup==true
  end
  if sshcommand
    rsync_opts << "-e"
    rsync_opts << sshcommand.shellescape
  end
  rsync_opts+=opts.delete(:rsync_late_opts)||[]
  cmd=["rsync"]+rsync_opts+files.map(&:to_s)+[out.to_s]
  Sh.sh(*cmd, expected: expected, **opts, &b)
  #expected: rsync error code 23 is some files/attrs were not transferred
end

#run_pager(*args, launch: :tty, default_less_env: "-FRX") ⇒ Object

all output is sent to the pager



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/shell_helpers/utils.rb', line 105

def run_pager(*args, launch: :tty, default_less_env: "-FRX")
  return unless $stdout.tty? and launch != :never
  read, write = IO.pipe

  unless Kernel.fork # Child process
    $stdout.reopen(write)
    $stderr.reopen(write) if $stderr.tty?
    read.close
    write.close
    return
  end

  # Parent process, become pager
  $stdin.reopen(read)
  read.close
  write.close

  #ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
  less_env=ENV['LESS']
  less_env=default_less_env if less_env.empty?
  less_env+="F" unless less_env.match(/F/) or launch == :always
  less_env+="R" unless less_env.match(/R/)
  less_env+="X" unless less_env.match(/X/)
  ENV['LESS']=less_env

  Kernel.select [$stdin] # Wait until we have input before we start the pager
  pager = ENV['PAGER'] || 'less'
  run=args.unshift(pager)
  exec(*run) rescue exec "/bin/sh", "-c", *run
end

#ssh(host, *commands, mode: :system, ssh_command: 'ssh', ssh_options: [], ssh_Ooptions: [], port: nil, forward: nil, x11: nil, user: nil, path: nil, parse: true, pty: nil, ssh_env: nil, **opts, &b) ⇒ Object

host can be of the form user@host:port warning this is different from standard ssh syntax of user@host:path



248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/shell_helpers/utils.rb', line 248

def ssh(host, *commands, mode: :system, ssh_command: 'ssh',
  ssh_options: [], ssh_Ooptions: [],
  port: nil, forward: nil, x11: nil, user: nil, path: nil, parse: true,
  pty: nil, ssh_env:nil,
  **opts, &b)

  #sshkit has a special setting for :local
  host=host.to_s unless mode==:sshkit and host.is_a?(Symbol)
  parse and host.is_a?(String) and host.match(/^(?:(.*)@)?(.*?)(?::(\d*))?$/) do |m|
    user||=m[1]
    host=m[2]
    port||=m[3]
  end
  unless mode==:net_ssh or mode==:sshkit
    ssh_command, *command_options= ssh_command.shellsplit
    ssh_options=command_options+ssh_options
    ssh_options += ["-p", port.to_s] if port
    ssh_options += ["-W", forward] if forward
    if x11 == :trusted
      ssh_options << "-Y"
    elsif x11
      ssh_options << "-X"
    end
    ssh_options << "-T" if pty==false
    ssh_options << "-t" if pty==true
    ssh_options += ssh_Ooptions.map {|o| ["-o", o]}.flatten
  else #net_ssh options needs to be a hash
    ssh_options={} if ssh_options.is_a?(Array)
    ssh_options[:port]=port if port
  end
  case mode
  when :system,:spawn,:capture,:exec
    host="#{user}@#{host}" if user
    env_commands= ssh_env ? [Export.export_variables(ssh_env, inline: true)]+commands : commands
    Sh.sh(* [ssh_command]+ssh_options+[host]+env_commands, mode: mode, **opts)
  when :net_ssh
    require 'net/ssh'
    user=nil;
    Net::SSH.start(host, user, ssh_options, &b)
  when :sshkit
    require 'sshkit'
    host=SSHKit::Host.new(host)
    host.extend(ExtendSSHKit)
    host.port=port if port
    host.user=user if user
    host.ssh_options=ssh_options
    host
  when :uri
    URI::Ssh::Generic.build(scheme: 'ssh', userinfo: user, host: host, path: path, port: port) #, query: ssh_options.join('&'))
  else
    # return options
    { ssh_command: ssh_command,
      ssh_options: ssh_options,
      ssh_command_options: ([ssh_command]+ssh_options).shelljoin,
      user: user,
      host: host,
      path: path,
      hostssh: user ? "#{user}@#{host}" : host,
      command: commands }
  end
end