/brz/remove-bazaar

# Copyright (C) 2005-2011 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Export functionality, which can take a Tree and create a different representation.

Such as non-controlled directories, tarfiles, zipfiles, etc.

"""

import os

import time

from bzrlib import (

    errors,

    pyutils,

    trace,

    )

# Maps format name => export function

_exporters = {}

# Maps filename extensions => export format name

_exporter_extensions = {}

def register_exporter(format, extensions, func, override=False):

    """Register an exporter.

    :param format: This is the name of the format, such as 'tgz' or 'zip'

    :param extensions: Extensions which should be used in the case that a

                       format was not explicitly specified.

    :type extensions: List

    :param func: The function. It will be called with (tree, dest, root)

    :param override: Whether to override an object which already exists.

                     Frequently plugins will want to provide functionality

                     until it shows up in mainline, so the default is False.

    """

    global _exporters, _exporter_extensions

    if (format not in _exporters) or override:

        _exporters[format] = func

    for ext in extensions:

        if (ext not in _exporter_extensions) or override:

            _exporter_extensions[ext] = format

def register_lazy_exporter(scheme, extensions, module, funcname):

    """Register lazy-loaded exporter function.

    When requesting a specific type of export, load the respective path.

    """

    def _loader(tree, dest, root, subdir, filtered, force_mtime):

        func = pyutils.get_named_object(module, funcname)

        return func(tree, dest, root, subdir, filtered=filtered,

                    force_mtime=force_mtime)

    register_exporter(scheme, extensions, _loader)

def export(tree, dest, format=None, root=None, subdir=None, filtered=False,

           per_file_timestamps=False):

    """Export the given Tree to the specific destination.

    :param tree: A Tree (such as RevisionTree) to export

    :param dest: The destination where the files,etc should be put

    :param format: The format (dir, zip, etc), if None, it will check the

                   extension on dest, looking for a match

    :param root: The root location inside the format.

                 It is common practise to have zipfiles and tarballs

                 extract into a subdirectory, rather than into the

                 current working directory.

                 If root is None, the default root will be

                 selected as the destination without its

                 extension.

    :param subdir: A starting directory within the tree. None means to export

        the entire tree, and anything else should specify the relative path to

        a directory to start exporting from.

    :param filtered: If True, content filtering is applied to the

                     files exported.

    :param per_file_timestamps: Whether to use the timestamp stored in the 

        tree rather than now(). This will do a revision lookup 

        for every file so will be significantly slower.

    """

    global _exporters, _exporter_extensions

    if format is None:

        for ext in _exporter_extensions:

            if dest.endswith(ext):

                format = _exporter_extensions[ext]

                break

    # Most of the exporters will just have to call

    # this function anyway, so why not do it for them

    if root is None:

        root = get_root_name(dest)

    if format not in _exporters:

        raise errors.NoSuchExportFormat(format)

    if not per_file_timestamps:

        force_mtime = time.time()

    else:

        force_mtime = None

    trace.mutter('export version %r', tree)

    tree.lock_read()

    try:

        return _exporters[format](tree, dest, root, subdir, filtered=filtered,

                                  force_mtime=force_mtime)

    finally:

        tree.unlock()

def get_root_name(dest):

    """Get just the root name for an export.

    """

    global _exporter_extensions

    if dest == '-':

        # Exporting to -/foo doesn't make sense so use relative paths.

        return ''

    dest = os.path.basename(dest)

    for ext in _exporter_extensions:

        if dest.endswith(ext):

            return dest[:-len(ext)]

    return dest

def _export_iter_entries(tree, subdir, skip_special=True):

    """Iter the entries for tree suitable for exporting.

    :param tree: A tree object.

    :param subdir: None or the path of an entry to start exporting from.

    :param skip_special: Whether to skip .bzr files.

    """

    if subdir == '':

        subdir = None

    if subdir is not None:

        subdir = subdir.rstrip('/')

    entries = tree.iter_entries_by_dir()

    entries.next() # skip root

    for path, entry in entries:

        # The .bzr* namespace is reserved for "magic" files like

        # .bzrignore and .bzrrules - do not export these

        if skip_special and path.startswith(".bzr"):

            continue

        if path == subdir:

            if entry.kind == 'directory':

                continue

            final_path = entry.name

        elif subdir is not None:

            if path.startswith(subdir + '/'):

                final_path = path[len(subdir) + 1:]

            else:

                continue

        else:

            final_path = path

        if not tree.has_filename(path):

            continue

        yield final_path, entry

register_lazy_exporter(None, [], 'bzrlib.export.dir_exporter', 'dir_exporter')

register_lazy_exporter('dir', [], 'bzrlib.export.dir_exporter', 'dir_exporter')

register_lazy_exporter('tar', ['.tar'], 'bzrlib.export.tar_exporter', 'plain_tar_exporter')

register_lazy_exporter('tgz', ['.tar.gz', '.tgz'], 'bzrlib.export.tar_exporter', 'tgz_exporter')

register_lazy_exporter('tbz2', ['.tar.bz2', '.tbz2'], 'bzrlib.export.tar_exporter', 'tbz_exporter')

register_lazy_exporter('tlzma', ['.tar.lzma'], 'bzrlib.export.tar_exporter', 'tar_lzma_exporter')

register_lazy_exporter('txz', ['.tar.xz'], 'bzrlib.export.tar_exporter', 'tar_xz_exporter')

register_lazy_exporter('zip', ['.zip'], 'bzrlib.export.zip_exporter', 'zip_exporter')