| # Copyright 2024 The Bazel Authors. All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """Builders to make building complex objects easier.""" | |
| load("@bazel_skylib//lib:types.bzl", "types") | |
| def _DepsetBuilder(): | |
| """Create a builder for a depset.""" | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| _order = [None], | |
| add = lambda *a, **k: _DepsetBuilder_add(self, *a, **k), | |
| build = lambda *a, **k: _DepsetBuilder_build(self, *a, **k), | |
| direct = [], | |
| get_order = lambda *a, **k: _DepsetBuilder_get_order(self, *a, **k), | |
| set_order = lambda *a, **k: _DepsetBuilder_set_order(self, *a, **k), | |
| transitive = [], | |
| ) | |
| return self | |
| def _DepsetBuilder_add(self, *values): | |
| """Add value to the depset. | |
| Args: | |
| self: {type}`DepsetBuilder` implicitly added. | |
| *values: {type}`depset | list | object` Values to add to the depset. | |
| The values can be a depset, the non-depset value to add, or | |
| a list of such values to add. | |
| Returns: | |
| {type}`DepsetBuilder` | |
| """ | |
| for value in values: | |
| if types.is_list(value): | |
| for sub_value in value: | |
| if types.is_depset(sub_value): | |
| self.transitive.append(sub_value) | |
| else: | |
| self.direct.append(sub_value) | |
| elif types.is_depset(value): | |
| self.transitive.append(value) | |
| else: | |
| self.direct.append(value) | |
| return self | |
| def _DepsetBuilder_set_order(self, order): | |
| """Sets the order to use. | |
| Args: | |
| self: {type}`DepsetBuilder` implicitly added. | |
| order: {type}`str` One of the {obj}`depset` `order` values. | |
| Returns: | |
| {type}`DepsetBuilder` | |
| """ | |
| self._order[0] = order | |
| return self | |
| def _DepsetBuilder_get_order(self): | |
| """Gets the depset order that will be used. | |
| Args: | |
| self: {type}`DepsetBuilder` implicitly added. | |
| Returns: | |
| {type}`str | None` If not previously set, `None` is returned. | |
| """ | |
| return self._order[0] | |
| def _DepsetBuilder_build(self): | |
| """Creates a {obj}`depset` from the accumulated values. | |
| Args: | |
| self: {type}`DepsetBuilder` implicitly added. | |
| Returns: | |
| {type}`depset` | |
| """ | |
| if not self.direct and len(self.transitive) == 1 and self._order[0] == None: | |
| return self.transitive[0] | |
| else: | |
| kwargs = {} | |
| if self._order[0] != None: | |
| kwargs["order"] = self._order[0] | |
| return depset(direct = self.direct, transitive = self.transitive, **kwargs) | |
| def _Optional(*initial): | |
| """A wrapper for a re-assignable value that may or may not be set. | |
| This allows structs to have attributes that aren't inherently mutable | |
| and must be re-assigned to have their value updated. | |
| Args: | |
| *initial: A single vararg to be the initial value, or no args | |
| to leave it unset. | |
| Returns: | |
| {type}`Optional` | |
| """ | |
| if len(initial) > 1: | |
| fail("Only zero or one positional arg allowed") | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| _value = list(initial), | |
| present = lambda *a, **k: _Optional_present(self, *a, **k), | |
| set = lambda *a, **k: _Optional_set(self, *a, **k), | |
| get = lambda *a, **k: _Optional_get(self, *a, **k), | |
| ) | |
| return self | |
| def _Optional_set(self, value): | |
| """Sets the value of the optional. | |
| Args: | |
| self: implicitly added | |
| value: the value to set. | |
| """ | |
| if len(self._value) == 0: | |
| self._value.append(value) | |
| else: | |
| self._value[0] = value | |
| def _Optional_get(self): | |
| """Gets the value of the optional, or error. | |
| Args: | |
| self: implicitly added | |
| Returns: | |
| The stored value, or error if not set. | |
| """ | |
| if not len(self._value): | |
| fail("Value not present") | |
| return self._value[0] | |
| def _Optional_present(self): | |
| """Tells if a value is present. | |
| Args: | |
| self: implicitly added | |
| Returns: | |
| {type}`bool` True if the value is set, False if not. | |
| """ | |
| return len(self._value) > 0 | |
| def _RuleBuilder(implementation = None, **kwargs): | |
| """Builder for creating rules. | |
| Args: | |
| implementation: {type}`callable` The rule implementation function. | |
| **kwargs: The same as the `rule()` function, but using builders | |
| for the non-mutable Bazel objects. | |
| """ | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| attrs = dict(kwargs.pop("attrs", None) or {}), | |
| cfg = kwargs.pop("cfg", None) or _TransitionBuilder(), | |
| exec_groups = dict(kwargs.pop("exec_groups", None) or {}), | |
| executable = _Optional(), | |
| fragments = list(kwargs.pop("fragments", None) or []), | |
| implementation = _Optional(implementation), | |
| extra_kwargs = kwargs, | |
| provides = list(kwargs.pop("provides", None) or []), | |
| test = _Optional(), | |
| toolchains = list(kwargs.pop("toolchains", None) or []), | |
| build = lambda *a, **k: _RuleBuilder_build(self, *a, **k), | |
| to_kwargs = lambda *a, **k: _RuleBuilder_to_kwargs(self, *a, **k), | |
| ) | |
| if "test" in kwargs: | |
| self.test.set(kwargs.pop("test")) | |
| if "executable" in kwargs: | |
| self.executable.set(kwargs.pop("executable")) | |
| return self | |
| def _RuleBuilder_build(self, debug = ""): | |
| """Builds a `rule` object | |
| Args: | |
| self: implicitly added | |
| debug: {type}`str` If set, prints the args used to create the rule. | |
| Returns: | |
| {type}`rule` | |
| """ | |
| kwargs = self.to_kwargs() | |
| if debug: | |
| lines = ["=" * 80, "rule kwargs: {}:".format(debug)] | |
| for k, v in sorted(kwargs.items()): | |
| lines.append(" {}={}".format(k, v)) | |
| print("\n".join(lines)) # buildifier: disable=print | |
| return rule(**kwargs) | |
| def _RuleBuilder_to_kwargs(self): | |
| """Builds the arguments for calling `rule()`. | |
| Args: | |
| self: implicitly added | |
| Returns: | |
| {type}`dict` | |
| """ | |
| kwargs = {} | |
| if self.executable.present(): | |
| kwargs["executable"] = self.executable.get() | |
| if self.test.present(): | |
| kwargs["test"] = self.test.get() | |
| kwargs.update( | |
| implementation = self.implementation.get(), | |
| cfg = self.cfg.build() if self.cfg.implementation.present() else None, | |
| attrs = { | |
| k: (v.build() if hasattr(v, "build") else v) | |
| for k, v in self.attrs.items() | |
| }, | |
| exec_groups = self.exec_groups, | |
| fragments = self.fragments, | |
| provides = self.provides, | |
| toolchains = self.toolchains, | |
| ) | |
| kwargs.update(self.extra_kwargs) | |
| return kwargs | |
| def _RunfilesBuilder(): | |
| """Creates a `RunfilesBuilder`. | |
| Returns: | |
| {type}`RunfilesBuilder` | |
| """ | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| add = lambda *a, **k: _RunfilesBuilder_add(self, *a, **k), | |
| add_targets = lambda *a, **k: _RunfilesBuilder_add_targets(self, *a, **k), | |
| build = lambda *a, **k: _RunfilesBuilder_build(self, *a, **k), | |
| files = _DepsetBuilder(), | |
| root_symlinks = {}, | |
| runfiles = [], | |
| symlinks = {}, | |
| ) | |
| return self | |
| def _RunfilesBuilder_add(self, *values): | |
| """Adds a value to the runfiles. | |
| Args: | |
| self: {type}`RunfilesBuilder` implicitly added. | |
| *values: {type}`File | runfiles | list[File] | depset[File] | list[runfiles]` | |
| The values to add. | |
| Returns: | |
| {type}`RunfilesBuilder` | |
| """ | |
| for value in values: | |
| if types.is_list(value): | |
| for sub_value in value: | |
| _RunfilesBuilder_add_internal(self, sub_value) | |
| else: | |
| _RunfilesBuilder_add_internal(self, value) | |
| return self | |
| def _RunfilesBuilder_add_targets(self, targets): | |
| """Adds runfiles from targets | |
| Args: | |
| self: {type}`RunfilesBuilder` implicitly added. | |
| targets: {type}`list[Target]` targets whose default runfiles | |
| to add. | |
| Returns: | |
| {type}`RunfilesBuilder` | |
| """ | |
| for t in targets: | |
| self.runfiles.append(t[DefaultInfo].default_runfiles) | |
| return self | |
| def _RunfilesBuilder_add_internal(self, value): | |
| if _is_file(value): | |
| self.files.add(value) | |
| elif types.is_depset(value): | |
| self.files.add(value) | |
| elif _is_runfiles(value): | |
| self.runfiles.append(value) | |
| else: | |
| fail("Unhandled value: type {}: {}".format(type(value), value)) | |
| def _RunfilesBuilder_build(self, ctx, **kwargs): | |
| """Creates a {obj}`runfiles` from the accumulated values. | |
| Args: | |
| self: {type}`RunfilesBuilder` implicitly added. | |
| ctx: {type}`ctx` The rule context to use to create the runfiles object. | |
| **kwargs: additional args to pass along to {obj}`ctx.runfiles`. | |
| Returns: | |
| {type}`runfiles` | |
| """ | |
| return ctx.runfiles( | |
| transitive_files = self.files.build(), | |
| symlinks = self.symlinks, | |
| root_symlinks = self.root_symlinks, | |
| **kwargs | |
| ).merge_all(self.runfiles) | |
| def _SetBuilder(initial = None): | |
| """Builder for list of unique values. | |
| Args: | |
| initial: {type}`list | None` The initial values. | |
| Returns: | |
| {type}`SetBuilder` | |
| """ | |
| initial = {} if not initial else {v: None for v in initial} | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| # TODO - Switch this to use set() builtin when available | |
| # https://bazel.build/rules/lib/core/set | |
| _values = initial, | |
| update = lambda *a, **k: _SetBuilder_update(self, *a, **k), | |
| build = lambda *a, **k: _SetBuilder_build(self, *a, **k), | |
| ) | |
| return self | |
| def _SetBuilder_build(self): | |
| """Builds the values into a list | |
| Returns: | |
| {type}`list` | |
| """ | |
| return self._values.keys() | |
| def _SetBuilder_update(self, *others): | |
| """Adds values to the builder. | |
| Args: | |
| self: implicitly added | |
| *others: {type}`list` values to add to the set. | |
| """ | |
| for other in others: | |
| for value in other: | |
| if value not in self._values: | |
| self._values[value] = None | |
| def _TransitionBuilder(implementation = None, inputs = None, outputs = None, **kwargs): | |
| """Builder for transition objects. | |
| Args: | |
| implementation: {type}`callable` the transition implementation function. | |
| inputs: {type}`list[str]` the inputs for the transition. | |
| outputs: {type}`list[str]` the outputs of the transition. | |
| **kwargs: Extra keyword args to use when building. | |
| Returns: | |
| {type}`TransitionBuilder` | |
| """ | |
| # buildifier: disable=uninitialized | |
| self = struct( | |
| implementation = _Optional(implementation), | |
| # Bazel requires transition.inputs to have unique values, so use set | |
| # semantics so extenders of a transition can easily add/remove values. | |
| # TODO - Use set builtin instead of custom builder, when available. | |
| # https://bazel.build/rules/lib/core/set | |
| inputs = _SetBuilder(inputs), | |
| # Bazel requires transition.inputs to have unique values, so use set | |
| # semantics so extenders of a transition can easily add/remove values. | |
| # TODO - Use set builtin instead of custom builder, when available. | |
| # https://bazel.build/rules/lib/core/set | |
| outputs = _SetBuilder(outputs), | |
| extra_kwargs = kwargs, | |
| build = lambda *a, **k: _TransitionBuilder_build(self, *a, **k), | |
| ) | |
| return self | |
| def _TransitionBuilder_build(self): | |
| """Creates a transition from the builder. | |
| Returns: | |
| {type}`transition` | |
| """ | |
| return transition( | |
| implementation = self.implementation.get(), | |
| inputs = self.inputs.build(), | |
| outputs = self.outputs.build(), | |
| **self.extra_kwargs | |
| ) | |
| # Skylib's types module doesn't have is_file, so roll our own | |
| def _is_file(value): | |
| return type(value) == "File" | |
| def _is_runfiles(value): | |
| return type(value) == "runfiles" | |
| builders = struct( | |
| DepsetBuilder = _DepsetBuilder, | |
| RunfilesBuilder = _RunfilesBuilder, | |
| RuleBuilder = _RuleBuilder, | |
| TransitionBuilder = _TransitionBuilder, | |
| SetBuilder = _SetBuilder, | |
| Optional = _Optional, | |
| ) |