root/trunk/pyramid/yamlRegistry.py

import syck
from pyramid import utils, core
from pyramid.path import path
from pprint import pprint
from cStringIO import StringIO
import re
from urlparse import urlsplit

# set up classes for yaml parser
class fragment:
    ''' an inline fragment which contains data and a template
    '''
    def __init__(self, node):
        self.template = node.get('template',None)
        self.locals = node.get('local',{})
        self.globals = node.get('global',{})
        self.file = node.get('file',None)

    def __repr__(self):
        s = StringIO()
        try:
            pprint({'template':self.template,'globals':self.globals,'locals':self.locals},s,4,10)
        except TypeError:
            pprint({'template':self.template,'globals':self.globals,'locals':self.locals},s)
        return s.getvalue()

    def __eq__(self,other):
        if self.template == other.template and \
           self.locals == other.locals and \
           self.globals == other.globals and \
           self.file == other.file:
            return True
        else:
            return False

    def __ne__(self,other):
        if self.template == other.template and \
           self.locals == other.locals and \
           self.globals == other.globals and \
           self.file == other.file:
            return False
        else:
            return True

class fragmentFile:
    ''' A file fragment which points at another yaml file
    '''
    def __init__(self, node):
        self.file = node

    def __repr__(self):
        s = StringIO()
        try:
            pprint({'file':self.file},s,4,10)
        except TypeError:
            pprint({'file':self.file},s)
        return s.getvalue()

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

    def __ne__(self,other):
        return self.file != other.file

def fragmentConstructor(node):
    try:
        if node.keys():
            return fragment(node)
    except AttributeError:
        return fragmentFile(node)


class rest(str):
    ''' a rest string for converting to html
    '''
    pass

class restfile(str):
    ''' a rest file for converting to html
    '''
    pass

class html(str):
    ''' a html block for converting to html
    '''
    pass

class htmlfile(str):
    ''' a html file for converting to html
    '''
    pass

class htfile(str):
    ''' a ht file for converting to html
    '''
    pass

class wikiurl(str):
    ''' a ht file for converting to html
    '''
    pass

class htfiledata:
    ''' a ht file for converting to ht file datafile and key
    '''
    def __init__(self,node):
        self.file = node['file']
        self.key = node.get('key',None)

    def __repr__(self):
        return '<htfiledata: file=%s, key=%s>'%(self.file,self.key)

    def __eq__(self,other):
        return self.file == other.file and self.key == other.key

    def __ne__(self,other):
        return self.file != other.file or self.key != other.key

class restfiledata:
    ''' a ht file for converting to ht file datafile and key
    '''
    def __init__(self,node):
        self.file = node['file']
        self.key = node.get('key',None)

    def __repr__(self):
        return '<htfiledata: file=%s, key=%s>'%(self.file,self.key)

    def __eq__(self,other):
        return self.file == other.file and self.key == other.key

    def __ne__(self,other):
        return self.file != other.file or self.key != other.key


class rhref(str):
    ''' relative href
    '''
    def __repr__(self):
        return '<rhref %s>' % str.__repr__(self)

class ahref(str):
    ''' absolute href
    '''
    def __repr__(self):
        return '<ahref %s>' % str.__repr__(self)

def url(text):
    ''' Factory to convert a string into a label and href (href is last space delimited item in string)
    '''
    # Split off the last space separated string for the url (rest is label/title)
    t = text.split(' ')
    label = ' '.join(t[:-1])

    # Get the label and possibly the title
    getlabelparts = re.compile('([^{}]*)(?: {(.*)})?$')
    m = getlabelparts.match(label)
    if m:
        label,title = m.groups()
    else:
        title = None
    if title is None:
        title = ''

    # Split the url up to check the prefix and whether it is an absolute url
    url = t[-1]
    urlparts = urlsplit(url)
    if urlparts[0] != '' or urlparts[2].startswith('/'):
        url = ahref(url)
    else:
        url = rhref(url)

    return {'href': url, 'label': label, 'title': title}

def linktree(node):
    ''' nav directive creates a tree of data/children nodes from an indented list of strings
    '''
    return utils.parseIndentedList(node,url)

class sectionnav(list):
    ''' section navigation (inherited)
    '''
    def __init__(self, node):
        list.__init__(self)
        self.extend(utils.parseIndentedList(node,url))


class breadcrumb(str):
    ''' a marker for the breadcrumb renderer
    '''
    def __init__(self,node):
        fields = node.split()
        self.file = fields[0]
        self.name = fields[1]

class acquire(str):
    ''' A marker for for extracting data from another fragment (This may
        cause problems as the target data may not be available at the point of flattening)
    '''
    def __init__(self,node):
        fields = node.split()
        self.file = fields[0]
        self.name = fields[1]
        self.template = ''
    def __repr__(self):
        s = StringIO()
        try:
            pprint({'template':self.template,'file':self.file,'name':self.name},s,4,10)
        except TypeError:
            pprint({'template':self.template,'file':self.file,'name':self.name},s)
        return s.getvalue()

def pathconstruct(pathstring):
    return path(pathstring)


def context(node):
    return core.Context(node)

class Loader(syck.Loader):

    __constructs = {}

    def register_construct(cls, func, name, tld=None, year=None):
        if tld is not None:
            tld = str(tld)
        if year is not None:
            year = int(year)
        cls.__constructs[(tld,year,name)] = func

    register_construct = classmethod(register_construct)

    def construct(self, node):
        if node.tag is not None:
            parts = node.tag.split(':',2)
            if parts[0] == 'tag':
                tld, year = parts[1].split(',')
                year = int(year)
                name = parts[2]
            if parts[0] == 'x-private':
                tld = None
                year = None
                name = parts[1]

            if tld or year or name:
                construct = self.__constructs.get((tld,year,name))
                if construct is not None:
                    return construct(node.value)
        return syck.Loader.construct(self, node)

# Set up type registry
_typeRegistry = {
    ('yaml.org','2002','fragment'): fragmentConstructor,
    ('yaml.org','2002','rest'): rest,
    ('yaml.org','2002','restfile'): restfile,
    ('yaml.org','2002','url'): url,
    ('yaml.org','2002','linktree'): linktree,
    ('yaml.org','2002','sectionnav'): sectionnav,
    ('yaml.org','2002','breadcrumb'): breadcrumb,
    ('yaml.org','2002','acquire'): acquire,
    ('yaml.org','2002','html'): html,
    ('yaml.org','2002','htmlfile'): htmlfile,
    ('yaml.org','2002','htfile'): htfile,
    ('yaml.org','2002','htfiledata'): htfiledata,
    ('yaml.org','2002','restfiledata'): restfiledata,
    ('yaml.org','2002','wikiurl'): wikiurl,
    ('python.yaml.org','2002','object:pyramid.path.path'): pathconstruct,
    ('python.yaml.org','2002','object:pyramid.core.Context'): context,
}

for vartype, factory in _typeRegistry.items():
    Loader.register_construct(factory, vartype[2],tld=vartype[0],year=vartype[1])