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