"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Object subclass:#Filename

	 instanceVariableNames:'nameString'

	 classVariableNames:'NextTempFilenameIndex'

	 poolDictionaries:''

	 category:'System-Support'!

Filename comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

	     All Rights Reserved

$Header: /cvs/stx/stx/libbasic/Filename.st,v 1.21 1995-02-22 01:13:28 claus Exp $

'!

!Filename class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

version

"

$Header: /cvs/stx/stx/libbasic/Filename.st,v 1.21 1995-02-22 01:13:28 claus Exp $

"

!

documentation

"

    Filenames; originally added for ST-80 compatibility, is

    taking over functionality from other classes (FileDirectory).

    Instances of Filename do not nescessarily represent valid or existing

    files - i.e. it is possible (and useful) to have instances for non-existing

    files around. In other words: the name-string is not checked automatically

    for being correct or existing.

    Thus, it is possible to do queries such as:

	'/fee/foo/foe' asFilename exists     

	'/not_existing' asFilename isDirectory 

	'/foo/bar' asFilename isReadable 

    (all of the above examples will probably return false on your machine ;-).

    examples:

	'Makefile' asFilename readStream

	'newFile' asFilename writeStream

	Filename newTemporary writeStream

"

! !

!Filename class methodsFor:'instance creation'!

named:aString

    "return a filename for a directory named aString."

    ^ (self basicNew) setName:aString

    "

     Filename named:'/tmp/fooBar'

    "

!

currentDirectory

    "return a filename for the current directory"

    ^ self named:(FileDirectory currentDirectory pathName)

    "

     Filename currentDirectory 

    "

!

newTemporary

    "return a new unique filename - use this for temporary files"

    |pid nm|

    NextTempFilenameIndex isNil ifTrue:[

	NextTempFilenameIndex := 1.

    ].

    "

     the following has to be made OS independent ...

    "

    pid := OperatingSystem getProcessId printString.

    nm := '/tmp/stxtmp_' , pid , '_' , NextTempFilenameIndex printString.

    NextTempFilenameIndex := NextTempFilenameIndex + 1.

    ^ self named:nm

    "

     Filename newTemporary

     Filename newTemporary

    "

!

fromUser

    "show a box to enter a filename. Return a filename instance or

     nil (if cancel was pressed)."

    |name|

    name := FileSelectionBox requestFilename.

    name notNil ifTrue:[^ self named:name].

    ^ nil

    "

     Filename fromUser

    "

! !

!Filename class methodsFor:'queries'!

separator

    "return the file/directory separator.

     Usually, this is $/ for unix-like systems 

     and $\ for dos-like ones (there may be more in the future)."

     ^ OperatingSystem fileSeparator

     "

      Filename separator  

     "

!

parentDirectoryName 

    "return the name used for the parent directory.

     This is '..' for unix and dos-like systems. 

     (there may be more in the future."

     ^ OperatingSystem parentDirectoryName

     "

      Filename parentDirectoryName  

     "

!

isCaseSensitive

    "return true, if filenames are case sensitive.

     We ask the OS about this, to be independent here."

    ^ OperatingSystem caseSensitiveFilenames

! !

!Filename methodsFor:'instance creation'!

constructString:subname

    "taking the receiver as a directory name, construct a new

     filenames string for an entry within this directory (i.e. for a file

     or a subdirectory in that directory)."

    |sepString|

    sepString := self class separator asString.

    nameString = sepString ifTrue:[

	"I am the root"

	^ sepString  , subname

    ].

    ^ nameString , sepString , subname

    "

     '/tmp' asFilename constructString:'foo'   

     '/' asFilename constructString:'foo'         

     '/usr/tmp' asFilename constructString:'foo'

    "

!

construct:subname

    "taking the receiver as a directory name, construct a new

     filename for an entry within this directory (i.e. for a file

     or a subdirectory in that directory)."

    ^ (self constructString:subname) asFilename

    "

     '/tmp' asFilename construct:'foo'    

     '/' asFilename construct:'foo'         

     '/usr/tmp' asFilename construct:'foo'

    "

! !

!Filename methodsFor:'misc'!

, aString

    "this allows filenames to understand how names are concatenated.

     Returns a new filename consisting of the receivers name, concatenated

     by aString. Notice this is NOT the same as construct:, which inserts

     a directory delimiter."

    ^ (nameString , aString asString) asFilename

    "

     'Makefile' asFilename , '.bak' 

     'Makefile' asFilename construct:'.bak' 

    "

! !

!Filename methodsFor:'comparing'!

hash

    "return an integer useful as a hash-key"

    ^ nameString hash

!

= aFilename

    "return true, if the argument represents the same filename"

    |str|

    self species == aFilename species ifTrue:[

	str := aFilename asString.

	self class isCaseSensitive ifTrue:[

	    ^ nameString = str

	].

	^ nameString sameAs:str

    ].

    ^ false

! !

!Filename methodsFor:'converting'!

asString

    "return the receiver converted to a string"

    ^ nameString

!

asFilename

    "return the receiver converted to a filename."

    "Thats pretty easy here :-)"

    ^ self

!

makeLegalFilename 

    "convert the receveivers name to be a legal filename.

     The implementation may change in the future to be more

     OS specific."

    "

     actually, in Unix spaces are allowed - but it makes life

     so hard; therefore, replace them by underscores ...

    "

    nameString replaceAll:(Character space) by:$_.

    "

     need more - especially on SYS5.3 type systems, 

     we may want to contract the fileName to 14 characters.

    "

    ^ self

    "

     'hello world' asFilename makeLegalFilename 

    "

! !

!Filename methodsFor:'private accessing'!

setName:aString

    "set the filename"

    nameString := aString

! !

!Filename methodsFor:'queries'!

separator

    "return the directory-separator character (or string)"

    ^ self class separator

!

directory

    "return the directory name part of the file/directory.

     - thats the name of the directory where the file/dir represented by

       the receiver is contained in.

     This method used to be called 'directoryName' but has been renamed

     for ST-80 compatibility."

    ^ OperatingSystem directoryNameOf:(self pathName)

    "

     '/foo/bar' asFilename directory

     '.' asFilename directory        

     '..' asFilename directory       

     '../..' asFilename directory     

    "

!

tail

    "the files name without directory prefix. For ST-80 compatiblity."

    ^ self baseName

!

baseName

    "return my baseName

     - thats the file/directory name without leading parent-dirs."

    ^ OperatingSystem baseNameOf:(self pathName) 

    "

     '/foo/bar' asFilename baseName  

     '.' asFilename baseName          

     '..' asFilename baseName         

     '../..' asFilename baseName       

    "

!

pathName

    "return the full pathname of the file represented by the receiver."

    |parentName sep|

    sep := self class separator.

    (nameString startsWith:sep) ifTrue:[

	parentName := self class parentDirectoryName.

	(nameString endsWith:parentName) ifFalse:[

	    (nameString endsWith:parentName , sep asString) ifFalse:[

		^ nameString

	    ]

	]

    ].

    ^ (FileDirectory directoryNamed:nameString) pathName

    "

     '/foo/bar' asFilename pathName

     '.' asFilename pathName 

     '../..' asFilename pathName 

    "

!

isAbsolute

    "return true, if the receiver represents an absolute pathname

     (in contrast to one relative to the current directory)."

    ^ (nameString startsWith:self class separator)

    "

     '/foo/bar' asFilename isAbsolute   

     '..' asFilename isAbsolute         

     'source/SBrowser.st' asFilename isAbsolute  

    "

!

isRelative

    "return true, if this name is interpreted relative to some

     directory (opposite of absolute)"

    ^ self isAbsolute not

!

isDirectory

    "return true, if the receiver represents an existing,

     readable directories pathname."

    ^ OperatingSystem isDirectory:nameString

    "

     '/foo/bar' asFilename isDirectory

     '/tmp' asFilename isDirectory

     'Makefile' asFilename isDirectory   

    "

!

exists

    "return true, if such a file exists."

    ^ OperatingSystem isValidPath:nameString

    "

     '/foo/bar' asFilename exists 

     '/tmp' asFilename exists  

     'Makefile' asFilename exists   

    "

!

isReadable

    "return true, if such a file exists and is readable."

    ^ OperatingSystem isReadable:nameString

    "

     '/foo/bar' asFilename isReadable   

     '/tmp' asFilename isReadable      

     'Makefile' asFilename isReadable   

    "

!

canBeWritten

    "same as isWritable - for ST-80 compatibility"

    ^ self isWritable

!

isWritable

    "return true, if such a file exists and is writable."

    ^ OperatingSystem isWritable:nameString

    "

     '/foo/bar' asFilename isWritable 

     '/tmp' asFilename isWritable   

     'Makefile' asFilename isWritable   

    "

!

isExecutable

    "return true, if such a file exists and is executable (by Unix's definition).

     For directories, true is returned if the directory can be entered.

     See isExecutableProgram for a related check."

    ^ OperatingSystem isExecutable:nameString

    "

     '/foo/bar' asFilename isExecutable 

     '/tmp' asFilename isExecutable   

     'Makefile' asFilename isExecutable   

     '/bin/ls' asFilename isExecutable   

    "

!

isExecutableProgram

    "return true, if such a file exists and is an executable program.

     (i.e. for directories, false is returned.)"

    ^ (OperatingSystem isExecutable:nameString)

      and:[(OperatingSystem isDirectory:nameString) not]

    "

     '/tmp' asFilename isExecutable         

     '/bin/ls' asFilename isExecutable       

     '/tmp' asFilename isExecutableProgram   

     '/bin/ls' asFilename isExecutableProgram    

    "

!

filenameCompletion

    "try to complete the filename. This method has both a side effect,

     and a return value:

	 it returns a collection of matching filename strings,

	 and sets (as side effect) the receivers filename to the longest common

	 match. 

     (i.e. if the size of the returned collection is exactly 1,

      the completion has succeeded and the receivers name has been changed to

      that. 

      If the returned collection is empty, nothing matched.

      If the size of the returned collection is greater than one, the receivers

      filename-string has been set to the longest common filename-prefix)"

    |dir name matching matchLen try allMatching sep parent|

    sep := self class separator asString.

    parent := self class parentDirectoryName.

    dir := self directory.

    (nameString endsWith:sep) ifTrue:[

	name := ''

    ] ifFalse:[

	name := self baseName.

    ].

    name = parent ifTrue:[^ dir asFilename filenameCompletion].

    matching := OrderedCollection new.

    (FileDirectory directoryNamed:dir) do:[:fileName |

	((fileName ~= '.') and:[fileName ~= parent]) ifTrue:[