 ------
 SCM Implementation: CM/Synergy
 ------
 Julien Henry (Capgemini) & La Poste
 ------
 2006-10-23
 ------

~~ 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: CM/Synergy

* General Info

   Link : {{http://www.telelogic.com/Products/synergy/synergycm/index.cfm}}

   License : Commercial

* SCM Url

    For all URLs below, we use a colon (:) as separator. If you use a colon for one of the variables (e.g. a windows path), then use a pipe (|) as separator.

-------
scm:synergy<delimiter>project_name<delimiter>database_delimiter<delimiter>project_version<delimiter>release<delimiter>purpose<delimiter>instance
-------

    <project_name>: This is the name of the project from which the checkout is done.

    <project_version>: This is the version of the project from which the checkout is done (usually a prep project).

    <release>: This is the release.

    <purpose>: This is the purpose.
	
	<instance>: This is the (optional) instance of the project from which the checkout is done (usually a prep project). Default is 1.

* Examples

-------
scm:synergy:MyProject:~:int_1.0:MyProject/2.0:Devel:1
scm|synergy|MyProject|-|int_1.0|MyProject/2.0|Devel:db1#1
-------

* Extra Information
** General

	ccm start command shall use -rc in addition to below options for remote linux clients.

** Checkout

    Checkout purpose is to get sources from a working Work Area to a given folder. First,
    it checks if a work area already exists with the given version. If yes, it only synchronizes and reconfigures
    the existing one, and then copies file to the expecting folder. If no Work Area exists, then a checkout is done.

    To specify the version of the checkout working project, use <tag> parameter.

    When a 'checkout' happens, the following scm commands are generated

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm query -u -f %objectname "owner='<username>' and status='working' and type='project' and has_predecessor('<project_spec>')" //Check for existing checkout
ccm synchronize -p <working_project_spec>
ccm reconfigure -p <working_project_spec>
ccm checkout -subprojects -rel [-t <tag>] -purpose <purpose> -release <release> -p <project_spec> // If no existing working project exists
ccm stop
-------

** Update

    Reconfigure project with default reconfigure template, and copy file from work area to expected folder.

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm query -u -f %objectname "owner='<username>' and status='working' and type='project' and has_predecessor('<project_spec>')" //Check for existing checkout
ccm reconfigure -r -p <working_project_spec>
ccm stop
-------

** Add

    Create a default task, add new file(s) to the repository and checkin the task.
    <message> You can change the synopsis of the task by setting this parameter

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm task -create -def -release <release> -synopsis <message>
ccm create -c <message> <filename>
ccm task -checkin <task_spec> -comment <message>
ccm stop
-------

** Remove

    Remove a file from repository.

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm delete <filename>
ccm stop
-------

** Changelog

 Get modified files history. In order to parse output of Synergy command, we need to know different parameters:

 * maven.scm.synergy.ccmDateFormat (default value is EEE MMM dd HH:mm:ss yyyy)

 * maven.scm.synergy.language (default value is en)

 * maven.scm.synergy.country (default value is US)

 []

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm query -u is_task_in_folder_of(is_folder_in_rp_of('<project_spec>')) and completion_date>time(<startDate>) and completion_date<time(<endDate>)
ccm task -show objects <task>
ccm stop
-------

** Checkin

    Checkin the default task.

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm task -checkin default -c <message>
ccm stop
-------

** Edit

    Create a default task and checkout file(s).

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm task -create -def -release <release> -synopsis <message>
ccm co <filename>
ccm stop
-------

** Unedit

    Cancel edition. Replace file with previous version.

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm delete -replace <filename>
ccm stop
-------

** Status

    Get state of files.

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm dir -m
ccm stop
-------

** Tag

    Create a baseline on the prep project.
    You may need to change the purpose in the pom to create the baseline (only prep purpose are allowed).

-------
ccm start -m -q -nogui -n <username> -pw <password>
ccm baseline -create <tag> -p <project_spec> -r <release> -purpose <purpose>
ccm stop
-------
