"{ Encoding: utf8 }"

"

 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' }"

"{ NameSpace: Smalltalk }"

AbstractSourceCodeManager subclass:#CVSSourceCodeManager

	instanceVariableNames:''

	classVariableNames:'CVSRoot RemoteCVS CVSModuleRoots CMD_checkout CVSTempDir

		DisabledModules CVSCommandSemaphore CVSExecutable

		CVSCommitOptions CVSUpdateOptions CVSCommandTimeout

		RecentlyCheckedModulesAndPackages RecentTags AuthorMap'

	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 file's 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, server-mode CVS is not supported.

    Comment:

        The code here is a copy-paste mess; it definitely needs some cleanup...

    [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 )

"

!

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'!

addExeptsPrivateRepositoryToModuleRoots

    CVSModuleRoots at:'stx' put:(self exeptsPrivateSTXRepositoryModuleRoot).

    CVSModuleRoots at:'exept' put:(self exeptsPrivateSTXRepositoryModuleRoot).

!

addExeptsPublicRepositoryToModuleRoots

    CVSModuleRoots at:'stx' put:(self exeptsPublicSTXRepositoryModuleRoot)

!

exeptsPrivateSTXRepositoryModuleRoot

    ^ ':pserver:',(OperatingSystem getLoginName),'@cvs.bh.exept.de:/cvs/stx'.

!

exeptsPublicSTXRepositoryModuleRoot

    ^ ':pserver:cvs@cvs.smalltalk-x.de:/cvs/stx'.

!

forgetDisabledModules

    DisabledModules := nil.

!

initCommands

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

    "Modified: / 13-10-2006 / 00:44:13 / cg"

!

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

    CVSCommandSemaphore := (Semaphore new:10) name:'Concurrent CVS Commands'.    "/ at most 10 cvs activities concurrently

    CVSCommitOptions := ''.

    CVSUpdateOptions := ''.

    RemoteCVS := true.

    DisabledModules := nil.

    CVSModuleRoots isNil ifTrue:[

        CVSModuleRoots := Dictionary new.

    ].

    "/ self possiblyAddExeptsPrivateRepositoryToModuleRoots.

    "/

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

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

    "/

    CVSRoot isNil ifTrue:[

        CVSRoot := OperatingSystem getEnvironment:'CVSROOT'.

        CVSRoot isNil ifTrue:[

            "disabled since $CVSROOT is not set"

            ^ self

        ].

    ].

    cvsCmd := self cvsExecutable.

"/    ok := OperatingSystem canExecuteCommand:cvsCmd.

"/    ok ifFalse:[

"/        'CVSSourceCodeManager [warning]: disabled because no >>cvs<< command was found' infoPrintCR.

"/        ^ self

"/    ].

    UseWorkTree := false.

    CacheDirectoryName isNil ifTrue:[

        self initCacheDirPath.

    ].

    CachingSources isNil ifTrue:[

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

        DefaultManager := self.    

    ].

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

    RemoteCVS ifFalse:[

        'CVSSourceCodeManager [info]: using faster local CVS mode' 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.

    "

    "

     CVSRoot := ':pserver:cg@cvs.bh.exept.de:/cvs/stx'.

     AbstractSourceCodeManager initialize.

     CVSSourceCodeManager initialize.

     SourceCodeManager := CVSSourceCodeManager.

    "

    "Created: / 04-11-1995 / 19:14:38 / cg"

    "Modified: / 19-12-1995 / 14:25:46 / stefan"

    "Modified: / 20-03-2012 / 19:06:35 / 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"

!

possiblyAddExeptsPrivateRepositoryToModuleRoots

    "/ for exept's convenience: if this is a host in our domain,

    "/ add the exept repository.

    |h addr|

    (h := OperatingSystem getHostName) notEmptyOrNil ifTrue:[

        addr := IPSocketAddress hostName:h.

        addr notNil ifTrue:[

            (addr hostAddress startsWith: #[172 23 1]) ifTrue:[

                self addExeptsPrivateRepositoryToModuleRoots

            ]

        ].

    ].

! !

!CVSSourceCodeManager class methodsFor:'accessing'!

CVSCommitOptions

    ^ CVSCommitOptions ? ''

!

CVSCommitOptions:aString

    CVSCommitOptions := aString.

!

CVSUpdateOptions

    ^ CVSUpdateOptions ? ''

!

CVSUpdateOptions:aString

    CVSUpdateOptions := aString.

!

cvsBinDirectory:ignoredString

    "ignored - for backward compatibility (to read old settings files)"

    "Created: / 21-09-2006 / 17:26:43 / cg"

!

cvsCommandTimeout

    ^ CVSCommandTimeout ? ("360" 120 seconds)

    "Modified (comment): / 08-01-2012 / 19:02:44 / cg"

!

cvsCommandTimeout:aTimeDuration

    CVSCommandTimeout := aTimeDuration asTimeDuration.

    "Created: / 08-01-2012 / 19:36:01 / cg"

!

cvsExecutable

    "return the name of the cvs executable."

    ^ CVSExecutable ? 'cvs'

    "Created: / 21-09-2006 / 15:31:12 / cg"

!

cvsExecutable:aString

    "set the name of the cvs executable."

    aString isEmptyOrNil ifTrue:[

        CVSExecutable := nil

    ] ifFalse:[        

        CVSExecutable := aString.

    ].

    "Created: / 21-09-2006 / 15:31:59 / cg"

    "Modified: / 21-09-2006 / 16:41:33 / cg"

!

cvsTmpDirectory

    "return the name of the tmp repository.

     That's the directory, where temporary files are created for checkin/checkout.

     If nil, a directory under the system's default tempDirectory is used."

    |d|

    CVSTempDir notNil ifTrue:[^ CVSTempDir].

    d := Filename tempDirectory / 'stx_cvs'.

    d exists ifFalse:[

        d recursiveMakeDirectory.

    ].

    ^ d pathName

    "

     CVSTempDir := nil   

    "

    "Modified (comment): / 24-09-2012 / 11:09:38 / cg"

!

cvsTmpDirectory:aPathNameString

    "set the name of the tmp repository.

     That's the directory, where temporary files are created for checkin/checkout.

     If nil, the system's default tempDirectory is used."

    CVSTempDir := aPathNameString

    "Modified (comment): / 24-09-2012 / 11:09:34 / cg"

!

knownModules

    "return the modules, we currently know"

    CVSModuleRoots isEmptyOrNil ifTrue:[^ #() ].

    ^ CVSModuleRoots keys

    "Modified: / 26-12-2011 / 00:49:03 / cg"

!

knownRepositories

    "return the modules, we currently know"

    ^ CVSModuleRoots values copyWith:CVSRoot 

!

recentTag

    "a place to remember recently set tags (to share between File and SystemBrowser)"

    ^ RecentTags isEmptyOrNil ifTrue:[nil] ifFalse:[RecentTags last].

    "

     self recentTag

    "

!

recentTag:aString

    "a place to remember recently set tags (to share between File and SystemBrowser)"

    "/ RecentTag := aString.

    RecentTags isNil ifTrue:[

        RecentTags := OrderedCollection new.

    ].

    RecentTags remove:aString ifAbsent:[].

    RecentTags addFirst:aString.

    RecentTags size > 10 ifTrue:[ RecentTags removeLast].

!

recentTags

    "a place to remember recently set tags (to share between File and SystemBrowser)"

    ^ RecentTags

!

repositoryForPackage:packageId