def setup_parser(cls, option_group, args, mkflag):
NailgunTask.setup_parser(option_group, args, mkflag)
flag = mkflag('override')
option_group.add_option(flag, action='append', dest='ivy_resolve_overrides',
help="""Specifies a jar dependency override in the form:
[org]#[name]=(revision|url)
For example, to specify 2 overrides:
%(flag)s=com.foo#bar=0.1.2 \\
%(flag)s=com.baz#spam=file:///tmp/spam.jar
""" % dict(flag=flag))
report = mkflag("report")
option_group.add_option(report, mkflag("report", negate=True), dest = "ivy_resolve_report",
action="callback", callback=mkflag.set_bool, default=False,
help = "[%default] Generate an ivy resolve html report")
option_group.add_option(mkflag("open"), mkflag("open", negate=True),
dest="ivy_resolve_open", default=False,
action="callback", callback=mkflag.set_bool,
help="[%%default] Attempt to open the generated ivy resolve report "
"in a browser (implies %s)." % report)
option_group.add_option(mkflag("outdir"), dest="ivy_resolve_outdir",
help="Emit ivy report outputs in to this directory.")
option_group.add_option(mkflag("args"), dest="ivy_args", action="append", default=[],
help = "Pass these extra args to ivy.")
option_group.add_option(mkflag("mutable-pattern"), dest="ivy_mutable_pattern",
help="If specified, all artifact revisions matching this pattern will "
"be treated as mutable unless a matching artifact explicitly "
"marks mutable as False.")
def setup_parser(cls, option_group, args, mkflag):
NailgunTask.setup_parser(option_group, args, mkflag)
option_group.add_option(mkflag("skip"), mkflag("skip", negate=True),
dest="scalastyle_skip", default=False,
action="callback", callback=mkflag.set_bool,
help="[%default] Skip scalastyle.")
def __init__(self, context):
CodeGen.__init__(self, context)
NailgunTask.__init__(self, context)
# TODO(John Sirois): kill if not needed by prepare_gen
self._classpath_by_compiler = {}
active_compilers = set(map(lambda t: t.compiler, context.targets(predicate=self.is_gentarget)))
for compiler, tools in self._all_possible_antlr_bootstrap_tools():
if compiler in active_compilers:
self._jvm_tool_bootstrapper.register_jvm_tool(compiler, tools)
def __init__(self, context):
NailgunTask.__init__(self, context)
self._scalastyle_config = self.context.config.get_required(
Scalastyle._CONFIG_SECTION, 'config')
if not os.path.exists(self._scalastyle_config):
raise Config.ConfigError(
'Scalastyle config file does not exist: %s' % self._scalastyle_config)
excludes_file = self.context.config.get(Scalastyle._CONFIG_SECTION, 'excludes')
self._excludes = set()
if excludes_file:
if not os.path.exists(excludes_file):
raise Config.ConfigError('Scalastyle excludes file does not exist: %s' % excludes_file)
self.context.log.debug('Using scalastyle excludes file %s' % excludes_file)
with open(excludes_file) as fh:
for pattern in fh.readlines():
self._excludes.add(re.compile(pattern.strip()))
self._scalastyle_bootstrap_key = 'scalastyle'
self.register_jvm_tool(self._scalastyle_bootstrap_key, [':scalastyle'])
def setup_parser(subcls, option_group, args, mkflag):
NailgunTask.setup_parser(option_group, args, mkflag)
option_group.add_option(mkflag('warnings'), mkflag('warnings', negate=True),
dest=subcls._language+'_compile_warnings',
default=True,
action='callback',
callback=mkflag.set_bool,
help='[%default] Compile with all configured warnings enabled.')
option_group.add_option(mkflag('partition-size-hint'),
dest=subcls._language+'_partition_size_hint',
action='store',
type='int',
default=-1,
help='Roughly how many source files to attempt to compile together. '
'Set to a large number to compile all sources together. Set this '
'to 0 to compile target-by-target. Default is set in pants.ini.')
option_group.add_option(mkflag('missing-deps'),
dest=subcls._language+'_missing_deps',
choices=['off', 'warn', 'fatal'],
default='warn',
help='[%default] One of off, warn, fatal. '
'Check for missing dependencies in ' + subcls._language + 'code. '
'Reports actual dependencies A -> B where there is no '
'transitive BUILD file dependency path from A to B.'
'If fatal, missing deps are treated as a build error.')
option_group.add_option(mkflag('missing-direct-deps'),
dest=subcls._language+'_missing_direct_deps',
choices=['off', 'warn', 'fatal'],
default='off',
help='[%default] One of off, warn, fatal. '
'Check for missing direct dependencies in ' + subcls._language +
' code. Reports actual dependencies A -> B where there is no '
'direct BUILD file dependency path from A to B. This is a very '
'strict check, as in practice it is common to rely on transitive, '
'non-direct dependencies, e.g., due to type inference or when the '
'main target in a BUILD file is modified to depend on other '
'targets in the same BUILD file as an implementation detail. It '
'may still be useful to set it to fatal temorarily, to detect '
'these.')
option_group.add_option(mkflag('unnecessary-deps'),
dest=subcls._language+'_unnecessary_deps',
choices=['off', 'warn', 'fatal'],
default='off',
help='[%default] One of off, warn, fatal. Check for declared '
'dependencies in ' + subcls._language + ' code that are not '
'needed. This is a very strict check. For example, generated code '
'will often legitimately have BUILD dependencies that are unused '
'in practice.')
option_group.add_option(mkflag('delete-scratch'), mkflag('delete-scratch', negate=True),
dest=subcls._language+'_delete_scratch',
default=True,
action='callback',
callback=mkflag.set_bool,
help='[%default] Leave intermediate scratch files around, '
'for debugging build problems.')
def _run():
"""
To add additional paths to sys.path, add a block to the config similar to the following:
[main]
roots: ['src/python/pants_internal/test/',]
"""
version = get_version()
if len(sys.argv) == 2 and sys.argv[1] == _VERSION_OPTION:
_do_exit(version)
root_dir = get_buildroot()
if not os.path.exists(root_dir):
_exit_and_fail('PANTS_BUILD_ROOT does not point to a valid path: %s' % root_dir)
if len(sys.argv) < 2 or (len(sys.argv) == 2 and sys.argv[1] in _HELP_ALIASES):
_help(version, root_dir)
command_class, command_args = _parse_command(root_dir, sys.argv[1:])
parser = optparse.OptionParser(version=version)
RcFile.install_disable_rc_option(parser)
parser.add_option(_LOG_EXIT_OPTION,
action='store_true',
default=False,
dest='log_exit',
help = 'Log an exit message on success or failure.')
config = Config.load()
# TODO: This can be replaced once extensions are enabled with
# https://github.com/pantsbuild/pants/issues/5
roots = config.getlist('parse', 'roots', default=[])
sys.path.extend(map(lambda root: os.path.join(root_dir, root), roots))
# XXX(wickman) This should be in the command goal, not un pants_exe.py!
run_tracker = RunTracker.from_config(config)
report = initial_reporting(config, run_tracker)
run_tracker.start(report)
url = run_tracker.run_info.get_info('report_url')
if url:
run_tracker.log(Report.INFO, 'See a report at: %s' % url)
else:
run_tracker.log(Report.INFO, '(To run a reporting server: ./pants server)')
command = command_class(run_tracker, root_dir, parser, command_args)
try:
if command.serialized():
def onwait(pid):
print('Waiting on pants process %s to complete' % _process_info(pid), file=sys.stderr)
return True
runfile = os.path.join(root_dir, '.pants.run')
lock = Lock.acquire(runfile, onwait=onwait)
else:
lock = Lock.unlocked()
try:
result = command.run(lock)
_do_exit(result)
except KeyboardInterrupt:
command.cleanup()
raise
finally:
lock.release()
finally:
run_tracker.end()
# Must kill nailguns only after run_tracker.end() is called, because there may still
# be pending background work that needs a nailgun.
if (hasattr(command.options, 'cleanup_nailguns') and command.options.cleanup_nailguns) \
or config.get('nailgun', 'autokill', default=False):
NailgunTask.killall(None)
def execute(self, targets): NailgunTask.killall(everywhere=self.context.options.ng_killall_everywhere)