ctx

Nightly · 9.0 · 8.5 · 8.4 · 8.3 · 8.2 · 7.7
Um objeto de contexto transmitido para a função de implementação de uma regra ou um aspecto. Ele dá acesso às informações e aos métodos necessários para analisar a meta atual.

Em particular, ela permite que a função de implementação acesse o rótulo, os atributos, a configuração e os provedores das dependências do destino atual. Ele tem métodos para declarar arquivos de saída e as ações que os produzem.

Os objetos de contexto existem 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.

Membros

actions

actions ctx.actions

Contém métodos para declarar arquivos de saída e as ações que os produzem.

aspect_ids

list ctx.aspect_ids

Uma lista de IDs de todos os aspectos aplicados ao destino. Disponível apenas em funções de implementação de aspectos.

attr

struct ctx.attr

Uma struct para acessar os valores dos atributos. Os valores são fornecidos pelo usuário. Caso contrário, um valor padrão é usado. Os atributos da struct e os tipos dos valores correspondem às chaves e aos valores do dicionário attrs fornecido à função rule. Veja um exemplo de uso.

bin_dir

root ctx.bin_dir

A raiz correspondente ao diretório bin.

build_file_path

string ctx.build_file_path

Descontinuado: use ctx.label.package + '/BUILD'. O caminho para o arquivo BUILD dessa regra, relativo à raiz de origem.

build_setting_value

unknown ctx.build_setting_value

Valor da configuração de build representada pelo destino atual. Se este não for o contexto de uma instância de uma regra que define o atributo build_setting, a leitura será um erro.

configuração

configuration ctx.configuration

A configuração de build do destino atual. Consulte o tipo de configuração do Starlark e a documentação de configuração para mais detalhes.

coverage_instrumented

bool ctx.coverage_instrumented(target=None)

Retorna se a instrumentação de cobertura de código precisa ser gerada ao realizar ações de compilação para essa regra ou, se target for fornecido, a regra especificada por essa meta. Se um destino de regra não Starlark ou não for uma regra for fornecido, isso vai retornar "False". Verifica se as origens da regra atual (se nenhum destino for fornecido) ou as origens do destino precisam ser instrumentadas com base nas configurações --instrumentation_filter e --instrument_test_targets. Isso é diferente de coverage_enabled na configuração, que observa se a coleta de dados de cobertura está ativada para toda a execução, mas não se um destino específico precisa ser instrumentado.

Parâmetros

Parâmetro Descrição
target Target ou None. O padrão é None
. Um destino que especifica uma regra. Se não for fornecido, o padrão será a regra atual.

created_actions

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ê precisará chamar essa função novamente se quiser inspecioná-las.

Isso ajuda a escrever testes para funções auxiliares de implementação de regras, que podem receber um objeto ctx e criar ações nele.

disabled_features

list ctx.disabled_features

O conjunto de recursos explicitamente desativados pelo usuário para essa regra.

exec_groups

ExecGroupCollection ctx.exec_groups

Uma coleção dos grupos de execução disponíveis para essa regra, indexados pelo nome. Acesse com ctx.exec_groups[name_of_group].

executável

struct ctx.executable

Um struct que contém arquivos executáveis definidos em atributos de tipo de rótulo marcados como executable=True. Os campos da 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 struct correspondente será None. Se um tipo de rótulo não estiver marcado como executable=True, nenhum campo de struct correspondente será gerado. Veja um exemplo de uso.

expand_location

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 rótulos que apontam para dependências diretas dessa regra ou que estão listados explicitamente no argumento opcional targets.

$(location ...) vai causar um erro se o destino referenciado tiver várias saídas. Nesse caso, use $(locations ...), porque ele produz uma lista de caminhos de saída separados por espaço. Ela também pode ser usada 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, geralmente é melhor manipular rótulos diretamente.

Parâmetros

Parâmetro Descrição
input string; required
String a ser expandida.
targets sequência de Targets; o padrão é []
Lista de destinos para mais informações de pesquisa. Eles são expandidos da seguinte maneira: um destino com um único arquivo em DefaultInfo.files é expandido para esse arquivo. Outras metas se expandem para o arquivo DefaultInfo.executable se definido e se --incompatible_locations_prefers_executable estiver ativado. Caso contrário, elas se expandem para DefaultInfo.files.
Pode retornar None.

expand_make_variables

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
            
            
                          string;
                                     required

                          The attribute name. Used for error reporting.
            		
          

                  

            
              command
            
            
                          string;
                                     required

                          The expression to expand. It can contain references to "Make variables".
            		
          

                  

            
              additional_substitutions
            
            
                          dict;
                                     required

                          Additional substitutions to make beyond the default make variables.
            		
          

                
      


        
features

        
list ctx.features


    The set of features that are explicitly enabled by the user for this rule. See example of use.

        
file

        
struct ctx.file


    A 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.files


    A 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.fragments


    Allows access to configuration fragments in target configuration.

        
genfiles_dir

        
root ctx.genfiles_dir


    The root corresponding to genfiles directory.

        
info_file

        
File ctx.info_file


    The 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.label


    The label of the target currently being analyzed.

        
outputs

        
structure ctx.outputs


    A 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 outputs dict, then for every entry in the dict, there is a field whose name is the key and whose value is the corresponding File.
  • For every attribute of type attr.output that 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 corresponding File; otherwise the field value is None.
  • For every attribute of type attr.output_list that the rule declares, there is a field whose name is the attribute's name. The field value is a list of File objects 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 executable or test, 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 the executable arg of DefaultInfo.


        
package_relative_label

        
Label ctx.package_relative_label(input)


    Converts the input string into a Label object, in the context of the package of the target currently being analyzed. If the input is already a Label, it is returned unchanged.
The result of this function is the same Label value as would be produced by passing the given string to a label-valued attribute of the rule and accessing the corresponding Label() é que Label() usa o contexto do pacote do arquivo .bzl que o chamou, e não o pacote do destino que está sendo analisado. Essa função tem o mesmo comportamento de 
native.package_relative_label(), que não pode ser usado em uma regra ou
função de implementação de aspecto.

                  
      
Parâmetros

      

        
          
          
        
        
          

            Parâmetro
            Descrição
          

        
        
                  

            
              input
            
            
                          string ou Label;
                                     required

                          A string de rótulo de entrada ou o objeto Label. Se um objeto de rótulo for transmitido, ele será retornado como está.
            		
          

                
      


        
resolve_command

        
tuple ctx.resolve_command(*, command='', attribute=None, expand_locations=False, make_variables=None, tools=[], label_dict={}, execution_requirements={})


    (Experimental) Retorna uma tupla (inputs, command, empty list) da lista de entradas resolvidas e a lista argv do comando resolvido, ambas adequadas para serem transmitidas como os argumentos de mesmo nome do método ctx.action.
Observação para usuários do Windows: esse método requer o Bash (MSYS2). Considere usar resolve_tools() (se isso atender às suas necessidades). A lista vazia é retornada como o terceiro membro da tupla para compatibilidade com versões anteriores.
                  
      
Parâmetros

      

        
          
          
        
        
          

            Parâmetro
            Descrição
          

        
        
                  

            
              command
            
            
                          string;
                                     o padrão é ''

                          Comando a ser resolvido.
            		
          

                  

            
              attribute
            
            
                          string ou None; o padrão é None
.
                          Nome do atributo associado para emitir um erro ou None.
            		
          

                  

            
              expand_locations
            
            
                          bool;
                                     o padrão é False

                          Vamos expandir as variáveis $(location)? Consulte ctx.expand_location() para mais detalhes.
            		
          

                  

            
              make_variables
            
            
                          dict ou None. O padrão é None
. Crie variáveis para expansão ou "None".
            		
          

                  

            
              tools
            
            
                          sequence de Targets;
                                     o padrão é []

                          Lista de ferramentas (lista de destinos).
            		
          

                  

            
              label_dict
            
            
                          dict;
                                     o padrão é {}

                          Dicionário de marcadores resolvidos e a lista correspondente de arquivos (um dicionário de marcador : lista de arquivos).
            		
          

                  

            
              execution_requirements
            
            
                          dict;
                                     o padrão é {}

                          Informações para programar a ação de resolver esse comando. Consulte tags para chaves úteis.
            		
          

                
      


        
resolve_tools

        
tuple ctx.resolve_tools(*, tools=[])


    Retorna uma tupla (inputs, empty list) do conjunto de entradas resolvidas necessárias para executar as ferramentas, adequada para ser transmitida como o argumento de mesmo nome dos métodos ctx.actions.run e ctx.actions.run_shell. 

Ao contrário de ctx.resolve_command, esse método não exige que o Bash seja instalado na máquina. Portanto, ele é adequado para regras criadas no Windows. A lista vazia é retornada como parte da tupla para compatibilidade com versões anteriores.
                  
      
Parâmetros

      

        
          
          
        
        
          

            Parâmetro
            Descrição
          

        
        
                  

            
              tools
            
            
                          sequence de Targets;
                                     o padrão é []

                          Lista de ferramentas (lista de destinos).
            		
          

                
      


        
regra

        
rule_attributes ctx.rule


    Descritor de atributos da regra a que o aspecto é aplicado. Disponível apenas em funções de implementação de aspectos.

        
runfiles

        
runfiles ctx.runfiles(files=[], transitive_files=None, collect_data=False, collect_default=False, symlinks={}, root_symlinks={})


    Cria um objeto runfiles.
                  
      
Parâmetros

      

        
          
          
        
        
          

            Parâmetro
            Descrição
          

        
        
                  

            
              files
            
            
                          sequência de Files;
                                     o padrão é []

                          A lista de arquivos a serem adicionados aos runfiles.
            		
          

                  

            
              transitive_files
            
            
                          depset de Files ou None. O padrão é None
. O conjunto (transitivo) de arquivos a serem adicionados aos runfiles. O depset precisa usar a ordem default, que, como o nome sugere, é a padrão.
            		
          

                  

            
              collect_data
            
            
                          bool;
                                     o padrão é False

                          Não é recomendável usar esse parâmetro. Consulte o guia de arquivos de execução. 
Se os runfiles de dados devem ser coletados das dependências nos atributos srcs, data e deps.
            

          

                  

            
              collect_default
            
            
                          bool;
                                     o padrão é False

                          Não é recomendável usar esse parâmetro. Consulte o guia de arquivos de execução. 
Se é necessário coletar os runfiles padrão das dependências nos atributos "srcs", "data" e "deps".
            

          

                  

            
            
                          dict ou depset de SymlinkEntrys;
                                     o padrão é {}

                          Um conjunto de dependências SymlinkEntry ou o mapa de links simbólicos a serem adicionados aos runfiles. Os links simbólicos são sempre adicionados ao diretório runfiles do espaço de trabalho principal (por exemplo, <runfiles_root>/_main/<symlink_path>, não o diretório correspondente ao repositório do destino atual). Consulte Links simbólicos de runfiles no guia de regras.
            		
          

                  

            
            
                          dict ou depset de SymlinkEntrys;
                                     o padrão é {}

                          Um depset SymlinkEntry ou um mapa de links simbólicos a serem adicionados aos runfiles. Consulte Links simbólicos de runfiles no guia de regras.
            		
          

                
      


        
split_attr

        
struct ctx.split_attr


    Uma struct para acessar os valores de atributos com configurações divididas. Se o atributo for uma lista de rótulos, o valor de "split_attr" será um dict das chaves da divisão (como strings) para listas de ConfiguredTargets nessa ramificação da divisão. Se o atributo for um rótulo, o valor de "split_attr" será um dict das chaves da divisão (como strings) para ConfiguredTargets únicos. Os atributos com configurações divididas ainda aparecem na estrutura "attr", mas os valores deles serão listas únicas com todas as ramificações da divisão mescladas.

        
super

        
unknown ctx.super()


    Experimental: chama a função de implementação do pai e retorna os provedores dela.

        
target_platform_has_constraint

        
bool ctx.target_platform_has_constraint(constraintValue)


    Retorna "true" se o valor da restrição especificada fizer parte da plataforma de destino atual.
                  
      
Parâmetros

      

        
          
          
        
        
          

            Parâmetro
            Descrição
          

        
        
                  

            
              constraintValue
            
            
                          ConstraintValueInfo;
                                     required

                          O valor da restrição para verificar a plataforma de destino.
            		
          

                
      


        
de ferramentas para segurança.

        
ToolchainContext ctx.toolchains


    Toolchains para o grupo de execução padrão desta regra.

        
var

        
dict ctx.var


    Dicionário (string para string) de variáveis de configuração.

        
version_file

        
File ctx.version_file


    O arquivo usado para manter o status volátil do espaço de trabalho para a solicitação de build atual. Consulte a documentação de --workspace_status_command para mais informações.

        
workspace_name

        
string ctx.workspace_name


    O nome do espaço de trabalho, que é efetivamente o nome da raiz de execução e o prefixo de runfiles do repositório principal. Se --enable_bzlmod estiver ativado, será a string fixa _main. Caso contrário, esse é o nome do espaço de trabalho definido no arquivo WORKSPACE.