Exemplo n.º 1
0
    def paginate(self):

        X = type('X', (str, ), {'modified': True})
        refs.load()

        res = ['1', 'asd', 'asd123', 'egg', 'spam', 'ham', '3.14', '42']
        res = [X(val) for val in res]

        # default stuff
        assert list(helpers.paginate(res, 4)) == \
            [((None, 1, 2), res[:4], True), ((1, 2, None), res[4:], True)]
        assert list(helpers.paginate(res, 7)) == \
            [((None, 1, 2), res[:7], True), ((1, 2, None), res[7:], True)]

        # with orphans
        assert list(helpers.paginate(res, 7, orphans=1)) == \
            [((None, 1, None), res, True)]
        assert list(helpers.paginate(res, 6, orphans=1)) == \
            [((None, 1, 2), res[:6], True), ((1, 2, None), res[6:], True)]

        # a real world example which has previously failed
        res = [X(_) for _ in range(20)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, None), res[10:], True)]

        res = [X(_) for _ in range(21)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, 3), res[10:20], True),
             ((2, 3, None), res[20:], True)]

        # edge cases
        assert list(helpers.paginate([], 2)) == []
        assert list(helpers.paginate([], 2, orphans=7)) == []
        assert list(helpers.paginate([X('1'), X('2'), X('3')], 3, orphans=1)) == \
            [((None, 1, None), [X('1'), X('2'), X('3')], True)]
Exemplo n.º 2
0
    def paginate(self):

        X = type('X', (str, ), {'modified': True}); refs.load()

        res = ['1', 'asd', 'asd123', 'egg', 'spam', 'ham', '3.14', '42']
        res = [X(val) for val in res]

        # default stuff
        assert list(helpers.paginate(res, 4)) == \
            [((None, 1, 2), res[:4], True), ((1, 2, None), res[4:], True)]
        assert list(helpers.paginate(res, 7)) == \
            [((None, 1, 2), res[:7], True), ((1, 2, None), res[7:], True)]

        # with orphans
        assert list(helpers.paginate(res, 7, orphans=1)) == \
            [((None, 1, None), res, True)]
        assert list(helpers.paginate(res, 6, orphans=1)) == \
            [((None, 1, 2), res[:6], True), ((1, 2, None), res[6:], True)]

        # a real world example which has previously failed
        res = [X(_) for _ in range(20)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, None), res[10:], True)]

        res = [X(_) for _ in range(21)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, 3), res[10:20], True),
             ((2, 3, None), res[20:], True)]

        # edge cases
        assert list(helpers.paginate([], 2)) == []
        assert list(helpers.paginate([], 2, orphans=7)) == []
        assert list(helpers.paginate([X('1'), X('2'), X('3')], 3, orphans=1)) == \
            [((None, 1, None), [X('1'), X('2'), X('3')], True)]
Exemplo n.º 3
0
    def generate(self, request):
        """Creates nicely paged listing of your posts.  First page is the
        index.hml used to have this nice url: http://yourblog.com/ with a recent
        list of your (e.g. summarized) Posts. Other pages are enumerated to /page/n+1
        """

        ipp = self.items_per_page
        tt = self.env.jinja2.get_template('main.html')

        entrylist = [entry for entry in request['entrylist'] if not entry.draft]
        paginator = paginate(entrylist, ipp, orphans=self.conf['default_orphans'])

        for (next, curr, prev), entries, has_changed in paginator:
            # curr = current page, next = newer pages, prev = older pages

            if next is not None:
                next = self.path.rstrip('/') if next == 1 \
                           else expand(self.pagination, {'num': next})

            curr = self.path if curr == 1 else expand(self.pagination, {'num': curr})
            prev = None if prev is None else expand(self.pagination, {'num': prev})
            path = joinurl(self.conf['output_dir'], curr, 'index.html')

            if exists(path) and not has_changed and not tt.has_changed:
                event.skip(path)
                continue

            html = tt.render(conf=self.conf, env=union(self.env, entrylist=entries,
                                  type='index', prev=prev, curr=curr, next=next,
                                  items_per_page=ipp, num_entries=len(entrylist)))

            yield html, path
Exemplo n.º 4
0
    def generate(self, conf, env, data):

        ipp = self.items_per_page
        tt = env.engine.fromfile(self.template)

        entrylist = data['entrylist']
        paginator = paginate(entrylist, ipp, self.path, conf.default_orphans)
        route = self.path

        for (next, curr, prev), entries, modified in paginator:
            # curr = current page, next = newer pages, prev = older pages

            next = None if next is None \
                else link(u'« Next', self.path.rstrip('/')) if next == 1 \
                    else link(u'« Next', expand(self.pagination, {'num': next}))

            curr = link(curr, self.path) if curr == 1 \
                else link(expand(self.pagination, {'num': curr}))

            prev = None if prev is None \
               else link(u'Previous »', expand(self.pagination, {'num': prev}))

            path = joinurl(conf['output_dir'], curr.href, 'index.html')

            if isfile(path) and not (modified or tt.modified or env.modified or conf.modified):
                event.skip(path)
                continue

            html = tt.render(conf=conf, env=union(env, entrylist=entries,
                                  type='index', prev=prev, curr=curr, next=next,
                                  items_per_page=ipp, num_entries=len(entrylist), route=route))
            yield html, path
Exemplo n.º 5
0
    def generate(self, request):

        ipp = self.items_per_page
        tt = self.env.engine.fromfile(self.template)

        entrylist = [entry for entry in request['entrylist'] if not entry.draft]
        paginator = paginate(entrylist, ipp, orphans=self.conf['default_orphans'])
        route = self.path

        for (next, curr, prev), entries, has_changed in paginator:
            # curr = current page, next = newer pages, prev = older pages

            next = None if next is None \
                else link(u'« Next', self.path.rstrip('/')) if next == 1 \
                    else link(u'« Next', expand(self.pagination, {'num': next}))

            curr = link(curr, self.path) if curr == 1 \
                else link(expand(self.pagination, {'num': curr}))

            prev = None if prev is None \
               else link(u'Previous »', expand(self.pagination, {'num': prev}))

            path = joinurl(self.conf['output_dir'], curr.href, 'index.html')

            if exists(path) and not has_changed and not tt.has_changed:
                event.skip(path)
                continue

            html = tt.render(conf=self.conf, env=union(self.env, entrylist=entries,
                                  type='index', prev=prev, curr=curr, next=next,
                                  items_per_page=ipp, num_entries=len(entrylist), route=route))

            yield html, path
Exemplo n.º 6
0
    def generate(self, conf, env, data, **kwargs):

        if self.pagination is None:
            self.items_per_page = 2**32
            self.pagination = self.path

        ipp = self.items_per_page
        tt = env.engine.fromfile(env, self.template)

        route = expand(self.path, kwargs)
        entrylist = data['entrylist']
        paginator = paginate(entrylist, ipp, route, conf.default_orphans)

        for (next, curr, prev), entrylist, modified in paginator:

            next = None if next is None \
                else link(u'Next', expand(self.path, kwargs)) if next == 1 \
                    else link(u'Next', expand(self.pagination, union({'num': next}, kwargs)))

            curr = link(curr, expand(self.path, kwargs)) if curr == 1 \
                else link(curr, expand(self.pagination, union({'num': curr}, kwargs)))

            prev = None if prev is None \
               else link(u'Previous', expand(self.pagination, union({'num': prev}, kwargs)))

            path = joinurl(conf['output_dir'], curr.href)

            if isfile(path) and not (modified or tt.modified or env.modified or conf.modified):
                event.skip(self.__class__.__name__.lower(), path)
                continue

            html = self.render(conf, env, union(locals(), kwargs))
            yield html, path
Exemplo n.º 7
0
    def generate(self, request):
        """Creates paged listing by tag."""

        ipp = self.items_per_page
        tt = self.env.engine.fromfile(self.template)

        for tag in self.tags:

            entrylist = [entry for entry in self.tags[tag]]
            paginator = paginate(entrylist, ipp, salt=tag, orphans=self.conf["default_orphans"])
            route = expand(self.path, {"name": tag}).rstrip("/")

            for (next, curr, prev), entries, has_changed in paginator:

                # e.g.: curr = /page/3, next = /page/2, prev = /page/4

                next = (
                    None
                    if next is None
                    else link(u"« Next", expand(self.path, {"name": tag}).rstrip("/"))
                    if next == 1
                    else link(u"« Next", expand(self.pagination, {"name": tag, "num": next}))
                )

                curr = (
                    link(curr, expand(self.path, {"name": tag}))
                    if curr == 1
                    else link(expand(self.pagination, {"num": curr, "name": tag}))
                )

                prev = (
                    None if prev is None else link(u"Previous »", expand(self.pagination, {"name": tag, "num": prev}))
                )

                path = joinurl(self.conf["output_dir"], curr, "index.html")

                if exists(path) and not has_changed and not tt.has_changed:
                    event.skip(path)
                    continue

                html = tt.render(
                    conf=self.conf,
                    env=union(
                        self.env,
                        entrylist=entries,
                        type="tag",
                        prev=prev,
                        curr=curr,
                        next=next,
                        tag=tag,
                        items_per_page=ipp,
                        num_entries=len(entrylist),
                        route=route,
                    ),
                )

                yield html, path
Exemplo n.º 8
0
    def generate(self, request):
        """Creates paged listing by tag."""

        ipp = self.items_per_page
        tt = self.env.engine.fromfile(self.template)

        entrylist = [
            entry for entry in request['entrylist'] if not entry.draft
        ]

        for tag in self.tags:

            entrylist = [entry for entry in self.tags[tag]]
            paginator = paginate(entrylist,
                                 ipp,
                                 salt=tag,
                                 orphans=self.conf['default_orphans'])
            route = expand(self.path, {'name': tag}).rstrip('/')

            for (next, curr, prev), entries, has_changed in paginator:

                # e.g.: curr = /page/3, next = /page/2, prev = /page/4

                next = None if next is None \
                else link(u'« Next', expand(self.path, {'name': tag}).rstrip('/')) if next == 1 \
                    else link(u'« Next', expand(self.pagination, {'name': tag, 'num': next}))

                curr = link(curr, expand(self.path, {'name': tag})) if curr == 1 \
                    else link(expand(self.pagination, {'num': curr, 'name': tag}))

                prev = None if prev is None \
                    else link(u'Previous »', expand(self.pagination, {'name': tag, 'num': prev}))

                path = joinurl(self.conf['output_dir'], curr, 'index.html')

                if exists(path) and not has_changed and not tt.has_changed:
                    event.skip(path)
                    continue

                html = tt.render(conf=self.conf,
                                 env=union(self.env,
                                           entrylist=entries,
                                           type='tag',
                                           prev=prev,
                                           curr=curr,
                                           next=next,
                                           tag=tag,
                                           items_per_page=ipp,
                                           num_entries=len(entrylist),
                                           route=route))

                yield html, path
Exemplo n.º 9
0
    def test_paginate(self):

        class X(str):
            # dummy class
            has_changed = True
            md5 = property(lambda x: str(hash(x)))

        res = ['1', 'asd', 'asd123', 'egg', 'spam', 'ham', '3.14', '42']
        res = [X(val) for val in res]

        # default stuff
        self.assertEqual(list(helpers.paginate(res, 4)),
            [((None, 1, 2), res[:4], True), ((1, 2, None), res[4:], True)])
        self.assertEqual(list(helpers.paginate(res, 4, lambda x: x.isdigit())),
            [((None, 1, None), [X('1'), X('42')], True), ])
        self.assertEqual(list(helpers.paginate(res, 7)),
            [((None, 1, 2), res[:7], True), ((1, 2, None), res[7:], True)])

        # with orphans
        self.assertEqual(list(helpers.paginate(res, 7, orphans=1)),
            [((None, 1, None), res, True)])
        self.assertEqual(list(helpers.paginate(res, 6, orphans=1)),
            [((None, 1, 2), res[:6], True), ((1, 2, None), res[6:], True)])

        # a real world example which has previously failed
        res = [X(_) for _ in range(20)]
        self.assertEqual(list(helpers.paginate(res, 10)),
            [((None, 1, 2), res[:10], True), ((1, 2, None), res[10:], True)])

        res = [X(_) for _ in range(21)]
        self.assertEqual(list(helpers.paginate(res, 10)),
            [((None, 1, 2), res[:10], True), ((1, 2, 3), res[10:20], True),
             ((2, 3, None), res[20:], True)])

        # edge cases
        self.assertEqual(list(helpers.paginate([], 2)), [])
        self.assertEqual(list(helpers.paginate([], 2, orphans=7)), [])
        self.assertEqual(list(helpers.paginate([X('1'), X('2'), X('3')], 3, orphans=1)),
            [((None, 1, None), [X('1'), X('2'), X('3')], True)])
Exemplo n.º 10
0
    def generate(self, conf, env, data):
        for lang in env.langs:
            ipp = self.items_per_page
            tt = env.engine.fromfile(self.template)

            entrylist = []
            for entry in data['entrylist']:
                try:
                    e = entry_for_lang(data, lang, entry)
                    entrylist.append(e)
                except TranslationNotFound:
                    pass#entrylist.append(entry)

            paginator = paginate(entrylist, ipp, self.path, conf.default_orphans)
            route = '/blog/'

            for (next, curr, prev), entries, modified in paginator:
                # curr = current page, next = newer pages, prev = older pages

                if next is None:
                    pass
                elif next == 1:
                    next = link(u'« Next', expand(self.path.rstrip('/'), {'lang':lang}))
                else:
                    next = link(u'« Next', expand(self.pagination, {'num': next,'lang': lang}))

                if next:
                    next.href = strip_default_lang(next.href, self.conf)

                curr = link(curr, self.path) if curr == 1 \
                    else link(expand(self.pagination, {'num': curr,'lang': lang}))
                curr.href = strip_default_lang(curr.href, self.conf)

                prev = None if prev is None \
                   else link(u'Previous »', expand(self.pagination, {'num': prev,'lang': lang}))
                if prev:
                    prev.href = strip_default_lang(prev.href, self.conf)

                path = joinurl(conf['output_dir'], expand(curr.href, {'lang': lang}), 'index.html')
                path = strip_default_lang(path, self.conf)
                env['lang'] = lang
                env['active_route'] = route

                if isfile(path) and not (modified or tt.modified or env.modified or conf.modified):
                    event.skip(path)
                    continue

                html = tt.render(conf=conf, env=union(env, entrylist=entries,
                                      type='index', prev=prev, curr=curr, next=next,
                                      items_per_page=ipp, num_entries=len(entrylist), route=route))
                yield html, path
Exemplo n.º 11
0
    def test_paginate(self):
        class X(str):  # dummy class
            has_changed = True
            md5 = property(lambda x: str(hash(x)))

        res = ['1', 'asd', 'asd123', 'egg', 'spam', 'ham', '3.14', '42']
        res = [X(val) for val in res]

        # default stuff
        assert list(helpers.paginate(res, 4)) == \
            [((None, 1, 2), res[:4], True), ((1, 2, None), res[4:], True)]
        assert list(helpers.paginate(res, 4, lambda x: x.isdigit())) == \
            [((None, 1, None), [X('1'), X('42')], True), ]
        assert list(helpers.paginate(res, 7)) == \
            [((None, 1, 2), res[:7], True), ((1, 2, None), res[7:], True)]

        # with orphans
        assert list(helpers.paginate(res, 7, orphans=1)) == \
            [((None, 1, None), res, True)]
        assert list(helpers.paginate(res, 6, orphans=1)) == \
            [((None, 1, 2), res[:6], True), ((1, 2, None), res[6:], True)]

        # a real world example which has previously failed
        res = [X(_) for _ in range(20)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, None), res[10:], True)]

        res = [X(_) for _ in range(21)]
        assert list(helpers.paginate(res, 10)) == \
            [((None, 1, 2), res[:10], True), ((1, 2, 3), res[10:20], True),
             ((2, 3, None), res[20:], True)]

        # edge cases
        assert list(helpers.paginate([], 2)) == []
        assert list(helpers.paginate([], 2, orphans=7)) == []
        assert list(helpers.paginate([X('1'), X('2'), X('3')], 3, orphans=1)) == \
            [((None, 1, None), [X('1'), X('2'), X('3')], True)]
Exemplo n.º 12
0
    def test_paginate(self):
        class X(str):  # dummy class
            has_changed = True
            md5 = property(lambda x: str(hash(x)))

        res = ["1", "asd", "asd123", "egg", "spam", "ham", "3.14", "42"]
        res = [X(val) for val in res]

        # default stuff
        assert list(helpers.paginate(res, 4)) == [((None, 1, 2), res[:4], True), ((1, 2, None), res[4:], True)]
        assert list(helpers.paginate(res, 4, lambda x: x.isdigit())) == [((None, 1, None), [X("1"), X("42")], True)]
        assert list(helpers.paginate(res, 7)) == [((None, 1, 2), res[:7], True), ((1, 2, None), res[7:], True)]

        # with orphans
        assert list(helpers.paginate(res, 7, orphans=1)) == [((None, 1, None), res, True)]
        assert list(helpers.paginate(res, 6, orphans=1)) == [
            ((None, 1, 2), res[:6], True),
            ((1, 2, None), res[6:], True),
        ]

        # a real world example which has previously failed
        res = [X(_) for _ in range(20)]
        assert list(helpers.paginate(res, 10)) == [((None, 1, 2), res[:10], True), ((1, 2, None), res[10:], True)]

        res = [X(_) for _ in range(21)]
        assert list(helpers.paginate(res, 10)) == [
            ((None, 1, 2), res[:10], True),
            ((1, 2, 3), res[10:20], True),
            ((2, 3, None), res[20:], True),
        ]

        # edge cases
        assert list(helpers.paginate([], 2)) == []
        assert list(helpers.paginate([], 2, orphans=7)) == []
        assert list(helpers.paginate([X("1"), X("2"), X("3")], 3, orphans=1)) == [
            ((None, 1, None), [X("1"), X("2"), X("3")], True)
        ]
Exemplo n.º 13
0
    def generate(self, request):

        ipp = self.items_per_page
        tt = self.env.engine.fromfile(self.template)

        entrylist = [
            entry for entry in request['entrylist'] if not entry.draft
        ]
        paginator = paginate(entrylist,
                             ipp,
                             orphans=self.conf['default_orphans'])
        route = self.path

        for (next, curr, prev), entries, has_changed in paginator:
            # curr = current page, next = newer pages, prev = older pages

            next = None if next is None \
                else link(u'« Next', self.path.rstrip('/')) if next == 1 \
                    else link(u'« Next', expand(self.pagination, {'num': next}))

            curr = link(curr, self.path) if curr == 1 \
                else link(expand(self.pagination, {'num': curr}))

            prev = None if prev is None \
               else link(u'Previous »', expand(self.pagination, {'num': prev}))

            path = joinurl(self.conf['output_dir'], curr.href, 'index.html')

            if exists(path) and not has_changed and not tt.has_changed:
                event.skip(path)
                continue

            html = tt.render(conf=self.conf,
                             env=union(self.env,
                                       entrylist=entries,
                                       type='index',
                                       prev=prev,
                                       curr=curr,
                                       next=next,
                                       items_per_page=ipp,
                                       num_entries=len(entrylist),
                                       route=route))

            yield html, path
Exemplo n.º 14
0
    def generate(self, request):
        """Creates paged listing by tag."""

        ipp = self.items_per_page
        tt = self.env.jinja2.get_template('main.html')

        entrylist = [entry for entry in request['entrylist'] if not entry.draft]

        for tag in self.tags:

            entrylist = [entry for entry in self.tags[tag]]
            paginator = paginate(entrylist, ipp, salt=tag, orphans=self.conf['default_orphans'])

            for (next, curr, prev), entries, has_changed in paginator:

                # e.g.: curr = /page/3, next = /page/2, prev = /page/4

                if next == 1:
                    next = expand(self.path, {'name': tag}).rstrip('/')
                elif next > 1:
                    next = expand(self.pagination, {'name': tag, 'num': next})

                if curr == 1:
                    curr = expand(self.path, {'name': tag})
                elif curr > 1:
                    curr = expand(self.pagination, {'num': curr, 'name': tag})

                if prev is not None:
                    prev = expand(self.pagination, {'name': tag, 'num': prev})

                path = joinurl(self.conf['output_dir'], curr, 'index.html')

                if exists(path) and not has_changed and not tt.has_changed:
                    event.skip(path)
                    continue

                html = tt.render(conf=self.conf, env=union(self.env, entrylist=entries,
                                type='tag', prev=prev, curr=curr, next=next,
                                items_per_page=ipp, num_entries=len(entrylist)))

                yield html, path
Exemplo n.º 15
0
    def generate(self, request):
        """Creates paged listing by tag."""

        ipp = self.items_per_page
        tt = self.env.engine.fromfile(self.template)

        entrylist = [entry for entry in request['entrylist'] if not entry.draft]

        for tag in self.tags:

            entrylist = [entry for entry in self.tags[tag]]
            paginator = paginate(entrylist, ipp, salt=tag, orphans=self.conf['default_orphans'])
            route = expand(self.path, {'name': tag}).rstrip('/')

            for (next, curr, prev), entries, has_changed in paginator:

                # e.g.: curr = /page/3, next = /page/2, prev = /page/4

                next = None if next is None \
                else link(u'« Next', expand(self.path, {'name': tag}).rstrip('/')) if next == 1 \
                    else link(u'« Next', expand(self.pagination, {'name': tag, 'num': next}))

                curr = link(curr, expand(self.path, {'name': tag})) if curr == 1 \
                    else link(expand(self.pagination, {'num': curr, 'name': tag}))

                prev = None if prev is None \
                    else link(u'Previous »', expand(self.pagination, {'name': tag, 'num': prev}))

                path = joinurl(self.conf['output_dir'], curr, 'index.html')

                if exists(path) and not has_changed and not tt.has_changed:
                    event.skip(path)
                    continue

                html = tt.render(conf=self.conf, env=union(self.env, entrylist=entries,
                                type='tag', prev=prev, curr=curr, next=next, tag=tag,
                                items_per_page=ipp, num_entries=len(entrylist), route=route))

                yield html, path
Exemplo n.º 16
0
    def generate(self, conf, env, data):
        """Creates paged listing by tag."""

        ipp = self.items_per_page
        tt = env.engine.fromfile(self.template)

        for tag in self.tags:

            route = expand(self.path, {'name': tag}).rstrip('/')
            entrylist = [entry for entry in self.tags[tag]]
            paginator = paginate(entrylist, ipp, route, conf['default_orphans'])

            for (next, curr, prev), entries, modified in paginator:

                # e.g.: curr = /page/3, next = /page/2, prev = /page/4

                next = None if next is None \
                else link(u'Next', expand(self.path, {'name': tag}).rstrip('/')) if next == 1 \
                    else link(u'Next', expand(self.pagination, {'name': tag, 'num': next}))

                curr = link(curr, expand(self.path, {'name': tag})) if curr == 1 \
                    else link(expand(self.pagination, {'num': curr, 'name': tag}))

                prev = None if prev is None \
                    else link(u'Previous', expand(self.pagination, {'name': tag, 'num': prev}))

                path = joinurl(conf['output_dir'], curr)

                if isfile(path) and not (modified or tt.modified or env.modified or conf.modified):
                    event.skip('tag', path)
                    continue

                html = tt.render(conf=conf, env=union(env, entrylist=entries,
                                type='tag', prev=prev, curr=curr, next=next, tag=tag,
                                items_per_page=ipp, num_entries=len(entrylist), route=route))

                yield html, path