def _gen_goals_reference(self):
"""Generate the goals reference rst doc."""
phase_dict = {}
phase_names = []
for phase, raw_goals in Phase.all():
goals = []
for g in raw_goals:
# TODO(lahosken) generalize indent_docstring, use here
doc = (g.task_type.__doc__ or "").replace("\n", " ").strip()
goals.append(TemplateData(name=g.task_type.__name__, doc=doc))
phase_dict[phase.name] = TemplateData(phase=phase, goals=goals)
phase_names.append(phase.name)
phases = [
phase_dict[name] for name in sorted(phase_names, key=str.lower)
]
template = resource_string(
__name__,
os.path.join(self._templates_dir, 'goals_reference.mustache'))
filename = os.path.join(self._outdir, 'goals_reference.rst')
self.context.log.info('Generating %s' % filename)
with safe_open(filename, 'w') as outfile:
generator = Generator(template, phases=phases)
generator.write(outfile)
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
return TemplateData(
path = root_relative_path,
sources = [ TemplateData(
path = root_relative_path,
package_prefix = source_set.path.replace('/', '.') if source_set.path else None,
is_test = source_set.is_test,
) ],
exclude_paths = [ os.path.join(source_set.source_base, x) for x in source_set.excludes ],
)
def jardep(self, jar):
return TemplateData(
org=jar.org,
name=jar.name,
rev=jar.rev,
scope='compile',
excludes=[self.create_exclude(exclude) for exclude in jar.excludes if exclude.name])
def _create_template_data(self):
jar_dependency, id, exported = self._get_artifact_info()
if self.excludes:
exclude_template_datas = [
exclude._create_template_data() for exclude in self.excludes
]
else:
exclude_template_datas = None
return TemplateData(
id=id,
name=self.name,
template_base=self.target_base,
exported=exported,
org=jar_dependency.org,
module=jar_dependency.name,
version=jar_dependency.rev,
sources=self.sources,
dependencies=[
dep._create_template_data() for dep in self.jar_dependencies
],
excludes=exclude_template_datas,
buildflags=self.buildflags,
)
def _create_template_data(self):
return TemplateData(
name = self.name,
template_base = self.target_base,
sources = self.sources,
resources = self.resources,
dependencies = self.dependencies
)
def create_source_template(base, includes=None, excludes=None):
return TemplateData(
base=source_bases[base],
includes=includes or [],
excludes=excludes or [],
joined_includes='|'.join(includes) if includes else '',
joined_excludes='|'.join(excludes) if excludes else '',
)
def jardep(self, jar, classifier=None):
return TemplateData(
org=jar.org,
name=jar.name + ('-only' if classifier == 'idl' else ''),
rev=jar.rev,
scope='runtime' if classifier == 'idl' else 'compile',
classifier=classifier,
excludes=[self.create_exclude(exclude) for exclude in jar.excludes if exclude.name]
)
def add_jarlibs(classpath_entries):
for classpath_entry in classpath_entries:
jar = classpath_entry.jar
source_jar = classpath_entry.source_jar
libs.append(
TemplateData(
jar=os.path.relpath(jar, self.cwd),
source_jar=os.path.relpath(source_jar, self.cwd)
if source_jar else None))
def entry(nom,
classdoc=None,
msg_rst=None,
argspec=None,
funcdoc=None,
methods=None):
"""Create a struct that our template expects to see.
:param nom: Symbol name, e.g. python_binary
:param classdoc: plain text appears above argspec
:param msg_rst: reST. useful in hand-crafted entries
:param argspec: arg string like (x, y="deflt")
:param funcdoc: function's __doc__, plain text
:param methods: list of entries for class' methods
"""
def indent_docstring_by_1(s):
"""Given a non-empty docstring, return a version indented by a space.
Given an empty thing, return the thing itself
"""
# In reST, it's useful to have strings that are similarly-indented.
# If we have a classdoc indented by 2 next to an __init__ funcdoc indented
# by 4, reST doesn't format things nicely. Oh, totally-dedenting doesn't
# format nicely either.
# Docstring indentation: more gnarly than you'd think:
# http://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
if not s: return s
# Convert tabs to spaces (following the normal Python rules)
# and split into a list of lines:
lines = s.expandtabs().splitlines()
# Determine minimum indentation (first line doesn't count):
indent = 999
for line in lines[1:]:
stripped = line.lstrip()
if stripped:
indent = min(indent, len(line) - len(stripped))
# Remove indentation (first line is special):
trimmed = [lines[0].strip()]
if indent < 999:
for line in lines[1:]:
trimmed.append(line[indent:].rstrip())
# Strip off trailing and leading blank lines:
while trimmed and not trimmed[-1]:
trimmed.pop()
while trimmed and not trimmed[0]:
trimmed.pop(0)
# Return a single string:
return '\n'.join([" " + t for t in trimmed])
return TemplateData(nom=nom.strip(),
classdoc=indent_docstring_by_1(classdoc),
msg_rst=indent_docstring_by_1(msg_rst),
argspec=argspec,
funcdoc=indent_docstring_by_1(funcdoc),
methods=methods,
showmethods=(methods and len(methods) > 0))
def _create_template_data(self):
return TemplateData(
org=self.org,
module=self.name,
version=self.rev,
excludes=self.excludes,
transitive=self.transitive,
ext=self.ext,
url=self.url,
configurations=';'.join(self._configurations),
)
def _jardep(self, jar, transitive=True, configurations='default'):
return TemplateData(
org=jar.org,
module=jar.name,
version=jar.rev,
mutable=False,
force=jar.force,
excludes=[self.create_exclude(exclude) for exclude in jar.excludes],
transitive=transitive,
artifacts=jar.artifacts,
configurations=configurations)
def _create_template_data(self):
return TemplateData(
org=self.org,
module=self.name,
version=self.rev,
force=self.force,
excludes=self.excludes,
transitive=self.transitive,
artifacts=self.artifacts,
configurations=';'.join(self._configurations),
)
def generate_ivysettings(self, publishedjars, publish_local=None):
template_relpath = os.path.join('templates', 'jar_publish', 'ivysettings.mustache')
template = pkgutil.get_data(__name__, template_relpath)
with safe_open(os.path.join(self.outdir, 'ivysettings.xml'), 'w') as wrapper:
generator = Generator(template,
ivysettings=self.ivysettings,
dir=self.outdir,
cachedir=self.cachedir,
published=[TemplateData(org=jar.org, name=jar.name)
for jar in publishedjars],
publish_local=publish_local)
generator.write(wrapper)
return wrapper.name
def _jardep(self, jar, transitive=True, configurations='default', classifier=None):
return TemplateData(
org=jar.org,
module=jar.name + ('-only' if classifier == 'idl' else ''),
version=jar.rev,
mutable=False,
force=jar.force,
excludes=[self.create_exclude(exclude) for exclude in jar.excludes],
transitive=transitive,
artifacts=jar.artifacts,
is_idl=(classifier == 'idl'),
configurations=configurations,
)
def create_sourcepath(base, sources):
def normalize_path_pattern(path):
return '%s/' % path if not path.endswith('/') else path
includes = [ normalize_path_pattern(source_set.path) for source_set in sources ]
excludes = []
for source_set in sources:
excludes.extend(normalize_path_pattern(exclude) for exclude in source_set.excludes)
return TemplateData(
base = base,
includes = includes,
excludes = excludes,
)
def tags_tocl(d, tag_list, title):
"""Generate specialized TOC.
E.g., tags_tocl(d, ["python", "anylang"], "Python")
tag_list: if an entry's tags contains any of these, use it
title: pretty title
"""
filtered_anchors = []
for anc in sorted(d.keys(), key=str.lower):
entry = d[anc]
if not "tags" in entry: continue
found = [t for t in tag_list if t in entry["tags"]]
if not found: continue
filtered_anchors.append(anc)
return TemplateData(t=title, e=filtered_anchors)
def _generate_jar_template(self, jar):
template=TemplateData(
org=jar.org,
module=jar.name,
version=jar.rev,
mutable=self._is_mutable(jar),
force=jar.force,
excludes=[self._generate_exclude_template(exclude) for exclude in jar.excludes],
transitive=jar.transitive,
artifacts=jar.artifacts,
is_idl='idl' in jar._configurations,
configurations=';'.join(jar._configurations),
)
override = self._overrides.get((jar.org, jar.name))
return override(template) if override else template
def _generate_jar_template(self, jar):
template = TemplateData(
org=jar.org,
module=jar.name,
version=jar.rev,
force=jar.force,
excludes=[
self._generate_exclude_template(exclude)
for exclude in jar.excludes
],
transitive=jar.transitive,
ext=jar.ext,
url=jar.url,
configurations=';'.join(jar._configurations),
)
override = self._overrides.get((jar.org, jar.name))
return override(template) if override else template
def _generate_ivy(self, jars, excludes, ivyxml):
org, name = self._ivy_utils.identify()
template_data = TemplateData(
org=org,
module=name,
version='latest.integration',
publications=None,
is_idl=False,
dependencies=[self._generate_jar_template(jar) for jar in jars],
excludes=[self._generate_exclude_template(exclude) for exclude in excludes]
)
safe_mkdir(os.path.dirname(ivyxml))
with open(ivyxml, 'w') as output:
generator = Generator(pkgutil.get_data(__name__, self._template_path),
root_dir = get_buildroot(),
lib = template_data)
generator.write(output)
def _jardep(self,
jar,
transitive=True,
ext=None,
url=None,
configurations='default'):
return TemplateData(
org=jar.org,
module=jar.name,
version=jar.rev,
force=jar.force,
excludes=[
self.create_exclude(exclude) for exclude in jar.excludes
],
transitive=transitive,
ext=ext,
url=url,
configurations=configurations,
)
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 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.work_dir, os.sep))
return self.project_filename if self.open else None
def _generate_project_files(self, project, ivyfile, ivysettingsfile):
def create_content_root(source_set):
root_relative_path = os.path.join(source_set.source_base,
source_set.path)
return TemplateData(
path=root_relative_path,
sources=[
TemplateData(
path=root_relative_path,
package_prefix=source_set.path.replace('/', '.'),
is_test=source_set.is_test,
)
],
exclude_paths=[
os.path.join(source_set.source_base, x)
for x in source_set.excludes
],
)
configured_module = TemplateData(
root_dir=self.root_dir,
path=self.module_filename,
content_roots=[
create_content_root(source_set)
for source_set in project.sources
],
has_bash=self.options.bash,
has_python=project.has_python,
has_scala=project.has_scala,
has_tests=project.has_tests,
has_ivy=True,
ivyfile=ivyfile,
ivysettingsfile=ivysettingsfile,
extra_components=[],
)
outdir = os.path.abspath(self.options.intellij_output_dir)
if not os.path.exists(outdir):
os.makedirs(outdir)
configured_project = TemplateData(
root_dir=self.root_dir,
outdir=outdir,
modules=[configured_module],
java_encoding=self.options.java_encoding,
resource_extensions=self._get_resource_extensions(project),
has_scala=project.has_scala,
scala=TemplateData(
fsc=self.options.fsc) if project.has_scala else None,
extra_checkstyle_suppression_files=project.
extra_checkstyle_suppression_files,
extra_components=[],
)
if not self.options.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).
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.options.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)
def _create_template_data(self):
return TemplateData(
org=self.org,
name=self.name,
)
def create_exclude(self, exclude):
return TemplateData(org=exclude.org, name=exclude.name)
def tocl(d):
"""Generate TOC, in-page links to the IDs we're going to define below"""
anchors = sorted(d.keys(), key=str.lower)
return TemplateData(t="All The Things", e=[a for a in anchors])
def test_equals(self):
self.assertEqual(self.data, TemplateData(baz=42).extend(foo='bar'))
def test_extend(self):
self.assertEqual(self.data.extend(jake=0.3),
TemplateData(baz=42, foo='bar', jake=0.3))
def _generate_exclude_template(self, exclude):
return TemplateData(org=exclude.org, name=exclude.name)
def setUp(self):
self.data = TemplateData(foo='bar', baz=42)
