def info_project(cfg, location):
project = prosconfig.ProjectConfig(path=location)
details = dict()
details['kernel'] = project.kernel
templates = local.get_local_templates(
pros_cfg=cfg.pros_cfg, template_types=[TemplateTypes.kernel])
details['kernelUpToDate'] = semver.compare(project.kernel,
sorted(templates, key=lambda t: semver.Version(t.version))[-1].version) \
>= 0
templates = local.get_local_templates(
pros_cfg=cfg.pros_cfg, template_types=[TemplateTypes.library])
details['libraries'] = dict()
if project.libraries.__class__ is dict:
for (lib, ver) in project.libraries.items():
details['libraries'][lib] = dict()
details['libraries'][lib]['version'] = ver
sorted_versions = sorted(
[t.version for t in templates if t.name == lib],
key=lambda v: semver.Version(v))
if len(sorted_versions) > 0:
latest = semver.compare(ver, sorted_versions[-1]) >= 0
else:
latest = True
details['libraries'][lib]['latest'] = latest
click.echo(json.dumps(details))
def most_recent(version_constraint_string1, version_constraint_string2):
range1 = version_range(version_constraint_string1)
range2 = version_range(version_constraint_string2)
if (not range1[1] is None) and (not range2[0] is None) and sv.compare(range1[1],range2[0])==-1:
return version_constraint(range2)
elif (not range2[1] is None) and (not range1[0] is None) and sv.compare(range2[1],range1[0])==-1:
return version_constraint(range1)
raise ValueError(f"ERROR: {range1} and {range2} intersect.")
def _get_version(self, spec):
spec = self._parse_spec(spec)
version = spec['version']
version_sign = spec['version_sign']
resource_name = spec['resource_name']
if version_sign == '==':
return os.path.join(self.fpath, spec['resource_name'], version)
found = self.iter_contents(resource_name)
if version is None:
sc = semantic_version.compare
sorted_vers = sorted(found,
cmp=lambda a, b: sc(a['version'],
b['version']),
reverse=True)
if not sorted_vers:
raise ResourceNotFound(spec)
version = sorted_vers[0]['version']
else:
version = '{}{}'.format(version_sign, version)
matched = filter(lambda x: semantic_version.match(version,
x['version']),
found)
sorted_vers = sorted(matched,
cmp=lambda a, b: semantic_version.compare(
a['version'],
b['version']),
reverse=True)
version = next((x['version'] for x in sorted_vers
if semantic_version.match(version, x['version'])),
None)
if version is None:
raise ResourceNotFound(spec)
return version
def _get_version(self, spec):
spec = self._parse_spec(spec)
version = spec['version']
version_sign = spec['version_sign']
resource_name = spec['resource_name']
if version_sign == '==':
return os.path.join(self.fpath, spec['resource_name'], version)
found = self.iter_contents(resource_name)
if version is None:
sc = semantic_version.compare
sorted_vers = sorted(found,
cmp=lambda a, b: sc(a['version'],
b['version']),
reverse=True)
if not sorted_vers:
raise ResourceNotFound(spec)
version = sorted_vers[0]['version']
else:
version = '{}{}'.format(version_sign, version)
matched = filter(lambda x: semantic_version.match(version,
x['version']),
found)
sorted_vers = sorted(matched,
cmp=lambda a, b: semantic_version.compare(
a['version'],
b['version']),
reverse=True)
version = next((x['version'] for x in sorted_vers
if semantic_version.match(version, x['version'])),
None)
if version is None:
raise ResourceNotFound(spec)
return version
def get_latest_repo_version(self, name, requirements):
version = None
for versions in PackageRepoIterator(name, self.repositories):
pkgdata = self.max_satisfying_repo_version(versions, requirements)
if not pkgdata:
continue
if not version or semantic_version.compare(pkgdata["version"], version) == 1:
version = pkgdata["version"]
return version
def version_cmp(af1, af2):
if af1['version'] is None and af2['version'] is None:
return 0
elif af1['version'] is None:
return -1
elif af2['version'] is None:
return 1
return semantic_version.compare(
af1['version'], af2['version'])
def version_cmp(af1, af2):
if af1['version'] is None and af2['version'] is None:
return 0
elif af1['version'] is None:
return -1
elif af2['version'] is None:
return 1
return semantic_version.compare(af1['version'],
af2['version'])
def compare(self):
if self.valid_semver():
comparison = semantic_version.compare(self.current_version, self.latest_version)
if (comparison >= 0):
self.status = "UPTODATE"
else:
self.status = "NEEDS_UPDATE"
else:
self.status = "INVALID_SEMVER"
def get_latest_repo_version(self, name, requirements):
version = None
for versions in PackageRepoIterator(name, self.repositories):
pkgdata = self.max_satisfying_repo_version(versions, requirements)
if not pkgdata:
continue
if not version or semantic_version.compare(pkgdata['version'],
version) == 1:
version = pkgdata['version']
return version
def compare(self):
if self.valid_semver():
comparison = semantic_version.compare(self.current_version,
self.latest_version)
if (comparison >= 0):
self.status = "UPTODATE"
else:
self.status = "NEEDS_UPDATE"
else:
self.status = "INVALID_SEMVER"
def test_comparisons(self):
for i, first in enumerate(self.order):
first_ver = semantic_version.Version(first)
for j, second in enumerate(self.order):
second_ver = semantic_version.Version(second)
if i < j:
self.assertTrue(first_ver < second_ver, '%r !< %r' % (first_ver, second_ver))
elif i == j:
self.assertTrue(first_ver == second_ver, '%r != %r' % (first_ver, second_ver))
else:
self.assertTrue(first_ver > second_ver, '%r !> %r' % (first_ver, second_ver))
self.assertEqual(cmp(i, j), semantic_version.compare(first, second))
def get_latest_repo_version( # pylint: disable=unused-argument
self,
name,
requirements,
silent=False):
version = None
for versions in PackageRepoIterator(name, self.repositories):
pkgdata = self.max_satisfying_repo_version(versions, requirements)
if not pkgdata:
continue
if (not version or semantic_version.compare(
pkgdata["version"], version) == 1):
version = pkgdata["version"]
return version
def get_latest_repo_version( # pylint: disable=unused-argument
self,
name,
requirements,
silent=False):
version = None
for versions in PackageRepoIterator(name, self.repositories):
pkgdata = self.max_satisfying_repo_version(versions, requirements)
if not pkgdata:
continue
if not version or semantic_version.compare(pkgdata['version'],
version) == 1:
version = pkgdata['version']
return version
def test_comparisons(self):
for i, first in enumerate(self.order):
first_ver = semantic_version.Version(first)
for j, second in enumerate(self.order):
second_ver = semantic_version.Version(second)
with self.subTest(first=first, second=second):
if i < j:
self.assertTrue(first_ver < second_ver, '%r !< %r' % (first_ver, second_ver))
elif i == j:
self.assertTrue(first_ver == second_ver, '%r != %r' % (first_ver, second_ver))
else:
self.assertTrue(first_ver > second_ver, '%r !> %r' % (first_ver, second_ver))
cmp_res = -1 if i < j else (1 if i > j else 0)
self.assertEqual(cmp_res, semantic_version.compare(first, second))
def main():
parser = argparse.ArgumentParser(description='Maven Update v' +
__version__)
parser.add_argument('file', help='gradle.build file')
parser.add_argument('-u',
'--update',
help='Actually update the gradle.build file',
action='store_true')
parser.add_argument('-p',
'--prerelease',
help='Update to prerelease versions',
action='store_true')
args = parser.parse_args()
log.debug(args.file)
gradlefile = os.path.expanduser(args.file)
if os.path.abspath(gradlefile):
gradlefile = os.path.join(os.getcwd(), gradlefile)
artifacts = parse_artifacts(gradlefile)
new_versions = []
for art in artifacts:
if 'com.android.support' not in art.group and 'com.google.android.gms' not in art.group:
latest_version = find_latest_version(art, args.prerelease)
new_versions.append(VersionCheck(latest_version, art))
log.debug(new_versions)
for check in new_versions:
meta = check.metadata
try:
if semantic_version.compare(meta.version, check.version) < 0:
print('%s:%s %s -> %s' %
(meta.group, meta.artifact, meta.version, check.version))
else:
print('%s:%s %s current' %
(meta.group, meta.artifact, meta.version))
except ValueError as e:
print('%s for %s' % (e, meta))
# actually rewrite the file, if one want
if args.update:
print("Rewriting build.gradle with updates..")
rewrite(gradlefile, new_versions)
def _update_highest_version(collection_version):
"""
Checks if this version is greater than the most highest one.
If this version is the first version in collection, is_highest is set to True.
If this version is greater than the highest version in collection, set is_highest
equals False on the last highest version and True on this version.
Otherwise does nothing.
"""
last_highest = collection_version.collection.versions.filter(is_highest=True).first()
if not last_highest:
collection_version.is_highest = True
return None
if semver.compare(collection_version.version, last_highest.version) > 0:
last_highest.is_highest = False
collection_version.is_highest = True
last_highest.save()
collection_version.save()
def main():
parser = argparse.ArgumentParser(description='Maven Update v'+__version__)
parser.add_argument('file', help='gradle.build file')
parser.add_argument('-u', '--update', help='Actually update the gradle.build file', action='store_true')
parser.add_argument('-p', '--prerelease', help='Update to prerelease versions', action='store_true')
args = parser.parse_args()
log.debug(args.file)
gradlefile = os.path.expanduser(args.file)
if os.path.abspath(gradlefile):
gradlefile = os.path.join(os.getcwd(), gradlefile)
artifacts = parse_artifacts(gradlefile)
new_versions = []
for art in artifacts:
if 'com.android.support' not in art.group and 'com.google.android.gms' not in art.group:
latest_version = find_latest_version(art, args.prerelease)
new_versions.append(VersionCheck(latest_version, art))
log.debug(new_versions)
for check in new_versions:
meta = check.metadata
try:
if semantic_version.compare(meta.version, check.version) < 0:
print('%s:%s %s -> %s' % (meta.group, meta.artifact, meta.version, check.version))
else:
print('%s:%s %s current' % (meta.group, meta.artifact, meta.version))
except ValueError as e:
print('%s for %s' % (e, meta))
# actually rewrite the file, if one want
if args.update:
print("Rewriting build.gradle with updates..")
rewrite(gradlefile, new_versions)
