1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

"""
All the functions below are macros in the Creoleparser Sandbox wiki.
Macro names are mapped to each function in the dictionary at the bottom
of this module.
"""


import genshi.builder as bldr
from genshi.filters import HTMLSanitizer
from model import Page

sanitizer = HTMLSanitizer()

def title(macro,environ,*pos,**kw):
    """Return the ``name`` attribute of the page object found in
    ``environ['wiki.metadata_page']``

    """

    return bldr.tag(environ['wiki.metadata_page'].name.replace('_',' '))

def creation_date(macro,environ,*pos,**kw):
    """Return the ``creation_date`` of the page.body in ``environ['wiki.metadata_page']``    """
    
    return bldr.tag(str(environ['wiki.metadata_page'].body.creation_date))

def include(macro,environ,pagename=None,*pos,**kw):
    """Return the parsed content of the page identified by arg_string"""
    
    if pagename is None:
        return None
    page_record = Page.get_by_key_name('-'+pagename)
    if page_record is not None:
        # infinit recursion protection
        if ('include',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id) in environ['wiki.recurse']:
            return bldr.tag.div("<<include %s>> stopped, possible infite \
recursion encountered" % macro.arg_string.strip())
        environ['wiki.recurse'].add(('include',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id))
        environ = environ.copy()
        environ['wiki.metadata_page'] = page_record
        environ['wiki.page'] = page_record
        return environ['wiki.parser'].generate(page_record.body.value,environ=environ)


def transclude(macro,environ,pagename=None,*pos,**kw):
    """Works like ``include`` except that ``environ[metadata_page]`` is set to
       the calling page.

    """

    if pagename is None:
        return None
    page_record = Page.get_by_key_name('-'+pagename)
    if page_record is not None:
        # infinit recursion protection
        if ('transclude',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id) in environ['wiki.recurse']:
            return bldr.tag.div("<<transclude%s>> stopped, possible infite \
recursion encountered" % macro.arg_string)
        environ['wiki.recurse'].add(('transclude',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id))
        environ = environ.copy()
        environ['wiki.metadata_page'] = environ['wiki.page'] 
        environ['wiki.page'] = page_record
        return environ['wiki.parser'].generate(page_record.body.value,environ=environ)


def include_raw(macro,page,pagename=None,*pos,**kw):
    """Return the raw text of the page identified by arg_string, rendered
    in a <pre> block.

    """

    if pagename is None:
        return None
    page = Page.get_by_key_name('-'+pagename)
    if page is not None:
        return bldr.tag.pre(page.body.value,class_='plain')


def include_source(macro,environ,pagename=None,*pos,**kw):
    """Return the parsed text of the page identified by arg_string, rendered
    in a <pre> block.

    """

    if pagename is None:
        return None
    page_record = Page.get_by_key_name('-'+pagename)
    if page_record is not None:
        # infinit recursion protection
        if ('include-source',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id) in environ['wiki.recurse']:
            return bldr.tag.div("<<include-source%s>> stopped, possible infite \
recursion encountered" % macro.arg_string)
        environ['wiki.recurse'].add(('include-source',macro.arg_string,environ['wiki.page'].id,environ['wiki.metadata_page'].id))
        environ = environ.copy()
        environ['wiki.page'] = page_record
        environ['wiki.metadata_page'] = page_record 
        return bldr.tag.pre(environ['wiki.parser'].render(page_record.body.value,environ=environ).decode('utf-8'))


def source(macro,environ,*pos,**kw):
    """Return the parsed text of body, rendered in a <pre> block."""
    
    if macro.body is None:
        return None
    return bldr.tag.pre(environ['wiki.parser'].render(macro.body,environ=environ).decode('utf-8'))


def pre(macro,environ,*pos,**kw):
    """Return the raw text of body, rendered in a <pre> block."""
    
    if macro.body is None:
        return None
    return bldr.tag.pre(macro.body)


def float_div(macro,environ,side='right',style='', *pos,**kw):
    """Return the parsed text of body, rendered in a <div> block. The div element
    gets a a style attribute to float the content right or left, based on the
    arg_string.
    
    """
    
    if macro.body is None:
        return None
    #side = arg_string.strip()
    if side not in ('right','left'):
        return None
    contents = environ['wiki.parser'].generate(macro.body,environ=environ)
    return bldr.tag.div(contents, style='float:'+side+';'+style)


def div(macro,environ,class_=None,id=None,style=None, *pos,**kw):
    """
    
    """
    
    if macro.body is None:
        return None
    if style:
        style = ';'.join(sanitizer.sanitize_css(style))
    if macro.isblock:
        context = 'block'
    else:
        context = 'inline'
    contents = environ['wiki.parser'].generate(macro.body,environ=environ, context=context)
    return bldr.tag.div(contents, id=id, class_=class_,style=style)

def span(macro,environ,class_=None,id=None,style=None, *pos,**kw):
    """
    
    """
    
    if macro.body is None:
        return None
    if style:
        style = ';'.join(sanitizer.sanitize_css(style))
    contents = environ['wiki.parser'].generate(macro.body,environ=environ,context='inline')
    return bldr.tag.span(contents, id=id, class_=class_,style=style)

macros = {'include':include,
          'transclude':transclude,
          'include-raw':include_raw,
          'include-source':include_source,
          'source':source,
          'pre':pre,
          'float':float_div,
          'title':title,
          'creation-date':creation_date,
          'div':div,
          'span':span,
          }