def parse_address():
if spec.startswith(':'):
# the :[target] could be in a sibling BUILD - so parse using the canonical address
pathish = "%s:%s" % (parse_context.buildfile.canonical_relpath, spec[1:])
return Address.parse(parse_context.buildfile.root_dir, pathish, False)
else:
return Address.parse(parse_context.buildfile.root_dir, spec, False)
def test_top_level(self):
with self.workspace('BUILD') as root_dir:
self.assertAddress(root_dir, 'BUILD', 'c', Address.parse(root_dir, ':c'))
self.assertAddress(root_dir, 'BUILD', 'c', Address.parse(root_dir, '.:c'))
self.assertAddress(root_dir, 'BUILD', 'c', Address.parse(root_dir, './:c'))
self.assertAddress(root_dir, 'BUILD', 'c', Address.parse(root_dir, './BUILD:c'))
self.assertAddress(root_dir, 'BUILD', 'c', Address.parse(root_dir, 'BUILD:c'))
def test_sibling_references(self):
with temporary_dir() as root_dir:
buildfile = create_buildfile(root_dir, 'a', name='BUILD',
content=dedent("""
dependencies(name='util',
dependencies=[
jar(org='com.twitter', name='util', rev='0.0.1')
]
)
""").strip()
)
sibling = create_buildfile(root_dir, 'a', name='BUILD.sibling',
content=dedent("""
dependencies(name='util-ex',
dependencies=[
pants(':util'),
jar(org='com.twitter', name='util-ex', rev='0.0.1')
]
)
""").strip()
)
ParseContext(buildfile).parse()
utilex = Target.get(Address.parse(root_dir, 'a:util-ex', is_relative=False))
utilex_deps = set(utilex.resolve())
util = Target.get(Address.parse(root_dir, 'a:util', is_relative=False))
util_deps = set(util.resolve())
self.assertEquals(util_deps, util_deps.intersection(utilex_deps))
def test_sibling_references(self):
with temporary_dir() as root_dir:
buildfile = create_buildfile(root_dir,
'a',
name='BUILD',
content=dedent('''
dependencies(name='util',
dependencies=[
jar(org='com.twitter', name='util', rev='0.0.1')
]
)
''').strip())
sibling = create_buildfile(root_dir,
'a',
name='BUILD.sibling',
content=dedent('''
dependencies(name='util-ex',
dependencies=[
pants(':util'),
jar(org='com.twitter', name='util-ex', rev='0.0.1')
]
)
''').strip())
ParseContext(buildfile).parse()
utilex = Target.get(
Address.parse(root_dir, 'a:util-ex', is_relative=False))
utilex_deps = set(utilex.resolve())
util = Target.get(
Address.parse(root_dir, 'a:util', is_relative=False))
util_deps = set(util.resolve())
self.assertEquals(util_deps, util_deps.intersection(utilex_deps))
def test_parse_from_root_dir(self):
with self.workspace('a/b/c/BUILD') as root_dir:
self.assertAddress(
root_dir, 'a/b/c/BUILD', 'c',
Address.parse(root_dir, 'a/b/c', is_relative=False))
self.assertAddress(
root_dir, 'a/b/c/BUILD', 'c',
Address.parse(root_dir, 'a/b/c', is_relative=True))
def test_parse_from_sub_dir(self):
with self.workspace('a/b/c/BUILD') as root_dir:
with pushd(os.path.join(root_dir, 'a')):
self.assertAddress(root_dir, 'a/b/c/BUILD', 'c',
Address.parse(root_dir, 'b/c', is_relative=True))
with pytest.raises(IOError):
Address.parse(root_dir, 'b/c', is_relative=False)
def test_default_form(self):
with self.workspace('a/BUILD') as root_dir:
self.assertAddress(root_dir, 'a/BUILD', 'a',
Address.parse(root_dir, 'a'))
self.assertAddress(root_dir, 'a/BUILD', 'a',
Address.parse(root_dir, 'a/BUILD'))
self.assertAddress(root_dir, 'a/BUILD', 'a',
Address.parse(root_dir, 'a/BUILD/'))
def test_parse_from_sub_dir(self):
with self.workspace('a/b/c/BUILD') as root_dir:
with pushd(os.path.join(root_dir, 'a')):
self.assertAddress(
root_dir, 'a/b/c/BUILD', 'c',
Address.parse(root_dir, 'b/c', is_relative=True))
with pytest.raises(IOError):
Address.parse(root_dir, 'b/c', is_relative=False)
def test_full_forms(self):
with self.workspace('a/BUILD') as root_dir:
self.assertAddress(root_dir, 'a/BUILD', 'b',
Address.parse(root_dir, 'a:b'))
self.assertAddress(root_dir, 'a/BUILD', 'b',
Address.parse(root_dir, 'a/:b'))
self.assertAddress(root_dir, 'a/BUILD', 'b',
Address.parse(root_dir, 'a/BUILD:b'))
self.assertAddress(root_dir, 'a/BUILD', 'b',
Address.parse(root_dir, 'a/BUILD/:b'))
def parse_address():
if spec.startswith(':'):
# the :[target] could be in a sibling BUILD - so parse using the canonical address
pathish = "%s:%s" % (parse_context.buildfile.canonical_relpath,
spec[1:])
return Address.parse(parse_context.buildfile.root_dir, pathish,
False)
else:
return Address.parse(parse_context.buildfile.root_dir, spec,
False)
def test_top_level(self):
with self.workspace('BUILD') as root_dir:
self.assertAddress(root_dir, 'BUILD', 'c',
Address.parse(root_dir, ':c'))
self.assertAddress(root_dir, 'BUILD', 'c',
Address.parse(root_dir, '.:c'))
self.assertAddress(root_dir, 'BUILD', 'c',
Address.parse(root_dir, './:c'))
self.assertAddress(root_dir, 'BUILD', 'c',
Address.parse(root_dir, './BUILD:c'))
self.assertAddress(root_dir, 'BUILD', 'c',
Address.parse(root_dir, 'BUILD:c'))
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
targets = []
# TODO(wickman) Ignore the -- crap
for k in range(len(self.args)):
arg = self.args[0]
if arg == '--':
self.args.pop(0)
break
try:
address = Address.parse(root_dir, arg)
target = Target.get(address)
except Exception as e:
break
if not target:
break
targets.append(target)
self.args.pop(0)
# stop at PythonBinary target
if isinstance(target, PythonBinary):
break
self.target = targets.pop(0) if targets else None
self.extra_targets = targets
if self.target is None:
self.error('No valid target specified!')
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
specs_end = self.args.index('--')
if len(self.args) > specs_end:
self.build_args = self.args[specs_end+1:len(self.args)+1]
else:
self.build_args = []
except ValueError:
specs_end = 1
self.build_args = self.args[1:] if len(self.args) > 1 else []
self.targets = OrderedSet()
for spec in self.args[0:specs_end]:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))
if not target:
self.error("Target %s does not exist" % address)
self.targets.update(tgt for tgt in target.resolve() if is_concrete(tgt))
def parse_jarcoordinate(coordinate):
components = coordinate.split('#', 1)
if len(components) == 2:
org, name = components
return org, name
else:
try:
address = Address.parse(get_buildroot(), coordinate)
try:
target = Target.get(address)
if not target:
siblings = Target.get_all_addresses(
address.buildfile)
prompt = 'did you mean' if len(
siblings
) == 1 else 'maybe you meant one of these'
raise TaskError('%s => %s?:\n %s' %
(address, prompt, '\n '.join(
str(a) for a in siblings)))
if not is_exported(target):
raise TaskError('%s is not an exported target' %
coordinate)
return target.provides.org, target.provides.name
except (ImportError, SyntaxError, TypeError):
raise TaskError('Failed to parse %s' %
address.buildfile.relpath)
except IOError:
raise TaskError('No BUILD file could be found at %s' %
coordinate)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
specs_end = self.args.index('--')
if len(self.args) > specs_end:
self.build_args = self.args[specs_end+1:len(self.args)+1]
else:
self.build_args = []
except ValueError:
specs_end = 1
self.build_args = self.args[1:] if len(self.args) > 1 else []
self.targets = OrderedSet()
for spec in self.args[0:specs_end]:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
raise
try:
target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))
raise
if not target:
self.error("Target %s does not exist" % address)
self.targets.add(target)
def _parse_targets(self, targets, root_dir):
for spec in self.args:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing target %s: %s" % (address, traceback.format_exc()))
if address.is_meta:
print("target is meta")
target = target.do_in_context(lambda: bang.extract_target([target], None))
if not IvyResolve._is_resolvable(target):
self.error("Target: %s is not resolvable" % address)
targets.add(target)
if not self.intransitive:
def add_targets(ttarget):
if hasattr(ttarget, 'internal_dependencies'):
for dep in ttarget.internal_dependencies:
if IvyResolve._is_resolvable(dep):
targets.add(dep)
else:
print("skipping %s as it's not ivy resolvable" % dep.name)
target.walk(add_targets)
return targets
def _parse_targets(self, targets, root_dir):
for spec in self.args:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing target %s: %s" % (address, traceback.format_exc()))
if address.is_meta:
print("target is meta")
target = target.do_in_context(lambda: bang.extract_target([target], None))
if not IvyResolve._is_resolvable(target):
self.error("Target: %s is not resolvable" % address)
targets.add(target)
if not self.intransitive:
def add_targets(ttarget):
if hasattr(ttarget, 'internal_dependencies'):
for dep in ttarget.internal_dependencies:
if IvyResolve._is_resolvable(dep):
targets.add(dep)
else:
print("skipping %s as it's not ivy resolvable" % dep.name)
target.walk(add_targets)
return targets
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
targets = []
for k in range(len(self.args)):
arg = self.args[0]
if arg == '--':
self.args.pop(0)
break
try:
address = Address.parse(root_dir, arg)
target = Target.get(address)
except Exception as e:
break
if not target:
break
targets.append(target)
self.args.pop(0)
# stop at PythonBinary target
if isinstance(target, PythonBinary):
break
self.target = targets.pop(0) if targets else None
self.extra_targets = targets
if self.target is None:
self.error('No valid target specified!')
def _synthesize_command(root_dir, args):
command = args[0]
if command in Command.all_commands():
subcommand_args = args[1:] if len(args) > 1 else []
return command, _add_default_options(command, subcommand_args)
if command.startswith('-'):
_exit_and_fail('Invalid command: %s' % command)
# assume 'build' if a command was omitted.
try:
Address.parse(root_dir, command)
return _BUILD_COMMAND, _add_default_options(_BUILD_COMMAND, args)
except:
_exit_and_fail('Failed to execute pants build: %s' % traceback.format_exc())
def _synthesize_command(root_dir, args):
command = args[0]
if command in Command.all_commands():
subcommand_args = args[1:] if len(args) > 1 else []
return command, _add_default_options(command, subcommand_args)
if command.startswith('-'):
_exit_and_fail('Invalid command: %s' % command)
# assume 'build' if a command was omitted.
try:
Address.parse(root_dir, command)
return _BUILD_COMMAND, _add_default_options(_BUILD_COMMAND, args)
except:
_exit_and_fail('Failed to execute pants build: %s' %
traceback.format_exc())
def target(cls, address):
"""Resolves the given target address to a Target object.
address: The BUILD target address to resolve.
Returns the corresponding Target or else None if the address does not point to a defined Target.
"""
return Target.get(Address.parse(cls.build_root, address, is_relative=False))
def __init__(self, run_tracker, root_dir, parser, argv):
Command.__init__(self, run_tracker, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
self.target = None
self.extra_targets = []
# We parse each arg in the context of the cli usage:
# ./pants command (options) [spec] (build args)
# ./pants command (options) [spec]... -- (build args)
# Our command token and our options are parsed out so we see args of the form:
# [spec] (build args)
# [spec]... -- (build args)
for k in range(len(self.args)):
arg = self.args.pop(0)
if arg == '--':
break
target = None
try:
address = Address.parse(root_dir, arg)
target = Target.get(address)
except Exception:
pass
if not target:
# We failed to parse the arg as a target or else it was in valid address format but did not
# correspond to a real target. Assume this is the 1st of the build args and terminate
# processing args for target addresses.
break
binaries = []
concrete_targets = [t for t in target.resolve() if t.is_concrete]
for resolved in concrete_targets:
if isinstance(resolved, PythonBinary):
binaries.append(resolved)
else:
self.extra_targets.append(resolved)
if not binaries:
# No binary encountered yet so move on to the next spec to find one or else accumulate more
# libraries for ./pants py -> interpreter mode.
pass
elif len(binaries) == 1:
# We found a binary and are done, the rest of the args get passed to it
self.target = binaries[0]
break
else:
self.error('Can only process 1 binary target, %s contains %d:\n\t%s' % (
arg, len(binaries), '\n\t'.join(str(binary.address) for binary in binaries)
))
if self.target is None:
if not self.extra_targets:
self.error('No valid target specified!')
self.target = self.extra_targets.pop(0)
def __init__(self, run_tracker, root_dir, parser, argv):
Command.__init__(self, run_tracker, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
self.target = None
self.extra_targets = []
# We parse each arg in the context of the cli usage:
# ./pants command (options) [spec] (build args)
# ./pants command (options) [spec]... -- (build args)
# Our command token and our options are parsed out so we see args of the form:
# [spec] (build args)
# [spec]... -- (build args)
for k in range(len(self.args)):
arg = self.args.pop(0)
if arg == '--':
break
target = None
try:
address = Address.parse(root_dir, arg)
target = Target.get(address)
except Exception:
pass
if not target:
# We failed to parse the arg as a target or else it was in valid address format but did not
# correspond to a real target. Assume this is the 1st of the build args and terminate
# processing args for target addresses.
break
binaries = []
for resolved in filter(is_concrete, target.resolve()):
if isinstance(resolved, PythonBinary):
binaries.append(resolved)
else:
self.extra_targets.append(resolved)
if not binaries:
# No binary encountered yet so move on to the next spec to find one or else accumulate more
# libraries for ./pants py -> interpreter mode.
pass
elif len(binaries) == 1:
# We found a binary and are done, the rest of the args get passed to it
self.target = binaries[0]
break
else:
self.error(
'Can only process 1 binary target, %s contains %d:\n\t%s' %
(arg, len(binaries), '\n\t'.join(
str(binary.address) for binary in binaries)))
if self.target is None:
if not self.extra_targets:
self.error('No valid target specified!')
self.target = self.extra_targets.pop(0)
def target(cls, address):
"""Resolves the given target address to a Target object.
address: The BUILD target address to resolve.
Returns the corresponding Target or else None if the address does not point to a defined Target.
"""
return Target.get(
Address.parse(cls.build_root, address, is_relative=False))
def get_pytest_eggs(root):
specs = ["3rdparty/python:pytest", "3rdparty/python:py"]
eggs = []
for spec in specs:
address = Address.parse(root, spec)
target = Target.get(address)
for dep in target.dependencies:
for egg in dep.eggs:
eggs.append(egg)
return eggs
def parse_url(spec):
match = MarkdownToHtml.PANTS_LINK.match(spec)
if match:
page = Target.get(Address.parse(get_buildroot(), match.group(1)))
if not page:
raise TaskError('Invalid link %s' % match.group(1))
alias, url = url_builder(page, config=get_config(page))
return alias, url
else:
return spec, spec
def parse_url(spec):
match = MarkdownToHtml.PANTS_LINK.match(spec)
if match:
page = Target.get(Address.parse(get_buildroot(), match.group(1)))
if not page:
raise TaskError('Invalid link %s' % match.group(1))
alias, url = url_builder(page, config=get_config(page))
return alias, url
else:
return spec, spec
def _coerce_to_targets(cls, from_str, to_str):
if isinstance(from_str, Compatibility.string):
if not isinstance(to_str, Compatibility.string):
raise TaskError('Finding paths from string %s to non-string %s' % (from_str, str(to_str)))
from_address = Address.parse(get_buildroot(), from_str)
to_address = Address.parse(get_buildroot(), to_str)
from_target = Target.get(from_address)
to_target = Target.get(to_address)
if not from_target:
raise TaskError('Target %s doesn\'t exist' % from_address.reference())
if not to_target:
raise TaskError('Target %s doesn\'t exist' % to_address.reference())
return from_target, to_target
elif isinstance(to_str, Compatibility.string):
raise TaskError('Finding paths from string %s to non-string %s' % (to_str, str(from_str)))
return from_str, to_str
def _coerce_to_targets(cls, from_str, to_str):
if isinstance(from_str, Compatibility.string):
if not isinstance(to_str, Compatibility.string):
raise TaskError('Finding paths from string %s to non-string %s' % (from_str, str(to_str)))
from_address = Address.parse(get_buildroot(), from_str)
to_address = Address.parse(get_buildroot(), to_str)
from_target = Target.get(from_address)
to_target = Target.get(to_address)
if not from_target:
raise TaskError('Target %s doesn\'t exist' % from_address.reference())
if not to_target:
raise TaskError('Target %s doesn\'t exist' % to_address.reference())
return from_target, to_target
elif isinstance(to_str, Compatibility.string):
raise TaskError('Finding paths from string %s to non-string %s' % (to_str, str(from_str)))
return from_str, to_str
def _parse_addresses(self, spec):
if spec.endswith('::'):
dir = self._get_dir(spec[:-len('::')])
for buildfile in BuildFile.scan_buildfiles(self._root_dir, os.path.join(self._root_dir, dir)):
for address in Target.get_all_addresses(buildfile):
yield address
elif spec.endswith(':'):
dir = self._get_dir(spec[:-len(':')])
for address in Target.get_all_addresses(BuildFile(self._root_dir, dir)):
yield address
else:
yield Address.parse(self._root_dir, spec)
def _parse_addresses(self, spec):
if spec.endswith('::'):
dir = self._get_dir(spec[:-len('::')])
for buildfile in BuildFile.scan_buildfiles(self._root_dir, os.path.join(self._root_dir, dir)):
for address in Target.get_all_addresses(buildfile):
yield address
elif spec.endswith(':'):
dir = self._get_dir(spec[:-len(':')])
for address in Target.get_all_addresses(BuildFile(self._root_dir, dir)):
yield address
else:
yield Address.parse(self._root_dir, spec)
def _parse_addresses(self):
addresses = OrderedSet()
for spec in self.args:
try:
if self.options.is_directory_list:
for address in Command.scan_addresses(self.root_dir, spec):
addresses.add(address)
else:
addresses.add(Address.parse(self.root_dir, spec))
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
return addresses
def _parse_buildfiles(self):
buildfiles = OrderedSet()
for spec in self.args:
try:
if self.options.is_directory_list:
for buildfile in BuildFile.scan_buildfiles(self.root_dir, spec):
buildfiles.add(buildfile)
else:
buildfiles.add(Address.parse(self.root_dir, spec).buildfile)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
return buildfiles
def _run_lint(self, target, args):
chroot = PythonChroot(target, self.root_dir, extra_targets=[
Target.get(Address.parse(self.root_dir, '3rdparty/python:pylint'))])
builder = chroot.dump()
builder.info().entry_point = 'pylint.lint'
builder.freeze()
interpreter_args = [
'--rcfile=%s' % os.path.join(self.root_dir, 'build-support', 'pylint', 'pylint.rc')]
interpreter_args.extend(args or [])
sources = OrderedSet([])
target.walk(lambda trg: sources.update(
trg.sources if hasattr(trg, 'sources') and trg.sources is not None else []))
pex = PEX(builder.path())
pex.run(args=interpreter_args + list(sources), with_chroot=True)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
address = Address.parse(root_dir, self.args[0])
target = Target.get(address)
except:
self.error("Invalid target in %s" % self.args[0])
if not target:
self.error("Target %s does not exist" % address)
self.target = target
self.args.pop(0)
def __init__(self, run_tracker, root_dir, parser, argv):
Command.__init__(self, run_tracker, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
address = Address.parse(root_dir, self.args[0])
self.target = Target.get(address)
if self.target is None:
self.error('%s is not a valid target!' % self.args[0])
if not self.target.provides:
self.error('Target must provide an artifact.')
self.dependencies = self.minified_dependencies(self.target)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
address = Address.parse(root_dir, self.args[0])
target = Target.get(address)
except Exception as e:
self.error("Invalid target in %s (%s)" % (self.args[0], str(e)))
if not target:
self.error("Target %s does not exist" % address)
self.target = target
self.args.pop(0)
def __init__(self, run_tracker, root_dir, parser, argv):
Command.__init__(self, run_tracker, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
self._config = Config.load()
self._root = root_dir
address = Address.parse(root_dir, self.args[0])
self.target = Target.get(address)
if self.target is None:
self.error('%s is not a valid target!' % self.args[0])
if not self.target.provides:
self.error('Target must provide an artifact.')
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
address = Address.parse(root_dir, self.args[0])
self.target = Target.get(address)
if self.target is None:
self.error('%s is not a valid target!' % self.args[0])
if not self.target.provides:
self.error('Target must provide an artifact.')
self.dependencies = self.minified_dependencies(self.target)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
specs_end = self.args.index('--')
if len(self.args) > specs_end:
self.build_args = self.args.__getslice__(
specs_end + 1,
len(self.args) + 1)
else:
self.build_args = []
except ValueError:
specs_end = 1
self.build_args = self.args[1:] if len(self.args) > 1 else []
self.targets = OrderedSet()
for spec in self.args.__getslice__(0, specs_end):
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" %
(spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" %
(address, traceback.format_exc()))
try:
InternalTarget.check_cycles(target)
except CycleException as e:
self.error("Target contains an internal dependency cycle: %s" %
e)
if not target:
self.error("Target %s does not exist" % address)
if not target.address.is_meta:
target.address.is_meta = self.options.is_meta or address.is_meta
self.targets.add(target)
self.is_ide = self.options.is_ide
self.ide_transitivity = self.options.ide_transitivity
def get_pytest_eggs(root):
specs = ["3rdparty/python:pytest"]
eggs = []
for spec in specs:
address = Address.parse(root, spec)
target = Target.get(address)
def add_eggs(target):
deps = []
for dep in target.dependencies:
if isinstance(dep, PythonEgg):
for egg in dep.eggs:
eggs.append(egg)
else:
deps.append(dep)
return deps
target.walk(lambda t: add_eggs(t))
return eggs
def _run_lint(self, target, args):
lint_target = Target.get(Address.parse(self.root_dir, self._opts['lint_target']))
assert lint_target, 'Could not find target %r' % self._opts['lint_target']
chroot = PythonChroot(target, self.root_dir, extra_targets=[lint_target],
conn_timeout=self._conn_timeout)
chroot.builder.info().ignore_errors = True
builder = chroot.dump()
builder.info().entry_point = self._opts['entry_point']
builder.info().run_name = 'main'
builder.freeze()
interpreter_args = self._opts['interpreter_args']
interpreter_args.extend(args or [])
sources = OrderedSet([])
target.walk(lambda trg: sources.update(
trg.sources if hasattr(trg, 'sources') and trg.sources is not None else []))
pex = PEX(builder.path())
pex.run(args=interpreter_args + list(sources), with_chroot=True)
def __init__(self, run_tracker, root_dir, parser, argv):
Command.__init__(self, run_tracker, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
self.config = Config.load()
self.interpreter_cache = PythonInterpreterCache(self.config, logger=self.debug)
self.interpreter_cache.setup()
interpreters = self.interpreter_cache.select_interpreter(
list(self.interpreter_cache.matches([self.options.interpreter]
if self.options.interpreter else [''])))
if len(interpreters) != 1:
self.error('Unable to detect suitable interpreter.')
else:
self.debug('Selected %s' % interpreters[0])
self.interpreter = interpreters[0]
try:
specs_end = self.args.index('--')
if len(self.args) > specs_end:
self.build_args = self.args[specs_end+1:len(self.args)+1]
else:
self.build_args = []
except ValueError:
specs_end = 1
self.build_args = self.args[1:] if len(self.args) > 1 else []
self.targets = OrderedSet()
for spec in self.args[0:specs_end]:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))
if not target:
self.error("Target %s does not exist" % address)
self.targets.update(tgt for tgt in target.resolve() if tgt.is_concrete)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if len(self.args) is not 1:
self.error("Exactly one BUILD address is required.")
spec = self.args[0]
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
self.target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))
if not self.target:
self.error("Target %s does not exist" % address)
def _parse_targets(self, root_dir):
targets = OrderedSet()
for spec in self.args:
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing target %s: %s" % (address, traceback.format_exc()))
if not Doc._is_documentable(target):
self.error("Target: %s is not documentable" % address)
targets.add(target)
return targets
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if len(self.args) is not 1:
self.error("Exactly one BUILD address is required.")
if self.options.is_internal_only and self.options.is_external_only:
self.error("At most one of external only or internal only can be selected.")
spec = self.args[0]
try:
self.address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
self.is_internal_only = self.options.is_internal_only
self.is_external_only = self.options.is_external_only
self.is_minimal = self.options.is_minimal
self.is_graph = self.options.is_graph
def get_pytest_eggs(root):
specs = ["3rdparty/python:pytest"]
eggs = []
for spec in specs:
address = Address.parse(root, spec)
target = Target.get(address)
def add_eggs(target):
deps = []
for dep in target.dependencies:
if isinstance(dep, PythonEgg):
for egg in dep.eggs:
eggs.append(egg)
else:
deps.append(dep)
return deps
target.walk(lambda t: add_eggs(t))
return eggs
def parse_spec(self, error, spec):
if spec.endswith("::"):
self.add_target_recursive(spec[: -len("::")])
elif spec.endswith(":"):
self.add_target_directory(spec[: -len(":")])
else:
try:
address = Address.parse(get_buildroot(), spec)
ParseContext(address.buildfile).parse()
target = Target.get(address)
if target:
self.targets.append(target)
else:
siblings = Target.get_all_addresses(address.buildfile)
prompt = "did you mean" if len(siblings) == 1 else "maybe you meant one of these"
error("%s => %s?:\n %s" % (address, prompt, "\n ".join(str(a) for a in siblings)))
except (TypeError, ImportError, TaskError, GoalError):
error(spec, include_traceback=True)
except (IOError, SyntaxError):
error(spec)
def _run_lint(self, target, args):
chroot = PythonChroot(
target,
self.root_dir,
extra_targets=[Target.get(Address.parse(self.root_dir, "3rdparty/python:pylint"))],
conn_timeout=self._conn_timeout,
)
chroot.builder.info().ignore_errors = True
builder = chroot.dump()
builder.info().entry_point = "pylint.lint"
builder.freeze()
interpreter_args = ["--rcfile=%s" % os.path.join(self.root_dir, "build-support", "pylint", "pylint.rc")]
interpreter_args.extend(args or [])
sources = OrderedSet([])
target.walk(
lambda trg: sources.update(trg.sources if hasattr(trg, "sources") and trg.sources is not None else [])
)
pex = PEX(builder.path())
pex.run(args=interpreter_args + list(sources), with_chroot=True)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.error("A spec argument is required")
try:
specs_end = self.args.index('--')
if len(self.args) > specs_end:
self.build_args = self.args.__getslice__(specs_end + 1, len(self.args) + 1)
else:
self.build_args = []
except ValueError:
specs_end = 1
self.build_args = self.args[1:] if len(self.args) > 1 else []
self.targets = OrderedSet()
for spec in self.args.__getslice__(0, specs_end):
try:
address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" % (spec, traceback.format_exc()))
try:
target = Target.get(address)
except:
self.error("Problem parsing BUILD target %s: %s" % (address, traceback.format_exc()))
try:
InternalTarget.check_cycles(target)
except CycleException as e:
self.error("Target contains an internal dependency cycle: %s" % e)
if not target:
self.error("Target %s does not exist" % address)
if not target.address.is_meta:
target.address.is_meta = self.options.is_meta or address.is_meta
self.targets.add(target)
self.is_ide = self.options.is_ide
self.ide_transitivity = self.options.ide_transitivity
def parse_spec(self, error, spec):
if spec.endswith('::'):
self.add_target_recursive(spec[:-len('::')])
elif spec.endswith(':'):
self.add_target_directory(spec[:-len(':')])
else:
try:
address = Address.parse(get_buildroot(), spec)
ParseContext(address.buildfile).parse()
target = Target.get(address)
if target:
self.targets.append(target)
else:
siblings = Target.get_all_addresses(address.buildfile)
prompt = 'did you mean' if len(siblings) == 1 else 'maybe you meant one of these'
error('%s => %s?:\n %s' % (address, prompt,
'\n '.join(str(a) for a in siblings)))
except (TypeError, ImportError, TaskError, GoalError):
error(spec, include_traceback=True)
except (IOError, SyntaxError):
error(spec)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if len(self.args) is not 1:
self.error("Exactly one BUILD address is required.")
spec = self.args[0]
try:
address = Address.parse(root_dir, spec)
except IOError:
self.error("Problem parsing spec %s: %s" %
(spec, traceback.format_exc()))
try:
self.target = Target.get(address)
except (ImportError, SyntaxError, TypeError):
self.error("Problem parsing BUILD target %s: %s" %
(address, traceback.format_exc()))
if not self.target:
self.error("Target %s does not exist" % address)
def _run_lint(self, target, args):
chroot = PythonChroot(target,
self.root_dir,
extra_targets=[
Target.get(
Address.parse(self.root_dir,
'3rdparty/python:pylint'))
])
builder = chroot.dump()
builder.info().entry_point = 'pylint.lint'
builder.freeze()
interpreter_args = [
'--rcfile=%s' %
os.path.join(self.root_dir, 'build-support', 'pylint', 'pylint.rc')
]
interpreter_args.extend(args or [])
sources = OrderedSet([])
target.walk(lambda trg: sources.update(trg.sources if hasattr(
trg, 'sources') and trg.sources is not None else []))
pex = PEX(builder.path())
pex.run(args=interpreter_args + list(sources), with_chroot=True)
def parse_jarcoordinate(coordinate):
components = coordinate.split('#', 1)
if len(components) == 2:
org, name = components
return org, name
else:
try:
address = Address.parse(get_buildroot(), coordinate)
try:
target = Target.get(address)
if not target:
siblings = Target.get_all_addresses(address.buildfile)
prompt = 'did you mean' if len(siblings) == 1 else 'maybe you meant one of these'
raise TaskError('%s => %s?:\n %s' % (address, prompt,
'\n '.join(str(a) for a in siblings)))
if not is_exported(target):
raise TaskError('%s is not an exported target' % coordinate)
return target.provides.org, target.provides.name
except (ImportError, SyntaxError, TypeError):
raise TaskError('Failed to parse %s' % address.buildfile.relpath)
except IOError:
raise TaskError('No BUILD file could be found at %s' % coordinate)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if len(self.args) is not 1:
self.error("Exactly one BUILD address is required.")
if self.options.is_internal_only and self.options.is_external_only:
self.error(
"At most one of external only or internal only can be selected."
)
spec = self.args[0]
try:
self.address = Address.parse(root_dir, spec)
except:
self.error("Problem parsing spec %s: %s" %
(spec, traceback.format_exc()))
self.is_internal_only = self.options.is_internal_only
self.is_external_only = self.options.is_external_only
self.is_minimal = self.options.is_minimal
self.is_graph = self.options.is_graph
