"{ Package: 'stx:libtool2' }"

Object subclass:#Archiver

	instanceVariableNames:'process temporaryDirectory fileName outStream errorStream

		synchron'

	classVariableNames:''

	poolDictionaries:''

	category:'System-Support-FileFormats'

!

Archiver subclass:#GZipArchive

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:Archiver

!

Archiver subclass:#TarArchive

	instanceVariableNames:'fileName'

	classVariableNames:''

	poolDictionaries:''

	privateIn:Archiver

!

Archiver subclass:#TarGZipArchive

	instanceVariableNames:'tarArchiver tarFile'

	classVariableNames:''

	poolDictionaries:''

	privateIn:Archiver

!

!Archiver class methodsFor:'instance creation'!

with:aFilename

    | instance |

    instance := self new.

    instance fileName:aFilename.

    ^ instance

! !

!Archiver class methodsFor:'classAccess'!

gzipArchive

    ^ GZipArchive

!

tarArchive

    ^ TarArchive

!

tarGZipArchive

    ^ TarGZipArchive

! !

!Archiver class methodsFor:'common options'!

MinusSign

    ^ $-

!

PipeSign

    ^ $>

! !

!Archiver methodsFor:'accessing'!

errorStream

    "return the value of the instance variable 'errorStream' (automatically generated)"

    ^ errorStream

!

errorStream:something

    "set the value of the instance variable 'errorStream' (automatically generated)"

    errorStream := something.

!

fileName

    "return the value of the instance variable 'fileName' (automatically generated)"

    ^ fileName

!

fileName:something

    "set the value of the instance variable 'fileName' (automatically generated)"

    fileName := something.

!

outStream

    "return the value of the instance variable 'outStream' (automatically generated)"

    ^ outStream

!

outStream:something

    "set the value of the instance variable 'outStream' (automatically generated)"

    outStream := something.

!

process

    "return the value of the instance variable 'process' (automatically generated)"

    ^ process

!

process:something

    "set the value of the instance variable 'process' (automatically generated)"

    process := something.

!

synchron

    "return the value of the instance variable 'synchron' (automatically generated)"

    ^ synchron

!

synchron:something

    "set the value of the instance variable 'synchron' (automatically generated)"

    synchron := something.

!

temporaryDirectory

    "return the value of the instance variable 'temporaryDirectory' (automatically generated)"

    temporaryDirectory isNil ifTrue:[

        temporaryDirectory := Filename newTemporary.

        temporaryDirectory makeDirectory.

    ].

    ^ temporaryDirectory

! !

!Archiver methodsFor:'actions'!

addFilesToArchiv:colOfFiles

    self subclassResponsibility.

!

extractTo:aColOfFiles

    self subclassResponsibility.

!

listFilesFromArchiv

    self subclassResponsibility.

!

removeFilesFromArchiv:aColOfFiles

    self subclassResponsibility.

! !

!Archiver methodsFor:'actions private'!

removeTemporaryDirectory

    | tmp |

    temporaryDirectory notNil ifTrue:[

        tmp := self temporaryDirectory.

        (FileDirectory directoryNamed:(tmp directory)) removeDirectory:tmp baseName.

        temporaryDirectory := nil.

    ].

!

stopProcess

    process notNil ifTrue:[

        process terminateWithAllSubprocesses.

        process waitUntilTerminated.

    ].

! !

!Archiver methodsFor:'command execution'!

executeCommand:cmd directory:aDirectory

    synchron isNil ifTrue:[synchron := true].

    synchron ifTrue:[

         OperatingSystem 

            executeCommand:cmd

            inputFrom:nil

            outputTo:outStream

            errorTo:errorStream

            inDirectory:aDirectory

            lineWise:true

            onError:[:status| false].

    ] ifFalse:[

        process := Process for:[

                [ 

                     OperatingSystem 

                        executeCommand:cmd

                        inputFrom:nil

                        outputTo:outStream

                        errorTo:errorStream

                        inDirectory:aDirectory

                        lineWise:true

                        onError:[:status| false].

                ] 

                valueNowOrOnUnwindDo:[

                    process := nil.

                ].

        ] priority:(Processor systemBackgroundPriority).

        process name:('ArchivFileCommand command >', cmd).

        process resume.

    ]

!

outStream:aOutStream errorStream:aErrorStream

    outStream := aOutStream.

    errorStream := aErrorStream.

!

outStream:aOutStream errorStream:aErrorStream synchron:aBoolean

    outStream := aOutStream.

    errorStream := aErrorStream.

    synchron := aBoolean

! !

!Archiver methodsFor:'initialization & release'!

release

    self stopProcess.

    self removeTemporaryDirectory.

! !

!Archiver::GZipArchive class methodsFor:'zip archiv command options'!

GZipArchivFileOption

    ^ 'f'

!

GZipArchivUnzipCommand

    ^ 'gunzip'

!

GZipArchivWriteToStdioOption

    ^ 'c'

!

GZipArchivZipCommand

    ^ 'gzip'

! !

!Archiver::GZipArchive methodsFor:'actions'!

unzipTo:aDirectory

    | cmd file newFile|

    (aDirectory exists not) ifTrue:[

        DialogBox warn:'cant unzip to not existing directory ', aDirectory asString.

    ].

    (aDirectory isDirectory not) ifTrue:[

        DialogBox warn:'cant unzip to file ', aDirectory asString.

    ].

    file := self fileName.

    (file directory asString = aDirectory asString) ifFalse:[

        file copyTo:(aDirectory construct:(file baseName)).

    ].

    newFile := aDirectory construct:(file baseName).

    cmd := self getUnzipCommandForFile:newFile.

    self executeCommand:cmd directory:aDirectory. 

!

zipFile:aFile to:newFile

    | cmd directory|

    directory := newFile directory.

    (directory exists not) ifTrue:[

        DialogBox warn:'cant unzip to not existing directory ', directory asString.

    ].

    (directory isDirectory not) ifTrue:[

        DialogBox warn:'cant unzip to file ', directory asString.

    ].

    cmd := self getZipCommandForFile:aFile to:newFile.

    self executeCommand:cmd directory:directory.

    newFile exists ifTrue:[

        self fileName:newFile.

    ].

! !

!Archiver::GZipArchive methodsFor:'command strings'!

getUnzipCommand

    | stream cmd|

    stream := WriteStream on:''.

    stream nextPutAll:self class GZipArchivUnzipCommand.

    stream space.

    stream nextPutAll:self fileName baseName.

    cmd := stream contents.

    stream close.

    ^ cmd

!

getUnzipCommandForFile:aFileName

    | stream cmd|

    stream := WriteStream on:''.

    stream nextPutAll:self class GZipArchivUnzipCommand.

    stream space.

    stream nextPutAll:aFileName asString.

    cmd := stream contents.

    stream close.

    ^ cmd

!

getZipCommandForFile:aFileName

    | stream cmd|

    stream := WriteStream on:''.

    stream nextPutAll:self class GZipArchivZipCommand.

    stream space.

    stream nextPutAll:aFileName asString.

    cmd := stream contents.

    stream close.

    ^ cmd

!

getZipCommandForFile:aFile to:newFile

    | stream cmd|

    stream := WriteStream on:''.

    stream nextPutAll:self class GZipArchivZipCommand.

    stream space.

    stream nextPut:self class MinusSign.

    stream nextPutAll:self class GZipArchivWriteToStdioOption.

    stream space.

    stream nextPutAll:aFile asString.

    stream space.

    stream nextPut:self class PipeSign.

    stream space.

    stream nextPutAll:newFile asString.

    cmd := stream contents.

    stream close.

    ^ cmd

! !

!Archiver::TarArchive class methodsFor:'command strings'!

TarArchivAddOption

    ^ 'r'

!

TarArchivCommand

    ^ 'tar'

!

TarArchivDeleteOption

    ^ '--delete'

!

TarArchivFileOption

    ^ 'f'

!

TarArchivListContentsOption

    ^ 't'

!

TarArchivListOptions

    ^ self TarArchivListContentsOption , self TarArchivVerboseOption 

        , self TarArchivFileOption

!

TarArchivListZippedOptions

    ^ self TarArchivListContentsOption , self TarArchivVerboseOption 

        , self TarArchivFileOption , self TarArchivZipOption

!

TarArchivUnpackInDirectoryOption

    ^ '-C '

!

TarArchivUnpackOption

    ^ 'x'

!

TarArchivVerboseOption

    ^ 'v'

!

TarArchivZipOption

    ^ 'z'

! !

!Archiver::TarArchive methodsFor:'actions'!

addFilesToArchiv:colOfFiles

    | cmd tempDir archivFile archivInTemp|

    tempDir := self temporaryDirectory.

    archivFile := self fileName.

    archivInTemp := tempDir construct:(archivFile baseName).

    "/ copy files to be added to tempDir

    colOfFiles do:[ :file |

        file recursiveCopyTo:(tempDir construct:(file baseName))

    ].

    "/ copy tar archiv to tempDir

    archivFile copyTo:archivInTemp.

    "/ addFiles to the tar archive

    cmd := self getAddFilesToTarArchiveCommandForArchiv:archivInTemp with:colOfFiles.

    self executeCommand:cmd directory:tempDir.

    "/ copy tar archiv back

    archivInTemp copyTo:(self fileName).

!

extractTo:aDirectory 

    ^ self extractTo:aDirectory with:nil

!

extractTo:aDirectory with:files

    |execDir cmd|

    execDir := self fileName directory.

    cmd := self getExtractSelectedFilesCommandForDirectory:aDirectory withSelection:files.

    self executeCommand:cmd directory:execDir.

!

extractWithOutDirectoryTo:aDirectory with:files

    |execDir tempDir tempFile|

    execDir := self fileName directory.

    tempDir := self temporaryDirectory.

    self extractTo:tempDir with:files.

    files do:[ : aFileString |

        tempFile := self temporaryDirectory construct:aFileString.

        tempFile exists ifTrue:[

            tempFile recursiveCopyTo:(aDirectory construct:(aFileString fileName asFilename baseName)).

        ].

    ].

!

listFilesFromArchiv

    self listFilesFromArchiv:nil

!

listFilesFromArchiv:newColOfFiles

    | cmd dir|

    self fileName isNil ifTrue:[ ^ self].

    dir := self fileName directory.

    cmd := self getFileListFromArchivCommand:newColOfFiles.

    self executeCommand:cmd directory:dir 

!

removeFilesFromArchiv:aColOfFiles

    |cmd|

    cmd := self getRemoveFilesFromTarArchivFor:aColOfFiles.

    self executeCommand:cmd directory:(self fileName directory). 

! !

!Archiver::TarArchive methodsFor:'command strings'!

getAddFilesToTarArchiveCommand:aColOfFiles 

    |filename cmd stream|

    filename := self fileName.

    filename exists ifTrue:[

        stream := WriteStream on:''.

        stream nextPutAll:self class TarArchivCommand.

        stream space.

        stream nextPutAll:self class TarArchivAddOption.

        stream nextPutAll:self class TarArchivFileOption.

        stream space.

        stream nextPutAll:filename asString.

        aColOfFiles do:[:el | 

            stream space.

            stream nextPutAll:(el asString)

        ].

        cmd := stream contents

    ].

    ^ cmd

!

getAddFilesToTarArchiveCommandForArchiv:archivFile with:aColOfFiles 

    | cmd stream|

    archivFile exists ifTrue:[

        stream := WriteStream on:''.

        stream nextPutAll:self class TarArchivCommand.

        stream space.

        stream nextPutAll:self class TarArchivAddOption.

        stream nextPutAll:self class TarArchivFileOption.

        stream space.

        stream nextPutAll:archivFile asString.

        aColOfFiles do:[:el | 

            stream space.

            stream nextPutAll:(el baseName)

        ].

        cmd := stream contents

    ].

    ^ cmd

!