예제 #1
0
 def render_try_finally(self, md):
     result = ''
     # first try to render the first block
     try:
         result = render_blocks(self.section, md)
     # Then handle finally block
     finally:
         result = result + render_blocks(self.finallyBlock, md)
     return result
예제 #2
0
 def render(self, md):
     d = {}
     md._push(d)
     try:
         for name,expr in self.args:
             if isinstance(expr, StringType):
                 d[name] = md[expr]
             else:
                 d[name] = expr(md)
         return render_blocks(self.section, md)
     finally:
         md._pop(1)
예제 #3
0
    def render_try_except(self, md):
        result = ''

        # first we try to render the first block
        try:
            result = render_blocks(self.section, md)
        except DTReturn:
            raise
        except:
            # but an error occurs.. save the info.
            t, v = sys.exc_info()[:2]
            if isinstance(t, StringType):
                errname = t
            else:
                errname = t.__name__

            handler = self.find_handler(t)

            if handler is None:
                # we didn't find a handler, so reraise the error
                raise

            # found the handler block, now render it
            try:
                f = StringIO()
                traceback.print_exc(100,f)
                error_tb = f.getvalue()
                ns = md.namespace(error_type=errname, error_value=v,
                    error_tb=error_tb)[0]
                md._push_instance(ns)
                return render_blocks(handler, md)
            finally:
                md._pop(1)

        else:
            # No errors have occurred, render the optional else block
            if (self.elseBlock is None):
                return result
            else:
                return result + render_blocks(self.elseBlock, md)
예제 #4
0
    def render(self, md):
        expr = self.expr
        if expr is None:
            t = self.__name__
            if t[-5:] == 'Error' and __builtins__.has_key(t):
                t = __builtins__[t]
        else:
            try:
                t = expr.eval(md)
            except:
                t = 'Invalid Error Type Expression'

        try:
            v = render_blocks(self.section,md)
        except:
            v = 'Invalid Error Value'

        raise t(v)
예제 #5
0
    def render(self, md):
        expr = self.expr
        if isinstance(expr, StringTypes):
            v = md[expr]
        else:
            v = expr(md)

        if self.only:
            _md = md
            md = md.__class__()
            if hasattr(_md, 'validate'):
                md.validate = _md.validate

        if self.mapping:
            md._push(v)
        else:
            if isinstance(v, TupleType) and len(v) == 1:
                v = v[0]
            md._push_instance(v)

        try:
            return render_blocks(self.section, md)
        finally:
            md._pop(1)
예제 #6
0
    def renderwob(self, md):
        """RENDER WithOutBatch"""
        expr = self.expr
        name = self.__name__
        if expr is None:
            sequence = md[name]
            cache = {name: sequence }
        else:
            sequence = expr(md)
            cache = None

        if not sequence:
            if self.elses:
                return render_blocks(self.elses, md)
            return ''

        if isinstance(sequence, StringType):
            raise InError('Strings are not allowed as input to the in tag.')

        section = self.section
        mapping = self.mapping


        if self.sort_expr is not None:
            self.sort = self.sort_expr.eval(md)
            sequence = self.sort_sequence(sequence)
        elif self.sort is not None:
            sequence = self.sort_sequence(sequence)

        if self.reverse_expr is not None and self.reverse_expr.eval(md):
            sequence = self.reverse_sequence(sequence)
        elif self.reverse is not None:
            sequence = self.reverse_sequence(sequence)

        vars = sequence_variables(sequence)
        kw = vars.data
        kw['mapping'] = mapping

        l = len(sequence)
        last = l - 1

        push = md._push
        pop = md._pop
        render = render_blocks
        get = self.args.get

        if cache:
            push(cache)
        push(vars)
        try:
            result = []
            append = result.append
            validate = md.validate
            for index in range(l):
                if index == last:
                    kw['sequence-end'] = 1
                client = sequence[index]

                if validate is not None:
                    try:
                        vv = validate(sequence, sequence, None, client, md)
                    except:
                        vv = 0
                    if not vv:
                        if get('skip_unauthorized'):
                            if index == 1:
                                kw['sequence-start'] = 0
                            continue
                        raise ValidationError(index)

                kw['sequence-index'] = index
                if isinstance(client, TupleType) and len(client) == 2:
                    client = client[1]

                if mapping:
                    push(client)
                else:
                    md._push_instance(client)

                try:
                    append(render(section, md))
                finally:
                    pop()
                if index == 0:
                    kw['sequence-start'] = 0

            result = ''.join(result)

        finally:
            if cache:
                pop()
            pop()

        return result
예제 #7
0
    def renderwb(self, md):
        expr = self.expr
        name = self.__name__
        if expr is None:
            sequence = md[name]
            cache = {name: sequence }
        else:
            sequence = expr(md)
            cache = None

        if not sequence:
            if self.elses:
                return render_blocks(self.elses, md)
            return ''

        if isinstance(sequence, StringType):
            raise InError('Strings are not allowed as input to the in tag.')


        section = self.section
        params = self.args

        mapping = self.mapping

        if self.sort_expr is not None:
            self.sort = self.sort_expr.eval(md)
            sequence = self.sort_sequence(sequence)
        elif self.sort is not None:
            sequence = self.sort_sequence(sequence)

        if self.reverse_expr is not None and self.reverse_expr.eval(md):
            sequence = self.reverse_sequence(sequence)
        elif self.reverse is not None:
            sequence = self.reverse_sequence(sequence)

        next = previous = 0
        try:
            start = int_param(params, md, 'start', 0)
        except:
            start=1
        end = int_param(params, md, 'end', 0)
        size = int_param(params, md, 'size', 0)
        overlap = int_param(params, md, 'overlap', 0)
        orphan = int_param(params, md, 'orphan', '3')
        start, end, sz = opt(start, end, size, orphan, sequence)
        if params.has_key('next'):
            next = 1
        if params.has_key('previous'):
            previous = 1

        last = end - 1
        first = start - 1

        try:
            query_string = md['QUERY_STRING']
        except:
            query_string = ''

        vars = sequence_variables(sequence,'?' + query_string,
                                  self.start_name_re)
        kw = vars.data
        kw['mapping'] = mapping
        kw['sequence-step-size'] = sz
        kw['sequence-step-overlap'] = overlap
        kw['sequence-step-start'] = start
        kw['sequence-step-end'] = end
        kw['sequence-step-start-index'] = start - 1
        kw['sequence-step-end-index'] = end - 1
        kw['sequence-step-orphan'] = orphan

        push = md._push
        pop = md._pop
        render = render_blocks

        if cache:
            push(cache)
        push(vars)
        try:
            if previous:
                if first > 0:
                    pstart, pend, psize = opt(0, first+overlap,
                                              sz, orphan, sequence)
                    kw['previous-sequence'] = 1
                    kw['previous-sequence-start-index'] = pstart - 1
                    kw['previous-sequence-end-index'] = pend - 1
                    kw['previous-sequence-size'] = pend + 1 - pstart
                    result=render(section,md)

                elif self.elses:
                    result = render(self.elses, md)
                else:
                    result = ''
            elif next:
                try:
                    # The following line is a sneaky way to test whether
                    # there are more items, without actually
                    # computing a length:
                    sequence[end]
                except IndexError:
                    if self.elses:
                        result = render(self.elses, md)
                    else:
                        result = ''
                else:
                    pstart, pend, psize = opt(end+1-overlap, 0,
                                              sz, orphan, sequence)
                    kw['next-sequence'] = 1
                    kw['next-sequence-start-index'] = pstart - 1
                    kw['next-sequence-end-index'] = pend - 1
                    kw['next-sequence-size'] = pend + 1 - pstart
                    result = render(section, md)
            else:
                result = []
                append = result.append
                validate = md.validate
                for index in range(first,end):
                    # preset
                    kw['previous-sequence'] = 0
                    # now more often defined then previously
                    kw['next-sequence'] = 0

                    if index==first or index==last:
                        # provide batching information
                        if first > 0:
                            pstart, pend, psize = opt(0, first + overlap,
                                                      sz, orphan, sequence)
                            if index == first:
                                kw['previous-sequence'] = 1
                            kw['previous-sequence-start-index'] = pstart - 1
                            kw['previous-sequence-end-index'] = pend - 1
                            kw['previous-sequence-size'] = pend + 1 - pstart
                        try:
                            # The following line is a sneaky way to
                            # test whether there are more items,
                            # without actually computing a length:
                            sequence[end]
                            pstart, pend, psize = opt(end + 1 - overlap, 0,
                                                      sz, orphan, sequence)
                            if index == last:
                                kw['next-sequence'] = 1
                            kw['next-sequence-start-index'] = pstart - 1
                            kw['next-sequence-end-index'] = pend - 1
                            kw['next-sequence-size'] = pend + 1 - pstart
                        except:
                            pass

                    if index == last:
                        kw['sequence-end'] = 1

                    client = sequence[index]

                    if validate is not None:
                        try:
                            vv = validate(sequence, sequence, None, client,md)
                        except:
                            vv = 0
                        if not vv:
                            if (params.has_key('skip_unauthorized') and
                                params['skip_unauthorized']):
                                if index == first:
                                    kw['sequence-start'] = 0
                                continue
                            raise ValidationError(index)

                    kw['sequence-index'] = index
                    if isinstance(client, TupleType) and len(client) == 2:
                        client = client[1]

                    if mapping:
                        push(client)
                    else:
                        md._push_instance(client)

                    try:
                        append(render(section, md))
                    finally:
                        pop(1)

                    if index == first:
                        kw['sequence-start'] = 0

                result = ''.join(result)

        finally:
            if cache:
                pop()
            pop()

        return result
예제 #8
0
    def __call__(self, client=None, mapping={}, **kw):
        """\
        Generate a document from a document template.

        The document will be generated by inserting values into the
        format string specified when the document template was
        created.  Values are inserted using standard python named
        string formats.

        The optional argument 'client' is used to specify a object
        containing values to be looked up.  Values will be looked up
        using getattr, so inheritence of values is supported.  Note
        that names beginning with '_' will not be looked up from the
        client.

        The optional argument, 'mapping' is used to specify a mapping
        object containing values to be inserted.

        Values to be inserted may also be specified using keyword
        arguments.

        Values will be inserted from one of several sources.  The
        sources, in the order in which they are consulted, are:

          o  Keyword arguments,

          o  The 'client' argument,

          o  The 'mapping' argument,

          o  The keyword arguments provided when the object was
             created, and

          o  The 'mapping' argument provided when the template was
             created.

        """
        # print '============================================================'
        # print '__called__'
        # print self.raw
        # print kw
        # print client
        # print mapping
        # print '============================================================'

        if mapping is None:
            mapping = {}

        if not hasattr(self, "_v_cooked"):
            try:
                changed = self.__changed__()
            except:
                changed = 1
            self.cook()
            if not changed:
                self.__changed__(0)

        pushed = None
        try:
            if isinstance(mapping, self.TemplateDict):
                pushed = 0
        except:
            pass

        globals = self.globals
        if pushed is not None:
            # We were passed a TemplateDict, so we must be a sub-template
            md = mapping
            push = md._push
            if globals:
                push(self.globals)
                pushed = pushed + 1
        else:
            md = self.TemplateDict()
            push = md._push
            shared_globals = self.shared_globals
            if shared_globals:
                push(shared_globals)
            if globals:
                push(globals)
            if mapping:
                push(mapping)
            md.validate = self.validate
            if client is not None:
                if isinstance(client, TupleType):
                    md.this = client[-1]
                else:
                    md.this = client
            pushed = 0

        level = md.level
        if level > 200:
            raise SystemError("infinite recursion in document template")
        md.level = level + 1

        if client is not None:
            if isinstance(client, TupleType):
                # if client is a tuple, it represents a "path" of clients
                # which should be pushed onto the md in order.
                for ob in client:
                    md._push_instance(ob)
                    pushed += 1
            else:
                # otherwise its just a normal client object.
                md._push_instance(client)
                pushed += 1

        if self._vars:
            push(self._vars)
            pushed += 1

        if kw:
            push(kw)
            pushed += 1

        try:
            try:
                result = render_blocks(self._v_blocks, md)
            except DTReturn, v:
                result = v.v
            return result