"

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

"

!

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

    Beside lots of protocol to query for a files attributes, the class

    protocol offers methods for filename completion, to construct pathes

    (in an OS-independent way) and to create temporary files.

    Especially the path-construction methods (i.e. #construct:) is highly

    recommended in order to avoid having OS details (like directory separators

    being slash or backslash) spreaded in your application.

    [author:]

        Claus Gittinger

    [see also:]

        String

        FileStream DirectoryStream PipeStream Socket

        OperatingSystem

        Date Time

"

!

examples

"

    does a file/directory exist ?:

        |f|

        f := 'foobar' asFilename.

        ^ f exists  

    is it a directory ?:

        |f|

        f := '/tmp' asFilename.

        ^ f isDirectory.   

    get the working directory:

        ^ Filename defaultDirectory

    get a files full pathname 

    (caring for relative names or symbolic links):

        |f|

        f := '..' asFilename.

        ^ f pathName  

    get a directories directory:

        |f|

        f := Filename defaultDirectory.

        ^ f directory 

    get a files directory:

        |f|

        f := './smalltalk' asFilename.

        ^ f directory 

    getting access & modification times:

        |f|

        f := '/tmp' asFilename.

        ^ f dates

    access time only:

        |f|

        f := '/tmp' asFilename.

        ^ f dates at:#accessed  

    getting all information on a file/directory:

        |f|

        f := '/tmp' asFilename.

        ^ f info

    getting a temporary file (unique name):

        |f|

        f := Filename newTemporary.

        ^ f    

    creating, writing, reading and removing a temporary file:

                                                                        [exBegin]

        |f writeStream readStream|

        f := Filename newTemporary.

        writeStream := f writeStream.

        writeStream nextPutAll:'hello world'.

        writeStream cr.

        writeStream close.

        'contents (as seen by unix''s cat command:' printNL.

        OperatingSystem executeCommand:('cat ' , f pathName).

        readStream := f readStream.

        Transcript showCR:'contents as seen by smalltalk:'.

        Transcript showCR:(readStream upToEnd).

        readStream close.

        f delete.

                                                                        [exEnd]

    getting a directories contents:

                                                                        [exBegin]

        |f files|

        f := '.' asFilename.

        files := f directoryContents.

        Transcript showCR:'the files are:'.

        Transcript showCR:(files printString).

                                                                        [exEnd]

    editing a file:

                                                                        [exBegin]

        |f|

        f := '/tmp/fooBar' asFilename.

        (f writeStream) nextPutAll:'hello world'; close.

        f edit

                                                                        [exEnd]

"

! !

!Filename  class methodsFor:'instance creation'!

currentDirectory

    "return a filename for the current directory"

    ^ self named:(FileDirectory currentDirectory pathName)

    "

     Filename currentDirectory 

    "

!

defaultDirectory

    "ST80 compatibility: same as currentDirectory"

    ^ self currentDirectory

    "

     Filename defaultDirectory 

    "

!

defaultDirectoryName

    "ST80 compatibility: return the defaultDirectories name (as a string)"

    ^ self defaultDirectory name

    "

     Filename defaultDirectoryName 

    "

!

fromComponents:aCollectionOfDirectoryNames

    "create & return a new filename from components given in

     aCollectionOfDirectoryNames. If the first component is the name of the

     root directory (i.e. '/') an absolute path-filename is returned."

    |sep s|

    sep := self separator asString.

    s := ''.

    aCollectionOfDirectoryNames keysAndValuesDo:[:index :component |

	index == 1 ifTrue:[

	    (component ~= sep 

	    or:[aCollectionOfDirectoryNames size == 1]) ifTrue:[

		s := s , component

	    ]

	] ifFalse:[

	    s := s , '/' , component

	].

    ].

    ^ self named:s

    "

     Filename fromComponents:#('/' 'foo' 'bar' 'baz')  

     Filename fromComponents:#('foo' 'bar' 'baz')  

     Filename fromComponents:#('/')  

     Filename fromComponents:

	 (Filename components:('.' asFilename pathName))

     Filename fromComponents:

	 (Filename components:('.' asFilename name)) 

    "

    "Modified: 29.2.1996 / 20:18:34 / cg"

!

fromUser

    "show a box to enter a filename. 

     Return a filename instance or nil (if cancel was pressed)."

    |name|

    name := Dialog requestFileName:'filename:' ifFail:nil.

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

    ^ nil

    "

     Filename fromUser

    "

    "Modified: 19.4.1996 / 13:57:44 / cg"

!

homeDirectory

    "return your homeDirectory.

     Some OperatingSystems do not support this - on those, the defaultDirectory

     (which is the currentDirectory) is returned."

    |s|

    s := OperatingSystem getHomeDirectory.

    s isNil ifTrue:[

	^ self defaultDirectory

    ].

    ^ s asFilename

    "

     Filename homeDirectory        

    "

    "Modified: 29.2.1996 / 21:00:31 / cg"

!

named:aString

    "return a filename for a directory named aString.

     This is the same as 'aString asFilename'."

    ^ (self basicNew) setName:aString

    "

     Filename named:'/tmp/fooBar'

    "

!

newTemporary

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

     The filenames returned are '/tmp/stxtmp_xx_nn' where xx is our

     unix process id, and nn is a unique number, incremented with every

     call to this method.

     If any of the environment variables ST_TMPDIR or TMPDIR is set, 

     its value defines the temp directory."

    ^ self newTemporaryIn:self tempDirectory pathName

    "

     Filename newTemporary    

     Filename newTemporary     

    "

    "Modified: 7.9.1995 / 10:48:31 / claus"

    "Modified: 7.3.1996 / 14:51:33 / cg"

!

newTemporaryIn:aDirectoryPrefix

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

     The filenames returned are in aDirectoryPrefix and named 'stxtmp_xx_nn',

     where xx is our unix process id, and nn is a unique number, incremented 

     with every call to this method.

     Notice: only a filename object is created and returned - no physical

     file is created by this method (i.e. you have to send #writeStream or

     whatever to it in order to really create something).

     See also: #newTemporary which looks for a good temp directory."

    |pid nm|

    NextTempFilenameIndex isNil ifTrue:[

	NextTempFilenameIndex := 1.

    ].

    "

     the following has to be made OS independent ...

    "

    pid := OperatingSystem getProcessId printString.

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

    NextTempFilenameIndex := NextTempFilenameIndex + 1.

    (aDirectoryPrefix isNil or:[aDirectoryPrefix asString isEmpty]) ifFalse:[

	nm := aDirectoryPrefix asFilename construct:nm

    ] ifTrue:[

	nm := nm asFilename

    ].

    ^ nm

    "temp files in '/tmp':

     Filename newTemporary    

    "

    "temp files somewhere 

     (not recommended - use above since it can be controlled via shell variables):

     Filename newTemporaryIn:'/tmp'    

     Filename newTemporaryIn:'/tmp'  

     Filename newTemporaryIn:'/usr/tmp'    

     Filename newTemporaryIn:'/'  

    "

    "a local temp file:

     Filename newTemporaryIn:''         

     Filename newTemporaryIn:nil         

     Filename newTemporaryIn:'.'         

     Filename newTemporaryIn:('source' asFilename) 

    "

    "Modified: 7.9.1995 / 10:48:31 / claus"

    "Modified: 7.3.1996 / 14:49:56 / cg"

!

tempDirectory

    "return the temp directory as a filename.

     If any of the environment variables ST_TMPDIR or TMPDIR is set, 

     its value defines the name, otherwise, '/tmp' is used.

     (at least on unix ...).

     Notice: do not hardcode '/tmp' into your programs - things may be

	     different on other OS's. Also, the user may want to set the

	     TMPDIR environment variable to have her temp files somewhere else.

	     (especially on SUNOS, the root partition is ALWAYS too small ..."

    |tempDir|

    tempDir := OperatingSystem getEnvironment:'ST_TMPDIR'.

    tempDir isNil ifTrue:[

	tempDir := OperatingSystem getEnvironment:'TMPDIR'.

	tempDir isNil ifTrue:[

	    tempDir := '/tmp'

	].

    ].

    ^ self named:tempDir

    "

     Filename tempDirectory           

     Filename tempDirectory pathName   

    "

    "Modified: 7.9.1995 / 10:48:31 / claus"

    "Created: 7.3.1996 / 14:51:18 / cg"

    "Modified: 7.3.1996 / 14:53:10 / cg"

! !

!Filename  class methodsFor:'queries'!

components:aString

    "separate the pathName given by aString into 

     a collection containing the directory components and the files name as

     the final component.

     If the argument names an absolute path, the first component will be the

     name of the root directory (i.e. '/')."

    |components|

    components := aString asCollectionOfSubstringsSeparatedBy:(self separator).

    components first isEmpty ifTrue:[

	components at:1 put:(self separator asString)

    ].

    ^ components

    "

     Filename components:'/foo/bar/baz' 

     Filename components:'foo/bar/baz'  

    "

    "Modified: 29.2.1996 / 20:06:38 / cg"

!

defaultClass

    "ST-80 compatibility:

     in ST-80, different subclasses of Filename are used for different

     OperatingSystems; defaultClass is supposed to return an appropriate class.

     Since in ST/X, there is (currently) only one Filename class, return it here."

    ^ self

!

filenameCompletionFor:aString directory:inDirectory directoriesOnly:directoriesOnly filesOnly:filesOnly ifMultiple:aBlock

    "perform filename completion on aString in some directory;

     return the longest matching filename prefix as a string.

     The boolean directoriesOnly and filesOnly control respectively,

     if only directories or only regular files are to be considered for completion.

     If multiple files match, the exception block aBlock is evaluated with a 

     filename representing the directory (where the match was done) as argument.

     (this may be different from the inDirectory argument, if aString is absolute

      or starts with ../)"

    |s f matchSet nMatch name words dir|

    s := aString.

    "

     find the last word ...

    "

    words := s asCollectionOfWords.

    words size == 0 ifTrue:[

        aBlock value:'.' asFilename.

        ^ ''

    ].

    f := words last asFilename.

    matchSet := f filenameCompletionIn:inDirectory.