mirror of https://github.com/patacrep/patacrep.git
Luthaf
11 years ago
19 changed files with 790 additions and 288 deletions
@ -0,0 +1,226 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Content plugin management. |
|||
|
|||
Content that can be included in a songbook is controlled by plugins. From the |
|||
user (or .sb file) point of view, each piece of content is introduced by a |
|||
keyword. This keywold is associated with a plugin (a submodule of this very |
|||
module), which parses the content, and return a list of instances of the |
|||
Content class. |
|||
|
|||
# Plugin definition |
|||
|
|||
A plugin is a submodule of this module, which have a variable |
|||
CONTENT_PLUGINS, which is a dictionary where: |
|||
- keys are keywords, |
|||
- values are parsers (see below). |
|||
|
|||
When analysing the content field of the .sb file, when those keywords are |
|||
met, the corresponding parser is called. |
|||
|
|||
# Parsers |
|||
|
|||
A parser is a function which takes as arguments: |
|||
- keyword: the keyword triggering this function; |
|||
- argument: the argument of the keyword (see below); |
|||
- contentlist: the list of content, that is, the part of the list |
|||
following the keyword (see example below); |
|||
- config: the configuration object of the current songbook. Plugins can |
|||
change it. |
|||
|
|||
A parser returns a list of instances of the Content class, defined in |
|||
this module (or of subclasses of this class). |
|||
|
|||
Example: When the following piece of content is met |
|||
|
|||
["sorted(author, @title)", "a_song.sg", "another_song.sg"] |
|||
|
|||
the parser associated to keyword 'sorted' get the arguments: |
|||
- keyword = "sorted" |
|||
- argument = "author, @title" |
|||
- contentlist = ["a_song.sg", "another_song.sg"] |
|||
- config = <the config file of the current songbook>. |
|||
|
|||
# Keyword |
|||
|
|||
A keyword is either an identifier (alphanumeric characters, and underscore), |
|||
or such an identifier, with some text surrounded by parenthesis (like a |
|||
function definition); this text is called the argument to the keyword. |
|||
Examples: |
|||
- sorted |
|||
- sorted(author, @title) |
|||
- cwd(some/path) |
|||
|
|||
If the keyword has an argument, it can be anything, given that it is |
|||
surrounded by parenthesis. It is up to the plugin to parse this argument. For |
|||
intance, keyword "foo()(( bar()" is a perfectly valid keyword, and the parser |
|||
associated to "foo" will get as argument the string ")(( bar(". |
|||
|
|||
# Content class |
|||
|
|||
The content classes are subclasses of class Content defined in this module. |
|||
Content is a perfectly valid class, but instances of it will not generate |
|||
anything in the resulting .tex. |
|||
|
|||
More documentation in the docstring of Content. |
|||
|
|||
""" |
|||
|
|||
import glob |
|||
import importlib |
|||
import jinja2 |
|||
import logging |
|||
import os |
|||
import re |
|||
|
|||
from patacrep import files |
|||
from patacrep.errors import SongbookError |
|||
|
|||
LOGGER = logging.getLogger(__name__) |
|||
EOL = '\n' |
|||
|
|||
#pylint: disable=no-self-use |
|||
class Content(object): |
|||
"""Content item. Will render to something in the .tex file. |
|||
|
|||
The current jinja2.runtime.Context is passed to all function defined |
|||
here. |
|||
""" |
|||
|
|||
def render(self, __context): |
|||
"""Render this content item. |
|||
|
|||
Returns a string, to be placed verbatim in the generated .tex file. |
|||
""" |
|||
return "" |
|||
|
|||
# Block management |
|||
|
|||
def begin_new_block(self, __previous, __context): |
|||
"""Return a boolean stating if a new block is to be created. |
|||
|
|||
# Arguments |
|||
|
|||
- __previous: the songbook.content.Content object of the previous item. |
|||
- __context: see Content() documentation. |
|||
|
|||
# Return |
|||
|
|||
- True if the renderer has to close previous block, and begin a new |
|||
one, |
|||
- False otherwise (the generated code for this item is part of the |
|||
current block). |
|||
""" |
|||
return True |
|||
|
|||
def begin_block(self, __context): |
|||
"""Return the string to begin a block.""" |
|||
return "" |
|||
|
|||
def end_block(self, __context): |
|||
"""Return the string to end a block.""" |
|||
return "" |
|||
|
|||
class ContentError(SongbookError): |
|||
"""Error in a content plugin.""" |
|||
def __init__(self, keyword, message): |
|||
super(ContentError, self).__init__() |
|||
self.keyword = keyword |
|||
self.message = message |
|||
|
|||
def __str__(self): |
|||
return "Content: {}: {}".format(self.keyword, self.message) |
|||
|
|||
def load_plugins(): |
|||
"""Load all content plugins, and return a dictionary of those plugins. |
|||
|
|||
Return value: a dictionary where: |
|||
- keys are the keywords ; |
|||
- values are functions triggered when this keyword is met. |
|||
""" |
|||
plugins = {} |
|||
for name in glob.glob(os.path.join(os.path.dirname(__file__), "*.py")): |
|||
if name.endswith(".py") and os.path.basename(name) != "__init__.py": |
|||
plugin = importlib.import_module( |
|||
'patacrep.content.{}'.format( |
|||
os.path.basename(name[:-len('.py')]) |
|||
) |
|||
) |
|||
for (key, value) in plugin.CONTENT_PLUGINS.items(): |
|||
if key in plugins: |
|||
LOGGER.warning( |
|||
"File %s: Keyword '%s' is already used. Ignored.", |
|||
files.relpath(name), |
|||
key, |
|||
) |
|||
continue |
|||
plugins[key] = value |
|||
return plugins |
|||
|
|||
@jinja2.contextfunction |
|||
def render_content(context, content): |
|||
"""Render the content of the songbook as a LaTeX code. |
|||
|
|||
Arguments: |
|||
- context: the jinja2.runtime.context of the current template |
|||
compilation. |
|||
- content: a list of Content() instances, as the one that was returned by |
|||
process_content(). |
|||
""" |
|||
rendered = "" |
|||
previous = None |
|||
last = None |
|||
for elem in content: |
|||
if not isinstance(elem, Content): |
|||
LOGGER.error("Ignoring bad content item '{}'.".format(elem)) |
|||
continue |
|||
|
|||
last = elem |
|||
if elem.begin_new_block(previous, context): |
|||
if previous: |
|||
rendered += previous.end_block(context) + EOL |
|||
rendered += elem.begin_block(context) + EOL |
|||
rendered += elem.render(context) + EOL |
|||
previous = elem |
|||
|
|||
if isinstance(last, Content): |
|||
rendered += last.end_block(context) + EOL |
|||
|
|||
return rendered |
|||
|
|||
def process_content(content, config=None): |
|||
"""Process content, and return a list of Content() objects. |
|||
|
|||
Arguments are: |
|||
- content: the content field of the .sb file, which should be a list, and |
|||
describe what is to be included in the songbook; |
|||
- config: the configuration dictionary of the current songbook. |
|||
|
|||
Return: a list of Content objects, corresponding to the content to be |
|||
included in the .tex file. |
|||
""" |
|||
contentlist = [] |
|||
plugins = load_plugins() |
|||
keyword_re = re.compile(r'^ *(?P<keyword>\w*) *(\((?P<argument>.*)\))? *$') |
|||
if not content: |
|||
content = [["song"]] |
|||
for elem in content: |
|||
if isinstance(elem, basestring): |
|||
elem = ["song", elem] |
|||
if len(content) == 0: |
|||
content = ["song"] |
|||
try: |
|||
match = keyword_re.match(elem[0]).groupdict() |
|||
except AttributeError: |
|||
raise ContentError(elem[0], "Cannot parse content type.") |
|||
(keyword, argument) = (match['keyword'], match['argument']) |
|||
if keyword not in plugins: |
|||
raise ContentError(keyword, "Unknown content type.") |
|||
contentlist.extend(plugins[keyword]( |
|||
keyword, |
|||
argument=argument, |
|||
contentlist=elem[1:], |
|||
config=config, |
|||
)) |
|||
return contentlist |
|||
@ -0,0 +1,39 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Change base directory before importing songs.""" |
|||
|
|||
import os |
|||
|
|||
from patacrep.content import process_content |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, config, argument, contentlist): |
|||
"""Return a list songs included in contentlist, whith a different base path. |
|||
|
|||
Arguments: |
|||
- keyword: unused; |
|||
- config: the current songbook configuration dictionary; |
|||
- argument: a directory; |
|||
- contentlist: songbook content, that is parsed by |
|||
patacrep.content.process_content(). |
|||
|
|||
This function adds 'argument' to the directories where songs are searched |
|||
for, and then processes the content. |
|||
|
|||
The 'argument' is added: |
|||
- first as a relative path to the current directory; |
|||
- then as a relative path to every path already present in |
|||
config['songdir']. |
|||
""" |
|||
old_songdir = config['_songdir'] |
|||
config['_songdir'] = ( |
|||
[argument] + |
|||
[os.path.join(path, argument) for path in config['_songdir']] + |
|||
config['_songdir'] |
|||
) |
|||
processed_content = process_content(contentlist, config) |
|||
config['_songdir'] = old_songdir |
|||
return processed_content |
|||
|
|||
CONTENT_PLUGINS = {'cwd': parse} |
|||
@ -0,0 +1,60 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Allow LaTeX sections (starred or not) as content of a songbook.""" |
|||
|
|||
from patacrep.content import Content, ContentError |
|||
|
|||
KEYWORDS = [ |
|||
"part", |
|||
"chapter", |
|||
"section", |
|||
"subsection", |
|||
"subsubsection", |
|||
"paragraph", |
|||
"subparagraph", |
|||
] |
|||
FULL_KEYWORDS = KEYWORDS + ["{}*".format(word) for word in KEYWORDS] |
|||
|
|||
class Section(Content): |
|||
"""A LaTeX section.""" |
|||
|
|||
def __init__(self, keyword, name, short=None): |
|||
self.keyword = keyword |
|||
self.name = name |
|||
self.short = short |
|||
|
|||
def render(self, __context): |
|||
if self.short is None: |
|||
return r'\{}{{{}}}'.format(self.keyword, self.name) |
|||
else: |
|||
return r'\{}[{}]{{{}}}'.format(self.keyword, self.short, self.name) |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, argument, contentlist, config): |
|||
"""Parse the contentlist. |
|||
|
|||
Arguments: |
|||
- keyword (one of "part", "chapter", "section", ... , "subparagraph", and |
|||
their starred versions "part*", "chapter*", ... , "subparagraph*"): the |
|||
section to use; |
|||
- argument: unused; |
|||
- contentlist: a list of one or two strings, which are the names (short |
|||
and long) of the section; |
|||
- config: configuration dictionary of the current songbook. |
|||
""" |
|||
if (keyword not in KEYWORDS) and (len(contentlist) != 1): |
|||
raise ContentError( |
|||
keyword, |
|||
"Starred section names must have exactly one argument." |
|||
) |
|||
if (len(contentlist) not in [1, 2]): |
|||
raise ContentError(keyword, "Section can have one or two arguments.") |
|||
return [Section(keyword, *contentlist)] #pylint: disable=star-args |
|||
|
|||
|
|||
CONTENT_PLUGINS = dict([ |
|||
(word, parse) |
|||
for word |
|||
in FULL_KEYWORDS |
|||
]) |
|||
@ -0,0 +1,114 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Plugin to include songs to the songbook.""" |
|||
|
|||
import glob |
|||
import jinja2 |
|||
import logging |
|||
import os |
|||
|
|||
from patacrep.content import Content, process_content, ContentError |
|||
from patacrep import files |
|||
from patacrep.songs import Song |
|||
|
|||
LOGGER = logging.getLogger(__name__) |
|||
|
|||
class SongRenderer(Content, Song): |
|||
"""Render a song in the .tex file.""" |
|||
|
|||
def begin_new_block(self, previous, __context): |
|||
"""Return a boolean stating if a new block is to be created.""" |
|||
return not isinstance(previous, SongRenderer) |
|||
|
|||
def begin_block(self, context): |
|||
"""Return the string to begin a block.""" |
|||
indexes = context.resolve("indexes") |
|||
if isinstance(indexes, jinja2.runtime.Undefined): |
|||
indexes = "" |
|||
return r'\begin{songs}{%s}' % indexes |
|||
|
|||
def end_block(self, __context): |
|||
"""Return the string to end a block.""" |
|||
return r'\end{songs}' |
|||
|
|||
def render(self, context): |
|||
"""Return the string that will render the song.""" |
|||
return r'\input{{{}}}'.format(files.relpath( |
|||
self.path, |
|||
os.path.dirname(context['filename']) |
|||
)) |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, argument, contentlist, config): |
|||
"""Parse data associated with keyword 'song'. |
|||
|
|||
Arguments: |
|||
- keyword: unused; |
|||
- argument: unused; |
|||
- contentlist: a list of strings, which are interpreted as regular |
|||
expressions (interpreted using the glob module), referring to songs. |
|||
- config: the current songbook configuration dictionary. |
|||
|
|||
Return a list of SongRenderer() instances. |
|||
""" |
|||
if 'languages' not in config: |
|||
config['_languages'] = set() |
|||
songlist = [] |
|||
for songdir in config['_songdir']: |
|||
if contentlist: |
|||
break |
|||
contentlist = [ |
|||
files.relpath(filename, songdir) |
|||
for filename |
|||
in files.recursive_find(songdir, "*.sg") |
|||
] |
|||
for elem in contentlist: |
|||
before = len(songlist) |
|||
for songdir in config['_songdir']: |
|||
for filename in glob.iglob(os.path.join(songdir, elem)): |
|||
LOGGER.debug('Parsing file "{}"…'.format(filename)) |
|||
song = SongRenderer(filename, config) |
|||
songlist.append(song) |
|||
config["_languages"].update(song.languages) |
|||
if len(songlist) > before: |
|||
break |
|||
if len(songlist) == before: |
|||
# No songs were added |
|||
LOGGER.warning( |
|||
"Expression '{}' did not match any file".format(elem) |
|||
) |
|||
return songlist |
|||
|
|||
|
|||
CONTENT_PLUGINS = {'song': parse} |
|||
|
|||
|
|||
class OnlySongsError(ContentError): |
|||
"A list that should contain only songs also contain other type of content." |
|||
def __init__(self, not_songs): |
|||
super(OnlySongsError, self).__init__() |
|||
self.not_songs = not_songs |
|||
|
|||
def __str__(self): |
|||
return ( |
|||
"Only songs are allowed, and the following items are not:" + |
|||
str(self.not_songs) |
|||
) |
|||
|
|||
def process_songs(content, config=None): |
|||
"""Process content that containt only songs. |
|||
|
|||
Call patacrep.content.process_content(), checks if the returned list |
|||
contains only songs, and raise an exception if not. |
|||
""" |
|||
contentlist = process_content(content, config) |
|||
not_songs = [ |
|||
item |
|||
for item |
|||
in contentlist |
|||
if not isinstance(item, SongRenderer) |
|||
] |
|||
if not_songs: |
|||
raise OnlySongsError(not_songs) |
|||
return contentlist |
|||
@ -0,0 +1,46 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Allow 'songchapter' and 'songsection' as content of a songbook.""" |
|||
|
|||
from patacrep.content import Content, ContentError |
|||
|
|||
KEYWORDS = [ |
|||
"songchapter", |
|||
"songsection", |
|||
] |
|||
|
|||
class SongSection(Content): |
|||
"""A songsection or songchapter.""" |
|||
|
|||
def __init__(self, keyword, name): |
|||
self.keyword = keyword |
|||
self.name = name |
|||
|
|||
def render(self, __context): |
|||
"""Render this section or chapter.""" |
|||
return r'\{}{{{}}}'.format(self.keyword, self.name) |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, argument, contentlist, config): |
|||
"""Parse the contentlist. |
|||
|
|||
Arguments: |
|||
- keyword ("songsection" or "songchapter"): the section to use; |
|||
- argument: unused; |
|||
- contentlist: a list of one string, which is the name of the section; |
|||
- config: configuration dictionary of the current songbook. |
|||
""" |
|||
if (keyword not in KEYWORDS) and (len(contentlist) != 1): |
|||
raise ContentError( |
|||
keyword, |
|||
"Starred section names must have exactly one argument.", |
|||
) |
|||
return [SongSection(keyword, contentlist[0])] |
|||
|
|||
|
|||
CONTENT_PLUGINS = dict([ |
|||
(word, parse) |
|||
for word |
|||
in KEYWORDS |
|||
]) |
|||
@ -0,0 +1,96 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Sorted list of songs. |
|||
|
|||
This plugin provides keyword 'sorted', used to include a sorted list of songs |
|||
to a songbook. |
|||
""" |
|||
|
|||
import locale |
|||
import logging |
|||
|
|||
from patacrep import files |
|||
from patacrep.content import ContentError |
|||
from patacrep.content.song import OnlySongsError, process_songs |
|||
|
|||
LOGGER = logging.getLogger(__name__) |
|||
|
|||
DEFAULT_SORT = ['by', 'album', '@title'] |
|||
|
|||
def normalize_string(string): |
|||
"""Return a normalized string. |
|||
|
|||
Normalized means: |
|||
- no surrounding spaces; |
|||
- lower case; |
|||
- passed through locale.strxfrm(). |
|||
""" |
|||
return locale.strxfrm(string.lower().strip()) |
|||
|
|||
def normalize_field(field): |
|||
"""Return a normalized field, it being a string or a list of strings.""" |
|||
if isinstance(field, basestring): |
|||
return normalize_string(field) |
|||
elif isinstance(field, list): |
|||
return [normalize_string(string) for string in field] |
|||
|
|||
def key_generator(sort): |
|||
"""Return a function that returns the list of values used to sort the song. |
|||
|
|||
Arguments: |
|||
- sort: the list of keys used to sort. |
|||
""" |
|||
|
|||
def ordered_song_keys(song): |
|||
"""Return the list of values used to sort the song.""" |
|||
songkey = [] |
|||
for key in sort: |
|||
if key == "@title": |
|||
field = song.unprefixed_titles |
|||
elif key == "@path": |
|||
field = song.path |
|||
elif key == "by": |
|||
field = song.authors |
|||
else: |
|||
try: |
|||
field = song.args[key] |
|||
except KeyError: |
|||
LOGGER.debug( |
|||
"Ignoring unknown key '{}' for song {}.".format( |
|||
key, |
|||
files.relpath(song.path), |
|||
) |
|||
) |
|||
field = "" |
|||
songkey.append(normalize_field(field)) |
|||
return songkey |
|||
return ordered_song_keys |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, config, argument, contentlist): |
|||
"""Return a sorted list of songs contained in 'contentlist'. |
|||
|
|||
Arguments: |
|||
- keyword: the string 'sorted'; |
|||
- config: the current songbook configuration dictionary; |
|||
- argument: the list of the fields used to sort songs, as strings |
|||
separated by commas (e.g. "by, album, @title"); |
|||
- contentlist: the list of content to be sorted. If this content |
|||
contain something else than a song, an exception is raised. |
|||
""" |
|||
if argument: |
|||
sort = [key.strip() for key in argument.split(",")] |
|||
else: |
|||
sort = DEFAULT_SORT |
|||
try: |
|||
songlist = process_songs(contentlist, config) |
|||
except OnlySongsError as error: |
|||
raise ContentError(keyword, ( |
|||
"Content list of this keyword can be only songs (or content " |
|||
"that result into songs), and the following are not:" + |
|||
str(error.not_songs) |
|||
)) |
|||
return sorted(songlist, key=key_generator(sort)) |
|||
|
|||
CONTENT_PLUGINS = {'sorted': parse} |
|||
@ -0,0 +1,58 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
"""Include LaTeX raw code in the songbook.""" |
|||
|
|||
import logging |
|||
import os |
|||
|
|||
from patacrep import files |
|||
from patacrep.content import Content |
|||
|
|||
LOGGER = logging.getLogger(__name__) |
|||
|
|||
class LaTeX(Content): |
|||
"""Inclusion of LaTeX code""" |
|||
|
|||
def __init__(self, filename): |
|||
self.filename = filename |
|||
|
|||
def render(self, context): |
|||
return r'\input{{{}}}'.format(files.relpath( |
|||
self.filename, |
|||
os.path.dirname(context['filename']), |
|||
)) |
|||
|
|||
#pylint: disable=unused-argument |
|||
def parse(keyword, argument, contentlist, config): |
|||
"""Parse the contentlist. |
|||
|
|||
Arguments: |
|||
- keyword: unused; |
|||
- argument: unused; |
|||
- contentlist: a list of name of tex files; |
|||
- config: configuration dictionary of the current songbook. |
|||
""" |
|||
if not contentlist: |
|||
LOGGER.warning( |
|||
"Useless 'tex' content: list of files to include is empty." |
|||
) |
|||
filelist = [] |
|||
for filename in contentlist: |
|||
checked_file = None |
|||
for path in config['_songdir']: |
|||
if os.path.exists(os.path.join(path, filename)): |
|||
checked_file = os.path.relpath(os.path.join(path, filename)) |
|||
break |
|||
if not checked_file: |
|||
LOGGER.warning( |
|||
("Cannot find file '{}' in '{}'. Compilation may fail " |
|||
"later.").format(filename, str(config['_songdir'])) |
|||
) |
|||
continue |
|||
filelist.append(LaTeX(checked_file)) |
|||
|
|||
return filelist |
|||
|
|||
|
|||
CONTENT_PLUGINS = {'tex': parse} |
|||
Loading…
Reference in new issue