# Copyright (c) 2007-2008 Infrae. All rights reserved.

# $Id: Common.py 33243 2009-01-29 10:59:47Z sylvain $

from sets import Set            # For python 2.3 compatibility

import os.path

import os

import re

import zc.buildout

def ignoredFile(file):

    """Return true if the file should be ignored while checking for

    added/changed/modified files.

    """

    for suffix in ['.pyc', '.pyo', '.egg-info']:

        if file.endswith(suffix):

            return True

    return False

def reportInvalidFiles(path, name, badfiles):

    """Report invalid files.

    """

    badfiles = [file for file in badfiles if not ignoredFile(file)]

    if not badfiles:

        return

    raise ValueError("""\

In '%s':

local modifications detected while uninstalling %r: Uninstall aborted!

Please check for local modifications and make sure these are checked

in.

If you sure that these modifications can be ignored, remove the

checkout manually:

  rm -rf %s

Or if applicable, add the file to the 'svn:ignore' property of the

file's container directory.  Alternatively, add an ignore glob pattern

to your subversion client's 'global-ignores' configuration variable.

""" % (path, name, """

  rm -rf """.join(badfiles)))

def checkExistPath(path, warning=True):

    """Check that a path exist.

    """

    status = os.path.exists(path)

    if not status and warning:

        print "-------- WARNING --------"

        print "Directory %s have been removed." % os.path.abspath(path)

        print "Changes might be lost."

        print "-------- WARNING --------"

    return status

def checkAddedPaths(location, urls):

    """Check that no path have been added to that location.

    """

    current_paths = Set([os.path.join(location, s) for s in

                         os.listdir(location)])

    recipe_paths = Set(urls.keys())

    added_paths = list(current_paths - recipe_paths)

    for path in added_paths[:]:

        if path.endswith('.svn'):

            added_paths.remove(path)

    if added_paths:

        msg = "New path have been added to the location: %s."

        raise ValueError(msg % ', '.join(added_paths))

def prepareURLs(location, urls):

    """Given a list of urls/path, and a location, prepare a list of

    tuple with url, full path.

    """

    def prepareEntry(line):

        link, path = line.split()

        return os.path.join(location, path), link

    return dict([prepareEntry(l) for l in urls.splitlines() if l.strip()])

def extractNames(urls):

    """Return just the target names of the urls (used for egg names)"""

    def extractName(line):

        link, name = line.split()

        return name

    return [extractName(line) for line in urls.splitlines() if line.strip()]

class BaseRecipe(object):

    """infrae.subversion recipe. Base class.

    """

    def __init__(self, buildout, name, options):

        self.buildout = buildout

        self.name = name

        self.options = options

        # location is overridable if desired.

        location = options.get('location', None)

        if location:

            self.location = os.path.abspath(os.path.join(

                buildout['buildout']['directory'], location))

        else:

            self.location = os.path.join(

                buildout['buildout']['parts-directory'], self.name)

        options['location'] = self.location

        self.revisions = {} # Store revision information for each link

        self.updated = []   # Store updated links

        self.urls = prepareURLs(self.location, options['urls'])

        self.export = options.get('export')

        self.offline = buildout['buildout'].get('offline', 'false') == 'true'

        self.eggify = options.get('as_eggs', False)

        self.eggs = self.eggify and extractNames(options['urls']) or []

        self.newest = (

            not self.offline and

            buildout['buildout'].get('newest', 'true') == 'true'

            )

        self.verbose = buildout['buildout'].get('verbosity', 0)

        self.warning = not (options.get('no_warnings', 'false') == 'true')

    def _exportInformationToOptions(self):

        """Export revision and changed information to options.

        Options can only contains strings.

        """

        if self.options.get('export_info', False):

            self.options['updated'] = str('\n'.join(self.updated))

            str_revisions = ['%s %s' % r for r in self.revisions.items()

                             if r[1]]

            self.options['revisions'] = str('\n'.join(sorted(str_revisions)))

        # Always export egg list

        self.options['eggs'] = '\n'.join(sorted(self.eggs))

    def _updateAllRevisionInformation(self):

        """Update all revision information for defined urls.

        """

        for path, link in self.urls.items():

            if os.path.exists(path):

                self._updateRevisionInformation(link, path)

    def _updateRevisionInformation(self, link, revision):

        """Update revision information on a path.

        """

        old_revision = self.revisions.get(link, None)

        self.revisions[link] = revision

        if not (old_revision is None):

            self.updated.append(link)

    def _updatePath(self, link, path):

        """Update a single path.

        """

        raise NotImplementedError

    def _updateAllPaths(self):

        """Update the checkouts.

        """

        ignore = self.options.get('ignore_updates', False) or self.export

        num_release = re.compile('.*@[0-9]+$')

        for path, link in self.urls.items():

            if not checkExistPath(path, warning=self.warning):

                if self.verbose:

                    print "Entry %s missing, checkout a new version ..." % link

                self._installPath(link, path)

                continue

            if ignore:

                continue

            if num_release.match(link):

                if self.verbose:

                    print "Given num release for %s, skipping." % link

                continue

            if self.verbose:

                print "Updating %s" % path

            self._updatePath(link, path)

    def update(self):

        """Update the recipe.

        Does not update SVN path if the buildout is in offline mode,

        but still eggify and export information.

        """

        if self.newest:

            self._updateAllPaths()

        if self.eggify:

            self._eggify()

        self._exportInformationToOptions()

        return self.location

    def _installPath(self, link, path):

        """Checkout a single entry.

        """

        raise NotImplementedError

    def _installPathVerbose(self, link, path):

        """Checkout a single entry with verbose.

        """

        if self.verbose:

            print "%s %s to %s" % (self.export and 'Export' or 'Fetch',

                                   link, path)

        self._installPath(link, path)

    def _eggify(self):

        """Install everything as development eggs if eggs=true"""

        if self.eggify:

            target = self.buildout['buildout']['develop-eggs-directory']

            for path in self.urls.keys():

                # If we update the recipe, and we don't have newest,

                # and that some path have been deleted, all of them

                # might not be there.

                if checkExistPath(path, warning=self.warning):

                    zc.buildout.easy_install.develop(path, target)

    def install(self):

        """Checkout the checkouts.

        Fails if buildout is running in offline mode.

        """

        for path, link in self.urls.items():

            self._installPathVerbose(link, path)

        installed = [self.location]

        if self.eggify:

            self._eggify()

            # And also return the develop-eggs/*.egg-link files that are

            # ours so that an uninstall automatically zaps them.

            dev_dir = self.buildout['buildout']['develop-eggs-directory']

            egg_links = ['%s.egg-link' % egg for egg in self.eggs]

            egg_links = [os.path.join(dev_dir, link) for link in egg_links]

            installed += egg_links

        self._exportInformationToOptions()

        return installed