def add_category(generator): tag = Tag('mozilla', generator.settings) for article in generator.articles: if not hasattr(article, 'tags'): setattr(article, 'tags', [ tag, ])
def _parse_metadata(self, meta): """Parse and sanitize metadata""" _DEL = object() # Used as a sentinel FCNS = { 'tags': lambda x, y: [Tag(t, y) for t in self._to_list(x)] or _DEL, 'date': lambda x, y: get_date(x) if x else _DEL, 'modified': lambda x, y: get_date(x) if x else _DEL, 'category': lambda x, y: Category(x, y) if x else _DEL, 'author': lambda x, y: Author(x, y) if x else _DEL, 'authors': lambda x, y: [Author(a, y) for a in self._to_list(x)] or _DEL, 'default': lambda x, y: x } out = {} for k, v in meta.items(): k = k.lower() if k in self.settings['FORMATTED_FIELDS']: self._md.reset() temp = self._md.convert("\n".join(self._to_list(v))) else: temp = FCNS.get(k, FCNS["default"])(v, self.settings) if temp is not _DEL: out[k] = temp return out
def test_slugify_tags_with_dots(self): settings = get_settings() settings['TAG_SUBSTITUTIONS'] = [('Fedora QA', 'fedora.qa', True)] settings['ARTICLE_URL'] = '{tag}/{slug}/' article_kwargs = self._copy_page_kwargs() article_kwargs['metadata']['tag'] = Tag('Fedora QA', settings) article_kwargs['metadata']['title'] = 'This Week in Fedora QA' article_kwargs['settings'] = settings article = Article(**article_kwargs) self.assertEqual(article.url, 'fedora.qa/this-week-in-fedora-qa/')
def _new_tag(tag_text, article, global_tags): """ Given the TAG_TEXT, an ARTICLE it applies to, and the defaultdict of GLOBAL_TAGS, add the relevant tags. Returns the Tag(...) for TAG_TEXT. """ tag = Tag(tag_text, article.settings) tags = getattr(article, 'tags', []) tags.append(tag) article.tags = list(set(tags)) global_tags[tag].append(article) return tag
posixize_path try: from markdown import Markdown except ImportError: Markdown = False # NOQA # Metadata processors have no way to discard an unwanted value, so we have # them return this value instead to signal that it should be discarded later. # This means that _filter_discardable_metadata() must be called on processed # metadata dicts before use, to remove the items with the special value. _DISCARD = object() METADATA_PROCESSORS = { 'tags': lambda x, y: ([Tag(tag, y) for tag in ensure_metadata_list(x)] or _DISCARD), 'date': lambda x, y: get_date(x.replace('_', ' ')), 'modified': lambda x, y: get_date(x), 'status': lambda x, y: x.strip() or _DISCARD, 'category': lambda x, y: _process_if_nonempty(Category, x, y), 'author': lambda x, y: _process_if_nonempty(Author, x, y), 'authors': lambda x, y: ([Author(author, y) for author in ensure_metadata_list(x)] or _DISCARD), 'slug': lambda x, y: x.strip() or _DISCARD,
def replacer(siteurl, m): what = m.group('what') value = urlparse(m.group('value')) path = value.path origin = m.group('path') # XXX Put this in a different location. if what in {'filename', 'attach'}: if path.startswith('/'): path = path[1:] else: # relative to the source path of this content path = content.get_relative_source_path( os.path.join(content.relative_dir, path)) if path not in content._context['filenames']: unquoted_path = path.replace('%20', ' ') if unquoted_path in content._context['filenames']: path = unquoted_path linked_content = content._context['filenames'].get(path) if linked_content: if what == 'attach': if isinstance(linked_content, Static): linked_content.attach_to(content) else: logger.warning( "%s used {attach} link syntax on a " "non-static file. Use {filename} instead.", content.get_relative_source_path()) origin = '/'.join((siteurl, linked_content.url)) origin = origin.replace('\\', '/') # for Windows paths. else: logger.warning( "Unable to find `%s`, skipping url replacement.", value.geturl(), extra={ 'limit_msg': ("Other resources were not found " "and their urls not replaced") }) elif what == 'category': origin = '/'.join((siteurl, Category(path, content.settings).url)) elif what == 'tag': origin = '/'.join((siteurl, Tag(path, content.settings).url)) elif what == 'index': origin = '/'.join((siteurl, content.settings['INDEX_SAVE_AS'])) elif what == 'author': origin = '/'.join((siteurl, Author(path, content.settings).url)) else: logger.warning( "Replacement Indicator '%s' not recognized, " "skipping replacement", what) # keep all other parts, such as query, fragment, etc. parts = list(value) parts[2] = origin origin = urlunparse(parts) return ''.join( (m.group('markup'), m.group('quote'), origin, m.group('quote')))
except ImportError: asciidoc = False try: from html import escape except ImportError: from cgi import escape try: from html.parser import HTMLParser except ImportError: from HTMLParser import HTMLParser from pelican.contents import Category, Tag, Author from pelican.utils import get_date, pelican_open METADATA_PROCESSORS = { 'tags': lambda x, y: [Tag(tag, y) for tag in x.split(',')], 'date': lambda x, y: get_date(x), 'status': lambda x, y: x.strip(), 'category': Category, 'author': Author, } class Reader(object): enabled = True file_extensions = ['static'] extensions = None def __init__(self, settings): self.settings = settings
DUPLICATES_DEFINITIONS_ALLOWED = { 'tags': False, 'date': False, 'modified': False, 'status': False, 'category': False, 'author': False, 'save_as': False, 'url': False, 'authors': False, 'slug': False } METADATA_PROCESSORS = { 'tags': lambda x, y: ([ Tag(tag, y) for tag in ensure_metadata_list(x) ] or _DISCARD), 'date': lambda x, y: get_date(x.replace('_', ' ')), 'modified': lambda x, y: get_date(x), 'status': lambda x, y: x.strip() or _DISCARD, 'category': lambda x, y: _process_if_nonempty(Category, x, y), 'author': lambda x, y: _process_if_nonempty(Author, x, y), 'authors': lambda x, y: ([ Author(author, y) for author in ensure_metadata_list(x) ] or _DISCARD), 'slug': lambda x, y: x.strip() or _DISCARD, } logger = logging.getLogger(__name__)
# import the directives to have pygments support from pelican import rstdirectives # NOQA except ImportError: core = False try: from markdown import Markdown except ImportError: Markdown = False # NOQA import re from pelican.contents import Category, Tag, Author from pelican.utils import get_date, pelican_open _METADATA_PROCESSORS = { 'tags': lambda x, y: [Tag(tag, y) for tag in unicode(x).split(',')], 'date': lambda x, y: get_date(x), 'status': lambda x, y: unicode.strip(x), 'category': Category, 'author': Author, } class Reader(object): enabled = True extensions = None def __init__(self, settings): self.settings = settings def process_metadata(self, name, value):
logger = logging.getLogger(__name__) HEADER_RE = re.compile( r"^---$" r"(?P<metadata>.+?)" r"^(?:---|\.\.\.)$" r"(?P<content>.*)", re.MULTILINE | re.DOTALL) DUPES_NOT_ALLOWED = \ set(k for k, v in DUPLICATES_DEFINITIONS_ALLOWED.items() if not v) - \ {"tags", "authors"} _DEL = object() YAML_METADATA_PROCESSORS = { 'tags': lambda x, y: [Tag(_strip(t), y) for t in _to_list(x)] or _DEL, 'date': lambda x, y: _parse_date(x), 'modified': lambda x, y: _parse_date(x), 'category': lambda x, y: Category(_strip(x), y) if x else _DEL, 'author': lambda x, y: Author(_strip(x), y) if x else _DEL, 'authors': lambda x, y: [Author(_strip(a), y) for a in _to_list(x)] or _DEL, 'slug': lambda x, y: _strip(x) or _DEL, 'save_as': lambda x, y: _strip(x) or _DEL, 'status': lambda x, y: _strip(x) or _DEL, } def _strip(obj): return str(obj if obj is not None else '').strip()
# them return this value instead to signal that it should be discarded later. # This means that _filter_discardable_metadata() must be called on processed # metadata dicts before use, to remove the items with the special value. _DISCARD = object() def _process_if_nonempty(processor, name, settings): """Removes extra whitespace from name and applies a metadata processor. If name is empty or all whitespace, returns _DISCARD instead. """ name = name.strip() return processor(name, settings) if name else _DISCARD METADATA_PROCESSORS = { 'tags': lambda x, y: [Tag(tag, y) for tag in strip_split(x)] or _DISCARD, 'date': lambda x, y: get_date(x.replace('_', ' ')), 'modified': lambda x, y: get_date(x), 'status': lambda x, y: x.strip() or _DISCARD, 'category': lambda x, y: _process_if_nonempty(Category, x, y), 'author': lambda x, y: _process_if_nonempty(Author, x, y), 'authors': lambda x, y: [Author(a, y) for a in strip_split(x)] or _DISCARD, 'slug': lambda x, y: x.strip() or _DISCARD, } def _filter_discardable_metadata(metadata): """Return a copy of a dict, minus any items marked as discardable.""" return {name: val for name, val in metadata.items() if val is not _DISCARD}