def checkstyle(self, targets, sources):
runtime_classpaths = self.context.products.get_data('runtime_classpath')
runtime_classpath = runtime_classpaths.get_for_targets(targets)
union_classpath = OrderedSet(self.tool_classpath('checkstyle'))
union_classpath.update(jar for conf, jar in runtime_classpath if conf in self.get_options().confs)
args = [
'-c', self.get_options().configuration,
'-f', 'plain'
]
if self.get_options().properties:
properties_file = os.path.join(self.workdir, 'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self.get_options().properties.items():
pf.write('{key}={value}\n'.format(key=k, value=v))
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=union_classpath, main=self._CHECKSTYLE_MAIN,
jvm_options=self.get_options().jvm_options,
args=args + xargs, workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, targets, sources):
runtime_classpaths = self.context.products.get_data('runtime_classpath')
union_classpath = OrderedSet(self.tool_classpath('checkstyle'))
for target in targets:
runtime_classpath = runtime_classpaths.get_for_targets(target.closure(bfs=True))
union_classpath.update(jar for conf, jar in runtime_classpath
if conf in self.get_options().confs)
args = [
'-c', self.get_options().configuration,
'-f', 'plain'
]
if self.get_options().properties:
properties_file = os.path.join(self.workdir, 'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self.get_options().properties.items():
pf.write('{key}={value}\n'.format(key=k, value=v))
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=union_classpath, main=self._CHECKSTYLE_MAIN,
jvm_options=self.get_options().jvm_options,
args=args + xargs, workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, sources, targets):
egroups = self.context.products.get_data('exclusives_groups')
etag = egroups.get_group_key_for_target(targets[0])
classpath = self.tool_classpath(self._checkstyle_bootstrap_key)
cp = egroups.get_classpath_for_group(etag)
classpath.extend(jar for conf, jar in cp if conf in self._confs)
args = ['-c', self._configuration_file, '-f', 'plain']
if self._properties:
properties_file = os.path.join(self.workdir,
'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self._properties.items():
pf.write('%s=%s\n' % (k, v))
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=classpath,
main=CHECKSTYLE_MAIN,
args=args + xargs,
workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, sources, targets):
egroups = self.context.products.get_data('exclusives_groups')
etag = egroups.get_group_key_for_target(targets[0])
classpath = self.tool_classpath(self._checkstyle_bootstrap_key)
cp = egroups.get_classpath_for_group(etag)
classpath.extend(jar for conf, jar in cp if conf in self._confs)
args = [
'-c', self._configuration_file,
'-f', 'plain'
]
if self._properties:
properties_file = os.path.join(self.workdir, 'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self._properties.items():
pf.write('%s=%s\n' % (k, v))
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=classpath, main=CHECKSTYLE_MAIN,
args=args + xargs, workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, targets, sources):
union_classpath = OrderedSet(self.tool_classpath('checkstyle'))
if self.get_options().include_user_classpath:
runtime_classpaths = self.context.products.get_data(
'runtime_classpath')
for target in targets:
runtime_classpath = runtime_classpaths.get_for_targets(
target.closure(bfs=True))
union_classpath.update(jar for conf, jar in runtime_classpath
if conf in self.get_options().confs)
task_config = self.get_options().configuration
subsystem_config = CheckstyleSubsystem.global_instance().options.config
if task_config and subsystem_config:
raise ValueError(
"Conflicting options for the config file used. You used the new, preferred "
"`--checkstyle-config`, but also used the deprecated `--lint-checkstyle-configuration`.\n"
"Please use only one of these (preferably `--checkstyle-config`)."
)
config = task_config or subsystem_config
if not config:
raise TaskError(
'No checkstyle configuration file configured. Configure with `--checkstyle-config`.'
)
args = ['-c', config, '-f', 'plain']
if self.get_options().properties:
properties_file = os.path.join(self.workdir,
'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self.get_options().properties.items():
pf.write(f'{k}={v}\n')
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=union_classpath,
main=self._CHECKSTYLE_MAIN,
jvm_options=self.get_options().jvm_options,
args=args + xargs,
workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, targets, sources):
union_classpath = OrderedSet(self.tool_classpath("checkstyle"))
if self.get_options().include_user_classpath:
runtime_classpaths = self.context.products.get_data("runtime_classpath")
for target in targets:
runtime_classpath = runtime_classpaths.get_for_targets(target.closure(bfs=True))
union_classpath.update(
jar for conf, jar in runtime_classpath if conf in self.get_options().confs
)
config = CheckstyleSubsystem.global_instance().options.config
if not config:
raise TaskError(
"No checkstyle configuration file configured. Configure with `--checkstyle-config`."
)
args = ["-c", config, "-f", "plain"]
if self.get_options().properties:
properties_file = os.path.join(self.workdir, "checkstyle.properties")
with safe_open(properties_file, "w") as pf:
for k, v in self.get_options().properties.items():
pf.write(f"{k}={v}\n")
args.extend(["-p", properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(
classpath=union_classpath,
main=self._CHECKSTYLE_MAIN,
jvm_options=self.get_options().jvm_options,
args=args + xargs,
workunit_name="checkstyle",
)
checks = Xargs(call)
return checks.execute(sources)
def checkstyle(self, targets, sources):
union_classpath = OrderedSet(self.tool_classpath('checkstyle'))
if self.get_options().include_user_classpath:
runtime_classpaths = self.context.products.get_data('runtime_classpath')
for target in targets:
runtime_classpath = runtime_classpaths.get_for_targets(target.closure(bfs=True))
union_classpath.update(jar for conf, jar in runtime_classpath
if conf in self.get_options().confs)
config = self._resolve_conflicting_options(old_option="configuration", new_option="config")
if not config:
raise TaskError(
'No checkstyle configuration file configured. Configure with `--checkstyle-config`.'
)
args = [
'-c', config,
'-f', 'plain'
]
if self.get_options().properties:
properties_file = os.path.join(self.workdir, 'checkstyle.properties')
with safe_open(properties_file, 'w') as pf:
for k, v in self.get_options().properties.items():
pf.write(f'{k}={v}\n')
args.extend(['-p', properties_file])
# We've hit known cases of checkstyle command lines being too long for the system so we guard
# with Xargs since checkstyle does not accept, for example, @argfile style arguments.
def call(xargs):
return self.runjava(classpath=union_classpath, main=self._CHECKSTYLE_MAIN,
jvm_options=self.get_options().jvm_options,
args=args + xargs, workunit_name='checkstyle')
checks = Xargs(call)
return checks.execute(sources)
class XargsTest(mox.MoxTestBase):
def setUp(self):
super(XargsTest, self).setUp()
self.call = self.mox.CreateMockAnything()
self.xargs = Xargs(self.call)
def test_execute_nosplit_success(self):
self.call(["one", "two", "three", "four"]).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(["one", "two", "three", "four"]))
def test_execute_nosplit_raise(self):
exception = Exception()
self.call(["one", "two", "three", "four"]).AndRaise(exception)
self.mox.ReplayAll()
with pytest.raises(Exception) as raised:
self.xargs.execute(["one", "two", "three", "four"])
self.assertTrue(exception is raised.value)
def test_execute_nosplit_fail(self):
self.call(["one", "two", "three", "four"]).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42, self.xargs.execute(["one", "two", "three", "four"]))
TOO_BIG = OSError(errno.E2BIG, os.strerror(errno.E2BIG))
def test_execute_split(self):
self.call(["one", "two", "three", "four"]).AndRaise(self.TOO_BIG)
self.call(["one", "two"]).AndReturn(0)
self.call(["three", "four"]).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(["one", "two", "three", "four"]))
def test_execute_uneven(self):
self.call(["one", "two", "three"]).AndRaise(self.TOO_BIG)
# TODO(John Sirois): We really don't care if the 1st call gets 1 argument or 2, we just
# care that all arguments get passed just once via exactly 2 rounds of call - consider making
# this test less brittle to changes in the chunking logic.
self.call(["one"]).AndReturn(0)
self.call(["two", "three"]).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(["one", "two", "three"]))
def test_execute_split_multirecurse(self):
self.call(["one", "two", "three", "four"]).AndRaise(self.TOO_BIG)
self.call(["one", "two"]).AndRaise(self.TOO_BIG)
self.call(["one"]).AndReturn(0)
self.call(["two"]).AndReturn(0)
self.call(["three", "four"]).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(["one", "two", "three", "four"]))
def test_execute_split_fail_fast(self):
self.call(["one", "two", "three", "four"]).AndRaise(self.TOO_BIG)
self.call(["one", "two"]).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42, self.xargs.execute(["one", "two", "three", "four"]))
def test_execute_split_fail_slow(self):
self.call(["one", "two", "three", "four"]).AndRaise(self.TOO_BIG)
self.call(["one", "two"]).AndReturn(0)
self.call(["three", "four"]).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42, self.xargs.execute(["one", "two", "three", "four"]))
class XargsTest(mox.MoxTestBase):
def setUp(self):
super(XargsTest, self).setUp()
self.call = self.mox.CreateMockAnything()
self.xargs = Xargs(self.call)
def test_execute_nosplit_success(self):
self.call(['one', 'two', 'three', 'four']).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
def test_execute_nosplit_raise(self):
exception = Exception()
self.call(['one', 'two', 'three', 'four']).AndRaise(exception)
self.mox.ReplayAll()
with pytest.raises(Exception) as raised:
self.xargs.execute(['one', 'two', 'three', 'four'])
self.assertTrue(exception is raised.value)
def test_execute_nosplit_fail(self):
self.call(['one', 'two', 'three', 'four']).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
TOO_BIG = OSError(errno.E2BIG, os.strerror(errno.E2BIG))
def test_execute_split(self):
self.call(['one', 'two', 'three', 'four']).AndRaise(self.TOO_BIG)
self.call(['one', 'two']).AndReturn(0)
self.call(['three', 'four']).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
def test_execute_uneven(self):
self.call(['one', 'two', 'three']).AndRaise(self.TOO_BIG)
# TODO(John Sirois): We really don't care if the 1st call gets 1 argument or 2, we just
# care that all arguments get passed just once via exactly 2 rounds of call - consider making
# this test less brittle to changes in the chunking logic.
self.call(['one']).AndReturn(0)
self.call(['two', 'three']).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three']))
def test_execute_split_multirecurse(self):
self.call(['one', 'two', 'three', 'four']).AndRaise(self.TOO_BIG)
self.call(['one', 'two']).AndRaise(self.TOO_BIG)
self.call(['one']).AndReturn(0)
self.call(['two']).AndReturn(0)
self.call(['three', 'four']).AndReturn(0)
self.mox.ReplayAll()
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
def test_execute_split_fail_fast(self):
self.call(['one', 'two', 'three', 'four']).AndRaise(self.TOO_BIG)
self.call(['one', 'two']).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
def test_execute_split_fail_slow(self):
self.call(['one', 'two', 'three', 'four']).AndRaise(self.TOO_BIG)
self.call(['one', 'two']).AndReturn(0)
self.call(['three', 'four']).AndReturn(42)
self.mox.ReplayAll()
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
class XargsTest(unittest.TestCase):
def setUp(self):
self.call = unittest.mock.Mock()
self.xargs = Xargs(self.call)
def test_execute_nosplit_success(self):
self.call.return_value = 0
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
def test_execute_nosplit_raise(self):
exception = Exception()
self.call.side_effect = exception
with self.assertRaises(Exception) as raised:
self.xargs.execute(['one', 'two', 'three', 'four'])
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
self.assertIs(exception, raised.exception)
def test_execute_nosplit_fail(self):
self.call.return_value = 42
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
TOO_BIG = OSError(errno.E2BIG, os.strerror(errno.E2BIG))
def test_execute_split(self):
self.call.side_effect = (self.TOO_BIG, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
self.assertEqual([
unittest.mock.call(['one', 'two', 'three', 'four']),
unittest.mock.call(['one', 'two']),
unittest.mock.call(['three', 'four'])
], self.call.mock_calls)
def test_execute_uneven(self):
self.call.side_effect = (self.TOO_BIG, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three']))
self.assertEqual(3, self.call.call_count)
self.assertEqual(unittest.mock.call(['one', 'two', 'three']),
self.call.mock_calls[0])
self.assertEqual(
sorted((unittest.mock.call(['one']),
unittest.mock.call(['two', 'three']))),
sorted(self.call.mock_calls[1:]))
def test_execute_split_multirecurse(self):
self.call.side_effect = (self.TOO_BIG, self.TOO_BIG, 0, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three',
'four']))
self.assertEqual([
unittest.mock.call(['one', 'two', 'three', 'four']),
unittest.mock.call(['one', 'two']),
unittest.mock.call(['one']),
unittest.mock.call(['two']),
unittest.mock.call(['three', 'four'])
], self.call.mock_calls)
def test_execute_split_fail_fast(self):
self.call.side_effect = (self.TOO_BIG, 42)
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([
unittest.mock.call(['one', 'two', 'three', 'four']),
unittest.mock.call(['one', 'two'])
], self.call.mock_calls)
def test_execute_split_fail_slow(self):
self.call.side_effect = (self.TOO_BIG, 0, 42)
self.assertEqual(42,
self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([
unittest.mock.call(['one', 'two', 'three', 'four']),
unittest.mock.call(['one', 'two']),
unittest.mock.call(['three', 'four'])
], self.call.mock_calls)
class XargsTest(unittest.TestCase):
def setUp(self):
self.call = mock.Mock()
self.xargs = Xargs(self.call)
def test_execute_nosplit_success(self):
self.call.return_value = 0
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three', 'four']))
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
def test_execute_nosplit_raise(self):
exception = Exception()
self.call.side_effect = exception
with self.assertRaises(Exception) as raised:
self.xargs.execute(['one', 'two', 'three', 'four'])
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
self.assertIs(exception, raised.exception)
def test_execute_nosplit_fail(self):
self.call.return_value = 42
self.assertEqual(42, self.xargs.execute(['one', 'two', 'three', 'four']))
self.call.assert_called_once_with(['one', 'two', 'three', 'four'])
TOO_BIG = OSError(errno.E2BIG, os.strerror(errno.E2BIG))
def test_execute_split(self):
self.call.side_effect = (self.TOO_BIG, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([mock.call(['one', 'two', 'three', 'four']),
mock.call(['one', 'two']),
mock.call(['three', 'four'])],
self.call.mock_calls)
def test_execute_uneven(self):
self.call.side_effect = (self.TOO_BIG, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three']))
self.assertEqual(3, self.call.call_count)
self.assertEqual(mock.call(['one', 'two', 'three']),
self.call.mock_calls[0])
self.assertEqual(sorted((mock.call(['one']), mock.call(['two', 'three']))),
sorted(self.call.mock_calls[1:]))
def test_execute_split_multirecurse(self):
self.call.side_effect = (self.TOO_BIG, self.TOO_BIG, 0, 0, 0)
self.assertEqual(0, self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([mock.call(['one', 'two', 'three', 'four']),
mock.call(['one', 'two']),
mock.call(['one']),
mock.call(['two']),
mock.call(['three', 'four'])],
self.call.mock_calls)
def test_execute_split_fail_fast(self):
self.call.side_effect = (self.TOO_BIG, 42)
self.assertEqual(42, self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([mock.call(['one', 'two', 'three', 'four']),
mock.call(['one', 'two'])],
self.call.mock_calls)
def test_execute_split_fail_slow(self):
self.call.side_effect = (self.TOO_BIG, 0, 42)
self.assertEqual(42, self.xargs.execute(['one', 'two', 'three', 'four']))
self.assertEqual([mock.call(['one', 'two', 'three', 'four']),
mock.call(['one', 'two']),
mock.call(['three', 'four'])],
self.call.mock_calls)
