def gather_dependencies(pom_path):
if not pom_path:
return []
pom = POM(pom_path)
pom_props = get_model_variables(pom)
deps, depm, props = _get_dependencies(pom)
# expand project model variables
expand_props(deps, pom_props)
expand_props(depm, pom_props)
curr_pom = pom
parent = pom.parent
while parent:
ppom = None
if parent.relativePath:
try:
ppom_path = os.path.join(os.path.dirname(curr_pom._path),
parent.relativePath)
ppom = POM(ppom_path)
except PomLoadingException:
pass
if not ppom:
ppom = get_parent_pom(parent)
parent = ppom.parent
pom_props = get_model_variables(ppom)
pdeps, pdepm, pprops = _get_dependencies(ppom)
expand_props(pdeps, pom_props)
expand_props(pdepm, pom_props)
# merge "dependencies" sections
merge_sections(deps, pdeps)
# merge "dependencyManagement" sections
merge_sections(depm, pdepm)
# merge "properties" sections
for pkey in pprops:
if pkey not in props:
props[pkey] = pprops[pkey]
curr_pom = ppom
for d in deps:
d.interpolate(props)
for dm in depm:
dm.interpolate(props)
# apply dependencyManagement on deps
for d in deps:
for dm in depm:
if d.compare_to(dm):
d.merge_with(dm)
break
# only deps with scope "compile" or "runtime" are interesting
deps = [x for x in deps if x.scope in ["", "compile", "runtime"]]
return deps
def get_parent_pom(pom):
try:
metadata = Metadata(config)
known_artifacts = metadata.get_provided_artifacts()
# TODO: implement __hash__() and __cmp__() in MetadataArtifact
for artifact in known_artifacts:
if (artifact.extension == "pom" and
artifact.groupId == pom.groupId and
artifact.artifactId == pom.artifactId):
return POM(artifact.path)
except IOError:
pass
req = ResolutionRequest(pom.groupId, pom.artifactId,
extension="pom", version=pom.version)
result = XMvnResolve.process_raw_request([req])[0]
if not result:
raise Exception("Unable to resolve parent POM")
return POM(result.artifactPath)
def _main():
usage = "usage: %prog [options] metadata_path pom_path|<MVN spec> [jar_path]"
parser = OptionParser(usage=usage)
parser.add_option(
"-a",
"--append",
type="str",
help="Additional depmaps to add (gid:aid) [default: %default]")
parser.add_option('-r',
'--versions',
type="str",
help='Additional versions to add for each depmap')
parser.add_option('-n',
'--namespace',
type="str",
help='Namespace to use for generated fragments',
default="")
parser.add_option('--pom-base',
type="str",
help='Base path under which POM files are installed',
default="")
parser.add_option('--jar-base',
type="str",
help='Base path under which JAR files are installed',
default="")
parser.set_defaults(append=None)
(options, args) = parser.parse_args()
append_deps = options.append
add_versions = options.versions
namespace = options.namespace
pom_base = options.pom_base
jar_base = options.jar_base
if len(args) < 2:
parser.error("Incorrect number of arguments")
# These will fail when incorrect number of arguments is given.
metadata_path = args[0].strip()
pom_path = args[1].strip()
jar_path = None
artifact = None
have_pom = False
if len(args) == 3:
jar_path = args[2].strip()
if ':' in pom_path:
pom_str = pom_path.rsplit('/')[-1]
artifact = MetadataArtifact.from_mvn_str(pom_str)
artifact_ext = artifact.extension or "jar"
file_ext = os.path.splitext(jar_path)[1][1:]
if artifact_ext != file_ext:
raise ExtensionsDontMatch(artifact_ext, file_ext)
if artifact.extension == 'jar':
artifact.extension = ''
if not artifact.version:
parser.error("Artifact definition has to include version")
else:
artifact = MetadataArtifact.from_pom(pom_path)
ext = os.path.splitext(jar_path)[1][1:]
if ext != "jar":
artifact.extension = ext
have_pom = True
if artifact:
inject_pom_properties(jar_path, artifact)
else:
# looks like POM only artifact
if ':' not in pom_path:
artifact = MetadataArtifact.from_pom(pom_path)
have_pom = True
if POM(pom_path).packaging != "pom":
raise PackagingTypeMissingFile(pom_path)
else:
sys.exit(
"JAR file path must be specified when using artifact coordinates"
)
# output file path for file lists
print(metadata_path)
artifact = add_compat_versions(artifact, add_versions)
if add_versions:
pom_path, jar_path = _make_files_versioned(add_versions, pom_path,
jar_path, pom_base,
jar_base)
if namespace:
artifact.namespace = namespace
artifact.properties["xmvn.resolver.disableEffectivePom"] = "true"
buildroot = os.environ.get('RPM_BUILD_ROOT')
am = []
if jar_path:
metadata_jar_path = os.path.abspath(jar_path)
artifact.path = metadata_jar_path.replace(
buildroot, "") if buildroot else metadata_jar_path
artifact = add_aliases(artifact, append_deps)
if artifact.extension == "jar":
artifact.extension = ""
am.append(artifact.copy())
# output file path for file list (if it's not versioned)
if not add_versions:
_print_path_with_dirs(jar_path, jar_base)
if have_pom:
metadata_pom_path = os.path.abspath(pom_path)
artifact.path = metadata_pom_path.replace(
buildroot, "") if buildroot else metadata_pom_path
artifact.extension = "pom"
artifact.aliases = None
artifact = add_aliases(artifact, append_deps)
am.append(artifact.copy())
# output file path for file list (if it's not versioned)
if not add_versions:
_print_path_with_dirs(pom_path, pom_base)
write_metadata(metadata_path, am)
def _main():
OptionParser.format_epilog = lambda self, formatter: self.epilog
parser = OptionParser(usage=usage, epilog=epilog)
parser.add_option("--skip-dependencies",
action="store_true",
default=False,
help="skip dependencies section in resulting metadata")
parser.add_option("-D",
action="append",
type="str",
help="add artifact property",
metavar="property=value")
sys.argv = args_to_unicode(sys.argv)
(options, args) = parser.parse_args()
if len(args) < 1:
parser.error("At least 1 argument is required")
try:
uart = Artifact.from_mvn_str(args[0])
uart.validate(allow_backref=False)
if len(args) == 1:
parser.error(
"When using artifact specification artifact path must be "
"provided")
if not (uart.groupId and uart.artifactId and uart.version):
parser.error("Defined artifact has to include at least groupId, "
"artifactId and version")
except (ArtifactFormatException):
if is_it_ivy_file(args[0]):
uart = IvyFile(args[0])
else:
# it should be good old POM file
uart = POM(args[0])
pom_path = args[0]
else:
pom_path = None
art = MetadataArtifact(uart.groupId, uart.artifactId, version=uart.version)
if hasattr(uart, "extension") and uart.extension:
art.extension = uart.extension
if hasattr(uart, "classifier") and uart.classifier:
art.classifier = uart.classifier
jar_path = None
if len(args) > 1:
jar_path = args[1]
extension = (os.path.splitext(jar_path)[1])[1:]
if hasattr(
art, "extension"
) and art.extension and art.extension != extension and not pom_path:
raise ExtensionsDontMatch("Extensions don't match: '%s' != '%s'" %
(art.extension, extension))
else:
art.extension = extension
else:
art.extension = "pom"
if os.path.exists(config):
metadata = Metadata.create_from_file(config)
else:
metadata = Metadata()
if (not options.skip_dependencies and pom_path
and not is_it_ivy_file(pom_path)):
deps = []
mvn_deps = gather_dependencies(pom_path)
for d in mvn_deps:
deps.append(MetadataDependency.from_mvn_dependency(d))
if deps:
art.dependencies = set(deps)
else:
art.properties["xmvn.resolver.disableEffectivePom"] = "true"
if options.D:
for d_opt in options.D:
key, value = d_opt.split("=")
art.properties[key] = value
add_artifact_elements(metadata, art, pom_path, jar_path)
metadata.write_to_file(config)
def test_decorated(self, *args, **kwargs):
main_dir = os.path.dirname(os.path.realpath(__file__))
fn(self, POM(os.path.join(main_dir, "data", fname)))
parser.error("Artifact definition has to include version")
else:
artifact = MetadataArtifact.from_pom(pom_path)
ext = os.path.splitext(jar_path)[1][1:]
if ext != "jar":
artifact.extension = ext
have_pom = True
if artifact:
inject_pom_properties(jar_path, artifact)
else:
# looks like POM only artifact
if ':' not in pom_path:
artifact = MetadataArtifact.from_pom(pom_path)
have_pom = True
if POM(pom_path).packaging != "pom":
raise PackagingTypeMissingFile(pom_path)
else:
print(
"JAR file path must be specified when using artifact coordinates"
)
sys.exit(1)
# output file path for file lists
print(metadata_path)
artifact = add_compat_versions(artifact, add_versions)
if add_versions:
pom_path, jar_path = _make_files_versioned(add_versions, pom_path,
jar_path)
def from_pom(cls, pom_path):
pom = POM(pom_path)
return cls(pom.groupId, pom.artifactId, version=pom.version,
path=pom_path)
try:
uart = Artifact.from_mvn_str(args[0])
uart.validate(allow_backref=False)
if len(args) == 1:
parser.error("When using artifact specification artifact path must be "
"provided")
if not (uart.groupId and uart.artifactId and uart.version):
parser.error("Defined artifact has to include at least groupId, "
"artifactId and version")
except (ArtifactFormatException):
if is_it_ivy_file(args[0]):
uart = IvyFile(args[0])
else:
# it should be good old POM file
uart = POM(args[0])
pom_path = args[0]
else:
pom_path = None
art = MetadataArtifact(uart.groupId, uart.artifactId, version=uart.version)
if hasattr(uart, "extension") and uart.extension:
art.extension = uart.extension
if hasattr(uart, "classifier") and uart.classifier:
art.classifier= uart.classifier
jar_path = None
if len(args) > 1:
jar_path = args[1]
extension = (os.path.splitext(jar_path)[1])[1:]
if hasattr(art, "extension") and art.extension and art.extension != extension and not pom_path:
