 ------
 SCM Implementation: Visual Source Safe
 ------
 Wim Deblauwe
 ------
 2008-09-02
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

SCM Implementation: Visual Source Safe

* General Info

    Link : {{http://msdn.microsoft.com/ssafe/}}

    License : Commercial

* SCM Url

    Because a colon is used for one of the variables (a windows path), a pipe (|) is used as the delimiter.

    The general format for a VSS SCM Url is

-------
scm:vss|path_to_repository|/module_name
-------

    The third variable is the path to the Visual Source Safe repository (where srcsafe.ini resides).

    Note that a forward slash is necessary before the module name in the final variable.

* Examples

-------
scm:vss|C:\Program Files\Microsoft Visual Studio\VSS|/SomeProject
-------

* Provider Configuration

  The provider configuration is defined in ${user.home}/.scm/vss-settings.xml

** VSS Installation directory

  The provider needs to know the installation path of the ss.exe in order to fulfill VSS commands. The installation path can be set in two ways - either in the vss-settings.xml file:

-------
<vss-settings>
  <Settings>
    <vssDirectory>ss_exe_directory</vssDirectory>
  <Settings>
</vss-settings>
-------

  or on the command line:

-------
mvn -DvssDirectory=ss_exe_directory scm:update
-------

  In either case, ss_exe_directory should be set to the full path to the directory where ss.exe resides (e.g. C:\Program Files\Microsoft Visual Studio\VSS\bin).
