Managing project files and directories with command line CVS

CVS tool documents: Index

About source code version control with CVS
A version control glossary
  Using command-line CVS to access project source files
  Contributing source code changes with CVS
  You are here: Managing project files and directories with CVS
  - Releasing files
  - Removing files
  - Renaming and moving files
  - Importing existing source files
  - CVS and RCS
  - Using keywords
  - Tagging and branching

Back to main Help index

Releasing files and directories

At certain point in a project's development cycle, managing your project's source repository invariably involves dealing with files and directories that have become deprecated or obsolete. The decision is made to abandon a certain piece of functionality within a module, for example. Or perhaps an change in infrastructure demands getting rid of some files and moving others. This section deals with several methods for dealing with such file management issues in CVS.

Releasing refers to a way of designating certain directories or modules that will no longer to be used in the project. The command to release is invoked within a working copy and effectively cancels cvs checkouts for the designated directories and their files. Unless these are expressly deleted, the files and directories actually remain intact within the repository, including all file revision history, but are no longer included in when working copies are checked out.

The command to release a file or directory is:

> cvs rel filename (or /directory_name)

More about releasing

Removing files

Removing is another way to get rid of files when you no longer want or need them to be part of the project's source repository. To do this, you must first delete the file from the working copy you have checked out on your local system.

Then, to remove a file from the shared repository, type:

> cvs remove filename

After you have removed one or more files, you must commit your changes.

With "cvs remove" (or "cvs rm"), the old file is not completely eradicated but rather stored in CVS' so-called "attic" along with its complete revision history.

More about removing files
What happens when you remove a file

Renaming and moving files and directories

If you have imported some existing source code into your repository, you may have files and directories you want to rename or or move.

The best way to rename a file in your working copy involves a series of steps. Use:

> cvs rm old_filename

to remove the old name, then

> cvs add new_filename

and finally,

> cvs commit new_filename

There really is no specific way in CVS to remove or rename directories. However, you can produce that effect by creating a new directory, moving the files you need into it, removing unwanted files from the old directory, and then simply no longer using it. Later, you can "prune" these empty directories the next time you a check out a working copy by using:

> cvs checkout -P

Another way to prune directories with no more files is to update with:

> cvs update -dP

More about moving and renaming files
More about moving and renaming directories

Importing existing code?

If you have existing files to add to the project, you can import these into CVS using the following command:

> cvs import filename

Importing allows you to add a lot of files at once, something like a super "cvs add." To import all existing directories and files, in your top level directory type:

cvs import -m "log message" projectname

This creates the files and directories in the CVS repository for your project on this site. If you want to preserve these files and directories in their original state, you may want to tag or archive this set of original files before you or any other developers begin checking out working copies of project files.

If your existing files are already under versioning control -- either in another CVS repository or in a versioning different system such as RCS -- there is no automated method for importing existing files that retains file histories. Using the cvs import command, copying files over, or creating them as new files does not retain these histories.

CVS and RCS

If you're already familiar with RCS, both RCS and CVS use a similar format for storing the version control histories of individual files. But you should be aware of at least two critical differences in adapting CVS:

- One of the central principals in RCS is file locking, which prevents other developers from checking out or modifying a file when you have checked it out. The benefit to file locking is that developers never have to deal with conflicting modifications within files. RCS protects files by only allowing them to be modified by one person at a time. Therefore, the drawback to RCS is: you can't commit your changes to a file while another developer has it checked out.
- The central tenant of CVS is to allow developers to check out, modify, and commit files concurrently, truly a benefit to projects with remote, geographically dispersed developers. The tradeoff is that on a CVS version controlled project, you can count on dealing with merge conflicts in files. The only method for resolving such conflicts is by hand-editing the file. Thus, project workflow with CVS ends up being a little different.

More about RCS and CVS

Keyword substitution

Keyword substitution (a.k.a keyword expansion) is an RCS holdover that may be useful to you as a developer. Keywords essentially let you embed version information permanently in source files. A string containing the full version information associated with a particular keyword is substituted whenever the file is subsequently revised.

As an example, including:

> $Author: root $

within the files permanently retains the login name of the user who checked in that revision.

Keyword substitution is a method for tracking file versions once the files are no longer part of a CVS repository. Keyword substitution can also be configured and suppressed.

More about keywords (including a list of common keywords)

Tagging and branching

The CVS repository for your project hosted on this site supports branching and tagging your source files. At certain points in your project, you may want to enable development work in your project to progress in more than one direction simultaneously. Instead of maintaining a singular, linear path of development, CVS branching provides a way to divert or split the source tree for ancillary development activities without impacting progress of the project's primary effort. Examples of reasons to branch include:

- to distinguish a clearly defined set of functionality in project source files for QA and testing, or
- when you want to try an experiment such as added features or functionality without affecting the project's progress.

Tagging is included in the discussion about branching because the two operations are used in conjunction. Tagging allows you to "take a snapshot" of the overall project's state at a certain point in time, for example, to preserve a build with some particular characteristic. Because CVS manages individual file revisions, tagging is an important option for benchmarking the overall state of project source code. Files included in a tag will most likely be at different points in their respective revision numbering.

The critical difference between branching and tagging is the reason they are complimentary operations:

> Branching affects individual files' revision numbering, whereas tagging assigns a common identifying marker across all project files at a fixed point in time.

So, for example, project files are often tagged at the point where branches are created.

Ultimately, branches in your project with successful outcomes get incorporated or merged back in to the main development trunk. When that happens -- and it may occur repeatedly on large or long-term projects -- identifying the point where this merge occurs is another reason to create a tag.

To tag project files, type:

> cvs tag unique_tag_name

Your tag name can be a release name or date, a product version identifier, or whatever you choose.

To create a branch, type:

> cvs tag -b unique_tag_name

Branching and tagging are complex topics with many considerations and options. You can find more comprehensive information and instructions in the following resources:

- cvshome.org: "More about branching and tagging"
- The Cederqvist Manual: "Branches"
- Open Source Development with CVS:
  "Marking A Moment In Time (Tags)"
  "Branches"

Back to main Help index