"

 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

	instanceVariableNames:'nameString'

	classVariableNames:'TempDirectory DefaultTempDirectory ConcreteClass'

	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:) 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)"

    TempDirectory := nil.

    self initializeConcreteClass.

    "

     self reinitialize

    "

    "Created: / 07-09-1997 / 23:33:02 / cg"

    "Modified: / 29-08-2006 / 12:40:28 / cg"

! !

!Filename class methodsFor:'instance creation'!

applicationDataDirectoryFor:appName

    "return the directory, where user-and-application-specific private files are to be

     located (ini-files, preferences etc.).

     Under windows, something like 'C:\Users\Administrator\AppData\Roaming\<appName>'

     is returned, under unix, we use ~/.<appName> (but see details in UnixOS).

     If the directory does not exist, it is created"

    |s dir|

    s := OperatingSystem getApplicationDataDirectoryFor:appName.

    s isNil ifTrue:[

        ^ self homeDirectory

    ].

    dir := self named:s.

    dir exists ifFalse:[

        dir makeDirectory

    ].

    ^ dir

    "                    

     Filename applicationDataDirectoryFor:'expecco'        

    "

    "Created: / 29-07-2010 / 12:05:35 / sr"

!

currentDirectory

    "return a filename for the current directory"

    ^ self named:(OperatingSystem getCurrentDirectory).

    "

     Filename currentDirectory 

    "

!

defaultDirectory

    "ST80 compatibility: same as currentDirectory"

    ^ self currentDirectory

    "

     Filename defaultDirectory 

    "

!

defaultTempDirectory

    "return the default temp directory as a filename.

     That is the same as TempDirectory, except that TempDirectory can be changed

     from the outside (via tempDirectory:) whereas this is the OS's original default.

     Use this for files which MUST remain the same (stx_sourceCache)"

    DefaultTempDirectory isNil ifTrue:[

        self tempDirectory.  "/ actually sets DefaultTempDirectory as side effect

        DefaultTempDirectory isNil ifTrue:[

            DefaultTempDirectory := TempDirectory

        ].

    ].

    DefaultTempDirectory exists ifFalse:[

        DefaultTempDirectory

            makeDirectory; 

            addAccessRights:#(readUser readGroup readOthers 

                              writeUser writeGroup writeOthers

                              executeUser executeGroup executeOthers

                              removeOnlyByOwner).

    ].

    ^ DefaultTempDirectory

    "

     Filename tempDirectory           

     Filename defaultTempDirectory           

    "

    "Created: / 07-03-1996 / 14:51:18 / cg"

    "Modified: / 29-08-2006 / 12:57:16 / cg"

!

desktopDirectory

    "return your desktop directory.

     Under windows, thats the real desktop directory; 

     under other OperatingSystems, the home directory is returned."

    |s|

    s := OperatingSystem getDesktopDirectory.

    s isNil ifTrue:[

        ^ self homeDirectory

    ].

    ^ self named:s

    "

     Filename desktopDirectory        

    "

    "Created: / 16-05-2007 / 13:18:34 / cg"

!

documentsDirectory

    "return your documents directory.

     Under windows, thats the real 'Documents' or 'My Documents'; 

     under other OperatingSystems, the home directory is returned."

    |s|

    s := OperatingSystem getDocumentsDirectory.

    s isNil ifTrue:[

        ^ self homeDirectory

    ].

    ^ self named:s

    "

     Filename documentsDirectory        

    "

    "Created: / 16-05-2007 / 13:18:34 / cg"

!

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

    |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 isAbstract ifTrue:[

        ^ ConcreteClass named:aString

    ].

    ^ self basicNew setName:aString

    "

     Filename named:'/tmp/fooBar'

    "