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', 'kivy', 'output', 'oldsdkloc', 'target',
  68     'update', 'encoding', 'forceversion', 'forcevercode', 'rm',
  69     'extlibs', 'srclibs', 'patch', 'prebuild', 'scanignore',
  70     'scandelete', 'build', 'buildjni', 'preassemble', 'bindir',
  71     '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             '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|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
 385     if metafile is None:
 386         return thisinfo
 387
 388     n = 0
 389     for line in metafile:
 390         n += 1
 391         line = line.rstrip('\r\n')
 392         if not line or line.startswith("#"):
 393             continue
 394
 395         try:
 396             field, value = line.split(':',1)
 397         except ValueError:
 398             raise MetaDataException("Invalid metadata in %s:%d" % (line, n))
 399
 400         if field == "Subdir":
 401             thisinfo[field] = value.split(',')
 402         else:
 403             thisinfo[field] = value
 404
 405     return thisinfo
 406
 407 # Read all metadata. Returns a list of 'app' objects (which are dictionaries as
 408 # returned by the parse_metadata function.
 409 def read_metadata(xref=True, package=None, store=True):
 410     apps = []
 411
 412     for basedir in ('metadata', 'tmp'):
 413         if not os.path.exists(basedir):
 414             os.makedirs(basedir)
 415
 416     for metafile in sorted(glob.glob(os.path.join('metadata', '*.txt'))):
 417         if package is None or metafile == os.path.join('metadata', package + '.txt'):
 418             appinfo = parse_metadata(metafile)
 419             check_metadata(appinfo)
 420             apps.append(appinfo)
 421
 422     if xref:
 423         # Parse all descriptions at load time, just to ensure cross-referencing
 424         # errors are caught early rather than when they hit the build server.
 425         def linkres(link):
 426             for app in apps:
 427                 if app['id'] == link:
 428                     return ("fdroid.app:" + link, "Dummy name - don't know yet")
 429             raise MetaDataException("Cannot resolve app id " + link)
 430         for app in apps:
 431             try:
 432                 description_html(app['Description'], linkres)
 433             except Exception, e:
 434                 raise MetaDataException("Problem with description of " + app['id'] +
 435                         " - " + str(e))
 436
 437     return apps
 438
 439 # Get the type expected for a given metadata field.
 440 def metafieldtype(name):
 441     if name in ['Description', 'Maintainer Notes']:
 442         return 'multiline'
 443     if name == 'Build Version':
 444         return 'build'
 445     if name == 'Build':
 446         return 'buildv2'
 447     if name == 'Use Built':
 448         return 'obsolete'
 449     if name not in app_defaults:
 450         return 'unknown'
 451     return 'string'
 452
 453 def flagtype(name):
 454     if name in ['extlibs', 'srclibs', 'patch', 'rm', 'buildjni',
 455             'scanignore', 'scandelete']:
 456         return 'list'
 457     if name in ['init', 'prebuild', 'build']:
 458         return 'script'
 459     return 'string'
 460
 461 # Parse metadata for a single application.
 462 #
 463 #  'metafile' - the filename to read. The package id for the application comes
 464 #               from this filename. Pass None to get a blank entry.
 465 #
 466 # Returns a dictionary containing all the details of the application. There are
 467 # two major kinds of information in the dictionary. Keys beginning with capital
 468 # letters correspond directory to identically named keys in the metadata file.
 469 # Keys beginning with lower case letters are generated in one way or another,
 470 # and are not found verbatim in the metadata.
 471 #
 472 # Known keys not originating from the metadata are:
 473 #
 474 #  'id'               - the application's package ID
 475 #  'builds'           - a list of dictionaries containing build information
 476 #                       for each defined build
 477 #  'comments'         - a list of comments from the metadata file. Each is
 478 #                       a tuple of the form (field, comment) where field is
 479 #                       the name of the field it preceded in the metadata
 480 #                       file. Where field is None, the comment goes at the
 481 #                       end of the file. Alternatively, 'build:version' is
 482 #                       for a comment before a particular build version.
 483 #  'descriptionlines' - original lines of description as formatted in the
 484 #                       metadata file.
 485 #
 486 def parse_metadata(metafile):
 487
 488     linedesc = None
 489
 490     def add_buildflag(p, thisbuild):
 491         bv = p.split('=', 1)
 492         if len(bv) != 2:
 493             raise MetaDataException("Invalid build flag at {0} in {1}".
 494                     format(buildlines[0], linedesc))
 495         pk, pv = bv
 496         if pk in thisbuild:
 497             raise MetaDataException("Duplicate definition on {0} in version {1} of {2}".
 498                     format(pk, thisbuild['version'], linedesc))
 499
 500         pk = pk.lstrip()
 501         if pk not in ordered_flags:
 502             raise MetaDataException("Unrecognised build flag at {0} in {1}".
 503                     format(p, linedesc))
 504         t = flagtype(pk)
 505         if t == 'list':
 506             # Port legacy ';' separators
 507             thisbuild[pk] = pv.replace(';',',').split(',')
 508         elif t == 'string':
 509             thisbuild[pk] = pv
 510         elif t == 'script':
 511             thisbuild[pk] = pv
 512         else:
 513             raise MetaDataException("Unrecognised build flag type '%s' at %s in %s" % (
 514                     t, p, linedesc))
 515
 516     def parse_buildline(lines):
 517         value = "".join(lines)
 518         parts = [p.replace("\\,", ",")
 519                  for p in re.split(r"(?<!\\),", value)]
 520         if len(parts) < 3:
 521             raise MetaDataException("Invalid build format: " + value + " in " + metafile.name)
 522         thisbuild = {}
 523         thisbuild['origlines'] = lines
 524         thisbuild['version'] = parts[0]
 525         thisbuild['vercode'] = parts[1]
 526         if parts[2].startswith('!'):
 527             # For backwards compatibility, handle old-style disabling,
 528             # including attempting to extract the commit from the message
 529             thisbuild['disable'] = parts[2][1:]
 530             commit = 'unknown - see disabled'
 531             index = parts[2].rfind('at ')
 532             if index != -1:
 533                 commit = parts[2][index+3:]
 534                 if commit.endswith(')'):
 535                     commit = commit[:-1]
 536             thisbuild['commit'] = commit
 537         else:
 538             thisbuild['commit'] = parts[2]
 539         for p in parts[3:]:
 540             add_buildflag(p, thisbuild)
 541
 542         return thisbuild
 543
 544     def add_comments(key):
 545         if not curcomments:
 546             return
 547         for comment in curcomments:
 548             thisinfo['comments'].append((key, comment))
 549         del curcomments[:]
 550
 551     def get_build_type(build):
 552         for t in ['maven', 'gradle', 'kivy']:
 553             if build.get(t, 'no') != 'no':
 554                 return t
 555         if 'output' in build:
 556             return 'raw'
 557         return 'ant'
 558
 559     thisinfo = {}
 560     if metafile:
 561         if not isinstance(metafile, file):
 562             metafile = open(metafile, "r")
 563         thisinfo['id'] = metafile.name[9:-4]
 564     else:
 565         thisinfo['id'] = None
 566
 567     thisinfo.update(app_defaults)
 568
 569     # General defaults...
 570     thisinfo['builds'] = []
 571     thisinfo['comments'] = []
 572
 573     if metafile is None:
 574         return thisinfo
 575
 576     mode = 0
 577     buildlines = []
 578     curcomments = []
 579     curbuild = None
 580
 581     c = 0
 582     for line in metafile:
 583         c += 1
 584         linedesc = "%s:%d" % (metafile.name, c)
 585         line = line.rstrip('\r\n')
 586         if mode == 3:
 587             if not any(line.startswith(s) for s in (' ', '\t')):
 588                 if 'commit' not in curbuild and 'disable' not in curbuild:
 589                     raise MetaDataException("No commit specified for {0} in {1}".format(
 590                         curbuild['version'], linedesc))
 591                 thisinfo['builds'].append(curbuild)
 592                 add_comments('build:' + curbuild['version'])
 593                 mode = 0
 594             else:
 595                 if line.endswith('\\'):
 596                     buildlines.append(line[:-1].lstrip())
 597                 else:
 598                     buildlines.append(line.lstrip())
 599                     bl = ''.join(buildlines)
 600                     add_buildflag(bl, curbuild)
 601                     buildlines = []
 602
 603         if mode == 0:
 604             if not line:
 605                 continue
 606             if line.startswith("#"):
 607                 curcomments.append(line)
 608                 continue
 609             try:
 610                 field, value = line.split(':',1)
 611             except ValueError:
 612                 raise MetaDataException("Invalid metadata in "+linedesc)
 613             if field != field.strip() or value != value.strip():
 614                 raise MetaDataException("Extra spacing found in "+linedesc)
 615
 616             # Translate obsolete fields...
 617             if field == 'Market Version':
 618                 field = 'Current Version'
 619             if field == 'Market Version Code':
 620                 field = 'Current Version Code'
 621
 622             fieldtype = metafieldtype(field)
 623             if fieldtype not in ['build', 'buildv2']:
 624                 add_comments(field)
 625             if fieldtype == 'multiline':
 626                 mode = 1
 627                 thisinfo[field] = []
 628                 if value:
 629                     raise MetaDataException("Unexpected text on same line as " + field + " in " + linedesc)
 630             elif fieldtype == 'string':
 631                 thisinfo[field] = value
 632             elif fieldtype == 'build':
 633                 if value.endswith("\\"):
 634                     mode = 2
 635                     buildlines = [value[:-1]]
 636                 else:
 637                     thisinfo['builds'].append(parse_buildline([value]))
 638                     add_comments('build:' + thisinfo['builds'][-1]['version'])
 639             elif fieldtype == 'buildv2':
 640                 curbuild = {}
 641                 vv = value.split(',')
 642                 if len(vv) != 2:
 643                     raise MetaDataException('Build should have comma-separated version and vercode, not "{0}", in {1}'.
 644                         format(value, linedesc))
 645                 curbuild['version'] = vv[0]
 646                 curbuild['vercode'] = vv[1]
 647                 buildlines = []
 648                 mode = 3
 649             elif fieldtype == 'obsolete':
 650                 pass        # Just throw it away!
 651             else:
 652                 raise MetaDataException("Unrecognised field type for " + field + " in " + linedesc)
 653         elif mode == 1:     # Multiline field
 654             if line == '.':
 655                 mode = 0
 656             else:
 657                 thisinfo[field].append(line)
 658         elif mode == 2:     # Line continuation mode in Build Version
 659             if line.endswith("\\"):
 660                 buildlines.append(line[:-1])
 661             else:
 662                 buildlines.append(line)
 663                 thisinfo['builds'].append(
 664                     parse_buildline(buildlines))
 665                 add_comments('build:' + thisinfo['builds'][-1]['version'])
 666                 mode = 0
 667     add_comments(None)
 668
 669     # Mode at end of file should always be 0...
 670     if mode == 1:
 671         raise MetaDataException(field + " not terminated in " + metafile.name)
 672     elif mode == 2:
 673         raise MetaDataException("Unterminated continuation in " + metafile.name)
 674     elif mode == 3:
 675         raise MetaDataException("Unterminated build in " + metafile.name)
 676
 677     if not thisinfo['Description']:
 678         thisinfo['Description'].append('No description available')
 679
 680     for build in thisinfo['builds']:
 681         build['type'] = get_build_type(build)
 682
 683     return thisinfo
 684
 685 # Write a metadata file.
 686 #
 687 # 'dest'    - The path to the output file
 688 # 'app'     - The app data
 689 def write_metadata(dest, app):
 690
 691     def writecomments(key):
 692         written = 0
 693         for pf, comment in app['comments']:
 694             if pf == key:
 695                 mf.write("%s\n" % comment)
 696                 written += 1
 697         if written > 0:
 698             logging.debug("...writing comments for " + (key if key else 'EOF'))
 699
 700     def writefield(field, value=None):
 701         writecomments(field)
 702         if value is None:
 703             value = app[field]
 704         mf.write("%s:%s\n" % (field, value))
 705
 706     mf = open(dest, 'w')
 707     if app['Disabled']:
 708         writefield('Disabled')
 709     if app['AntiFeatures']:
 710         writefield('AntiFeatures')
 711     if app['Provides']:
 712         writefield('Provides')
 713     writefield('Categories')
 714     writefield('License')
 715     writefield('Web Site')
 716     writefield('Source Code')
 717     writefield('Issue Tracker')
 718     if app['Donate']:
 719         writefield('Donate')
 720     if app['FlattrID']:
 721         writefield('FlattrID')
 722     if app['Bitcoin']:
 723         writefield('Bitcoin')
 724     if app['Litecoin']:
 725         writefield('Litecoin')
 726     if app['Dogecoin']:
 727         writefield('Dogecoin')
 728     mf.write('\n')
 729     if app['Name']:
 730         writefield('Name')
 731     if app['Auto Name']:
 732         writefield('Auto Name')
 733     writefield('Summary')
 734     writefield('Description', '')
 735     for line in app['Description']:
 736         mf.write("%s\n" % line)
 737     mf.write('.\n')
 738     mf.write('\n')
 739     if app['Requires Root']:
 740         writefield('Requires Root', 'Yes')
 741         mf.write('\n')
 742     if app['Repo Type']:
 743         writefield('Repo Type')
 744         writefield('Repo')
 745         mf.write('\n')
 746     for build in app['builds']:
 747         writecomments('build:' + build['version'])
 748         mf.write("Build:%s,%s\n" % ( build['version'], build['vercode']))
 749
 750         def write_builditem(key, value):
 751             if key in ['version', 'vercode', 'origlines', 'type']:
 752                 return
 753             if key in valuetypes['bool'].attrs:
 754                 if not value:
 755                     return
 756                 value = 'yes'
 757             t = flagtype(key)
 758             logging.debug("...writing {0} : {1}".format(key, value))
 759             outline = '    %s=' % key
 760             if t == 'string':
 761                 outline += value
 762             elif t == 'script':
 763                 outline += '&& \\\n        '.join([s.lstrip() for s in value.split('&& ')])
 764             elif t == 'list':
 765                 outline += ','.join(value) if type(value) == list else value
 766             outline += '\n'
 767             mf.write(outline)
 768
 769         for key in ordered_flags:
 770             if key in build:
 771                 write_builditem(key, build[key])
 772         mf.write('\n')
 773
 774     if 'Maintainer Notes' in app:
 775         writefield('Maintainer Notes', '')
 776         for line in app['Maintainer Notes']:
 777             mf.write("%s\n" % line)
 778         mf.write('.\n')
 779         mf.write('\n')
 780
 781
 782     if app['Archive Policy']:
 783         writefield('Archive Policy')
 784     writefield('Auto Update Mode')
 785     writefield('Update Check Mode')
 786     if app['Vercode Operation']:
 787         writefield('Vercode Operation')
 788     if app['Update Check Data']:
 789         writefield('Update Check Data')
 790     if app['Current Version']:
 791         writefield('Current Version')
 792         writefield('Current Version Code')
 793     mf.write('\n')
 794     if app['No Source Since']:
 795         writefield('No Source Since')
 796         mf.write('\n')
 797     writecomments(None)
 798     mf.close()
 799
 800