Ejemplos de rules en Python

Ejemplo n.º 1

Archivo: register.py Proyecto: codealchemy/pants

def rules():
    return [
        *assembly.rules(),
        *build_pkg.rules(),
        *build_pkg_target.rules(),
        *check.rules(),
        *third_party_pkg.rules(),
        *golang.rules(),
        *import_analysis.rules(),
        *go_mod.rules(),
        *first_party_pkg.rules(),
        *link.rules(),
        *pkg_analyzer.rules(),
        *sdk.rules(),
        *tests_analysis.rules(),
        *tailor.rules(),
        *target_type_rules.rules(),
        *test.rules(),
        *run_binary.rules(),
        *package_binary.rules(),
        *load_go_binary.rules(),
        # Gofmt
        *gofmt_rules(),
        *gofmt_skip_field.rules(),
    ]

Ejemplo n.º 2

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *external_tool.rules(),
            *sdk.rules(),
            *import_analysis.rules(),
            QueryRule(GoStdLibImports, []),
        ],
    )
    return rule_runner

Ejemplo n.º 3

def rules():
    return (
        *collect_rules(),
        *first_party_pkg.rules(),
        *import_analysis.rules(),
        UnionRule(InferDependenciesRequest, InferGoPackageDependenciesRequest),
        UnionRule(InjectDependenciesRequest, InjectGoThirdPartyPackageDependenciesRequest),
        UnionRule(InjectDependenciesRequest, InjectGoBinaryMainDependencyRequest),
        UnionRule(GenerateTargetsRequest, GenerateTargetsFromGoModRequest),
    )

Ejemplo n.º 4

Archivo: import_analysis_test.py Proyecto: hephex/pants

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *import_analysis.rules(),
            QueryRule(GoStdLibImports, []),
            QueryRule(ImportConfig, [ImportConfigRequest]),
        ],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 5

Archivo: target_type_rules.py Proyecto: patricklaw/pants

def rules():
    return (
        *collect_rules(),
        *go_pkg.rules(),
        *import_analysis.rules(),
        UnionRule(InjectDependenciesRequest,
                  InjectGoPackageDependenciesRequest),
        UnionRule(InferDependenciesRequest, InferGoPackageDependenciesRequest),
        UnionRule(InjectDependenciesRequest,
                  InjectGoExternalPackageDependenciesRequest),
        UnionRule(GenerateTargetsRequest,
                  GenerateGoExternalPackageTargetsRequest),
    )

Ejemplo n.º 6

Archivo: tests_analysis_test.py Proyecto: hephex/pants

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(rules=[
        *assembly.rules(),
        *build_pkg.rules(),
        *import_analysis.rules(),
        *go_mod.rules(),
        *first_party_pkg.rules(),
        *third_party_pkg.rules(),
        *tests_analysis.rules(),
        *link.rules(),
        *sdk.rules(),
        QueryRule(GeneratedTestMain, [GenerateTestMainRequest]),
    ], )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 7

def rules():
    return [
        *assembly.rules(),
        *build_go_pkg.rules(),
        *external_module.rules(),
        *golang.rules(),
        *go_target_types.rules(),
        *import_analysis.rules(),
        *go_mod.rules(),
        *go_pkg.rules(),
        *sdk.rules(),
        *tailor.rules(),
        *target_type_rules.rules(),
        *custom_goals.rules(),
        *package_binary.rules(),
    ]

Ejemplo n.º 8

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[GoBinary, GoPackage, GoModule],
        rules=[
            *external_tool.rules(),
            *assembly.rules(),
            *source_files.rules(),
            *import_analysis.rules(),
            *package_binary.rules(),
            *build_go_pkg.rules(),
            *go_pkg.rules(),
            *go_mod.rules(),
            *target_type_rules.rules(),
            *external_module.rules(),
            *sdk.rules(),
            QueryRule(BuiltPackage, (GoBinaryFieldSet, )),
        ],
    )

Ejemplo n.º 9

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *import_analysis.rules(),
            *go_mod.rules(),
            *first_party_pkg.rules(),
            *link.rules(),
            *third_party_pkg.rules(),
            *target_type_rules.rules(),
            QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
        ],
        target_types=[GoModTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 10

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *external_tool.rules(),
            *source_files.rules(),
            *sdk.rules(),
            *assembly.rules(),
            *build_go_pkg.rules(),
            *import_analysis.rules(),
            *go_mod.rules(),
            *go_pkg.rules(),
            *external_module.rules(),
            *target_type_rules.rules(),
            QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
        ],
        target_types=[GoPackage, GoModule, GoExternalPackageTarget],
    )
    rule_runner.set_options(
        ["--backend-packages=pants.backend.experimental.go"])
    return rule_runner

Ejemplo n.º 11

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *check.rules(),
            *sdk.rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *import_analysis.rules(),
            *link.rules(),
            *go_mod.rules(),
            *first_party_pkg.rules(),
            *third_party_pkg.rules(),
            *target_type_rules.rules(),
            QueryRule(CheckResults, [GoCheckRequest]),
        ],
        target_types=[GoModTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 12

Archivo: package_binary_integration_test.py Proyecto: hephex/pants

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *assembly.rules(),
            *import_analysis.rules(),
            *package_binary.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *first_party_pkg.rules(),
            *go_mod.rules(),
            *link.rules(),
            *target_type_rules.rules(),
            *third_party_pkg.rules(),
            *sdk.rules(),
            QueryRule(BuiltPackage, (GoBinaryFieldSet,)),
        ],
        target_types=[GoBinaryTarget, GoModTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 13

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *third_party_pkg.rules(),
            *first_party_pkg.rules(),
            *load_go_binary.rules(),
            *build_pkg.rules(),
            *import_analysis.rules(),
            *link.rules(),
            *assembly.rules(),
            *target_type_rules.rules(),
            *go_mod.rules(),
            QueryRule(AllThirdPartyPackages, [AllThirdPartyPackagesRequest]),
            QueryRule(ThirdPartyPkgAnalysis, [ThirdPartyPkgAnalysisRequest]),
        ],
        target_types=[GoModTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 14

Archivo: rules_integration_test.py Proyecto: codealchemy/pants

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        target_types=[GoModTarget, GoPackageTarget],
        rules=[
            *skip_field.rules(),
            *go_vet_rules(),
            *source_files.rules(),
            *target_type_rules.rules(),
            *first_party_pkg.rules(),
            *third_party_pkg.rules(),
            *sdk.rules(),
            *go_mod.rules(),
            *import_analysis.rules(),
            *link.rules(),
            *build_pkg.rules(),
            *assembly.rules(),
            QueryRule(LintResults, (GoVetRequest, )),
            SubsystemRule(GoVetSubsystem),
        ],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner

Ejemplo n.º 15

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *import_analysis.rules(),
            *link.rules(),
            *go_mod.rules(),
            *first_party_pkg.rules(),
            *third_party_pkg.rules(),
            *target_type_rules.rules(),
            generate_from_file,
            QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(BuildGoPackageRequest, [BuildGoPackageTargetRequest]),
            QueryRule(FallibleBuildGoPackageRequest, [BuildGoPackageTargetRequest]),
            UnionRule(GoCodegenBuildRequest, GoCodegenBuildFilesRequest),
        ],
        target_types=[GoModTarget, GoPackageTarget, FilesGeneratorTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner