return vars, nil

}

func Initialize(wd string) ([]string, error) {

oldHome := os.Getenv("HOME")

os.Setenv("HOME", "/tmp")

}

const (

)

// We might have something like $(pwd), in which case we don't want

// to wrap the name in `{}`, which would cause it to be ${}(pwd) and

// cannot be evaluated by a run task.

// Map will return the value matching a KEY=VAL pair in the given environment.

func Map(key string, env []string) string {

mapper := envMapper{env}

}

// Mapper will replace ${TEMPLATE} patterns in the string with the KEY=VAL pairs

orig := str

last := str

prev := map[string]struct{}{}

if last == next {

return next, nil

}

}

last = next

prev[last] = struct{}{}

}

package environment

import (

return parts[0], parts[1]

}

func Merge(orig, update []string) []string {

env := map[string]string{}

package main

import (

"bitbucket.org/rw_grim/convey/yaml"

)

type Clean struct {

Files yaml.StringOrSlice `yaml:"files"`

}

return list, nil

}

func (c *Clean) Execute(name string, logger *gomol.LogAdapter, env []string, st *state.State) error {

fullEnv := environment.Merge(env, st.GetEnv())

return nil

}

func (c *Clean) New() tasks.Task {

return &Clean{}

}

func (c *Clean) Valid() error {

if len(c.Files) == 0 {

return fmt.Errorf("No files specified")

"bitbucket.org/rw_grim/convey/yaml"

)

type Extend struct {

Task string `yaml:"task"`

Environment yaml.StringOrSlice `yaml:"environment"`

InnerTask tasks.Task

}

func (e *Extend) Execute(name string, logger *gomol.LogAdapter, env []string, st *state.State) error {

// While extending, certain environment variables can be expanded into

// lists. We store this meta information as a stack on the state, which

))

}

func (e *Extend) New() tasks.Task {

return &Extend{}

}

func (e *Extend) Valid() error {

if e.ExpandDelimiter == "" {

e.ExpandDelimiter = ";"

return nil

}

func (e *Extend) Dependencies() []string {

return []string{e.Task}

}

func (e *Extend) Resolve(taskMap map[string]tasks.Task) error {

task, ok := taskMap[e.Task]

if !ok {

)

var (

Tasks = map[string]tasks.Task{

"clean": &Clean{},

"extend": &Extend{},

"github.com/go-yaml/yaml"

)

type Loader struct{}

func addTask(name string, task tasks.Task, plan plans.Plan, cfg *config.Config) {

return nil

}

func (l *Loader) Load(base, path string, data []byte, disableDeprecated bool) (*config.Config, error) {

var pipeline bitbucketPipelines

err := yaml.Unmarshal(data, &pipeline)

return cfg, nil

}

func (l *Loader) LoadOverride(base, path string, data []byte, cfg *config.Config, disableDeprecated bool) {

return

}

func (l *Loader) Filenames() []string {

return []string{"bitbucket-pipelines.yml"}

}

func (l *Loader) OverrideSuffix() string {

return "-override"

}

func (l *Loader) DefaultPlan() string {

return "default"

}

func (l *Loader) ResolvePlanName(plan string, cfg *config.Config, st *state.State) string {

if plan != "" {

// try to shortcut if we can

matchMapper["bookmark"] = append(matchMapper["bookmark"], hgBookmark)

}

for prefix, matchers := range matchMapper {

for _, matcher := range matchers {

calculatedName := fmt.Sprintf("%s-%s", prefix, matcher)

Options options `yaml:"options"`

}

type Loader struct {

logger *gomol.LogAdapter

defaultPlan string

fileLoader func(string, *Loader) (*cConfig.Config, error)

}

}

// load the raw config

var baseConfig *cConfig.Config

if cfg.Extends != "" {

return nil, ErrMaxExtendsDepth

}

extendsAbsName := filepath.Join(path, cfg.Extends)

// We can safely ignore no plans and no tasks errors here

// as we're ensured to also get a valid base config back.

}

// turn the raw tasks into real tasks

if err != nil {

return nil, err

}

}

// store the default plan in the loader

// tasks, plans, and metaplans are all name => * maps, and

// if we're extending something we want to inherit all of these

// Check if the default plan is being overridden

if cfg.Options.DefaultPlan != "" {

}

// don't clobber ssh-identities with an empty list

// in the correct order. This is a problem, for example, if the extend

// intrinsic clones a task that is not fully resolved.

return nil, err

}

return baseConfig, nil

}

// Extract resolvable tasks from config tasks

resolvables := map[string]tasks.ResolvableTask{}

return nil

}

}

}

var overrideData override

err := yaml.Unmarshal(data, &overrideData)

// Check if the default plan is being overridden

if overrideData.Options.DefaultPlan != "" {

}

// if there are ssh-identities in the override they need to replace the

}

}

func (l *Loader) Filenames() []string {

return []string{"convey.yml", "convey.yaml"}

}

func (l *Loader) OverrideSuffix() string {

return "-override"

}

func (l *Loader) DefaultPlan() string {

if l.defaultPlan != "" {

return l.defaultPlan

return "default"

}

func (l *Loader) ResolvePlanName(plan string, cfg *cConfig.Config, st *state.State) string {

return plan

}

func (s *conveySuite) TestPlansRequired(t sweet.T) {

data := `tasks:

foo:

image: foobar

`

default-plan: overridden-plan

tasks:

foo:

image: imaginary

plans:

overridden-plan:

func (d *defaultPlanSuite) TestDefaultPlanFromOverride(t sweet.T) {

data := `tasks:

foo:

image: imaginary

plans:

overridden-plan:

var baseData = `tasks:

foo:

image: notreal

plans:

default:

)

const (

MaxExtendsDepth = 50

)

var (

ErrMaxExtendsDepth = errors.New("exceeded allowed depth for extended configs")

)

data := `

tasks:

a:

image: alpine:3.6

environment:

- X=1

- Y=2

b:

task: a

environment:

- X=3

data := `

tasks:

a:

image: alpine:3.6

environment:

- X=1

- Y=2

b:

task: a

environment:

- X=3

c:

task: b

environment:

- X=4

data := `

tasks:

a:

task: b

b:

task: a

plans:

default:

data := `

tasks:

b:

task: a

plans:

default:

- x=1

tasks:

foo:

image: imaginary

environment:

- x=2

- x=3

tasks:

bar:

task: foo

environment:

- x=3

data1 := `

tasks:

pre:

image: pre

post:

image: post

foo:

image: foo

plans:

plan1:

extends: base1.yaml

tasks:

bar:

image: bar

plans:

plan1:

extends: base2.yaml

tasks:

baz:

image: baz

plans:

plan1:

data1 := `

tasks:

foo:

image: foo

plans:

plan1:

extends: base1.yaml

tasks:

bar:

image: bar

plans:

plan2:

data1 := `

tasks:

foo:

image: foo

plans:

plan1:

extends: base1.yaml

tasks:

bar:

image: bar

plans:

plan1:

data1 := `

tasks:

foo:

image: foo

plans:

plan1:

- z=3

tasks:

foo:

image: imaginary1

bar:

image: imaginary2

baz:

image: imaginary3

plans:

plan1:

- w=4

tasks:

bonk:

image: imaginary4

plans:

plan2:

- z=3

tasks:

foo:

image: imaginary1

bar:

image: imaginary2

baz:

image: imaginary3

plans:

plan1:

- z=4

tasks:

baz:

image: imaginary4

plans:

plan1:

default-plan: plan1

tasks:

foo:

image: imaginary1

plans:

plan1:

default-plan: plan2

tasks:

bar:

image: imaginary1

plans:

plan2:

default-plan: plan1

tasks:

foo:

image: imaginary1

`

default-plan: plan1

tasks:

foo:

image: imaginary1

`

"bitbucket.org/rw_grim/convey/color"

)

func NewAdapter(identifier string) *gomol.LogAdapter {

attrs := gomol.NewAttrsFromMap(map[string]interface{}{

"id": identifier,

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

package logging

import (

// Package network provides the interface creating networks.

package network

type Network interface {

Name() string

Destroy() error

re = regexp.MustCompile("[^._A-Za-z0-9-]")

}

func Normalize(in string) string {

return re.ReplaceAllLiteralString(in, "_")

}

return realPath, nil

}

func TraversesNonExistent(root, path string) (string, error) {

// attempt to do a normal traversal

realPath, err := Traverses(root, path)

"fmt"

)

type MetaPlan struct {

Plans []string `yaml:"plans"`

}

func (m *MetaPlan) UnmarshalYAML(unmarshal func(interface{}) error) error {

type rawMetaPlan MetaPlan

raw := rawMetaPlan{}

)

var (

ErrNoStages = errors.New("no stages found")

)

type Plan struct {

Environment yaml.StringOrSlice `yaml:"environment"`

Stages []stages.Stage `yaml:"stages"`

}

}

func (p *Plan) Execute(path string, tasks map[string]tasks.Task, env []string, st *state.State) error {

logger := logging.NewAdapter(path)

planEnv := environment.Merge(env, p.Environment)

return planErr

}

func (p *Plan) Valid() error {

if len(p.Stages) == 0 {

return ErrNoStages

"bitbucket.org/rw_grim/convey/state"

)

type Default struct{}

func (d *Default) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

logger := logging.NewAdapter("convey-runner")

/* now look for the plan */

var normalizeRegex *regexp.Regexp

type (

Graphviz struct{}

Normalized string

Name string

}

Normalized string

Name string

Enabled bool

Concurrent bool

Always bool

Tasks []string

}

Normalized string

Name string

Color string

}

Normalized string

Name string

Color string

}

)

return prefix + "_" + normalizeRegex.ReplaceAllString(str, "_")

}

Normalized: normalize("task", name),

Name: name,

}

return tasks

}

for name, cMetaPlan := range cfg.MetaPlans {

Normalized: normalize("metaplan", name),

Name: name,

Color: color.X11(name),

return metaPlans

}

Normalized: normalize("plan", name),

Name: name,

Color: color.X11(name),

}

for idx, stage := range plan.Stages {

Normalized: normalize("stage", stage.Name),

Name: stage.Name,

Enabled: stage.Enabled,

return graphvizPlan

}

for name, plan := range cfg.Plans {

plans = append(plans, g.plan(name, plan))

return plans

}

func (g *Graphviz) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

logger := logging.NewAdapter("graphviz")

"bitbucket.org/rw_grim/convey/state"

)

type ListEnvironment struct{}

func (l *ListEnvironment) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

fmt.Printf("Builtins:\n")

stateEnv := st.GetEnv()

"bitbucket.org/rw_grim/convey/state"

)

type ListMetaPlans struct{}

func (l *ListMetaPlans) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

for metaPlanName, metaPlan := range cfg.MetaPlans {

fmt.Printf("%s\n", metaPlanName)

"bitbucket.org/rw_grim/convey/state"

)

type ListPlans struct{}

func (l *ListPlans) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

for planName, plan := range cfg.Plans {

fmt.Printf("%s\n", planName)

"bitbucket.org/rw_grim/convey/state"

)

type ListTasks struct{}

func (l *ListTasks) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

tasks := []string{}

tasks = append(tasks, taskName)

}

"bitbucket.org/rw_grim/convey/state"

)

type Runner interface {

Run(cfg *config.Config, plan []string, env []string, st *state.State) int

}

"bitbucket.org/rw_grim/convey/state"

)

type ShowConfig struct{}

func (sc *ShowConfig) Run(cfg *config.Config, plans []string, env []string, st *state.State) int {

spew.Dump(cfg)

return false, err

}

func ShouldEnable(identities []string) (bool, error) {

if len(identities) <= 0 {

return false, nil

"bitbucket.org/rw_grim/convey/yaml"

)

type Stage struct {

Name string `yaml:"name"`

Enabled bool `yaml:"enabled"`

Tasks yaml.StringOrSlice `yaml:"tasks"`

}

func (s *Stage) UnmarshalYAML(unmarshal func(interface{}) error) error {

type rawStage Stage

raw := rawStage{Enabled: true}

return nil

}

func (s *Stage) Execute(path string, logger *gomol.LogAdapter, taskMap map[string]tasks.Task, env []string, st *state.State) error {

stageEnv := environment.Merge(env, s.Environment)

"bitbucket.org/rw_grim/convey/workspace"

)

type State struct {

CfgPath string

CleanupList *cleanup.List

mutex sync.RWMutex

}

func New() *State {

return &State{

runningContainers: map[string]struct{}{},

// never a useful case - a high expansion limit should catch this

// without ever hitting a practical edge.

next, err := st.expandSlice(prev, fullEnv)

if err != nil {

return nil, err

Expect(err.Error()).To(ContainSubstring("hit limit"))

}

names := getNames("foo $bar ${baz} ${bar} $bonk_quux honk")

Expect(names).To(HaveLen(4))

Expect(names).To(ConsistOf([]string{"bar", "baz", "bar", "bonk_quux"}))

}

p := product(map[string][]string{

"a": []string{"1", "2", "3"},

"b": []string{"4", "5"},

"bitbucket.org/rw_grim/convey/state"

)

type Task interface {

Execute(name string, logger *gomol.LogAdapter, env []string, st *state.State) error

New() Task

Valid() error

}

type ResolvableTask interface {

// Resolve is called by the loader once the current set of tasks

// by name have been loaded from the config file.