Class: ShellHelpers::PathnameExt::Base

Inherits:
Pathname
  • Object
show all
Defined in:
lib/shell_helpers/pathname.rb

Direct Known Subclasses

ShellHelpers::Pathname

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Pathname

#write

Class Method Details

./(path) ⇒ Object

Pathname / 'usr'



74
75
76
 
# File 'lib/shell_helpers/pathname.rb', line 74

def /(path)
	new(path)
end

.[](path) ⇒ Object

Pathname['/usr']



78
79
80
 
# File 'lib/shell_helpers/pathname.rb', line 78

def [](path)
	new(path)
end

.cd(dir, &b) ⇒ Object 



82
83
84
 
# File 'lib/shell_helpers/pathname.rb', line 82

def cd(dir,&b)
	self.new(dir).cd(&b)
end

.current ⇒ Object

differ from Pathname.pwd in that this returns a relative path



66
67
68
 
# File 'lib/shell_helpers/pathname.rb', line 66

def current
	return Pathname.new(".")
end

.home ⇒ Object 



56
57
58
 
# File 'lib/shell_helpers/pathname.rb', line 56

def home
	return Pathname.new(Dir.home)
end

.hometilde ⇒ Object 



59
60
61
 
# File 'lib/shell_helpers/pathname.rb', line 59

def hometilde
	return Pathname.new('~')
end

.null ⇒ Object 



69
70
71
 
# File 'lib/shell_helpers/pathname.rb', line 69

def null
	return Pathname.new('/dev/null')
end

.slash ⇒ Object 



62
63
64
 
# File 'lib/shell_helpers/pathname.rb', line 62

def slash
	return Pathname.new("/")
end

Instance Method Details

#abs_path(base: self.class.pwd, mode: :clean) ⇒ Object 



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/shell_helpers/pathname.rb', line 205

def abs_path(base: self.class.pwd, mode: :clean)
	f= absolute? ? self : base+self
	case mode
	when :clean
		f.cleanpath
	when :clean_sym
		f.cleanpath(consider_symlink: true)
	when :real
		f.realpath
	when :realdir
		f.realdirpath
	else
		f
	end
end

#append_name(*args, join: '') ⇒ Object

Pathname.new("foo")+"bar" return "foo/bar" Pathname.new("foo").append_name("bar") return "foobar"



147
148
149
 
# File 'lib/shell_helpers/pathname.rb', line 147

def append_name(*args,join:'')
	Pathname.new(self.to_s+args.join(join))
end

#backup(suffix: '.old', overwrite: true) ⇒ Object 



196
197
198
199
200
201
202
203
 
# File 'lib/shell_helpers/pathname.rb', line 196

def backup(suffix: '.old', overwrite: true)
	if self.exist?
		filebk=self.append_name(suffix)
		filebk=nonexisting_name if filebk.exist? and !overwrite
		logger.debug "Backup #{self} -> #{filebk}" if respond_to?(:logger)
		FileUtils.mv(self,filebk)
	end
end

#bad_symlink? ⇒ Boolean

Returns:

  • (Boolean) 


314
315
316
 
# File 'lib/shell_helpers/pathname.rb', line 314

def bad_symlink?
	symlink? and !dereference.exist?
end

#binary? ⇒ Boolean

stolen from ptools (https://github.com/djberg96/ptools/blob/master/lib/ptools.rb)

Returns:

  • (Boolean) 


167
168
169
170
171
172
173
174
175
 
# File 'lib/shell_helpers/pathname.rb', line 167

def binary?
	return false if directory?
	bytes = stat.blksize
	bytes = 4096 if bytes > 4096
	s = read(bytes, bytes) || ""
	#s = s.encode('US-ASCII', :undef => :replace).split(//)
	s=s.split(//)
	((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
end

#call(prog, *args, pos: :last, full: false, **opts) ⇒ Object

calls an external program



357
358
359
360
361
362
363
364
 
# File 'lib/shell_helpers/pathname.rb', line 357

def call(prog,*args,pos: :last,full:false,**opts)
	name=to_s
	name=(self.class.pwd+self).to_s if full and relative?
	sh_args=args
	pos=sh_args.length if pos==:last
	sh_args[pos,0]=name
	Sh.sh(prog,*sh_args,**opts)
end

#chattr(*args, **opts) ⇒ Object 



366
367
368
 
# File 'lib/shell_helpers/pathname.rb', line 366

def chattr(*args,**opts)
	call("chattr",*args,**opts)
end

#components ⇒ Object 



129
130
131
 
# File 'lib/shell_helpers/pathname.rb', line 129

def components
	each_filename.to_a
end

#convert_path(base: self.class.pwd, mode: :clean, checkdir: false) ⇒ Object

call abs_path or rel_path according to :mode



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/shell_helpers/pathname.rb', line 230

def convert_path(base: self.class.pwd, mode: :clean, checkdir: false)
	case mode
	when :clean
		cleanpath
	when :clean_sym
		cleanpath(consider_symlink: true)
	when :rel
		rel_path(base: base, checkdir: checkdir)
	when :relative
		rel_path(base: base, checkdir: checkdir) unless self.relative?
	when :absolute,:abs
		abs_path(base: base, mode: :abs)
	when :abs_clean
		abs_path(base: base, mode: :clean)
	when :abs_cleansym
		abs_path(base: base, mode: :cleansym)
	when :abs_real
		abs_path(base: base, mode: :real)
	when :abs_realdir
		abs_path(base: base, mode: :realdir)
	else
		self
	end
end

#copy_entry(dest, dereference: false, preserve: true) ⇒ Object

use the low level FileUtils feature to copy the metadata if passed a dir just copy the dir metadata, not the directory recursively Note this differs from FileUtils.copy_entry who copy directories recursively



48
49
50
51
52
53
 
# File 'lib/shell_helpers/pathname.rb', line 48

def copy_entry(dest, dereference: false, preserve: true)
	require 'fileutils'
	ent = FileUtils::Entry_.new(@path, nil, dereference)
	ent.copy dest.to_s
	ent.copy_metadata dest.to_s if preserve
end

#depth ⇒ Object 



132
133
134
 
# File 'lib/shell_helpers/pathname.rb', line 132

def depth
	each_filename.count
end

#dereference(mode = true) ⇒ Object 



303
304
305
306
307
308
309
310
311
312
 
# File 'lib/shell_helpers/pathname.rb', line 303

def dereference(mode=true)
	return self unless mode
	case mode
	when :simple
		return follow if symlink?
	else
		return follow.dereference(mode) if symlink?
	end
	self
end

#entries(filter: true) ⇒ Object 



136
137
138
139
140
141
142
143
 
# File 'lib/shell_helpers/pathname.rb', line 136

def entries(filter: true)
	c=super()
	if filter
		c.reject {|c| c.to_s=="." or c.to_s==".."}
	else
		c
	end
end

#filewrite(*args, mode: "w", perm: nil, mkpath: false, backup: false) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/shell_helpers/pathname.rb', line 109

def filewrite(*args,mode:"w",perm: nil,mkpath: false,backup: false)
	logger.debug("Write to #{self}"+ (perm ? " (#{perm})" : "")) if respond_to?(:logger)
	self.dirname.mkpath if mkpath
	self.backup if backup and exist?
	if !exist? && symlink?
		logger.debug "Removing bad symlink #{self}" if respond_to?(:logger)
		self.unlink
	end
	self.open(mode: mode) do |fh|
		fh.chmod(perm) if perm
		#hack to pass an array to write and do the right thing
		if args.length == 1 && Array === args.first
			fh.puts(args.first)
		else
			fh.write(*args)
		end
		yield fh if block_given?
	end
end

#find(*args, &b) ⇒ Object 



276
277
278
279
 
# File 'lib/shell_helpers/pathname.rb', line 276

def find(*args,&b)
	require 'shell_helpers/utils'
	Utils.find(self,*args,&b)
end

#follow ⇒ Object

follow a symlink



293
294
295
296
297
298
299
300
301
 
# File 'lib/shell_helpers/pathname.rb', line 293

def follow
	return self unless symlink?
	l=readlink
	if l.relative?
		self.dirname+l
	else
		l
	end
end

#hidden? ⇒ Boolean

Returns:

  • (Boolean) 


318
319
320
321
 
# File 'lib/shell_helpers/pathname.rb', line 318

def hidden?
	#without abs_path '.' is considered as hidden
	abs_path.basename.to_s[0]=="."
end

#may_exist? ⇒ Boolean

exist? returns false if called on a symlink pointing to a non existing file

Returns:

  • (Boolean) 


97
98
99
 
# File 'lib/shell_helpers/pathname.rb', line 97

def may_exist?
	exist? or symlink?
end

#new_name(cond) ⇒ Object

loop until we get a name satisfying cond



152
153
154
155
156
157
 
# File 'lib/shell_helpers/pathname.rb', line 152

def new_name(cond)
	loop.with_index do |_,ind|
		n=self.class.new(yield(self,ind))
		return n if cond.call(n)
	end
end

#nonexisting_name ⇒ Object

find a non existing filename



159
160
161
162
163
164
 
# File 'lib/shell_helpers/pathname.rb', line 159

def nonexisting_name
	return self unless self.may_exist?
	new_name(Proc.new {|f| !f.may_exist?}) do |old_name, ind|
		old_name.append_name("%02d" % ind)
	end
end

#orig_find ⇒ Object

overwrites Pathname#find



275
 
# File 'lib/shell_helpers/pathname.rb', line 275

alias orig_find find

#read! ⇒ Object

like read, but output nil rather than an exception if the file does not exist



103
104
105
106
107
 
# File 'lib/shell_helpers/pathname.rb', line 103

def read!
		read
rescue
	nil
end

#readbin(*args) ⇒ Object 



184
185
186
 
# File 'lib/shell_helpers/pathname.rb', line 184

def readbin(*args)
	open("rb").read(*args)
end

#rel_glob(pattern, expand: false) ⇒ Object

We now have Pathname#glob



282
283
284
285
286
287
288
289
290
 
# File 'lib/shell_helpers/pathname.rb', line 282

def rel_glob(pattern, expand: false)
	g=[]
	self.cd { g=Dir.glob(pattern) }
	if expand
		g.map {|f| self+f} 
	else
		g.map {|f| Pathname.new(f)}
	end
end

#rel_path(base: self.class.pwd, checkdir: false) ⇒ Object 



221
222
223
224
225
226
227
 
# File 'lib/shell_helpers/pathname.rb', line 221

def rel_path(base: self.class.pwd, checkdir: false)
	base=base.dirname unless base.directory? if checkdir
	relative_path_from(base)
rescue ArgumentError => e
	warn "#{self}.relative_path_from(#{base}): #{e}"
	self
end

#rel_path_to(target = self.class.pwd, base: self.class.pwd, mode: :rel, clean_mode: :abs_clean, inside: false, **opts) ⇒ Object

path from self to target (warning: we always assume that we are one level up self, except if inside is true) bar=SH::Pathname.new("foo/bar"); baz=SH::Pathname.new("foo/baz") bar.rel_path_to(baz) #ShellHelpers::Pathname:baz bar.rel_path_to(baz, inside: true) #ShellHelpers::Pathname:../baz note: there is no real sense to use mode: :rel here, but we don't prevent it



262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/shell_helpers/pathname.rb', line 262

def rel_path_to(target=self.class.pwd, base: self.class.pwd, mode: :rel, clean_mode: :abs_clean, inside: false, **opts)
	target=self.class.new(target) unless target.is_a?(self.class)
	sbase=opts[:source_base]||base
	smode=opts[:source_mode]||clean_mode
	tbase=opts[:target_base]||base
	tmode=opts[:target_mode]||clean_mode
	source=self.convert_path(base: sbase, mode: smode)
	target=target.convert_path(base: tbase, mode: tmode)
	from=inside ? source : source.dirname
	target.convert_path(base: from, mode: mode)
end

#rm_bad_symlinks(rm: false, hidden: false) ⇒ Object 



338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/shell_helpers/pathname.rb', line 338

def rm_bad_symlinks(rm:false,hidden:false)
	r=[]
	if directory?
		filter=if hidden
				->(x,_) {x.hidden?}
			else
				->(*x) {false}
			end
		find(filter:filter) do |file|
			if file.bad_symlink?
				r<<file
				file.rm if rm
			end
		end
	end
	r
end

#rm_empty_dirs(rm: true) ⇒ Object

remove all empty directories inside self this includes directories which only include empty directories



325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/shell_helpers/pathname.rb', line 325

def rm_empty_dirs(rm:true)
	r=[]
	if directory?
		find(depth:true) do |file|
			if file.directory? and file.children(false).empty?
				r<<file
				file.rmdir if rm
			end
		end
	end
	r
end

#rm_r ⇒ Object

rmtree should be rm_rf, not rm_r!



27
 
# File 'lib/shell_helpers/pathname.rb', line 27

alias_method :rm_r, :rmtree

#rmtree ⇒ Object Also known as: rm_rf 



28
29
30
31
32
 
# File 'lib/shell_helpers/pathname.rb', line 28

def rmtree
	require 'fileutils'
	FileUtils.rm_rf(@path)
	nil
end

#shellescape ⇒ Object 



35
36
37
38
 
# File 'lib/shell_helpers/pathname.rb', line 35

def shellescape
	require 'shellwords'
	to_s.shellescape
end

#split_all ⇒ Object

taken from facets/split_all



189
190
191
192
193
194
 
# File 'lib/shell_helpers/pathname.rb', line 189

def split_all
	head, tail = split
	return [tail] if head.to_s == '.' || tail.to_s == '/'
	return [head, tail] if head.to_s == '/'
	return head.split_all + [tail]
end

#sudo_mkdir ⇒ Object 



370
371
372
 
# File 'lib/shell_helpers/pathname.rb', line 370

def sudo_mkdir
	Sh.sh("mkdir -p #{shellescape}", sudo: true)
end

#sudo_mkpath ⇒ Object 



373
374
375
 
# File 'lib/shell_helpers/pathname.rb', line 373

def sudo_mkpath
	Sh.sh("mkdir -p #{shellescape}", sudo: true)
end

#text? ⇒ Boolean

return true if the file is a text

Returns:

  • (Boolean) 


178
179
180
181
182
 
# File 'lib/shell_helpers/pathname.rb', line 178

def text?
	#!! %x/file #{self.to_s}/.match(/text/)
	return false if directory?
	!binary?
end

#to_relative ⇒ Object 



40
41
42
43
 
# File 'lib/shell_helpers/pathname.rb', line 40

def to_relative
	return self if relative?
	relative_path_from(Pathname.slash)
end