GNU Info

(cvsbook.info)The modules File

---

Next: The commitinfo And loginfo And rcsinfo Files Prev: The config File Up: The CVSROOT/ Administrative Directory

---

Enter node , (file) or (file)node

The modules File
----------------

In modules, you can define aliases and alternate groupings for projects
in the repository.  The most basic module line is of the form:

     MODULE_NAME   DIRECTORY_IN_REPOSITORY

for example,

     mp    myproj
     asub  myproj/a-subdir

(The paths given on the right are relative to the top of the
repository.)  This gives developers an alternate name by which to check
out a project or a portion of a project:

     floss$ cvs co mp
     cvs checkout: Updating mp
     U mp/README.txt
     U mp/foo.jpg
     U mp/hello.c
     cvs checkout: Updating mp/a-subdir
     U mp/a-subdir/whatever.c
     cvs checkout: Updating mp/a-subdir/subsubdir
     U mp/a-subdir/subsubdir/fish.c
     cvs checkout: Updating mp/b-subdir
     U mp/b-subdir/random.c

or

     floss$ cvs -d /usr/local/newrepos/ co asub
     cvs checkout: Updating asub
     U asub/whatever.c
     cvs checkout: Updating asub/subsubdir
     U asub/subsubdir/fish.c

Notice how in both cases the module's name became the name of the
directory created for the working copy.  In the case of asub, it didn't
even bother with the intermediate myproj/ directory, but created a
top-level asub/ instead, even though it came from myproj/a-subdir in the
repository.  Updates, commits, and all other CVS commands will behave
normally in those working copies - the only thing unusual about them
are their names.

By putting file names after the directory name, you can define a module
consisting of just some of the files in a given repository directory.
For example

     readme  myproj  README.txt

and

     no-readme  myproj  hello.c  foo.jpg

would permit the following checkouts, respectively:

     floss$ cvs -q co readme
     U readme/README.txt
     floss$ cvs -q co no-readme
     U no-readme/hello.c
     U no-readme/foo.jpg
     floss$

You can define a module that will include multiple repository
directories by using the -a (for `alias') flag, but note that the
directories will get them checked out under their original names.  For
example, this line

     twoproj  -a  myproj  yourproj

would allow you to do this (assuming that both myproj/ and yourproj/ are
in the repository):

     floss$ cvs co twoproj
     U myproj/README.txt
     U myproj/foo.jpg
     U myproj/hello.c
     U myproj/a-subdir/whatever.c
     U myproj/a-subdir/subsubdir/fish.c
     U myproj/b-subdir/random.c
     U yourproj/README
     U yourproj/foo.c
     U yourproj/some-subdir/file1.c
     U yourproj/some-subdir/file2.c
     U yourproj/some-subdir/another-subdir/blah.c

The name `twoproj' was a convenient handle to pull in both projects,
but it didn't affect the names of the working copies. (There is no
requirement that alias modules refer to multiple directories, by the
way; we could have omitted twoproj, in which case myproj would still
have been checked out under the name `myproj'.)

Modules can even refer to other modules, by prefixing them with an
ampersand:

     mp    myproj
     asub  myproj/a-subdir
     twoproj -a myproj yourproj
     tp  &twoproj

Doing a checkout of `tp' would have exactly the same result as the
checkout of `twoproj' did.

There are a few other tricks you can do with modules, most of them less
frequently used than the ones just presented.  See the node modules in
the Cederqvist for information about them.