def generate_project(self, project): def linked_folder_id(source_set): return source_set.source_base.replace(os.path.sep, '.') def base_path(source_set): return os.path.join(source_set.root_dir, source_set.source_base) def create_source_base_template(source_set): source_base = base_path(source_set) return source_base, TemplateData(id=linked_folder_id(source_set), path=source_base) source_bases = dict(map(create_source_base_template, project.sources)) if project.has_python: source_bases.update( map(create_source_base_template, project.py_sources)) source_bases.update( map(create_source_base_template, project.py_libs)) def create_source_template(base_id, includes=None, excludes=None): return TemplateData( base=base_id, includes='|'.join(OrderedSet(includes)) if includes else None, excludes='|'.join(OrderedSet(excludes)) if excludes else None, ) def create_sourcepath(base_id, sources): def normalize_path_pattern(path): return '{}/'.format(path) if not path.endswith('/') else path includes = [ normalize_path_pattern(src_set.path) for src_set in sources if src_set.path ] excludes = [] for source_set in sources: excludes.extend( normalize_path_pattern(exclude) for exclude in source_set.excludes) return create_source_template(base_id, includes, excludes) pythonpaths = [] if project.has_python: for source_set in project.py_sources: pythonpaths.append( create_source_template(linked_folder_id(source_set))) for source_set in project.py_libs: lib_path = source_set.path if source_set.path.endswith( '.egg') else '{}/'.format(source_set.path) pythonpaths.append( create_source_template(linked_folder_id(source_set), includes=[lib_path])) configured_project = TemplateData( name=self.project_name, java=TemplateData(jdk=self.java_jdk, language_level=('1.{}'.format( self.java_language_level))), python=project.has_python, scala=project.has_scala and not project.skip_scala, source_bases=source_bases.values(), pythonpaths=pythonpaths, debug_port=project.debug_port, ) outdir = os.path.abspath(os.path.join(self.gen_project_workdir, 'bin')) safe_mkdir(outdir) source_sets = defaultdict(OrderedSet) # base_id -> source_set for source_set in project.sources: source_sets[linked_folder_id(source_set)].add(source_set) sourcepaths = [ create_sourcepath(base_id, sources) for base_id, sources in source_sets.items() ] libs = list(project.internal_jars) libs.extend(project.external_jars) configured_classpath = TemplateData( sourcepaths=sourcepaths, has_tests=project.has_tests, libs=libs, scala=project.has_scala, # Eclipse insists the outdir be a relative path unlike other paths outdir=os.path.relpath(outdir, get_buildroot()), ) def apply_template(output_path, template_relpath, **template_data): with safe_open(output_path, 'w') as output: Generator(pkgutil.get_data(__name__, template_relpath), **template_data).write(output) apply_template(self.project_filename, self.project_template, project=configured_project) apply_template(self.classpath_filename, self.classpath_template, classpath=configured_classpath) apply_template(os.path.join( self.gen_project_workdir, 'Debug on port {}.launch'.format(project.debug_port)), self.debug_template, project=configured_project) apply_template(self.coreprefs_filename, self.coreprefs_template, project=configured_project) for resource in _SETTINGS: with safe_open(os.path.join(self.cwd, '.settings', resource), 'w') as prefs: prefs.write( pkgutil.get_data(__name__, os.path.join(_TEMPLATE_BASEDIR, resource))) factorypath = TemplateData( project_name=self.project_name, # The easiest way to make sure eclipse sees all annotation processors is to put all libs on # the apt factorypath - this does not seem to hurt eclipse performance in any noticeable way. jarpaths=libs) apply_template(self.apt_filename, self.apt_template, factorypath=factorypath) if project.has_python: apply_template(self.pydev_filename, self.pydev_template, project=configured_project) else: safe_delete(self.pydev_filename) print('\nGenerated project at {}{}'.format(self.gen_project_workdir, os.sep))
def create_source_base_template(source_set): source_base = base_path(source_set) return source_base, TemplateData(id=linked_folder_id(source_set), path=source_base)
def generate_project(self, project): def linked_folder_id(source_set): return source_set.source_base.replace(os.path.sep, '.') def base_path(source_set): return os.path.join(source_set.root_dir, source_set.source_base) def create_source_base_template(source_set): source_base = base_path(source_set) return source_base, TemplateData( id=linked_folder_id(source_set), path=source_base ) source_bases = dict(map(create_source_base_template, project.sources)) def create_source_template(base_id, includes=None, excludes=None): return TemplateData( base=base_id, includes='|'.join(OrderedSet(includes)) if includes else None, excludes='|'.join(OrderedSet(excludes)) if excludes else None, ) def create_sourcepath(base_id, sources): def normalize_path_pattern(path): return '{}/'.format(path) if not path.endswith('/') else path includes = [normalize_path_pattern(src_set.path) for src_set in sources if src_set.path] excludes = [] for source_set in sources: excludes.extend(normalize_path_pattern(exclude) for exclude in source_set.excludes) return create_source_template(base_id, includes, excludes) source_sets = defaultdict(OrderedSet) # base_id -> source_set for source_set in project.sources: source_sets[linked_folder_id(source_set)].add(source_set) sourcepaths = [create_sourcepath(base_id, sources) for base_id, sources in source_sets.items()] libs = [] def add_jarlibs(classpath_entries): for classpath_entry in classpath_entries: libs.append((classpath_entry.jar, classpath_entry.source_jar)) add_jarlibs(project.internal_jars) add_jarlibs(project.external_jars) scala = TemplateData( language_level=self.scala_language_level, compiler_classpath=project.scala_compiler_classpath ) outdir = os.path.abspath(self.ensime_output_dir) if not os.path.exists(outdir): os.makedirs(outdir) configured_project = TemplateData( name=self.project_name, java=TemplateData( jdk=self.java_jdk, language_level=('1.{}'.format(self.java_language_level)) ), scala=scala, source_bases=source_bases.values(), sourcepaths=sourcepaths, has_tests=project.has_tests, internal_jars=[cp_entry.jar for cp_entry in project.internal_jars], internal_source_jars=[cp_entry.source_jar for cp_entry in project.internal_jars if cp_entry.source_jar], external_jars=[cp_entry.jar for cp_entry in project.external_jars], external_javadoc_jars=[cp_entry.javadoc_jar for cp_entry in project.external_jars if cp_entry.javadoc_jar], external_source_jars=[cp_entry.source_jar for cp_entry in project.external_jars if cp_entry.source_jar], libs=libs, outdir=os.path.relpath(outdir, get_buildroot()), ) def apply_template(output_path, template_relpath, **template_data): with safe_open(output_path, 'w') as output: Generator(pkgutil.get_data(__name__, template_relpath), **template_data).write(output) apply_template(self.project_filename, self.project_template, project=configured_project) print('\nGenerated ensime project at {}{}'.format(self.gen_project_workdir, os.sep))
def _compile_target(self, target): # "Compiles" a target by forming an isolated chroot of its sources and transitive deps and then # attempting to import each of the target's sources in the case of a python library or else the # entry point in the case of a python binary. # # For a library with sources lib/core.py and lib/util.py a "compiler" main file would look like: # # if __name__ == '__main__': # import lib.core # import lib.util # # For a binary with entry point lib.bin:main the "compiler" main file would look like: # # if __name__ == '__main__': # from lib.bin import main # # In either case the main file is executed within the target chroot to reveal missing BUILD # dependencies. with self.context.new_workunit(name=target.address.spec): modules = [] if isinstance(target, PythonBinary): source = 'entry_point {}'.format(target.entry_point) components = target.entry_point.rsplit(':', 1) module = components[0] if len(components) == 2: function = components[1] data = TemplateData( source=source, import_statement='from {} import {}'.format( module, function)) else: data = TemplateData( source=source, import_statement='import {}'.format(module)) modules.append(data) else: for path in target.sources_relative_to_source_root(): if path.endswith('.py'): if os.path.basename(path) == '__init__.py': module_path = os.path.dirname(path) else: module_path, _ = os.path.splitext(path) source = 'file {}'.format( os.path.join(target.target_base, path)) module = module_path.replace(os.path.sep, '.') data = TemplateData( source=source, import_statement='import {}'.format(module)) modules.append(data) if not modules: # Nothing to eval, so a trivial compile success. return 0 interpreter = self.select_interpreter_for_targets([target]) if isinstance(target, PythonBinary): pexinfo, platforms = target.pexinfo, target.platforms else: pexinfo, platforms = None, None generator = Generator(pkgutil.get_data(__name__, self._EVAL_TEMPLATE_PATH), chroot_parent=self.chroot_cache_dir, modules=modules) executable_file_content = generator.render() with self.cached_chroot( interpreter=interpreter, pex_info=pexinfo, targets=[target], platforms=platforms, executable_file_content=executable_file_content) as chroot: pex = chroot.pex() with self.context.new_workunit( name='eval', labels=[ WorkUnitLabel.COMPILER, WorkUnitLabel.RUN, WorkUnitLabel.TOOL ], cmd=' '.join(pex.cmdline())) as workunit: returncode = pex.run(stdout=workunit.output('stdout'), stderr=workunit.output('stderr')) workunit.set_outcome(WorkUnit.SUCCESS if returncode == 0 else WorkUnit.FAILURE) if returncode != 0: self.context.log.error('Failed to eval {}'.format( target.address.spec)) return returncode
def _generate_exclude_template(exclude): return TemplateData(org=exclude.org, name=exclude.name)
def generate_project(self, project): def linked_folder_id(source_set): return source_set.source_base.replace(os.path.sep, '.') def base_path(source_set): return os.path.join(source_set.root_dir, source_set.source_base, source_set.path) def create_source_base_template(source_set): source_base = base_path(source_set) return SourceBase(id=linked_folder_id(source_set), path=source_base) source_sets = project.sources[:] if project.has_python: source_sets.extend(project.py_sources) source_bases = frozenset(map(create_source_base_template, source_sets)) libs = [] def add_jarlibs(classpath_entries): for classpath_entry in classpath_entries: libs.append((classpath_entry.jar, classpath_entry.source_jar)) add_jarlibs(project.internal_jars) add_jarlibs(project.external_jars) scala_full_version = scala_platform.scala_build_info[ self.context.options['scala-platform']['version']].full_version scala = TemplateData( language_level=scala_full_version, compiler_classpath=project.scala_compiler_classpath) outdir = os.path.abspath(self.ensime_output_dir) if not os.path.exists(outdir): os.makedirs(outdir) java_platform = JvmPlatform.global_instance().default_platform jdk_home = JvmPlatform.preferred_jvm_distribution([java_platform], strict=True).home configured_project = TemplateData( name=self.project_name, java_home=jdk_home, scala=scala, source_bases=source_bases, has_tests=project.has_tests, internal_jars=[cp_entry.jar for cp_entry in project.internal_jars], internal_source_jars=[ cp_entry.source_jar for cp_entry in project.internal_jars if cp_entry.source_jar ], external_jars=[cp_entry.jar for cp_entry in project.external_jars], external_javadoc_jars=[ cp_entry.javadoc_jar for cp_entry in project.external_jars if cp_entry.javadoc_jar ], external_source_jars=[ cp_entry.source_jar for cp_entry in project.external_jars if cp_entry.source_jar ], libs=libs, outdir=os.path.relpath(outdir, get_buildroot()), root_dir=get_buildroot(), cache_dir=os.path.join(self.cwd, '.ensime_cache')) def apply_template(output_path, template_relpath, **template_data): with safe_open(output_path, 'w') as output: Generator(pkgutil.get_data(__name__, template_relpath), **template_data).write(output) apply_template(self.project_filename, self.project_template, project=configured_project) print('\nGenerated ensime project at {}{}'.format( self.gen_project_workdir, os.sep))
def tocl(d): """Generate TOC, in-page links to the IDs we're going to define below""" anchors = sorted(d.keys(), key=_lower) return TemplateData(t='All The Things', e=[a for a in anchors])
def generate_project(self, project): def create_content_root(source_set): root_relative_path = os.path.join(source_set.source_base, source_set.path) \ if source_set.path else source_set.source_base if self.get_options().infer_test_from_siblings: is_test = IdeaGen._sibling_is_test(source_set) else: is_test = source_set.is_test sources = TemplateData( path=root_relative_path, package_prefix=source_set.path.replace('/', '.') if source_set.path else None, is_test=is_test ) return TemplateData( path=root_relative_path, sources=[sources], exclude_paths=[os.path.join(source_set.source_base, x) for x in source_set.excludes], ) content_roots = [create_content_root(source_set) for source_set in project.sources] if project.has_python: content_roots.extend(create_content_root(source_set) for source_set in project.py_sources) scala = None if project.has_scala: scala = TemplateData( language_level=self.scala_language_level, maximum_heap_size=self.scala_maximum_heap_size, fsc=self.fsc, compiler_classpath=project.scala_compiler_classpath ) exclude_folders = [] if self.get_options().exclude_maven_target: exclude_folders += IdeaGen._maven_targets_excludes(get_buildroot()) exclude_folders += self.get_options().exclude_folders configured_module = TemplateData( root_dir=get_buildroot(), path=self.module_filename, content_roots=content_roots, bash=self.bash, python=project.has_python, scala=scala, internal_jars=[cp_entry.jar for cp_entry in project.internal_jars], internal_source_jars=[cp_entry.source_jar for cp_entry in project.internal_jars if cp_entry.source_jar], external_jars=[cp_entry.jar for cp_entry in project.external_jars], external_javadoc_jars=[cp_entry.javadoc_jar for cp_entry in project.external_jars if cp_entry.javadoc_jar], external_source_jars=[cp_entry.source_jar for cp_entry in project.external_jars if cp_entry.source_jar], extra_components=[], exclude_folders=exclude_folders, ) outdir = os.path.abspath(self.intellij_output_dir) if not os.path.exists(outdir): os.makedirs(outdir) configured_project = TemplateData( root_dir=get_buildroot(), outdir=outdir, git_root=Git.detect_worktree(), modules=[ configured_module ], java=TemplateData( encoding=self.java_encoding, maximum_heap_size=self.java_maximum_heap_size, jdk=self.java_jdk, language_level = 'JDK_1_%d' % self.java_language_level ), resource_extensions=list(project.resource_extensions), scala=scala, checkstyle_classpath=';'.join(project.checkstyle_classpath), debug_port=project.debug_port, extra_components=[], ) existing_project_components = None existing_module_components = None if not self.nomerge: # Grab the existing components, which may include customized ones. existing_project_components = self._parse_xml_component_elements(self.project_filename) existing_module_components = self._parse_xml_component_elements(self.module_filename) # Generate (without merging in any extra components). safe_mkdir(os.path.abspath(self.intellij_output_dir)) ipr = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.project_template), project = configured_project)) iml = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.module_template), module = configured_module)) if not self.nomerge: # Get the names of the components we generated, and then delete the # generated files. Clunky, but performance is not an issue, and this # is an easy way to get those component names from the templates. extra_project_components = self._get_components_to_merge(existing_project_components, ipr) extra_module_components = self._get_components_to_merge(existing_module_components, iml) os.remove(ipr) os.remove(iml) # Generate again, with the extra components. ipr = self._generate_to_tempfile(Generator(pkgutil.get_data(__name__, self.project_template), project = configured_project.extend(extra_components = extra_project_components))) iml = self._generate_to_tempfile(Generator(pkgutil.get_data(__name__, self.module_template), module = configured_module.extend(extra_components = extra_module_components))) self.context.log.info('Generated IntelliJ project in {directory}' .format(directory=self.gen_project_workdir)) shutil.move(ipr, self.project_filename) shutil.move(iml, self.module_filename) return self.project_filename if self.open else None
def generate_project(self, project): def is_test(source_set): # Non test targets that otherwise live in test target roots (say a java_library), must # be marked as test for IDEA to correctly link the targets with the test code that uses # them. Therefore we check the base instead of the is_test flag. return source_set.source_base in SourceSet.TEST_BASES def create_content_root(source_set): root_relative_path = os.path.join(source_set.source_base, source_set.path) \ if source_set.path else source_set.source_base sources = TemplateData(path=root_relative_path, package_prefix=source_set.path.replace( '/', '.') if source_set.path else None, is_test=is_test(source_set)) return TemplateData( path=root_relative_path, sources=[sources], exclude_paths=[ os.path.join(source_set.source_base, x) for x in source_set.excludes ], ) content_roots = [ create_content_root(source_set) for source_set in project.sources ] if project.has_python: content_roots.extend( create_content_root(source_set) for source_set in project.py_sources) scala = None if project.has_scala: scala = TemplateData( language_level=self.scala_language_level, maximum_heap_size=self.scala_maximum_heap_size, fsc=self.fsc, compiler_classpath=project.scala_compiler_classpath) configured_module = TemplateData( root_dir=get_buildroot(), path=self.module_filename, content_roots=content_roots, bash=self.bash, python=project.has_python, scala=scala, internal_jars=[cp_entry.jar for cp_entry in project.internal_jars], internal_source_jars=[ cp_entry.source_jar for cp_entry in project.internal_jars if cp_entry.source_jar ], external_jars=[cp_entry.jar for cp_entry in project.external_jars], external_javadoc_jars=[ cp_entry.javadoc_jar for cp_entry in project.external_jars if cp_entry.javadoc_jar ], external_source_jars=[ cp_entry.source_jar for cp_entry in project.external_jars if cp_entry.source_jar ], extra_components=[], ) outdir = os.path.abspath(self.intellij_output_dir) if not os.path.exists(outdir): os.makedirs(outdir) configured_project = TemplateData( root_dir=get_buildroot(), outdir=outdir, modules=[configured_module], java=TemplateData(encoding=self.java_encoding, maximum_heap_size=self.java_maximum_heap_size, jdk=self.java_jdk, language_level='JDK_1_%d' % self.java_language_level), resource_extensions=list(project.resource_extensions), scala=scala, checkstyle_suppression_files=','.join( project.checkstyle_suppression_files), checkstyle_classpath=';'.join(project.checkstyle_classpath), debug_port=project.debug_port, extra_components=[], ) existing_project_components = None existing_module_components = None if not self.nomerge: # Grab the existing components, which may include customized ones. existing_project_components = self._parse_xml_component_elements( self.project_filename) existing_module_components = self._parse_xml_component_elements( self.module_filename) # Generate (without merging in any extra components). safe_mkdir(os.path.abspath(self.intellij_output_dir)) ipr = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.project_template), project=configured_project)) iml = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.module_template), module=configured_module)) if not self.nomerge: # Get the names of the components we generated, and then delete the # generated files. Clunky, but performance is not an issue, and this # is an easy way to get those component names from the templates. extra_project_components = self._get_components_to_merge( existing_project_components, ipr) extra_module_components = self._get_components_to_merge( existing_module_components, iml) os.remove(ipr) os.remove(iml) # Generate again, with the extra components. ipr = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.project_template), project=configured_project.extend( extra_components=extra_project_components))) iml = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.module_template), module=configured_module.extend( extra_components=extra_module_components))) shutil.move(ipr, self.project_filename) shutil.move(iml, self.module_filename) print('\nGenerated project at %s%s' % (self.gen_project_workdir, os.sep)) return self.project_filename if self.open else None
def setUp(self): self.data = TemplateData(foo='bar', baz=42)
def generate_project(self, project): def create_content_root(source_set): root_relative_path = os.path.join(source_set.source_base, source_set.path) \ if source_set.path else source_set.source_base if source_set.resources_only: if source_set.is_test: content_type = 'java-test-resource' else: content_type = 'java-resource' else: content_type = '' sources = TemplateData(path=root_relative_path, package_prefix=source_set.path.replace( '/', '.') if source_set.path else None, is_test=source_set.is_test, content_type=content_type) return TemplateData( path=root_relative_path, sources=[sources], exclude_paths=[ os.path.join(source_set.source_base, x) for x in source_set.excludes ], ) content_roots = [ create_content_root(source_set) for source_set in project.sources ] if project.has_python: content_roots.extend( create_content_root(source_set) for source_set in project.py_sources) java_language_level = None for target in project.targets: if isinstance(target, JvmTarget): if java_language_level is None or java_language_level < target.platform.source_level: java_language_level = target.platform.source_level if java_language_level is not None: java_language_level = 'JDK_{0}_{1}'.format( *java_language_level.components[:2]) outdir = os.path.abspath(self.intellij_output_dir) if not os.path.exists(outdir): os.makedirs(outdir) scm = get_scm() configured_project = TemplateData( root_dir=get_buildroot(), outdir=outdir, git_root=scm.worktree, java=TemplateData(encoding=self.java_encoding, jdk=self.java_jdk, language_level='JDK_1_{}'.format( self.java_language_level)), resource_extensions=list(project.resource_extensions), debug_port=project.debug_port, extra_components=[], java_language_level=java_language_level, ) if not self.context.options.target_specs: raise TaskError("No targets specified.") abs_target_specs = [ os.path.join(get_buildroot(), spec) for spec in self.context.options.target_specs ] configured_workspace = TemplateData( targets=json.dumps(abs_target_specs), project_path=os.path.join(get_buildroot(), abs_target_specs[0].split(':')[0]), idea_plugin_version=IDEA_PLUGIN_VERSION) # Generate (without merging in any extra components). safe_mkdir(os.path.abspath(self.intellij_output_dir)) ipr = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.project_template), project=configured_project)) iws = self._generate_to_tempfile( Generator(pkgutil.get_data(__name__, self.workspace_template), workspace=configured_workspace)) self._outstream.write(self.gen_project_workdir) shutil.move(ipr, self.project_filename) shutil.move(iws, self.workspace_filename) return self.project_filename
def generate_ivy(cls, targets, jars, excludes, ivyxml, confs, resolve_hash_name=None, pinned_artifacts=None): if resolve_hash_name: org = IvyUtils.INTERNAL_ORG_NAME name = resolve_hash_name else: org, name = cls.identify(targets) extra_configurations = [ conf for conf in confs if conf and conf != 'default' ] jars_by_key = OrderedDict() for jar in jars: jars = jars_by_key.setdefault((jar.org, jar.name), []) jars.append(jar) manager = JarDependencyManagement.global_instance() artifact_set = PinnedJarArtifactSet( pinned_artifacts) # Copy, because we're modifying it. for jars in jars_by_key.values(): for i, dep in enumerate(jars): direct_coord = M2Coordinate.create(dep) managed_coord = artifact_set[direct_coord] if direct_coord.rev != managed_coord.rev: # It may be necessary to actually change the version number of the jar we want to resolve # here, because overrides do not apply directly (they are exclusively transitive). This is # actually a good thing, because it gives us more control over what happens. coord = manager.resolve_version_conflict(managed_coord, direct_coord, force=dep.force) dep = copy.copy(dep) dep.rev = coord.rev jars[i] = dep elif dep.force: # If this dependency is marked as 'force' and there is no version conflict, use the normal # pants behavior for 'force'. artifact_set.put(direct_coord) dependencies = [ cls._generate_jar_template(jars) for jars in jars_by_key.values() ] # As it turns out force is not transitive - it only works for dependencies pants knows about # directly (declared in BUILD files - present in generated ivy.xml). The user-level ivy docs # don't make this clear [1], but the source code docs do (see isForce docs) [2]. I was able to # edit the generated ivy.xml and use the override feature [3] though and that does work # transitively as you'd hope. # # [1] http://ant.apache.org/ivy/history/2.3.0/settings/conflict-managers.html # [2] https://svn.apache.org/repos/asf/ant/ivy/core/branches/2.3.0/ # src/java/org/apache/ivy/core/module/descriptor/DependencyDescriptor.java # [3] http://ant.apache.org/ivy/history/2.3.0/ivyfile/override.html overrides = [ cls._generate_override_template(coord) for coord in artifact_set ] excludes = [ cls._generate_exclude_template(exclude) for exclude in excludes ] template_data = TemplateData(org=org, module=name, extra_configurations=extra_configurations, dependencies=dependencies, excludes=excludes, overrides=overrides) template_relpath = os.path.join('templates', 'ivy_utils', 'ivy.mustache') template_text = pkgutil.get_data(__name__, template_relpath) generator = Generator(template_text, lib=template_data) with safe_open(ivyxml, 'w') as output: generator.write(output)
def generate_pom(self, tgt, version, path): closure = OrderedSet([t for t in tgt.closure() if t is not tgt]) # Remove all transitive deps of Pom dependencies and then add back the pom_dep itself. pom_deps = [t for t in closure if isinstance(t, PomTarget)] for pom in pom_deps: closure -= pom.closure() closure.add(pom) dependencies = OrderedDict() for dep in closure: if isinstance(dep, PomTarget): dep_jar = TemplateData( artifact_id=dep.payload.provides.name, group_id=dep.payload.provides.org, version=version, scope='compile', ) key = (dep.payload.provides.org, dep.payload.provides.name) dependencies[key] = dep_jar elif isinstance(dep, Resources): pass elif isinstance(dep, JarLibrary): for jar in dep.jar_dependencies: dep_jar = TemplateData( artifact_id=jar.name, group_id=jar.org, version=jar.rev, scope='compile', ) key = (jar.org, jar.name, jar.classifier) dependencies[key] = dep_jar else: pass # TODO(mateo): This needs to be configurable - preferably as a dependency or at least an option. # We are now using it for internal libs - so this confusing and should be fixed soon-ish. target_jar = TemplateData( artifact_id=tgt.payload.provides.name, group_id=tgt.payload.provides.org, version=version, scope='compile', dependencies=dependencies.values(), # TODO(dan): These should really come from an OSSRHPublicationMetadata # instance, but it might have to be made a Target first so we don't # duplicate it for every PomTarget. name='fsq.io', description='Foursquare Opensource', url='http://github.com/foursquare/fsqio', licenses=[ TemplateData( name='Apache', url='http://www.opensource.org/licenses/Apache-2.0', ) ], scm=TemplateData( url='[email protected]:foursquare/spindle.git', # TODO(dan): Are these the right values? connection='scm:git:[email protected]:foursquare/fsqio.git', developer_connection= 'scm:git:[email protected]:foursquare/fsqio.git', ), developers=[ TemplateData( id='paperstreet', name='Daniel Harrison', url='https://github.com/paperstreet', ), TemplateData( id='mateor', name='Mateo Rodriguez', url='https://github.com/mateor', ), ], ) template_relpath = os.path.join(_TEMPLATES_RELPATH, 'pom.mustache') template_text = pkgutil.get_data(__name__, template_relpath) generator = Generator(template_text, project=target_jar) with safe_open(path, 'wb') as output: generator.write(output)
def create_source_template(base_id, includes=None, excludes=None): return TemplateData( base=base_id, includes='|'.join(OrderedSet(includes)) if includes else None, excludes='|'.join(OrderedSet(excludes)) if excludes else None, )
def test_extend(self): self.assertEqual(self.data.extend(jake=0.3), TemplateData(baz=42, foo="bar", jake=0.3))
def create_exclude(exclude): return TemplateData(org=exclude.org, name=exclude.name)
def test_equals(self): self.assertEqual(self.data, TemplateData(baz=42).extend(foo="bar"))
def _data(self, target_type, deps=None, rev=None, pkgs=None): parameters = TemplateData(deps=deps, rev=rev, pkgs=pkgs) if (deps or rev or pkgs) else None return TemplateData(type=target_type, parameters=parameters)
def setUp(self): self.data = TemplateData(foo="bar", baz=42)
def _generate_override_template(jar): return TemplateData(org=jar.org, module=jar.module, version=jar.version)
def _generate_jar_template(cls, jars): Dependency = namedtuple( 'DependencyAttributes', ['org', 'name', 'rev', 'mutable', 'force', 'transitive']) global_dep_attributes = set( Dependency(org=jar.org, name=jar.name, rev=jar.rev, mutable=jar.mutable, force=jar.force, transitive=jar.transitive) for jar in jars) if len(global_dep_attributes) != 1: # TODO(John Sirois): Need to provide information about where these came from - could be # far-flung JarLibrary targets. The jars here were collected from targets via # `calculate_classpath` above and so merging of the 2 could provide the context needed. # See: https://github.com/pantsbuild/pants/issues/2239 conflicting_dependencies = sorted( str(g) for g in global_dep_attributes) raise cls.IvyResolveConflictingDepsError( 'Found conflicting dependencies:\n\t{}'.format( '\n\t'.join(conflicting_dependencies))) jar_attributes = global_dep_attributes.pop() excludes = set() for jar in jars: excludes.update(jar.excludes) any_have_url = False Artifact = namedtuple('Artifact', ['name', 'type_', 'ext', 'url', 'classifier']) artifacts = OrderedDict() for jar in jars: ext = jar.ext url = jar.url if url: any_have_url = True classifier = jar.classifier artifact = Artifact(name=jar.name, type_=ext or 'jar', ext=ext, url=url, classifier=classifier) artifacts[(ext, url, classifier)] = artifact if len(artifacts) == 1: # If the only artifact has no attributes that we need a nested <artifact/> for, just emit # a <dependency/>. artifacts.pop((None, None, None), None) template = TemplateData(org=jar_attributes.org, module=jar_attributes.name, version=jar_attributes.rev, mutable=jar_attributes.mutable, force=jar_attributes.force, transitive=jar_attributes.transitive, artifacts=artifacts.values(), any_have_url=any_have_url, excludes=[ cls._generate_exclude_template(exclude) for exclude in excludes ]) return template