 ------
 SCM Implementation: Bazaar
 ------
 Torbj�rn Eikli Sm�rgrav
 ------
 2006-02-01
 ------

~~ 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: Bazaar

* General Info

    Link : {{http://bazaar-vcs.org/}}

    License : GNU General Public License

    "Bazaar-NG is a decentralized revision control system designed to be easy for developers
    and end users alike. Decentralized revision control systems give people the ability to work
    over the internet using the bazaar development model. When you use Bazaar-NG, you can commit
    to your own branches of your favorite free software projects without needing special permission."

    The provider supports Bazaar from version 0.7, though important features like sftp transport where
    not included before version 0.8.

* SCM Url

    Path or url to the branch location.
    Supported protocols: FTP, SFTP, AFTP, HTTP, HTTPS and FILE.

-------
scm:bazaar:url_to_repository
-------

* Examples

-------
scm:bazaar:http://host/v3 (read only)
scm:bazaar:sftp://username:password@host/~/dev/project/v3 (relativ path)
scm:bazaar:sftp://host:port/home/smorgrav/dev/project/v3 (absolute path without explicit username)
scm:bazaar:file://C:/dev/project/v3 (windows drive)
scm:bazaar:file:///home/smorgrav/dev/project/v3 (linux drive)
-------
