Em particular, ele permite que a função de implementação acesse o rótulo, os atributos, a configuração e os provedores do destino das dependências atuais. Ela tem métodos para declarar arquivos de saída e as ações que os produzem.
Os objetos de contexto basicamente funcionam durante a chamada para a função de implementação. Não é útil acessar esses objetos fora da função associada. Consulte a página Regras para mais informações.
Participantes
- ações
- aspect_ids (em inglês)
- atraente
- bin_dir (em inglês)
- build_file_path (em inglês)
- build_setting_value (em inglês)
- configuração
- coverage_instrumented (em inglês)
- created_actions
- default_provider (em inglês)
- disabled_features
- grupos_executivos
- executável
- expand_location (em inglês)
- expand_make_variables (em inglês)
- recursos
- file
- arquivos
- fragmentos
- genfiles_dir (em inglês)
- arquivo de informações
- label
- novo_arquivo
- saídas
- resolve_command (em inglês)
- resolve_tools (em inglês)
- regra
- runfiles (em inglês)
- split_attr (em inglês)
- target_platform_has_constraint (em inglês)
- conjuntos de ferramentas
- var
- version_file (em inglês)
- workspace_name (em inglês)
corretivas
actions ctx.actionsContém métodos para declarar arquivos de saída e as ações que os produzem.
id_do_aspecto
list ctx.aspect_idsUma lista de códigos para todos os aspectos aplicados à segmentação. Disponível apenas em funções de implementação de aspectos.
attr
struct ctx.attrUma estrutura para acessar os valores dos atributos. Os valores são fornecidos pelo usuário (se não forem, um valor padrão será usado). Os atributos da estrutura e os tipos de seus valores correspondem às chaves e aos valores do dict
attrs fornecido para a função rule. Veja um exemplo de uso.
bin_dir
root ctx.bin_dirA raiz correspondente ao diretório bin.
caminho_do_arquivo_de_criação
string ctx.build_file_pathO caminho para o arquivo BUILD dessa regra, relativo à raiz da origem.
valor_da_configuração_da_criação
unknown ctx.build_setting_valueExperimental. Este campo é experimental e está sujeito a alterações a qualquer momento. Não dependa disso.
O valor da configuração da compilação representada pelo destino atual. É um erro acessar este campo para regras que não definem o atributo build_setting na definição delas.
configuração
configuration ctx.configurationA configuração padrão. Consulte o tipo de configuração para mais detalhes.
cobertura_instrumentado
bool ctx.coverage_instrumented(target=None)Retorna se a instrumentação de cobertura de código deve ser gerada ao realizar ações de compilação para essa regra ou, se
target for fornecida, a regra especificada por essa meta. Se for fornecido um destino de regra não regra ou Starlark, será retornado False. Verifica se as origens da regra atual (se nenhum destino for fornecido) ou as origens do destino devem ser instrumentadas com base nas configurações de --instrumentation_filter e --instrument_test_targets. Isso é diferente de coverage_enabled na configuração, que indica se a coleta de dados de cobertura está ativada em toda a execução, mas não se um destino específico deve ser instrumentado.
Parâmetros
| Parâmetro | Descrição |
|---|---|
target
|
Target; or None;
default = NoneUm destino que especifica uma regra. Se não for fornecido, o padrão será a regra atual. |
ações_criadas
StarlarkValue ctx.created_actions()Para regras com _skylark_testable definido como
True, isso retorna um provedor Actions que representa todas as ações criadas até o momento para a regra atual. Para todas as outras regras, retorna None. O provedor não é atualizado quando ações subsequentes são criadas. Portanto, você terá que chamar essa função novamente se quiser inspecioná-las. Isso serve para ajudar a criar testes para funções auxiliares de implementação de regras, que podem usar um objeto
ctx e criar ações nele.
provedor_padrão
Provider ctx.default_providerObsoleto. Use DefaultInfo, em vez disso.
recursos_desativados
list ctx.disabled_featuresO conjunto de recursos que foram explicitamente desativados pelo usuário para esta regra.
grupos_executivos
ExecGroupCollection ctx.exec_groupsUma coleção dos grupos de execução disponíveis para essa regra, indexados pelo nome deles. Acesso com
ctx.exec_groups[name_of_group].
Executável
struct ctx.executableUm
struct contendo arquivos executáveis definidos em atributos de tipo de rótulo marcados como executable=True. Os campos struct correspondem aos nomes dos atributos. Cada valor na estrutura é um File ou None. Se um atributo opcional não for especificado na regra, o valor da estrutura correspondente será None. Se um tipo de rótulo não estiver marcado como executable=True, nenhum campo de estrutura correspondente será gerado. Veja um exemplo de uso.
expandir_local
string ctx.expand_location(input, targets=[])Expande todos os modelos
$(location ...) na string especificada, substituindo $(location //x) pelo caminho do arquivo de saída do destino //x. A expansão só funciona para marcadores que apontam para dependências diretas desta regra ou que estejam explicitamente listadas no argumento opcional targets. $(location ...) causará um erro se o destino referenciado tiver várias saídas. Nesse caso, use $(locations ...), já que ele produz uma lista separada de espaços dos caminhos de saída. Também pode ser usado com segurança para um único arquivo de saída.Essa função é útil para permitir que o usuário especifique um comando em um arquivo BUILD (como para
genrule). Em outros casos, muitas vezes é melhor manipular os rótulos diretamente.
Parâmetros
| Parâmetro | Descrição |
|---|---|
input
|
obrigatória String a ser expandida. |
targets
|
sequence of Targets;
default = []Lista de destinos para informações de pesquisa adicionais. |
None.
expandir_criar_variáveis
string ctx.expand_make_variables(attribute_name, command, additional_substitutions)Obsoleto. Use ctx.var para acessar as variáveis.
Retorna uma string depois de expandir todas as referências a "Criar variáveis". As variáveis precisam ter o seguinte formato:
$(VAR_NAME). Além disso, $$VAR_NAME expands to $VAR_NAME. Examples:
ctx.expand_make_variables("cmd", "$(MY_VAR)", {"MY_VAR": "Hi"}) # == "Hi"
ctx.expand_make_variables("cmd", "$$PWD", {}) # == "$PWD"
Additional variables may come from other places, such as configurations. Note that this function is experimental.
Parameters
| Parameter | Description |
|---|---|
attribute_name
|
required The attribute name. Used for error reporting. |
command
|
required The expression to expand. It can contain references to "Make variables". |
additional_substitutions
|
required Additional substitutions to make beyond the default make variables. |
features
list ctx.featuresThe set of features that are explicitly enabled by the user for this rule. See example of use.
file
struct ctx.fileA
struct containing files defined in label type attributes marked as allow_single_file. The struct fields correspond to the attribute names. The struct value is always a File or None. If an optional attribute is not specified in the rule then the corresponding struct value is None. If a label type is not marked as allow_single_file, no corresponding struct field is generated. It is a shortcut for:list(ctx.attr.<ATTR>.files)[0]In other words, use
file to access the (singular) default output of a dependency. See example of use.
files
struct ctx.filesA
struct containing files defined in label or label list type attributes. The struct fields correspond to the attribute names. The struct values are list of Files. It is a shortcut for:[f for t in ctx.attr.<ATTR> for f in t.files]In other words, use
files to access the default outputs of a dependency. See example of use.
fragments
fragments ctx.fragmentsAllows access to configuration fragments in target configuration.
genfiles_dir
root ctx.genfiles_dirThe root corresponding to genfiles directory.
info_file
File ctx.info_fileThe file that is used to hold the non-volatile workspace status for the current build request. See documentation for --workspace_status_command for more information.
label
Label ctx.labelThe label of the target currently being analyzed.
new_file
File ctx.new_file(var1, var2=unbound, var3=unbound)DEPRECATED. Use ctx.actions.declare_file.
Creates a file object. There are four possible signatures to this method:
- new_file(filename): Creates a file object with the given filename in the current package.
- new_file(file_root, filename): Creates a file object with the given filename under the given file root.
- new_file(sibling_file, filename): Creates a file object in the same directory as the given sibling file.
- new_file(file_root, sibling_file, suffix): Creates a file object with same base name of the sibling_file but with different given suffix, under the given file root.
Does not actually create a file on the file system, just declares that some action will do so. You must create an action that generates the file. If the file should be visible to other rules, declare a rule output instead when possible. Doing so enables Blaze to associate a label with the file that rules can refer to (allowing finer dependency control) instead of referencing the whole rule.
Parameters
| Parameter | Description |
|---|---|
var1
|
string; or root; or File;
required |
var2
|
string; or File;
default = unbound |
var3
|
string;
default = unbound |
outputs
structure ctx.outputsA pseudo-struct containing all the predeclared output files, represented by
File objects. See the Rules page for more information and examples.This field does not exist on aspect contexts, since aspects do not have predeclared outputs.
The fields of this object are defined as follows. It is an error if two outputs produce the same field name or have the same label.
- If the rule declares an
outputsdict, then for every entry in the dict, there is a field whose name is the key and whose value is the correspondingFile. - For every attribute of type
attr.outputthat the rule declares, there is a field whose name is the attribute's name. If the target specified a label for that attribute, then the field value is the correspondingFile; otherwise the field value isNone. - For every attribute of type
attr.output_listthat the rule declares, there is a field whose name is the attribute's name. The field value is a list ofFileobjects corresponding to the labels given for that attribute in the target, or an empty list if the attribute was not specified in the target. - (Deprecated) If the rule is marked
executableortest, there is a field named"executable", which is the default executable. It is recommended that instead of using this, you pass another file (either predeclared or not) to theexecutablearg ofDefaultInfo.
resolve_command
tuple ctx.resolve_command(command='', attribute=None, expand_locations=False, make_variables=None, tools=[], label_dict={}, execution_requirements={})(Experimental) Returns a tuple
(inputs, command, input_manifests) of the list of resolved inputs, the argv list for the resolved command, and the runfiles metadata required to run the command, all of them suitable for passing as the same-named arguments of the ctx.action method.Note for Windows users: this method requires Bash (MSYS2). Consider using
resolve_tools() instead (if that fits your needs).
Parameters
| Parameter | Description |
|---|---|
command
|
default = '' Command to resolve. |
attribute
|
string; or None;
default = NoneName of the associated attribute for which to issue an error, or None. |
expand_locations
|
default = False Shall we expand $(location) variables? See ctx.expand_location() for more details. |
make_variables
|
dict; or None;
default = NoneMake variables to expand, or None. |
tools
|
sequence of Targets;
default = []List of tools (list of targets). |
label_dict
|
default = {} Dictionary of resolved labels and the corresponding list of Files (a dict of Label : list of Files). |
execution_requirements
|
default = {} Information for scheduling the action to resolve this command. See tags for useful keys. |
resolve_tools
tuple ctx.resolve_tools(tools=[])Returns a tuple
(inputs, input_manifests) of the depset of resolved inputs and the runfiles metadata required to run the tools, both of them suitable for passing as the same-named arguments of the ctx.actions.run method.In contrast to
ctx.resolve_command, this method does not require that Bash be installed on the machine, so it's suitable for rules built on Windows.
Parameters
| Parameter | Description |
|---|---|
tools
|
sequence of Targets;
default = []List of tools (list of targets). |
rule
rule_attributes ctx.ruleRule attributes descriptor for the rule that the aspect is applied to. Only available in aspect implementation functions.
runfiles
runfiles ctx.runfiles(files=[], transitive_files=None, collect_data=False, collect_default=False, symlinks={}, root_symlinks={})Creates a runfiles object.
Parameters
| Parameter | Description |
|---|---|
files
|
sequence of Files;
default = []The list of files to be added to the runfiles. |
transitive_files
|
depset of Files; or None;
default = NoneThe (transitive) set of files to be added to the runfiles. The depset should use the default order (which, as the name implies, is the default).
|
collect_data
|
default = False Use of this parameter is not recommended. See runfiles guide. Whether to collect the data runfiles from the dependencies in srcs, data and deps attributes. |
collect_default
|
default = False Use of this parameter is not recommended. See runfiles guide. Whether to collect the default runfiles from the dependencies in srcs, data and deps attributes. |
symlinks
|
dict; or depset of SymlinkEntrys;
default = {}Either a SymlinkEntry depset or the map of symlinks, prefixed by workspace name, to be added to the runfiles. See Runfiles symlinks in the rules guide. |
root_symlinks
|
dict; or depset of SymlinkEntrys;
default = {}Either a SymlinkEntry depset or a map of symlinks to be added to the runfiles. See Runfiles symlinks in the rules guide. |
split_attr
struct ctx.split_attrA struct to access the values of attributes with split configurations. If the attribute is a label list, the value of split_attr is a dict of the keys of the split (as strings) to lists of the ConfiguredTargets in that branch of the split. If the attribute is a label, then the value of split_attr is a dict of the keys of the split (as strings) to single ConfiguredTargets. Attributes with split configurations still appear in the attr struct, but their values will be single lists with all the branches of the split merged together.
target_platform_has_constraint
bool ctx.target_platform_has_constraint(constraintValue)Returns true if the given constraint value is part of the current target platform.
Parameters
| Parameter | Description |
|---|---|
constraintValue
|
required The constraint value to check the target platform against. |
toolchains
ToolchainContext ctx.toolchainsToolchains for the default exec group of this rule.
var
dict ctx.varDictionary (String to String) of configuration variables.
version_file
File ctx.version_fileThe file that is used to hold the volatile workspace status for the current build request. See documentation for --workspace_status_command for more information.
workspace_name
string ctx.workspace_nameThe workspace name as defined in the WORKSPACE file.