Class: FakeFS::Pathname

Inherits:
Object
  • Object
show all
Defined in:
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb,
lib/fakefs/pathname.rb

Overview

Pathname class

Constant Summary collapse

TO_PATH =

to_path is implemented so Pathname objects are usable with File.open, etc.

:to_path
SAME_PATHS = 
if File::FNM_SYSCASE.nonzero?
  proc { |a, b| a.casecmp(b).zero? }
else
  proc { |a, b| a == b }
end
SEPARATOR_LIST = 
"#{Regexp.quote File::SEPARATOR}"
SEPARATOR_PAT = 
/#{Regexp.quote File::SEPARATOR}/

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path) ⇒ Pathname

Create a Pathname object from the given String (or String-like object). If path contains a NUL character (\0), an ArgumentError is raised.



33
34
35
36
37
38
39
40
41
42
 
# File 'lib/fakefs/pathname.rb', line 33

def initialize(path)
  path = path.__send__(TO_PATH) if path.respond_to? TO_PATH
  @path = path.dup

  if /\0/ =~ @path
    fail ArgumentError, "pathname contains \\0: #{@path.inspect}"
  end

  taint if @path.tainted?
end

Class Method Details

.getwd ⇒ Object Also known as: pwd

See Dir.getwd. Returns the current working directory as a Pathname.



928
929
930
 
# File 'lib/fakefs/pathname.rb', line 928

def self.getwd
  new(Dir.getwd)
end

.glob(*args) ⇒ Object

See Dir.glob. Returns or yields Pathname objects.



918
919
920
921
922
923
924
 
# File 'lib/fakefs/pathname.rb', line 918

def self.glob(*args) # :yield: pathname
  if block_given?
    Dir.glob(*args) { |f| yield new(f) }
  else
    Dir.glob(*args).map { |f| new(f) }
  end
end

Instance Method Details

#+(other) ⇒ Object

Pathname#+ appends a pathname fragment to this one to produce a new Pathname object.

p1 = Pathname.new("/usr")      # Pathname:/usr
p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd

This method doesn’t access the file system; it is pure string manipulation.



430
431
432
433
 
# File 'lib/fakefs/pathname.rb', line 430

def +(other)
  other = Pathname.new(other) unless other.is_a?(Pathname)
  Pathname.new(plus(@path, other.to_s))
end

#<=>(other) ⇒ Object

Provides for comparing pathnames, case-sensitively.



76
77
78
79
 
# File 'lib/fakefs/pathname.rb', line 76

def <=>(other)
  return nil unless other.is_a?(Pathname)
  @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
end

#==(other) ⇒ Object Also known as: ===, eql?

Compare this pathname with other. The comparison is string-based. Be aware that two different paths (foo.txt and ./foo.txt) can refer to the same file.



67
68
69
70
 
# File 'lib/fakefs/pathname.rb', line 67

def ==(other)
  return false unless other.is_a?(Pathname)
  other.to_s == @path
end

#absolute? ⇒ Boolean

Predicate method for testing whether a path is absolute. It returns true if the pathname begins with a slash.

Returns:

  • (Boolean) 


335
336
337
 
# File 'lib/fakefs/pathname.rb', line 335

def absolute?
  !relative?
end

#ascend {|_self| ... } ⇒ Object

Iterates over and yields a new Pathname object for each element in the given path in ascending order.

Pathname.new('/path/to/some/file.rb').ascend { |v| p v}
   #<Pathname:/path/to/some/file.rb>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to>
   #<Pathname:/path>
   #<Pathname:/>

Pathname.new('path/to/some/file.rb').ascend { |v| p v}
   #<Pathname:path/to/some/file.rb>
   #<Pathname:path/to/some>
   #<Pathname:path/to>
   #<Pathname:path>

It doesn’t access actual filesystem.

This method is available since 1.8.5.

Yields:

  • (_self)

Yield Parameters:



408
409
410
411
412
413
414
415
416
 
# File 'lib/fakefs/pathname.rb', line 408

def ascend
  path = @path
  yield self
  while (r = chop_basename(path))
    path, _name = r
    break if path.empty?
    yield self.class.new(del_trailing_separator(path))
  end
end

#atime ⇒ Object

See File.atime. Returns last access time.



667
668
669
 
# File 'lib/fakefs/pathname.rb', line 667

def atime
  File.atime(@path)
end

#basename(*args) ⇒ Object

See File.basename. Returns the last component of the path.



765
766
767
 
# File 'lib/fakefs/pathname.rb', line 765

def basename(*args)
  self.class.new(File.basename(@path, *args))
end

#binread(*args) ⇒ Object

See IO.binread. Returns all the bytes from the file, or the first N if specified.



649
650
651
 
# File 'lib/fakefs/pathname.rb', line 649

def binread(*args)
  File.binread(@path, *args)
end

#blockdev? ⇒ Boolean

See FileTest.blockdev?.

Returns:

  • (Boolean) 


795
796
797
 
# File 'lib/fakefs/pathname.rb', line 795

def blockdev?
  FileTest.blockdev?(@path)
end

#chardev? ⇒ Boolean

See FileTest.chardev?.

Returns:

  • (Boolean) 


800
801
802
 
# File 'lib/fakefs/pathname.rb', line 800

def chardev?
  FileTest.chardev?(@path)
end

#children(with_directory = true) ⇒ Object

Returns the children of the directory (files and subdirectories, not recursive) as an array of Pathname objects. By default, the returned pathnames will have enough information to access the files. If you set with_directory to false, then the returned pathnames will contain the filename only.

For example:

pn = Pathname("/usr/lib/ruby/1.8")
pn.children
  # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
         Pathname:/usr/lib/ruby/1.8/Env.rb,
         Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
pn.children(false)
  # -> [ Pathname:English.rb,
         Pathname:Env.rb,
         Pathname:abbrev.rb, ... ]

Note that the result never contain the entries . and .. in the directory because they are not children.

This method has existed since 1.8.1.



527
528
529
530
531
532
533
534
535
536
537
538
539
 
# File 'lib/fakefs/pathname.rb', line 527

def children(with_directory = true)
  with_directory = false if @path == '.'
  result = []
  Dir.foreach(@path) do |e|
    next if e == '.' || e == '..'
    if with_directory
      result << self.class.new(File.join(@path, e))
    else
      result << self.class.new(e)
    end
  end
  result
end

#chmod(mode) ⇒ Object

See File.chmod. Changes permissions.



683
684
685
 
# File 'lib/fakefs/pathname.rb', line 683

def chmod(mode)
  File.chmod(mode, @path)
end

#chown(owner, group) ⇒ Object

See File.chown. Change owner and group of file.



693
694
695
 
# File 'lib/fakefs/pathname.rb', line 693

def chown(owner, group)
  File.chown(owner, group, @path)
end

#cleanpath(consider_symlink = false) ⇒ Object

Returns clean pathname of self with consecutive slashes and useless dots removed. The filesystem is not accessed.

If consider_symlink is true, then a more conservative algorithm is used to avoid breaking symbolic linkages. This may retain more .. entries than absolutely necessary, but without accessing the filesystem, this can’t be avoided. See #realpath.



182
183
184
185
186
187
188
 
# File 'lib/fakefs/pathname.rb', line 182

def cleanpath(consider_symlink = false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end

#ctime ⇒ Object

See File.ctime. Returns last (directory entry, not file) change time.



673
674
675
 
# File 'lib/fakefs/pathname.rb', line 673

def ctime
  File.ctime(@path)
end

#descend ⇒ Object

Iterates over and yields a new Pathname object for each element in the given path in descending order.

Pathname.new('/path/to/some/file.rb').descend { |v| p v}
   #<Pathname:/>
   #<Pathname:/path>
   #<Pathname:/path/to>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to/some/file.rb>

Pathname.new('path/to/some/file.rb').descend { |v| p v}
   #<Pathname:path>
   #<Pathname:path/to>
   #<Pathname:path/to/some>
   #<Pathname:path/to/some/file.rb>

It doesn’t access actual filesystem.

This method is available since 1.8.5.



381
382
383
384
385
386
 
# File 'lib/fakefs/pathname.rb', line 381

def descend
  vs = []
  ascend { |v| vs << v }
  vs.reverse_each { |v| yield v }
  nil
end

#directory? ⇒ Boolean

See FileTest.directory?.

Returns:

  • (Boolean) 


825
826
827
 
# File 'lib/fakefs/pathname.rb', line 825

def directory?
  FileTest.directory?(@path)
end

#dirname ⇒ Object

See File.dirname. Returns all but the last component of the path.



771
772
773
 
# File 'lib/fakefs/pathname.rb', line 771

def dirname
  self.class.new(File.dirname(@path))
end

#each_child(with_directory = true, &b) ⇒ Object

Iterates over the children of the directory (files and subdirectories, not recursive). It yields Pathname object for each child. By default, the yielded pathnames will have enough information to access the files. If you set with_directory to false, then the returned pathnames will contain the filename only.

Pathname("/usr/local").each_child { |f| p f }
#=> #<Pathname:/usr/local/share>
#   #<Pathname:/usr/local/bin>
#   #<Pathname:/usr/local/games>
#   #<Pathname:/usr/local/lib>
#   #<Pathname:/usr/local/include>
#   #<Pathname:/usr/local/sbin>
#   #<Pathname:/usr/local/src>
#   #<Pathname:/usr/local/man>

Pathname("/usr/local").each_child(false) { |f| p f }
#=> #<Pathname:share>
#   #<Pathname:bin>
#   #<Pathname:games>
#   #<Pathname:lib>
#   #<Pathname:include>
#   #<Pathname:sbin>
#   #<Pathname:src>
#   #<Pathname:man>



569
570
571
 
# File 'lib/fakefs/pathname.rb', line 569

def each_child(with_directory = true, &b)
  children(with_directory).each(&b)
end

#each_entry ⇒ Object

Iterates over the entries (files and subdirectories) in the directory. It yields a Pathname object for each entry.

This method has existed since 1.8.1.



944
945
946
 
# File 'lib/fakefs/pathname.rb', line 944

def each_entry(*) # :yield: pathname
  Dir.foreach(@path) { |f| yield self.class.new(f) }
end

#each_filename ⇒ Object

Iterates over each component of the path.

Pathname.new("/usr/bin/ruby").each_filename { |filename| ... }
  # yields "usr", "bin", and "ruby".



354
355
356
357
358
359
 
# File 'lib/fakefs/pathname.rb', line 354

def each_filename # :yield: filename
  return to_enum(__method__) unless block_given?
  _prefix, names = split_names(@path)
  names.each { |filename| yield filename }
  nil
end

#each_line(*args, &block) ⇒ Object

#each_line iterates over the line in the file. It yields a String object for each line.

This method has existed since 1.8.1.



631
632
633
634
635
636
637
638
639
 
# File 'lib/fakefs/pathname.rb', line 631

def each_line(*args, &block) # :yield: line
  if block_given?
    File.open(@path, 'r') do |io|
      io.each_line(*args, &block)
    end
  else
    enum_for(:each_line, *args)
  end
end

#entries ⇒ Object

Return the entries (files and subdirectories) in the directory, each as a Pathname object.



936
937
938
 
# File 'lib/fakefs/pathname.rb', line 936

def entries
  Dir.entries(@path).map { |f| self.class.new(f) }
end

#executable? ⇒ Boolean

See FileTest.executable?.

Returns:

  • (Boolean) 


805
806
807
 
# File 'lib/fakefs/pathname.rb', line 805

def executable?
  FileTest.executable?(@path)
end

#executable_real? ⇒ Boolean

See FileTest.executable_real?.

Returns:

  • (Boolean) 


810
811
812
 
# File 'lib/fakefs/pathname.rb', line 810

def executable_real?
  FileTest.executable_real?(@path)
end

#exist? ⇒ Boolean

See FileTest.exist?.

Returns:

  • (Boolean) 


815
816
817
 
# File 'lib/fakefs/pathname.rb', line 815

def exist?
  FileTest.exist?(@path)
end

#expand_path(*args) ⇒ Object

See File.expand_path.



781
782
783
 
# File 'lib/fakefs/pathname.rb', line 781

def expand_path(*args)
  self.class.new(File.expand_path(@path, *args))
end

#extname ⇒ Object

See File.extname. Returns the file’s extension.



776
777
778
 
# File 'lib/fakefs/pathname.rb', line 776

def extname
  File.extname(@path)
end

#file? ⇒ Boolean

See FileTest.file?.

Returns:

  • (Boolean) 


830
831
832
 
# File 'lib/fakefs/pathname.rb', line 830

def file?
  FileTest.file?(@path)
end

#find ⇒ Object

Pathname#find is an iterator to traverse a directory tree in a depth first manner. It yields a Pathname for each file under “this” directory.

Since it is implemented by find.rb, Find.prune can be used to control the traverse.

If self is ., yielded pathnames begin with a filename in the current directory, not ./.



977
978
979
980
981
982
983
984
 
# File 'lib/fakefs/pathname.rb', line 977

def find(*) # :yield: pathname
  require 'find'
  if @path == '.'
    Find.find(@path) { |f| yield self.class.new(f.sub(%r{/\A\./}, '')) }
  else
    Find.find(@path) { |f| yield self.class.new(f) }
  end
end

#fnmatch(pattern, *args) ⇒ Object

See File.fnmatch. Return true if the receiver matches the given pattern



704
705
706
 
# File 'lib/fakefs/pathname.rb', line 704

def fnmatch(pattern, *args)
  File.fnmatch(pattern, @path, *args)
end

#fnmatch?(pattern, *args) ⇒ Boolean

See File.fnmatch? (same as #fnmatch).

Returns:

  • (Boolean) 


709
710
711
 
# File 'lib/fakefs/pathname.rb', line 709

def fnmatch?(pattern, *args)
  File.fnmatch?(pattern, @path, *args)
end

#freeze ⇒ Object 



44
45
46
47
48
 
# File 'lib/fakefs/pathname.rb', line 44

def freeze
  super
  @path.freeze
  self
end

#ftype ⇒ Object

See File.ftype. Returns “type” of file (“file”, “directory”, etc).



715
716
717
 
# File 'lib/fakefs/pathname.rb', line 715

def ftype
  File.ftype(@path)
end

#grpowned? ⇒ Boolean

See FileTest.grpowned?.

Returns:

  • (Boolean) 


820
821
822
 
# File 'lib/fakefs/pathname.rb', line 820

def grpowned?
  FileTest.grpowned?(@path)
end

#hash ⇒ Object

:nodoc:



81
82
83
 
# File 'lib/fakefs/pathname.rb', line 81

def hash # :nodoc:
  @path.hash
end

#inspect ⇒ Object

:nodoc:



94
95
96
 
# File 'lib/fakefs/pathname.rb', line 94

def inspect # :nodoc:
  "#<#{self.class}:#{@path}>"
end

#join(*args) ⇒ Object

Pathname#join joins pathnames.

path0.join(path1, ..., pathN) is the same as path0 + path1 + ... + pathN.



489
490
491
492
493
494
495
496
497
498
499
500
 
# File 'lib/fakefs/pathname.rb', line 489

def join(*args)
  args.unshift self
  result = args.pop
  result = Pathname.new(result) unless result.is_a?(Pathname)
  return result if result.absolute?
  args.reverse_each do |arg|
    arg = Pathname.new(arg) unless arg.is_a?(Pathname)
    result = arg + result
    return result if result.absolute?
  end
  result
end

#lchmod(mode) ⇒ Object

See File.lchmod.



688
689
690
 
# File 'lib/fakefs/pathname.rb', line 688

def lchmod(mode)
  File.lchmod(mode, @path)
end

#lchown(owner, group) ⇒ Object

See File.lchown.



698
699
700
 
# File 'lib/fakefs/pathname.rb', line 698

def lchown(owner, group)
  File.lchown(owner, group, @path)
end

#lstat ⇒ Object

See File.lstat.



745
746
747
 
# File 'lib/fakefs/pathname.rb', line 745

def lstat
  File.lstat(@path)
end

#make_link(old) ⇒ Object

See File.link. Creates a hard link.



720
721
722
 
# File 'lib/fakefs/pathname.rb', line 720

def make_link(old)
  File.link(old, @path)
end

#make_symlink(old) ⇒ Object

See File.symlink. Creates a symbolic link.



750
751
752
 
# File 'lib/fakefs/pathname.rb', line 750

def make_symlink(old)
  File.symlink(old, @path)
end

#mkdir(*args) ⇒ Object

See Dir.mkdir. Create the referenced directory.



949
950
951
 
# File 'lib/fakefs/pathname.rb', line 949

def mkdir(*args)
  Dir.mkdir(@path, *args)
end

#mkpath ⇒ Object

See FileUtils.mkpath. Creates a full path, including any intermediate directories that don’t yet exist.



991
992
993
994
995
 
# File 'lib/fakefs/pathname.rb', line 991

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

#mountpoint? ⇒ Boolean

#mountpoint? returns true if self points to a mountpoint.

Returns:

  • (Boolean) 


310
311
312
313
314
315
316
317
318
319
 
# File 'lib/fakefs/pathname.rb', line 310

def mountpoint?
  stat1 = lstat
  begin
    stat2 = parent.lstat
    stat1.dev == stat2.dev && stat1.ino == stat2.ino ||
      stat1.dev != stat2.dev
  rescue Errno::ENOENT
    false
  end
end

#mtime ⇒ Object

See File.mtime. Returns last modification time.



678
679
680
 
# File 'lib/fakefs/pathname.rb', line 678

def mtime
  File.mtime(@path)
end

#open(*args, &block) ⇒ Object

See File.open. Opens the file for reading or writing.



725
726
727
 
# File 'lib/fakefs/pathname.rb', line 725

def open(*args, &block) # :yield: file
  File.open(@path, *args, &block)
end

#opendir(&block) ⇒ Object

See Dir.open.



959
960
961
 
# File 'lib/fakefs/pathname.rb', line 959

def opendir(&block) # :yield: dir
  Dir.open(@path, &block)
end

#owned? ⇒ Boolean

See FileTest.owned?.

Returns:

  • (Boolean) 


845
846
847
 
# File 'lib/fakefs/pathname.rb', line 845

def owned?
  FileTest.owned?(@path)
end

#parent ⇒ Object

#parent returns the parent directory.

This is same as self + '..'.



305
306
307
 
# File 'lib/fakefs/pathname.rb', line 305

def parent
  self + '..'
end

#pipe? ⇒ Boolean

See FileTest.pipe?.

Returns:

  • (Boolean) 


835
836
837
 
# File 'lib/fakefs/pathname.rb', line 835

def pipe?
  FileTest.pipe?(@path)
end

#read(*args) ⇒ Object

See IO.read. Returns all data from the file, or the first N bytes if specified.



643
644
645
 
# File 'lib/fakefs/pathname.rb', line 643

def read(*args)
  File.read(@path, *args)
end

#readable? ⇒ Boolean

See FileTest.readable?.

Returns:

  • (Boolean) 


850
851
852
 
# File 'lib/fakefs/pathname.rb', line 850

def readable?
  FileTest.readable?(@path)
end

#readable_real? ⇒ Boolean

See FileTest.readable_real?.

Returns:

  • (Boolean) 


860
861
862
 
# File 'lib/fakefs/pathname.rb', line 860

def readable_real?
  FileTest.readable_real?(@path)
end

#readlines(*args) ⇒ Object

See IO.readlines. Returns all the lines from the file.



654
655
656
 
# File 'lib/fakefs/pathname.rb', line 654

def readlines(*args)
  File.readlines(@path, *args)
end

#readlink ⇒ Object

See File.readlink. Read symbolic link.



730
731
732
 
# File 'lib/fakefs/pathname.rb', line 730

def readlink
  self.class.new(File.readlink(@path))
end

#realdirpath(basedir = nil) ⇒ Object

Returns the real (absolute) pathname of self in the actual filesystem. The real pathname doesn’t contain symlinks or useless dots.

The last component of the real pathname can be nonexistent.



298
299
300
 
# File 'lib/fakefs/pathname.rb', line 298

def realdirpath(basedir = nil)
  self.class.new(File.realdirpath(@path, basedir))
end

#realpath(basedir = nil) ⇒ Object

Returns the real (absolute) pathname of self in the actual filesystem not containing symlinks or useless dots.

All components of the pathname must exist when this method is called.



288
289
290
 
# File 'lib/fakefs/pathname.rb', line 288

def realpath(basedir = nil)
  self.class.new(File.realpath(@path, basedir))
end

#relative? ⇒ Boolean

The opposite of #absolute?

Returns:

  • (Boolean) 


340
341
342
343
344
345
346
 
# File 'lib/fakefs/pathname.rb', line 340

def relative?
  path = @path
  while (r = chop_basename(path))
    path, _basename = r
  end
  path == ''
end

#relative_path_from(base_directory) ⇒ Object

#relative_path_from returns a relative path from the argument to the receiver. If self is absolute, the argument must be absolute too. If self is relative, the argument must be relative too.

#relative_path_from doesn’t access the filesystem. It assumes no symlinks.

ArgumentError is raised when it cannot find a relative path.

This method has existed since 1.8.1.



585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
 
# File 'lib/fakefs/pathname.rb', line 585

def relative_path_from(base_directory)
  dest_directory = cleanpath.to_s
  base_directory = base_directory.cleanpath.to_s
  dest_prefix = dest_directory
  dest_names = []
  while (r = chop_basename(dest_prefix))
    dest_prefix, basename = r
    dest_names.unshift basename if basename != '.'
  end
  base_prefix = base_directory
  base_names = []
  while (r = chop_basename(base_prefix))
    base_prefix, basename = r
    base_names.unshift basename if basename != '.'
  end
  unless SAME_PATHS[dest_prefix, base_prefix]
    fail ArgumentError, "different prefix: #{dest_prefix.inspect} " \
    "and #{base_directory.inspect}"
  end
  while !dest_names.empty? &&
        !base_names.empty? &&
        SAME_PATHS[dest_names.first, base_names.first]
    dest_names.shift
    base_names.shift
  end
  if base_names.include? '..'
    fail ArgumentError, "base_directory has ..: #{base_directory.inspect}"
  end
  base_names.fill('..')
  relpath_names = base_names + dest_names
  if relpath_names.empty?
    Pathname.new('.')
  else
    Pathname.new(File.join(*relpath_names))
  end
end

#rename(to) ⇒ Object

See File.rename. Rename the file.



735
736
737
 
# File 'lib/fakefs/pathname.rb', line 735

def rename(to)
  File.rename(@path, to)
end

#rmdir ⇒ Object

See Dir.rmdir. Remove the referenced directory.



954
955
956
 
# File 'lib/fakefs/pathname.rb', line 954

def rmdir
  Dir.rmdir(@path)
end

#rmtree ⇒ Object

See FileUtils.rm_r. Deletes a directory and all beneath it.



998
999
1000
1001
1002
1003
1004
 
# File 'lib/fakefs/pathname.rb', line 998

def rmtree
  # The name "rmtree" is borrowed from File::Path of Perl.
  # File::Path provides "mkpath" and "rmtree".
  require 'fileutils'
  FileUtils.rm_r(@path)
  nil
end

#root? ⇒ Boolean

#root? is a predicate for root directories. I.e. it returns true if the pathname consists of consecutive slashes.

It doesn’t access actual filesystem. So it may return false for some pathnames which points to roots such as /usr/...

Returns:

  • (Boolean) 


329
330
331
 
# File 'lib/fakefs/pathname.rb', line 329

def root?
  chop_basename(@path).nil? && /#{SEPARATOR_PAT}/o =~ @path
end

#setgid? ⇒ Boolean

See FileTest.setgid?.

Returns:

  • (Boolean) 


870
871
872
 
# File 'lib/fakefs/pathname.rb', line 870

def setgid?
  FileTest.setgid?(@path)
end

#setuid? ⇒ Boolean

See FileTest.setuid?.

Returns:

  • (Boolean) 


865
866
867
 
# File 'lib/fakefs/pathname.rb', line 865

def setuid?
  FileTest.setuid?(@path)
end

#size ⇒ Object

See FileTest.size.



875
876
877
 
# File 'lib/fakefs/pathname.rb', line 875

def size
  FileTest.size(@path)
end

#size? ⇒ Boolean

See FileTest.size?.

Returns:

  • (Boolean) 


880
881
882
 
# File 'lib/fakefs/pathname.rb', line 880

def size?
  FileTest.size?(@path)
end

#socket? ⇒ Boolean

See FileTest.socket?.

Returns:

  • (Boolean) 


840
841
842
 
# File 'lib/fakefs/pathname.rb', line 840

def socket?
  FileTest.socket?(@path)
end

#split ⇒ Object

See File.split. Returns the #dirname and the #basename in an Array.



787
788
789
 
# File 'lib/fakefs/pathname.rb', line 787

def split
  File.split(@path).map { |f| self.class.new(f) }
end

#stat ⇒ Object

See File.stat. Returns a File::Stat object.



740
741
742
 
# File 'lib/fakefs/pathname.rb', line 740

def stat
  File.stat(@path)
end

#sticky? ⇒ Boolean

See FileTest.sticky?.

Returns:

  • (Boolean) 


885
886
887
 
# File 'lib/fakefs/pathname.rb', line 885

def sticky?
  FileTest.sticky?(@path)
end

#sub(pattern, *rest, &block) ⇒ Object

Return a pathname which is substituted by String#sub.



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/fakefs/pathname.rb', line 99

def sub(pattern, *rest, &block)
  if block
    path = @path.sub(pattern, *rest) do |*args|
      begin
        old = Thread.current[:pathname_sub_matchdata]
        Thread.current[:pathname_sub_matchdata] = $LAST_MATCH_INFO
        eval('$~ = Thread.current[:pathname_sub_matchdata]',
             block.binding)
      ensure
        Thread.current[:pathname_sub_matchdata] = old
      end
      yield(*args)
    end
  else
    path = @path.sub(pattern, *rest)
  end
  self.class.new(path)
end

#sub_ext(repl) ⇒ Object

Return a pathname which the extension of the basename is substituted by repl.

If self has no extension part, repl is appended.



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

def sub_ext(repl)
  ext = File.extname(@path)
  self.class.new(@path.chomp(ext) + repl)
end

#symlink? ⇒ Boolean

See FileTest.symlink?.

Returns:

  • (Boolean) 


890
891
892
 
# File 'lib/fakefs/pathname.rb', line 890

def symlink?
  FileTest.symlink?(@path)
end

#sysopen(*_args) ⇒ Object

See IO.sysopen. Not supported by fakefs.



659
660
661
 
# File 'lib/fakefs/pathname.rb', line 659

def sysopen(*_args)
  fail NotImplementedError, 'sysopen is not supported by fakefs'
end

#taint ⇒ Object 



50
51
52
53
54
 
# File 'lib/fakefs/pathname.rb', line 50

def taint
  super
  @path.taint
  self
end

#to_s ⇒ Object

Return the path as a String.



86
87
88
 
# File 'lib/fakefs/pathname.rb', line 86

def to_s
  @path.dup
end

#truncate(length) ⇒ Object

See File.truncate. Truncate the file to length bytes.



755
756
757
 
# File 'lib/fakefs/pathname.rb', line 755

def truncate(length)
  File.truncate(@path, length)
end

#unlink ⇒ Object Also known as: delete

Removes a file or directory, using File.unlink or Dir.unlink as necessary.



1011
1012
1013
1014
1015
1016
1017
 
# File 'lib/fakefs/pathname.rb', line 1011

def unlink
  if File.directory? @path
    Dir.unlink @path
  else
    File.unlink @path
  end
end

#untaint ⇒ Object 



56
57
58
59
60
 
# File 'lib/fakefs/pathname.rb', line 56

def untaint
  super
  @path.untaint
  self
end

#utime(atime, mtime) ⇒ Object

See File.utime. Update the access and modification times.



760
761
762
 
# File 'lib/fakefs/pathname.rb', line 760

def utime(atime, mtime)
  File.utime(atime, mtime, @path)
end

#world_readable? ⇒ Boolean

See FileTest.world_readable?.

Returns:

  • (Boolean) 


855
856
857
 
# File 'lib/fakefs/pathname.rb', line 855

def world_readable?
  FileTest.world_readable?(@path)
end

#world_writable? ⇒ Boolean

See FileTest.world_writable?.

Returns:

  • (Boolean) 


900
901
902
 
# File 'lib/fakefs/pathname.rb', line 900

def world_writable?
  FileTest.world_writable?(@path)
end

#writable? ⇒ Boolean

See FileTest.writable?.

Returns:

  • (Boolean) 


895
896
897
 
# File 'lib/fakefs/pathname.rb', line 895

def writable?
  FileTest.writable?(@path)
end

#writable_real? ⇒ Boolean

See FileTest.writable_real?.

Returns:

  • (Boolean) 


905
906
907
 
# File 'lib/fakefs/pathname.rb', line 905

def writable_real?
  FileTest.writable_real?(@path)
end

#zero? ⇒ Boolean

See FileTest.zero?.

Returns:

  • (Boolean) 


910
911
912
 
# File 'lib/fakefs/pathname.rb', line 910

def zero?
  FileTest.zero?(@path)
end