Source code for slacklog.formatters

# -*- coding: utf-8 -*-
"""
SlackLog formatters
===================

SlackLog formatter takes an in-memory representation of a Slackware ChangeLog.txt and produces a different representation of it.
"""
import codecs
import datetime
import os
import re
import time
from slacklog import models

[docs]class SlackLogFormatter (object): """ Base class for SlackLog formatters. This class is ment for subclassing. """ max_entries = None """If not :py:const:`None`, must be an :py:class:`int` representing how many entries are formatted from the beginning of the log. Rest of the entries are ignored.""" max_pkgs = None """If not :py:const:`None`, must be an :py:class:`int` representing how many packages are formatted from the beginning of each entry. Rest of the packages are ignored."""
[docs] def format(cls, log): """ Return unicode representation of the in-memory representation of the log. Default implementation calls :py:meth:`format_log_preamble`, followed by a call to :py:meth:`format_entry` for each log entry, and finally calls :py:meth:`format_log_postamble`. The return value is the concatenation of the return values of the mentioned functions. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of the log. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) data = u'' data += cls.format_log_preamble(log) data += cls.format_list(log.entries, cls.format_entry, cls.max_entries) data += cls.format_log_postamble(log) return data
format = classmethod(format)
[docs] def format_log_preamble(cls, log): """ Return unicode representation of the log preamble, the part before entries. Default implementation returns empty string. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log preamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) return u''
format_log_preamble = classmethod(format_log_preamble)
[docs] def format_log_postamble(cls, log): """ Return unicode representation of the log postamble, the part after all entries. Default implementation returns empty string. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log postamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) return u''
format_log_postamble = classmethod(format_log_postamble)
[docs] def format_entry(cls, entry, is_first, is_last): """ Return unicode representation of a single log entry. Default implementation calls :py:meth:`format_entry_separator` with arguments `is_first` and `is_last`, followed by a call to :py:meth:`format_entry_preamble`, followed by a call to :py:meth:`format_pkg` for each package in this log entry, finally followed by a call to :py:meth:`format_entry_postamble`. The return value is the concatenation of the return values of the mentioned functions. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :param bool is_first: :py:const:`True` if this is first entry, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last entry, :py:const:`False` otherwise. :return: Unicode representation of log entry. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = u'' data += cls.format_entry_separator(is_first, is_last) data += cls.format_entry_preamble(entry) data += cls.format_list(entry.pkgs, cls.format_pkg, cls.max_pkgs) data += cls.format_entry_postamble(entry) return data
format_entry = classmethod(format_entry)
[docs] def format_entry_separator(cls, is_first, is_last): """ Return unicode representation of the log entry separator. Default implementation returns an empty string. :param bool is_first: :py:const:`True` if this is first entry, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last entry, :py:const:`False` otherwise. :return: Unicode representation of log entry separator. :type: :py:class:`unicode` """ return u''
format_entry_separator = classmethod(format_entry_separator)
[docs] def format_entry_preamble(cls, entry): """ Return unicode representation of the log entry preamble, the part before packages. Default implementation returns an empty string. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry preamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) return u''
format_entry_preamble = classmethod(format_entry_preamble)
[docs] def format_entry_postamble(cls, entry): """ Return unicode representation of the log entry postamble, the part after packages. Default implementation returns an empty string. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry postamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) return u''
format_entry_postamble = classmethod(format_entry_postamble)
[docs] def format_pkg(cls, pkg, is_first, is_last): """ Return unicode representation of a single log entry package. Default implementation calls :py:meth:`format_pkg_separator`, followed by a call to :py:meth:`format_pkg_preamble`, and finally calls :py:meth:`format_pkg_postamble`. The return value is the concatenation of the return values of the mentioned functions. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :param bool is_first: :py:const:`True` if this is first package, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last package, :py:const:`False` otherwise. :return: Unicode representation of log entry package. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) data = u'' data += cls.format_pkg_separator(is_first, is_last) data += cls.format_pkg_preamble(pkg) data += cls.format_pkg_postamble(pkg) return data
format_pkg = classmethod(format_pkg)
[docs] def format_pkg_separator(cls, is_first, is_last): """ Return unicode representation of the log entry package separator. Default implementation returns an empty string. :param bool is_first: :py:const:`True` if this is first package, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last package, :py:const:`False` otherwise. :return: Unicode representation of log entry package separator. :type: :py:class:`unicode` """ return u''
format_pkg_separator = classmethod(format_pkg_separator)
[docs] def format_pkg_preamble(cls, pkg): """ Return unicode representation of the log entry package preamble. Default implementation returns an empty string. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package preamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) return u''
format_pkg_preamble = classmethod(format_pkg_preamble)
[docs] def format_pkg_postamble(cls, pkg): """ Return unicode representation of the log entry package postamble. Default implementation returns an empty string. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package postamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) return u''
format_pkg_postamble = classmethod(format_pkg_postamble)
[docs] def format_list(cls, list_of_items, item_formatter, max_items=None): """ Return unicode representation of a list of objects. This method is not ment for subclassing. :param list_of_items: List of items to format. :type: list :param item_formatter: Function that formats one item. :type: A callable that takes one item as the first positional argument, two booleans `is_first` and `is_last` as second and third positional arguments, and returns a :py:class:`unicode` string. :return: Formatted data. :rtype: :py:class:`unicode` """ data = u'' num_items = len(list_of_items) if max_items: assert(isinstance(max_items, int)) if num_items > max_items: num_items = max_items for index in xrange(num_items): is_first = False is_last = False if index == 0: is_first = True if index == num_items - 1: is_last = True data += item_formatter(list_of_items[index], is_first, is_last) return data
format_list = classmethod(format_list)
[docs]class SlackLogTxtFormatter (SlackLogFormatter): """ Concrete SlackLog formatter that tries to regenerate the original ChangeLog.txt. """
[docs] def format_entry_separator(cls, is_first, is_last): """ Overrides :py:meth:`SlackLogFormatter.format_entry_separator`. :param bool is_first: :py:const:`True` if this is first entry, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last entry, :py:const:`False` otherwise. :return: Unicode representation of log entry separator. :type: :py:class:`unicode` """ if not is_first: return u'+--------------------------+\n' return u''
format_entry_separator = classmethod(format_entry_separator)
[docs] def format_entry_preamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_preamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry preamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = u'' data += entry.timestamp.strftime("%a %b %d %H:%M:%S %Z %Y") # Remove leading zero from the day-of-month only data = re.sub(r' 0(\d) ', r' \1 ', data) data += u'\n' if entry.description: data += entry.description return data
format_entry_preamble = classmethod(format_entry_preamble)
[docs] def format_pkg_preamble(cls, pkg): """ Overrides :py:meth:`SlackLogFormatter.format_pkg_preamble`. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package preamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) return u'%s:%s' % (pkg.pkg, pkg.description)
format_pkg_preamble = classmethod(format_pkg_preamble)
[docs]class SlackLogRssFormatter (SlackLogFormatter): """ Concrete SlackLog formatter that generates an RSS feed. """ slackware = None """:py:class:`unicode` description of the distro version. E.g. 'Slackware 13.37' or 'Slackware64 current'.""" rssLink = None """:py:class:`unicode`. Full URL of the RSS feed.""" webLink = None """:py:class:`unicode`. Full URL of the WWW version of the feed.""" description = None """:py:class:`unicode` description of the feed.""" language = None """:py:class:`unicode` language identifier. E.g. 'en'.""" managingEditor = None """:py:class:`unicode`. Email, and possibly name, of the feed manager. E.g. 'jane@doe.net (Jane Doe)'.""" webMaster = None """:py:class:`unicode`. Email, and possibly name, of the webmaster. E.g. 'john@doe.net (John Doe)'. """
[docs] def format_log_preamble(cls, log): """ Overrides :py:meth:`SlackLogFormatter.format_log_preamble`. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log preamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) data = u'<?xml version="1.0"?>\n' data += u'<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">\n' data += u' <channel>\n' data += u' <atom:link href="%s" rel="self" type="application/rss+xml" />\n' % cls.rssLink data += u' <title>%s ChangeLog</title>\n' % cls.slackware if cls.webLink: data += u' <link>%s</link>\n' % cls.webLink else: data += u' <link>%s</link>\n' % cls.rssLink if cls.description: data += u' <description>%s</description>\n' % cls.description data += u' <docs>http://www.rssboard.org/rss-specification</docs>\n' data += u' <language>%s</language>\n' % cls.language if cls.managingEditor: data += u' <managingEditor>%s</managingEditor>\n' % cls.managingEditor if cls.webMaster: data += u' <webMaster>%s</webMaster>\n' % cls.webMaster data += u' <pubDate>%s</pubDate>\n' % log.entries[0].timestamp.strftime("%a, %d %b %Y %H:%M:%S GMT") data += u' <lastBuildDate>%s</lastBuildDate>\n' % datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S GMT") data += u' <generator>SlackLog</generator>\n' return data
format_log_preamble = classmethod(format_log_preamble)
[docs] def format_log_postamble(cls, log): """ Overrides :py:meth:`SlackLogFormatter.format_log_postamble`. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log postamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) return u' </channel>\n</rss>\n'
format_log_postamble = classmethod(format_log_postamble)
[docs] def format_entry_preamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_preamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry preamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = u' <item>\n' if cls.webLink: data += u' <guid isPermaLink="true">%s#%s</guid>\n' % (cls.webLink, entry.timestamp.strftime("%Y%m%dT%H%M%SZ")) else: data += u' <guid isPermaLink="false">%s-%s</guid>\n' % (cls.slackware.replace(' ', '-'), entry.timestamp.strftime("%Y%m%dT%H%M%SZ")) data += u' <title>%s changes for %s</title>\n' % (cls.slackware, entry.timestamp.strftime("%a, %d %b %Y %H:%M:%S GMT")) data += u' <pubDate>%s</pubDate>\n' % entry.timestamp.strftime("%a, %d %b %Y %H:%M:%S GMT") data += u' <description><![CDATA[<pre>' if entry.description: data += entry.description.replace('<','&lt;') return data
format_entry_preamble = classmethod(format_entry_preamble)
[docs] def format_entry_postamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_postamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry postamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) return u'</pre>]]></description>\n </item>\n'
format_entry_postamble = classmethod(format_entry_postamble)
[docs] def format_pkg_preamble(cls, pkg): """ Overrides :py:meth:`SlackLogFormatter.format_pkg_preamble`. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package preamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) return u'%s:%s' % (pkg.pkg, pkg.description.replace('<','&lt;'))
format_pkg_preamble = classmethod(format_pkg_preamble)
[docs]class SlackLogAtomFormatter (SlackLogFormatter): """ Concrete SlackLog formatter that generates an Atom feed. """ slackware = None """:py:class:`unicode` description of the distro version. E.g. 'Slackware 13.37' or 'Slackware64 current'.""" link = None """:py:class:`unicode`. Full URL of the Atom feed.""" webLink = None """:py:class:`unicode`. Full URL of the HTML version.""" name = None """:py:class:`unicode`. Name of the feed author.""" email = None """:py:class:`unicode`. Email of the feed author."""
[docs] def format_log_preamble(cls, log): """ Overrides :py:meth:`SlackLogFormatter.format_log_preamble`. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log preamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) data = u'<?xml version="1.0"?>\n' data += u'<feed xmlns="http://www.w3.org/2005/Atom">\n' data += u' <link href="%s" rel="self" type="application/rss+xml" />\n' % cls.link data += u' <title>%s ChangeLog</title>\n' % cls.slackware if cls.webLink: data += u' <link href="%s" />\n' % cls.webLink else: data += u' <link href="%s" />\n' % cls.link data += u' <updated>%s</updated>\n' % datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ") data += u' <author>\n' data += u' <name>%s</name>\n' % cls.name data += u' <email>%s</email>\n' % cls.email data += u' </author>\n' data += u' <id>%s</id>\n' % cls.link return data
format_log_preamble = classmethod(format_log_preamble)
[docs] def format_log_postamble(cls, log): """ Overrides :py:meth:`SlackLogFormatter.format_log_postamble`. :param log: in-memory representation of the log. :type: :py:class:`slacklog.models.SlackLog` :return: Unicode representation of log postamble. :type: :py:class:`unicode` """ assert(isinstance(log, models.SlackLog)) return u'</feed>\n'
format_log_postamble = classmethod(format_log_postamble)
[docs] def format_entry_preamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_preamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry preamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = u' <entry>\n' data += u' <title>%s changes for %s</title>\n' % (cls.slackware, entry.timestamp.strftime("%a, %d %b %Y %H:%M:%S GMT")) if cls.webLink: data += u' <link href="%s#%s" />\n' % (cls.webLink, entry.timestamp.strftime("%Y%m%dT%H%M%SZ")) else: data += u' <link href="%s#%s" />\n' % (cls.link, entry.timestamp.strftime("%Y%m%dT%H%M%SZ")) data += u' <updated>%s</updated>\n' % entry.timestamp.strftime("%Y-%m-%dT%H:%M:%SZ") data += u' <id>%s#%s</id>\n' % (cls.link, entry.timestamp.strftime("%Y%m%dT%H%M%SZ")) data += u' <content type="html"><![CDATA[<pre>' return data
format_entry_preamble = classmethod(format_entry_preamble)
[docs] def format_entry_postamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_postamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry postamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) return u'</pre>]]></content>\n </entry>\n'
format_entry_postamble = classmethod(format_entry_postamble)
[docs] def format_pkg_preamble(cls, pkg): """ Overrides :py:meth:`SlackLogFormatter.format_pkg_preamble`. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package preamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) return u'%s:%s' % (pkg.pkg, pkg.description.replace('<','&lt;'))
format_pkg_preamble = classmethod(format_pkg_preamble)
[docs]class SlackLogPyblosxomFormatter (SlackLogFormatter): """ Concrete SlackLog formatter that generates Pyblosxom blog entries. """ quiet = False """If :py:const:`True`, """ slackware = None """:py:class:`unicode` description of the distro version. E.g. 'Slackware 13.37' or 'Slackware64 current'.""" datadir = None """Blog entry directory.""" extension = 'txt' """Blog entry filename extension.""" encoding = 'utf-8' """Blog entry file encoding.""" tags_separator = ',' """Separator for tags.""" pkg_separator = ':' """Separator for packages.""" pyfilemtime = False """If :py:const:`True`, a pyfilemtime compatible filenames are generated.""" overwrite = False """If :py:const:`True`, already existing blog entries are overwritten.""" backup = True """If :py:const:`True`, already existing blog entries are copied to backups before overwriting.""" # Subclass can change these entry_preamble = u'<div class="slackLogEntry">\n' """:py:class:`unicode`. HTML to insert before the entry.""" entry_postamble = u'</div>\n' """:py:class:`unicode`. HTML to insert after the entry.""" entry_desc_preamble = u'<div class="slackLogEntryDesc">' """:py:class:`unicode`. HTML to insert before the entry description.""" entry_desc_postamble = u'</div>\n' """:py:class:`unicode`. HTML to insert after the entry description.""" entry_pkgs_preamble = u'<div class="slackLogEntryPkgs">\n' """:py:class:`unicode`. HTML to insert before the list of packages.""" entry_pkgs_postamble = U'</div>\n' """:py:class:`unicode`. HTML to insert after the list of packages.""" pkg_preamble = u'<div class="slackLogPkg">' """:py:class:`unicode`. HTML to insert before a package.""" pkg_postamble = u'</div>\n' """:py:class:`unicode`. HTML to insert after a package.""" pkg_name_preamble = u'<span class="slackLogPkgName">' """:py:class:`unicode`. HTML to insert before package name.""" pkg_name_postamble = u'</span>' """:py:class:`unicode`. HTML to insert after package name.""" pkg_desc_preamble = u'<span class="slackLogPkgDesc">' """:py:class:`unicode`. HTML to insert before package description.""" pkg_desc_postamble = u'</span>' """:py:class:`unicode`. HTML to insert after package description."""
[docs] def format_entry(cls, entry, is_first, is_last): """ Overrides :py:meth:`SlackLogFormatter.format_entry`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :param bool is_first: :py:const:`True` if this is first entry, :py:const:`False` otherwise. :param bool is_last: :py:const:`True` if this is last entry, :py:const:`False` otherwise. :return: Unicode representation of log entry. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = super(SlackLogPyblosxomFormatter, cls).format_entry(entry, is_first, is_last) # generate filename for this entry filename = '%s%s%s' % (cls.datadir, os.path.sep, cls.format_entry_basename(entry)) if cls.pyfilemtime: filename += entry.timestamp.strftime("-%Y-%m-%d-%H-%M") filename += '.%s' % cls.extension filename = os.path.expanduser(filename) # Ensure that the directory exists try: os.makedirs(os.path.dirname(filename)) except: # Directory already exists pass # Handle the entries that already exist if os.path.exists(filename): if cls.overwrite: if cls.backup: # Make a backup i = 1 backup = "%s~%d~" % (filename, i) while os.path.exists(backup): backup = "%s~%d~" % (filename, i) i += 1 if not cls.quiet: print "Backing up entry: %s" % backup os.rename(filename, backup) else: print "Overwriting entry: %s" % filename else: if not cls.quiet: print "Entry already exists: %s" % filename return data # Write the entry file = codecs.open(filename, 'w', cls.encoding) file.write(data) file.close() # Set the mtime (for those who do not want to use the # pyfilemtime plugin) timestamp = time.mktime(entry.timestamp.timetuple()) os.utime(filename, (timestamp, timestamp)) return data
format_entry = classmethod(format_entry)
[docs] def format_entry_preamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_preamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry preamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = cls.format_entry_title(entry) if cls.tags_separator: data += u'#tags %s\n' % cls.format_entry_tags(entry) data += cls.entry_preamble if entry.description: data += u'%s%s%s' % (cls.entry_desc_preamble, entry.description, cls.entry_desc_postamble) if entry.pkgs: data += cls.entry_pkgs_preamble return data
format_entry_preamble = classmethod(format_entry_preamble)
[docs] def format_entry_postamble(cls, entry): """ Overrides :py:meth:`SlackLogFormatter.format_entry_postamble`. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry postamble. :type: :py:class:`unicode` """ assert(isinstance(entry, models.SlackLogEntry)) data = u'' if entry.pkgs: data += cls.entry_pkgs_postamble data += cls.entry_postamble return data
format_entry_postamble = classmethod(format_entry_postamble)
[docs] def format_pkg_preamble(cls, pkg): """ Overrides :py:meth:`SlackLogFormatter.format_pkg_preamble`. :param pkg: in-memory representation of the log entry package :type: :py:class:`slacklog.models.SlackLogPkg` :return: Unicode representation of log entry package preamble. :type: :py:class:`unicode` """ assert(isinstance(pkg, models.SlackLogPkg)) data = u'%s%s%s%s%s%s%s%s%s' % (cls.pkg_preamble, cls.pkg_name_preamble, pkg.pkg, cls.pkg_name_postamble, cls.pkg_separator, cls.pkg_desc_preamble, pkg.description, cls.pkg_desc_postamble, cls.pkg_postamble) return data
format_pkg_preamble = classmethod(format_pkg_preamble)
[docs] def format_entry_basename(cls, entry): """ Return basename for the log entry. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry name :type: :py:class:`unicode` """ return cls.slackware.replace(' ','-').replace('.','_').lower()
format_entry_basename = classmethod(format_entry_basename)
[docs] def format_entry_title(cls, entry): """ Return log entry title. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry title :type: :py:class:`unicode` """ return u'%s changes for %s\n' % (cls.slackware, entry.timestamp.strftime("%a, %d %b %Y %H:%M:%S GMT"))
format_entry_title = classmethod(format_entry_title)
[docs] def format_entry_tags(cls, entry): """ Return log entry tags. :param entry: in-memory representation of the log entry. :type: :py:class:`slacklog.models.SlackLogEntry` :return: Unicode representation of log entry tags :type: :py:class:`unicode` """ return u'%s' % cls.slackware.replace(' ',cls.tags_separator)
format_entry_tags = classmethod(format_entry_tags)