"

 COPYRIGHT (c) 1995 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:libbasic3' }"

AbstractSourceCodeManager subclass:#CVSSourceCodeManager

	instanceVariableNames:''

	classVariableNames:'Verbose CVSRoot CVSWorkDirectory RemoteCVS CVSBinDir

		CVSModuleRoots CMD_checkout CVSTempDir DisabledModules

		CVSCommandSemaphore'

	poolDictionaries:''

	category:'System-SourceCodeManagement'

!

!CVSSourceCodeManager class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1995 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

"

    SourceCodeManager which accesses the sourcecode through cvs.

    It requires the shell environment variable CVSROOT to be set

    to the top of the repository tree. (or alternatively, the CVSRoot

    variable being set by a private.rc file).

    Under that top, for each module (especially the stx module itself), 

    a subdirectory containing that modules directories must exist.

    If not specified otherwise, the module defaults to 'stx'. 

    If a class has its home in another module, it has to be compiled

    with a corresponding entry in the package string (see below).

    Within a module, classes are organized in classlibraries, and the corresponding

    source code is found in various subdirectories of CVSROOT. The directories

    name can also be provided by the package string - if not, it defaults to the

    libraries name.

    The package string controls all this, and is REQUIRED in order for the sourceCodeManager

    to be able to retrieve a classes source.

    The package strings format is:

        '...any infotext....(sourceCodeInfo)'

    the sourceCOdeInfo consists of multiple entries, separated by colons.

    The following formats are allowed:

        (libraryName)                   - module defaults to 'stx'; directory to the name of the library

        (foo/bar/x)                     - module defaults to 'stx'; dir is 'foo/bar/x'; library name defaults to x

        (module:directory:libname)      - specifies all components

    The first formats are intermediate, for backward compatibility. We urge everyone

    to use the last format (by changing the Make.proto files and add a -P flag to

    the stc compiler flags (see libbasic/Make.proto as an example).

    Notice, that the sourceCodeManager is (currently) only consulted, if no

    source subdirectory exists, or no source file is found there. If it does exist,

    that one is supposed to contain an up-to-date version of the classes source

    (this is temporary - in the future the probe order will be reversed, trying

     the source repository first).

    The source directory is required for systems which do NO source code control.

    Setup:

        - make certain, that the commands 'cvs' and 'co' are available on your system.

        - add setup for the CVSROOT environment variable to your .bashrc / .login / .profile

        - Make certain that either no local source directory exists, or it is empty or it contains

          only source code for files NOT found in the repository (this will not be required in future versions).

    Caveat:

        currently, the rcs container is accessed directly, since cvs mangles the files ident-string and

        thus does not correctly recreate the original file (all source is offset by some characters w.r.t. the

        compiled file).

        Therefore, sevrer-mode CVS is not supported.

    [class variables:]

        CVSTempDir      <String | nil>  where a directory tree is

                                        generated temporarily for checkin/checkout

                                        (default is nil -> systems tmp-dir)

        CVSRoot         <String>        the CVS root. Imported from the

                                        CVSROOT shell variable.

        RemoteCVS       <Boolean>       if true, remote CVS access is used

                                        (i.e. via a socket to a CVS server).

                                        if false, disk access is used;

                                        files in CVSRoot must be accessable.

        CVSWorkDirectory                not yet supported/implemented.

                                        PLANNED: name of a directory hierarchy,

                                        which is kept in sync with the current

                                        version.

        CVSBinDir                       where the CVS commands are found

        CVSModuleRoots  <Directory>     per-module roots.

                                        If empty, or no entry is found for a

                                        module is found, CVSRoot is used.

                                        Otherwise, specifies a per-module CVSRoot.

                                        (allows multiple CVS hierarchies)

    [author:]

        Claus Gittinger

    [see also:]

        ( cvs manual page :man: cvs )

        ( Coding style used in Smalltalk/X classes :html: programming/codingStyle.html )

    [restrictions:]

        commercial version only

"

!

examples

"

    Default setup:

        This setup accesses all sources from a single repository: /files/CVS.

        Actually, this is the setup as used within eXept for development.

            CVSSourceCodeManager initializeForRepository:'/files/CVS'.

    Dual repository setup:

        This accesses all ST/X standard classes' source from the /files/CVS

        repository, while your private classes are created in and accessed from

        '/files/myCVS'.

        This setup is useful, if you need revision management on the

        ST/X standard classes as well as for your own classes.

        In order to do this, you should (manually) check in all ST/X classes

        into a private repository WHILE preserving the original revision numbers.

        A shell-procedure similar to:

            for i in lib*/*.st

            do

                id=`ident $i`

                set $id

                rev=$3

                ci -r$rev <CVSDIR>/$i $i

            done

        should acomplish this.

        Now, that you have all ST/X files in your own repository (and with the

        original revision numbers), access is possible by defining CVSROOT

        as above. However, in order to have your own files being stored in

        another repository, you have to give a per-module repository.

        This defines the default repository (for your containers):

            CVSSourceCodeManager initializeForRepository:'/files/myCVS'.

        and this specifies a repository for all standard ST/X classes (in the stx module):

            CVSSourceCodeManager repositoryName:'/files/CVS' forModule:'stx'

    Dual repository setup for eXept customers with a full licence

    (these can access our in-house master repository, for convenient software update

     and uploading):

        All class sourcees under the 'stx' module (i.e. packageID is 'stx:*') can be accessed

        from the eXept cvs server (i.e. CVSROOT for them is :pserver:userName@exept.de:/files/CVS/stc).

        All local classes should be maintained in and accessed from a local cvs repository

        such as '/files/myCVS'.

        Then, tell the CVSSourceCodeManager about this;

        first the default repository:

            CVSSourceCodeManager initializeForRepository:'/files/myCVS'.

        and the repository for all standard ST/X classes (in the stx module):

            CVSSourceCodeManager repositoryName:':pserver:userName@exept.de:/files/CVS' forModule:'stx'

"

! !

!CVSSourceCodeManager class methodsFor:'initialization'!

forgetDisabledModules

    DisabledModules := nil.

!

initCommands

    CMD_checkout := 'cvs -n checkout %1'.

!

initialize

    "check if $CVSROOT (the shell variable) or CVSRoot (the smalltalk global)

     is set, check if cvs commands can be executed and install myself as the

     SourceCodeManager if this works out ok"

    | s f top ok triedPath cvsCmd cmdName |

    CVSCommandSemaphore := Semaphore new:10.

    RemoteCVS := true.

    DisabledModules := nil.

    CVSModuleRoots isNil ifTrue:[

        CVSModuleRoots := Dictionary new.

    ].

    "/

    "/ if CVSROOT is non-empty and both cvs and co are available

    "/ as commands, assume this system uses a cvs source code management.

    "/

    CVSRoot ifNil:[

        CVSRoot := OperatingSystem getEnvironment:'CVSROOT'.

        CVSRoot ifNil:[

            "disabled since $CVSROOT is not set"

            ^ self

        ].

    ].

    OperatingSystem isMSDOSlike ifTrue:[

        cvsCmd := 'cvs.exe'

    ] ifFalse:[

        cvsCmd := 'cvs'

    ].

    CVSBinDir size > 0 ifTrue:[

        OperatingSystem isMSDOSlike ifTrue:[

            cmdName := CVSBinDir asFilename constructString:cvsCmd.

            ( OperatingSystem canExecuteCommand:cmdName) ifFalse:[

                CVSBinDir := ''.

            ] ifTrue:[

                CVSBinDir := CVSBinDir asFilename pathName

            ]

        ]

    ].

    CVSBinDir size == 0 ifTrue:[

        CVSBinDir := ''.

        (ok := OperatingSystem canExecuteCommand:cvsCmd) ifFalse:[

            "/ mhmh - no cvs;

            OperatingSystem isUNIXlike ifTrue:[

                triedPath := #( '/usr/local/bin' ).

            ] ifFalse:[

                OperatingSystem isMSDOSlike ifTrue:[

                    triedPath := Array with:'c:\bin'

                                        with:(Filename currentDirectory pathName)

                                        with:(OperatingSystem stxBinDirPath ? 'c:\windows').

                ] ifFalse:[

                    triedPath := #()

                ]

            ].

            triedPath do:[:eachTriedDir |

                ok ifFalse:[

                    (OperatingSystem canExecuteCommand:(eachTriedDir asFilename constructString:cvsCmd)) ifTrue:[

                        ok := true.

                        CVSBinDir := eachTriedDir.

                    ]

                ]

            ].

        ].

    ] ifFalse:[

        ok := OperatingSystem canExecuteCommand:(CVSBinDir asFilename constructString:cvsCmd).

    ].

    ok ifFalse:[

        'CVSSourceCodeManager [warning]: disabled since no >> cvs << command found' infoPrintCR.

        ^ self

    ].

"/    (OperatingSystem canExecuteCommand:(CVSBinDir , 'co')) ifFalse:[

"/        'CVSSourceCodeManager [warning]: limited functionality - no >> co << command found' infoPrintCR.

"/    ].

"/    (OperatingSystem canExecuteCommand:(CVSBinDir , 'rlog')) ifFalse:[

"/        'CVSSourceCodeManager [warning]: limited functionality - no >> rlog << command found' infoPrintCR.

"/    ].

"/    (OperatingSystem canExecuteCommand:(CVSBinDir , 'patch')) ifFalse:[

"/        'CVSSourceCodeManager [warning]: limited functionality - no >> patch << command found' infoPrintCR.

"/    ].

    UseWorkTree := false.

    CacheDirectoryName ifNil:[

        self initCacheDirPath.

    ].

    CachingSources ifNil:[

        CachingSources := true.

    ].

    "/

    "/ check if there is an stx directory there

    "/

    ((f := CVSRoot asFilename) isDirectory 

    and:[(top := f construct:'stx') isDirectory

    and:[top isReadable]]) ifTrue:[

        RemoteCVS := false

    ].

    Smalltalk at:#SourceCodeManager put:self.

    DefaultManager := self.    

    ('CVSSourceCodeManager [info]: repository CVSROOT is ''' , CVSRoot , '''.') infoPrintCR.

    RemoteCVS ifTrue:[

        'CVSSourceCodeManager [info]: assume remote CVS mode (no stx found in CVSROOT)' infoPrintCR.

        ^ self

    ].

    "/

    "/ optionally set the WorkTreeDirectoryName from $STX_WORKTREE;

    "/ if non-nil, a working tree is kept there

    "/ and updated/commited files are not removed.

    "/ If you use a regular (make-) tree, 

    "/ set WorkTreeDirectoryName (or the environment variable) to that.

    "/

    "/ this is not yet finished.

    "/

    s := OperatingSystem getEnvironment:'STX_WORKTREE'.

    s notNil ifTrue:[

        WorkTreeDirectoryName := s.

        UseWorkTree := true.

    ]

    "

     AbstractSourceCodeManager initialize

     CVSSourceCodeManager initialize

    "

    "

     CVSRoot := '/files/CVS'.

     AbstractSourceCodeManager initialize.

     CVSSourceCodeManager initialize.

    "

    "Created: / 4.11.1995 / 19:14:38 / cg"

    "Modified: / 19.12.1995 / 14:25:46 / stefan"

    "Modified: / 5.12.2001 / 18:52:00 / cg"

!

initializeForRepository:aDirectoryName

    "set the global CVSROOT directory (i.e. the repositories name).

     And reinitialize. 

     Can be used from the launcher to change/configure the repository."

    self repositoryName:aDirectoryName.

    AbstractSourceCodeManager initialize.

    CVSSourceCodeManager initialize.

    "

     CVSSourceCodeManager initializeForRepository:'/files/CVS'

     CVSSourceCodeManager initializeForRepository:'ibm:/files/CVS'

    "

    "Created: / 13.8.1997 / 17:20:57 / cg"

    "Modified: / 25.9.1997 / 12:28:05 / stefan"

    "Modified: / 2.11.1997 / 17:08:27 / cg"

! !

!CVSSourceCodeManager class methodsFor:'accessing'!

cvsBinDirectory

    "return the name of the bin repository.

     Thats the directory, where the cvs / cvs.exe command is found."

    ^ CVSBinDir

!

cvsBinDirectory:aString

    "set the name of the bin repository.

     Thats the directory, where the cvs / cvs.exe command is found."

    aString isEmpty ifTrue:[

        CVSBinDir := aString

    ] ifFalse:[        

        CVSBinDir := aString asFilename pathName.

        (CVSBinDir endsWith:Filename separator) ifTrue:[

            CVSBinDir := CVSBinDir copyWithoutLast:1.

        ]

    ].

!

cvsTmpDirectory

    "return the name of the tmp repository.

     Thats the directory, where temporary files are created for checkin/checkout.

     If nil, the systems default tempDirectory is used."

    ^ (CVSTempDir ? Filename tempDirectory pathName)

    "

     CVSTempDir := nil   

    "

!

cvsTmpDirectory:aPathNameString

    "set the name of the tmp repository.

     Thats the directory, where temporary files are created for checkin/checkout.

     If nil, the systems default tempDirectory is used."

    CVSTempDir := aPathNameString

!

knownModules

    "return the modules, we currently know"

    ^ CVSModuleRoots keys 

!

knownRepositories

    "return the modules, we currently know"

    ^ CVSModuleRoots values copyWith:CVSRoot 

!

repositoryName

    "return the name of the global repository.

     This is used, if no per-module repository is defined."

    ^ CVSRoot

    "Created: 14.9.1996 / 13:22:05 / cg"

    "Modified: 19.9.1997 / 06:12:02 / cg"

!

repositoryName:aDirectoryName

    "set the name of the repository;

     thats the name of the global CVSROOT directory, which is used 

     if no specific repository was defined for a module.

     Can be used from an rc-script, to override the CVSROOT shell 

     variable setting."

    DisabledModules := nil.

    CVSRoot := aDirectoryName.

    "Created: 14.9.1996 / 13:22:24 / cg"

    "Modified: 19.9.1997 / 06:10:31 / cg"

!

repositoryName:aRepositoryName forModule:aModuleName

    "set the CVSROOT directory which provides the sources for all 

     classes in a particular module.

     This can be used from an rc-script, to specify a repository

     for a particular module.

     If left unspecified, the global (i.e. fallBack) repository is used."

    DisabledModules := nil.

    CVSModuleRoots at:aModuleName put:aRepositoryName

    "Modified: 19.9.1997 / 06:09:40 / cg"

!

repositoryNameForModule:aModuleName

    "return the CVSROOT directory which provides the sources for all 

     classes in a particular module.

     Nil is returned for unspecified moduleRoots; in this case, 

     the global (i.e. fallBack) repository will be used for source access."

    ^ CVSModuleRoots at:aModuleName ifAbsent:nil.

    "Modified: 19.9.1997 / 06:09:40 / cg"

    "Created: 19.9.1997 / 06:13:06 / cg"

!

repositoryNamesPerModule

    "return the dictionary, which associates CVSRoots to module names.

     If no entry is contained in this dictionary for some module,

     the default cvsRoot (CVSRoot) will be used."

    ^ CVSModuleRoots 

!

repositoryNamesPerModule:aDictionary

    "set the dictionary, which associates CVSRoots to module names.

     If no entry is contained in this dictionary for some module,

     the default cvsRoot (CVSRoot) will be used."

    CVSModuleRoots := aDictionary

! !

!CVSSourceCodeManager class methodsFor:'private'!

checkOut:relativeFilename module:moduleDir in:tempdir

    "checkout realtiveFilename in tempdir"

    |cmd|

    cmd := 'checkout -l ' , relativeFilename.

    ^ self 

        executeCVSCommand:cmd 

        module:moduleDir

        inDirectory:tempdir name

        log:false