~menesis/schooltool/versionator

import re
import apt_pkg # apt-get install python-apt
from pkg_resources import parse_version
from copy import copy
from van.pydeb import py_to_bin, bin_to_py, py_version_to_deb

import visualize


APT_INITIALIZED = False
def require_apt():
    global APT_INITIALIZED
    if not APT_INITIALIZED:
        apt_pkg.InitSystem()
        APT_INITIALIZED = True

SHOW_GAUGES = True


def getParsedDependsNames(parsed):
    """Lists all packages mentioned in parsed dependency list.
    Includes all alternative dependencies (pkg-foo | pkg-bar (>= 1.2.6)).
    """
    result = set()
    for alternatives in parsed:
        for name, ver, op in alternatives:
            result.add(name)
    return sorted(result)


class PackageDesc(dict):

    def __init__(self, package=None, version=None):
        super(PackageDesc, self).__init__()
        if isinstance(package, dict):
            self.update(package)
        else:
            if package is not None:
                self['Package'] = package
            if version is not None:
                self['Version'] = version

    @property
    def name(self):
        return self.get('Package')

    @property
    def version(self):
        return self.get('Version')

    @property
    def simple_ver(self):
        return self['Version']

    @property
    def dependencies(self):
        result = []
        for key in 'Pre-Depends', 'Depends':
            if key in self:
                result.extend(apt_pkg.ParseDepends(self[key]))
        return result

    @property
    def dependency_names(self):
        return getParsedDependsNames(self.dependencies)

    @property
    def provides_names(self):
        if 'Provides' in self:
            return getParsedDependsNames(
                apt_pkg.ParseDepends(self['Provides']))
        return []

    @property
    def conflicts(self):
        result = []
        for key in 'Breaks', 'Conflicts':
            if key in self:
                result.extend(apt_pkg.ParseDepends(self[key]))
        return result

    @property
    def conflict_names(self):
        return getParsedDependsNames(self.conflicts)

    @property
    def replaces(self):
        result = []
        if 'Replaces' in self:
            result.extend(apt_pkg.ParseDepends(self['Replaces']))
        return result

    @property
    def replaces_names(self):
        return getParsedDependsNames(self.replaces)

    def cmp_ver(self, other):
        return cmp(parse_version(self.simple_ver),
                   parse_version(other.simple_ver))

    def __str__(self):
        s = self.get('Package', '???')
        if 'Version' in self:
            s += ' (%s)' % self['Version']
        return s

    def __repr__(self):
        return '<%s %s>' % (self.__class__.__name__, str(self))

    def __hash__(self):
        return hash(self.name)

    def __eq__(self, other):
        return self.name == other.name


re_deb_entry = re.compile("^(?P<key>[\w\d-]+): (?P<value>.*)")


class DebDesc(PackageDesc):

    def __init__(self, package_desc):
        if isinstance(package_desc, dict):
            self.update(package_desc)
        else:
            # package_desc is list of lines probably :)
            self.load_entries(package_desc)

    def load_entries(self, lines):
        entry = ''
        for line in lines:
            m = re_deb_entry.match(line)
            if m is None:
                if entry in self:
                    self[entry] += '\n' + line
                else:
                    self[entry] = line
            else:
                groups = m.groupdict()
                entry = groups['key']
                self[entry] = groups['value']

    @property
    def simple_ver(self):
        # crappy guess at simple package version
        version = self['Version'].split('-')[0]
        version = version.replace('~', '')
        if ':' in version:
            return version[version.find(':')+1:]
        return version

    def cmp_ver(self, other):
        if isinstance(other, DebDesc):
            require_apt()
            return apt_pkg.VersionCompare(self['Version'], other['Version'])
        else:
            return PackageDesc.cmp_ver(self, other)


class EggDesc(PackageDesc):
    pass


class Packages(set):

    def __copy__(self):
        cls = type(self)
        inst = cls()
        inst.update(self)
        return inst

    def __getitem__(self, item):
        if isinstance(item, str):
            name = item
        elif isinstance(item, PackageDesc):
            name = item.name
        else:
            raise NotImplemented()
        for pkg in self:
            if pkg.name == name:
                return pkg
        raise KeyError(item)

    def get(self, item, default=None):
        try:
            return self[item]
        except KeyError:
            return default

    def add(self, item):
        existing = self.get(item)
        if existing and existing.cmp_ver(item) < 0:
            self.remove(existing)
        super(Packages, self).add(copy(item))

    def remove(self, item):
        item = self[item]
        super(Packages, self).remove(item)

    def update(self, other):
        for item in other:
            self.add(copy(item))

    def __repr__(self):
        return '<%s (%d)>' % (self.__class__, len(self))

    def getVirtualPackageNames(self):
        names = set()
        for pkg in self:
            names.update(pkg.provides_names)
        return names


class Debs(Packages):

    def __init__(self, filename=None, names=()):
        if filename is not None:
            self.load(filename, names)

    def _read_block(self, stream):
        lines = []
        s = stream.readline().rstrip()
        while s:
            lines.append(s)
            s = stream.readline().rstrip()
        return lines

    def load(self, filename, names=()):
        """Load packages Debian apt style file"""
        self.clear()
        f = open(filename)

        global SHOW_GAUGES
        gauge = None
        if SHOW_GAUGES:
            f.seek(0, 2)
            f_len = f.tell()
            f.seek(0)
            gauge = visualize.Gauge(label=filename)
            gauge.reset(f_len)
        packages = Packages()
        lines = self._read_block(f)
        while lines:
            deb = DebDesc(lines)
            if not names or deb.name in names:
                packages.add(deb)
            lines = self._read_block(f)
            if gauge:
                gauge.tick(f.tell())
        if gauge:
            gauge.done('%s packages' % len(packages))
        f.close()
        self.update(packages)

    @classmethod
    def fromPackages(cls, packages):
        debs = cls()
        for pkg in packages:
            if isinstance(pkg, EggDesc):
                deb = DebDesc(pkg)
                deb['Package'] = py_to_bin(deb['Package'])
                deb['Version'] = py_version_to_deb(deb['Version'])
                debs.add(deb)
            elif isinstance(pkg, PackageDesc):
                debs.add(DebDesc(pkg))
            elif isinstance(pkg, str):
                debs.add(DebDesc(PackageDesc(package=pkg)))
            else:
                raise NotImplemented()
        return debs


class Eggs(Packages):

    def __init__(self, buildout_cfg=None, names=()):
        if buildout_cfg is not None:
            self.load_versions(buildout_cfg, names)

    def _iter_buildout_cfg(self, stream):
        """Stupid buildout.cfg iterator.
        Yields line, package, version for every line in the stream.
        Yelds line, None, None when not inside [versions] entry point.
        """
        lines = stream.readlines()
        entrypoint = ''
        for s in lines:
            s = s.strip()
            if s.startswith('[') and s.endswith(']'):
                entrypoint = s[1:-1]
            if (entrypoint=='versions' and
                s and s[0].isalpha() and '=' in s):
                package, version = [e.strip() for e in s.split('=')]
                comment = version.find('#')
                if comment != -1:
                    version = version[:comment].strip()
            else:
                package = version = None
            yield (s, package, version)


    def load_versions(self, filename, names=()):
        """Load versions from [versions] entrypoint in buildout.cfg"""
        f = open(filename)
        comments = ''
        for line, package, version in self._iter_buildout_cfg(f):
            if package is not None:
                egg = EggDesc(package=package, version=version)
                if comments:
                    egg['Comments'] = comments
                if not names or egg.name in names:
                    self.add(egg)
            if line.startswith('#'):
                comments += line[1:].strip() + '\n'
            else:
                comments = ''
        f.close()

    @classmethod
    def fromPackages(cls, packages):
        eggs = cls()
        for pkg in packages:
            if isinstance(pkg, DebDesc):
                egg = EggDesc(pkg)
                egg['Package'] = bin_to_py(pkg['Package'])
                egg['Version'] = pkg.simple_ver
                eggs.add(egg)
            elif isinstance(pkg, PackageDesc):
                eggs.add(EggDesc(pkg))
            elif isinstance(pkg, str):
                eggs.add(EggDesc(PackageDesc(package=pkg)))
            else:
                raise NotImplemented()
        return eggs


class MappedPackages(object):

    def __init__(self, packages):
        self.packages = copy(packages)
        self.update()

    def update(self, packages=[]):
        packages = self.packages.fromPackages(packages)
        if packages:
            self.packages.update(packages)
        self.by_name = dict([
            (self._make_name(package), package)
            for package in self.packages])
        if len(self.by_name) != len(self.packages):
            raise Exception('Some packages have identical names')

    def _make_name(self, item):
        name = None
        if isinstance(item, str):
            name = item
        elif isinstance(item, DebDesc):
            name = item.name
            if isinstance(self.packages, Eggs):
                name = bin_to_py(name)
        elif isinstance(item, EggDesc):
            name = item.name
            if isinstance(self.packages, Debs):
                name = py_to_bin(name)
        else:
            raise NotImplemented()
        return name

    def __contains__(self, item):
        try:
            return self._make_name(item) in self.by_name
        except KeyError:
            return False

    def __getitem__(self, item):
        name = self._make_name(item)
        return self.by_name[name]

    def get(self, item, default=None):
        try:
            return self[item]
        except KeyError:
            return default

    def __iter__(self):
        return iter(self.packages)


def namespace_sort_key(namespaces):
    """Build a sort key, by namespaces.
    e.g.: namespaces = ['', 'zope.', 'zope.app.', 'zc.', 'z3c.']
    """
    def key(pkg):
        best_score = len(namespaces) + 1
        most_specific = None
        name = pkg.name
        for score, namespace in enumerate(namespaces):
            if name.startswith(namespace):
                if (most_specific is None or
                    len(namespace) > len(most_specific)):
                    best_score = score
                    most_specific = namespace
        return (best_score, str(pkg))
    return key


def loose_namespace_sort_key(namespaces):
    """Build a sort key, by namespaces.
    e.g.: namespaces = ['', 'zope.', 'zope.app.', 'zc.', 'z3c.']
    """
    def key(pkg):
        best_score = len(namespaces) + 1
        most_specific = None
        if isinstance(pkg, PackageDesc):
            name = pkg.name
        else:
            name = pkg
        for score, namespace in enumerate(namespaces):
            if namespace in name:
                if (most_specific is None or
                    len(namespace) > len(most_specific)):
                    best_score = score
                    most_specific = namespace
        return (best_score, str(pkg))
    return key