@@ -115,8 +115,8 @@ If you provide source code, a new build will be automatically triggered. You can

     Search all templates, image streams, and Docker images that match the arguments provided.

 .PP

-\fB\-\-strategy\fP=""

-    Specify the build strategy to use if you don't want to detect (docker|source).

+\fB\-\-strategy\fP=

+    Specify the build strategy to use if you don't want to detect (docker|pipeline|source).

 .PP

 \fB\-\-template\fP=[]

@@ -103,8 +103,8 @@ Once the build configuration is created a new build will be automatically trigge

     Specify the file or directory to copy from the source image and its destination in the build directory. Format: [source]:[destination\-dir].

 .PP

-\fB\-\-strategy\fP=""

-    Specify the build strategy to use if you don't want to detect (docker|source).

+\fB\-\-strategy\fP=

+    Specify the build strategy to use if you don't want to detect (docker|pipeline|source).

 .PP

 \fB\-\-to\fP=""

@@ -115,8 +115,8 @@ If you provide source code, a new build will be automatically triggered. You can

     Search all templates, image streams, and Docker images that match the arguments provided.

 .PP

-\fB\-\-strategy\fP=""

-    Specify the build strategy to use if you don't want to detect (docker|source).

+\fB\-\-strategy\fP=

+    Specify the build strategy to use if you don't want to detect (docker|pipeline|source).

 .PP

 \fB\-\-template\fP=[]

@@ -103,8 +103,8 @@ Once the build configuration is created a new build will be automatically trigge

     Specify the file or directory to copy from the source image and its destination in the build directory. Format: [source]:[destination\-dir].

 .PP

-\fB\-\-strategy\fP=""

-    Specify the build strategy to use if you don't want to detect (docker|source).

+\fB\-\-strategy\fP=

+    Specify the build strategy to use if you don't want to detect (docker|pipeline|source).

 .PP

 \fB\-\-to\fP=""

@@ -34,6 +34,7 @@ import (

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

 	dockerutil "github.com/openshift/origin/pkg/cmd/util/docker"

 	configcmd "github.com/openshift/origin/pkg/config/cmd"

+	"github.com/openshift/origin/pkg/generate"

 	newapp "github.com/openshift/origin/pkg/generate/app"

 	newcmd "github.com/openshift/origin/pkg/generate/app/cmd"

 	"github.com/openshift/origin/pkg/generate/git"

@@ -170,7 +171,7 @@ func NewCmdNewApplication(name, baseName string, f *clientcmd.Factory, out, erro

 	cmd.Flags().StringSliceVar(&config.Groups, "group", config.Groups, "Indicate components that should be grouped together as <comp1>+<comp2>.")

 	cmd.Flags().StringArrayVarP(&config.Environment, "env", "e", config.Environment, "Specify a key-value pair for an environment variable to set into each container. This doesn't apply to objects created from a template, use parameters instead.")

 	cmd.Flags().StringVar(&config.Name, "name", "", "Set name to use for generated application artifacts")

-	cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).")

+	cmd.Flags().Var(&config.Strategy, "strategy", "Specify the build strategy to use if you don't want to detect (docker|pipeline|source).")

 	cmd.Flags().StringP("labels", "l", "", "Label to set in all resources for this application.")

 	cmd.Flags().BoolVar(&config.InsecureRegistry, "insecure-registry", false, "If true, indicates that the referenced Docker images are on insecure registries and should bypass certificate checking")

 	cmd.Flags().BoolVarP(&config.AsList, "list", "L", false, "List all local templates and image streams that can be used to create.")

@@ -505,6 +506,11 @@ func CompleteAppConfig(config *newcmd.AppConfig, f *clientcmd.Factory, c *cobra.

 	if len(config.SourceImage) == 0 && len(config.SourceImagePath) != 0 {

 		return kcmdutil.UsageError(c, "--source-image must be specified when --source-image-path is specified.")

 	}

+

+	if config.BinaryBuild && config.Strategy == generate.StrategyPipeline {

+		return kcmdutil.UsageError(c, "specifying binary builds and the pipeline strategy at the same time is not allowed.")

+	}

+

 	return nil

 }

@@ -72,7 +72,7 @@ func TestNewAppDefaultFlags(t *testing.T) {

 		},

 		"strategy": {

 			flagName:   "strategy",

-			defaultVal: config.Strategy,

+			defaultVal: "",

 		},

 		"labels": {

 			flagName:   "labels",

@@ -129,7 +129,7 @@ func NewCmdNewBuild(name, baseName string, f *clientcmd.Factory, in io.Reader, o

 	cmd.Flags().StringVar(&config.To, "to", "", "Push built images to this image stream tag (or Docker image repository if --to-docker is set).")

 	cmd.Flags().BoolVar(&config.OutputDocker, "to-docker", false, "Have the build output push to a Docker repository.")

 	cmd.Flags().StringArrayVarP(&config.Environment, "env", "e", config.Environment, "Specify a key-value pair for an environment variable to set into resulting image.")

-	cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).")

+	cmd.Flags().Var(&config.Strategy, "strategy", "Specify the build strategy to use if you don't want to detect (docker|pipeline|source).")

 	cmd.Flags().StringVarP(&config.Dockerfile, "dockerfile", "D", "", "Specify the contents of a Dockerfile to build directly, implies --strategy=docker. Pass '-' to read from STDIN.")

 	cmd.Flags().BoolVar(&config.BinaryBuild, "binary", false, "Instead of expecting a source URL, set the build to expect binary contents. Will disable triggers.")

 	cmd.Flags().StringP("labels", "l", "", "Label to set in all generated resources.")

@@ -10,6 +10,7 @@ import (

 	"strconv"

 	"strings"

+	"github.com/golang/glog"

 	"github.com/pborman/uuid"

 	kapi "k8s.io/kubernetes/pkg/api"

 	"k8s.io/kubernetes/pkg/api/unversioned"

@@ -18,6 +19,7 @@ import (

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	deployapi "github.com/openshift/origin/pkg/deploy/api"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/git"

 	imageapi "github.com/openshift/origin/pkg/image/api"

 	"github.com/openshift/origin/pkg/util"

@@ -193,13 +195,19 @@ func (r *SourceRef) BuildSource() (*buildapi.BuildSource, []buildapi.BuildTrigge

 // BuildStrategyRef is a reference to a build strategy

 type BuildStrategyRef struct {

-	IsDockerBuild bool

-	Base          *ImageRef

+	Strategy generate.Strategy

+	Base     *ImageRef

 }

 // BuildStrategy builds an OpenShift BuildStrategy from a BuildStrategyRef

 func (s *BuildStrategyRef) BuildStrategy(env Environment) (*buildapi.BuildStrategy, []buildapi.BuildTriggerPolicy) {

-	if s.IsDockerBuild {

+	switch s.Strategy {

+	case generate.StrategyPipeline:

+		return &buildapi.BuildStrategy{

+			JenkinsPipelineStrategy: &buildapi.JenkinsPipelineBuildStrategy{},

+		}, s.Base.BuildTriggers()

+

+	case generate.StrategyDocker:

 		var triggers []buildapi.BuildTriggerPolicy

 		strategy := &buildapi.DockerBuildStrategy{

 			Env: env.List(),

@@ -212,14 +220,18 @@ func (s *BuildStrategyRef) BuildStrategy(env Environment) (*buildapi.BuildStrate

 		return &buildapi.BuildStrategy{

 			DockerStrategy: strategy,

 		}, triggers

+

+	case generate.StrategySource:

+		return &buildapi.BuildStrategy{

+			SourceStrategy: &buildapi.SourceBuildStrategy{

+				From: s.Base.ObjectReference(),

+				Env:  env.List(),

+			},

+		}, s.Base.BuildTriggers()

 	}

-	return &buildapi.BuildStrategy{

-		SourceStrategy: &buildapi.SourceBuildStrategy{

-			From: s.Base.ObjectReference(),

-			Env:  env.List(),

-		},

-	}, s.Base.BuildTriggers()

+	glog.Error("BuildStrategy called with unknown strategy")

+	return nil, nil

 }

 // BuildRef is a reference to a build configuration

@@ -10,6 +10,7 @@ import (

 	"k8s.io/kubernetes/pkg/util/sets"

 	"github.com/openshift/origin/pkg/cmd/cli/describe"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/app"

 	imageapi "github.com/openshift/origin/pkg/image/api"

 )

@@ -148,16 +149,10 @@ func describeBuildPipelineWithImage(out io.Writer, ref app.ComponentReference, p

 				}

 				matches = append(matches, t.Platform)

 			}

-			if len(matches) > 0 && !pipeline.Build.Strategy.IsDockerBuild {

+			if len(matches) > 0 && pipeline.Build.Strategy.Strategy == generate.StrategySource {

 				fmt.Fprintf(out, "    * The source repository appears to match: %s\n", strings.Join(matches, ", "))

 			}

 		}

-		var strategy string

-		if pipeline.Build.Strategy.IsDockerBuild {

-			strategy = "Docker"

-		} else {

-			strategy = "source"

-		}

 		noSource := false

 		var source string

 		switch s := pipeline.Build.Source; {

@@ -175,7 +170,7 @@ func describeBuildPipelineWithImage(out io.Writer, ref app.ComponentReference, p

 			source = "<unknown>"

 		}

-		fmt.Fprintf(out, "    * A %s build using %s will be created\n", strategy, source)

+		fmt.Fprintf(out, "    * A %s build using %s will be created\n", pipeline.Build.Strategy.Strategy, source)

 		if buildOut, err := pipeline.Build.Output.BuildOutput(); err == nil && buildOut != nil && buildOut.To != nil {

 			switch to := buildOut.To; {

 			case to.Kind == "ImageStreamTag":

@@ -28,8 +28,10 @@ import (

 	"github.com/openshift/origin/pkg/client"

 	cmdutil "github.com/openshift/origin/pkg/cmd/util"

 	"github.com/openshift/origin/pkg/dockerregistry"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/app"

 	"github.com/openshift/origin/pkg/generate/dockerfile"

+	"github.com/openshift/origin/pkg/generate/jenkinsfile"

 	"github.com/openshift/origin/pkg/generate/source"

 	imageapi "github.com/openshift/origin/pkg/image/api"

 	outil "github.com/openshift/origin/pkg/util"

@@ -44,10 +46,6 @@ const (

 	GeneratedByNewBuild  = "OpenShiftNewBuild"

 )

-// ErrNoDockerfileDetected is the error returned when the requested build strategy is Docker

-// and no Dockerfile is detected in the repository.

-var ErrNoDockerfileDetected = errors.New("No Dockerfile was found in the repository and the requested build strategy is 'docker'")

-

 // GenerationInputs control how new-app creates output

 // TODO: split these into finer grained structs

 type GenerationInputs struct {

@@ -59,7 +57,7 @@ type GenerationInputs struct {

 	InsecureRegistry bool

-	Strategy string

+	Strategy generate.Strategy

 	Name     string

 	To       string

@@ -161,8 +159,9 @@ func NewAppConfig() *AppConfig {

 	return &AppConfig{

 		Resolvers: Resolvers{

 			Detector: app.SourceRepositoryEnumerator{

-				Detectors: source.DefaultDetectors,

-				Tester:    dockerfile.NewTester(),

+				Detectors:         source.DefaultDetectors,

+				DockerfileTester:  dockerfile.NewTester(),

+				JenkinsfileTester: jenkinsfile.NewTester(),

 			},

 		},

 	}

@@ -249,18 +248,18 @@ func (c *AppConfig) AddArguments(args []string) []string {

 }

 // validateBuilders confirms that all images associated with components that are to be built,

-// are builders (or we're using a docker strategy).

+// are builders (or we're using a non-source strategy).

 func (c *AppConfig) validateBuilders(components app.ComponentReferences) error {

-	if len(c.Strategy) != 0 {

+	if c.Strategy != generate.StrategyUnspecified {

 		return nil

 	}

 	errs := []error{}

 	for _, ref := range components {

 		input := ref.Input()

 		// if we're supposed to build this thing, and the image/imagestream we've matched it to did not come from an explicit CLI argument,

-		// and the image/imagestream we matched to is not explicitly an s2i builder, and we're not doing a docker-type build, warn the user

+		// and the image/imagestream we matched to is not explicitly an s2i builder, and we're doing a source-type build, warn the user

 		// that this probably won't work and force them to declare their intention explicitly.

-		if input.ExpectToBuild && input.ResolvedMatch != nil && !app.IsBuilderMatch(input.ResolvedMatch) && input.Uses != nil && !input.Uses.IsDockerBuild() {

+		if input.ExpectToBuild && input.ResolvedMatch != nil && !app.IsBuilderMatch(input.ResolvedMatch) && input.Uses != nil && input.Uses.GetStrategy() == generate.StrategySource {

 			errs = append(errs, fmt.Errorf("the image match %q for source repository %q does not appear to be a source-to-image builder.\n\n- to attempt to use this image as a source builder, pass \"--strategy=source\"\n- to use it as a base image for a Docker build, pass \"--strategy=docker\"", input.ResolvedMatch.Name, input.Uses))

 			continue

 		}

@@ -275,13 +274,6 @@ func validateEnforcedName(name string) error {

 	return nil

 }

-func validateStrategyName(name string) error {

-	if name != "docker" && name != "source" {

-		return fmt.Errorf("invalid strategy: %s. Must be 'docker' or 'source'.", name)

-	}

-	return nil

-}

-

 func validateOutputImageReference(ref string) error {

 	if _, err := imageapi.ParseDockerImageReference(ref); err != nil {

 		return fmt.Errorf("invalid output image reference: %s", ref)

@@ -304,7 +296,7 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 			switch {

 			case refInput.ExpectToBuild:

 				glog.V(4).Infof("will add %q secrets into a build for a source build of %q", strings.Join(c.Secrets, ","), refInput.Uses)

-				if err := refInput.Uses.AddBuildSecrets(c.Secrets, refInput.Uses.IsDockerBuild()); err != nil {

+				if err := refInput.Uses.AddBuildSecrets(c.Secrets); err != nil {

 					return nil, fmt.Errorf("unable to add build secrets %q: %v", strings.Join(c.Secrets, ","), err)

 				}

@@ -317,7 +309,7 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 					if err != nil {

 						return nil, fmt.Errorf("can't build %q: %v", from, err)

 					}

-					if !inputImage.AsImageStream && from != "scratch" {

+					if !inputImage.AsImageStream && from != "scratch" && (refInput.Uses == nil || refInput.Uses.GetStrategy() != generate.StrategyPipeline) {

 						msg := "Could not find an image stream match for %q. Make sure that a Docker image with that tag is available on the node for the build to succeed."

 						glog.Warningf(msg, from)

 					}

@@ -351,6 +343,12 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 			if c.NoOutput {

 				pipeline.Build.Output = nil

 			}

+			if refInput.Uses != nil && refInput.Uses.GetStrategy() == generate.StrategyPipeline {

+				pipeline.Build.Output = nil

+				pipeline.Deployment = nil

+				pipeline.Image = nil

+				pipeline.InputImage = nil

+			}

 			common = append(common, pipeline)

 			if err := common.Reduce(); err != nil {

 				return nil, fmt.Errorf("can't create a pipeline from %s: %v", common, err)

@@ -613,12 +611,6 @@ func (c *AppConfig) Run() (*AppResult, error) {

 		}

 	}

-	if len(c.Strategy) > 0 {

-		if err := validateStrategyName(c.Strategy); err != nil {

-			return nil, err

-		}

-	}

-

 	if err := optionallyValidateExposedPorts(c, repositories); err != nil {

 		return nil, err

 	}

@@ -901,7 +893,7 @@ func optionallyValidateExposedPorts(config *AppConfig, repositories app.SourceRe

 		return nil

 	}

-	if len(config.Strategy) > 0 && config.Strategy != "docker" {

+	if config.Strategy != generate.StrategyUnspecified && config.Strategy != generate.StrategyDocker {

 		return nil

 	}

@@ -15,6 +15,7 @@ import (

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	client "github.com/openshift/origin/pkg/client/testclient"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/app"

 	image "github.com/openshift/origin/pkg/image/api"

 	templateapi "github.com/openshift/origin/pkg/template/api"

@@ -339,7 +340,7 @@ func mockSourceRepositories(t *testing.T, file string) []*app.SourceRepository {

 		"https://github.com/openshift/ruby-hello-world.git",

 		file,

 	} {

-		s, err := app.NewSourceRepository(location)

+		s, err := app.NewSourceRepository(location, generate.StrategySource)

 		if err != nil {

 			t.Fatal(err)

 		}

@@ -356,11 +357,10 @@ func TestBuildPipelinesWithUnresolvedImage(t *testing.T) {

 		t.Fatal(err)

 	}

-	sourceRepo, err := app.NewSourceRepository("https://github.com/foo/bar.git")

+	sourceRepo, err := app.NewSourceRepository("https://github.com/foo/bar.git", generate.StrategyDocker)

 	if err != nil {

 		t.Fatal(err)

 	}

-	sourceRepo.BuildWithDocker()

 	sourceRepo.SetInfo(&app.SourceRepositoryInfo{

 		Dockerfile: dockerFile,

 	})

@@ -509,15 +509,15 @@ func TestBuildOutputCycleWithFollowingTag(t *testing.T) {

 func TestAllowedNonNumericExposedPorts(t *testing.T) {

 	tests := []struct {

-		strategy             string

+		strategy             generate.Strategy

 		allowNonNumericPorts bool

 	}{

 		{

-			strategy:             "",

+			strategy:             generate.StrategyUnspecified,

 			allowNonNumericPorts: true,

 		},

 		{

-			strategy:             "source",

+			strategy:             generate.StrategySource,

 			allowNonNumericPorts: false,

 		},

 	}

@@ -543,15 +543,15 @@ func TestAllowedNonNumericExposedPorts(t *testing.T) {

 func TestDisallowedNonNumericExposedPorts(t *testing.T) {

 	tests := []struct {

-		strategy             string

+		strategy             generate.Strategy

 		allowNonNumericPorts bool

 	}{

 		{

-			strategy:             "",

+			strategy:             generate.StrategyUnspecified,

 			allowNonNumericPorts: false,

 		},

 		{

-			strategy:             "docker",

+			strategy:             generate.StrategyDocker,

 			allowNonNumericPorts: false,

 		},

 	}

@@ -8,6 +8,7 @@ import (

 	"github.com/golang/glog"

 	kutilerrors "k8s.io/kubernetes/pkg/util/errors"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/app"

 	dockerfileutil "github.com/openshift/origin/pkg/util/docker/dockerfile"

 )

@@ -53,6 +54,10 @@ func (r *Resolvers) DockerfileResolver() app.Resolver {

 	return resolver

 }

+func (r *Resolvers) PipelineResolver() app.Resolver {

+	return app.PipelineResolver{}

+}

+

 // TODO: why does this differ from ImageSourceResolver?

 func (r *Resolvers) SourceResolver() app.Resolver {

 	resolver := app.PerfectMatchWeightedResolver{}

@@ -110,7 +115,7 @@ func Resolve(r *Resolvers, c *ComponentInputs, g *GenerationInputs) (*ResolvedCo

 		repo.SetContextDir(g.ContextDir)

 	}

-	if len(g.Strategy) != 0 && len(repositories) == 0 && !g.BinaryBuild {

+	if g.Strategy != generate.StrategyUnspecified && len(repositories) == 0 && !g.BinaryBuild {

 		return nil, errors.New("when --strategy is specified you must provide at least one source code location")

 	}

@@ -154,7 +159,7 @@ func Resolve(r *Resolvers, c *ComponentInputs, g *GenerationInputs) (*ResolvedCo

 	}

 	// For source repos that are not yet linked to a component, create components

-	sourceComponents, err := AddMissingComponentsToRefBuilder(b, repositories.NotUsed(), r.DockerfileResolver(), r.SourceResolver(), g)

+	sourceComponents, err := AddMissingComponentsToRefBuilder(b, repositories.NotUsed(), r.DockerfileResolver(), r.SourceResolver(), r.PipelineResolver(), g)

 	if err != nil {

 		return nil, err

 	}

@@ -177,16 +182,17 @@ func Resolve(r *Resolvers, c *ComponentInputs, g *GenerationInputs) (*ResolvedCo

 // AddSourceRepositoriesToRefBuilder adds the provided repositories to the reference builder, identifies which

 // should be built using Docker, and then returns the full list of source repositories.

 func AddSourceRepositoriesToRefBuilder(b *app.ReferenceBuilder, repos []string, g *GenerationInputs) (app.SourceRepositories, error) {

+	strategy := g.Strategy

+	if strategy == generate.StrategyUnspecified {

+		strategy = generate.StrategySource

+	}

 	for _, s := range repos {

-		if repo, ok := b.AddSourceRepository(s); ok {

+		if repo, ok := b.AddSourceRepository(s, strategy); ok {

 			repo.SetContextDir(g.ContextDir)

-			if g.Strategy == "docker" {

-				repo.BuildWithDocker()

-			}

 		}

 	}

 	if len(g.Dockerfile) > 0 {

-		if len(g.Strategy) != 0 && g.Strategy != "docker" {

+		if g.Strategy != generate.StrategyUnspecified && g.Strategy != generate.StrategyDocker {

 			return nil, errors.New("when directly referencing a Dockerfile, the strategy must must be 'docker'")

 		}

 		if err := AddDockerfileToSourceRepositories(b, g.Dockerfile); err != nil {

@@ -230,15 +236,25 @@ func AddDockerfileToSourceRepositories(b *app.ReferenceBuilder, dockerfile strin

 func DetectSource(repositories []*app.SourceRepository, d app.Detector, g *GenerationInputs) error {

 	errs := []error{}

 	for _, repo := range repositories {

-		err := repo.Detect(d, g.Strategy == "docker")

+		err := repo.Detect(d, g.Strategy == generate.StrategyDocker || g.Strategy == generate.StrategyPipeline)

 		if err != nil {

-			if g.Strategy == "docker" && err == app.ErrNoLanguageDetected {

-				errs = append(errs, ErrNoDockerfileDetected)

-			} else {

-				errs = append(errs, err)

-			}

+			errs = append(errs, err)

 			continue

 		}

+		switch g.Strategy {

+		case generate.StrategyDocker:

+			if repo.Info().Dockerfile == nil {

+				errs = append(errs, errors.New("No Dockerfile was found in the repository and the requested build strategy is 'docker'"))

+			}

+		case generate.StrategyPipeline:

+			if !repo.Info().Jenkinsfile {

+				errs = append(errs, errors.New("No Jenkinsfile was found in the repository and the requested build strategy is 'pipeline'"))

+			}

+		default:

+			if repo.Info().Dockerfile == nil && !repo.Info().Jenkinsfile && len(repo.Info().Types) == 0 {

+				errs = append(errs, errors.New("No language matched the source repository"))

+			}

+		}

 	}

 	return kutilerrors.NewAggregate(errs)

 }

@@ -354,7 +370,7 @@ func AddImageSourceRepository(sourceRepos app.SourceRepositories, r app.Resolver

 		sourceRepos[0].SetSourceImage(compRef)

 		sourceRepos[0].SetSourceImagePath(sourcePath, destPath)

 	default:

-		return nil, nil, errors.New("--image-source cannot be used with multiple source repositories")

+		return nil, nil, errors.New("--source-image cannot be used with multiple source repositories")

 	}

 	return compRef, sourceRepos, nil

@@ -386,13 +402,14 @@ func InferBuildTypes(components app.ComponentReferences, g *GenerationInputs) (a

 		}

 		input.ResolvedMatch.GeneratorInput = generatorInput

-		// if the strategy is explicitly Docker, all repos should assume docker

-		if g.Strategy == "docker" && input.Uses != nil {

-			input.Uses.BuildWithDocker()

+		// if the strategy is set explicitly, apply it to all repos.

+		// for example, this affects repos specified in the form image~source.

+		if g.Strategy != generate.StrategyUnspecified && input.Uses != nil {

+			input.Uses.SetStrategy(g.Strategy)

 		}

 		// if we are expecting build inputs, or get a build input when strategy is not docker, expect to build

-		if g.ExpectToBuild || (input.ResolvedMatch.Builder && g.Strategy != "docker") {

+		if g.ExpectToBuild || (input.ResolvedMatch.Builder && g.Strategy != generate.StrategyDocker) {

 			input.ExpectToBuild = true

 		}

@@ -403,7 +420,7 @@ func InferBuildTypes(components app.ComponentReferences, g *GenerationInputs) (a

 			continue

 		}

 	}

-	if len(components) == 0 && g.BinaryBuild && g.Strategy == "source" {

+	if len(components) == 0 && g.BinaryBuild && g.Strategy == generate.StrategySource {

 		return nil, errors.New("you must provide a builder image when using the source strategy with a binary build")

 	}

 	if len(components) == 0 && g.BinaryBuild {

@@ -464,11 +481,12 @@ func EnsureHasSource(components app.ComponentReferences, repositories app.Source

 				if input.Uses != nil {

 					continue

 				}

-				repo := app.NewBinarySourceRepository()

+				strategy := generate.StrategySource

 				isBuilder := input.ResolvedMatch != nil && input.ResolvedMatch.Builder

-				if g.Strategy == "docker" || (len(g.Strategy) == 0 && !isBuilder) {

-					repo.BuildWithDocker()

+				if g.Strategy == generate.StrategyDocker || (g.Strategy == generate.StrategyUnspecified && !isBuilder) {

+					strategy = generate.StrategyDocker

 				}

+				repo := app.NewBinarySourceRepository(strategy)

 				input.Use(repo)

 				repo.UsedBy(input)

 				input.ExpectToBuild = true

@@ -488,7 +506,7 @@ func EnsureHasSource(components app.ComponentReferences, repositories app.Source

 // builder. These components have already gone through source code detection and have a SourceRepositoryInfo attached

 // to them.

 func AddMissingComponentsToRefBuilder(

-	b *app.ReferenceBuilder, repositories app.SourceRepositories, dockerfileResolver, sourceResolver app.Resolver,

+	b *app.ReferenceBuilder, repositories app.SourceRepositories, dockerfileResolver, sourceResolver, pipelineResolver app.Resolver,

 	g *GenerationInputs,

 ) (app.ComponentReferences, error) {

 	errs := []error{}

@@ -499,7 +517,7 @@ func AddMissingComponentsToRefBuilder(

 		case info == nil:

 			errs = append(errs, fmt.Errorf("source not detected for repository %q", repo))

 			continue

-		case info.Dockerfile != nil && (len(g.Strategy) == 0 || g.Strategy == "docker"):

+		case info.Dockerfile != nil && (g.Strategy == generate.StrategyUnspecified || g.Strategy == generate.StrategyDocker):

 			node := info.Dockerfile.AST()

 			baseImage := dockerfileutil.LastBaseImage(node)

 			if baseImage == "" {

@@ -511,7 +529,18 @@ func AddMissingComponentsToRefBuilder(

 				input.Use(repo)

 				input.ExpectToBuild = true

 				repo.UsedBy(input)

-				repo.BuildWithDocker()

+				repo.SetStrategy(generate.StrategyDocker)

+				return input

+			})

+			result = append(result, refs...)

+

+		case info.Jenkinsfile && (g.Strategy == generate.StrategyUnspecified || g.Strategy == generate.StrategyPipeline):

+			refs := b.AddComponents([]string{"pipeline"}, func(input *app.ComponentInput) app.ComponentReference {

+				input.Resolver = pipelineResolver

+				input.Use(repo)

+				input.ExpectToBuild = true

+				repo.UsedBy(input)

+				repo.SetStrategy(generate.StrategyPipeline)

 				return input

 			})

 			result = append(result, refs...)

@@ -5,6 +5,8 @@ import (

 	"sort"

 	"strings"

+	"github.com/openshift/origin/pkg/generate"

+

 	"k8s.io/kubernetes/pkg/util/errors"

 )

@@ -205,7 +207,7 @@ func (r *ReferenceBuilder) AddComponents(inputs []string, fn func(*ComponentInpu

 			input.GroupID = r.groupID

 			ref := fn(input)

 			if len(repo) != 0 {

-				repository, ok := r.AddSourceRepository(repo)

+				repository, ok := r.AddSourceRepository(repo, generate.StrategySource)

 				if !ok {

 					continue

 				}

@@ -251,13 +253,13 @@ func (r *ReferenceBuilder) AddGroups(inputs []string) {

 }

 // AddSourceRepository resolves the input to an actual source repository

-func (r *ReferenceBuilder) AddSourceRepository(input string) (*SourceRepository, bool) {

+func (r *ReferenceBuilder) AddSourceRepository(input string, strategy generate.Strategy) (*SourceRepository, bool) {

 	for _, existing := range r.repos {

 		if input == existing.location {

 			return existing, true

 		}

 	}

-	source, err := NewSourceRepository(input)

+	source, err := NewSourceRepository(input, strategy)

 	if err != nil {

 		r.errs = append(r.errs, err)

 		return nil, false

@@ -197,6 +197,19 @@ func (r UniqueExactOrInexactMatchResolver) Resolve(value string) (*ComponentMatc

 	}

 }

+// PipelineResolver returns a dummy ComponentMatch for any value input.  It is

+// used to provide a dummy component for for the pipeline/Jenkinsfile strategy.

+type PipelineResolver struct {

+}

+

+// Resolve returns a dummy ComponentMatch for any value input.

+func (r PipelineResolver) Resolve(value string) (*ComponentMatch, error) {

+	return &ComponentMatch{

+		Value:     value,

+		LocalOnly: true,

+	}, nil

+}

+

 // MultiSimpleSearcher is a set of searchers

 type MultiSimpleSearcher []Searcher

@@ -10,6 +10,7 @@ import (

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	deployapi "github.com/openshift/origin/pkg/deploy/api"

+	"github.com/openshift/origin/pkg/generate"

 	imageapi "github.com/openshift/origin/pkg/image/api"

 )

@@ -55,7 +56,7 @@ func TestBuildConfigOutput(t *testing.T) {

 	for i, test := range tests {

 		output.AsImageStream = test.asImageStream

 		source := &SourceRef{URL: url}

-		strategy := &BuildStrategyRef{IsDockerBuild: false, Base: base}

+		strategy := &BuildStrategyRef{Strategy: generate.StrategySource, Base: base}

 		build := &BuildRef{Source: source, Output: output, Strategy: strategy}

 		config, err := build.BuildConfig()

 		if err != nil {

@@ -15,6 +15,7 @@ import (

 	build "github.com/openshift/origin/pkg/build/api"

 	deploy "github.com/openshift/origin/pkg/deploy/api"

+	"github.com/openshift/origin/pkg/generate"

 	image "github.com/openshift/origin/pkg/image/api"

 	route "github.com/openshift/origin/pkg/route/api"

 	"github.com/openshift/origin/pkg/util/docker/dockerfile"

@@ -90,7 +91,7 @@ func (pb *pipelineBuilder) NewBuildPipeline(from string, input *ImageRef, source

 	source.Name = name

 	// Append any exposed ports from Dockerfile to input image

-	if sourceRepository.IsDockerBuild() && sourceRepository.Info() != nil {

+	if sourceRepository.GetStrategy() == generate.StrategyDocker && sourceRepository.Info() != nil {

 		node := sourceRepository.Info().Dockerfile.AST()

 		ports := dockerfile.LastExposedPorts(node)

 		if len(ports) > 0 {

@@ -14,7 +14,7 @@ import (

 	"github.com/golang/glog"

 	buildapi "github.com/openshift/origin/pkg/build/api"

-	"github.com/openshift/origin/pkg/generate/dockerfile"

+	"github.com/openshift/origin/pkg/generate"

 	"github.com/openshift/origin/pkg/generate/git"

 	"github.com/openshift/origin/pkg/generate/source"

 	s2iapi "github.com/openshift/source-to-image/pkg/api"

@@ -99,7 +99,7 @@ type SourceRepository struct {

 	sourceImageTo   string

 	usedBy           []ComponentReference

-	buildWithDocker  bool

+	strategy         generate.Strategy

 	ignoreRepository bool

 	binary           bool

@@ -110,7 +110,7 @@ type SourceRepository struct {

 // NewSourceRepository creates a reference to a local or remote source code repository from

 // a URL or path.

-func NewSourceRepository(s string) (*SourceRepository, error) {

+func NewSourceRepository(s string, strategy generate.Strategy) (*SourceRepository, error) {

 	location, err := git.ParseRepository(s)

 	if err != nil {

 		return nil, err

@@ -119,13 +119,14 @@ func NewSourceRepository(s string) (*SourceRepository, error) {

 	return &SourceRepository{

 		location: s,

 		url:      *location,

+		strategy: strategy,

 	}, nil

 }

 // NewSourceRepositoryWithDockerfile creates a reference to a local source code repository with

 // the provided relative Dockerfile path (defaults to "Dockerfile").

 func NewSourceRepositoryWithDockerfile(s, dockerfilePath string) (*SourceRepository, error) {

-	r, err := NewSourceRepository(s)

+	r, err := NewSourceRepository(s, generate.StrategyDocker)

 	if err != nil {

 		return nil, err

 	}

@@ -148,6 +149,7 @@ func NewSourceRepositoryWithDockerfile(s, dockerfilePath string) (*SourceReposit

 func NewSourceRepositoryForDockerfile(contents string) (*SourceRepository, error) {

 	s := &SourceRepository{

 		ignoreRepository: true,

+		strategy:         generate.StrategyDocker,

 	}

 	err := s.AddDockerfile(contents)

 	return s, err

@@ -155,10 +157,11 @@ func NewSourceRepositoryForDockerfile(contents string) (*SourceRepository, error

 // NewBinarySourceRepository creates a source repository that is configured for binary

 // input.

-func NewBinarySourceRepository() *SourceRepository {

+func NewBinarySourceRepository(strategy generate.Strategy) *SourceRepository {

 	return &SourceRepository{

 		binary:           true,

 		ignoreRepository: true,

+		strategy:         strategy,

 	}

 }

@@ -171,6 +174,7 @@ func NewImageSourceRepository(compRef ComponentReference, from, to string) *Sour

 		sourceImageTo:    to,

 		ignoreRepository: true,

 		location:         compRef.Input().From,

+		strategy:         generate.StrategySource,

 	}

 }

@@ -189,14 +193,14 @@ func (r *SourceRepository) InUse() bool {

 	return len(r.usedBy) > 0

 }

-// BuildWithDocker specifies that the source repository was built with Docker

-func (r *SourceRepository) BuildWithDocker() {

-	r.buildWithDocker = true

+// SetStrategy sets the source repository strategy

+func (r *SourceRepository) SetStrategy(strategy generate.Strategy) {

+	r.strategy = strategy

 }

-// IsDockerBuild checks if the source repository was built with Docker

-func (r *SourceRepository) IsDockerBuild() bool {

-	return r.buildWithDocker

+// GetStrategy returns the source repository strategy

+func (r *SourceRepository) GetStrategy() generate.Strategy {

+	return r.strategy

 }

 func (r *SourceRepository) String() string {

@@ -377,7 +381,7 @@ func (r *SourceRepository) AddDockerfile(contents string) error {

 		r.info = &SourceRepositoryInfo{}

 	}

 	r.info.Dockerfile = dockerfile

-	r.buildWithDocker = true

+	r.SetStrategy(generate.StrategyDocker)

 	r.forceAddDockerfile = true

 	return nil

 }

@@ -385,7 +389,7 @@ func (r *SourceRepository) AddDockerfile(contents string) error {

 // AddBuildSecrets adds the defined secrets into a build. The input format for

 // the secrets is "<secretName>:<destinationDir>". The destinationDir is

 // optional and when not specified the default is the current working directory.

-func (r *SourceRepository) AddBuildSecrets(secrets []string, isDockerBuild bool) error {

+func (r *SourceRepository) AddBuildSecrets(secrets []string) error {

 	injections := s2iapi.VolumeList{}

 	r.secrets = []buildapi.SecretBuildSource{}

 	for _, in := range secrets {

@@ -402,7 +406,7 @@ func (r *SourceRepository) AddBuildSecrets(secrets []string, isDockerBuild bool)

 		return false

 	}

 	for _, in := range injections {

-		if isDockerBuild && filepath.IsAbs(in.Destination) {

+		if r.GetStrategy() == generate.StrategyDocker && filepath.IsAbs(in.Destination) {

 			return fmt.Errorf("for the docker strategy, the secret destination directory %q must be a relative path", in.Destination)

 		}

 		if len(validation.ValidateSecretName(in.Source, false)) != 0 {

@@ -443,9 +447,10 @@ func (rr SourceRepositories) NotUsed() SourceRepositories {

 // SourceRepositoryInfo contains info about a source repository

 type SourceRepositoryInfo struct {

-	Path       string

-	Types      []SourceLanguageType

-	Dockerfile Dockerfile

+	Path        string

+	Types       []SourceLanguageType

+	Dockerfile  Dockerfile

+	Jenkinsfile bool

 }

 // Terms returns which languages the source repository was

@@ -482,23 +487,20 @@ type Detector interface {

 // SourceRepositoryEnumerator implements the Detector interface

 type SourceRepositoryEnumerator struct {

-	Detectors source.Detectors

-	Tester    dockerfile.Tester

+	Detectors         source.Detectors

+	DockerfileTester  generate.Tester

+	JenkinsfileTester generate.Tester

 }

-// ErrNoLanguageDetected is the error returned when no language can be detected by all

-// source code detectors.

-var ErrNoLanguageDetected = errors.New("No language matched the source repository")

-

 // Detect extracts source code information about the provided source repository

-func (e SourceRepositoryEnumerator) Detect(dir string, dockerStrategy bool) (*SourceRepositoryInfo, error) {

+func (e SourceRepositoryEnumerator) Detect(dir string, noSourceDetection bool) (*SourceRepositoryInfo, error) {

 	info := &SourceRepositoryInfo{

 		Path: dir,

 	}

 	// no point in doing source-type detection if the requested build strategy

-	// is docker

-	if !dockerStrategy {

+	// is docker or pipeline

+	if !noSourceDetection {

 		for _, d := range e.Detectors {

 			if detected, ok := d(dir); ok {

 				info.Types = append(info.Types, SourceLanguageType{

@@ -508,17 +510,17 @@ func (e SourceRepositoryEnumerator) Detect(dir string, dockerStrategy bool) (*So

 			}

 		}

 	}

-	if path, ok, err := e.Tester.Has(dir); err == nil && ok {

+	if path, ok, err := e.DockerfileTester.Has(dir); err == nil && ok {

 		dockerfile, err := NewDockerfileFromFile(path)

 		if err != nil {

 			return nil, err

 		}

 		info.Dockerfile = dockerfile

 	}

-

-	if info.Dockerfile == nil && len(info.Types) == 0 {

-		return nil, ErrNoLanguageDetected

+	if _, ok, err := e.JenkinsfileTester.Has(dir); err == nil && ok {

+		info.Jenkinsfile = true

 	}

+

 	return info, nil

 }

@@ -528,8 +530,8 @@ func (e SourceRepositoryEnumerator) Detect(dir string, dockerStrategy bool) (*So

 // more info

 func StrategyAndSourceForRepository(repo *SourceRepository, image *ImageRef) (*BuildStrategyRef, *SourceRef, error) {

 	strategy := &BuildStrategyRef{

-		Base:          image,

-		IsDockerBuild: repo.IsDockerBuild(),

+		Base:     image,

+		Strategy: repo.strategy,

 	}

 	source := &SourceRef{

 		Binary:       repo.binary,

@@ -1,6 +1,10 @@

 package app

-import "testing"

+import (

+	"testing"

+

+	"github.com/openshift/origin/pkg/generate"

+)

 func TestAddBuildSecrets(t *testing.T) {

 	type result struct{ name, dest string }

@@ -35,12 +39,13 @@ func TestAddBuildSecrets(t *testing.T) {

 		},

 	}

 	repo := &SourceRepository{}

-	if err := repo.AddBuildSecrets([]string{"secret1:/absolute/path"}, true); err == nil {