self.comments = {}
self.added = None
self.lastupdated = None
+ self._modified = set()
# Translates human-readable field names to attribute names, e.g.
# 'Auto Name' to 'AutoName'
if k == 'builds':
d['builds'] = []
for build in v:
- d['builds'].append(build.__dict__)
- else:
- k = App.attr_to_field(k)
- d[k] = v
+ b = {k: v for k, v in build.__dict__.iteritems() if not k.startswith('_')}
+ d['builds'].append(b)
+ elif not k.startswith('_'):
+ f = App.attr_to_field(k)
+ d[f] = v
return d
# Gets the value associated to a field name, e.g. 'Auto Name'
raise MetaDataException('Unrecognised app field: ' + f)
k = App.field_to_attr(f)
self.__dict__[k] = v
+ self._modified.add(k)
# Appends to the value associated to a field name, e.g. 'Auto Name'
def append_field(self, f, v):
}
-def metafieldtype(name):
+def fieldtype(name):
if name in fieldtypes:
return fieldtypes[name]
return TYPE_STRING
self.submodules = False
self.init = ''
self.patch = []
- self.gradle = False
+ self.gradle = []
self.maven = False
self.kivy = False
self.output = None
self.rm = []
self.extlibs = []
self.prebuild = ''
- self.update = None
+ self.update = []
self.target = None
self.scanignore = []
self.scandelete = []
self.ndk = None
self.preassemble = []
self.gradleprops = []
- self.antcommands = None
+ self.antcommands = []
self.novcheck = False
+ self._modified = set()
+
def get_flag(self, f):
if f not in build_flags:
raise MetaDataException('Unrecognised build flag: ' + f)
if f not in build_flags:
raise MetaDataException('Unrecognised build flag: ' + f)
self.__dict__[f] = v
+ self._modified.add(f)
def append_flag(self, f, v):
if f not in build_flags:
self.matching = matching
if type(matching) is str:
self.compiled = re.compile(matching)
+ else:
+ self.matching = set(self.matching)
self.sep = sep
self.fields = fields
self.flags = flags
def _assert_regex(self, values, appid):
for v in values:
if not self.compiled.match(v):
- raise MetaDataException("'%s' is not a valid %s in %s. "
- % (v, self.name, appid) +
- "Regex pattern: %s" % (self.matching))
+ raise MetaDataException("'%s' is not a valid %s in %s. Regex pattern: %s"
+ % (v, self.name, appid, self.matching))
def _assert_list(self, values, appid):
for v in values:
if v not in self.matching:
- raise MetaDataException("'%s' is not a valid %s in %s. "
- % (v, self.name, appid) +
- "Possible values: %s" % (", ".join(self.matching)))
+ raise MetaDataException("'%s' is not a valid %s in %s. Possible values: %s"
+ % (v, self.name, appid, ', '.join(self.matching)))
def check(self, v, appid):
- if type(v) is not str or not v:
+ if not v:
return
- if self.sep is not None:
- values = v.split(self.sep)
+ if type(v) == list:
+ values = v
else:
values = [v]
- if type(self.matching) is list:
+ if type(self.matching) is set:
self._assert_list(values, appid)
else:
self._assert_regex(values, appid)
FieldValidator("HTTP link",
r'^http[s]?://', None,
- ["Web Site", "Source Code", "Issue Tracker", "Changelog", "Donate"], []),
+ ["WebSite", "SourceCode", "IssueTracker", "Changelog", "Donate"], []),
FieldValidator("Bitcoin address",
r'^[a-zA-Z0-9]{27,34}$', None,
["Litecoin"],
[]),
- FieldValidator("bool",
- r'([Yy]es|[Nn]o|[Tt]rue|[Ff]alse)', None,
- ["Requires Root"],
- ['submodules', 'oldsdkloc', 'forceversion', 'forcevercode',
- 'novcheck']),
-
FieldValidator("Repo Type",
['git', 'git-svn', 'svn', 'hg', 'bzr', 'srclib'], None,
- ["Repo Type"],
+ ["RepoType"],
[]),
FieldValidator("Binaries",
FieldValidator("Archive Policy",
r'^[0-9]+ versions$', None,
- ["Archive Policy"],
+ ["ArchivePolicy"],
[]),
FieldValidator("Anti-Feature",
FieldValidator("Auto Update Mode",
r"^(Version .+|None)$", None,
- ["Auto Update Mode"],
+ ["AutoUpdateMode"],
[]),
FieldValidator("Update Check Mode",
r"^(Tags|Tags .+|RepoManifest|RepoManifest/.+|RepoTrunk|HTTP|Static|None)$", None,
- ["Update Check Mode"],
+ ["UpdateCheckMode"],
[])
}
# Check an app's metadata information for integrity errors
def check_metadata(app):
for v in valuetypes:
- for f in v.fields:
- v.check(app.get_field(f), app.id)
+ for k in v.fields:
+ if k not in app._modified:
+ continue
+ v.check(app.__dict__[k], app.id)
for build in app.builds:
- for f in v.flags:
- v.check(build.get_flag(f), app.id)
+ for k in v.flags:
+ if k not in build._modified:
+ continue
+ v.check(build.__dict__[k], app.id)
# Formatter for descriptions. Create an instance, and call parseline() with
self.bold = False
self.ital = False
self.state = self.stNONE
+ self.laststate = self.stNONE
self.text_html = ''
self.text_txt = ''
self.html = StringIO()
self.endol()
def endpara(self):
+ self.laststate = self.state
self.state = self.stNONE
whole_para = ' '.join(self.para_lines)
self.addtext(whole_para)
self.text.write(textwrap.fill(whole_para, 80,
break_long_words=False,
break_on_hyphens=False))
- self.text.write('\n\n')
self.html.write('</p>')
del self.para_lines[:]
def endul(self):
self.html.write('</ul>')
- self.text.write('\n')
+ self.laststate = self.state
self.state = self.stNONE
def endol(self):
self.html.write('</ol>')
- self.text.write('\n')
+ self.laststate = self.state
self.state = self.stNONE
def formatted(self, txt, html):
self.endcur()
elif line.startswith('* '):
self.endcur([self.stUL])
- self.text.write(line)
- self.text.write('\n')
if self.state != self.stUL:
self.html.write('<ul>')
self.state = self.stUL
+ if self.laststate != self.stNONE:
+ self.text.write('\n\n')
+ else:
+ self.text.write('\n')
+ self.text.write(line)
self.html.write('<li>')
self.addtext(line[1:])
self.html.write('</li>')
elif line.startswith('# '):
self.endcur([self.stOL])
- self.text.write(line)
- self.text.write('\n')
if self.state != self.stOL:
self.html.write('<ol>')
self.state = self.stOL
+ if self.laststate != self.stNONE:
+ self.text.write('\n\n')
+ else:
+ self.text.write('\n')
+ self.text.write(line)
self.html.write('<li>')
self.addtext(line[1:])
self.html.write('</li>')
self.para_lines.append(line)
self.endcur([self.stPARA])
if self.state == self.stNONE:
- self.html.write('<p>')
self.state = self.stPARA
+ if self.laststate != self.stNONE:
+ self.text.write('\n\n')
+ self.html.write('<p>')
def end(self):
self.endcur()
- self.text_txt = self.text.getvalue().rstrip()
+ self.text_txt = self.text.getvalue()
self.text_html = self.html.getvalue()
self.text.close()
self.html.close()
def post_metadata_parse(app):
for k, v in app.__dict__.iteritems():
+ if k not in app._modified:
+ continue
if type(v) in (float, int):
app.__dict__[k] = str(v)
for build in app.builds:
for k, v in build.__dict__.iteritems():
+ if k not in build._modified:
+ continue
if type(v) in (float, int):
build.__dict__[k] = str(v)
continue
build.__dict__[k] = re.sub(esc_newlines, '', v).lstrip().rstrip()
elif ftype == TYPE_BOOL:
# TODO handle this using <xsd:element type="xsd:boolean> in a schema
- if isinstance(v, basestring) and v == 'true':
- build.__dict__[k] = True
- elif ftype == TYPE_BOOL:
+ if isinstance(v, basestring):
+ build.__dict__[k] = _decode_bool(v)
+ elif ftype == TYPE_STRING:
if isinstance(v, bool) and v:
build.__dict__[k] = 'yes'
return rv
+bool_true = re.compile(r'([Yy]es|[Tt]rue)')
+bool_false = re.compile(r'([Nn]o|[Ff]alse)')
+
+
+def _decode_bool(s):
+ if bool_true.match(s):
+ return True
+ if bool_false.match(s):
+ return False
+ raise MetaDataException("Invalid bool '%s'" % s)
+
+
def parse_metadata(metadatapath):
_, ext = common.get_extension(metadatapath)
accepted = common.config['accepted_formats']
raise MetaDataException('"%s" is not an accepted format, convert to: %s' % (
metadatapath, ', '.join(accepted)))
- app = None
- if ext == 'txt':
- app = parse_txt_metadata(metadatapath)
- elif ext == 'json':
- app = parse_json_metadata(metadatapath)
- elif ext == 'xml':
- app = parse_xml_metadata(metadatapath)
- elif ext == 'yaml':
- app = parse_yaml_metadata(metadatapath)
- else:
- raise MetaDataException('Unknown metadata format: %s' % metadatapath)
+ app = App()
+ app.metadatapath = metadatapath
+ app.id, _ = common.get_extension(os.path.basename(metadatapath))
+
+ with open(metadatapath, 'r') as mf:
+ if ext == 'txt':
+ parse_txt_metadata(mf, app)
+ elif ext == 'json':
+ parse_json_metadata(mf, app)
+ elif ext == 'xml':
+ parse_xml_metadata(mf, app)
+ elif ext == 'yaml':
+ parse_yaml_metadata(mf, app)
+ else:
+ raise MetaDataException('Unknown metadata format: %s' % metadatapath)
post_metadata_parse(app)
return app
-def parse_json_metadata(metadatapath):
-
- app = get_default_app_info(metadatapath)
+def parse_json_metadata(mf, app):
# fdroid metadata is only strings and booleans, no floats or ints. And
# json returns unicode, and fdroidserver still uses plain python strings
# TODO create schema using https://pypi.python.org/pypi/jsonschema
- jsoninfo = None
- with open(metadatapath, 'r') as f:
- jsoninfo = json.load(f, object_hook=_decode_dict,
- parse_int=lambda s: s,
- parse_float=lambda s: s)
+ jsoninfo = json.load(mf, object_hook=_decode_dict,
+ parse_int=lambda s: s,
+ parse_float=lambda s: s)
app.update_fields(jsoninfo)
for f in ['Description', 'Maintainer Notes']:
v = app.get_field(f)
return app
-def parse_xml_metadata(metadatapath):
-
- app = get_default_app_info(metadatapath)
+def parse_xml_metadata(mf, app):
- tree = ElementTree.ElementTree(file=metadatapath)
+ tree = ElementTree.ElementTree(file=mf)
root = tree.getroot()
if root.tag != 'resources':
return app
-def parse_yaml_metadata(metadatapath):
+def parse_yaml_metadata(mf, app):
- app = get_default_app_info(metadatapath)
-
- yamlinfo = None
- with open(metadatapath, 'r') as f:
- yamlinfo = yaml.load(f, Loader=YamlLoader)
+ yamlinfo = yaml.load(mf, Loader=YamlLoader)
app.update_fields(yamlinfo)
return app
build_cont = re.compile(r'^[ \t]')
-def parse_txt_metadata(metadatapath):
+def parse_txt_metadata(mf, app):
linedesc = None
elif t == TYPE_STRING or t == TYPE_SCRIPT:
build.set_flag(pk, pv)
elif t == TYPE_BOOL:
- if pv == 'yes':
- build.set_flag(pk, True)
+ build.set_flag(pk, _decode_bool(pv))
def parse_buildline(lines):
v = "".join(lines)
if len(parts) < 3:
raise MetaDataException("Invalid build format: " + v + " in " + metafile.name)
build = Build()
- build.origlines = lines
build.version = parts[0]
build.vercode = parts[1]
if parts[2].startswith('!'):
app.comments[key] = list(curcomments)
del curcomments[:]
- app = get_default_app_info(metadatapath)
- metafile = open(metadatapath, "r")
-
mode = 0
buildlines = []
multiline_lines = []
vc_seen = set()
c = 0
- for line in metafile:
+ for line in mf:
c += 1
- linedesc = "%s:%d" % (metafile.name, c)
+ linedesc = "%s:%d" % (mf.name, c)
line = line.rstrip('\r\n')
if mode == 3:
if build_cont.match(line):
if f == 'Market Version Code':
f = 'Current Version Code'
- ftype = metafieldtype(f)
+ ftype = fieldtype(f)
if ftype not in [TYPE_BUILD, TYPE_BUILD_V2]:
add_comments(f)
if ftype == TYPE_MULTILINE:
add_comments('build:' + app.builds[-1].vercode)
mode = 0
add_comments(None)
- metafile.close()
# Mode at end of file should always be 0
if mode == 1:
- raise MetaDataException(f + " not terminated in " + metafile.name)
+ raise MetaDataException(f + " not terminated in " + mf.name)
if mode == 2:
raise MetaDataException("Unterminated continuation in " + metafile.name)
if mode == 3:
mf.write("# %s\n" % line)
def w_field(f, v):
- t = metafieldtype(f)
+ t = fieldtype(f)
if t == TYPE_LIST:
v = ','.join(v)
elif t == TYPE_MULTILINE:
continue
t = flagtype(f)
- out = ' %s=' % f
+ mf.write(' %s=' % f)
if t == TYPE_STRING:
- out += v
+ mf.write(v)
elif t == TYPE_BOOL:
- out += 'yes'
+ mf.write('yes')
elif t == TYPE_SCRIPT:
- out += '&& \\\n '.join([s.lstrip() for s in v.split('&& ')])
+ first = True
+ for s in v.split(' && '):
+ if first:
+ first = False
+ else:
+ mf.write(' && \\\n ')
+ mf.write(s)
elif t == TYPE_LIST:
- out += ','.join(v) if type(v) == list else v
+ mf.write(','.join(v))
- mf.write(out)
mf.write('\n')
write_plaintext_metadata(mf, app, w_comment, w_field, w_build)
def w_field(f, v, prefix='', t=None):
if t is None:
- t = metafieldtype(f)
+ t = fieldtype(f)
v = ''
if t == TYPE_LIST:
v = '\n'