replace parser with actions/workflow-parser

vendor/github.com/actions/workflow-parser/model/configuration.go

@@ -0,0 +1,73 @@
+package model
+
+// Configuration is a parsed main.workflow file
+type Configuration struct {
+	Actions   []*Action
+	Workflows []*Workflow
+}
+
+// Action represents a single "action" stanza in a .workflow file.
+type Action struct {
+	Identifier string
+	Uses       Uses
+	Runs, Args ActionCommand
+	Needs      []string
+	Env        map[string]string
+	Secrets    []string
+}
+
+// ActionCommand represents the optional "runs" and "args" attributes.
+// Each one takes one of two forms:
+//   - runs="entrypoint arg1 arg2 ..."
+//   - runs=[ "entrypoint", "arg1", "arg2", ... ]
+// If the user uses the string form, "Raw" contains that value, and
+// "Parsed" contains an array of the string value split at whitespace.
+// If the user uses the array form, "Raw" is empty, and "Parsed" contains
+// the array.
+type ActionCommand struct {
+	Raw    string
+	Parsed []string
+}
+
+// Workflow represents a single "workflow" stanza in a .workflow file.
+type Workflow struct {
+	Identifier string
+	On         string
+	Resolves   []string
+}
+
+// GetAction looks up action by identifier.
+//
+// If the action is not found, nil is returned.
+func (c *Configuration) GetAction(id string) *Action {
+	for _, action := range c.Actions {
+		if action.Identifier == id {
+			return action
+		}
+	}
+	return nil
+}
+
+// GetWorkflow looks up a workflow by identifier.
+//
+// If the workflow is not found, nil is returned.
+func (c *Configuration) GetWorkflow(id string) *Workflow {
+	for _, workflow := range c.Workflows {
+		if workflow.Identifier == id {
+			return workflow
+		}
+	}
+	return nil
+}
+
+// GetWorkflows gets all Workflow structures that match a given type of event.
+// e.g., GetWorkflows("push")
+func (c *Configuration) GetWorkflows(eventType string) []*Workflow {
+	var ret []*Workflow
+	for _, workflow := range c.Workflows {
+		if IsMatchingEventType(workflow.On, eventType) {
+			ret = append(ret, workflow)
+		}
+	}
+	return ret
+}

vendor/github.com/actions/workflow-parser/model/eventtypes.go

@@ -0,0 +1,55 @@
+package model
+
+import (
+	"strings"
+)
+
+// IsAllowedEventType returns true if the event type is supported.
+func IsAllowedEventType(eventType string) bool {
+	_, ok := eventTypeWhitelist[strings.ToLower(eventType)]
+	return ok
+}
+
+// IsMatchingEventType checks to see if the "flowOn" string from a flow's on attribute matches the incoming webhook of type eventType.
+func IsMatchingEventType(flowOn, eventType string) bool {
+	return strings.ToLower(flowOn) == strings.ToLower(eventType)
+}
+
+// https://developer.github.com/actions/creating-workflows/workflow-configuration-options/#events-supported-in-workflow-files
+var eventTypeWhitelist = map[string]struct{}{
+	"check_run":                   {},
+	"check_suite":                 {},
+	"commit_comment":              {},
+	"create":                      {},
+	"delete":                      {},
+	"deployment":                  {},
+	"deployment_status":           {},
+	"fork":                        {},
+	"gollum":                      {},
+	"issue_comment":               {},
+	"issues":                      {},
+	"label":                       {},
+	"member":                      {},
+	"milestone":                   {},
+	"page_build":                  {},
+	"project_card":                {},
+	"project_column":              {},
+	"project":                     {},
+	"public":                      {},
+	"pull_request_review_comment": {},
+	"pull_request_review":         {},
+	"pull_request":                {},
+	"push":                        {},
+	"release":                     {},
+	"repository_dispatch":         {},
+	"status":                      {},
+	"watch":                       {},
+}
+
+func AddAllowedEventType(s string) {
+	eventTypeWhitelist[s] = struct{}{}
+}
+
+func RemoveAllowedEventType(s string) {
+	delete(eventTypeWhitelist, s)
+}

vendor/github.com/actions/workflow-parser/model/uses.go

@@ -0,0 +1,57 @@
+package model
+
+import (
+	"fmt"
+)
+
+type Uses interface {
+	fmt.Stringer
+	isUses()
+}
+
+// UsesDockerImage represents `uses = "docker://<image>"`
+type UsesDockerImage struct {
+	Image string
+}
+
+// UsesRepository represents `uses = "<owner>/<repo>[/<path>]@<ref>"`
+type UsesRepository struct {
+	Repository string
+	Path       string
+	Ref        string
+}
+
+// UsesPath represents `uses = "./<path>"`
+type UsesPath struct {
+	Path string
+}
+
+// UsesInvalid represents any invalid `uses = "<raw>"` value
+type UsesInvalid struct {
+	Raw string
+}
+
+func (u *UsesDockerImage) isUses() {}
+func (u *UsesRepository) isUses()  {}
+func (u *UsesPath) isUses()        {}
+func (u *UsesInvalid) isUses()     {}
+
+func (u *UsesDockerImage) String() string {
+	return fmt.Sprintf("docker://%s", u.Image)
+}
+
+func (u *UsesRepository) String() string {
+	if u.Path == "" {
+		return fmt.Sprintf("%s@%s", u.Repository, u.Ref)
+	}
+
+	return fmt.Sprintf("%s/%s@%s", u.Repository, u.Path, u.Ref)
+}
+
+func (u *UsesPath) String() string {
+	return fmt.Sprintf("./%s", u.Path)
+}
+
+func (u *UsesInvalid) String() string {
+	return u.Raw
+}