Copyright (c) 2010-2013, Morepath Developers

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the

documentation and/or other materials provided with the distribution.

* Neither the name of the <organization> nor the

names of its contributors may be used to endorse or promote products

derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL FANSTATIC DEVELOPERS BE LIABLE FOR ANY

DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import os

import shutil

import sys

import tempfile

from optparse import OptionParser

tmpeggs = tempfile.mkdtemp()

usage = '''\

parser = OptionParser(usage=usage)

parser.add_option("-v", "--version", help="use a specific zc.buildout version")

parser.add_option("-t", "--accept-buildout-test-releases",

dest='accept_buildout_test_releases',

action="store_true", default=False,

help=("Normally, if you do not specify a --version, the "

"bootstrap script and buildout gets the newest "

"*final* versions of zc.buildout and its recipes and "

"extensions for you. If you use this flag, "

"bootstrap and buildout will get the newest releases "

"even if they are alphas or betas."))

parser.add_option("-c", "--config-file",

help=("Specify the path to the buildout configuration "

"file to be used."))

parser.add_option("-f", "--find-links",

help=("Specify a URL to search for buildout releases"))

options, args = parser.parse_args()

to_reload = False

try:

import pkg_resources

import setuptools

except ImportError:

ez = {}

try:

from urllib.request import urlopen

except ImportError:

from urllib2 import urlopen

# XXX use a more permanent ez_setup.py URL when available.

exec(urlopen('https://bitbucket.org/pypa/setuptools/raw/0.7.2/ez_setup.py'

).read(), ez)

setup_args = dict(to_dir=tmpeggs, download_delay=0)

ez['use_setuptools'](**setup_args)

if to_reload:

reload(pkg_resources)

import pkg_resources

# This does not (always?) update the default working set. We will

# do it.

for path in sys.path:

if path not in pkg_resources.working_set.entries:

pkg_resources.working_set.add_entry(path)

ws = pkg_resources.working_set

cmd = [sys.executable, '-c',

'from setuptools.command.easy_install import main; main()',

'-mZqNxd', tmpeggs]

find_links = os.environ.get(

'bootstrap-testing-find-links',

options.find_links or

('http://downloads.buildout.org/'

if options.accept_buildout_test_releases else None)

)

if find_links:

cmd.extend(['-f', find_links])

setuptools_path = ws.find(

pkg_resources.Requirement.parse('setuptools')).location

requirement = 'zc.buildout'

version = options.version

if version is None and not options.accept_buildout_test_releases:

# Figure out the most recent final version of zc.buildout.

import setuptools.package_index

_final_parts = '*final-', '*final'

def _final_version(parsed_version):

for part in parsed_version:

if (part[:1] == '*') and (part not in _final_parts):

return False

return True

index = setuptools.package_index.PackageIndex(

search_path=[setuptools_path])

if find_links:

index.add_find_links((find_links,))

req = pkg_resources.Requirement.parse(requirement)

if index.obtain(req) is not None:

best = []

bestv = None

for dist in index[req.project_name]:

distv = dist.parsed_version

if _final_version(distv):

if bestv is None or distv > bestv:

best = [dist]

bestv = distv

elif distv == bestv:

best.append(dist)

if best:

best.sort()

version = best[-1].version

if version:

requirement = '=='.join((requirement, version))

cmd.append(requirement)

import subprocess

if subprocess.call(cmd, env=dict(os.environ, PYTHONPATH=setuptools_path)) != 0:

raise Exception(

"Failed to execute command:\n%s",

repr(cmd)[1:-1])

ws.add_entry(tmpeggs)

ws.require(requirement)

import zc.buildout.buildout

if not [a for a in args if '=' not in a]:

args.append('bootstrap')

if options.config_file is not None:

args[0:0] = ['-c', options.config_file]

zc.buildout.buildout.main(args)

shutil.rmtree(tmpeggs)

develop = .

parts = devpython scripts

versions = versions

show-picked-versions = true

extensions = mr.developer

auto-checkout = comparch

comparch = git ssh://faassen@startifact.com/home/faassen/comparch.git

recipe = zc.recipe.egg

interpreter = devpython

eggs = morepath

pyflakes

recipe = zc.recipe.egg:scripts

eggs = morepath [test]

pytest

from .implicit import initialize

initialize()

from comparch import PredicateRegistry

from .interfaces import IResource, ResourceError

from .request import Request

PREDICATES = ['name', 'request_method']

class PredicateLookup(object):

def __init__(self, predicate_registry):

self.predicate_registry = predicate_registry

def __call__(self, request, model):

func = self.predicate_registry.get(self.get_predicates(request))

if func is None:

return None

return func(request, model)

# XXX move to request?

def get_predicates(self, request):

result = {}

result['request_method'] = request.method

result['name'] = request.resolver_info()['name']

return result

def register_resource(registry, model, resource, **predicates):

lookup = registry.exact_get(IResource, (Request, model))

if lookup is None:

lookup = PredicateLookup(PredicateRegistry(PREDICATES))

registry.register(IResource, (Request, model), lookup)

lookup.predicate_registry.register(predicates, resource)

from comparch import ClassRegistry, CachedLookup, implicit

def initialize():

registry = ClassRegistry()

implicit.initialize(CachedLookup(registry))

from comparch import Interface

from abc import abstractmethod

class IConsumer(Interface):

"""A consumer consumes steps in a stack to find an object.

@abstractmethod

def __call__(self, obj, stack):

"""Returns a boolean meaning that some stack has been consumed,

class IResource(Interface):

pass

class ResolveError(Exception):

pass

class ModelError(ResolveError):

"""Exception raised when a model cannot be resolved

class ResourceError(ResolveError):

"""Exception raised when a resource cannot be resolved

import re

DEFAULT = u'default'

RESOURCE = u'resource'

def parse_path(path, shortcuts=None):

"""Parses a path /foo/bar/baz to a stack of steps.

if shortcuts is None:

shortcuts = {}

if path == '/' or not path:

return []

if path.startswith('/'):

path = path[1:]

steps = re.split(r'/+', path.rstrip('/'))

result = []

for step in steps:

for key, value in shortcuts.items():

if step.startswith(key):

step = (u'++%s++' % value) + step[len(key):]

break

if step.startswith(u'++'):

try:

ns, name = step[2:].split(u'++', 1)

except ValueError:

ns = DEFAULT

name = step

else:

ns = DEFAULT

name = step

result.append((ns, name))

result.reverse()

return result

def create_path(stack, shortcuts=None):

"""Rebuilds a path from a stack.

if shortcuts is None:

shortcuts = {}

else:

inversed_shortcuts = {}

for key, value in shortcuts.items():

# do not allow multiple shortcuts for the same namespace

assert value not in inversed_shortcuts

inversed_shortcuts[value] = key

shortcuts = inversed_shortcuts

result = []

for ns, name in reversed(stack):

if ns == DEFAULT:

result.append(name)

continue

shortcut = shortcuts.get(ns)

if shortcut is not None:

result.append(shortcut + name)

continue

result.append(u'++%s++%s' % (ns, name))

return '/' + u'/'.join(result)