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.



922
923
924
 
# File 'lib/fakefs/pathname.rb', line 922

def self.getwd
  new(Dir.getwd)
end

.glob(*args) ⇒ Object

See Dir.glob. Returns or yields Pathname objects.



912
913
914
915
916
917
918
 
# File 'lib/fakefs/pathname.rb', line 912

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.



661
662
663
 
# File 'lib/fakefs/pathname.rb', line 661

def atime
  File.atime(@path)
end

#basename(*args) ⇒ Object

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



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

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.



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

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

#blockdev? ⇒ Boolean

See FileTest.blockdev?.

Returns:

  • (Boolean) 


789
790
791
 
# File 'lib/fakefs/pathname.rb', line 789

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

#chardev? ⇒ Boolean

See FileTest.chardev?.

Returns:

  • (Boolean) 


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

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.



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

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

#chown(owner, group) ⇒ Object

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



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

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.



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

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) 


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

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

#dirname ⇒ Object

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



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

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.



938
939
940
 
# File 'lib/fakefs/pathname.rb', line 938

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
 
# File 'lib/fakefs/pathname.rb', line 631

def each_line(*args, &block) # :yield: line
  IO.foreach(@path, *args, &block)
end

#entries ⇒ Object

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



930
931
932
 
# File 'lib/fakefs/pathname.rb', line 930

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

#executable? ⇒ Boolean

See FileTest.executable?.

Returns:

  • (Boolean) 


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

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

#executable_real? ⇒ Boolean

See FileTest.executable_real?.

Returns:

  • (Boolean) 


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

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

#exist? ⇒ Boolean

See FileTest.exist?.

Returns:

  • (Boolean) 


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

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

#expand_path(*args) ⇒ Object

See File.expand_path.



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

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

#extname ⇒ Object

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



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

def extname
  File.extname(@path)
end

#file? ⇒ Boolean

See FileTest.file?.

Returns:

  • (Boolean) 


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

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 ./.



971
972
973
974
975
976
977
978
 
# File 'lib/fakefs/pathname.rb', line 971

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



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

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

#fnmatch?(pattern, *args) ⇒ Boolean

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

Returns:

  • (Boolean) 


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

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).



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

def ftype
  File.ftype(@path)
end

#grpowned? ⇒ Boolean

See FileTest.grpowned?.

Returns:

  • (Boolean) 


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

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.



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

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

#lchown(owner, group) ⇒ Object

See File.lchown.



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

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

#lstat ⇒ Object

See File.lstat.



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

def lstat
  File.lstat(@path)
end

#make_link(old) ⇒ Object

See File.link. Creates a hard link.



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

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

#make_symlink(old) ⇒ Object

See File.symlink. Creates a symbolic link.



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

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

#mkdir(*args) ⇒ Object

See Dir.mkdir. Create the referenced directory.



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

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.



985
986
987
988
989
 
# File 'lib/fakefs/pathname.rb', line 985

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.



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

def mtime
  File.mtime(@path)
end

#open(*args, &block) ⇒ Object

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



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

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

#opendir(&block) ⇒ Object

See Dir.open.



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

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

#owned? ⇒ Boolean

See FileTest.owned?.

Returns:

  • (Boolean) 


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

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) 


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

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.



637
638
639
 
# File 'lib/fakefs/pathname.rb', line 637

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

#readable? ⇒ Boolean

See FileTest.readable?.

Returns:

  • (Boolean) 


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

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

#readable_real? ⇒ Boolean

See FileTest.readable_real?.

Returns:

  • (Boolean) 


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

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

#readlines(*args) ⇒ Object

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



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

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

#readlink ⇒ Object

See File.readlink. Read symbolic link.



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

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.



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

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

#rmdir ⇒ Object

See Dir.rmdir. Remove the referenced directory.



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

def rmdir
  Dir.rmdir(@path)
end

#rmtree ⇒ Object

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



992
993
994
995
996
997
998
 
# File 'lib/fakefs/pathname.rb', line 992

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).nil?
end

#setgid? ⇒ Boolean

See FileTest.setgid?.

Returns:

  • (Boolean) 


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

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

#setuid? ⇒ Boolean

See FileTest.setuid?.

Returns:

  • (Boolean) 


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

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

#size ⇒ Object

See FileTest.size.



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

def size
  FileTest.size(@path)
end

#size? ⇒ Boolean

See FileTest.size?.

Returns:

  • (Boolean) 


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

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

#socket? ⇒ Boolean

See FileTest.socket?.

Returns:

  • (Boolean) 


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

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

#split ⇒ Object

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



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

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

#stat ⇒ Object

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



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

def stat
  File.stat(@path)
end

#sticky? ⇒ Boolean

See FileTest.sticky?.

Returns:

  • (Boolean) 


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

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) 


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

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

#sysopen(*args) ⇒ Object

See IO.sysopen.



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

def sysopen(*args)
  IO.sysopen(@path, *args)
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.



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

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.



1005
1006
1007
1008
 
# File 'lib/fakefs/pathname.rb', line 1005

def unlink
  Dir.unlink @path if File.directory? @path
  File.unlink @path unless File.directory? @path
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.



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

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

#world_readable? ⇒ Boolean

See FileTest.world_readable?.

Returns:

  • (Boolean) 


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

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

#world_writable? ⇒ Boolean

See FileTest.world_writable?.

Returns:

  • (Boolean) 


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

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

#writable? ⇒ Boolean

See FileTest.writable?.

Returns:

  • (Boolean) 


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

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

#writable_real? ⇒ Boolean

See FileTest.writable_real?.

Returns:

  • (Boolean) 


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

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

#zero? ⇒ Boolean

See FileTest.zero?.

Returns:

  • (Boolean) 


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

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