def test_and_filters() -> None: divisible_by_6 = and_filters(create_filters(["2", "3"], is_divisible_by)) assert divisible_by_6(2) is False assert divisible_by_6(3) is False assert divisible_by_6(6) is True assert divisible_by_6(9) is False assert divisible_by_6(12) is True
def create( cls, filter_subsystem: FilterSubsystem, registered_target_types: RegisteredTargetTypes, *, tags: Iterable[str], exclude_target_regexps: Iterable[str], ) -> SpecsFilter: exclude_patterns = tuple( re.compile(pattern) for pattern in exclude_target_regexps) def exclude_target_regexps_filter(tgt: Target) -> bool: return all( p.search(tgt.address.spec) is None for p in exclude_patterns) def tags_outer_filter(tag: str) -> TargetFilter: def tags_inner_filter(tgt: Target) -> bool: return tag in (tgt.get(Tags).value or []) return tags_inner_filter tags_filter = and_filters(create_filters(tags, tags_outer_filter)) return SpecsFilter( is_specified=bool(filter_subsystem.is_specified() or tags or exclude_target_regexps), filter_subsystem_filter=filter_subsystem.all_filters( registered_target_types), tags_filter=tags_filter, exclude_target_regexps_filter=exclude_target_regexps_filter, )
def filter_targets( # NB: We must preserve target generators, not replace with their generated targets. targets: UnexpandedTargets, filter_subsystem: FilterSubsystem, console: Console, registered_target_types: RegisteredTargetTypes, ) -> FilterGoal: def filter_target_type(target_type: str) -> TargetFilter: if target_type not in registered_target_types.aliases: raise UnrecognizedTargetTypeException(target_type, registered_target_types) def filt(tgt: Target) -> bool: if tgt.alias == target_type: return True if tgt.deprecated_alias == target_type: warn_deprecated_target_type(type(tgt)) return True return False return filt def filter_address_regex(address_regex: str) -> TargetFilter: regex = compile_regex(address_regex) return lambda tgt: bool(regex.search(tgt.address.spec)) def filter_tag_regex(tag_regex: str) -> TargetFilter: regex = compile_regex(tag_regex) return lambda tgt: any( bool(regex.search(tag)) for tag in tgt.get(Tags).value or ()) def filter_granularity(granularity: TargetGranularity) -> TargetFilter: return match( granularity, { TargetGranularity.all_targets: lambda _: True, TargetGranularity.file_targets: lambda tgt: tgt.address.is_file_target, TargetGranularity.build_targets: lambda tgt: not tgt.address.is_file_target, }, ) anded_filter: TargetFilter = and_filters([ *(create_filters(filter_subsystem.options.target_type, filter_target_type)), *(create_filters(filter_subsystem.options.address_regex, filter_address_regex)), *(create_filters(filter_subsystem.options.tag_regex, filter_tag_regex)), filter_granularity(filter_subsystem.options.granularity), ]) addresses = sorted(target.address for target in targets if anded_filter(target)) with filter_subsystem.line_oriented(console) as print_stdout: for address in addresses: print_stdout(address.spec) return FilterGoal(exit_code=0)
def filter_targets( targets: Targets, options: FilterOptions, console: Console, registered_target_types: RegisteredTargetTypes, ) -> FilterGoal: def filter_target_type(target_type: str) -> TargetFilter: if target_type not in registered_target_types.aliases: raise UnrecognizedTargetTypeException(target_type, registered_target_types) return lambda tgt: tgt.alias == target_type def filter_address_regex(address_regex: str) -> TargetFilter: regex = compile_regex(address_regex) return lambda tgt: bool(regex.search(tgt.address.spec)) def filter_tag_regex(tag_regex: str) -> TargetFilter: regex = compile_regex(tag_regex) return lambda tgt: any( bool(regex.search(tag)) for tag in tgt.get(Tags).value or ()) anded_filter: TargetFilter = and_filters([ *(create_filters(options.values.target_type, filter_target_type)), *(create_filters(options.values.address_regex, filter_address_regex)), *(create_filters(options.values.tag_regex, filter_tag_regex)), ]) addresses = sorted(target.address for target in targets if anded_filter(target)) with options.line_oriented(console) as print_stdout: for address in addresses: print_stdout(address) return FilterGoal(exit_code=0)
def _tag_filter(self): def filter_for_tag(tag: str) -> Callable[[Target], bool]: def filter_target(tgt: Target) -> bool: return tag in (tgt.get(Tags).value or []) return filter_target return and_filters(create_filters(self.tags, filter_for_tag))
def all_filters(self, registered_target_types: RegisteredTargetTypes) -> TargetFilter: return and_filters( [ *self.target_type_filters(registered_target_types), *self.address_regex_filters(), *self.tag_regex_filters(), self.granularity_filter(), ] )
def _tag_filter(self): def filter_for_tag(tag: str) -> Callable[[TargetAdaptor], bool]: def filter_target(tgt: TargetAdaptor) -> bool: # `tags` can sometimes be explicitly set to `None`. We convert that to an empty list # with `or`. tags = tgt.kwargs.get("tags", []) or [] return tag in [str(t_tag) for t_tag in tags] return filter_target return and_filters(create_filters(self.tags, filter_for_tag))
def _target_tag_matches(self): def filter_for_tag(tag): def filter_target(tgt): # `tags` can sometimes be explicitly set to `None`. We convert that to an empty list # with `or`. tags = tgt.kwargs().get("tags", []) or [] return tag in [str(t_tag) for t_tag in tags] return filter_target return and_filters(create_filters(self.tags, filter_for_tag))
def filter_targets( targets: UnexpandedTargets, filter_subsystem: FilterSubsystem, console: Console, registered_target_types: RegisteredTargetTypes, ) -> FilterGoal: if not filter_subsystem.options.is_default("target"): raise ValueError(TARGET_REMOVAL_MSG) if not filter_subsystem.options.is_default("ancestor"): raise ValueError(ANCESTOR_REMOVAL_MSG) def filter_target_type(target_type: str) -> TargetFilter: if target_type not in registered_target_types.aliases: raise UnrecognizedTargetTypeException(target_type, registered_target_types) return lambda tgt: tgt.alias == target_type def filter_address_regex(address_regex: str) -> TargetFilter: regex = compile_regex(address_regex) return lambda tgt: bool(regex.search(tgt.address.spec)) def filter_tag_regex(tag_regex: str) -> TargetFilter: regex = compile_regex(tag_regex) return lambda tgt: any( bool(regex.search(tag)) for tag in tgt.get(Tags).value or ()) resolve_option = partial( resolve_conflicting_options, old_scope="filter", new_scope="filter", old_container=filter_subsystem.options, new_container=filter_subsystem.options, ) target_type = resolve_option(old_option="type", new_option="target_type") address_regex = resolve_option(old_option="regex", new_option="address_regex") anded_filter: TargetFilter = and_filters([ *(create_filters(target_type, filter_target_type)), *(create_filters(address_regex, filter_address_regex)), *(create_filters(filter_subsystem.options.tag_regex, filter_tag_regex)), ]) addresses = sorted(target.address for target in targets if anded_filter(target)) with filter_subsystem.line_oriented(console) as print_stdout: for address in addresses: print_stdout(address.spec) return FilterGoal(exit_code=0)