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 __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 __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 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 _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): 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 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