Module: RIO::IF::Path

Included in:
Rio
Defined in:
lib/rio/if/path.rb

Instance Method Summary collapse

Instance Method Details

#/(arg) ⇒ Object

Subdirectory operator.

Effectively the same as #join(arg)

a = rio('a')
b = rio('b')
c = a/b                   #=> rio('a/b')

ario = rio('adir')
ario/'afile.rb'           #=> rio('adir/afile.rb')
ario/'b'/'c'/'d'          #=> rio('adir/b/c/d')

ario = rio('adir')
ario /= 'afile.rb'        #=> rio('adir/afile.rb')



326
327
328
 
# File 'lib/rio/if/path.rb', line 326

def /(arg) 
  target / arg 
end

#abs(*args) ⇒ Object

Returns a new rio with a path equal to the absolute path of this rio

rio('/tmp').chdir
rio('afile').abs # => rio('/tmp/afile')



85
 
# File 'lib/rio/if/path.rb', line 85

def abs(*args) target.abs(*args)  end

#base ⇒ Object

Returns a new Rio whose path is the base path that is used by #abs to create an absolute Rio from a relative one.

rio('/tmp').chdir
rio('afile').base # => rio('/tmp/')

See #abs.



103
 
# File 'lib/rio/if/path.rb', line 103

def base() target.base()  end

#basename(*args) ⇒ Object

Similar to File#basename

Returns a Rio whose path is that returned by File#basename when passed the path of a rio and the value returned by File#extname. This differs from the behaviour of File#basename.

File.basename('afile.txt')                           #=> 'afile.txt'
File.basename('afile.txt',File.extname('afile.txt')) #=> 'afile'
rio('afile.txt').basename                            #=> rio('afile')
rio('afile.txt').basename('.txt')                    #=> same thing
rio('afile.txt').ext('.txt').basename                #=> same thing

See also #ext,#ext?,#filename,



180
 
# File 'lib/rio/if/path.rb', line 180

def basename(*args) target.basename(*args) end

#basename=(arg) ⇒ Object

Replace the part of the path returned by #basename. If in rename mode, also renames the referenced filesystem object.

Returns the new value of basename

ario = rio('dirA/dirB/afile.rb')
ario.dirname = 'dirC'          # rio('dirC/afile.rb')
ario.basename = 'bfile'        # rio('dirC/bfile.rb')
ario.extname = '.txt'          # rio('dirC/bfile.txt')
ario.filename = 'cfile.rb'     # rio('dirC/cfile.rb')

rio('adir/afile.txt').rename.filename = 'bfile.rb' # adir/afile.txt => adir/bfile.rb
rio('adir/afile.txt').rename.basename = 'bfile'    # adir/afile.txt => adir/bfile.txt
rio('adir/afile.txt').rename.extname  = '.rb'      # adir/afile.txt => adir/afile.rb
rio('adir/afile.txt').rename.dirname =  'b/c'      # adir/afile.txt => b/c/afile.txt

See #basename, #rename



232
 
# File 'lib/rio/if/path.rb', line 232

def basename=(arg) target.basename = arg end

#cleanpath(consider_symlink = false) ⇒ Object

Calls Pathname#cleanpath

Returns a new Rio whose path is the 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.



433
 
# File 'lib/rio/if/path.rb', line 433

def cleanpath(consider_symlink=false) target.cleanpath(consider_symlink)  end

#dirname(*args) ⇒ Object

Calls File#dirname

Returns a new Rio referencing the directory portion of a Rio.

rio('/tmp/zippy.txt').dirname   #=> rio('/tmp')



188
 
# File 'lib/rio/if/path.rb', line 188

def dirname(*args) target.dirname(*args) end

#dirname=(arg) ⇒ Object

Replace the part of the path returned by #dirname. If in rename mode, also renames the referenced filesystem object.

Returns the new value of dirname

ario = rio('dirA/dirB/afile.rb')
ario.dirname = 'dirC'          # rio('dirC/afile.rb')
ario.basename = 'bfile'        # rio('dirC/bfile.rb')
ario.extname = '.txt'          # rio('dirC/bfile.txt')
ario.filename = 'cfile.rb'     # rio('dirC/cfile.rb')

rio('adir/afile.txt').rename.filename = 'bfile.rb' # adir/afile.txt => adir/bfile.rb
rio('adir/afile.txt').rename.basename = 'bfile'    # adir/afile.txt => adir/bfile.txt
rio('adir/afile.txt').rename.extname  = '.rb'      # adir/afile.txt => adir/afile.rb
rio('adir/afile.txt').rename.dirname =  'b/c'      # adir/afile.txt => b/c/afile.txt

See #dirname, #rename



253
 
# File 'lib/rio/if/path.rb', line 253

def dirname=(arg) target.dirname  = arg end

#expand_path(*args) ⇒ Object

Calls File#expand_path

Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory of the process unless dir_string is given, in which case it will be used as the starting point. The given pathname may start with a “~��, which expands to the process owner�s home directory (the environment variable HOME must be set correctly). “~user�� expands to the named user�s home directory.

Returns a Rio representing the returned path



78
 
# File 'lib/rio/if/path.rb', line 78

def expand_path(*args) target.expand_path(*args) end

#ext(arg = nil) ⇒ Object

Sets the string that the Rio considers an extension. The value will be used by subsequent calls to #basename. If called with no arguments resets its value to the value returned by File#extname. Returns the Rio.

ario = rio('afile.tar.gz')
ario.ext?                        #=> '.gz'
ario.basename                    #=> rio('afile.tar')
ario.ext('.tar.gz').basename     #=> rio('afile')
ario.ext?                        #=> '.tar.gz'

ario = rio('afile.txt')
ario.ext('.txt').basename        #=> rio('afile')
ario.ext('.zip').basename        #=> rio('afile.txt')
ario.ext.basename                #=> rio('afile')
ario.ext('').basename            #=> rio('afile.txt')

See also #ext?,#noext,#basename,



124
 
# File 'lib/rio/if/path.rb', line 124

def ext(arg=nil) target.ext(arg); self end

#ext? ⇒ Boolean

Returns the value of the Rio’s ‘ext’ variable This defaults to the value returned by #extname and may be set by either calling #ext or by passing an argument #basename See also #basename, #ext, #extname, #noext

ario = rio('afile.txt')
ario.ext?                        #=> '.txt'
ario.ext('.txt').basename        #=> rio('afile')
ario.ext?                        #=> '.txt'
ario.ext('.zip').basename        #=> rio('afile.txt')
ario.ext?                        #=> '.zip'
ario.basename('.tar')            #=> rio('afile.txt')
ario.ext?                        #=> '.tar'
ario.ext.basename                #=> rio('afile')
ario.ext?                        #=> '.txt'
ario.noext.basename              #=> rio('afile.txt')
ario.ext?                        #=> ''

Returns:

  • (Boolean) 


155
 
# File 'lib/rio/if/path.rb', line 155

def ext?() target.ext?() end

#extname(*args) ⇒ Object

Calls File#extname

Returns a String containing the path’s extension

rio('/tmp/zippy.txt').extname   #=> '.txt'



163
 
# File 'lib/rio/if/path.rb', line 163

def extname(*args) target.extname(*args) end

#extname=(arg) ⇒ Object

Replace the part of the path returned by #extname. If in rename mode, also renames the referenced filesystem object.

Returns the extension

ario = rio('dirA/dirB/afile.rb')
ario.extname = '.txt'          # rio('dirC/bfile.txt')

rio('adir/afile.txt').rename.extname  = '.rb'      # adir/afile.txt => adir/afile.rb

See aslo #extname, #rename



211
 
# File 'lib/rio/if/path.rb', line 211

def extname=(arg) target.extname = arg end

#filename ⇒ Object

Returns a new Rio with all path information stripped away. This is similar to #basename, except that it always includes an extension if one exists

rio('apath/afile.txt').filename #=> rio('afile.txt')



196
 
# File 'lib/rio/if/path.rb', line 196

def filename() target.filename() end

#filename=(arg) ⇒ Object

Replace the part of the path returned by #filename. If in rename mode, also renames the referenced filesystem object.

Returns the new value of filename

ario = rio('dirA/dirB/afile.rb')
ario.dirname = 'dirC'          # rio('dirC/afile.rb')
ario.basename = 'bfile'        # rio('dirC/bfile.rb')
ario.extname = '.txt'          # rio('dirC/bfile.txt')
ario.filename = 'cfile.rb'     # rio('dirC/cfile.rb')

rio('adir/afile.txt').rename.filename = 'bfile.rb' # adir/afile.txt => adir/bfile.rb
rio('adir/afile.txt').rename.basename = 'bfile'    # adir/afile.txt => adir/bfile.txt
rio('adir/afile.txt').rename.extname  = '.rb'      # adir/afile.txt => adir/afile.rb
rio('adir/afile.txt').rename.dirname =  'b/c'      # adir/afile.txt => b/c/afile.txt

See #filename, #rename



275
 
# File 'lib/rio/if/path.rb', line 275

def filename=(arg) target.filename = arg end

#fspath ⇒ Object

Returns the path for the Rio on the underlying file system Returns nil if the Rio is not on the filesystem (i.e. stdin: or http: Rios)



59
 
# File 'lib/rio/if/path.rb', line 59

def fspath() target.fspath() end

#host(*args) ⇒ Object

Calls URI#host for Rios which have a URI. Otherwise raises NoMethodError.

rio('http://ruby-doc.org/').host #=> 'ruby-doc'



385
 
# File 'lib/rio/if/path.rb', line 385

def host(*args) target.host(*args) end

#join(*args) ⇒ Object

Creates new Rio by adding args as additional directory components like File#join.

ario = rio('adir')
brio = rio('b')
crio = ario.join(brio)    #=> rio('adir/b')

ario = rio('adir')
ario.join('b','c','d')    #=> rio('ario/b/c/d')

See also IF::Path#/



288
 
# File 'lib/rio/if/path.rb', line 288

def join(*args) target.join(*args) end

#join!(*args) ⇒ Object

Changes a Rio inplace by adding args as additional directory components like #join,



345
 
# File 'lib/rio/if/path.rb', line 345

def join!(*args) target.join!(*args); self end

#merge(other) ⇒ Object

Calls URI#merge

Merges two Rios. URI#merge does not document exactly what merging two URIs means. This appears to join the paths like other + path. See URI#merge for less information.



405
 
# File 'lib/rio/if/path.rb', line 405

def merge(other) target.merge(other)  end

#noext ⇒ Object

Identical to #ext(”)

ario.basename                  #=> rio('afile')
ario.noext.basename            #=> rio('afile.txt')

See also #ext



134
 
# File 'lib/rio/if/path.rb', line 134

def noext() target.noext(); self end

#opaque(*args) ⇒ Object

Calls URI#opaque for Rios which have URI representations. The opaque portion of a URI is the portion after the colon and before the question-mark beginning the query.

rio('http://example.org/do.cgi?n=1').opaque  #=> '//example.org/do.cgi'

For Rios that do not have URL representations, returns the same part of Rio’s internal psuedo-URL



395
 
# File 'lib/rio/if/path.rb', line 395

def opaque(*args) target.opaque(*args) end

#path(*args) ⇒ Object

Returns the path for the Rio, which is defined differently for different types of Rios.

For Rios representing paths on the underlying file system this is an alias #fspath. For Rios with paths that are not on the file system this is an alias for #urlpath.

Otherwise this returns nil.



38
 
# File 'lib/rio/if/path.rb', line 38

def path(*args) target.path(*args) end

#realpath ⇒ Object

Calls Pathname#realpath

Returns a new Rio whose path is the real (absolute) pathname of self in the actual filesystem. The real pathname doesn’t contain symlinks or useless dots.



441
 
# File 'lib/rio/if/path.rb', line 441

def realpath() target.realpath()  end

#rel(other = nil) ⇒ Object

Returns a new rio with a path equal to the relative path from other

rio('/tmp/afile').rel('/tmp')   #=> rio('afile')
rio('zippy/afile').rel('zippy') #=> rio('afile')



92
 
# File 'lib/rio/if/path.rb', line 92

def rel(other=nil) target.rel(other)  end

#rootpath(*args) ⇒ Object

#rootpath



350
351
352
 
# File 'lib/rio/if/path.rb', line 350

def rootpath(*args) # :nodoc:
  target.rootpath(*args) 
end

#route_from(other) ⇒ Object

Calls URI#route_from

Returns a new rio representing the path to this Rio from the perspective of other. URI#route_from requires that absolute URIs be used. #route_from does not.



413
 
# File 'lib/rio/if/path.rb', line 413

def route_from(other) target.route_from(other)  end

#route_to(other) ⇒ Object

Calls URI#route_to

Returns a new rio representing the path to other from the perspective of this Rio. URI#route_to requires that absolute URIs be used. #route_to does not.



420
 
# File 'lib/rio/if/path.rb', line 420

def route_to(other) target.route_to(other)  end

#scheme(*args) ⇒ Object

Returns the scheme for the Rio’s URI-like URI#scheme where the Rio is represented by a standard URI. For Rios that are not represented by standard URIs one of Rio’s non-standard schemes is returned.

rio('http://ruby-doc.org/').scheme #=> 'http'



379
 
# File 'lib/rio/if/path.rb', line 379

def scheme(*args) target.scheme(*args) end

#splitpath ⇒ Object

Returns an array of Rios, one for each path element. (Note that this behavior differs from File#split.)

rio('a/b/c').split   #=> [rio('a'),rio('b'),rio('c')]

The array returned is extended with a to_rio method, which will put the parts back together again.

ary = rio('a/b/c').split   #=> [rio('a'),rio('b'),rio('c')]
ary.to_rio           #=> rio('a/b/c')

ary = rio('a/b/c').split   #=> [rio('a'),rio('b'),rio('c')]
ary[1] = rio('d')
ary.to_rio           #=> rio('a/d/c')

See also #join, IF::Path#/



308
 
# File 'lib/rio/if/path.rb', line 308

def splitpath() target.splitpath() end

#to_uri ⇒ Object

For resources that have a URL (RFC1738) representation, this returns a URI object referencing it. Otherwise this raises NoMethodError.

rio('http://rubyforge.org/').to_uri     #=> <URI::HTTP:0x818bd84 URL:http://rubyforge.org/>
rio('adir/afile').to_uri                #=> <URI::Generic:0x817d288 URL:adir/afile>



55
 
# File 'lib/rio/if/path.rb', line 55

def to_uri() target.to_uri end

#to_url ⇒ Object

For resources that have a absolute URL (RFC1738) representation, this returns a string containing that representation. For objects that do not this returns a RIORL (a descriptive pseudo-URL).

rio('/var/www/')                  #=> "file:///var/www/"
rio('http://rio.rubyforge.org/')  #=> "http://rio.rubyforge.org"



47
 
# File 'lib/rio/if/path.rb', line 47

def to_url() target.to_url end

#urlpath ⇒ Object

Returns the path portion of the URL representation of the rio Returns nil if the Rio URL has no path (i.e. stdin: or http: Rios)



63
 
# File 'lib/rio/if/path.rb', line 63

def urlpath() target.urlpath() end