Fix typo in app link hrefs
[f-droid:fdroidserver.git] / fdroidserver / metadata.py
1 # -*- coding: utf-8 -*-
2 #
3 # metadata.py - part of the FDroid server tools
4 # Copyright (C) 2013, Ciaran Gultnieks, ciaran@ciarang.com
5 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
6 #
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Affero General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU Affero General Public License for more details.
16 #
17 # You should have received a copy of the GNU Affero General Public License
18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
20 import os
21 import re
22 import glob
23 import cgi
24 import logging
25
26 from collections import OrderedDict
27
28 srclibs = None
29
30
31 class MetaDataException(Exception):
32     def __init__(self, value):
33         self.value = value
34
35     def __str__(self):
36         return self.value
37
38 # In the order in which they are laid out on files
39 app_defaults = OrderedDict([
40     ('Disabled', None),
41     ('AntiFeatures', None),
42     ('Provides', None),
43     ('Categories', ['None']),
44     ('License', 'Unknown'),
45     ('Web Site', ''),
46     ('Source Code', ''),
47     ('Issue Tracker', ''),
48     ('Donate', None),
49     ('FlattrID', None),
50     ('Bitcoin', None),
51     ('Litecoin', None),
52     ('Dogecoin', None),
53     ('Name', None),
54     ('Auto Name', ''),
55     ('Summary', ''),
56     ('Description', []),
57     ('Requires Root', False),
58     ('Repo Type', ''),
59     ('Repo', ''),
60     ('Maintainer Notes', []),
61     ('Archive Policy', None),
62     ('Auto Update Mode', 'None'),
63     ('Update Check Mode', 'None'),
64     ('Update Check Ignore', None),
65     ('Vercode Operation', None),
66     ('Update Check Name', None),
67     ('Update Check Data', None),
68     ('Current Version', ''),
69     ('Current Version Code', '0'),
70     ('No Source Since', ''),
71     ])
72
73
74 # In the order in which they are laid out on files
75 # Sorted by their action and their place in the build timeline
76 flag_defaults = OrderedDict([
77     ('disable', False),
78     ('commit', None),
79     ('subdir', None),
80     ('submodules', False),
81     ('init', ''),
82     ('patch', []),
83     ('gradle', False),
84     ('maven', False),
85     ('kivy', False),
86     ('output', None),
87     ('srclibs', []),
88     ('oldsdkloc', False),
89     ('encoding', None),
90     ('forceversion', False),
91     ('forcevercode', False),
92     ('rm', []),
93     ('extlibs', []),
94     ('prebuild', ''),
95     ('update', ['auto']),
96     ('target', None),
97     ('scanignore', []),
98     ('scandelete', []),
99     ('build', ''),
100     ('buildjni', []),
101     ('preassemble', []),
102     ('antcommand', None),
103     ('novcheck', False),
104     ])
105
106
107 # Designates a metadata field type and checks that it matches
108 #
109 # 'name'     - The long name of the field type
110 # 'matching' - List of possible values or regex expression
111 # 'sep'      - Separator to use if value may be a list
112 # 'fields'   - Metadata fields (Field:Value) of this type
113 # 'attrs'    - Build attributes (attr=value) of this type
114 #
115 class FieldValidator():
116
117     def __init__(self, name, matching, sep, fields, attrs):
118         self.name = name
119         self.matching = matching
120         if type(matching) is str:
121             self.compiled = re.compile(matching)
122         self.sep = sep
123         self.fields = fields
124         self.attrs = attrs
125
126     def _assert_regex(self, values, appid):
127         for v in values:
128             if not self.compiled.match(v):
129                 raise MetaDataException("'%s' is not a valid %s in %s. "
130                                         % (v, self.name, appid) +
131                                         "Regex pattern: %s" % (self.matching))
132
133     def _assert_list(self, values, appid):
134         for v in values:
135             if v not in self.matching:
136                 raise MetaDataException("'%s' is not a valid %s in %s. "
137                                         % (v, self.name, appid) +
138                                         "Possible values: %s" % (", ".join(self.matching)))
139
140     def check(self, value, appid):
141         if type(value) is not str or not value:
142             return
143         if self.sep is not None:
144             values = value.split(self.sep)
145         else:
146             values = [value]
147         if type(self.matching) is list:
148             self._assert_list(values, appid)
149         else:
150             self._assert_regex(values, appid)
151
152
153 # Generic value types
154 valuetypes = {
155     FieldValidator("Integer",
156                    r'^[1-9][0-9]*$', None,
157                    [],
158                    ['vercode']),
159
160     FieldValidator("Hexadecimal",
161                    r'^[0-9a-f]+$', None,
162                    ['FlattrID'],
163                    []),
164
165     FieldValidator("HTTP link",
166                    r'^http[s]?://', None,
167                    ["Web Site", "Source Code", "Issue Tracker", "Donate"], []),
168
169     FieldValidator("Bitcoin address",
170                    r'^[a-zA-Z0-9]{27,34}$', None,
171                    ["Bitcoin"],
172                    []),
173
174     FieldValidator("Litecoin address",
175                    r'^L[a-zA-Z0-9]{33}$', None,
176                    ["Litecoin"],
177                    []),
178
179     FieldValidator("Dogecoin address",
180                    r'^D[a-zA-Z0-9]{33}$', None,
181                    ["Dogecoin"],
182                    []),
183
184     FieldValidator("Boolean",
185                    ['Yes', 'No'], None,
186                    ["Requires Root"],
187                    []),
188
189     FieldValidator("bool",
190                    ['yes', 'no'], None,
191                    [],
192                    ['submodules', 'oldsdkloc', 'forceversion', 'forcevercode',
193                     'novcheck']),
194
195     FieldValidator("Repo Type",
196                    ['git', 'git-svn', 'svn', 'hg', 'bzr', 'srclib'], None,
197                    ["Repo Type"],
198                    []),
199
200     FieldValidator("Archive Policy",
201                    r'^[0-9]+ versions$', None,
202                    ["Archive Policy"],
203                    []),
204
205     FieldValidator("Anti-Feature",
206                    ["Ads", "Tracking", "NonFreeNet", "NonFreeDep", "NonFreeAdd", "UpstreamNonFree"], ',',
207                    ["AntiFeatures"],
208                    []),
209
210     FieldValidator("Auto Update Mode",
211                    r"^(Version .+|None)$", None,
212                    ["Auto Update Mode"],
213                    []),
214
215     FieldValidator("Update Check Mode",
216                    r"^(Tags|Tags .+|RepoManifest|RepoManifest/.+|RepoTrunk|HTTP|Static|None)$", None,
217                    ["Update Check Mode"],
218                    [])
219     }
220
221
222 # Check an app's metadata information for integrity errors
223 def check_metadata(info):
224     for v in valuetypes:
225         for field in v.fields:
226             v.check(info[field], info['id'])
227         for build in info['builds']:
228             for attr in v.attrs:
229                 v.check(build[attr], info['id'])
230
231
232 # Formatter for descriptions. Create an instance, and call parseline() with
233 # each line of the description source from the metadata. At the end, call
234 # end() and then text_plain, text_wiki and text_html will contain the result.
235 class DescriptionFormatter:
236     stNONE = 0
237     stPARA = 1
238     stUL = 2
239     stOL = 3
240     bold = False
241     ital = False
242     state = stNONE
243     text_plain = ''
244     text_wiki = ''
245     text_html = ''
246     linkResolver = None
247
248     def __init__(self, linkres):
249         self.linkResolver = linkres
250
251     def endcur(self, notstates=None):
252         if notstates and self.state in notstates:
253             return
254         if self.state == self.stPARA:
255             self.endpara()
256         elif self.state == self.stUL:
257             self.endul()
258         elif self.state == self.stOL:
259             self.endol()
260
261     def endpara(self):
262         self.text_plain += '\n'
263         self.text_html += '</p>'
264         self.state = self.stNONE
265
266     def endul(self):
267         self.text_html += '</ul>'
268         self.state = self.stNONE
269
270     def endol(self):
271         self.text_html += '</ol>'
272         self.state = self.stNONE
273
274     def formatted(self, txt, html):
275         formatted = ''
276         if html:
277             txt = cgi.escape(txt)
278         while True:
279             index = txt.find("''")
280             if index == -1:
281                 return formatted + txt
282             formatted += txt[:index]
283             txt = txt[index:]
284             if txt.startswith("'''"):
285                 if html:
286                     if self.bold:
287                         formatted += '</b>'
288                     else:
289                         formatted += '<b>'
290                 self.bold = not self.bold
291                 txt = txt[3:]
292             else:
293                 if html:
294                     if self.ital:
295                         formatted += '</i>'
296                     else:
297                         formatted += '<i>'
298                 self.ital = not self.ital
299                 txt = txt[2:]
300
301     def linkify(self, txt):
302         linkified_plain = ''
303         linkified_html = ''
304         while True:
305             index = txt.find("[")
306             if index == -1:
307                 return (linkified_plain + self.formatted(txt, False), linkified_html + self.formatted(txt, True))
308             linkified_plain += self.formatted(txt[:index], False)
309             linkified_html += self.formatted(txt[:index], True)
310             txt = txt[index:]
311             if txt.startswith("[["):
312                 index = txt.find("]]")
313                 if index == -1:
314                     raise MetaDataException("Unterminated ]]")
315                 url = txt[2:index]
316                 if self.linkResolver:
317                     url, urltext = self.linkResolver(url)
318                 else:
319                     urltext = url
320                 linkified_html += '<a href="' + url + '">' + cgi.escape(urltext) + '</a>'
321                 linkified_plain += urltext
322                 txt = txt[index + 2:]
323             else:
324                 index = txt.find("]")
325                 if index == -1:
326                     raise MetaDataException("Unterminated ]")
327                 url = txt[1:index]
328                 index2 = url.find(' ')
329                 if index2 == -1:
330                     urltxt = url
331                 else:
332                     urltxt = url[index2 + 1:]
333                     url = url[:index2]
334                 linkified_html += '<a href="' + url + '">' + cgi.escape(urltxt) + '</a>'
335                 linkified_plain += urltxt
336                 if urltxt != url:
337                     linkified_plain += ' (' + url + ')'
338                 txt = txt[index + 1:]
339
340     def addtext(self, txt):
341         p, h = self.linkify(txt)
342         self.text_plain += p
343         self.text_html += h
344
345     def parseline(self, line):
346         self.text_wiki += "%s\n" % line
347         if not line:
348             self.endcur()
349         elif line.startswith('* '):
350             self.endcur([self.stUL])
351             if self.state != self.stUL:
352                 self.text_html += '<ul>'
353                 self.state = self.stUL
354             self.text_html += '<li>'
355             self.text_plain += '* '
356             self.addtext(line[1:])
357             self.text_html += '</li>'
358         elif line.startswith('# '):
359             self.endcur([self.stOL])
360             if self.state != self.stOL:
361                 self.text_html += '<ol>'
362                 self.state = self.stOL
363             self.text_html += '<li>'
364             self.text_plain += '* '  # TODO: lazy - put the numbers in!
365             self.addtext(line[1:])
366             self.text_html += '</li>'
367         else:
368             self.endcur([self.stPARA])
369             if self.state == self.stNONE:
370                 self.text_html += '<p>'
371                 self.state = self.stPARA
372             elif self.state == self.stPARA:
373                 self.text_html += ' '
374                 self.text_plain += ' '
375             self.addtext(line)
376
377     def end(self):
378         self.endcur()
379
380
381 # Parse multiple lines of description as written in a metadata file, returning
382 # a single string in plain text format.
383 def description_plain(lines, linkres):
384     ps = DescriptionFormatter(linkres)
385     for line in lines:
386         ps.parseline(line)
387     ps.end()
388     return ps.text_plain
389
390
391 # Parse multiple lines of description as written in a metadata file, returning
392 # a single string in wiki format. Used for the Maintainer Notes field as well,
393 # because it's the same format.
394 def description_wiki(lines):
395     ps = DescriptionFormatter(None)
396     for line in lines:
397         ps.parseline(line)
398     ps.end()
399     return ps.text_wiki
400
401
402 # Parse multiple lines of description as written in a metadata file, returning
403 # a single string in HTML format.
404 def description_html(lines, linkres):
405     ps = DescriptionFormatter(linkres)
406     for line in lines:
407         ps.parseline(line)
408     ps.end()
409     return ps.text_html
410
411
412 def parse_srclib(metafile):
413
414     thisinfo = {}
415     if metafile and not isinstance(metafile, file):
416         metafile = open(metafile, "r")
417
418     # Defaults for fields that come from metadata
419     thisinfo['Repo Type'] = ''
420     thisinfo['Repo'] = ''
421     thisinfo['Subdir'] = None
422     thisinfo['Prepare'] = None
423     thisinfo['Srclibs'] = None
424
425     if metafile is None:
426         return thisinfo
427
428     n = 0
429     for line in metafile:
430         n += 1
431         line = line.rstrip('\r\n')
432         if not line or line.startswith("#"):
433             continue
434
435         try:
436             field, value = line.split(':', 1)
437         except ValueError:
438             raise MetaDataException("Invalid metadata in %s:%d" % (line, n))
439
440         if field == "Subdir":
441             thisinfo[field] = value.split(',')
442         else:
443             thisinfo[field] = value
444
445     return thisinfo
446
447
448 def read_srclibs():
449     """Read all srclib metadata.
450
451     The information read will be accessible as metadata.srclibs, which is a
452     dictionary, keyed on srclib name, with the values each being a dictionary
453     in the same format as that returned by the parse_srclib function.
454
455     A MetaDataException is raised if there are any problems with the srclib
456     metadata.
457     """
458     global srclibs
459
460     # They were already loaded
461     if srclibs is not None:
462         return
463
464     srclibs = {}
465
466     srcdir = 'srclibs'
467     if not os.path.exists(srcdir):
468         os.makedirs(srcdir)
469
470     for metafile in sorted(glob.glob(os.path.join(srcdir, '*.txt'))):
471         srclibname = os.path.basename(metafile[:-4])
472         srclibs[srclibname] = parse_srclib(metafile)
473
474
475 # Read all metadata. Returns a list of 'app' objects (which are dictionaries as
476 # returned by the parse_metadata function.
477 def read_metadata(xref=True):
478
479     # Always read the srclibs before the apps, since they can use a srlib as
480     # their source repository.
481     read_srclibs()
482
483     apps = {}
484
485     for basedir in ('metadata', 'tmp'):
486         if not os.path.exists(basedir):
487             os.makedirs(basedir)
488
489     for metafile in sorted(glob.glob(os.path.join('metadata', '*.txt'))):
490         appid, appinfo = parse_metadata(metafile)
491         check_metadata(appinfo)
492         apps[appid] = appinfo
493
494     if xref:
495         # Parse all descriptions at load time, just to ensure cross-referencing
496         # errors are caught early rather than when they hit the build server.
497         def linkres(appid):
498             if appid in apps:
499                 return ("fdroid.app:" + appid, "Dummy name - don't know yet")
500             raise MetaDataException("Cannot resolve app id " + appid)
501
502         for appid, app in apps.iteritems():
503             try:
504                 description_html(app['Description'], linkres)
505             except MetaDataException, e:
506                 raise MetaDataException("Problem with description of " + appid +
507                                         " - " + str(e))
508
509     return apps
510
511
512 # Get the type expected for a given metadata field.
513 def metafieldtype(name):
514     if name in ['Description', 'Maintainer Notes']:
515         return 'multiline'
516     if name in ['Categories']:
517         return 'list'
518     if name == 'Build Version':
519         return 'build'
520     if name == 'Build':
521         return 'buildv2'
522     if name == 'Use Built':
523         return 'obsolete'
524     if name not in app_defaults:
525         return 'unknown'
526     return 'string'
527
528
529 def flagtype(name):
530     if name in ['extlibs', 'srclibs', 'patch', 'rm', 'buildjni',
531                 'update', 'scanignore', 'scandelete']:
532         return 'list'
533     if name in ['init', 'prebuild', 'build']:
534         return 'script'
535     if name in ['submodules', 'oldsdkloc', 'forceversion', 'forcevercode',
536                 'novcheck']:
537         return 'bool'
538     return 'string'
539
540
541 def fill_build_defaults(build):
542
543     def get_build_type():
544         for t in ['maven', 'gradle', 'kivy']:
545             if build[t]:
546                 return t
547         if build['output']:
548             return 'raw'
549         return 'ant'
550
551     for flag, value in flag_defaults.iteritems():
552         if flag in build:
553             continue
554         build[flag] = value
555     build['type'] = get_build_type()
556
557
558 # Parse metadata for a single application.
559 #
560 #  'metafile' - the filename to read. The package id for the application comes
561 #               from this filename. Pass None to get a blank entry.
562 #
563 # Returns a dictionary containing all the details of the application. There are
564 # two major kinds of information in the dictionary. Keys beginning with capital
565 # letters correspond directory to identically named keys in the metadata file.
566 # Keys beginning with lower case letters are generated in one way or another,
567 # and are not found verbatim in the metadata.
568 #
569 # Known keys not originating from the metadata are:
570 #
571 #  'builds'           - a list of dictionaries containing build information
572 #                       for each defined build
573 #  'comments'         - a list of comments from the metadata file. Each is
574 #                       a tuple of the form (field, comment) where field is
575 #                       the name of the field it preceded in the metadata
576 #                       file. Where field is None, the comment goes at the
577 #                       end of the file. Alternatively, 'build:version' is
578 #                       for a comment before a particular build version.
579 #  'descriptionlines' - original lines of description as formatted in the
580 #                       metadata file.
581 #
582 def parse_metadata(metafile):
583
584     appid = None
585     linedesc = None
586
587     def add_buildflag(p, thisbuild):
588         bv = p.split('=', 1)
589         if len(bv) != 2:
590             raise MetaDataException("Invalid build flag at {0} in {1}"
591                                     .format(buildlines[0], linedesc))
592         pk, pv = bv
593         if pk in thisbuild:
594             raise MetaDataException("Duplicate definition on {0} in version {1} of {2}"
595                                     .format(pk, thisbuild['version'], linedesc))
596
597         pk = pk.lstrip()
598         if pk not in flag_defaults:
599             raise MetaDataException("Unrecognised build flag at {0} in {1}"
600                                     .format(p, linedesc))
601         t = flagtype(pk)
602         if t == 'list':
603             # Port legacy ';' separators
604             thisbuild[pk] = [v.strip() for v in pv.replace(';', ',').split(',')]
605         elif t == 'string' or t == 'script':
606             thisbuild[pk] = pv
607         elif t == 'bool':
608             value = pv == 'yes'
609             if value:
610                 thisbuild[pk] = True
611             else:
612                 logging.debug("...ignoring bool flag %s" % p)
613
614         else:
615             raise MetaDataException("Unrecognised build flag type '%s' at %s in %s"
616                                     % (t, p, linedesc))
617
618     def parse_buildline(lines):
619         value = "".join(lines)
620         parts = [p.replace("\\,", ",")
621                  for p in re.split(r"(?<!\\),", value)]
622         if len(parts) < 3:
623             raise MetaDataException("Invalid build format: " + value + " in " + metafile.name)
624         thisbuild = {}
625         thisbuild['origlines'] = lines
626         thisbuild['version'] = parts[0]
627         thisbuild['vercode'] = parts[1]
628         if parts[2].startswith('!'):
629             # For backwards compatibility, handle old-style disabling,
630             # including attempting to extract the commit from the message
631             thisbuild['disable'] = parts[2][1:]
632             commit = 'unknown - see disabled'
633             index = parts[2].rfind('at ')
634             if index != -1:
635                 commit = parts[2][index + 3:]
636                 if commit.endswith(')'):
637                     commit = commit[:-1]
638             thisbuild['commit'] = commit
639         else:
640             thisbuild['commit'] = parts[2]
641         for p in parts[3:]:
642             add_buildflag(p, thisbuild)
643
644         return thisbuild
645
646     def add_comments(key):
647         if not curcomments:
648             return
649         for comment in curcomments:
650             thisinfo['comments'].append((key, comment))
651         del curcomments[:]
652
653     thisinfo = {}
654     if metafile:
655         if not isinstance(metafile, file):
656             metafile = open(metafile, "r")
657         appid = metafile.name[9:-4]
658
659     thisinfo.update(app_defaults)
660     thisinfo['id'] = appid
661
662     # General defaults...
663     thisinfo['builds'] = []
664     thisinfo['comments'] = []
665
666     if metafile is None:
667         return appid, thisinfo
668
669     mode = 0
670     buildlines = []
671     curcomments = []
672     curbuild = None
673     vc_seen = {}
674
675     c = 0
676     for line in metafile:
677         c += 1
678         linedesc = "%s:%d" % (metafile.name, c)
679         line = line.rstrip('\r\n')
680         if mode == 3:
681             if not any(line.startswith(s) for s in (' ', '\t')):
682                 commit = curbuild['commit'] if 'commit' in curbuild else None
683                 if not commit and 'disable' not in curbuild:
684                     raise MetaDataException("No commit specified for {0} in {1}"
685                                             .format(curbuild['version'], linedesc))
686
687                 thisinfo['builds'].append(curbuild)
688                 add_comments('build:' + curbuild['vercode'])
689                 mode = 0
690             else:
691                 if line.endswith('\\'):
692                     buildlines.append(line[:-1].lstrip())
693                 else:
694                     buildlines.append(line.lstrip())
695                     bl = ''.join(buildlines)
696                     add_buildflag(bl, curbuild)
697                     buildlines = []
698
699         if mode == 0:
700             if not line:
701                 continue
702             if line.startswith("#"):
703                 curcomments.append(line)
704                 continue
705             try:
706                 field, value = line.split(':', 1)
707             except ValueError:
708                 raise MetaDataException("Invalid metadata in " + linedesc)
709             if field != field.strip() or value != value.strip():
710                 raise MetaDataException("Extra spacing found in " + linedesc)
711
712             # Translate obsolete fields...
713             if field == 'Market Version':
714                 field = 'Current Version'
715             if field == 'Market Version Code':
716                 field = 'Current Version Code'
717
718             fieldtype = metafieldtype(field)
719             if fieldtype not in ['build', 'buildv2']:
720                 add_comments(field)
721             if fieldtype == 'multiline':
722                 mode = 1
723                 thisinfo[field] = []
724                 if value:
725                     raise MetaDataException("Unexpected text on same line as " + field + " in " + linedesc)
726             elif fieldtype == 'string':
727                 thisinfo[field] = value
728             elif fieldtype == 'list':
729                 thisinfo[field] = [v.strip() for v in value.replace(';', ',').split(',')]
730             elif fieldtype == 'build':
731                 if value.endswith("\\"):
732                     mode = 2
733                     buildlines = [value[:-1]]
734                 else:
735                     curbuild = parse_buildline([value])
736                     thisinfo['builds'].append(curbuild)
737                     add_comments('build:' + thisinfo['builds'][-1]['vercode'])
738             elif fieldtype == 'buildv2':
739                 curbuild = {}
740                 vv = value.split(',')
741                 if len(vv) != 2:
742                     raise MetaDataException('Build should have comma-separated version and vercode, not "{0}", in {1}'
743                                             .format(value, linedesc))
744                 curbuild['version'] = vv[0]
745                 curbuild['vercode'] = vv[1]
746                 if curbuild['vercode'] in vc_seen:
747                     raise MetaDataException('Duplicate build recipe found for vercode %s in %s' % (
748                                             curbuild['vercode'], linedesc))
749                 vc_seen[curbuild['vercode']] = True
750                 buildlines = []
751                 mode = 3
752             elif fieldtype == 'obsolete':
753                 pass        # Just throw it away!
754             else:
755                 raise MetaDataException("Unrecognised field type for " + field + " in " + linedesc)
756         elif mode == 1:     # Multiline field
757             if line == '.':
758                 mode = 0
759             else:
760                 thisinfo[field].append(line)
761         elif mode == 2:     # Line continuation mode in Build Version
762             if line.endswith("\\"):
763                 buildlines.append(line[:-1])
764             else:
765                 buildlines.append(line)
766                 curbuild = parse_buildline(buildlines)
767                 thisinfo['builds'].append(curbuild)
768                 add_comments('build:' + thisinfo['builds'][-1]['vercode'])
769                 mode = 0
770     add_comments(None)
771
772     # Mode at end of file should always be 0...
773     if mode == 1:
774         raise MetaDataException(field + " not terminated in " + metafile.name)
775     elif mode == 2:
776         raise MetaDataException("Unterminated continuation in " + metafile.name)
777     elif mode == 3:
778         raise MetaDataException("Unterminated build in " + metafile.name)
779
780     if not thisinfo['Description']:
781         thisinfo['Description'].append('No description available')
782
783     for build in thisinfo['builds']:
784         fill_build_defaults(build)
785
786     return (appid, thisinfo)
787
788
789 # Write a metadata file.
790 #
791 # 'dest'    - The path to the output file
792 # 'app'     - The app data
793 def write_metadata(dest, app):
794
795     def writecomments(key):
796         written = 0
797         for pf, comment in app['comments']:
798             if pf == key:
799                 mf.write("%s\n" % comment)
800                 written += 1
801         if written > 0:
802             logging.debug("...writing comments for " + (key or 'EOF'))
803
804     def writefield(field, value=None):
805         writecomments(field)
806         if value is None:
807             value = app[field]
808         t = metafieldtype(field)
809         if t == 'list':
810             value = ','.join(value)
811         mf.write("%s:%s\n" % (field, value))
812
813     def writefield_nonempty(field, value=None):
814         if value is None:
815             value = app[field]
816         if value:
817             writefield(field, value)
818
819     mf = open(dest, 'w')
820     writefield_nonempty('Disabled')
821     writefield_nonempty('AntiFeatures')
822     writefield_nonempty('Provides')
823     writefield('Categories')
824     writefield('License')
825     writefield('Web Site')
826     writefield('Source Code')
827     writefield('Issue Tracker')
828     writefield_nonempty('Donate')
829     writefield_nonempty('FlattrID')
830     writefield_nonempty('Bitcoin')
831     writefield_nonempty('Litecoin')
832     writefield_nonempty('Dogecoin')
833     mf.write('\n')
834     writefield_nonempty('Name')
835     writefield_nonempty('Auto Name')
836     writefield('Summary')
837     writefield('Description', '')
838     for line in app['Description']:
839         mf.write("%s\n" % line)
840     mf.write('.\n')
841     mf.write('\n')
842     if app['Requires Root']:
843         writefield('Requires Root', 'Yes')
844         mf.write('\n')
845     if app['Repo Type']:
846         writefield('Repo Type')
847         writefield('Repo')
848         mf.write('\n')
849     for build in app['builds']:
850
851         if build['version'] == "Ignore":
852             continue
853
854         writecomments('build:' + build['vercode'])
855         mf.write("Build:%s,%s\n" % (build['version'], build['vercode']))
856
857         def write_builditem(key, value):
858
859             if key in ['version', 'vercode']:
860                 return
861
862             if value == flag_defaults[key]:
863                 return
864
865             t = flagtype(key)
866
867             logging.debug("...writing {0} : {1}".format(key, value))
868             outline = '    %s=' % key
869
870             if t == 'string':
871                 outline += value
872             if t == 'bool':
873                 outline += 'yes'
874             elif t == 'script':
875                 outline += '&& \\\n        '.join([s.lstrip() for s in value.split('&& ')])
876             elif t == 'list':
877                 outline += ','.join(value) if type(value) == list else value
878
879             outline += '\n'
880             mf.write(outline)
881
882         for flag in flag_defaults:
883             value = build[flag]
884             if value:
885                 write_builditem(flag, value)
886         mf.write('\n')
887
888     if app['Maintainer Notes']:
889         writefield('Maintainer Notes', '')
890         for line in app['Maintainer Notes']:
891             mf.write("%s\n" % line)
892         mf.write('.\n')
893         mf.write('\n')
894
895     writefield_nonempty('Archive Policy')
896     writefield('Auto Update Mode')
897     writefield('Update Check Mode')
898     writefield_nonempty('Update Check Ignore')
899     writefield_nonempty('Vercode Operation')
900     writefield_nonempty('Update Check Name')
901     writefield_nonempty('Update Check Data')
902     if app['Current Version']:
903         writefield('Current Version')
904         writefield('Current Version Code')
905     mf.write('\n')
906     if app['No Source Since']:
907         writefield('No Source Since')
908         mf.write('\n')
909     writecomments(None)
910     mf.close()