"

 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.

"

"{ Package: 'stx:libbasic' }"

Object subclass:#Filename

!

!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:) are highly

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

    being slash or backslash) spreaded in your application.

    Since Filenames have different semantics under different operating systems,

    class methods are delegated to concrete implementations in various subclasses like

    UnixFilename, PCFilename, ...

    The delegation is implemented in a way, so that some methods of

    specific OS Filenames might be used, even if ST/X is currently running 

    on a different OS (as long as the method does not depend on the OperatingSystem class).

    [author:]

        Claus Gittinger

    [see also:]

        String

        FileStream DirectoryStream PipeStream Socket

        OperatingSystem

        Date Time

"

!

examples

"

    does a file/directory exist ?:

                                                                        [exBegin]

        |f|

        f := 'foobar' asFilename.

        ^ f exists  

                                                                        [exEnd]

    is it a directory ?:

                                                                        [exBegin]

        |f|

        f := '/tmp' asFilename.

        ^ f isDirectory.   

                                                                        [exEnd]

    get the working directory:

                                                                        [exBegin]

        ^ Filename defaultDirectory

                                                                        [exEnd]

    get a files full pathname 

    (caring for relative names or symbolic links):

                                                                        [exBegin]

        |f|

        f := '..' asFilename.

        ^ f pathName  

                                                                        [exEnd]

    get a directories directory:

                                                                        [exBegin]

        |f|

        f := Filename defaultDirectory.

        ^ f directory 

                                                                        [exEnd]

    get a files directory:

                                                                        [exBegin]

        |f|

        f := './smalltalk' asFilename.

        ^ f directory 

                                                                        [exEnd]

    getting access & modification times:

                                                                        [exBegin]

        |f|

        f := '/tmp' asFilename.

        ^ f dates

                                                                        [exEnd]

    access time only:

                                                                        [exBegin]

        |f|

        f := '/tmp' asFilename.

        ^ f dates at:#accessed  

                                                                        [exEnd]

    getting all information on a file/directory:

                                                                        [exBegin]

        |f|

        f := '/tmp' asFilename.

        ^ f info

                                                                        [exEnd]

    getting a temporary file (unique name):

                                                                        [exBegin]

        |f|

        f := Filename newTemporary.

        ^ f    

                                                                        [exEnd]

    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 := Filename currentDirectory.

        files := f directoryContents.

        Transcript showCR:'the files are:'.

        Transcript showCR:(files printString).

                                                                        [exEnd]

    editing a file:

                                                                        [exBegin]

        |f|

        f := Filename newTemporary.

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

        f edit

                                                                        [exEnd]

"

! !

!Filename class methodsFor:'initialization'!

initialize

    "initialize for the OS we are running on"

    ConcreteClass isNil ifTrue:[

        self initializeConcreteClass

    ].

    "

     self initialize

    "

    "Created: 7.9.1997 / 23:32:55 / cg"

!

initializeConcreteClass

    "initialize for the OS we are running on"

    OperatingSystem isUNIXlike ifTrue:[

        ConcreteClass := UnixFilename

    ] ifFalse:[OperatingSystem isMSDOSlike ifTrue:[

        ConcreteClass := PCFilename

    ] ifFalse:[OperatingSystem isVMSlike ifTrue:[

        ConcreteClass := OpenVMSFilename

    ] ifFalse:[

        self error:'Filename: unknown OperatingSystem when initializing concrete Filename class'.

    ]]].

    ConcreteClass isNil ifTrue:[

        self error:'Filename: Missing concrete Filename class'.

    ].

    "

     self initializeConcreteClass

    "

    "Modified: 7.9.1997 / 23:32:37 / cg"

!

reinitialize

    "initialize for the OS we are running on (after a restart)"

    "

     self reinitialize

    "

! !

!Filename class methodsFor:'instance creation'!

currentDirectory

    "return a filename for the current directory"

    self == Filename ifTrue:[

        ^ ConcreteClass currentDirectory

    ].

    "/ fallBack - works on Unix & MSDOS (but not on VMS)

    ^ self named:'.'

    "/ ^ self named:('.' asFilename pathName)

    "

     Filename currentDirectory 

    "

    "Modified: 8.9.1997 / 00:24:15 / cg"

!

currentDirectoryName

    "return a filename for the current directory"

    self == Filename ifTrue:[

        ^ ConcreteClass currentDirectoryName

    ].

    "/ fallBack - works on Unix & MSDOS (but not on VMS)

    ^ '.'

    "

     Filename currentDirectoryName    

    "

    "Modified: / 8.9.1997 / 00:24:15 / cg"

    "Created: / 21.10.1998 / 17:49:57 / cg"

!

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 

    "

!

findDefaultDirectory

    "same as #defaultDirectory for ST80 compatibility"

    ^ self defaultDirectory

    "Created: 20.6.1997 / 17:00:29 / cg"

!

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

    self == Filename ifTrue:[

        ^ ConcreteClass fromComponents:aCollectionOfDirectoryNames

    ].

    ^ self named:(self nameFromComponents:aCollectionOfDirectoryNames)

    "

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

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

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

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

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

     Filename fromComponents:#('/')  

     Filename fromComponents:

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

     Filename fromComponents:

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

    "

    "Modified: 8.9.1997 / 00:23:16 / cg"

!

fromUser

    "show a box to enter a filename. 

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

    |name|

    name := Dialog 

        requestFileName:'filename:' 

        default:nil

        fromDirectory:(FileSelectionBox lastFileSelectionDirectory).

    name notEmptyOrNil 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

    ].

    ^ self named:s

    "

     Filename homeDirectory        

    "

    "Modified: 8.9.1997 / 00:25:23 / cg"

!

named:aString

    "return a filename for a directory named aString.

     This is the same as 'aString asFilename'."

    self == Filename ifTrue:[

        ^ ConcreteClass named:aString

    ].

    ^ self basicNew setName:aString

    "

     Filename named:'/tmp/fooBar'

    "

    "Modified: 7.9.1997 / 23:30:06 / cg"

!

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.

     Notice, that no file is created by this - only a unique name

     is generated."

    ^ self newTemporaryIn:self tempDirectory

    "

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

    ^ self newTemporaryIn:aDirectoryPrefix nameTemplate:self tempFileNameTemplate

    "temp files in '/tmp':

     Filename newTemporary    

    "

    "temp files somewhere 

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

     UnixFilename newTemporaryIn:'/tmp'    

     UnixFilename newTemporaryIn:'/tmp'  

     UnixFilename newTemporaryIn:'/usr/tmp'    

     UnixFilename 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: / 11.8.1998 / 22:51:43 / cg"

!