Changeset 3214

Show
Ignore:
Timestamp:
02/12/08 00:13:29 (1 year ago)
Author:
pacopablo
Message:

Beginning of port to 0.11

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • tracblogplugin/trunk/setup.py

    r2399 r3214  
    44 
    55PACKAGE = 'tBlog' 
    6 VERSION = '0.2.2' 
     6VERSION = '0.3' 
    77 
    88setup(  name=PACKAGE, version=VERSION, 
    …… 
    1515        packages = ['tBlog'], 
    1616        package_data = { 'tBlog' : ['htdocs/css/*.css', 'htdocs/img/*', 
    17                                     'templates/*.cs', ]}, 
     17                                    'templates/*.html', ]}, 
    1818        entry_points = {'trac.plugins': ['tBlog = tBlog']}, 
    19         install_requires = ['TracTags>=0.3,<0.5', 'TracWebAdmin'] 
     19        install_requires = ['TracTags>=0.6'] 
    2020) 

  • tracblogplugin/trunk/tBlog/__init__.py

    r596 r3214  
     1import parseargs 
    12from web_ui import * 
    2 try: 
    3     from admin import * 
    4 except ImportError: 
    5     pass 
     3#try: 
     4#    from admin import * 
     5#except ImportError: 
     6#    pass 
    67from new_blog import * 

  • tracblogplugin/trunk/tBlog/new_blog.py

    r1582 r3214  
    11# -*- coding: utf-8 -*- 
    22# 
    3 # Copyright (C) 2006 John Hampton <pacopablo@asylumware.com> 
     3# Copyright (C) 2006-2008 John Hampton <pacopablo@pacopablo.com> 
    44# All rights reserved. 
    55# 
    …… 
    1313# http://trac-hacks.org/wiki/TracBlogPlugin 
    1414# 
    15 # Author: John Hampton <pacopablo@asylumware.com> 
     15# Author: John Hampton <pacopablo@pacopablo.com> 
    1616import os 
    1717import os.path 
    …… 
    2020import re 
    2121from pkg_resources import resource_filename 
     22 
     23from genshi.builder import tag 
     24 
    2225from trac.core import * 
    2326from trac.web import IRequestHandler 
    …… 
    2831from trac.wiki.formatter import wiki_to_html 
    2932from trac.wiki.model import WikiPage 
    30 from tractags.api import TagEngine 
    31 from tractags.parseargs import parseargs 
     33from trac.wiki.macros import WikiMacroBase 
     34from trac.config import Option 
     35from trac.resource import * 
     36 
     37from tBlog.parseargs import parseargs 
     38 
     39#from tractags.api import TagEngine 
     40#from tractags.parseargs import parseargs 
    3241 
    3342__all__ = ['BlogPost'] 
    …… 
    3544_tag_split = re.compile('[,\s]+') 
    3645 
    37 class BlogPost(Component): 
     46class BlogPost(WikiMacroBase): 
    3847    """Inserts a link to create a new blog post 
    3948 
    …… 
    4554    '''blogtitle''' - Default blog entry title.[[br]] 
    4655    '''text''' - Default entry body text.[[br]] 
    47     '''pagename''' - Default wiki page name.[[br]] 
     56    '''page_format''' - Default wiki page name.[[br]] 
    4857    '''readonly''' - Default readonly page status.[[br]] 
    4958    '''link''' - Text to display as the link.[[br]] 
    …… 
    6271               IPermissionRequestor) 
    6372 
     73    page_format = Option('blog', 'page_format', '%Y/%m/%d/%H.%M', doc="Default page naming " 
     74                        "scheme for blog posts.") 
     75 
    6476    # IPermissionRequestor 
    6577    def get_permission_actions(self): 
    6678        return ['BLOG_POSTER'] 
    6779 
    68     # IWikiMacroProvider 
    69     def get_macros(self): 
    70         yield "BlogPost" 
    71  
    72     def get_macro_description(self, name): 
    73         """Return the subclass's docstring.""" 
    74         return inspect.getdoc(self.__class__) 
    75  
    76     def render_macro(self, req, name, content): 
     80    # WikiMacroBase 
     81    def expand_macro(self, formatter, name, content): 
    7782        """ Display the blog in the wiki page """ 
    78         if req.perm.has_permission('BLOG_POSTER'): 
     83        if formatter.perm.has_permission('BLOG_POSTER'): 
    7984            args, kwargs = self._split_macro_args(content) 
    8085            try: 
    …… 
    8489                blog_link = self.env.config.get('blog', 'new_blog_link',  
    8590                                                'New Blog Post') 
    86             return Markup('<a href="%s">%s</a>',  
    87                           self.env.href.blog('new',**kwargs), 
    88                           blog_link) 
     91            return tag.a(blog_link, href=formatter.req.href.blog('new',**kwargs)) 
    8992        return '' 
    9093 
    …… 
    106109        add_stylesheet(req, 'blog/css/blog.css') 
    107110        add_stylesheet(req, 'common/css/wiki.css') 
    108         self._new_blog_post(req) 
    109         referer = req.args.get('referer') or req.get_header('Referer') or self.env.href.blog() 
    110         req.hdf['blog.referer'] = referer 
    111         return 'new_blog.cs', None 
     111#        self._new_blog_post(req) 
     112        referer = req.args.get('referer') or req.get_header('Referer') or req.href.blog() 
     113        data = self._new_blog_post(req) 
     114        data['blog']['referer'] =  referer 
     115        return 'blog_new.html', data, None 
    112116 
    113117    def _new_blog_post(self, req): 
    114         """ Generate a new blog post 
    115  
    116         """ 
     118        """ Generate a new blog post """ 
    117119        action = req.args.get('action', 'edit') 
    118         pg_name_fmt = self.env.config.get('blog', 'page_format',  
    119                                           '%Y/%m/%d/%H.%M') 
    120120        wikitext = req.args.get('text', '') 
    121121        blogtitle = req.args.get('blogtitle', '') 
    122         pagename = req.args.get('pagename', pg_name_fmt)  
    123         pagename = time.strftime(pagename) 
    124         if '%@' in pagename and blogtitle:  
    125             urltitle = re.sub(r'[^\w]+', '-', blogtitle).lower()  
     122        page_format = req.args.get('page_format', self.page_format)  
     123        pagename = self._generate_pagename(page_format, blogtitle, req.authname)  
     124        page = WikiPage(self.env, pagename, None) 
     125 
     126        comment = req.args.get('comment', '') 
     127        readonly = int(req.args.has_key('readonly')) 
     128        edit_rows = int(req.args.get('edit_rows', 20)) 
     129        scroll_bar_pos = req.args.get('scroll_bar_pos', '') 
     130        req_tags = req.args.get('tags', []) 
     131        page_source = page.text 
     132 
     133        title = get_resource_summary(self.env, page.resource) 
     134        if action: 
     135            title += ' (%s)' % action 
     136 
     137        wiki = {'page_name' : pagename, 
     138                'comment' : comment, 
     139                'author' : req.authname, 
     140                'edit_rows' : edit_rows, 
     141                'version' : 0, 
     142                'read_only' : readonly, 
     143                'scroll_bar_pos' : scroll_bar_pos, 
     144                'page_source' : page_source, 
     145                'action' : action, 
     146               } 
     147 
     148        data = {'page' : page, 
     149                'action' : action, 
     150                'title' : title, 
     151                'blog' : {}, 
     152               } 
     153        data.update(wiki) 
     154        return data 
     155         
     156#        if req.method == 'POST': 
     157#            if action == 'edit': 
     158#                if req.args.has_key('cancel'): 
     159#                    referrer = req.args.get('referer') or req.get_header('Referer') or self.env.href.blog() 
     160#                    req.redirect(referrer) 
     161#                page = WikiPage(self.env, pagename, None) 
     162#                tags = TagEngine(self.env).tagspace.wiki 
     163#                if req.args.has_key('preview'): 
     164#                    req.hdf['blog.action'] = 'preview' 
     165#                    self._render_editor(req, page, self.env.get_db_cnx(), 
     166#                                        preview=True)  
     167#                else: 
     168#                    titleline = ' '.join(["=", blogtitle, "=\n"]) 
     169#                    if blogtitle: 
     170#                        page.text = ''.join([titleline, wikitext]) 
     171#                    else: 
     172#                        page.text = wikitext 
     173#                    # Add footer  
     174#                    page.text = page.text.join(["\n\n",self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))])  
     175#                    page.readonly = readonly 
     176#                    page.save(req.authname, comment, req.remote_addr) 
     177#                    taglist = [x.strip() for x in req_tags.split(',') if x] 
     178#                    taglist = [t.strip() for t in  
     179#                               _tag_split.split(req.args.get('tags'))  
     180#                               if t.strip()] 
     181#                    tags.add_tags(req, pagename, taglist) 
     182#                    referrer = req.args.get('referer') or req.get_header('Referer') or self.env.href.blog() 
     183#                    req.redirect(referrer) 
     184#        else: 
     185#            info = { 
     186#                'title' : blogtitle, 
     187#                'pagename': pagename, 
     188#                'page_source': wikitext, 
     189#                'comment': comment, 
     190#                'readonly': readonly, 
     191#                'edit_rows': edit_rows, 
     192#                'scroll_bar_pos': req.args.get('scroll_bar_pos', '') 
     193#            } 
     194#            req.hdf['blog'] = info 
     195#            req.hdf['title'] = 'New Blog Entry' 
     196#            tlist = req.args.getlist('tag') 
     197#            if not tlist: 
     198#                tlist = [self.env.config.get('blog', 'default_tag', 'blog')] 
     199#            req.hdf['tags'] = ', '.join(tlist) 
     200#            pass 
     201 
     202    def _generate_pagename(self, page_format, title, authname): 
     203        """ Generate a page name based on the format specified. 
     204 
     205        All formatting in `time.strftime` is valid along with '%@' for using the blog title 
     206        and '$U' for using the username of the authenticated user. 
     207        """ 
     208 
     209        pagename = time.strftime(page_format) 
     210        if '%@' in pagename and title:  
     211            urltitle = re.sub(r'[^\w]+', '-', title).lower()  
    126212            pagename = pagename.replace('%@', urltitle)  
    127213            while '-' in pagename and len(pagename) > 60:  
    …… 
    129215            pagename = pagename.strip('-') 
    130216        if '$U' in pagename: 
    131             pagename = pagename.replace('$U', req.authname) 
    132         comment = req.args.get('comment', '') 
    133         readonly = int(req.args.has_key('readonly')) 
    134         edit_rows = int(req.args.get('edite_rows', 20)) 
    135         req_tags = req.args.get('tags', []) 
    136          
    137         if req.method == 'POST': 
    138             if action == 'edit': 
    139                 if req.args.has_key('cancel'): 
    140                     referrer = req.args.get('referer') or req.get_header('Referer') or self.env.href.blog() 
    141                     req.redirect(referrer) 
    142                 page = WikiPage(self.env, pagename, None) 
    143                 tags = TagEngine(self.env).tagspace.wiki 
    144                 if req.args.has_key('preview'): 
    145                     req.hdf['blog.action'] = 'preview' 
    146                     self._render_editor(req, page, self.env.get_db_cnx(), 
    147                                         preview=True)  
    148                 else: 
    149                     titleline = ' '.join(["=", blogtitle, "=\n"]) 
    150                     if blogtitle: 
    151                         page.text = ''.join([titleline, wikitext]) 
    152                     else: 
    153                         page.text = wikitext 
    154                     # Add footer  
    155                     page.text = page.text.join(["\n\n",self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))])  
    156                     page.readonly = readonly 
    157                     page.save(req.authname, comment, req.remote_addr) 
    158 #                    taglist = [x.strip() for x in req_tags.split(',') if x] 
    159                     taglist = [t.strip() for t in  
    160                                _tag_split.split(req.args.get('tags'))  
    161                                if t.strip()] 
    162                     tags.add_tags(req, pagename, taglist) 
    163                     referrer = req.args.get('referer') or req.get_header('Referer') or self.env.href.blog() 
    164                     req.redirect(referrer) 
    165         else: 
    166             info = { 
    167                 'title' : blogtitle, 
    168                 'pagename': pagename, 
    169                 'page_source': wikitext, 
    170                 'comment': comment, 
    171                 'readonly': readonly, 
    172                 'edit_rows': edit_rows, 
    173                 'scroll_bar_pos': req.args.get('scroll_bar_pos', '') 
    174             } 
    175             req.hdf['blog'] = info 
    176             req.hdf['title'] = 'New Blog Entry' 
    177             tlist = req.args.getlist('tag') 
    178             if not tlist: 
    179                 tlist = [self.env.config.get('blog', 'default_tag', 'blog')] 
    180             req.hdf['tags'] = ', '.join(tlist) 
    181             pass 
    182  
    183     def _render_editor(self, req, page, db, preview=False): 
    184         blogtitle = req.args.get('blogtitle') 
    185         titleline = ' '.join(["=", blogtitle, "=\n"]) 
    186         if req.args.has_key('text'): 
    187             page.text = req.args.get('text') 
    188         if preview: 
    189             page.readonly = req.args.has_key('readonly') 
    190  
    191         author = req.authname 
    192         comment = req.args.get('comment', '') 
    193         editrows = req.args.get('editrows') 
    194         tags = req.args.get('tags') 
    195         req.hdf['tags'] = tags 
    196         if editrows: 
    197             pref = req.session.get('wiki_editrows', '20') 
    198             if editrows != pref: 
    199                 req.session['wiki_editrows'] = editrows 
    200         else: 
    201             editrows = req.session.get('wiki_editrows', '20') 
    202  
    203         req.hdf['title'] = page.name + ' (edit)' 
    204         info = { 
    205             'title' : blogtitle, 
    206             'pagename': page.name, 
    207             'page_source': page.text, 
    208             'author': author, 
    209             'comment': comment, 
    210             'readonly': page.readonly, 
    211             'edit_rows': editrows, 
    212             'scroll_bar_pos': req.args.get('scroll_bar_pos', '') 
    213         } 
    214         if preview: 
    215             if blogtitle: 
    216                 info['page_html'] = wiki_to_html(''.join([titleline,  
    217                                                  req.args.get('text'),  
    218                                                  "\n\n",self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))]),  
    219                                                 self.env, req, db) 
    220             else: 
    221                 info['page_html'] = wiki_to_html(page.text.join(["\n\n", 
    222                     self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))]),  
    223                                                   self.env,  
    224                                                   req,  
    225                                                   db)  
    226             info['readonly'] = int(req.args.has_key('readonly')) 
    227         req.hdf['blog'] = info 
     217            pagename = pagename.replace('$U', authname) 
     218        return pagename 
     219 
     220#    def _render_editor(self, req, page, db, preview=False): 
     221#        blogtitle = req.args.get('blogtitle') 
     222#        titleline = ' '.join(["=", blogtitle, "=\n"]) 
     223#        if req.args.has_key('text'): 
     224#            page.text = req.args.get('text') 
     225#        if preview: 
     226#            page.readonly = req.args.has_key('readonly') 
     227# 
     228#        author = req.authname 
     229#        comment = req.args.get('comment', '') 
     230#        editrows = req.args.get('editrows') 
     231#        tags = req.args.get('tags') 
     232#        req.hdf['tags'] = tags 
     233#        if editrows: 
     234#            pref = req.session.get('wiki_editrows', '20') 
     235#            if editrows != pref: 
     236#                req.session['wiki_editrows'] = editrows 
     237#        else: 
     238#            editrows = req.session.get('wiki_editrows', '20') 
     239# 
     240#        req.hdf['title'] = page.name + ' (edit)' 
     241#        info = { 
     242#            'title' : blogtitle, 
     243#            'pagename': page.name, 
     244#            'page_source': page.text, 
     245#            'author': author, 
     246#            'comment': comment, 
     247#            'readonly': page.readonly, 
     248#            'edit_rows': editrows, 
     249#            'scroll_bar_pos': req.args.get('scroll_bar_pos', '') 
     250#        } 
     251#        if preview: 
     252#            if blogtitle: 
     253#                info['page_html'] = wiki_to_html(''.join([titleline,  
     254#                                                 req.args.get('text'),  
     255#                                                 "\n\n",self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))]),  
     256#                                                self.env, req, db) 
     257#            else: 
     258#                info['page_html'] = wiki_to_html(page.text.join(["\n\n", 
     259#                    self.variable_substitution(req,self.env.config.get('blog', 'footer', ''))]),  
     260#                                                  self.env,  
     261#                                                  req,  
     262#                                                  db)  
     263#            info['readonly'] = int(req.args.has_key('readonly')) 
     264#        req.hdf['blog'] = info 
    228265 
    229266    def variable_substitution(self,req,string):  
    …… 
    234271    # ITemplateProvider 
    235272    def get_templates_dirs(self): 
    236         """ 
    237             Return the absolute path of the directory containing the provided 
    238             templates 
    239         """ 
    240273        return [resource_filename(__name__, 'templates')] 
    241274 
    242275    def get_htdocs_dirs(self): 
    243         """ 
    244         Return a list of directories with static resources (such as style 
    245         sheets, images, etc.) 
    246  
    247         Each item in the list must be a `(prefix, abspath)` tuple. The 
    248         `prefix` part defines the path in the URL that requests to these 
    249         resources are prefixed with. 
    250          
    251         The `abspath` is the absolute path to the directory containing the 
    252         resources on the local file system. 
    253         """ 
    254276        return [('blog', resource_filename(__name__, 'htdocs'))] 
    255277 

  • tracblogplugin/trunk/tBlog/web_ui.py

    r2403 r3214  
    2323from StringIO import StringIO 
    2424from pkg_resources import resource_filename 
     25 
     26from genshi.builder import tag 
     27 
    2528from trac.core import * 
    2629from trac.web import IRequestHandler 
    …… 
    2831from trac.web.chrome import INavigationContributor  
    2932from trac.util import Markup, format_date, format_datetime, http_date 
    30 try: 
    31     from trac.util.text import to_unicode 
    32 except ImportError: 
    33     to_unicode = lambda x: x 
     33from trac.util.text import to_unicode 
    3434from trac.wiki.formatter import Formatter, wiki_to_oneliner, wiki_to_html 
    3535from trac.wiki.model import WikiPage 
    36 from trac.wiki.api import IWikiMacroProvider 
     36from trac.wiki.macros import WikiMacroBase  
    3737from trac.perm import IPermissionRequestor 
    38  
    39 from tractags.api import TagEngine 
    40 from tractags.parseargs import parseargs 
     38from trac.config import Option, BoolOption, ListOption 
     39 
     40from tBlog.parseargs import parseargs 
     41 
     42#from tractags.api import TagEngine 
     43#from tractags.parseargs import parseargs 
    4144 
    4245 
    …… 
    6770 
    6871 
    69 class NoFloatFormatter(Formatter): 
    70     """A modified formatter that inserts macro_no_float=1 into the HDF.""" 
    71      
    72     def __init__(self, *args, **kwords): 
    73         if 'macro_blacklist' in kwords: 
    74             self.macro_blacklist = kwords['macro_blacklist'] 
    75             del kwords['macro_blacklist'] 
    76         if 'req' in kwords: 
    77             kwords['req'].hdf['macro_no_float'] = 1 
    78         else: 
    79             for arg in args: 
    80                 if hasattr(arg, 'hdf'): 
    81                     arg.hdf['macro_no_float'] = 1 
    82                     break 
    83             else: 
    84                 raise TracError, "Unable to isolate req" 
    85         super(NoFloatFormatter,self).__init__(*args, **kwords) 
    86  
    87     def _macro_formatter(self, match, fullmatch): 
    88         name = fullmatch.group('macroname') 
    89         if name in self.macro_blacklist: 
    90             return '' 
    91         return super(NoFloatFormatter, self)._macro_formatter(match, fullmatch) 
     72#class NoFloatFormatter(Formatter): 
     73#    """A modified formatter that inserts macro_no_float=1 into the HDF.""" 
     74#     
     75#    def __init__(self, *args, **kwords): 
     76#        if 'macro_blacklist' in kwords: 
     77#            self.macro_blacklist = kwords['macro_blacklist'] 
     78#            del kwords['macro_blacklist'] 
     79#        if 'req' in kwords: 
     80#            kwords['req'].hdf['macro_no_float'] = 1 
     81#        else: 
     82#            for arg in args: 
     83#                if hasattr(arg, 'hdf'): 
     84#                    arg.hdf['macro_no_float'] = 1 
     85#                    break 
     86#            else: 
     87#                raise TracError, "Unable to isolate req" 
     88#        super(NoFloatFormatter,self).__init__(*args, **kwords) 
     89# 
     90#    def _macro_formatter(self, match, fullmatch): 
     91#        name = fullmatch.group('macroname') 
     92#        if name in self.macro_blacklist: 
     93#            return '' 
     94#        return super(NoFloatFormatter, self)._macro_formatter(match, fullmatch) 
    9295         
    93 def wiki_to_nofloat_html(wikitext, env, req, db=None, absurls=0,  
    94                          escape_newlines=False, macro_blacklist=[]): 
    95     out = StringIO() 
    96     NoFloatFormatter(env, req, absurls, db, macro_blacklist=macro_blacklist 
    97                     ).format(wikitext, out, escape_newlines) 
    98     return Markup(out.getvalue()) 
    99  
    100 class TracBlogPlugin(Component): 
     96#def wiki_to_nofloat_html(wikitext, env, req, db=None, absurls=0,  
     97#                         escape_newlines=False, macro_blacklist=[]): 
     98#    out = StringIO() 
     99#    NoFloatFormatter(env, req, absurls, db, macro_blacklist=macro_blacklist 
     100#                    ).format(wikitext, out, escape_newlines) 
     101#    return Markup(out.getvalue()) 
     102 
     103class TracBlogPlugin(WikiMacroBase): 
    101104    """Displays a blog based on tags 
    102105     
    …… 
    156159    """ 
    157160 
    158     implements(IRequestHandler, ITemplateProvider, INavigationContributor, 
    159                IWikiMacroProvider, IPermissionRequestor) 
     161    implements(ITemplateProvider, INavigationContributor, IPermissionRequestor) 
     162#    implements(IRequestHandler, ITemplateProvider, INavigationContributor, 
     163#               IWikiMacroProvider, IPermissionRequestor) 
     164 
     165    nav_bar = BoolOption('blog', 'nav_bar', True, doc="True or False.  Whether to show " 
     166                         "the link to the blag handler in the main navigation bar.") 
     167    nav_bar_text = Option('blog', 'nav_bar_text', 'Blog',  doc="The text to show in the " 
     168                          "navigation bar entry linking to the blog handler.") 
     169    default_tag = ListOption('blog', 'default_tag', 'blog',  doc="Comma separated list of " 
     170                             "tags.  The combination of which are used as the default for " 
     171                             "signifying a blog post.") 
    160172 
    161173    # IPermissionRequestor 
    162     def get_permission_actions(self): 
     174    def get_permission_actions(sef): 
    163175        return ['BLOG_VIEW'] 
    164176 
    …… 
    169181                 
    170182    def get_navigation_items(self, req): 
    171         nav_bar = bool_val(self.env.config.get('blog', 'nav_bar', True)) 
    172         if req.perm.has_permission('BLOG_VIEW') and nav_bar: 
    173             req.hdf['trac.href.blog'] = self.env.href.blog() 
    174             yield 'mainnav', 'blog', Markup('<a href="%s">Blog</a>', 
    175                                              self.env.href.blog()) 
     183        if req.perm.has_permission('BLOG_VIEW') and self.nav_bar: 
     184            yield 'mainnav', 'blog', tag.a(self.nav_bar_text, href= req.href.blog()) 
    176185 
    177186    # IWikiMacroProvider 
    …… 
    180189        yield "SplitPost" 
    181190 
    182     def get_macro_description(self, name): 
    183         """Return the subclass's docstring.""" 
    184         return inspect.getdoc(self.__class__) 
    185  
    186     def render_macro(self, req, name, content): 
     191    def expand_macro(self, formatter, name, content): 
    187192        """ Display the blog in the wiki page """ 
    188193        if name == 'SplitPost': 
    …… 
    191196        tags, kwargs = self._split_macro_args(content) 
    192197        if not tags: 
    193             tstr = self.env.config.get('blog', 'default_tag', 'blog') 
    194             tags = [t.strip() for t in _tag_split.split(tstr) if t.strip()] 
    195         self._generate_blog(req, *tags, **kwargs) 
    196         req.hdf['blog.macro'] = True 
    197         data = req.hdf.render('blog.cs') 
    198         return req.hdf.render('blog.cs') 
    199 # Originally this was put in for ticket #306.  [3141] fixed the issue in trac 
    200 # proper, however, I left this in due to a suggestion from cboos 
    201 # http://lists.edgewall.com/archive/trac-dev/2006-April/000397.html 
    202 # However, it looks like 0.9.x can't handle it.  So, we'll see what other  
    203 # wonderful unicode errors we'll get now :) 
    204 #        return unicode(req.hdf.render('blog.cs'), 'utf-8') 
     198            tags = [t.strip() for t in self.default_tag] 
     199#        self._generate_blog(req, *tags, **kwargs) 
     200#        req.hdf['blog.macro'] = True 
     201#        data = req.hdf.render('blog.cs') 
     202        return 'rendered data' 
    205203 
    206204    def _split_macro_args(self, argv): 
    …… 
    214212        return args, kwargs 
    215213 
    216     def match_request(self, req): 
    217         return req.path_info == '/blog' 
    218  
    219     def process_request(self, req): 
    220         req.perm.assert_permission('BLOG_VIEW') 
    221         add_stylesheet(req, 'blog/css/blog.css') 
    222         add_stylesheet(req, 'common/css/wiki.css') 
    223         tags = req.args.getlist('tag') 
    224         format = req.args.get('format') 
    225         kwargs = {} 
    226         for key in req.args.keys(): 
    227             if key != 'tag': 
    228                 kwargs[key] = req.args[key] 
    229             continue 
    230         if not tags: 
    231             tstr = self.env.config.get('blog', 'default_tag', 'blog') 
    232             tags = [t.strip() for t in _tag_split.split(tstr) if t.strip()] 
    233         num_posts = self.env.config.get('blog', 'num_posts', 0) 
    234         kwargs.setdefault('num_posts', num_posts) 
    235         self._generate_blog(req, *tags, **kwargs) 
    236         if format == 'rss': 
    237             return 'blog_rss.cs', 'application/rss+xml' 
    238         else: 
    239             add_link(req, 'alternate', self.env.href.blog(format='rss'), 
    240                         'RSS Feed', 'application/rss+xml', 'rss') 
    241             return 'blog.cs', None 
    242  
    243     def _generate_blog(self, req, *args, **kwargs): 
    244         """Extract the blog pages and fill the HDF. 
    245  
    246         *args is a list of tags to use to limit the blog scope 
    247         **kwargs are any aditional keyword arguments that are needed 
    248         """ 
    249         tallies = {} 
    250         tags = TagEngine(self.env).tagspace.wiki 
    251         try: 
    252             union = kwargs['union'] 
    253         except KeyError: 
    254             union = False 
    255         # Formatting 
    256         read_post = "[wiki:%s Read Post]" 
    257         entries = {} 
    258         if not len(args): 
    259             tlist = [self.env.config.get('blog', 'default_tag', 'blog')] 
    260         else: 
    261             tlist = args 
    262         if union: 
    263             blog = tags.get_tagged_names(tlist, operation='union') 
    264         else: 
    265             blog = tags.get_tagged_names(tlist, operation='intersection') 
    266         macropage = req.args.get('page', None) 
    267  
    268         poststart, postend, default_times = self._get_time_range(req, **kwargs) 
    269         mark_updated = self._choose_value('mark_updated', req, kwargs,  
    270                                           convert=bool_val) 
    271         if not mark_updated and (not isinstance(mark_updated, bool)): 
    272             mark_updated = bool_val(self.env.config.get('blog', 'mark_updated', 
    273                                                          True)) 
    274         macro_bl = self.env.config.get('blog', 'macro_blacklist', '').split(',') 
    275         macro_bl = [name.strip() for name in macro_bl if name.strip()] 
    276         macro_bl.append('BlogShow') 
    277  
    278         # Get the email addresses of all known users and validate the "poster" 
    279         # BlogShow optional argument at the same time (avoids looping the user 
    280         # list twice). 
    281         is_poster = None 
    282         limit_poster = self._choose_value('poster', req, kwargs, convert=None) 
    283         email_map = {} 
    284         for username, name, email in self.env.get_known_users(): 
    285             if email: 
    286                 email_map[username] = email 
    287             if limit_poster != None: 
    288                 if username == limit_poster: 
    289                     is_poster = username 
    290  
    291                         
    292         num_posts = self._choose_value('num_posts', req, kwargs, convert=int) 
    293         if num_posts and default_times: 
    294             poststart = sys.maxint 
    295             postend = 0 
    296         for blog_entry in blog: 
    297             if blog_entry == macropage: 
    298                 continue 
    299             try: 
    300                 page = WikiPage(self.env, version=1, name=blog_entry) 
    301                 version, post_time, author, comment, ipnr = page.get_history( 
    302                                                             ).next() 
    303                 # if we're limiting by poster, do so now so that the calendar 
    304                 # only shows the number of entries the specific poster made. 
    305                 if is_poster != None: 
    306                     if is_poster != author: 
    307                         continue 
    308  
    309                 self._add_to_tallies(tallies, post_time, blog_entry) 
    310                 page = WikiPage(self.env, name=blog_entry) 
    311                 version, modified, author, comment, ipnr = page.get_history( 
    312                                                            ).next() 
    313             except: 
    314                 self.log.debug("Error loading wiki page %s" % blog_entry, exc_info=True) 
    315                 continue 
    316             if poststart >= post_time >= postend:        
    317                 time_format = self.env.config.get('blog', 'date_format') \ 
    318                               or '%x %X' 
    319                 timeStr = format_datetime(post_time, format=time_format)  
    320                 fulltext = page.text 
    321                 # remove comments in blog view: 
    322                 del_comments = re.compile('==== Comment.*\Z', re.DOTALL) 
    323                 fulltext = del_comments.sub('', fulltext) 
    324                 # remove the [[AddComment...]] tag, otherwise it would appeare 
    325                 # more than one and crew up the blog view: 
    326                 del_addcomment  = re.compile('\[\[AddComment.*\Z', re.DOTALL) 
    327                 fulltext = del_addcomment.sub('', fulltext) 
    328                 # limit length of preview: 
    329                 post_size = self._choose_value('post_size', req, kwargs, int) 
    330                 if not post_size and (not isinstance(post_size, int)): 
    331                     post_size = int(self.env.config.get('blog', 'post_size',  
    332                                     1024)) 
    333                 text = self._trim_page(fulltext, blog_entry, post_size) 
    334                 pagetags = [x for x in tags.get_name_tags(blog_entry) if x not in tlist] 
    335                 tagtags = [] 
    336                 for i, t in enumerate(pagetags[:3]): 
    337                     d = { 'link' : t, 
    338                           'name' : t, 
    339                           'last' : i == (len(pagetags[:3]) - 1), 
    340                         } 
    341                     tagtags.append(d) 
    342                     continue 
    343                 # extract title from text: 
    344                 match = _title_split_match(fulltext) 
    345                 if match: 
    346                     title = match.group(1) 
    347                     fulltext = match.group(2) 
    348                 else:  
    349                     title = blog_entry 
    350                 html_text = wiki_to_html(fulltext, self.env, req) 
    351                 rss_text = Markup.escape(to_unicode(html_text)) 
    352                 data = { 
    353                         'name'      : blog_entry, 
    354                         'title'     : title, 
    355                         'href'      : self.env.href.wiki(blog_entry), 
    356                         'wiki_link' : wiki_to_oneliner(read_post %  
    357                                                        blog_entry, 
    358                                                        self.env), 
    359                         'time'      : timeStr, 
    360                         'date'      : http_date(post_time), 
    361 #                        'date'      : http_date(page.time), 
    362                         'author'    : author, 
    363                         'wiki_text' : wiki_to_nofloat_html(text, self.env, req, 
    364                                                    macro_blacklist=macro_bl), 
    365                         'rss_text'  : rss_text, 
    366                         'comment'   : wiki_to_oneliner(comment, self.env), 
    367                         'tags'      : { 
    368                                         'present' : len(pagetags), 
    369                                         'tags'    : tagtags, 
    370                                         'more'    : len(pagetags) > 3 or 0, 
    371                                       }, 
    372                        } 
    373                 if author: 
     214#    def match_request(self, req): 
     215#        return req.path_info == '/blog' 
     216# 
     217#    def process_request(self, req): 
     218#        req.perm.assert_permission('BLOG_VIEW') 
     219#        add_stylesheet(req, 'blog/css/blog.css') 
     220#        add_stylesheet(req, 'common/css/wiki.css') 
     221#        tags = req.args.getlist('tag') 
     222#        format = req.args.get('format') 
     223#        kwargs = {} 
     224#        for key in req.args.keys(): 
     225#            if key != 'tag': 
     226#                kwargs[key] = req.args[key] 
     227#            continue 
     228#        if not tags: 
     229#            tstr = self.env.config.get('blog', 'default_tag', 'blog') 
     230#            tags = [t.strip() for t in _tag_split.split(tstr) if t.strip()] 
     231#        num_posts = self.env.config.get('blog', 'num_posts', 0) 
     232#        kwargs.setdefault('num_posts', num_posts) 
     233#        self._generate_blog(req, *tags, **kwargs) 
     234#        if format == 'rss': 
     235#            return 'blog_rss.cs', 'application/rss+xml' 
     236#        else: 
     237#            add_link(req, 'alternate', self.env.href.blog(format='rss'), 
     238#                        'RSS Feed', 'application/rss+xml', 'rss') 
     239#            return 'blog.cs', None 
     240# 
     241#    def _generate_blog(self, req, *args, **kwargs): 
     242#        """Extract the blog pages and fill the HDF. 
     243## 
     244#        *args is a list of tags to use to limit the blog scope 
     245#        **kwargs are any aditional keyword arguments that are needed 
     246#        """ 
     247#        tallies = {} 
     248#        tags = TagEngine(self.env).tagspace.wiki 
     249#        try: 
     250#            union = kwargs['union'] 
     251#        except KeyError: 
     252#            union = False 
     253#        # Formatting 
     254#        read_post = "[wiki:%s Read Post]" 
     255#        entries = {} 
     256#        if not len(args): 
     257#            tlist = [self.env.config.get('blog', 'default_tag', 'blog')] 
     258#        else: 
     259#            tlist = args 
     260#        if union: 
     261#            blog = tags.get_tagged_names(tlist, operation='union') 
     262#        else: 
     263#            blog = tags.get_tagged_names(tlist, operation='intersection') 
     264#        macropage = req.args.get('page', None) 
     265# 
     266#        poststart, postend, default_times = self._get_time_range(req, **kwargs) 
     267#        mark_updated = self._choose_value('mark_updated', req, kwargs,  
     268#                                          convert=bool_val) 
     269#        if not mark_updated and (not isinstance(mark_updated, bool)): 
     270#            mark_updated = bool_val(self.env.config.get('blog', 'mark_updated', 
     271#                                                         True)) 
     272#        macro_bl = self.env.config.get('blog', 'macro_blacklist', '').split(',') 
     273#        macro_bl = [name.strip() for name in macro_bl if name.strip()] 
     274#        macro_bl.append('BlogShow') 
     275# 
     276#        # Get the email addresses of all known users and validate the "poster" 
     277#        # BlogShow optional argument at the same time (avoids looping the user 
     278#        # list twice). 
     279#        is_poster = None 
     280#        limit_poster = self._choose_value('poster', req, kwargs, convert=None) 
     281#        email_map = {} 
     282#        for username, name, email in self.env.get_known_users(): 
     283#            if email: 
     284#                email_map[username] = email 
     285#            if limit_poster != None: 
     286#                if username == limit_poster: 
     287#                    is_poster = username 
     288# 
     289#                        
     290#        num_posts = self._choose_value('num_posts', req, kwargs, convert=int) 
     291#        if num_posts and default_times: 
     292#            poststart = sys.maxint 
     293#            postend = 0 
     294#        for blog_entry in blog: 
     295#            if blog_entry == macropage: 
     296#                continue 
     297#            try: 
     298#                page = WikiPage(self.env, version=1, name=blog_entry) 
     299#                version, post_time, author, comment, ipnr = page.get_history( 
     300#                                                            ).next() 
     301#                # if we're limiting by poster, do so now so that the calendar 
     302#                # only shows the number of entries the specific poster made. 
     303#                if is_poster != None: 
     304#                    if is_poster != author: 
     305#                        continue 
     306# 
     307#                self._add_to_tallies(tallies, post_time, blog_entry) 
     308#                page = WikiPage(self.env, name=blog_entry) 
     309#                version, modified, author, comment, ipnr = page.get_history( 
     310#                                                           ).next() 
     311##            except: 
     312#                self.log.debug("Error loading wiki page %s" % blog_entry, exc_info=True) 
     313#                continue 
     314#            if poststart >= post_time >= postend:        
     315#                time_format = self.env.config.get('blog', 'date_format') \ 
     316#                              or '%x %X' 
     317#                timeStr = format_datetime(post_time, format=time_format)  
     318#                fulltext = page.text 
     319#                # remove comments in blog view: 
     320#                del_comments = re.compile('==== Comment.*\Z', re.DOTALL) 
     321#                fulltext = del_comments.sub('', fulltext) 
     322#                # remove the [[AddComment...]] tag, otherwise it would appeare 
     323#                # more than one and crew up the blog view: 
     324#                del_addcomment  = re.compile('\[\[AddComment.*\Z', re.DOTALL) 
     325#                fulltext = del_addcomment.sub('', fulltext) 
     326#                # limit length of preview: 
     327#                post_size = self._choose_value('post_size', req, kwargs, int) 
     328#                if not post_size and (not isinstance(post_size, int)): 
     329#                    post_size = int(self.env.config.get('blog', 'post_size',  
     330#                                    1024)) 
     331#                text = self._trim_page(fulltext, blog_entry, post_size) 
     33