+ *.pyc

+ pelican.pid

+ srv.pid

+ output/

+ # packaging docs 

+ 

+ ## Running the server for writing new articles

+ 

+ Running the pelican development server is useful when writing new articles. The steps to

+ get it running are:

+ 

+ 1. Install pelican: `sudo dnf install pelican GitPython`

+ 2. Check out the packagin docs source (from your fork or the main repo)

+ 3. In the main folder of the checked out repo, run `./develop_server.sh start`

+ and your local copy of the Docs Fedora will be at http://localhost:8000/

+ #!/usr/bin/env bash

+ ##

+ # This section should match your Makefile

+ ##

+ PY=${PY:-python}

+ PELICAN=${PELICAN:-pelican}

+ PELICANOPTS=

+ 

+ BASEDIR=$(pwd)

+ INPUTDIR=$BASEDIR/content

+ OUTPUTDIR=$BASEDIR/output

+ CONFFILE=$BASEDIR/pelicanconf.py

+ 

+ ###

+ # Don't change stuff below here unless you are sure

+ ###

+ 

+ SRV_PID=$BASEDIR/srv.pid

+ PELICAN_PID=$BASEDIR/pelican.pid

+ 

+ function usage(){

+   echo "usage: $0 (stop) (start) (restart) [port]"

+   echo "This starts Pelican in debug and reload mode and then launches"

+   echo "an HTTP server to help site development. It doesn't read"

+   echo "your Pelican settings, so if you edit any paths in your Makefile"

+   echo "you will need to edit your settings as well."

+   exit 3

+ }

+ 

+ function alive() {

+   kill -0 $1 >/dev/null 2>&1

+ }

+ 

+ function shut_down(){

+   PID=$(cat $SRV_PID)

+   if [[ $? -eq 0 ]]; then

+     if alive $PID; then

+       echo "Stopping HTTP server"

+       kill $PID

+     else

+       echo "Stale PID, deleting"

+     fi

+     rm $SRV_PID

+   else

+     echo "HTTP server PIDFile not found"

+   fi

+ 

+   PID=$(cat $PELICAN_PID)

+   if [[ $? -eq 0 ]]; then

+     if alive $PID; then

+       echo "Killing Pelican"

+       kill $PID

+     else

+       echo "Stale PID, deleting"

+     fi

+     rm $PELICAN_PID

+   else

+     echo "Pelican PIDFile not found"

+   fi

+ }

+ 

+ function start_up(){

+   local port=$1

+   echo "Starting up Pelican and HTTP server"

+   shift

+   $PELICAN --debug --autoreload -r $INPUTDIR -o $OUTPUTDIR -s $CONFFILE $PELICANOPTS &

+   pelican_pid=$!

+   echo $pelican_pid > $PELICAN_PID

+   cd $OUTPUTDIR

+   $PY -m pelican.server $port &

+   srv_pid=$!

+   echo $srv_pid > $SRV_PID

+   cd $BASEDIR

+   sleep 1

+   if ! alive $pelican_pid ; then

+     echo "Pelican didn't start. Is the Pelican package installed?"

+     return 1

+   elif ! alive $srv_pid ; then

+     echo "The HTTP server didn't start. Is there another service using port" $port "?"

+     return 1

+   fi

+   echo 'Pelican and HTTP server processes now running in background.'

+ }

+ 

+ ###

+ #  MAIN

+ ###

+ [[ ($# -eq 0) || ($# -gt 2) ]] && usage

+ port=''

+ [[ $# -eq 2 ]] && port=$2

+ 

+ if [[ $1 == "stop" ]]; then

+   shut_down

+ elif [[ $1 == "restart" ]]; then

+   shut_down

+   start_up $port

+ elif [[ $1 == "start" ]]; then

+   if ! start_up $port; then

+     shut_down

+   fi

+ else

+   usage

+ fi

+ # -*- coding: utf-8 -*- #

+ from __future__ import unicode_literals

+ 

+ AUTHOR = u'The Fedora Project'

+ SITENAME = u'Fedora Documentation'

+ SITEURL = 'https://docs.pagure.org/docs-fedora/'

+ 

+ PATH = 'content'

+ ARTICLE_EXCLUDES = ['modules']

+ TIMEZONE = 'Europe/Paris'

+ 

+ DEFAULT_LANG = u'en'

+ 

+ THEME = 'theme'

+ 

+ # Feed generation is usually not desired when developing

+ FEED_ALL_ATOM = None

+ CATEGORY_FEED_ATOM = None

+ TRANSLATION_FEED_ATOM = None

+ AUTHOR_FEED_ATOM = None

+ AUTHOR_FEED_RSS = None

+ 

+ # Blogroll

+ LINKS = (('Pelican', 'http://getpelican.com/'),

+          ('Python.org', 'http://python.org/'),

+          ('Jinja2', 'http://jinja.pocoo.org/'),

+          ('You can modify those links in your config file', '#'),)

+ 

+ # Social widget

+ SOCIAL = (('You can add links in your config file', '#'),

+           ('Another social link', '#'),)

+ 

+ DEFAULT_PAGINATION = False

+ 

+ PLUGIN_PATHS = ['plugins']

+ PLUGINS = ['asciidoc_reader', 'filetime_from_git', 'tipue_search', 'related_posts']

+ 

+ STATIC_PATHS = ['images']

+ 

+ DIRECT_TEMPLATES = (('index', 'tags', 'categories', 'authors', 'archives', 'search', 'all_articles'))

+ 

+ PAGINATED_DIRECT_TEMPLATES = ['index', 'all_articles']

+ 

+ # Uncomment following line if you want document-relative URLs when developing

+ RELATIVE_URLS = True

+ 

+ AsciiDoc Reader

+ ###############

+ 

+ This plugin allows you to use `AsciiDoc <http://www.methods.co.nz/asciidoc/>`_

+ to write your posts. File extension should be ``.asc``, ``.adoc``,

+ or ``.asciidoc``.

+ 

+ Dependency

+ ----------

+ 

+ There are two command line utilities commonly used to render AsciiDoc:

+ ``asciidoc`` and ``asciidoctor``. One of the two will need to be installed and

+ on the PATH.

+ 

+ **Note**: The ``asciidoctor`` utility is recommended since the original

+ ``asciidoc`` is no longer maintained.

+ 

+ Settings

+ --------

+ 

+ ========================================  =======================================================

+ Setting name (followed by default value)  What does it do?

+ ========================================  =======================================================

+ ``ASCIIDOC_CMD = asciidoc``               Selects which utility to use for rendering. Will

+                                           autodetect utility if not provided.

+ ``ASCIIDOC_OPTIONS = []``                 A list of options to pass to AsciiDoc. See the `manpage

+                                           <http://www.methods.co.nz/asciidoc/manpage.html>`_.

+ ========================================  =======================================================

+ 

+ Example file header

+ -------------------

+ 

+ Following the `example <https://github.com/getpelican/pelican/blob/master/docs/content.rst#file-metadata>`_ in the main pelican documentation:

+ 

+ .. code-block:: none

+ 

+   = My super title

+ 

+   :date: 2010-10-03 10:20

+   :modified: 2010-10-04 18:40

+   :tags: thats, awesome

+   :category: yeah

+   :slug: my-super-post

+   :authors: Alexis Metaireau, Conan Doyle

+   :summary: Short version for index and feeds

+ 

+   == title level 2

+ 

+   and so on...

+ from .asciidoc_reader import *

+ # -*- coding: utf-8 -*-

+ """

+ AsciiDoc Reader

+ ===============

+ 

+ This plugin allows you to use AsciiDoc to write your posts.

+ File extension should be ``.asc``, ``.adoc``, or ``asciidoc``.

+ """

+ 

+ from pelican.readers import BaseReader

+ from pelican import signals

+ import os

+ import re

+ import subprocess

+ 

+ def call(cmd):

+     """Calls a CLI command and returns the stdout as string."""

+     return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True).communicate()[0].decode('utf-8')

+ 

+ def default():

+     """Attempt to find the default AsciiDoc utility."""

+     for cmd in ALLOWED_CMDS:

+         if len(call(cmd + " --help")):

+             return cmd

+ 

+ ALLOWED_CMDS = ["asciidoc", "asciidoctor"]

+ 

+ ENABLED = None != default()

+ 

+ class AsciiDocReader(BaseReader):

+     """Reader for AsciiDoc files."""

+ 

+     enabled = ENABLED

+     file_extensions = ['asc', 'adoc', 'asciidoc']

+     default_options = ['--no-header-footer']

+ 

+     def read(self, source_path):

+         """Parse content and metadata of AsciiDoc files."""

+         cmd = self._get_cmd()

+         content = ""

+         if cmd:

+             optlist = self.settings.get('ASCIIDOC_OPTIONS', []) + self.default_options

+             options = " ".join(optlist)

+             content = call("%s %s -o - %s" % (cmd, options, source_path))

+         metadata = self._read_metadata(source_path)

+         return content, metadata

+ 

+     def _get_cmd(self):

+         """Returns the AsciiDoc utility command to use for rendering or None if

+         one cannot be found."""

+         if self.settings.get('ASCIIDOC_CMD') in ALLOWED_CMDS:

+             return self.settings.get('ASCIIDOC_CMD')

+         return default()

+ 

+     def _read_metadata(self, source_path):

+         """Parses the AsciiDoc file at the given `source_path` and returns found

+         metadata."""

+         metadata = {}

+         with open(source_path) as fi:

+             prev = ""

+             for line in fi.readlines():

+                 # Parse for doc title.

+                 if 'title' not in metadata.keys():

+                     title = ""

+                     if line.startswith("= "):

+                         title = line[2:].strip()

+                     elif line.count("=") == len(prev.strip()):

+                         title = prev.strip()

+                     if title:

+                         metadata['title'] = self.process_metadata('title', title)

+ 

+                 # Parse for other metadata.

+                 regexp = re.compile(r"^:[A-z]+:\s*[A-z0-9]")

+                 if regexp.search(line):

+                     toks = line.split(":", 2)

+                     key = toks[1].strip().lower()

+                     val = toks[2].strip()

+                     if key == 'tags' or key == 'fedoraversions':

+                         val = val.split(',')

+                     metadata[key] = self.process_metadata(key, val)

+                 prev = line

+         return metadata

+ 

+ def add_reader(readers):

+     for ext in AsciiDocReader.file_extensions:

+         readers.reader_classes[ext] = AsciiDocReader

+ 

+ def register():

+     signals.readers_init.connect(add_reader)

+ # -*- coding: utf-8 -*-

+ from __future__ import unicode_literals

+ 

+ import datetime

+ import os

+ 

+ from pelican.readers import Readers

+ from pelican.tests.support import unittest, get_settings

+ 

+ from .asciidoc_reader import ENABLED

+ 

+ CUR_DIR = os.path.dirname(__file__)

+ CONTENT_PATH = os.path.join(CUR_DIR, 'test_data')

+ 

+ @unittest.skipUnless(ENABLED, "asciidoc isn't installed")

+ class AsciiDocReaderTest(unittest.TestCase):

+     def read_file(self, path, **kwargs):

+         # Isolate from future API changes to readers.read_file

+         r = Readers(settings=get_settings(**kwargs))

+         return r.read_file(base_path=CONTENT_PATH, path=path)

+ 

+     def test_article_with_asc_extension(self):

+         # Ensure the asc extension is being processed by the correct reader

+         page = self.read_file(

+             path='article_with_asc_extension.asc')

+         expected = ('<div class="sect1">'

+                     '<h2 id="_used_for_pelican_test">'

+                     'Used for pelican test</h2>'

+                     '<div class="sectionbody">'

+                     '<div class="paragraph">'

+                     '<p>The quick brown fox jumped over '

+                     'the lazy dog&#8217;s back.</p>'

+                     '</div></div></div>')

+         actual = "".join(page.content.splitlines())

+         expected = "".join(expected.splitlines())

+         self.assertEqual(actual, expected)

+         expected = {

+             'category': 'Blog',

+             'author': 'Author O. Article',

+             'title': 'Test AsciiDoc File Header',

+             'date': datetime.datetime(2011, 9, 15, 9, 5),

+             'tags': ['Linux', 'Python', 'Pelican'],

+         }

+         for key, value in expected.items():

+             self.assertEqual(value, page.metadata[key], (

+                 'Metadata attribute \'%s\' does not match expected value.\n'

+                 'Expected: %s\n'

+                 'Actual: %s') % (key, value, page.metadata[key]))

+ 

+     def test_article_with_asc_options(self):

+         # test to ensure the ASCIIDOC_OPTIONS is being used

+         page = self.read_file(path='article_with_asc_options.asc',

+             ASCIIDOC_OPTIONS=["-a revision=1.0.42"])

+         expected = ('<div class="sect1">'

+                     '<h2 id="_used_for_pelican_test">'

+                     'Used for pelican test</h2>'

+                     '<div class="sectionbody">'

+                     '<div class="paragraph">'

+                     '<p>version 1.0.42</p></div>'

+                     '<div class="paragraph">'

+                     '<p>The quick brown fox jumped over '

+                     'the lazy dog&#8217;s back.</p>'

+                     '</div></div></div>')

+         actual = "".join(page.content.splitlines())

+         expected = "".join(expected.splitlines())

+         self.assertEqual(actual, expected)

+ 

+ 

+ if __name__ == '__main__':

+     unittest.main()

+ Test AsciiDoc File Header

+ =========================

+ :Author: Author O. Article

+ :Email: <author@nowhere.com>

+ :Date: 2011-09-15 09:05

+ :Category: Blog

+ :Tags: Linux, Python, Pelican

+ 

+ == Used for pelican test

+ 

+ The quick brown fox jumped over the lazy dog's back.

+ = Test AsciiDoc File Header

+ 

+ == Used for pelican test

+ 

+ version {revision}

+ 

+ The quick brown fox jumped over the lazy dog's back.

+ Category Metadata

+ -----------------

+ 

+ A plugin to read metadata for each category from an index file in that

+ category's directory.

+ 

+ For this plugin to work properly, your articles should not have a

+ Category: tag in their metadata; instead, they should be stored in

+ (subdirectories of) per-category directories.  Each per-category

+ directory must have a file named 'index.ext' at its top level, where

+ .ext is any extension that will be picked up by an article reader.

+ The metadata of that article becomes the metadata for the category,

+ copied over verbatim, with three special cases:

+ 

+  * The category's name is set to the article's title.

+  * The category's slug is set to the name of the parent directory

+    of the index.ext file.

+  * The _text_ of the article is stored as category.description.

+ 

+ You can use this, for example, to control the slug used for each

+ category independently of its name, or to add a description at the top

+ of each category page.

+ from .category_meta import *

+ '''Copyright 2014, 2015 Zack Weinberg

+ 

+ Category Metadata

+ -----------------

+ 

+ A plugin to read metadata for each category from an index file in that

+ category's directory.

+ 

+ For this plugin to work properly, your articles should not have a

+ Category: tag in their metadata; instead, they should be stored in

+ (subdirectories of) per-category directories.  Each per-category

+ directory must have a file named 'index.ext' at its top level, where

+ .ext is any extension that will be picked up by an article reader.

+ The metadata of that article becomes the metadata for the category,

+ copied over verbatim, with three special cases:

+ 

+  * The category's name is set to the article's title.

+  * The category's slug is set to the name of the parent directory

+    of the index.ext file.

+  * The _text_ of the article is stored as category.description.

+ '''

+ 

+ from pelican import signals

+ import os

+ import re

+ 

+ import logging

+ logger = logging.getLogger(__name__)

+ 

+ ### CORE BUG: https://github.com/getpelican/pelican/issues/1547

+ ### Content.url_format does not honor category.slug (or author.slug).

+ ### The sanest way to work around this is to dynamically redefine each

+ ### article's class to a subclass of itself with the bug fixed.

+ ###

+ ### Core was fixed in rev 822fb134e041c6938c253dd4db71813c4d0dc74a,

+ ### which is not yet in any release, so we dynamically detect whether

+ ### the installed version of Pelican still has the bug.

+ 

+ patched_subclasses = {}

+ def make_patched_subclass(klass):

+     if klass.__name__ not in patched_subclasses:

+         class PatchedContent(klass):

+             @property

+             def url_format(self):

+                 metadata = super(PatchedContent, self).url_format

+                 if hasattr(self, 'author'):

+                     metadata['author'] = self.author.slug

+                 if hasattr(self, 'category'):

+                     metadata['category'] = self.category.slug

+ 

+                 return metadata

+         # Code in core uses Content class names as keys for things.

+         PatchedContent.__name__ = klass.__name__

+         patched_subclasses[klass.__name__] = PatchedContent

+     return patched_subclasses[klass.__name__]

+ 

+ def patch_urlformat(cont):

+     # Test whether this content object needs to be patched.

+     md = cont.url_format

+     if ((hasattr(cont, 'author') and cont.author.slug != md['author']) or

+         (hasattr(cont, 'category') and cont.category.slug != md['category'])):

+         logger.debug("Detected bug 1547, applying workaround.")

+         cont.__class__ = make_patched_subclass(cont.__class__)

+ 

+ ### END OF BUG WORKAROUND

+ 

+ def make_category(article, slug):

+     # Reuse the article's existing category object.

+     category = article.category

+ 

+     # Setting a category's name resets its slug, so do that first.

+     category.name = article.title

+     category.slug = slug

+     category.summary = article.summary

+ 

+     # Description from article text.

+     # XXX Relative URLs in the article content may not be handled correctly.

+     setattr(category, 'description', article.content)

+ 

+     # Metadata, to the extent that this makes sense.

+     for k, v in article.metadata.items():

+         if k not in ('path', 'slug', 'category', 'name', 'title',

+                      'description', 'reader'):

+             setattr(category, k, v)

+ 

+     logger.debug("Category: %s -> %s", category.slug, category.name)

+     return category

+ 

+ def pretaxonomy_hook(generator):

+     """This hook is invoked before the generator's .categories property is

+        filled in. Each article has already been assigned a category

+        object, but these objects are _not_ unique per category and so are

+        not safe to tack metadata onto (as is).

+ 

+        The category metadata we're looking for is represented as an

+        Article object, one per directory, whose filename is 'index.ext'.

+     """

+ 

+     category_objects = {}

+     real_articles = []

+ 

+     for article in generator.articles:

+         dirname, fname = os.path.split(article.source_path)

+         fname, _ = os.path.splitext(fname)

+         if fname == 'index':

+             category_objects[dirname] = \

+                 make_category(article, os.path.basename(dirname))

+         else:

+             real_articles.append(article)

+ 

+     category_assignment = \

+         re.compile("^(" +

+                    "|".join(re.escape(prefix)

+                             for prefix in category_objects.keys()) +

+                    ")/")

+ 

+     for article in real_articles:

+         m = category_assignment.match(article.source_path)

+         if not m or m.group(1) not in category_objects:

+             logger.error("No category assignment for %s (%s)",

+                          article, article.source_path)

+             continue

+ 

+         article.category = category_objects[m.group(1)]

+         patch_urlformat(article)

+ 

+     generator.articles = real_articles

+ 

+ def register():

+     signals.article_generator_pretaxonomy.connect(pretaxonomy_hook)

+ Use Git commit to determine page date

+ ======================================

+ If the blog content is managed by git repo, this plugin will set articles'

+ and pages' ``metadata['date']`` according to git commit. This plugin depends

+ on python package ``gitpython``, install::

+ 

+     pip install gitpython

+ 

+ The date is determined via the following logic:

+ 

+ * if a file is not tracked by Git, or a file is staged but never committed

+     - metadata['date'] = filesystem time

+     - metadata['modified'] = filesystem time

+ * if a file is tracked, but no changes in staging area or working directory

+     - metadata['date'] = first commit time

+     - metadata['modified'] = last commit time

+ * if a file is tracked, and has changes in stage area or working directory

+     - metadata['date'] = first commit time

+     - metadata['modified'] = filesystem time

+ 

+ When this module is enabled, ``date`` and ``modified`` will be determined

+ by Git status; no need to manually set in article/page metadata. And

+ operations like copy and move will not affect the generated results.

+ 

+ If you don't want a given article or page to use the Git time, set the

+ metadata to ``gittime: off`` to disable it.

+ 

+ Other options

+ -------------

+ 

+ ### GIT_HISTORY_FOLLOWS_RENAME (default True)

+ You can also set GIT_HISTORY_FOLLOWS_RENAME to True in your pelican config to 

+ make the plugin follow file renames i.e. ensure the creation date matches

+ the original file creation date, not the date is was renamed.

+ 

+ ### GIT_GENERATE_PERMALINK (default False)

+ Use in combination with permalink plugin to generate permalinks using the original

+ commit sha 

+ 

+ ### GIT_SHA_METADATA (default True)

+ Adds sha of current and oldest commit to metadata

+ 

+ ### GIT_FILETIME_FROM_GIT (default True)

+ Enable filetime from git behaviour

+ 

+ Content specific options

+ ------------------------

+ Adding metadata `gittime` = False will prevent the plugin trying to setting filetime for this

+ content.

+ 

+ Adding metadata `git_permalink` = False will prevent the plugin from adding permalink for this

+ content.

+ 

+ FAQ

+ ---

+ 

+ ### Q. I get a GitCommandError: 'git rev-list ...' when I run the plugin. What's up?

+ Be sure to use the correct gitpython module for your distros git binary.

+ Using the GIT_HISTORY_FOLLOWS_RENAME option to True may also make your problem go away as it uses

+ a different method to find commits.

+ from .registration import *

+ # -*- coding: utf-8 -*-

+ import base64

+ import hashlib

+ import os

+ import logging

+ from pelican.utils import strftime

+ from .utils import string_to_bool

+ from .utils import datetime_from_timestamp

+ from .registration import content_git_object_init

+ 

+ 

+ logger = logging.getLogger(__name__)

+ 

+ 

+ @content_git_object_init.connect

+ def filetime_from_git(content, git_content):

+     '''

+     Update modification and creation times from git

+     '''

+     if not content.settings['GIT_FILETIME_FROM_GIT']:

+         # Disabled for everything

+         return

+ 

+     if not string_to_bool(content.metadata.get('gittime', 'yes')):

+         # Disable for this content

+         return

+ 

+     path = content.source_path

+     fs_creation_time = datetime_from_timestamp(os.stat(path).st_ctime, content)

+     fs_modified_time = datetime_from_timestamp(os.stat(path).st_mtime, content)

+ 

+     # 1. file is not managed by git

+     #    date: fs time

+     # 2. file is staged, but has no commits

+     #    date: fs time

+     # 3. file is managed, and clean

+     #    date: first commit time, update: last commit time or None

+     # 4. file is managed, but dirty

+     #    date: first commit time, update: fs time

+     if git_content.is_managed_by_git():

+         if git_content.is_committed():

+             content.date = git_content.get_oldest_commit_date()

+ 

+             if git_content.is_modified():

+                 content.modified = fs_modified_time

+             else:

+                 content.modified = git_content.get_newest_commit_date()

+         else:

+             # File isn't committed

+             content.date = fs_creation_time

+     else:

+         # file is not managed by git

+         content.date = fs_creation_time

+ 

+     # Clean up content attributes

+     if not hasattr(content, 'modified'):

+         content.modified = content.date

+ 

+     if hasattr(content, 'date'):

+         content.locale_date = strftime(content.date, content.date_format)

+ 

+     if hasattr(content, 'modified'):

+         content.locale_modified = strftime(

+             content.modified, content.date_format)

+ 

+ 

+ @content_git_object_init.connect

+ def git_sha_metadata(content, git_content):

+     '''

+     Add sha metadata to content

+     '''

+     if not content.settings['GIT_SHA_METADATA']:

+         return

+ 

+     if not git_content.is_committed():

+         return

+ 

+     content.metadata['gitsha_newest'] = str(git_content.get_newest_commit())

+     content.metadata['gitsha_oldest'] = str(git_content.get_oldest_commit())

+ 

+ 

+ @content_git_object_init.connect

+ def git_permalink(content, git_content):

+     '''

+     Add git based permalink id to content metadata

+     '''

+     if not content.settings['GIT_GENERATE_PERMALINK']:

+         return

+ 

+     if not string_to_bool(content.metadata.get('git_permalink', 'yes')):

+         # Disable for this content

+         return

+ 

+     if not git_content.is_committed():

+         return

+ 

+     permalink_hash = hashlib.sha1()

+     permalink_hash.update(str(git_content.get_oldest_commit()))

+     permalink_hash.update(str(git_content.get_oldest_filename()))

+     git_permalink_id = base64.urlsafe_b64encode(permalink_hash.digest())

+     permalink_id_metadata_key = content.settings['PERMALINK_ID_METADATA_KEY']

+ 

+     if permalink_id_metadata_key in content.metadata:

+         content.metadata[permalink_id_metadata_key] = (

+             ','.join((

+                 content.metadata[permalink_id_metadata_key], git_permalink_id)))

+     else:

+         content.metadata[permalink_id_metadata_key] = git_permalink_id

+ # -*- coding: utf-8 -*-

+ """

+ Wraps a content object to provide some git information

+ """

+ import logging

+ from pelican.utils import memoized

+ from .git_wrapper import git_wrapper

+ 

+ DEV_LOGGER = logging.getLogger(__name__)

+ 

+ 

+ class GitContentAdapter(object):

+     """

+     Wraps a content object to provide some git information

+     """

+     def __init__(self, content):

+         self.content = content

+         self.git = git_wrapper('.')

+         self.tz_name = content.settings.get('TIMEZONE', None)

+         self.follow = content.settings['GIT_HISTORY_FOLLOWS_RENAME']

+ 

+     @memoized

+     def is_committed(self):

+         '''

+         Is committed

+         '''

+         return len(self.get_commits()) > 0

+ 

+     @memoized

+     def is_modified(self):

+         '''

+         Has content been modified since last commit

+         '''

+         return self.git.is_file_modified(self.content.source_path)

+ 

+     @memoized

+     def is_managed_by_git(self):

+         '''

+         Is content stored in a file managed by git

+         '''

+         return self.git.is_file_managed_by_git(self.content.source_path)

+ 

+     @memoized

+     def get_commits(self):

+         '''

+         Get all commits involving this filename

+         :returns: List of commits newest to oldest

+         '''

+         if not self.is_managed_by_git():

+             return []

+         return self.git.get_commits(self.content.source_path, self.follow)

+ 

+     @memoized

+     def get_oldest_commit(self):

+         '''

+         Get oldest commit involving this file

+ 

+         :returns: Oldest commit

+         '''

+         return self.git.get_commits(self.content.source_path, self.follow)[-1]

+ 

+     @memoized

+     def get_newest_commit(self):

+         '''

+         Get oldest commit involving this file

+ 

+         :returns: Newest commit

+         '''

+         return self.git.get_commits(self.content.source_path, follow=False)[0]

+ 

+     @memoized

+     def get_oldest_filename(self):

+         '''

+         Get the original filename of this content. Implies follow

+         '''

+         commit_and_name_iter = self.git.get_commits_and_names_iter(

+             self.content.source_path)

+         _commit, name = commit_and_name_iter.next()

+         return name

+ 

+     @memoized

+     def get_oldest_commit_date(self):

+         '''

+         Get datetime of oldest commit involving this file

+ 

+         :returns: Datetime of oldest commit

+         '''

+         oldest_commit = self.get_oldest_commit()

+         return self.git.get_commit_date(oldest_commit, self.tz_name)

+ 

+     @memoized

+     def get_newest_commit_date(self):

+         '''

+         Get datetime of newest commit involving this file

+ 

+         :returns: Datetime of newest commit

+         '''

+         newest_commit = self.get_newest_commit()

+         return self.git.get_commit_date(newest_commit, self.tz_name)

+ # -*- coding: utf-8 -*-