def list():
"""Lists all addresses under the current build root subject to `--spec-excludes` constraints."""
build_root = get_buildroot()
options, build_config = OptionsInitializer().setup()
aliases = build_config.registered_aliases()
symbol_table = {alias: Target for alias in aliases.target_types}
object_table = aliases.objects
def per_path_symbol_factory(path, global_symbols):
per_path_symbols = {}
symbols = global_symbols.copy()
for alias, target_macro_factory in aliases.target_macro_factories.items(
):
for target_type in target_macro_factory.target_types:
symbols[
target_type] = lambda *args, **kwargs: per_path_symbols[
alias](*args, **kwargs)
parse_context = ParseContext(rel_path=os.path.relpath(
os.path.dirname(path), build_root),
type_aliases=symbols)
for alias, object_factory in aliases.context_aware_object_factories.items(
):
per_path_symbols[alias] = object_factory(parse_context)
for alias, target_macro_factory in aliases.target_macro_factories.items(
):
target_macro = target_macro_factory.target_macro(parse_context)
per_path_symbols[alias] = target_macro
for target_type in target_macro_factory.target_types:
per_path_symbols[target_type] = target_macro
return per_path_symbols
parser = legacy_python_callbacks_parser(
symbol_table,
object_table=object_table,
per_path_symbol_factory=per_path_symbol_factory)
mapper = AddressMapper(build_root, parser=parser)
# Should use build_ignore_patterns instead.
spec_excludes = None
for address, obj in mapper.walk_addressables(path_excludes=spec_excludes):
print(address.spec)
def list():
"""Lists all addresses under the current build root subject to `--spec-excludes` constraints."""
build_root = get_buildroot()
options, build_config = OptionsInitializer().setup()
aliases = build_config.registered_aliases()
symbol_table = {alias: Target for alias in aliases.target_types}
object_table = aliases.objects
def per_path_symbol_factory(path, global_symbols):
per_path_symbols = {}
symbols = global_symbols.copy()
for alias, target_macro_factory in aliases.target_macro_factories.items():
for target_type in target_macro_factory.target_types:
symbols[target_type] = lambda *args, **kwargs: per_path_symbols[alias](*args, **kwargs)
parse_context = ParseContext(rel_path=os.path.relpath(os.path.dirname(path), build_root),
type_aliases=symbols)
for alias, object_factory in aliases.context_aware_object_factories.items():
per_path_symbols[alias] = object_factory(parse_context)
for alias, target_macro_factory in aliases.target_macro_factories.items():
target_macro = target_macro_factory.target_macro(parse_context)
per_path_symbols[alias] = target_macro
for target_type in target_macro_factory.target_types:
per_path_symbols[target_type] = target_macro
return per_path_symbols
parser = legacy_python_callbacks_parser(symbol_table,
object_table=object_table,
per_path_symbol_factory=per_path_symbol_factory)
mapper = AddressMapper(build_root, parser=parser)
spec_excludes = options.for_global_scope().spec_excludes
for address, obj in mapper.walk_addressables(path_excludes=spec_excludes):
print(address.spec)
class AddressMapperTest(unittest.TestCase):
def setUp(self):
self.work_dir = safe_mkdtemp()
self.addCleanup(safe_rmtree, self.work_dir)
self.build_root = os.path.join(self.work_dir, 'build_root')
shutil.copytree(
os.path.join(os.path.dirname(__file__), 'examples/mapper_test'),
self.build_root)
parser = partial(parse_json,
symbol_table={
'struct': Struct,
'target': Target
})
self.address_mapper = AddressMapper(build_root=self.build_root,
build_pattern=r'.+\.BUILD.json$',
parser=parser)
self.a_b_target = Target(
name='b',
dependencies=['//d:e'],
configurations=['//a', Struct(embedded='yes')])
def test_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
touch(build_file)
address_family = self.address_mapper.family('a/c')
self.assertEqual({}, address_family.addressables)
# But success is cached.
self.assertIs(address_family, self.address_mapper.family('a/c'))
def test_no_address_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
with safe_open(build_file, 'w') as fp:
fp.write('{"type_alias": "struct", "name": "c"}')
resolved = self.address_mapper.resolve(Address.parse('a/c'))
self.assertEqual(Struct(name='c'), resolved)
# But success is cached.
self.assertIs(resolved,
self.address_mapper.resolve(Address.parse('a/c')))
def test_resolve(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
def test_invalidate_build_file_added(self):
address_family = self.address_mapper.family('a/b')
self.assertEqual({Address.parse('a/b'): self.a_b_target},
address_family.addressables)
with open(os.path.join(self.build_root, 'a/b/sibling.BUILD.json'),
'w') as fp:
fp.write('{"type_alias": "struct", "name": "c"}')
still_valid = self.address_mapper.family('a/b')
self.assertIs(address_family, still_valid)
self.address_mapper.invalidate_build_file('a/b/sibling.BUILD.json')
newly_formed = self.address_mapper.family('a/b')
self.assertIsNot(address_family, newly_formed)
self.assertEqual(
{
Address.parse('a/b'): self.a_b_target,
Address.parse('a/b:c'): Struct(name='c')
}, newly_formed.addressables)
def test_invalidate_build_file_changed(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b:c'))
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
with safe_open(build_file, 'w+') as fp:
fp.write('{"type_alias": "struct", "name": "c"}')
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b:c'))
self.address_mapper.invalidate_build_file('a/b/b.BUILD.json')
resolved = self.address_mapper.resolve(Address.parse('a/b:c'))
self.assertEqual(Struct(name='c'), resolved)
# But success is cached.
self.assertIs(resolved,
self.address_mapper.resolve(Address.parse('a/b:c')))
def test_invalidate_build_file_removed(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
os.unlink(build_file)
self.assertIs(resolved,
self.address_mapper.resolve(Address.parse('a/b')))
self.address_mapper.invalidate_build_file(build_file)
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
def test_invalidation_un_normalized(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
os.unlink(os.path.join(self.build_root, 'a/b/b.BUILD.json'))
self.assertIs(resolved,
self.address_mapper.resolve(Address.parse('a/b')))
un_normalized_build_root = os.path.join(self.work_dir,
'build_root_linked')
os.symlink(self.build_root, un_normalized_build_root)
un_normalized_build_file = os.path.join(un_normalized_build_root,
'a/b/b.BUILD.json')
self.address_mapper.invalidate_build_file(un_normalized_build_file)
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
def test_invalidation_relative(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
os.unlink(build_file)
self.assertIs(resolved,
self.address_mapper.resolve(Address.parse('a/b')))
self.address_mapper.invalidate_build_file('a/b/b.BUILD.json')
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
@staticmethod
def addr(spec):
return Address.parse(spec)
def test_walk_addressables(self):
self.assertEqual(
sorted([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/b:b'), self.a_b_target),
(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables()))
def test_walk_addressables_rel_path(self):
self.assertEqual(
sorted([(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables(rel_path='a/d')))
def test_walk_addressables_path_excludes(self):
self.assertEqual([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/d:d'), Target(name='d'))],
list(
self.address_mapper.walk_addressables(
path_excludes=['a/b', 'a/d/e'])))
class AddressMapperTest(unittest.TestCase):
def setUp(self):
self.work_dir = safe_mkdtemp()
self.addCleanup(safe_rmtree, self.work_dir)
self.build_root = os.path.join(self.work_dir, 'build_root')
shutil.copytree(
os.path.join(os.path.dirname(__file__), 'examples/mapper_test'),
self.build_root)
self.address_mapper = AddressMapper(build_root=self.build_root,
symbol_table_cls=TargetTable,
parser_cls=JsonParser,
build_pattern=r'.+\.BUILD.json$')
self.a_b_target = Target(
name='b',
dependencies=['//d:e'],
configurations=['//a', Struct(embedded='yes')])
def test_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
touch(build_file)
address_family = self.address_mapper.family('a/c')
self.assertEqual({}, address_family.addressables)
def test_no_address_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
with safe_open(build_file, 'w') as fp:
fp.write('{"type_alias": "struct", "name": "c"}')
resolved = self.address_mapper.resolve(Address.parse('a/c'))
self.assertEqual(Struct(name='c'), resolved)
def test_resolve(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
@staticmethod
def addr(spec):
return Address.parse(spec)
def test_walk_addressables(self):
self.assertEqual(
sorted([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/b:b'), self.a_b_target),
(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables()))
def test_walk_addressables_rel_path(self):
self.assertEqual(
sorted([(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables(rel_path='a/d')))
def test_walk_addressables_path_excludes(self):
self.assertEqual([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/d:d'), Target(name='d'))],
list(
self.address_mapper.walk_addressables(
path_excludes=['a/b', 'a/d/e'])))
class AddressMapperTest(unittest.TestCase):
def setUp(self):
self.work_dir = safe_mkdtemp()
self.addCleanup(safe_rmtree, self.work_dir)
self.build_root = os.path.join(self.work_dir, 'build_root')
shutil.copytree(os.path.join(os.path.dirname(__file__), 'examples/mapper_test'),
self.build_root)
parser = partial(parse_json, symbol_table={'configuration': Configuration, 'target': Target})
self.address_mapper = AddressMapper(build_root=self.build_root,
build_pattern=r'.+\.BUILD.json$',
parser=parser)
self.a_b_target = Target(name='b',
dependencies=['//d:e'],
configurations=['//a', Configuration(embedded='yes')])
def test_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
touch(build_file)
address_family = self.address_mapper.family('a/c')
self.assertEqual({}, address_family.addressables)
# But success is cached.
self.assertIs(address_family, self.address_mapper.family('a/c'))
def test_no_address_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
with safe_open(build_file, 'w') as fp:
fp.write('{"type_alias": "configuration", "name": "c"}')
resolved = self.address_mapper.resolve(Address.parse('a/c'))
self.assertEqual(Configuration(name='c'), resolved)
# But success is cached.
self.assertIs(resolved, self.address_mapper.resolve(Address.parse('a/c')))
def test_resolve(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
def test_invalidate_build_file_added(self):
address_family = self.address_mapper.family('a/b')
self.assertEqual({Address.parse('a/b'): self.a_b_target},
address_family.addressables)
with open(os.path.join(self.build_root, 'a/b/sibling.BUILD.json'), 'w') as fp:
fp.write('{"type_alias": "configuration", "name": "c"}')
still_valid = self.address_mapper.family('a/b')
self.assertIs(address_family, still_valid)
self.address_mapper.invalidate_build_file('a/b/sibling.BUILD.json')
newly_formed = self.address_mapper.family('a/b')
self.assertIsNot(address_family, newly_formed)
self.assertEqual({Address.parse('a/b'): self.a_b_target,
Address.parse('a/b:c'): Configuration(name='c')},
newly_formed.addressables)
def test_invalidate_build_file_changed(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b:c'))
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
with safe_open(build_file, 'w+') as fp:
fp.write('{"type_alias": "configuration", "name": "c"}')
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b:c'))
self.address_mapper.invalidate_build_file('a/b/b.BUILD.json')
resolved = self.address_mapper.resolve(Address.parse('a/b:c'))
self.assertEqual(Configuration(name='c'), resolved)
# But success is cached.
self.assertIs(resolved, self.address_mapper.resolve(Address.parse('a/b:c')))
def test_invalidate_build_file_removed(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
os.unlink(build_file)
self.assertIs(resolved, self.address_mapper.resolve(Address.parse('a/b')))
self.address_mapper.invalidate_build_file(build_file)
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
def test_invalidation_un_normalized(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
os.unlink(os.path.join(self.build_root, 'a/b/b.BUILD.json'))
self.assertIs(resolved, self.address_mapper.resolve(Address.parse('a/b')))
un_normalized_build_root = os.path.join(self.work_dir, 'build_root_linked')
os.symlink(self.build_root, un_normalized_build_root)
un_normalized_build_file = os.path.join(un_normalized_build_root, 'a/b/b.BUILD.json')
self.address_mapper.invalidate_build_file(un_normalized_build_file)
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
def test_invalidation_relative(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
build_file = os.path.join(self.build_root, 'a/b/b.BUILD.json')
os.unlink(build_file)
self.assertIs(resolved, self.address_mapper.resolve(Address.parse('a/b')))
self.address_mapper.invalidate_build_file('a/b/b.BUILD.json')
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/b'))
@staticmethod
def addr(spec):
return Address.parse(spec)
def test_walk_addressables(self):
self.assertEqual(sorted([(self.addr('//:root'), Configuration(name='root')),
(self.addr('a/b:b'), self.a_b_target),
(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Configuration(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables()))
def test_walk_addressables_rel_path(self):
self.assertEqual(sorted([(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Configuration(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables(rel_path='a/d')))
def test_walk_addressables_path_excludes(self):
self.assertEqual([(self.addr('//:root'), Configuration(name='root')),
(self.addr('a/d:d'), Target(name='d'))],
list(self.address_mapper.walk_addressables(path_excludes=['a/b', 'a/d/e'])))
class AddressMapperTest(unittest.TestCase):
def setUp(self):
self.work_dir = safe_mkdtemp()
self.addCleanup(safe_rmtree, self.work_dir)
self.build_root = os.path.join(self.work_dir, 'build_root')
shutil.copytree(os.path.join(os.path.dirname(__file__), 'examples/mapper_test'),
self.build_root)
self.address_mapper = AddressMapper(build_root=self.build_root,
symbol_table_cls=TargetTable,
parser_cls=JsonParser,
build_pattern=r'.+\.BUILD.json$')
self.a_b_target = Target(name='b',
dependencies=['//d:e'],
configurations=['//a', Struct(embedded='yes')])
def test_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.family('a/c')
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
touch(build_file)
address_family = self.address_mapper.family('a/c')
self.assertEqual({}, address_family.addressables)
def test_no_address_no_family(self):
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
# Errors are not cached.
with self.assertRaises(ResolveError):
self.address_mapper.resolve(Address.parse('a/c'))
build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json')
with safe_open(build_file, 'w') as fp:
fp.write('{"type_alias": "struct", "name": "c"}')
resolved = self.address_mapper.resolve(Address.parse('a/c'))
self.assertEqual(Struct(name='c'), resolved)
def test_resolve(self):
resolved = self.address_mapper.resolve(Address.parse('a/b'))
self.assertEqual(self.a_b_target, resolved)
@staticmethod
def addr(spec):
return Address.parse(spec)
def test_walk_addressables(self):
self.assertEqual(sorted([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/b:b'), self.a_b_target),
(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables()))
def test_walk_addressables_rel_path(self):
self.assertEqual(sorted([(self.addr('a/d:d'), Target(name='d')),
(self.addr('a/d/e:e'), Target(name='e')),
(self.addr('a/d/e:e-prime'), Struct(name='e-prime'))]),
sorted(self.address_mapper.walk_addressables(rel_path='a/d')))
def test_walk_addressables_path_excludes(self):
self.assertEqual([(self.addr('//:root'), Struct(name='root')),
(self.addr('a/d:d'), Target(name='d'))],
list(self.address_mapper.walk_addressables(path_excludes=['a/b', 'a/d/e'])))