How to use org.guvnor.ala.pipeline

@Override
public Pipeline buildAs(final String name) {
  return new BasePipeline(name,
              stages);
}

public ConfigBasedPipelineImpl(PipelineConfig config) {
  setName(config.getName());
  setStages(buildStages(config));
  this.config = config;
}

  private List<Stage> buildStages(PipelineConfig config) {
    List<Stage> stages = new ArrayList<>();
    for (final PipelineConfigStage configStage : config.getConfigStages()) {
      stages.add(StageUtil.config(configStage.getName(),
                    f -> configStage.getConfig()));
    }
    return stages;
  }
}

/**
 * @return the Pipeline input for an incremental build for one resource.
 */
public static Input createIncrementalBuildInput( String rootPathUri,
                         String resourceUri,
                         String buildType ) {
  Input input = new Input();
  input.put( LocalSourceConfig.ROOT_PATH, rootPathUri );
  input.put( LocalBuildConfig.RESOURCE, resourceUri );
  input.put( LocalBuildConfig.BUILD_TYPE, buildType );
  return input;
}

@Test
public void testNewBuilder() {
  ConfigBasedPipelineBuilder builder = PipelineFactory.newBuilder();
  for (int i = 0; i < CONFIG_COUNT; i++) {
    builder.addConfigStage(mockConfigStageName(i),
                configs.get(i));
  }
  ConfigBasedPipeline result = builder.buildAs(PIPELINE_NAME);
  assertPipelineIsTheExpected(result);
}

private PipelineExecutorTaskDefImpl(final Pipeline pipeline) {
  this.pipeline = pipeline.getName();
  pipeline.getStages().forEach(stage -> stages.add(stage.getName()));
}

  private Pipeline createDummyPipeline(String pipelineName) {
    final GitConfig gitConfig = new GitConfigImpl();
    final Pipeline pipeline = PipelineFactory
        .newBuilder()
        .addConfigStage("GigConfig",
              gitConfig)
        .buildAs(pipelineName);

    return pipeline;
  }
}

  @Override
  public Pipeline build(final PipelineConfig config) {
    stages.clear();
    for (final Config c : config.getConfigStages()) {
      stages.add(StageUtil.config(c.toString(),
                    f -> c));
    }
    return new BasePipeline(config.getName(),
                stages,
                config);
  }
};

private void assertPipelineIsTheExpected(ConfigBasedPipeline pipeline) {
  assertEquals(PIPELINE_NAME,
         pipeline.getName());
  assertNotNull(pipeline.getConfig());
  PipelineConfig pipelineConfig = pipeline.getConfig();
  assertEquals(PIPELINE_NAME,
         pipelineConfig.getName());
  List<PipelineConfigStage> configStages = pipelineConfig.getConfigStages();
  assertEquals(CONFIG_COUNT,
         configStages.size());
  for (int i = 0; i < CONFIG_COUNT; i++) {
    PipelineConfigStage configStage = configStages.get(i);
    assertEquals(mockConfigStageName(i),
           configStage.getName());
    assertEquals(configs.get(i),
           configStage.getConfig());
  }
}

@Override
public String newPipeline(PipelineConfig config) throws BusinessException {
  final Pipeline pipeline = PipelineFactory.startFrom(null).build(config);
  pipelineRegistry.registerPipeline(pipeline);
  return config.getName();
}

@Test
public void testNewPipeline() {
  List<PipelineConfigStage> configStages = new ArrayList<>();
  for (int i = 0; i < CONFIG_COUNT; i++) {
    configStages.add(new PipelineConfigStage(mockConfigStageName(i),
                         configs.get(i)));
  }
  PipelineConfigImpl pipelineConfig = new PipelineConfigImpl(PIPELINE_NAME,
                                configStages);
  ConfigBasedPipeline result = PipelineFactory.newPipeline(pipelineConfig);
  assertPipelineIsTheExpected(result);
}

  public static <T extends Config> Stage<T, T> identity() {
    return config("Identity",
           Function.identity());
  }
}

public void init(final Collection<ConfigExecutor> configExecutors) {
  for (final ConfigExecutor configExecutor : configExecutors) {
    this.configExecutors.put(configExecutor.executeFor(),
                 configExecutor);
  }
}

/**
 * @return the Pipeline input for a project full build.
 */
public static Input createFullBuildInput( String rootPathUri ) {
  Input input = new Input();
  input.put( LocalSourceConfig.ROOT_PATH, rootPathUri );
  input.put( LocalBuildConfig.BUILD_TYPE, LocalBuildConfig.BuildType.FULL_BUILD.name( ) );
  return input;
}

private PipelineExecutorTaskDefImpl(final Pipeline pipeline) {
  this.pipeline = pipeline.getName();
  pipeline.getStages().forEach(stage -> stages.add(stage.getName()));
}

@Override
public String newPipeline(PipelineConfig config,
             ProviderType providerType) throws BusinessException {
  final Pipeline pipeline = PipelineFactory.startFrom(null).build(config);
  pipelineRegistry.registerPipeline(pipeline,
                   providerType);
  return config.getName();
}

public static <OUTPUT extends Config> Stage<?, OUTPUT> config(final String name,
                               final Supplier<OUTPUT> s) {
  return config(name,
         ignore -> s.get());
}

public void init(final Collection<ConfigExecutor> configExecutors) {
  for (final ConfigExecutor configExecutor : configExecutors) {
    this.configExecutors.put(configExecutor.executeFor(),
                 configExecutor);
  }
}

private Input mockInput(int count) {
  Input input = new Input();
  for (int i = 0; i < count; i++) {
    input.put("key." + Integer.toString(i),
         "value." + Integer.toString(i));
  }
  return input;
}

private Input mockInput(int count) {
  Input input = new Input();
  for (int i = 0; i < count; i++) {
    input.put("key." + Integer.toString(i),
         "value." + Integer.toString(i));
  }
  return input;
}