mirror of
https://github.com/janeczku/calibre-web
synced 2024-11-25 02:57:22 +00:00
bbf6d9b026
Bugfix for feeds
- removed categories related and up
- load new books now working
- category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working
563 lines
22 KiB
Python
563 lines
22 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
babel.messages.extract
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Basic infrastructure for extracting localizable messages from source files.
|
|
|
|
This module defines an extensible system for collecting localizable message
|
|
strings from a variety of sources. A native extractor for Python source
|
|
files is builtin, extractors for other sources can be added using very
|
|
simple plugins.
|
|
|
|
The main entry points into the extraction functionality are the functions
|
|
`extract_from_dir` and `extract_from_file`.
|
|
|
|
:copyright: (c) 2013 by the Babel Team.
|
|
:license: BSD, see LICENSE for more details.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
from tokenize import generate_tokens, COMMENT, NAME, OP, STRING
|
|
|
|
from babel.util import parse_encoding, pathmatch, relpath
|
|
from babel._compat import PY2, text_type
|
|
from textwrap import dedent
|
|
|
|
|
|
GROUP_NAME = 'babel.extractors'
|
|
|
|
DEFAULT_KEYWORDS = {
|
|
'_': None,
|
|
'gettext': None,
|
|
'ngettext': (1, 2),
|
|
'ugettext': None,
|
|
'ungettext': (1, 2),
|
|
'dgettext': (2,),
|
|
'dngettext': (2, 3),
|
|
'N_': None,
|
|
'pgettext': ((1, 'c'), 2)
|
|
}
|
|
|
|
DEFAULT_MAPPING = [('**.py', 'python')]
|
|
|
|
empty_msgid_warning = (
|
|
'%s: warning: Empty msgid. It is reserved by GNU gettext: gettext("") '
|
|
'returns the header entry with meta information, not the empty string.')
|
|
|
|
|
|
def _strip_comment_tags(comments, tags):
|
|
"""Helper function for `extract` that strips comment tags from strings
|
|
in a list of comment lines. This functions operates in-place.
|
|
"""
|
|
def _strip(line):
|
|
for tag in tags:
|
|
if line.startswith(tag):
|
|
return line[len(tag):].strip()
|
|
return line
|
|
comments[:] = map(_strip, comments)
|
|
|
|
|
|
def extract_from_dir(dirname=None, method_map=DEFAULT_MAPPING,
|
|
options_map=None, keywords=DEFAULT_KEYWORDS,
|
|
comment_tags=(), callback=None, strip_comment_tags=False):
|
|
"""Extract messages from any source files found in the given directory.
|
|
|
|
This function generates tuples of the form ``(filename, lineno, message,
|
|
comments, context)``.
|
|
|
|
Which extraction method is used per file is determined by the `method_map`
|
|
parameter, which maps extended glob patterns to extraction method names.
|
|
For example, the following is the default mapping:
|
|
|
|
>>> method_map = [
|
|
... ('**.py', 'python')
|
|
... ]
|
|
|
|
This basically says that files with the filename extension ".py" at any
|
|
level inside the directory should be processed by the "python" extraction
|
|
method. Files that don't match any of the mapping patterns are ignored. See
|
|
the documentation of the `pathmatch` function for details on the pattern
|
|
syntax.
|
|
|
|
The following extended mapping would also use the "genshi" extraction
|
|
method on any file in "templates" subdirectory:
|
|
|
|
>>> method_map = [
|
|
... ('**/templates/**.*', 'genshi'),
|
|
... ('**.py', 'python')
|
|
... ]
|
|
|
|
The dictionary provided by the optional `options_map` parameter augments
|
|
these mappings. It uses extended glob patterns as keys, and the values are
|
|
dictionaries mapping options names to option values (both strings).
|
|
|
|
The glob patterns of the `options_map` do not necessarily need to be the
|
|
same as those used in the method mapping. For example, while all files in
|
|
the ``templates`` folders in an application may be Genshi applications, the
|
|
options for those files may differ based on extension:
|
|
|
|
>>> options_map = {
|
|
... '**/templates/**.txt': {
|
|
... 'template_class': 'genshi.template:TextTemplate',
|
|
... 'encoding': 'latin-1'
|
|
... },
|
|
... '**/templates/**.html': {
|
|
... 'include_attrs': ''
|
|
... }
|
|
... }
|
|
|
|
:param dirname: the path to the directory to extract messages from. If
|
|
not given the current working directory is used.
|
|
:param method_map: a list of ``(pattern, method)`` tuples that maps of
|
|
extraction method names to extended glob patterns
|
|
:param options_map: a dictionary of additional options (optional)
|
|
:param keywords: a dictionary mapping keywords (i.e. names of functions
|
|
that should be recognized as translation functions) to
|
|
tuples that specify which of their arguments contain
|
|
localizable strings
|
|
:param comment_tags: a list of tags of translator comments to search for
|
|
and include in the results
|
|
:param callback: a function that is called for every file that message are
|
|
extracted from, just before the extraction itself is
|
|
performed; the function is passed the filename, the name
|
|
of the extraction method and and the options dictionary as
|
|
positional arguments, in that order
|
|
:param strip_comment_tags: a flag that if set to `True` causes all comment
|
|
tags to be removed from the collected comments.
|
|
:see: `pathmatch`
|
|
"""
|
|
if dirname is None:
|
|
dirname = os.getcwd()
|
|
if options_map is None:
|
|
options_map = {}
|
|
|
|
absname = os.path.abspath(dirname)
|
|
for root, dirnames, filenames in os.walk(absname):
|
|
for subdir in dirnames:
|
|
if subdir.startswith('.') or subdir.startswith('_'):
|
|
dirnames.remove(subdir)
|
|
dirnames.sort()
|
|
filenames.sort()
|
|
for filename in filenames:
|
|
filename = relpath(
|
|
os.path.join(root, filename).replace(os.sep, '/'),
|
|
dirname
|
|
)
|
|
for pattern, method in method_map:
|
|
if pathmatch(pattern, filename):
|
|
filepath = os.path.join(absname, filename)
|
|
options = {}
|
|
for opattern, odict in options_map.items():
|
|
if pathmatch(opattern, filename):
|
|
options = odict
|
|
if callback:
|
|
callback(filename, method, options)
|
|
for lineno, message, comments, context in \
|
|
extract_from_file(method, filepath,
|
|
keywords=keywords,
|
|
comment_tags=comment_tags,
|
|
options=options,
|
|
strip_comment_tags=
|
|
strip_comment_tags):
|
|
yield filename, lineno, message, comments, context
|
|
break
|
|
|
|
|
|
def extract_from_file(method, filename, keywords=DEFAULT_KEYWORDS,
|
|
comment_tags=(), options=None, strip_comment_tags=False):
|
|
"""Extract messages from a specific file.
|
|
|
|
This function returns a list of tuples of the form ``(lineno, funcname,
|
|
message)``.
|
|
|
|
:param filename: the path to the file to extract messages from
|
|
:param method: a string specifying the extraction method (.e.g. "python")
|
|
:param keywords: a dictionary mapping keywords (i.e. names of functions
|
|
that should be recognized as translation functions) to
|
|
tuples that specify which of their arguments contain
|
|
localizable strings
|
|
:param comment_tags: a list of translator tags to search for and include
|
|
in the results
|
|
:param strip_comment_tags: a flag that if set to `True` causes all comment
|
|
tags to be removed from the collected comments.
|
|
:param options: a dictionary of additional options (optional)
|
|
"""
|
|
fileobj = open(filename, 'rb')
|
|
try:
|
|
return list(extract(method, fileobj, keywords, comment_tags, options,
|
|
strip_comment_tags))
|
|
finally:
|
|
fileobj.close()
|
|
|
|
|
|
def extract(method, fileobj, keywords=DEFAULT_KEYWORDS, comment_tags=(),
|
|
options=None, strip_comment_tags=False):
|
|
"""Extract messages from the given file-like object using the specified
|
|
extraction method.
|
|
|
|
This function returns tuples of the form ``(lineno, message, comments)``.
|
|
|
|
The implementation dispatches the actual extraction to plugins, based on the
|
|
value of the ``method`` parameter.
|
|
|
|
>>> source = '''# foo module
|
|
... def run(argv):
|
|
... print _('Hello, world!')
|
|
... '''
|
|
|
|
>>> from StringIO import StringIO
|
|
>>> for message in extract('python', StringIO(source)):
|
|
... print message
|
|
(3, u'Hello, world!', [], None)
|
|
|
|
:param method: a string specifying the extraction method (.e.g. "python");
|
|
if this is a simple name, the extraction function will be
|
|
looked up by entry point; if it is an explicit reference
|
|
to a function (of the form ``package.module:funcname`` or
|
|
``package.module.funcname``), the corresponding function
|
|
will be imported and used
|
|
:param fileobj: the file-like object the messages should be extracted from
|
|
:param keywords: a dictionary mapping keywords (i.e. names of functions
|
|
that should be recognized as translation functions) to
|
|
tuples that specify which of their arguments contain
|
|
localizable strings
|
|
:param comment_tags: a list of translator tags to search for and include
|
|
in the results
|
|
:param options: a dictionary of additional options (optional)
|
|
:param strip_comment_tags: a flag that if set to `True` causes all comment
|
|
tags to be removed from the collected comments.
|
|
:raise ValueError: if the extraction method is not registered
|
|
"""
|
|
func = None
|
|
if ':' in method or '.' in method:
|
|
if ':' not in method:
|
|
lastdot = method.rfind('.')
|
|
module, attrname = method[:lastdot], method[lastdot + 1:]
|
|
else:
|
|
module, attrname = method.split(':', 1)
|
|
func = getattr(__import__(module, {}, {}, [attrname]), attrname)
|
|
else:
|
|
try:
|
|
from pkg_resources import working_set
|
|
except ImportError:
|
|
pass
|
|
else:
|
|
for entry_point in working_set.iter_entry_points(GROUP_NAME,
|
|
method):
|
|
func = entry_point.load(require=True)
|
|
break
|
|
if func is None:
|
|
# if pkg_resources is not available or no usable egg-info was found
|
|
# (see #230), we resort to looking up the builtin extractors
|
|
# directly
|
|
builtin = {
|
|
'ignore': extract_nothing,
|
|
'python': extract_python,
|
|
'javascript': extract_javascript
|
|
}
|
|
func = builtin.get(method)
|
|
if func is None:
|
|
raise ValueError('Unknown extraction method %r' % method)
|
|
|
|
results = func(fileobj, keywords.keys(), comment_tags,
|
|
options=options or {})
|
|
|
|
for lineno, funcname, messages, comments in results:
|
|
if funcname:
|
|
spec = keywords[funcname] or (1,)
|
|
else:
|
|
spec = (1,)
|
|
if not isinstance(messages, (list, tuple)):
|
|
messages = [messages]
|
|
if not messages:
|
|
continue
|
|
|
|
# Validate the messages against the keyword's specification
|
|
context = None
|
|
msgs = []
|
|
invalid = False
|
|
# last_index is 1 based like the keyword spec
|
|
last_index = len(messages)
|
|
for index in spec:
|
|
if isinstance(index, tuple):
|
|
context = messages[index[0] - 1]
|
|
continue
|
|
if last_index < index:
|
|
# Not enough arguments
|
|
invalid = True
|
|
break
|
|
message = messages[index - 1]
|
|
if message is None:
|
|
invalid = True
|
|
break
|
|
msgs.append(message)
|
|
if invalid:
|
|
continue
|
|
|
|
# keyword spec indexes are 1 based, therefore '-1'
|
|
if isinstance(spec[0], tuple):
|
|
# context-aware *gettext method
|
|
first_msg_index = spec[1] - 1
|
|
else:
|
|
first_msg_index = spec[0] - 1
|
|
if not messages[first_msg_index]:
|
|
# An empty string msgid isn't valid, emit a warning
|
|
where = '%s:%i' % (hasattr(fileobj, 'name') and \
|
|
fileobj.name or '(unknown)', lineno)
|
|
sys.stderr.write((empty_msgid_warning % where) + '\n')
|
|
continue
|
|
|
|
messages = tuple(msgs)
|
|
if len(messages) == 1:
|
|
messages = messages[0]
|
|
|
|
if strip_comment_tags:
|
|
_strip_comment_tags(comments, comment_tags)
|
|
yield lineno, messages, comments, context
|
|
|
|
|
|
def extract_nothing(fileobj, keywords, comment_tags, options):
|
|
"""Pseudo extractor that does not actually extract anything, but simply
|
|
returns an empty list.
|
|
"""
|
|
return []
|
|
|
|
|
|
def extract_python(fileobj, keywords, comment_tags, options):
|
|
"""Extract messages from Python source code.
|
|
|
|
It returns an iterator yielding tuples in the following form ``(lineno,
|
|
funcname, message, comments)``.
|
|
|
|
:param fileobj: the seekable, file-like object the messages should be
|
|
extracted from
|
|
:param keywords: a list of keywords (i.e. function names) that should be
|
|
recognized as translation functions
|
|
:param comment_tags: a list of translator tags to search for and include
|
|
in the results
|
|
:param options: a dictionary of additional options (optional)
|
|
:rtype: ``iterator``
|
|
"""
|
|
funcname = lineno = message_lineno = None
|
|
call_stack = -1
|
|
buf = []
|
|
messages = []
|
|
translator_comments = []
|
|
in_def = in_translator_comments = False
|
|
comment_tag = None
|
|
|
|
encoding = parse_encoding(fileobj) or options.get('encoding', 'iso-8859-1')
|
|
|
|
if PY2:
|
|
next_line = fileobj.readline
|
|
else:
|
|
next_line = lambda: fileobj.readline().decode(encoding)
|
|
|
|
tokens = generate_tokens(next_line)
|
|
for tok, value, (lineno, _), _, _ in tokens:
|
|
if call_stack == -1 and tok == NAME and value in ('def', 'class'):
|
|
in_def = True
|
|
elif tok == OP and value == '(':
|
|
if in_def:
|
|
# Avoid false positives for declarations such as:
|
|
# def gettext(arg='message'):
|
|
in_def = False
|
|
continue
|
|
if funcname:
|
|
message_lineno = lineno
|
|
call_stack += 1
|
|
elif in_def and tok == OP and value == ':':
|
|
# End of a class definition without parens
|
|
in_def = False
|
|
continue
|
|
elif call_stack == -1 and tok == COMMENT:
|
|
# Strip the comment token from the line
|
|
if PY2:
|
|
value = value.decode(encoding)
|
|
value = value[1:].strip()
|
|
if in_translator_comments and \
|
|
translator_comments[-1][0] == lineno - 1:
|
|
# We're already inside a translator comment, continue appending
|
|
translator_comments.append((lineno, value))
|
|
continue
|
|
# If execution reaches this point, let's see if comment line
|
|
# starts with one of the comment tags
|
|
for comment_tag in comment_tags:
|
|
if value.startswith(comment_tag):
|
|
in_translator_comments = True
|
|
translator_comments.append((lineno, value))
|
|
break
|
|
elif funcname and call_stack == 0:
|
|
if tok == OP and value == ')':
|
|
if buf:
|
|
messages.append(''.join(buf))
|
|
del buf[:]
|
|
else:
|
|
messages.append(None)
|
|
|
|
if len(messages) > 1:
|
|
messages = tuple(messages)
|
|
else:
|
|
messages = messages[0]
|
|
# Comments don't apply unless they immediately preceed the
|
|
# message
|
|
if translator_comments and \
|
|
translator_comments[-1][0] < message_lineno - 1:
|
|
translator_comments = []
|
|
|
|
yield (message_lineno, funcname, messages,
|
|
[comment[1] for comment in translator_comments])
|
|
|
|
funcname = lineno = message_lineno = None
|
|
call_stack = -1
|
|
messages = []
|
|
translator_comments = []
|
|
in_translator_comments = False
|
|
elif tok == STRING:
|
|
# Unwrap quotes in a safe manner, maintaining the string's
|
|
# encoding
|
|
# https://sourceforge.net/tracker/?func=detail&atid=355470&
|
|
# aid=617979&group_id=5470
|
|
value = eval('# coding=%s\n%s' % (str(encoding), value),
|
|
{'__builtins__':{}}, {})
|
|
if PY2 and not isinstance(value, text_type):
|
|
value = value.decode(encoding)
|
|
buf.append(value)
|
|
elif tok == OP and value == ',':
|
|
if buf:
|
|
messages.append(''.join(buf))
|
|
del buf[:]
|
|
else:
|
|
messages.append(None)
|
|
if translator_comments:
|
|
# We have translator comments, and since we're on a
|
|
# comma(,) user is allowed to break into a new line
|
|
# Let's increase the last comment's lineno in order
|
|
# for the comment to still be a valid one
|
|
old_lineno, old_comment = translator_comments.pop()
|
|
translator_comments.append((old_lineno+1, old_comment))
|
|
elif call_stack > 0 and tok == OP and value == ')':
|
|
call_stack -= 1
|
|
elif funcname and call_stack == -1:
|
|
funcname = None
|
|
elif tok == NAME and value in keywords:
|
|
funcname = value
|
|
|
|
|
|
def extract_javascript(fileobj, keywords, comment_tags, options):
|
|
"""Extract messages from JavaScript source code.
|
|
|
|
:param fileobj: the seekable, file-like object the messages should be
|
|
extracted from
|
|
:param keywords: a list of keywords (i.e. function names) that should be
|
|
recognized as translation functions
|
|
:param comment_tags: a list of translator tags to search for and include
|
|
in the results
|
|
:param options: a dictionary of additional options (optional)
|
|
"""
|
|
from babel.messages.jslexer import tokenize, unquote_string
|
|
funcname = message_lineno = None
|
|
messages = []
|
|
last_argument = None
|
|
translator_comments = []
|
|
concatenate_next = False
|
|
encoding = options.get('encoding', 'utf-8')
|
|
last_token = None
|
|
call_stack = -1
|
|
|
|
for token in tokenize(fileobj.read().decode(encoding)):
|
|
if token.type == 'operator' and token.value == '(':
|
|
if funcname:
|
|
message_lineno = token.lineno
|
|
call_stack += 1
|
|
|
|
elif call_stack == -1 and token.type == 'linecomment':
|
|
value = token.value[2:].strip()
|
|
if translator_comments and \
|
|
translator_comments[-1][0] == token.lineno - 1:
|
|
translator_comments.append((token.lineno, value))
|
|
continue
|
|
|
|
for comment_tag in comment_tags:
|
|
if value.startswith(comment_tag):
|
|
translator_comments.append((token.lineno, value.strip()))
|
|
break
|
|
|
|
elif token.type == 'multilinecomment':
|
|
# only one multi-line comment may preceed a translation
|
|
translator_comments = []
|
|
value = token.value[2:-2].strip()
|
|
for comment_tag in comment_tags:
|
|
if value.startswith(comment_tag):
|
|
lines = value.splitlines()
|
|
if lines:
|
|
lines[0] = lines[0].strip()
|
|
lines[1:] = dedent('\n'.join(lines[1:])).splitlines()
|
|
for offset, line in enumerate(lines):
|
|
translator_comments.append((token.lineno + offset,
|
|
line))
|
|
break
|
|
|
|
elif funcname and call_stack == 0:
|
|
if token.type == 'operator' and token.value == ')':
|
|
if last_argument is not None:
|
|
messages.append(last_argument)
|
|
if len(messages) > 1:
|
|
messages = tuple(messages)
|
|
elif messages:
|
|
messages = messages[0]
|
|
else:
|
|
messages = None
|
|
|
|
# Comments don't apply unless they immediately precede the
|
|
# message
|
|
if translator_comments and \
|
|
translator_comments[-1][0] < message_lineno - 1:
|
|
translator_comments = []
|
|
|
|
if messages is not None:
|
|
yield (message_lineno, funcname, messages,
|
|
[comment[1] for comment in translator_comments])
|
|
|
|
funcname = message_lineno = last_argument = None
|
|
concatenate_next = False
|
|
translator_comments = []
|
|
messages = []
|
|
call_stack = -1
|
|
|
|
elif token.type == 'string':
|
|
new_value = unquote_string(token.value)
|
|
if concatenate_next:
|
|
last_argument = (last_argument or '') + new_value
|
|
concatenate_next = False
|
|
else:
|
|
last_argument = new_value
|
|
|
|
elif token.type == 'operator':
|
|
if token.value == ',':
|
|
if last_argument is not None:
|
|
messages.append(last_argument)
|
|
last_argument = None
|
|
else:
|
|
messages.append(None)
|
|
concatenate_next = False
|
|
elif token.value == '+':
|
|
concatenate_next = True
|
|
|
|
elif call_stack > 0 and token.type == 'operator' \
|
|
and token.value == ')':
|
|
call_stack -= 1
|
|
|
|
elif funcname and call_stack == -1:
|
|
funcname = None
|
|
|
|
elif call_stack == -1 and token.type == 'name' and \
|
|
token.value in keywords and \
|
|
(last_token is None or last_token.type != 'name' or
|
|
last_token.value != 'function'):
|
|
funcname = token.value
|
|
|
|
last_token = token
|