~abentley/bzrtools/bzrtools.dev

# Copyright (C) 2004 Aaron Bentley
# <aaron.bentley@utoronto.ca>
#
#    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import pybaz as arch
from pybaz import iter_revision_libraries
from pybaz.backends.baz import sequence_cmd, null_cmd, one_cmd, status_cmd
import re
from native import DiffFilenames, DiffHunk, DiffLine, DiffAddLine
from native import DiffRemoveLine

__docformat__ = "restructuredtext"
__doc__ = "Functionality provided by tla"


def chattermatch (line, matchtext):
    """
    Detects whether line is Chatter that begins with matchtext.

    :param line: The line to test
    :type line: `arch.Chatter`, other
    :param matchtext: The chatter text to look for
    :type matchtext: string
    """
    return isinstance(line, arch.Chatter) and line.text.startswith(matchtext)

def diff_iter(changeset):
    """
    Generate an iterator of diff output for a given changeset

    :param changeset: The location of the changeset
    :type changeset: string
    :rtype: iterator of diff output
    """
    printline=False
    iterator = sequence_cmd(['show-changeset', '--diffs', changeset])
    for line in arch.classify_chatter(iterator):
        if chattermatch(line, "file metadata changed") or \
            chattermatch(line, "modified files"):
            printline=True
        if not printline:
            continue
        if isinstance(line, arch.Chatter):
            yield line
        elif line.startswith("---"):
            origname=line
        elif line.startswith("+++"):
            yield DiffFilenames(origname, line)
        elif line.startswith("@"):
            yield DiffHunk(line)
        elif line.startswith("+"):
            yield DiffAddLine(line)
        elif line.startswith("-"):
            yield DiffRemoveLine(line)
        elif line.startswith(" "):
            yield DiffLine(line)
        else:
            yield line


def iter_mirror_archive(from_arch, to_arch, limit):
    iter = mirror_archive(from_arch, to_arch, limit)
    return arch.classify_chatter(iter)

def  mirror_archive(from_arch, to_arch, limit):
    """
    Mirrors an archive to another archive.

    :param from_arch: The name of the source archive 
    :param to_arch: The name of the target archive
    :param limit: The specific thing to mirror from the archive.  May be a\
    branch, package or package-version.  Must not include an archive.
    :rtype: arch.util.exec_safe_iter_stdout
    """
    command=['archive-mirror', str(from_arch), str(to_arch)]
    if limit != None:
        command.append(str(limit))
    for line in arch.util.exec_safe_iter_stdout('tla', command, expected=(0)):
        yield line.rstrip('\n')


def iter_get(revision, directory=None, link=False, no_pristine=False, 
             no_greedy_add=False):
    """Creates a new dir containing the given revision.

    :param revision: The revision to get
    :type revision: `arch.Revision`
    :param directory: The name of the dir to create
    :type directory: str
    :rtype: Iterator of `arch.Chatter`
    """
    if directory is None:
        directory = revision.fullname
    return arch.classify_chatter(_iter_get(revision.fullname, directory, 
                                           link, no_pristine, no_greedy_add))


def _iter_get(revision, directory, link, no_pristine, no_greedy_add):
    """Creates a new dir containing the given revision.

    :param revision: The revision to get
    :type revision: `arch.Revision`
    :param directory: The name of the dir to create
    :type directory: str
    :rtype: Iterator of str
    """
    args = ["get"]
    if link:
      args.append("--link")
    if no_pristine:
      args.append("--no-pristine")
    if no_greedy_add:
      args.append("--no-greedy-add")
    args.extend([revision, directory])
    return sequence_cmd(args)


def iter_library_add(revision, directory=None):
    """Adds a revision to a library.

    :param revision: The revision to add
    :type revision: `arch.Revision`
    :param directory: The directory of the library to add to
    :type directory: str
    :rtype: Iterator of `arch.Chatter`
    """
    return arch.ChangesetApplication(_iter_library_add(revision.fullname,
                                                       directory))


def _iter_library_add(revision, directory):
    """Creates a new dir containing the given revision.

    :param revision: The revision to get
    :type revision: str
    :param directory: The name of the dir to create
    :type directory: str
    :rtype: Iterator of str
    """
    args = ["library-add"]
    if directory is not None:
        args.extend(["-L", directory])
    args.append(revision)
    return arch.util.exec_safe_iter_stdout('tla', args)


def iter_missing(tree, version, reverse=False, skip_present=False):
    assert (isinstance(version, arch.Version))
    for line in _iter_missing(str(tree), version.fullname, reverse, 
                              skip_present):
        yield arch.Revision(line)


def iter_new_merges(tree, version, reverse=False):
    """List patchlogs that are new in this tree since the last commit.

    :param tree: The working tree to calculate new revisions in
    :type tree: str
    :param version: The version to use when determining new logs
    :type version: str
    :param reverse: If true, list backwards, from newest to oldest
    :type reverse: bool
    :return: An iterator for new revision logs in this tree
    :rtype: Iterator of `arch.Patchlog`
    """
    assert (isinstance(version, arch.Version))
    for line in _iter_new_merges(tree, version.fullname, reverse):
        yield arch.Patchlog(line, tree)


def _iter_missing(directory, version, reverse, skip_present):
    args = [ 'missing', '--full', '--dir', directory ]
    if reverse: args.append('--reverse')
    if skip_present: 
        args.append('--skip-present')
    args.append(version)
    return sequence_cmd(args)


def _iter_new_merges(directory, version, reverse):
    """List patchlogs that are new in this tree since the last commit.

    :param directory: The working tree to calculate new revisions in
    :type directory: str
    :param version: The version to use when determining new logs
    :type version: str
    :param reverse: If true, list backwards, from newest to oldest
    :type reverse: bool
    :return: An iterator for names of revisions new in this tree
    :rtype: Iterator of str
    """
    args = [ 'new-merges', '--dir', directory ]
    if reverse: 
        args.append('--reverse')
    args.append(version)
    return sequence_cmd(args)


def apply_changeset(directory, changeset, reverse=False):
    application = changeset.iter_apply(directory, reverse=reverse)
    for line in application:
        pass
    return application.conflicting


def iter_tla_commands(command_aliases = True):
    """Generator for tla command name iterator.

    :rtype: iterator of str
    """
    for line in sequence_cmd(["help"]):
        pieces=line.split(':')
        if len(pieces) == 2:
            if command_aliases or (re.search('\(alias for', pieces[1]) is None):
                yield pieces[0].lstrip(' ').rstrip(' ')

def iter_tla_cmd_help(name, detailed=False):
    if detailed:
        arg = "-H"
    else:
        arg = "-h"
    return sequence_cmd((name, arg))

def _iter_browse(search):
    if search is None:
        return []
    splurch=search.split("/")
    args=["rbrowse", "-A", splurch[0]]
    if len(splurch) > 1:
        args.append(splurch[1])
    return sequence_cmd(args)


def iter_browse(search):
    archive = None
    for entry in _iter_browse(search):
        if entry.startswith('            ') or entry == "":
            pass
        elif entry.startswith('         '):
            assert (archive is not None)
            yield arch.Version("%s/%s" % (archive.fullname, entry[9:]))
        elif entry.startswith('      '):
            assert (archive is not None)
            yield arch.Branch("%s/%s" % (archive.fullname, entry[6:]))
        elif entry.startswith('   '):
            assert (archive is not None)
            yield arch.Category("%s/%s" % (archive.fullname, entry[3:]))
        else:
            assert (archive is not None)
            archive = arch.Archive(entry)
            yield archive


def _iter_log_for_merge(directory, version, reverse):
    """Produces log-for-merge output

    :param directory: The tree to produce output for
    :type directory: str
    :param version: The version to produce output for
    :type version: str
    :param reverse: List the logs in reverse order
    :type reverse: bool
    :return: An iterator that iterates through lines of output
    :rtype: iterator of str
    """
    args = ["log-for-merge"]
    if reverse:
        args.append("--reverse")
    if version is not None:
        args.append(version)
    return sequence_cmd(args)


def log_for_merge(tree, version=None, reverse=False):
    """Produces log-for-merge output

    :param tree: The tree to produce output for
    :type tree: `arch.WorkingTree`
    :param version: The version to produce output for
    :type version: `arch.Version`
    :param reverse: List the logs in reverse order
    :type reverse: bool
    :return: log-for-merge output or None
    :rtype: str or NoneType
    """
    merge_log = ""
    if version is not None:
        version = str(version)
    for line in _iter_log_for_merge(tree, version, reverse):
        merge_log += line + "\n"
    if len(merge_log) == 1 and merge_log[0]=="\n":
        return None
    return merge_log


def add_id(files, id=None):
    """Adds an explicit id to a list of files.

    :param files: the name of the file to add an id to
    :type files: list of str
    :param id: tag one file using the specified id, instead of generating id
    :type id: str
    """
    args = ["add-id"]
    if id is not None:
        args.extend(["--id", id])
    args.extend(files)
    return null_cmd(args)


def file_id(filename):
    return one_cmd(("id", filename)).split()[1].rstrip("\n")


def has_changed(version):
    return status_cmd(['changes', str(version)], (0, 1)) == 1


def iter_all_inventory(tree, dirs, control_files=False):
    args = ['inventory', '--both', '--ids']
    if control_files:
        args.append('--all')
    return sequence_cmd(args, chdir=str(tree))


class TreeFile:
    def __init__(self, name, tagged, letter):
        self.letter = letter
        self.name = name
        self.tagged = tagged

    def __str__(self):
        line = self.letter
        if not self.tagged:
            line += "? "
        else:
            line += "  "
        line += self.name
        return line

    def get_id(self):
        return None

class SourceFile(TreeFile):
    def __init__(self, name, tagged, id):
        TreeFile.__init__(self, name, tagged, "S")
        self.id = id

    def get_id(self):
        return self.id


class PreciousFile(TreeFile):
    def __init__(self, name, tagged):
        TreeFile.__init__(self, name, tagged, "P")


class BackupFile(TreeFile):
    def __init__(self, name, tagged):
        TreeFile.__init__(self, name, tagged, "B")


class JunkFile(TreeFile):
    def __init__(self, name, tagged):
        TreeFile.__init__(self, name, tagged, "J")


class UnrecognizedFile(TreeFile):
    def __init__(self, name, tagged):
        TreeFile.__init__(self, name, tagged, "U")


class TreeRootFile(TreeFile):
    def __init__(self, name, tagged):
        TreeFile.__init__(self, name, tagged, "T")

category_letters = {
"S" : SourceFile, 
"P" : PreciousFile,
"B" : BackupFile,
"J" : JunkFile,
"U" : UnrecognizedFile,
"T" : TreeRootFile
}


non_root = (SourceFile, PreciousFile, BackupFile, JunkFile, UnrecognizedFile)


def file_classifier(iter):
    for line in iter:
        segment = line.split()
        tagged = len(segment[0]) == 1 or segment[0][1] !="?"
        name = segment[1]
        if segment[0][0] == "S":
            file_id = segment[2]
            yield SourceFile(name, tagged, file_id)
        else:
            yield category_letters[segment[0][0]](name, tagged)


def iter_inventory_filter(tree, dirs, tagged=None, categories=None, 
                          control_files=False):
    for my_file in file_classifier(iter_all_inventory(tree, dirs, 
                                                      control_files)):
        if tagged is not None:
            if tagged != my_file.tagged:
                continue

        if categories is None:
            yield my_file
        else:
            for category in categories:
                if isinstance(my_file, category):
                    yield my_file
                    break


def file_line(my_file, category=True, untagged=True, filename=True, id=False):
    line = ""
    if category:
        line += my_file.letter
    if untagged:
        if my_file.tagged:
            line +=" "
        else:
            line +="?"
    if filename:
        if len(line) > 0:
            line +=" "
        line += my_file.name
    
    if id:
        if len(line) > 0:
            line +="\t"
        if my_file.get_id() is not None:
            line += my_file.get_id()
        else:
            line += "???"
    return line


def get_id_filename_map(tree):
    map = {}
    for listing in iter_inventory_filter(tree, (tree,), categories=(SourceFile,), 
                                         control_files=True):
        map[listing.id] = listing.name
    return map


def file_find(my_file, revision=None):
    """Returns the path to the file in the revision.
    :param my_file: the file in the working tree to find in the revision
    :type my_file: str
    :param revision: The revision to look in
    :type revision: `arch.Revision`, str, or NoneTye
    """
    args=["file-find", my_file]
    if revision is not None:
        args.append(str(revision))
    for line in arch.classify_chatter(sequence_cmd(args)):
        if isinstance (line, arch.Chatter):
            continue
        return line


class LintProblem:
    def __init__(self, filename):
        self.filename = filename
    def __str__(self):
        return filename


class BrokenSymlink(LintProblem):
    def __init__(self, filename):
        LintProblem.__init__(self, filename)


class UnrecognizedLintFile(LintProblem):
    def __init__(self, filename):
        LintProblem.__init__(self, filename)

class UnusedID(LintProblem):
    def __init__(self, filename):
        LintProblem.__init__(self, filename)

class DuplicateID(LintProblem):
    def __init__(self, id, files):
        self.id = id
        self.files = files

    def __str__(self):
        output = ""
        did_id = False
        for file in self.files:
            output += file
            if not did_id:
                output +="\t%s" % self.id
                did_id = True
            output += "\n"
        return output
# arch-tag: 07e2fed5-d68a-4272-95d9-65450a4f9774