New template formatter functions to work with identifiers and dates

resources/template-functions.json

@@ -5,8 +5,9 @@
     "strcat": "def evaluate(self, formatter, kwargs, mi, locals, *args):\n    i = 0\n    res = ''\n    for i in range(0, len(args)):\n        res += args[i]\n    return res\n", 
     "substr": "def evaluate(self, formatter, kwargs, mi, locals, str_, start_, end_):\n    return str_[int(start_): len(str_) if int(end_) == 0 else int(end_)]\n", 
     "ifempty": "def evaluate(self, formatter, kwargs, mi, locals, val, value_if_empty):\n    if val:\n        return val\n    else:\n        return value_if_empty\n", 
+    "select": "def evaluate(self, formatter, kwargs, mi, locals, val, key):\n    if not val:\n        return ''\n    vals = [v.strip() for v in val.split(',')]\n    for v in vals:\n        if v.startswith(key+':'):\n            return v[len(key)+1:]\n    return ''\n", 
     "field": "def evaluate(self, formatter, kwargs, mi, locals, name):\n    return formatter.get_value(name, [], kwargs)\n", 
-    "capitalize": "def evaluate(self, formatter, kwargs, mi, locals, val):\n    return capitalize(val)\n", 
+    "subtract": "def evaluate(self, formatter, kwargs, mi, locals, x, y):\n    x = float(x if x else 0)\n    y = float(y if y else 0)\n    return unicode(x - y)\n", 
     "list_item": "def evaluate(self, formatter, kwargs, mi, locals, val, index, sep):\n    if not val:\n        return ''\n    index = int(index)\n    val = val.split(sep)\n    try:\n        return val[index]\n    except:\n        return ''\n", 
     "shorten": "def evaluate(self, formatter, kwargs, mi, locals,\n             val, leading, center_string, trailing):\n    l = max(0, int(leading))\n    t = max(0, int(trailing))\n    if len(val) > l + len(center_string) + t:\n        return val[0:l] + center_string + ('' if t == 0 else val[-t:])\n    else:\n        return val\n", 
     "re": "def evaluate(self, formatter, kwargs, mi, locals, val, pattern, replacement):\n    return re.sub(pattern, replacement, val)\n", 
@@ -19,11 +20,13 @@
     "test": "def evaluate(self, formatter, kwargs, mi, locals, val, value_if_set, value_not_set):\n    if val:\n        return value_if_set\n    else:\n        return value_not_set\n", 
     "eval": "def evaluate(self, formatter, kwargs, mi, locals, template):\n    from formatter import eval_formatter\n    template = template.replace('[[', '{').replace(']]', '}')\n    return eval_formatter.safe_format(template, locals, 'EVAL', None)\n", 
     "multiply": "def evaluate(self, formatter, kwargs, mi, locals, x, y):\n    x = float(x if x else 0)\n    y = float(y if y else 0)\n    return unicode(x * y)\n", 
-    "subtract": "def evaluate(self, formatter, kwargs, mi, locals, x, y):\n    x = float(x if x else 0)\n    y = float(y if y else 0)\n    return unicode(x - y)\n", 
+    "format_date": "def evaluate(self, formatter, kwargs, mi, locals, val, format_string):\n    print val\n    if not val:\n        return ''\n    try:\n        dt = parse_date(val)\n        s = format_date(dt, format_string)\n    except:\n        s = 'BAD DATE'\n    return s\n", 
+    "capitalize": "def evaluate(self, formatter, kwargs, mi, locals, val):\n    return capitalize(val)\n", 
     "count": "def evaluate(self, formatter, kwargs, mi, locals, val, sep):\n    return unicode(len(val.split(sep)))\n", 
     "lowercase": "def evaluate(self, formatter, kwargs, mi, locals, val):\n    return val.lower()\n", 
     "assign": "def evaluate(self, formatter, kwargs, mi, locals, target, value):\n    locals[target] = value\n    return value\n", 
     "switch": "def evaluate(self, formatter, kwargs, mi, locals, val, *args):\n    if (len(args) % 2) != 1:\n        raise ValueError(_('switch requires an odd number of arguments'))\n    i = 0\n    while i < len(args):\n        if i + 1 >= len(args):\n            return args[i]\n        if re.search(args[i], val):\n            return args[i+1]\n        i += 2\n", 
     "strcmp": "def evaluate(self, formatter, kwargs, mi, locals, x, y, lt, eq, gt):\n    v = strcmp(x, y)\n    if v < 0:\n        return lt\n    if v == 0:\n        return eq\n    return gt\n", 
+    "raw_field": "def evaluate(self, formatter, kwargs, mi, locals, name):\n    return unicode(getattr(mi, name, None))\n", 
     "cmp": "def evaluate(self, formatter, kwargs, mi, locals, x, y, lt, eq, gt):\n    x = float(x if x else 0)\n    y = float(y if y else 0)\n    if x < y:\n        return lt\n    if x == y:\n        return eq\n    return gt\n"
 }

src/calibre/utils/formatter_functions.py

@@ -12,6 +12,7 @@ import inspect, re, traceback, sys
 
 from calibre.utils.titlecase import titlecase
 from calibre.utils.icu import capitalize, strcmp
+from calibre.utils.date import parse_date, format_date
 
 
 class FormatterFunctions(object):
@@ -230,6 +231,15 @@ class BuiltinField(BuiltinFormatterFunction):
     def evaluate(self, formatter, kwargs, mi, locals, name):
         return formatter.get_value(name, [], kwargs)
 
+class BuiltinRaw_field(BuiltinFormatterFunction):
+    name = 'raw_field'
+    arg_count = 1
+    doc = _('raw_field(name) -- returns the metadata field named by name '
+            'without applying any formatting.')
+
+    def evaluate(self, formatter, kwargs, mi, locals, name):
+        return unicode(getattr(mi, name, None))
+
 class BuiltinSubstr(BuiltinFormatterFunction):
     name = 'substr'
     arg_count = 3
@@ -396,6 +406,23 @@ class BuiltinListitem(BuiltinFormatterFunction):
         except:
             return ''
 
+class BuiltinSelect(BuiltinFormatterFunction):
+    name = 'select'
+    arg_count = 2
+    doc = _('select(val, key) -- interpret the value as a comma-separated list '
+            'of items, with the items being "id:value". Find the pair with the'
+            'id equal to key, and return the corresponding value.'
+            )
+
+    def evaluate(self, formatter, kwargs, mi, locals, val, key):
+        if not val:
+            return ''
+        vals = [v.strip() for v in val.split(',')]
+        for v in vals:
+            if v.startswith(key+':'):
+                return v[len(key)+1:]
+        return ''
+
 class BuiltinSublist(BuiltinFormatterFunction):
     name = 'sublist'
     arg_count = 4
@@ -424,6 +451,34 @@ class BuiltinSublist(BuiltinFormatterFunction):
         except:
             return ''
 
+class BuiltinFormat_date(BuiltinFormatterFunction):
+    name = 'format_date'
+    arg_count = 2
+    doc = _('format_date(val, format_string) -- format the value, which must '
+            'be a date field, using the format_string, returning a string. '
+            'The formatting codes are: '
+            'd    : the day as number without a leading zero (1 to 31) '
+            'dd   : the day as number with a leading zero (01 to 31) '
+            'ddd  : the abbreviated localized day name (e.g. "Mon" to "Sun"). '
+            'dddd : the long localized day name (e.g. "Monday" to "Sunday"). '
+            'M    : the month as number without a leading zero (1 to 12). '
+            'MM   : the month as number with a leading zero (01 to 12) '
+            'MMM  : the abbreviated localized month name (e.g. "Jan" to "Dec"). '
+            'MMMM : the long localized month name (e.g. "January" to "December"). '
+            'yy   : the year as two digit number (00 to 99). '
+            'yyyy : the year as four digit number.')
+
+    def evaluate(self, formatter, kwargs, mi, locals, val, format_string):
+        print val
+        if not val:
+            return ''
+        try:
+            dt = parse_date(val)
+            s = format_date(dt, format_string)
+        except:
+            s = 'BAD DATE'
+        return s
+
 class BuiltinUppercase(BuiltinFormatterFunction):
     name = 'uppercase'
     arg_count = 1
@@ -464,14 +519,17 @@ builtin_contains    = BuiltinContains()
 builtin_count       = BuiltinCount()
 builtin_divide      = BuiltinDivide()
 builtin_eval        = BuiltinEval()
-builtin_ifempty     = BuiltinIfempty()
+builtin_format_date = BuiltinFormat_date()
 builtin_field       = BuiltinField()
+builtin_ifempty     = BuiltinIfempty()
 builtin_list_item   = BuiltinListitem()
 builtin_lookup      = BuiltinLookup()
 builtin_lowercase   = BuiltinLowercase()
 builtin_multiply    = BuiltinMultiply()
 builtin_print       = BuiltinPrint()
+builtin_raw_field   = BuiltinRaw_field()
 builtin_re          = BuiltinRe()
+builtin_select      = BuiltinSelect()
 builtin_shorten     = BuiltinShorten()
 builtin_strcat      = BuiltinStrcat()
 builtin_strcmp      = BuiltinStrcmp()