public BuildRule createBuildRule()

in src/com/facebook/buck/features/go/GoTestDescription.java [201:388]
170 lines of code
6 McCabe index (conditional complexity)

  public BuildRule createBuildRule(
      BuildRuleCreationContextWithTargetGraph context,
      BuildTarget buildTarget,
      BuildRuleParams params,
      GoTestDescriptionArg args) {
    GoPlatform platform =
        GoDescriptors.getPlatformForRule(
            getGoToolchain(buildTarget.getTargetConfiguration()),
            this.goBuckConfig,
            buildTarget,
            args);

    ActionGraphBuilder graphBuilder = context.getActionGraphBuilder();
    ProjectFilesystem projectFilesystem = context.getProjectFilesystem();

    GoTestCoverStep.Mode coverageMode;
    ImmutableSortedSet.Builder<BuildRule> extraDeps = ImmutableSortedSet.naturalOrder();
    ImmutableSet.Builder<SourcePath> srcs;
    ImmutableMap<String, Path> coverVariables;

    ImmutableSet.Builder<SourcePath> rawSrcs = ImmutableSet.builder();
    rawSrcs.addAll(args.getSrcs());
    if (args.getLibrary().isPresent()) {
      GoLibraryDescriptionArg libraryArg =
          graphBuilder
              .requireMetadata(args.getLibrary().get(), GoLibraryDescriptionArg.class)
              .get();

      rawSrcs.addAll(libraryArg.getSrcs());
    }
    if (args.getCoverageMode().isPresent()) {
      coverageMode = args.getCoverageMode().get();
      GoTestCoverStep.Mode coverage = coverageMode;

      GoTestCoverSource coverSource =
          (GoTestCoverSource)
              graphBuilder.computeIfAbsent(
                  buildTarget.withAppendedFlavors(InternalFlavor.of("gen-cover")),
                  target ->
                      new GoTestCoverSource(
                          target,
                          projectFilesystem,
                          graphBuilder,
                          platform,
                          rawSrcs.build(),
                          platform.getCover(),
                          coverage));

      coverVariables = coverSource.getVariables();
      srcs = ImmutableSet.builder();
      srcs.addAll(coverSource.getCoveredSources()).addAll(coverSource.getTestSources());
      extraDeps.add(coverSource);
    } else {
      srcs = rawSrcs;
      coverVariables = ImmutableMap.of();
      coverageMode = GoTestCoverStep.Mode.NONE;
    }

    if (buildTarget.getFlavors().contains(TEST_LIBRARY_FLAVOR)) {
      return createTestLibrary(
          buildTarget,
          projectFilesystem,
          params.copyAppendingExtraDeps(extraDeps.build()),
          graphBuilder,
          srcs.build(),
          args,
          platform);
    }

    Path packageName = getGoPackageName(graphBuilder, buildTarget, args);

    params = params.copyAppendingExtraDeps(extraDeps.build());

    GoBinary testMain;
    GoTestMain generatedTestMain;
    if (args.getSpecs().isPresent()) {
      UserVerify.checkArgument(
          args.getRunner().isPresent(),
          "runner should be specified for rules implementing test protocol");

      BuildRule runner = graphBuilder.requireRule(args.getRunner().get());
      UserVerify.verify(
          runner instanceof GoTestRunner, "runner should be a go_test_runner for go_test");
      GoTestRunner testRunner = (GoTestRunner) runner;

      BuildRuleParams generatorParams = params.withoutDeclaredDeps().withoutExtraDeps();
      GoBinary testMainGeneratorRule =
          (GoBinary)
              graphBuilder.computeIfAbsent(
                  buildTarget.withFlavors(InternalFlavor.of("make-test-main-gen")),
                  target ->
                      GoDescriptors.createGoBinaryRule(
                          target,
                          projectFilesystem,
                          generatorParams,
                          graphBuilder,
                          goBuckConfig,
                          Linker.LinkableDepType.STATIC_PIC,
                          Optional.empty(),
                          ImmutableSet.of(testRunner.getTestRunnerGenerator()),
                          ImmutableSortedSet.of(),
                          ImmutableList.of(),
                          ImmutableList.of(),
                          ImmutableList.of(),
                          ImmutableList.of(),
                          platform));

      Tool testMainGenerator =
          testMainGeneratorRule.getExecutableCommand(OutputLabel.defaultLabel());

      generatedTestMain =
          new GoTestMain(
              buildTarget.withAppendedFlavors(InternalFlavor.of("test-main-src")),
              projectFilesystem,
              params.withDeclaredDeps(
                  ImmutableSortedSet.<BuildRule>naturalOrder()
                      .addAll(BuildableSupport.getDepsCollection(testMainGenerator, graphBuilder))
                      .build()),
              testMainGenerator,
              srcs.build(),
              packageName,
              platform,
              ImmutableMap.of(packageName, coverVariables),
              coverageMode);
      graphBuilder.addToIndex(generatedTestMain);
    } else {
      generatedTestMain =
          requireTestMainGenRule(
              buildTarget,
              projectFilesystem,
              params,
              graphBuilder,
              platform,
              srcs.build(),
              ImmutableMap.of(packageName, coverVariables),
              coverageMode,
              packageName);
    }

    testMain =
        createTestMainRule(
            buildTarget,
            projectFilesystem,
            params,
            graphBuilder,
            args,
            platform,
            generatedTestMain);

    graphBuilder.addToIndex(testMain);

    StringWithMacrosConverter macrosConverter =
        StringWithMacrosConverter.of(
            buildTarget,
            context.getCellPathResolver().getCellNameResolver(),
            graphBuilder,
            MACRO_EXPANDERS);

    if (args.getSpecs().isPresent()) {
      return new GoTestX(
          buildTarget,
          projectFilesystem,
          params.withDeclaredDeps(ImmutableSortedSet.of(testMain)).withoutExtraDeps(),
          testMain,
          args.getLabels(),
          args.getContacts(),
          TestRunnerSpecCoercer.coerce(args.getSpecs().get(), macrosConverter),
          args.getResources());
    }
    return new GoTest(
        buildTarget,
        projectFilesystem,
        params.withDeclaredDeps(ImmutableSortedSet.of(testMain)).withoutExtraDeps(),
        testMain,
        args.getLabels(),
        args.getContacts(),
        args.getTestRuleTimeoutMs()
            .map(Optional::of)
            .orElse(
                goBuckConfig
                    .getDelegate()
                    .getView(TestBuckConfig.class)
                    .getDefaultTestRuleTimeoutMs()),
        ImmutableMap.copyOf(Maps.transformValues(args.getEnv(), macrosConverter::convert)),
        args.getRunTestSeparately(),
        args.getResources(),
        coverageMode);
  }