Update to go 1.18 and add nix for the dev environment

.envrc

@@ -0,0 +1 @@
+use nix

.gitignore

@@ -2,3 +2,4 @@ campaigner
 campaign.json
 template.tmpl
 tickets.csv
+vendor/

.gitlab-ci.yml

@@ -1,18 +1,15 @@
-image: golang:1.14-buster
+image: golang:1.18-buster
 
 fmt:
   stage: lint
   script:
-    - go fmt -mod=vendor ./...
+    - go fmt ./...
     - if [[ -n $(git status --porcelain) ]]; then echo "The code is not correctly formatted"; exit 1; fi
 
 build:
   stage: build
   script:
     - make build
-  artifacts:
-    paths:
-      - campaigner
 
 stages:
   - lint

LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2015, Dave Cheney <dave@cheney.net>
+BSD 3-Clause License
+
+Copyright (c) 2020, Miguel de la Cruz
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -11,6 +13,10 @@ modification, are permitted provided that the following conditions are met:
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

Makefile

@@ -8,7 +8,7 @@ check:
 	golangci-lint run -E gofmt ./...
 
 build:
-	go build -mod=vendor
+	go build
 
 install:
-	go install -mod=vendor
+	go install

README.md

@@ -4,9 +4,11 @@ Command line tool to create and manage community campaigns. `campaigner` takes c
 
  - `campaigner init` generates the campaign file, linking it to the jira instance and github repository and to the epic issue that will host each campaign ticket.
  - `campaigner add` parses information from different sources and uses it to generate tickets for the campaign.
+ - `campaigner label` lists and modifies the campaign's labels for GitHub.
  - `campaigner publish` builds the tickets information and publishes it both to jira and github.
  - `campaigner sync` downloads updated information of the campaign progress.
  - `campaigner status` shows the current campaign data and progression.
+ - `campaigner list` shows the current campaign tickets and their status.
  - `campaigner report` generates reports from the campaign data.
 
 ## Install
@@ -35,17 +37,10 @@ The template body can use as well the [JIRA text formatting notation](https://ji
 
 Lastly, before creating the campaign, we can add a template to act as a footer for the tickets when being created in GitHub. In this case, the template will receive the ticket struct, so we can use any of its properties. This footer template supports GitHub Markdown.
 
-Once we have both files, we can run `campaigner init` to create the campaign:
+Once we have both files, we can run `campaigner init` to create the campaign. The command can be run without any arguments or flags and it will request the mandatory pieces of information interactively:
 
 ```sh
-$ campaigner init --help
+$ campaigner init \
-Creates a new campaign in the current directory
-
-Usage:
-  campaigner init [flags]
-
-Examples:
-  campaigner init \
     --jira-username johndoe \
     --jira-token secret \
     --github-token TOKEN \
@@ -57,27 +52,18 @@ Examples:
     --summary 'Refactor {{.function}} to inject the configuration service' \
     --issue-template ./refactor-config.tmpl \
     --footer-template ./github-footer.tmpl
-
-
-Flags:
-  -e, --epic string              the epic id to associate this campaign with
-  -f, --footer-template string   the template path to append to the github issues as a footer
-      --github-token string      the github token
-  -h, --help                     help for init
-  -t, --issue-template string    the template path for the description of the tickets
-  -i, --issue-type string        the issue type to create the tickets as (default "Story")
-      --jira-token string        the jira token or password
-      --jira-username string     the jira username
-  -l, --label strings            the labels to add to the Github issues
-  -r, --repository string        the github repository
-  -s, --summary string           the summary of the tickets
-  -u, --url string               the jira server URL
 ```
 
-If there is any mandatory flag that we don't use, we will be asked for it interactively by the tool.
-
 The `summary` of the campaign can be a go template as well, that will receive the same properties described above for the issue template.
 
+### Modifying campaign GitHub labels
+
+`campaigner` can add labels to the GitHub tickets when creating them. Labels can be added to the campaign as part of the `init` command, but they can be managed as well when the campaign is already created with the `campaigner label` commands:
+
+ - `campaigner label list` lists the current campaign labels.
+ - `campaigner label remote` lists the labels that exist in the remote GitHub repository.
+ - `campaigner label update` opens `$EDITOR` with the campaign labels and allows you to add / remove / edit them, saving them when the editor closes. It will error if a label doesn't exist in the remote repository, but you can skip this check adding the `--skip-check` flag.
+
 ### Adding tickets to the campaign
 
 There are currently three ways to add tickets to a campaign: using `govet`, using `grep` or importing a `csv`. We can add tickets at any point during the campaign lifecycle, and we can use different methods in the same campaign, just remember that the summary and the templates will be filled with whatever properties we have in each ticket, so all of them should have at least those used in the templates.
@@ -89,15 +75,30 @@ You can see more information on how each method works using `campaigner add --he
 Once the campaign is ready, we can see its status running `campaigner status`:
 
 ```sh
+$ campaigner status
 Current campaign for johndoe/testrepo with summary
 Remove the ToDo comment in {{.filename}}:{{.lineNo}}
 
-        351     total tickets
+         67     -         total tickets
-        0/351   published in Jira
+         24   35%     published in Jira
-        0/0     published in Github
+         24   35%   published in Github
+         17   25%              assigned
+          0    0%                closed
 
 ```
 
 The status shows the total of tickets that we have created, how many of those have been published in Jira and of that last amount, how many have been published in GitHub too.
 
 To publish tickets, you can use the `campaigner publish jira` and `campaigner publish github` commands, and you can publish tickets in batches or just publish all of them. When running a publish command, `campaigner` will search the first unpublished tickets and will use the provider APIs to publish them.
+
+### Syncing the campaign status
+
+If we want to check the status of our campaign as it progresses and the tickets get assigned and closed, we have first to sync our local state of the campaign with the status of the tickets we've published:
+
+```sh
+$ campaigner sync
+Updating ticket 9 of 9
+Synchronization completed
+```
+
+This will fetch the current state of the jira tickets and github issues and update our local campaign. Then we can run `campaigner status` to see the updated progress, or we can generate reports from the campaign's information with `campaigner report`.

app/app.go

@@ -0,0 +1,78 @@
+package app
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/google/go-github/v32/github"
+	jira "gopkg.in/andygrunwald/go-jira.v1"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/model"
+)
+
+type App struct {
+	Path string
+
+	JiraClient   *jira.Client
+	GithubClient *github.Client
+	Campaign     *model.Campaign
+}
+
+func SaveCampaign(campaign *model.Campaign, path string) error {
+	marshaledCampaign, err := json.MarshalIndent(campaign, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(path, marshaledCampaign, 0600); err != nil {
+		return fmt.Errorf("cannot save campaign: %w", err)
+	}
+	return nil
+}
+
+func (a *App) Save() error {
+	return SaveCampaign(a.Campaign, a.Path)
+}
+
+func (a *App) Load() error {
+	if _, err := os.Stat("."); err != nil {
+		return fmt.Errorf("cannot read campaign: %w", err)
+	}
+
+	fileContents, err := ioutil.ReadFile(a.Path)
+	if err != nil {
+		return fmt.Errorf("there was a problem reading the campaign file: %w", err)
+	}
+
+	var campaign model.Campaign
+	if err := json.Unmarshal(fileContents, &campaign); err != nil {
+		return fmt.Errorf("there was a problem parsing the campaign file: %w", err)
+	}
+
+	a.Campaign = &campaign
+	return nil
+}
+
+func (a *App) InitClients() error {
+	if err := a.InitGithubClient(); err != nil {
+		return err
+	}
+	if err := a.InitJiraClient(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func NewApp(path string) (*App, error) {
+	app := &App{Path: path}
+
+	if err := app.Load(); err != nil {
+		return nil, err
+	}
+	if err := app.InitClients(); err != nil {
+		return nil, err
+	}
+	return app, nil
+}

app/github.go

@@ -0,0 +1,202 @@
+package app
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"text/template"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/model"
+
+	"github.com/StevenACoffman/j2m"
+	"github.com/google/go-github/v32/github"
+	"golang.org/x/oauth2"
+)
+
+func (a *App) InitGithubClient() error {
+	ctx := context.Background()
+	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: a.Campaign.Github.Token})
+	tc := oauth2.NewClient(ctx, ts)
+
+	a.GithubClient = github.NewClient(tc)
+	return nil
+}
+
+func getFooterTemplate(ticket *model.Ticket, templatePath string) (string, error) {
+	footerTmpl, err := template.ParseFiles(templatePath)
+	if err != nil {
+		return "", err
+	}
+
+	var footerBytes bytes.Buffer
+	if err := footerTmpl.Execute(&footerBytes, ticket); err != nil {
+		return "", err
+	}
+	return footerBytes.String(), nil
+}
+
+func (a *App) PublishInGithub(ticket *model.Ticket, dryRun bool) (*github.Issue, error) {
+	mdDescription := j2m.JiraToMD(ticket.Description)
+	if a.Campaign.FooterTemplate != "" {
+		footer, err := getFooterTemplate(ticket, a.Campaign.FooterTemplate)
+		if err != nil {
+			return nil, err
+		}
+
+		mdDescription += "\n" + footer
+	}
+
+	issueRequest := &github.IssueRequest{
+		Title:  &ticket.Summary,
+		Body:   &mdDescription,
+		Labels: &a.Campaign.Github.Labels,
+	}
+
+	if dryRun {
+		b, _ := json.MarshalIndent(issueRequest, "", "  ")
+		fmt.Println(string(b))
+		return &github.Issue{
+			Title: issueRequest.Title,
+			Body:  issueRequest.Body,
+		}, nil
+	}
+
+	owner, repo := a.Campaign.RepoComponents()
+	newIssue, _, err := a.GithubClient.Issues.Create(context.Background(), owner, repo, issueRequest)
+	if err != nil {
+		return nil, err
+	}
+	return newIssue, nil
+}
+
+func (a *App) PublishNextInGithub(w io.Writer, dryRun bool) (bool, error) {
+	ticket := a.Campaign.NextGithubUnpublishedTicket()
+	if ticket == nil {
+		return false, nil
+	}
+
+	issue, err := a.PublishInGithub(ticket, dryRun)
+	if err != nil {
+		return false, err
+	}
+
+	if dryRun {
+		return true, nil
+	}
+
+	ticket.GithubLink = issue.GetNumber()
+	ticket.GithubStatus = issue.GetState()
+	if err := a.Save(); err != nil {
+		return false, err
+	}
+
+	fmt.Fprintf(w, "Issue published: https://github.com/%s/issues/%d\n", a.Campaign.Github.Repo, ticket.GithubLink)
+
+	if err := a.UpdateJiraAfterGithub(ticket); err != nil {
+		fmt.Fprintf(os.Stderr, "error updating Jira info for %s after publishing in Github\n", ticket.JiraLink)
+	}
+
+	return true, nil
+}
+
+func (a *App) PublishAllInGithub(w io.Writer, dryRun bool) (int, error) {
+	count := 0
+	for {
+		next, err := a.PublishNextInGithub(w, dryRun)
+		if err != nil {
+			return count, err
+		}
+		if !next {
+			break
+		}
+		count++
+	}
+	return count, nil
+}
+
+func (a *App) PublishBatchInGithub(w io.Writer, batch int, dryRun bool) error {
+	for i := 1; i <= batch; i++ {
+		next, err := a.PublishNextInGithub(w, dryRun)
+		if err != nil {
+			return err
+		}
+		if !next {
+			return nil
+		}
+	}
+	return nil
+}
+
+func (a *App) GithubSync() error {
+	tickets := a.Campaign.GetPublishedGithubTickets()
+	total := len(tickets)
+	owner, repo := a.Campaign.RepoComponents()
+
+	for i, ticket := range tickets {
+		fmt.Printf("\rUpdating ticket %d of %d", i+1, total)
+
+		// ticket is on its final stage, continue
+		if ticket.IsAssigned() && ticket.IsClosed() {
+			continue
+		}
+
+		issue, _, err := a.GithubClient.Issues.Get(context.Background(), owner, repo, ticket.GithubLink)
+		if err != nil {
+			return err
+		}
+
+		assignee := issue.GetAssignee()
+		if assignee != nil {
+			ticket.GithubAssignee = assignee.GetLogin()
+		}
+		ticket.GithubStatus = issue.GetState()
+	}
+	fmt.Print("\n")
+
+	return a.Save()
+}
+
+func (a *App) ListLabels() ([]string, error) {
+	owner, repo := a.Campaign.RepoComponents()
+	opts := &github.ListOptions{Page: 0, PerPage: 100}
+	labels, _, err := a.GithubClient.Issues.ListLabels(context.Background(), owner, repo, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	strLabels := make([]string, len(labels))
+	for i, label := range labels {
+		strLabels[i] = *label.Name
+	}
+
+	return strLabels, nil
+}
+
+func (a *App) CheckLabels(labels []string) (bool, []string, error) {
+	ghLabels, err := a.ListLabels()
+	if err != nil {
+		return false, nil, err
+	}
+
+	badLabels := []string{}
+	for _, label := range labels {
+		exists := false
+		for _, ghLabel := range ghLabels {
+			if label == ghLabel {
+				exists = true
+			}
+		}
+
+		if !exists {
+			badLabels = append(badLabels, label)
+		}
+	}
+
+	if len(badLabels) == 0 {
+		return true, nil, nil
+	}
+	return false, badLabels, nil
+}

app/jira.go

@@ -0,0 +1,224 @@
+package app
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+	"text/template"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/model"
+
+	jira "gopkg.in/andygrunwald/go-jira.v1"
+)
+
+const GithubIssueJiraField = "customfield_11106"
+
+func (a *App) InitJiraClient() error {
+	tp := jira.BasicAuthTransport{
+		Username: a.Campaign.Jira.Username,
+		Password: a.Campaign.Jira.Token,
+	}
+
+	client, err := jira.NewClient(tp.Client(), a.Campaign.Jira.Url)
+	if err != nil {
+		return err
+	}
+
+	a.JiraClient = client
+	return nil
+}
+
+func (a *App) UpdateJiraAfterGithub(ticket *model.Ticket) error {
+	data := map[string]interface{}{
+		"fields": map[string]interface{}{
+			GithubIssueJiraField: a.Campaign.GetGithubUrl(ticket),
+			"fixVersions": []map[string]interface{}{
+				{
+					"name": "Help Wanted",
+				},
+			},
+		},
+	}
+
+	_, err := a.JiraClient.Issue.UpdateIssue(ticket.JiraLink, data)
+	return err
+}
+
+func (a *App) GetJiraIssueFromTicket(ticket *model.Ticket) (*jira.Issue, error) {
+	summaryTmpl, err := template.New("").Parse(a.Campaign.Summary)
+	if err != nil {
+		return nil, err
+	}
+
+	var summaryBytes bytes.Buffer
+	if err := summaryTmpl.Execute(&summaryBytes, ticket.Data); err != nil {
+		return nil, err
+	}
+	summary := summaryBytes.String()
+
+	descriptionTemplate, err := template.ParseFiles(a.Campaign.IssueTemplate)
+	if err != nil {
+		return nil, err
+	}
+
+	var descriptionBytes bytes.Buffer
+	if err := descriptionTemplate.Execute(&descriptionBytes, ticket.Data); err != nil {
+		return nil, err
+	}
+	description := descriptionBytes.String()
+
+	data := map[string]string{
+		"Description": description,
+		"Summary":     summary,
+		"Project":     a.Campaign.Jira.Project,
+		"Issue Type":  a.Campaign.Jira.IssueType,
+		"Epic Link":   a.Campaign.Jira.Epic,
+	}
+
+	createMetaInfo, _, err := a.JiraClient.Issue.GetCreateMeta(a.Campaign.Jira.Project)
+	if err != nil {
+		return nil, err
+	}
+
+	project := createMetaInfo.GetProjectWithKey(a.Campaign.Jira.Project)
+	if project == nil {
+		return nil, fmt.Errorf("Error retrieving project with key %s", a.Campaign.Jira.Project)
+	}
+
+	issueType := project.GetIssueTypeWithName(a.Campaign.Jira.IssueType)
+	if issueType == nil {
+		return nil, fmt.Errorf("Error retrieving issue type with name Story")
+	}
+
+	issue, err := jira.InitIssueWithMetaAndFields(project, issueType, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return issue, nil
+}
+
+func (a *App) PublishInJira(ticket *model.Ticket, dryRun bool) (*jira.Issue, error) {
+	issue, err := a.GetJiraIssueFromTicket(ticket)
+	if err != nil {
+		return nil, err
+	}
+
+	if dryRun {
+		b, _ := json.MarshalIndent(issue, "", "  ")
+		fmt.Println(string(b))
+		return issue, nil
+	}
+
+	newIssue, _, err := a.JiraClient.Issue.Create(issue)
+	if err != nil {
+		return nil, err
+	}
+
+	return newIssue, nil
+}
+
+func (a *App) GetIssue(issueNo string) (*jira.Issue, error) {
+	issue, _, err := a.JiraClient.Issue.Get(issueNo, nil)
+	if err != nil {
+		return nil, err
+	}
+	return issue, nil
+}
+
+func (a *App) PublishNextInJira(w io.Writer, dryRun bool) (bool, error) {
+	ticket := a.Campaign.NextJiraUnpublishedTicket()
+	if ticket == nil {
+		return false, nil
+	}
+
+	issue, err := a.PublishInJira(ticket, dryRun)
+	if err != nil {
+		return false, err
+	}
+
+	if dryRun {
+		return true, nil
+	}
+
+	issue, _, err = a.JiraClient.Issue.Get(issue.Key, nil)
+	if err != nil {
+		return false, err
+	}
+
+	ticket.JiraLink = issue.Key
+	ticket.Summary = issue.Fields.Summary
+	ticket.Description = issue.Fields.Description
+	ticket.JiraStatus = issue.Fields.Status.Name
+	if err := a.Save(); err != nil {
+		return false, err
+	}
+
+	fmt.Fprintf(w, "Ticket published: %s/browse/%s\n", strings.TrimSuffix(a.Campaign.Jira.Url, "/"), ticket.JiraLink)
+
+	return true, nil
+}
+
+func (a *App) PublishAllInJira(w io.Writer, dryRun bool) (int, error) {
+	count := 0
+	for {
+		next, err := a.PublishNextInJira(w, dryRun)
+		if err != nil {
+			return count, err
+		}
+		if !next {
+			break
+		}
+		count++
+	}
+	return count, nil
+}
+
+func (a *App) PublishBatchInJira(w io.Writer, batch int, dryRun bool) error {
+	for i := 1; i <= batch; i++ {
+		next, err := a.PublishNextInJira(w, dryRun)
+		if err != nil {
+			return err
+		}
+		if !next {
+			return nil
+		}
+	}
+	return nil
+}
+
+func (a *App) GetTicketsFromJiraEpic() ([]*model.Ticket, error) {
+	jql := fmt.Sprintf("project = %s AND type = %s AND \"Epic Link\" = %s", a.Campaign.Jira.Project, a.Campaign.Jira.IssueType, a.Campaign.Jira.Epic)
+
+	page := 0
+	maxPerPage := 50
+	issues := []jira.Issue{}
+	for {
+		opts := &jira.SearchOptions{StartAt: maxPerPage * page, MaxResults: maxPerPage}
+		pageIssues, _, err := a.JiraClient.Issue.Search(jql, opts)
+		if err != nil {
+			return nil, err
+		}
+
+		issues = append(issues, pageIssues...)
+		if len(pageIssues) < maxPerPage {
+			break
+		}
+		page++
+	}
+
+	tickets := []*model.Ticket{}
+	for _, issue := range issues {
+		// ToDo: if they have github link, fill and fetch github data
+		ticket := &model.Ticket{
+			JiraLink:    issue.Key,
+			JiraStatus:  issue.Fields.Status.Name,
+			Summary:     issue.Fields.Summary,
+			Description: issue.Fields.Description,
+		}
+		tickets = append(tickets, ticket)
+	}
+	return tickets, nil
+}

campaign/campaign.go

@@ -1,40 +0,0 @@
-package campaign
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-
-	"git.ctrlz.es/mgdelacroix/campaigner/model"
-)
-
-func Save(campaign *model.Campaign) error {
-	marshaledCampaign, err := json.MarshalIndent(campaign, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	if err := ioutil.WriteFile("./campaign.json", marshaledCampaign, 0600); err != nil {
-		return fmt.Errorf("cannot save campaign: %w", err)
-	}
-	return nil
-}
-
-func Read() (*model.Campaign, error) {
-	if _, err := os.Stat("."); err != nil {
-		return nil, fmt.Errorf("cannot read campaign: %w", err)
-	}
-
-	fileContents, err := ioutil.ReadFile("./campaign.json")
-	if err != nil {
-		return nil, fmt.Errorf("there was a problem reading the campaign file: %w", err)
-	}
-
-	var campaign model.Campaign
-	if err := json.Unmarshal(fileContents, &campaign); err != nil {
-		return nil, fmt.Errorf("there was a problem parsing the campaign file: %w", err)
-	}
-
-	return &campaign, nil
-}

cmd/add.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
 	"git.ctrlz.es/mgdelacroix/campaigner/model"
 	"git.ctrlz.es/mgdelacroix/campaigner/parsers"
 )
@@ -25,7 +25,7 @@ func GrepAddCmd() *cobra.Command {
 `,
 		Example: `  grep -nriIF --include \*.go cobra.Command | campaigner add grep`,
 		Args:    cobra.NoArgs,
-		Run:     grepAddCmdF,
+		Run:     withApp(grepAddCmdF),
 	}
 
 	cmd.Flags().BoolP("file-only", "f", false, "Generates one ticket per file instead of per match")
@@ -60,7 +60,7 @@ func GovetAddCmd() *cobra.Command {
 `,
 		Example: `  govet ./... 2>&1 | campaigner add govet`,
 		Args:    cobra.NoArgs,
-		Run:     govetAddCmdF,
+		Run:     withApp(govetAddCmdF),
 	}
 
 	cmd.Flags().BoolP("file-only", "f", false, "Generates one ticket per file instead of per match")
@@ -74,7 +74,7 @@ func CsvAddCmd() *cobra.Command {
 		Short:   "Generates the tickets reading a csv file",
 		Example: `  campaigner add csv tickets.csv`,
 		Args:    cobra.ExactArgs(1),
-		Run:     csvAddCmdF,
+		Run:     withApp(csvAddCmdF),
 	}
 }
 
@@ -95,59 +95,40 @@ func AddCmd() *cobra.Command {
 	return cmd
 }
 
-func grepAddCmdF(cmd *cobra.Command, _ []string) {
+func grepAddCmdF(a *app.App, cmd *cobra.Command, _ []string) {
 	fileOnly, _ := cmd.Flags().GetBool("file-only")
 
 	tickets := parsers.ParseWith(parsers.GREP)
+	addedTickets := a.Campaign.AddTickets(tickets, fileOnly)
 
-	cmp, err := campaign.Read()
+	if err := a.Save(); err != nil {
-	if err != nil {
 		ErrorAndExit(cmd, err)
 	}
-
+	cmd.Printf("%d tickets have been added\n", addedTickets)
-	cmp.Tickets = append(cmp.Tickets, tickets...)
-	cmp.Tickets = model.RemoveDuplicateTickets(cmp.Tickets, fileOnly)
-
-	if err := campaign.Save(cmp); err != nil {
-		ErrorAndExit(cmd, err)
-	}
-	cmd.Printf("%d tickets have been added\n", len(tickets))
 }
 
 func agAddCmdF(_ *cobra.Command, _ []string) error {
 	return fmt.Errorf("not implemented yet")
 }
 
-func govetAddCmdF(cmd *cobra.Command, _ []string) {
+func govetAddCmdF(a *app.App, cmd *cobra.Command, _ []string) {
 	fileOnly, _ := cmd.Flags().GetBool("file-only")
 
 	tickets := parsers.ParseWith(parsers.GOVET)
+	addedTickets := a.Campaign.AddTickets(tickets, fileOnly)
 
-	cmp, err := campaign.Read()
+	if err := a.Save(); err != nil {
-	if err != nil {
 		ErrorAndExit(cmd, err)
 	}
-
+	cmd.Printf("%d tickets have been added\n", addedTickets)
-	cmp.Tickets = append(cmp.Tickets, tickets...)
-	cmp.Tickets = model.RemoveDuplicateTickets(cmp.Tickets, fileOnly)
-
-	if err := campaign.Save(cmp); err != nil {
-		ErrorAndExit(cmd, err)
-	}
-	cmd.Printf("%d tickets have been added\n", len(tickets))
 }
 
-func csvAddCmdF(cmd *cobra.Command, args []string) {
+func csvAddCmdF(a *app.App, cmd *cobra.Command, args []string) {
 	file, err := os.Open(args[0])
 	if err != nil {
 		ErrorAndExit(cmd, err)
 	}
 
-	cmp, err := campaign.Read()
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
 	csvReader := csv.NewReader(bufio.NewReader(file))
 	records, err := csvReader.ReadAll()
 	if err != nil {
@@ -160,10 +141,10 @@ func csvAddCmdF(cmd *cobra.Command, args []string) {
 		for i, header := range headers {
 			data[header] = line[i]
 		}
-		cmp.Tickets = append(cmp.Tickets, &model.Ticket{Data: data})
+		a.Campaign.Tickets = append(a.Campaign.Tickets, &model.Ticket{Data: data})
 	}
 
-	if err := campaign.Save(cmp); err != nil {
+	if err := a.Save(); err != nil {
 		ErrorAndExit(cmd, err)
 	}
 	cmd.Printf("%d tickets have been added\n", len(records[1:]))

cmd/completion.go

@@ -0,0 +1,59 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+func CompletionCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "completion",
+		Short: "Generates autocompletions for bash and zsh",
+	}
+
+	cmd.AddCommand(
+		BashCompletionCmd(),
+		ZshCompletionCmd(),
+	)
+
+	return cmd
+}
+
+func BashCompletionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "bash",
+		Short: "Generates autocompletions for bash",
+		Long: `Generates autocompletions for bash. To load them, run:
+
+. <(campaigner completion bash)
+
+To configure your bash shell to load completions for each session, add the above line to your ~/.bashrc`,
+		Run: bashCompletionCmdF,
+	}
+}
+
+func ZshCompletionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "zsh",
+		Short: "Generates autocompletions for zsh",
+		Long: `Generates autocompletions for zsh. To load them, run:
+
+. <(campaigner completion zsh)
+
+To configure your zsh shell to load completions for each session, add the above line to your ~/.zshrc`,
+		Run: zshCompletionCmdF,
+	}
+}
+
+func bashCompletionCmdF(cmd *cobra.Command, args []string) {
+	if err := cmd.Root().GenBashCompletion(cmd.OutOrStdout()); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("unable to generate completions: %w", err))
+	}
+}
+
+func zshCompletionCmdF(cmd *cobra.Command, args []string) {
+	if err := cmd.Root().GenZshCompletion(cmd.OutOrStdout()); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("unable to generate completions: %w", err))
+	}
+}

cmd/init.go

@@ -6,7 +6,7 @@ import (
 	"os"
 	"strings"
 
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
 	"git.ctrlz.es/mgdelacroix/campaigner/model"
 
 	"github.com/spf13/cobra"
@@ -50,6 +50,15 @@ func InitCmd() *cobra.Command {
 }
 
 func initCmdF(cmd *cobra.Command, _ []string) {
+	campaignPath, _ := cmd.Flags().GetString("campaign")
+
+	_, err := os.Stat(campaignPath)
+	if err == nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot use %s as campaign file: file already exists", campaignPath))
+	} else if !os.IsNotExist(err) {
+		ErrorAndExit(cmd, fmt.Errorf("cannot use %s as campaign file: %w", campaignPath, err))
+	}
+
 	getStringFlagOrAskIfEmpty := func(name string, question string) string {
 		val, _ := cmd.Flags().GetString(name)
 		if val == "" {
@@ -78,7 +87,7 @@ func initCmdF(cmd *cobra.Command, _ []string) {
 
 	project := strings.Split(epic, "-")[0]
 
-	cmp := &model.Campaign{
+	campaign := &model.Campaign{
 		Jira: model.ConfigJira{
 			Url:       url,
 			Username:  jiraUsername,
@@ -96,7 +105,7 @@ func initCmdF(cmd *cobra.Command, _ []string) {
 		IssueTemplate:  issueTemplate,
 		FooterTemplate: footerTemplate,
 	}
-	if err := campaign.Save(cmp); err != nil {
+	if err := app.SaveCampaign(campaign, campaignPath); err != nil {
 		ErrorAndExit(cmd, err)
 	}
 }

cmd/label.go

@@ -0,0 +1,141 @@
+package cmd
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
+)
+
+const defaultEditor = "vim"
+
+func ListLabelCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "list",
+		Short: "List the local campaign labels",
+		Args:  cobra.NoArgs,
+		Run:   withApp(listLabelCmdF),
+	}
+}
+
+func RemoteLabelCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "remote",
+		Short: "List all the GitHub repository labels",
+		Args:  cobra.NoArgs,
+		Run:   withApp(remoteLabelCmdF),
+	}
+}
+
+func UpdateLabelCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "update",
+		Short: "Updates the campaign's GitHub labels",
+		Args:  cobra.NoArgs,
+		Run:   withApp(updateLabelCmdF),
+	}
+
+	cmd.Flags().BoolP("skip-check", "s", false, "do not check if the labels exist in the remote repository")
+
+	return cmd
+}
+
+func LabelCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "label",
+		Short: "Commands to manage GitHub labels",
+	}
+
+	cmd.AddCommand(
+		ListLabelCmd(),
+		RemoteLabelCmd(),
+		UpdateLabelCmd(),
+	)
+
+	return cmd
+}
+
+func listLabelCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	for _, label := range a.Campaign.Github.Labels {
+		fmt.Println(label)
+	}
+}
+
+func remoteLabelCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	labels, err := a.ListLabels()
+	if err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot retrieve labels list: %w", err))
+	}
+
+	fmt.Printf("Labels for repository %s:\n\n", color.GreenString(a.Campaign.Github.Repo))
+	for _, label := range labels {
+		fmt.Println(label)
+	}
+}
+
+func updateLabelCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	skipCheck, _ := cmd.Flags().GetBool("skip-check")
+
+	file, err := ioutil.TempFile(os.TempDir(), "campaigner-")
+	if err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot create temp file: %w", err))
+	}
+	defer func() {
+		file.Close()
+		os.Remove(file.Name())
+	}()
+	labelBytes := []byte(strings.Join(a.Campaign.Github.Labels, "\n"))
+	if _, err := file.Write(labelBytes); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot write labels to temp file: %w", err))
+	}
+
+	editor := os.Getenv("EDITOR")
+	if editor == "" {
+		editor = defaultEditor
+	}
+
+	editorCmd := exec.Command(editor, file.Name())
+	editorCmd.Stdout = cmd.OutOrStdout()
+	editorCmd.Stdin = cmd.InOrStdin()
+	editorCmd.Stderr = cmd.ErrOrStderr()
+
+	if err := editorCmd.Run(); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot run editor command: %w", err))
+	}
+
+	newLabelBytes, err := ioutil.ReadFile(file.Name())
+	if err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot read file: %w", err))
+	}
+
+	newLabels := []string{}
+	for _, label := range strings.Split(string(newLabelBytes), "\n") {
+		if label != "" {
+			newLabels = append(newLabels, strings.TrimSpace(label))
+		}
+	}
+
+	if !skipCheck {
+		ok, badLabels, err := a.CheckLabels(newLabels)
+		if err != nil {
+			ErrorAndExit(cmd, fmt.Errorf("cannot check new labels list: %w", err))
+		}
+
+		if !ok {
+			ErrorAndExit(cmd, fmt.Errorf("these labels doesn't exist in the repository:\n\n%s", strings.Join(badLabels, "\n")))
+		}
+	}
+
+	a.Campaign.Github.Labels = newLabels
+	if err := a.Save(); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot save campaign: %w", err))
+	}
+
+	cmd.Println("Labels successfully updated")
+}

cmd/list.go

@@ -0,0 +1,29 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
+)
+
+func ListCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "Prints a list of the campaign's tickets",
+		Long:  "Prints a list of the campaign's tickets with their statuses and external ids",
+		Args:  cobra.NoArgs,
+		Run:   withApp(listCmdF),
+	}
+
+	cmd.Flags().BoolP("published-only", "p", false, "list only published tickets")
+	cmd.Flags().BoolP("links", "l", false, "print full links for jira and github ticket numbers")
+
+	return cmd
+}
+
+func listCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	publishedOnly, _ := cmd.Flags().GetBool("published-only")
+	printLinks, _ := cmd.Flags().GetBool("links")
+
+	a.Campaign.PrintList(publishedOnly, printLinks)
+}

cmd/publish.go

@@ -3,9 +3,8 @@ package cmd
 import (
 	"fmt"
 
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
-	"git.ctrlz.es/mgdelacroix/campaigner/github"
+	"git.ctrlz.es/mgdelacroix/campaigner/model"
-	"git.ctrlz.es/mgdelacroix/campaigner/jira"
 
 	"github.com/spf13/cobra"
 )
@@ -15,7 +14,7 @@ func JiraPublishCmd() *cobra.Command {
 		Use:   "jira",
 		Short: "Publishes the campaign tickets in jira",
 		Args:  cobra.NoArgs,
-		RunE:  jiraPublishCmdF,
+		RunE:  withAppE(jiraPublishCmdF),
 	}
 
 	cmd.Flags().BoolP("all", "a", false, "Publish all the tickets of the campaign")
@@ -30,7 +29,7 @@ func GithubPublishCmd() *cobra.Command {
 		Use:   "github",
 		Short: "Publishes the campaign tickets in github",
 		Args:  cobra.NoArgs,
-		RunE:  githubPublishCmdF,
+		RunE:  withAppE(githubPublishCmdF),
 	}
 
 	cmd.Flags().BoolP("all", "a", false, "Publish all the tickets of the campaign")
@@ -40,6 +39,33 @@ func GithubPublishCmd() *cobra.Command {
 	return cmd
 }
 
+func TicketPublishCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "ticket",
+		Short: "Publishes an already existing jira ticket in Github",
+		Long: `This command publishes a ticket that is outside the campaign and already created in jira, into Github.
+
+It is intended to use for standalone Help Wanted tickets that don't fit into a campaing, but nonetheless need to be published in Github and linked back. It does require of a campaign.json file that describes the connection with both the Jira instance and the GitHub repository, but it will never modify it, so the command can be run pointing to a previously existing campaign which connection details match with the ones that apply for the ticket.
+
+Github labels will not be read from the campaign.json file, so they need to be specified with the --label flag if wanted.`,
+		Example: `  # if we don't want any github label to be added to the ticket
+  $ campaigner publish ticket MM-1234
+
+  # if we want to add some labels in github
+  $ campaigner publish ticket MM-1234 --label Tech/Go --label "Help Wanted"
+
+  # if we want to use a campaign file outside the current directory
+  $ campaigner publish ticket MM-1234 --campaign ~/campaigns/standalone.json`,
+		Args: cobra.ExactArgs(1),
+		RunE: withAppE(ticketPublishCmdF),
+	}
+
+	cmd.Flags().StringSliceP("label", "l", []string{}, "the labels to add to the Github issues")
+	cmd.Flags().Bool("dry-run", false, "Print the tickets information instead of publishing them")
+
+	return cmd
+}
+
 func PublishCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "publish",
@@ -50,12 +76,13 @@ func PublishCmd() *cobra.Command {
 	cmd.AddCommand(
 		GithubPublishCmd(),
 		JiraPublishCmd(),
+		TicketPublishCmd(),
 	)
 
 	return cmd
 }
 
-func jiraPublishCmdF(cmd *cobra.Command, _ []string) error {
+func jiraPublishCmdF(a *app.App, cmd *cobra.Command, _ []string) error {
 	all, _ := cmd.Flags().GetBool("all")
 	batch, _ := cmd.Flags().GetInt("batch")
 	dryRun, _ := cmd.Flags().GetBool("dry-run")
@@ -64,33 +91,23 @@ func jiraPublishCmdF(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("One of --all or --batch flags is required")
 	}
 
-	cmp, err := campaign.Read()
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
-	jiraClient, err := jira.NewClient(cmp.Jira.Url, cmp.Jira.Username, cmp.Jira.Token)
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
 	if all {
-		count, err := jiraClient.PublishAll(cmp, dryRun)
+		count, err := a.PublishAllInJira(cmd.OutOrStdout(), dryRun)
 		if err != nil {
 			ErrorAndExit(cmd, err)
 		}
-		cmd.Printf("All %d tickets successfully published in jira\n", count)
+		cmd.Printf("\nAll %d tickets successfully published in jira\n", count)
 	} else {
-		if err := jiraClient.PublishBatch(cmp, batch, dryRun); err != nil {
+		if err := a.PublishBatchInJira(cmd.OutOrStdout(), batch, dryRun); err != nil {
 			ErrorAndExit(cmd, err)
 		}
-		cmd.Printf("Batch of %d tickets successfully published in jira\n", batch)
+		cmd.Printf("\nBatch of %d tickets successfully published in jira\n", batch)
 	}
 
 	return nil
 }
 
-func githubPublishCmdF(cmd *cobra.Command, _ []string) error {
+func githubPublishCmdF(a *app.App, cmd *cobra.Command, _ []string) error {
 	all, _ := cmd.Flags().GetBool("all")
 	batch, _ := cmd.Flags().GetInt("batch")
 	dryRun, _ := cmd.Flags().GetBool("dry-run")
@@ -99,24 +116,57 @@ func githubPublishCmdF(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("One of --all or --batch flags is required")
 	}
 
-	cmp, err := campaign.Read()
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
-	githubClient := github.NewClient(cmp.Github.Repo, cmp.Github.Token)
-
 	if all {
-		count, err := githubClient.PublishAll(cmp, dryRun)
+		count, err := a.PublishAllInGithub(cmd.OutOrStdout(), dryRun)
 		if err != nil {
 			ErrorAndExit(cmd, err)
 		}
-		cmd.Printf("All %d tickets successfully published in github\n", count)
+		cmd.Printf("\nAll %d tickets successfully published in github\n", count)
 	} else {
-		if err := githubClient.PublishBatch(cmp, batch, dryRun); err != nil {
+		if err := a.PublishBatchInGithub(cmd.OutOrStdout(), batch, dryRun); err != nil {
 			ErrorAndExit(cmd, err)
 		}
-		cmd.Printf("Batch of %d tickets successfully published in github\n", batch)
+		cmd.Printf("\nBatch of %d tickets successfully published in github\n", batch)
+	}
+
+	return nil
+}
+
+func ticketPublishCmdF(a *app.App, cmd *cobra.Command, args []string) error {
+	labels, _ := cmd.Flags().GetStringSlice("label")
+	dryRun, _ := cmd.Flags().GetBool("dry-run")
+
+	jiraTicketId := args[0]
+
+	jiraIssue, err := a.GetIssue(jiraTicketId)
+	if err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot get jira issue %q: %w", jiraTicketId, err))
+	}
+
+	ticket := &model.Ticket{
+		Summary:     jiraIssue.Fields.Summary,
+		Description: jiraIssue.Fields.Description,
+		JiraLink:    jiraTicketId,
+	}
+	// update the campaign labels only to publish the ticket
+	a.Campaign.Github.Labels = labels
+
+	githubIssue, err := a.PublishInGithub(ticket, dryRun)
+	if err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("cannot publish ticket %q in github: %w", jiraTicketId, err))
+	}
+
+	if dryRun {
+		return nil
+	}
+
+	ticket.GithubLink = githubIssue.GetNumber()
+	ticket.GithubStatus = githubIssue.GetState()
+
+	cmd.Printf("Issue published: https://github.com/%s/issues/%d\n", a.Campaign.Github.Repo, ticket.GithubLink)
+
+	if err := a.UpdateJiraAfterGithub(ticket); err != nil {
+		ErrorAndExit(cmd, fmt.Errorf("error updating Jira info for %q after publishing in Github", jiraTicketId))
 	}
 
 	return nil

cmd/pull.go

@@ -1,12 +1,31 @@
 package cmd
 
+import (
+	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
+)
+
 func PullCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:   "pull",
 		Short: "Imports tickets from Jira",
-		Long: "Imports all tickets from a Jira epic issue",
+		Long:  "Imports all tickets from a Jira epic issue. This command is only intended to use when the Jira tickets are already created and we want to use campaigner to import and manage them",
-		RunE: pullCmdF,
+		Args:  cobra.NoArgs,
+		Run:   withApp(pullCmdF),
+	}
 }
 
-	cmd.Flags().BoolP("epic")
+func pullCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	tickets, err := a.GetTicketsFromJiraEpic()
+	if err != nil {
+		ErrorAndExit(cmd, err)
+	}
+
+	addedTickets := a.Campaign.AddTickets(tickets, false)
+
+	if err := a.Save(); err != nil {
+		ErrorAndExit(cmd, err)
+	}
+	cmd.Printf("%d tickets have been added\n", addedTickets)
 }

cmd/report.go

@@ -0,0 +1,33 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
+)
+
+func UsersReportCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "users",
+		Short: "A users report",
+		Args:  cobra.NoArgs,
+		Run:   withApp(userReportCmdF),
+	}
+}
+
+func ReportCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "report",
+		Short: "Generates reports on campaign information",
+	}
+
+	cmd.AddCommand(
+		UsersReportCmd(),
+	)
+
+	return cmd
+}
+
+func userReportCmdF(a *app.App, cmd *cobra.Command, _ []string) {
+	a.Campaign.PrintUserReport()
+}

cmd/root.go

@@ -5,21 +5,59 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
 )
 
+func withApp(f func(*app.App, *cobra.Command, []string)) func(*cobra.Command, []string) {
+	return func(cmd *cobra.Command, args []string) {
+		campaignPath, _ := cmd.Flags().GetString("campaign")
+
+		a, err := app.NewApp(campaignPath)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "ERROR: "+err.Error())
+			os.Exit(1)
+		}
+
+		f(a, cmd, args)
+	}
+}
+
+func withAppE(f func(*app.App, *cobra.Command, []string) error) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		campaignPath, _ := cmd.Flags().GetString("campaign")
+
+		a, err := app.NewApp(campaignPath)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "ERROR: "+err.Error())
+			os.Exit(1)
+		}
+
+		return f(a, cmd, args)
+	}
+}
+
 func RootCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "campaigner",
 		Short: "Create and manage Open Source campaigns",
 	}
 
+	cmd.PersistentFlags().String("campaign", "campaign.json", "the path to the campaign file")
+
 	cmd.AddCommand(
 		AddCmd(),
 		// FilterCmd(),
 		InitCmd(),
+		LabelCmd(),
+		ListCmd(),
 		StatusCmd(),
 		PublishCmd(),
+		PullCmd(),
 		SyncCmd(),
+		ReportCmd(),
+		CompletionCmd(),
+		UICmd(),
 	)
 
 	return cmd

cmd/status.go

@@ -1,9 +1,9 @@
 package cmd
 
 import (
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
-
 	"github.com/spf13/cobra"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
 )
 
 func StatusCmd() *cobra.Command {
@@ -12,15 +12,10 @@ func StatusCmd() *cobra.Command {
 		Short: "Prints the campaign status",
 		Long:  "Prints the current status of the campaign and its tickets",
 		Args:  cobra.NoArgs,
-		Run:   statusCmdF,
+		Run:   withApp(statusCmdF),
 	}
 }
 
-func statusCmdF(cmd *cobra.Command, _ []string) {
+func statusCmdF(a *app.App, cmd *cobra.Command, _ []string) {
-	cmp, err := campaign.Read()
+	a.Campaign.PrintStatus()
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
-	cmp.PrintStatus()
 }

cmd/sync.go

@@ -1,61 +1,24 @@
 package cmd
 
 import (
-	"fmt"
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
-	"encoding/json"
 
 	"github.com/spf13/cobra"
-
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
-	"git.ctrlz.es/mgdelacroix/campaigner/jira"
-	"git.ctrlz.es/mgdelacroix/campaigner/model"
 )
 
 func SyncCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:   "sync",
 		Short: "Syncs the tickets",
 		Long:  "Synchronizes the status of the published tickets with remote providers",
 		Args:  cobra.NoArgs,
-		Run:   syncCmdF,
+		Run:   withApp(syncCmdF),
+	}
 }
 
-	cmd.Flags().BoolP("all", "a", false, "syncs all the published tickets")
+func syncCmdF(a *app.App, cmd *cobra.Command, _ []string) {
-	cmd.Flags().StringP("jira-issue", "j", "", "syncs a ticket by Jira issue number")
+	if err := a.GithubSync(); err != nil {
-	cmd.Flags().IntP("github-issue", "g", 0, "syncs a ticket by GitHub issue number")
-
-	return cmd
-}
-
-func syncCmdF(cmd *cobra.Command, _ []string) {
-	jiraIssue, _ := cmd.Flags().GetString("jira-issue")
-	// githubIssue, _ := cmd.Flags().GetInt()
-
-	// check that one is defined, or all
-
-	cmp, err := campaign.Read()
-	if err != nil {
 		ErrorAndExit(cmd, err)
 	}
-
+	cmd.Println("Synchronization completed")
-	var ticket *model.Ticket
-	if jiraIssue != "" {
-		ticket = cmp.GetByJiraIssue(jiraIssue)
-		if ticket == nil {
-			ErrorAndExit(cmd, fmt.Errorf("Could not find jira issue %s", jiraIssue))
-		}
-	}
-
-	jiraClient, err := jira.NewClient(cmp.Jira.Url, cmp.Jira.Username, cmp.Jira.Token)
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-
-	i, _, err := jiraClient.Issue.Get(ticket.JiraIssue(), nil)
-	if err != nil {
-		ErrorAndExit(cmd, err)
-	}
-	b, _ := json.MarshalIndent(i.Fields, "", "  ")
-
-	fmt.Printf(string(b))
 }

cmd/ui.go

@@ -0,0 +1,115 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"git.ctrlz.es/mgdelacroix/campaigner/app"
+	"git.ctrlz.es/mgdelacroix/campaigner/model"
+	"github.com/spf13/cobra"
+
+	"github.com/charmbracelet/bubbles/list"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+var docStyle = lipgloss.NewStyle().Margin(1, 2)
+
+func UICmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "ui",
+		Short: "Shows the campaigner UI",
+		Args:  cobra.NoArgs,
+		RunE:  withAppE(uiCmdF),
+	}
+}
+
+type item struct {
+	title, desc string
+}
+
+func (i item) Title() string       { return i.title }
+func (i item) Description() string { return i.desc }
+func (i item) FilterValue() string { return i.title }
+
+type uiModel struct {
+	list list.Model
+}
+
+func (m uiModel) Init() tea.Cmd {
+	return nil
+}
+
+func (m uiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if msg.String() == "ctrl+q" {
+			return m, tea.Quit
+		}
+	case tea.WindowSizeMsg:
+		h, v := docStyle.GetFrameSize()
+		m.list.SetSize(msg.Width-h, msg.Height-v)
+	}
+
+	var cmd tea.Cmd
+	m.list, cmd = m.list.Update(msg)
+	return m, cmd
+}
+
+func (m uiModel) View() string {
+	return docStyle.Render(m.list.View())
+}
+
+func renderTicketDescription(ticket *model.Ticket) string {
+	var status, bgColor string
+	if ticket.IsClosed() {
+		status = "closed"
+		bgColor = "#DB0202"
+	} else if ticket.IsAssigned() {
+		status = fmt.Sprintf("assigned [%s]", ticket.GithubAssignee)
+		bgColor = "#146300"
+	} else if ticket.IsPublishedGithub() {
+		status = "github"
+		bgColor = "#171515"
+	} else if ticket.IsPublishedJira() {
+		status = "jira"
+		bgColor = "#0052CC"
+	} else {
+		status = "unpublished"
+		bgColor = "#8C6700"
+	}
+
+	style := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#FAFAFA")).
+		Background(lipgloss.Color(bgColor)).
+		Padding(0, 2)
+
+	return fmt.Sprintf("Status: %s", style.Render(status))
+}
+
+func uiCmdF(a *app.App, cmd *cobra.Command, _ []string) error {
+	items := make([]list.Item, len(a.Campaign.Tickets))
+	for i, ticket := range a.Campaign.Tickets {
+		title := ticket.Summary
+		if title == "" {
+			b, err := json.Marshal(ticket.Data)
+			if err != nil {
+				return fmt.Errorf("cannot marshal ticket data: %w", err)
+			}
+			title = string(b)
+		}
+		items[i] = item{title, renderTicketDescription(ticket)}
+	}
+
+	delegate := list.NewDefaultDelegate()
+
+	m := uiModel{list: list.New(items, delegate, 0, 0)}
+	m.list.Title = fmt.Sprintf("Campaign: %q", a.Campaign.Summary)
+
+	p := tea.NewProgram(m)
+	if _, err := p.Run(); err != nil {
+		return err
+	}
+
+	return nil
+}

github/github.go

@@ -1,134 +0,0 @@
-package github
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"text/template"
-
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
-	"git.ctrlz.es/mgdelacroix/campaigner/model"
-
-	"github.com/StevenACoffman/j2m"
-	"github.com/google/go-github/v29/github"
-	"golang.org/x/oauth2"
-)
-
-type GithubClient struct {
-	*github.Client
-	Repo string
-}
-
-func NewClient(repo, token string) *GithubClient {
-	ctx := context.Background()
-	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
-	tc := oauth2.NewClient(ctx, ts)
-
-	client := github.NewClient(tc)
-	return &GithubClient{
-		Client: client,
-		Repo:   repo,
-	}
-}
-
-func getFooterTemplate(ticket *model.Ticket, templatePath string) (string, error) {
-	footerTmpl, err := template.ParseFiles(templatePath)
-	if err != nil {
-		return "", err
-	}
-
-	var footerBytes bytes.Buffer
-	if err := footerTmpl.Execute(&footerBytes, ticket); err != nil {
-		return "", err
-	}
-	return footerBytes.String(), nil
-}
-
-func (c *GithubClient) PublishTicket(ticket *model.Ticket, cmp *model.Campaign, dryRun bool) (*github.Issue, error) {
-	mdDescription := j2m.JiraToMD(ticket.Description)
-	if cmp.FooterTemplate != "" {
-		footer, err := getFooterTemplate(ticket, cmp.FooterTemplate)
-		if err != nil {
-			return nil, err
-		}
-
-		mdDescription += "\n" + footer
-	}
-
-	issueRequest := &github.IssueRequest{
-		Title:  &ticket.Summary,
-		Body:   &mdDescription,
-		Labels: &cmp.Github.Labels,
-	}
-
-	if dryRun {
-		b, _ := json.MarshalIndent(issueRequest, "", "  ")
-		fmt.Println(string(b))
-		return &github.Issue{
-			Title: issueRequest.Title,
-			Body:  issueRequest.Body,
-		}, nil
-	}
-
-	owner, repo := cmp.RepoComponents()
-	newIssue, _, err := c.Issues.Create(context.Background(), owner, repo, issueRequest)
-	if err != nil {
-		return nil, err
-	}
-	return newIssue, nil
-}
-
-func (c *GithubClient) PublishNextTicket(cmp *model.Campaign, dryRun bool) (bool, error) {
-	ticket := cmp.NextGithubUnpublishedTicket()
-	if ticket == nil {
-		return false, nil
-	}
-
-	issue, err := c.PublishTicket(ticket, cmp, dryRun)
-	if err != nil {
-		return false, err
-	}
-
-	if dryRun {
-		return true, nil
-	}
-
-	ticket.GithubLink = issue.GetNumber()
-	if user := issue.GetUser(); user != nil {
-		ticket.GithubAssignee = user.GetLogin()
-	}
-	ticket.GithubStatus = issue.GetState()
-	if err := campaign.Save(cmp); err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (c *GithubClient) PublishAll(cmp *model.Campaign, dryRun bool) (int, error) {
-	count := 0
-	for {
-		next, err := c.PublishNextTicket(cmp, dryRun)
-		if err != nil {
-			return count, err
-		}
-		if !next {
-			break
-		}
-		count++
-	}
-	return count, nil
-}
-
-func (c *GithubClient) PublishBatch(cmp *model.Campaign, batch int, dryRun bool) error {
-	for i := 1; i <= batch; i++ {
-		next, err := c.PublishNextTicket(cmp, dryRun)
-		if err != nil {
-			return err
-		}
-		if !next {
-			return nil
-		}
-	}
-	return nil
-}

go.mod

@@ -1,14 +1,51 @@
 module git.ctrlz.es/mgdelacroix/campaigner
 
-go 1.13
+go 1.18
 
 require (
-	github.com/StevenACoffman/j2m v0.0.0-20190826163711-7d8d00c99217
+	github.com/StevenACoffman/j2m v0.0.0-20221129131709-a8330742260e
-	github.com/fatih/color v1.9.0
+	github.com/charmbracelet/bubbles v0.16.1
-	github.com/fatih/structs v1.1.0 // indirect
+	github.com/charmbracelet/bubbletea v0.24.2
-	github.com/google/go-github/v29 v29.0.3
+	github.com/charmbracelet/lipgloss v0.7.1
-	github.com/spf13/cobra v0.0.6
+	github.com/fatih/color v1.15.0
-	github.com/trivago/tgo v1.0.7 // indirect
+	github.com/google/go-github/v32 v32.1.0
-	golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be
+	github.com/spf13/cobra v1.7.0
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/oauth2 v0.10.0
 	gopkg.in/andygrunwald/go-jira.v1 v1.8.0
 )
+
+require (
+	github.com/atotto/clipboard v0.1.4 // indirect
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/fatih/structs v1.1.0 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/google/go-querystring v1.0.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.18 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/reflow v0.3.0 // indirect
+	github.com/muesli/termenv v0.15.1 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	github.com/sahilm/fuzzy v0.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/trivago/tgo v1.0.7 // indirect
+	golang.org/x/crypto v0.11.0 // indirect
+	golang.org/x/net v0.12.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/sys v0.10.0 // indirect
+	golang.org/x/term v0.10.0 // indirect
+	golang.org/x/text v0.11.0 // indirect
+	google.golang.org/appengine v1.6.7 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -1,156 +1,112 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/StevenACoffman/j2m v0.0.0-20221129131709-a8330742260e h1:qkjvD01/uaaDh1sXxbE2qYdPPhn5quRPupYAvpc+Uo4=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/StevenACoffman/j2m v0.0.0-20221129131709-a8330742260e/go.mod h1:y1vzL6Jab7oLzLLE2CtItTyEI6hKQnNMmqDrO+2a7Pk=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
-github.com/StevenACoffman/j2m v0.0.0-20190826163711-7d8d00c99217 h1:y2QXqPIec+mEDDToinjdFymzQZmLNRIKtuOkdomqyA4=
+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/StevenACoffman/j2m v0.0.0-20190826163711-7d8d00c99217/go.mod h1:y1vzL6Jab7oLzLLE2CtItTyEI6hKQnNMmqDrO+2a7Pk=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY=
-github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c=
-github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY=
-github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
-github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
-github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
-github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/google/go-github/v29 v29.0.3 h1:IktKCTwU//aFHnpA+2SLIi7Oo9uhAzgsdZNbcAqhgdc=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-github/v29 v29.0.3/go.mod h1:CHKiKKPHJ0REzfwc14QMklvtHwCveD0PxlMjLlzAM5E=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-github/v32 v32.1.0 h1:GWkQOdXqviCPx7Q7Fj+KyPoGm4SwHRh8rheoPhd27II=
+github.com/google/go-github/v32 v32.1.0/go.mod h1:rIEpZD9CTDQwDK9GDrtMTycQNA4JU3qBsCizh3q2WCI=
 github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
-github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
-github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
-github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34=
-github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho=
-github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
-github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
-github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
+github.com/muesli/termenv v0.15.1 h1:UzuTb/+hhlBugQz28rpzey4ZuKcZ03MeKsoG7IJZIxs=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/sahilm/fuzzy v0.1.0 h1:FzWGaw2Opqyu+794ZQ9SYifWv2EIXpwP4q8dY1kDAwI=
-github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/sahilm/fuzzy v0.1.0/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v0.0.6 h1:breEStsVwemnKh2/s6gMvSdMEkwW0sK8vGStnlVBMCs=
-github.com/spf13/cobra v0.0.6/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
-github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/trivago/tgo v1.0.7 h1:uaWH/XIy9aWYWpjm2CU3RpcqZXmX2ysQ9/Go+d9gyrM=
 github.com/trivago/tgo v1.0.7/go.mod h1:w4dpD+3tzNIIiIfkWWa85w5/B77tlvdZckQ+6PkFnhc=
-github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
-github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
-github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
-go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190522155817-f3200d17e092 h1:4QSRKanuywn15aTZvI/mIDEgPQpswuFndXpOj3rKEco=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
+golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/oauth2 v0.10.0 h1:zHCpF2Khkwy4mMB4bv0U37YtJdTGW8jI0glAApi0Kh8=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/oauth2 v0.10.0/go.mod h1:kTpgurOux7LqtuxjuyZa4Gj2gdezIt/jQtGnNFfypQI=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037 h1:YyJpGZS1sBuBCzLAR1VEpK193GlqGZbnPFnPV/5Rsb4=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.10.0 h1:3R7pNqamzBraeqj/Tj8qt1aQ2HpmlC+Cx/qL/7hn4/c=
+golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/andygrunwald/go-jira.v1 v1.8.0 h1:yWx1yYM4zlS04NEr+1j7SLUss7BMydYb6EGdOQu1i1w=
 gopkg.in/andygrunwald/go-jira.v1 v1.8.0/go.mod h1:hNeNKrZGMnxaFGE31KAok3B0GoOGEQPZsAv7Ffyn3/I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

jira/jira.go

@@ -1,171 +0,0 @@
-package jira
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"text/template"
-
-	"git.ctrlz.es/mgdelacroix/campaigner/campaign"
-	"git.ctrlz.es/mgdelacroix/campaigner/model"
-
-	jira "gopkg.in/andygrunwald/go-jira.v1"
-)
-
-type JiraClient struct {
-	*jira.Client
-}
-
-func NewClient(url, username, token string) (*JiraClient, error) {
-	tp := jira.BasicAuthTransport{
-		Username: username,
-		Password: token,
-	}
-
-	client, err := jira.NewClient(tp.Client(), url)
-	if err != nil {
-		return nil, err
-	}
-
-	return &JiraClient{client}, nil
-}
-
-func (c *JiraClient) GetIssueFromTicket(ticket *model.Ticket, cmp *model.Campaign) (*jira.Issue, error) {
-	summaryTmpl, err := template.New("").Parse(cmp.Summary)
-	if err != nil {
-		return nil, err
-	}
-
-	var summaryBytes bytes.Buffer
-	if err := summaryTmpl.Execute(&summaryBytes, ticket.Data); err != nil {
-		return nil, err
-	}
-	summary := summaryBytes.String()
-
-	descriptionTemplate, err := template.ParseFiles(cmp.IssueTemplate)
-	if err != nil {
-		return nil, err
-	}
-
-	var descriptionBytes bytes.Buffer
-	if err := descriptionTemplate.Execute(&descriptionBytes, ticket.Data); err != nil {
-		return nil, err
-	}
-	description := descriptionBytes.String()
-
-	data := map[string]string{
-		"Description": description,
-		"Summary":     summary,
-		"Project":     cmp.Jira.Project,
-		"Issue Type":  cmp.Jira.IssueType,
-		"Epic Link":   cmp.Jira.Epic,
-	}
-
-	createMetaInfo, _, err := c.Issue.GetCreateMeta(cmp.Jira.Project)
-	if err != nil {
-		return nil, err
-	}
-
-	project := createMetaInfo.GetProjectWithKey(cmp.Jira.Project)
-	if project == nil {
-		return nil, fmt.Errorf("Error retrieving project with key %s", cmp.Jira.Project)
-	}
-
-	issueType := project.GetIssueTypeWithName(cmp.Jira.IssueType)
-	if issueType == nil {
-		return nil, fmt.Errorf("Error retrieving issue type with name Story")
-	}
-
-	issue, err := jira.InitIssueWithMetaAndFields(project, issueType, data)
-	if err != nil {
-		return nil, err
-	}
-
-	return issue, nil
-}
-
-func (c *JiraClient) PublishTicket(ticket *model.Ticket, cmp *model.Campaign, dryRun bool) (*jira.Issue, error) {
-	issue, err := c.GetIssueFromTicket(ticket, cmp)
-	if err != nil {
-		return nil, err
-	}
-
-	if dryRun {
-		b, _ := json.MarshalIndent(issue, "", "  ")
-		fmt.Println(string(b))
-		return issue, nil
-	}
-
-	newIssue, _, err := c.Issue.Create(issue)
-	if err != nil {
-		return nil, err
-	}
-
-	return newIssue, nil
-}
-
-func (c *JiraClient) GetIssue(issueNo string) (*jira.Issue, error) {
-	issue, _, err := c.Issue.Get(issueNo, nil)
-	if err != nil {
-		return nil, err
-	}
-	return issue, nil
-}
-
-func (c *JiraClient) PublishNextTicket(cmp *model.Campaign, dryRun bool) (bool, error) {
-	ticket := cmp.NextJiraUnpublishedTicket()
-	if ticket == nil {
-		return false, nil
-	}
-
-	issue, err := c.PublishTicket(ticket, cmp, dryRun)
-	if err != nil {
-		return false, err
-	}
-
-	if dryRun {
-		return true, nil
-	}
-
-	issue, _, err = c.Issue.Get(issue.Key, nil)
-	if err != nil {
-		return false, err
-	}
-
-	ticket.JiraLink = fmt.Sprintf("%s/browse/%s", cmp.Jira.Url, issue.Key)
-	ticket.Summary = issue.Fields.Summary
-	ticket.Description = issue.Fields.Description
-	ticket.JiraStatus = issue.Fields.Status.Name
-	if err := campaign.Save(cmp); err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (c *JiraClient) PublishAll(cmp *model.Campaign, dryRun bool) (int, error) {
-	count := 0
-	for {
-		next, err := c.PublishNextTicket(cmp, dryRun)
-		if err != nil {
-			return count, err
-		}
-		if !next {
-			break
-		}
-		count++
-	}
-	return count, nil
-}
-
-func (c *JiraClient) PublishBatch(cmp *model.Campaign, batch int, dryRun bool) error {
-	for i := 1; i <= batch; i++ {
-		next, err := c.PublishNextTicket(cmp, dryRun)
-		if err != nil {
-			return err
-		}
-		if !next {
-			return nil
-		}
-	}
-	return nil
-}

model/campaign.go

@@ -2,8 +2,11 @@ package model
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
+	"os"
 	"strings"
+	"text/tabwriter"
 	"text/template"
 
 	"github.com/fatih/color"
@@ -54,20 +57,126 @@ func (c *Campaign) NextGithubUnpublishedTicket() *Ticket {
 
 func (c *Campaign) PrintStatus() {
 	totalTickets := len(c.Tickets)
-	var totalPublishedJira, totalPublishedGithub int
+	var totalPublishedJira, totalPublishedGithub, totalAssigned, totalClosed int
 	for _, t := range c.Tickets {
 		if t.IsPublishedJira() {
 			totalPublishedJira++
 			if t.IsPublishedGithub() {
 				totalPublishedGithub++
+				if t.IsAssigned() {
+					totalAssigned++
+					if t.IsClosed() {
+						totalClosed++
+					}
+				}
 			}
 		}
 	}
 
 	fmt.Printf("Current campaign for %s with summary\n%s\n\n", color.GreenString(c.Github.Repo), color.CyanString(c.Summary))
-	fmt.Printf("\t%d\ttotal tickets\n", totalTickets)
+	if totalTickets == 0 {
-	fmt.Printf("\t%d/%d\tpublished in Jira\n", totalPublishedJira, totalTickets)
+		fmt.Println("There are no tickets in the campaign. Run \"campaigner add --help\" to find out how to add them.")
-	fmt.Printf("\t%d/%d\tpublished in Github\n\n", totalPublishedGithub, totalPublishedJira)
+		return
+	}
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', tabwriter.AlignRight)
+	fmt.Fprintf(w, "      %d\t-\ttotal tickets\t\n", totalTickets)
+	fmt.Fprintf(w, "      %d\t%d%%\tpublished in Jira\t\n", totalPublishedJira, totalPublishedJira*100/totalTickets)
+	fmt.Fprintf(w, "      %d\t%d%%\tpublished in Github\t\n", totalPublishedGithub, totalPublishedGithub*100/totalTickets)
+	fmt.Fprintf(w, "      %d\t%d%%\tassigned\t\n", totalAssigned, totalAssigned*100/totalTickets)
+	fmt.Fprintf(w, "      %d\t%d%%\tclosed\t\n\n", totalClosed, totalClosed*100/totalTickets)
+	w.Flush()
+}
+
+func (c *Campaign) PrintList(publishedOnly, printLinks bool) {
+	for _, t := range c.Tickets {
+		if t.IsPublishedJira() {
+			jiraLink := t.JiraLink
+			if printLinks {
+				jiraLink = c.GetJiraUrl(t)
+			}
+
+			var str string
+			if t.IsPublishedGithub() {
+				githubLink := fmt.Sprintf("#%d", t.GithubLink)
+				if printLinks {
+					githubLink = c.GetGithubUrl(t)
+				}
+
+				str = fmt.Sprintf("[%s / %s] %s", color.BlueString(jiraLink), color.CyanString(githubLink), t.Summary)
+			} else {
+				str = fmt.Sprintf("[%s] %s", color.BlueString(jiraLink), t.Summary)
+			}
+			if t.GithubStatus != "" {
+				if t.IsClosed() {
+					str += fmt.Sprintf(" (%s)", color.MagentaString(t.GithubStatus))
+				} else {
+					str += fmt.Sprintf(" (%s)", color.GreenString(t.GithubStatus))
+				}
+			}
+			fmt.Println(str)
+		} else if !publishedOnly {
+			b, _ := json.Marshal(t.Data)
+			fmt.Printf("unpublished: %s\n", color.YellowString(string(b)))
+		}
+	}
+}
+
+func (c *Campaign) AddTickets(tickets []*Ticket, fileOnly bool) int {
+	c.Tickets = append(c.Tickets, tickets...)
+	removedTickets := c.RemoveDuplicateTickets(fileOnly)
+	return len(tickets) - removedTickets
+}
+
+func (c *Campaign) RemoveDuplicateTickets(fileOnly bool) int {
+	removedTickets := 0
+	datalessTickets := []*Ticket{}
+	ticketMap := map[string]*Ticket{}
+	for _, t := range c.Tickets {
+		filename, _ := t.Data["filename"].(string)
+		lineNo, _ := t.Data["lineNo"].(int)
+
+		if filename == "" {
+			datalessTickets = append(datalessTickets, t)
+			continue
+		}
+
+		if fileOnly {
+			// a previous ticket for the filename already existed
+			if _, ok := ticketMap[filename]; ok {
+				removedTickets++
+			}
+			ticketMap[filename] = t
+		} else {
+			ticketKey := fmt.Sprintf("%s:%d", filename, lineNo)
+			// a previous ticket for the same key already existed
+			if _, ok := ticketMap[ticketKey]; ok {
+				removedTickets++
+			}
+			ticketMap[ticketKey] = t
+		}
+	}
+
+	cleanTickets := []*Ticket{}
+	// dataless tickets are added first as they come from already
+	// existing tickets in Jira
+	cleanTickets = append(cleanTickets, datalessTickets...)
+	for _, t := range ticketMap {
+		cleanTickets = append(cleanTickets, t)
+	}
+
+	c.Tickets = cleanTickets
+	return removedTickets
+}
+
+func (c *Campaign) GetPublishedGithubTickets() []*Ticket {
+	publishedTickets := []*Ticket{}
+	for _, ticket := range c.Tickets {
+		if ticket.IsPublishedGithub() {
+			publishedTickets = append(publishedTickets, ticket)
+		}
+	}
+	return publishedTickets
 }
 
 func (c *Campaign) FillTicket(t *Ticket) error {
@@ -103,12 +212,10 @@ func (c *Campaign) RepoComponents() (string, string) {
 	return "", ""
 }
 
-func (c *Campaign) GetByJiraIssue(num string) (ticket *Ticket) {
+func (c *Campaign) GetJiraUrl(ticket *Ticket) string {
-	for _, t := range c.Tickets {
+	return fmt.Sprintf("%s/browse/%s", c.Jira.Url, ticket.JiraLink)
-		if t.JiraIssue() == num {
-			ticket = t
-			return
 }
-	}
+
-	return
+func (c *Campaign) GetGithubUrl(ticket *Ticket) string {
+	return fmt.Sprintf("https://github.com/%s/issues/%d", c.Github.Repo, ticket.GithubLink)
 }

model/campaign_reports.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+)
+
+func (c *Campaign) PrintUserReport() {
+	userTickets := map[string]int{}
+	for _, ticket := range c.Tickets {
+		if !ticket.IsClosed() {
+			continue
+		}
+
+		user := ticket.GithubAssignee
+		if user != "" {
+			if count, ok := userTickets[user]; ok {
+				userTickets[user] = count + 1
+			} else {
+				userTickets[user] = 1
+			}
+		}
+	}
+
+	fmt.Println()
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', tabwriter.AlignRight)
+	fmt.Fprintln(w, "GitHub username\tTickets closed\t")
+	fmt.Fprintln(w, "---------------\t--------------\t")
+	for user, count := range userTickets {
+		fmt.Fprintf(w, "%s\t%d\t\n", user, count)
+	}
+	w.Flush()
+	fmt.Println()
+}

model/campaign_test.go

@@ -0,0 +1,84 @@
+package model
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func createTicket(filename string, lineNo int) *Ticket {
+	return &Ticket{
+		Data: map[string]interface{}{
+			"filename": filename,
+			"lineNo":   lineNo,
+		},
+	}
+}
+
+func TestAddTickets(t *testing.T) {
+	t.Run("Tickets should be added correctly with fileOnly disabled", func(t *testing.T) {
+		campaign := &Campaign{}
+		ticketsToAdd := []*Ticket{
+			createTicket("user.txt", 1),
+			createTicket("test.txt", 2),
+			createTicket("sample.txt", 3),
+			createTicket("user.txt", 4),
+		}
+
+		addedTickets := campaign.AddTickets(ticketsToAdd, false)
+		require.Equal(t, 4, addedTickets)
+		require.Len(t, campaign.Tickets, 4)
+	})
+
+	t.Run("Should account for already existing tickets with fileOnly disabled", func(t *testing.T) {
+		campaign := &Campaign{
+			Tickets: []*Ticket{
+				createTicket("user.txt", 1),
+				createTicket("test.txt", 2),
+			},
+		}
+		ticketsToAdd := []*Ticket{
+			createTicket("user.txt", 1),
+			createTicket("test.txt", 2),
+			createTicket("sample.txt", 3),
+			createTicket("user.txt", 4),
+		}
+
+		addedTickets := campaign.AddTickets(ticketsToAdd, false)
+		require.Equal(t, 2, addedTickets)
+		require.Len(t, campaign.Tickets, 4)
+	})
+
+	t.Run("Tickets should be added correctly with fileOnly enabled", func(t *testing.T) {
+		campaign := &Campaign{}
+		ticketsToAdd := []*Ticket{
+			createTicket("user.txt", 1),
+			createTicket("test.txt", 2),
+			createTicket("sample.txt", 3),
+			createTicket("user.txt", 4),
+		}
+
+		addedTickets := campaign.AddTickets(ticketsToAdd, true)
+		require.Equal(t, 3, addedTickets)
+		require.Len(t, campaign.Tickets, 3)
+	})
+
+	t.Run("Should account for already existing tickets with fileOnly enabled", func(t *testing.T) {
+		campaign := &Campaign{
+			Tickets: []*Ticket{
+				createTicket("user.txt", 1),
+				createTicket("test.txt", 2),
+			},
+		}
+		ticketsToAdd := []*Ticket{
+			createTicket("user.txt", 1),
+			createTicket("test.txt", 2),
+			createTicket("sample.txt", 3),
+			createTicket("user.txt", 4),
+		}
+
+		addedTickets := campaign.AddTickets(ticketsToAdd, true)
+		require.Equal(t, 1, addedTickets)
+		require.Len(t, campaign.Tickets, 3)
+	})
+}

model/ticket.go

@@ -2,7 +2,6 @@ package model
 
 import (
 	"fmt"
-	"strings"
 )
 
 type Ticket struct {
@@ -16,32 +15,20 @@ type Ticket struct {
 	Data           map[string]interface{} `json:"data,omitempty"`
 }
 
-func RemoveDuplicateTickets(tickets []*Ticket, fileOnly bool) []*Ticket {
-	ticketMap := map[string]*Ticket{}
-	for _, t := range tickets {
-		filename, _ := t.Data["filename"].(string)
-		lineNo, _ := t.Data["lineNo"].(int)
-		if fileOnly {
-			ticketMap[filename] = t
-		} else {
-			ticketMap[fmt.Sprintf("%s:%d", filename, lineNo)] = t
-		}
-	}
-
-	cleanTickets := []*Ticket{}
-	for _, t := range ticketMap {
-		cleanTickets = append(cleanTickets, t)
-	}
-
-	return cleanTickets
-}
-
 func (t *Ticket) IsPublishedJira() bool {
 	return t.JiraLink != ""
 }
 
 func (t *Ticket) IsPublishedGithub() bool {
-	return t.JiraLink != "" && t.GithubLink != 0
+	return t.IsPublishedJira() && t.GithubLink != 0
+}
+
+func (t *Ticket) IsAssigned() bool {
+	return t.IsPublishedGithub() && t.GithubAssignee != ""
+}
+
+func (t *Ticket) IsClosed() bool {
+	return t.IsAssigned() && t.GithubStatus == "closed"
 }
 
 func (t *Ticket) PrintStatus() {
@@ -49,11 +36,3 @@ func (t *Ticket) PrintStatus() {
 		fmt.Printf("[%s] %s\n", t.JiraLink, t.Summary)
 	}
 }
-
-func (t *Ticket) JiraIssue() string {
-	parts := strings.Split(t.JiraLink, "/")
-	if len(parts) < 2 {
-		return ""
-	}
-	return parts[len(parts)-1]
-}

shell.nix

@@ -0,0 +1,16 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    gnumake
+    go_1_18
+    golangci-lint
+  ];
+  shellHook = ''
+    echo '
+┏━╸┏━┓┏┳┓┏━┓┏━┓╻┏━╸┏┓╻┏━╸┏━┓
+┃  ┣━┫┃┃┃┣━┛┣━┫┃┃╺┓┃┗┫┣╸ ┣┳┛
+┗━╸╹ ╹╹ ╹╹  ╹ ╹╹┗━┛╹ ╹┗━╸╹┗╸
+'
+  '';
+  hardeningDisable = [ "all" ];
+}

vendor/github.com/StevenACoffman/j2m/.gitignore

@@ -1,12 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, build with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out

vendor/github.com/StevenACoffman/j2m/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Steve Coffman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/StevenACoffman/j2m/Makefile

@@ -1,15 +0,0 @@
-.DEFAULT_GOAL := easy
-.PHONY: install clean all easy
-
-bin/j2m:
-	go build -o bin/j2m cmd/j2m.go
-
-all: bin/j2m
-
-install: bin/j2m
-	cp bin/* ~/bin
-
-clean:
-	rm -f bin/*
-
-easy: all

vendor/github.com/StevenACoffman/j2m/README.md

@@ -1,61 +0,0 @@
-[![GoDoc](https://godoc.org/github.com/StevenACoffman/j2m?status.svg)](https://godoc.org/github.com/StevenACoffman/j2m)
-[![GoReportcard](https://goreportcard.com/badge/github.com/StevenACoffman/j2m?status.svg)](https://goreportcard.com/report/github.com/StevenACoffman/j2m)
-
-# jira-to-md
-
-## JIRA to MarkDown text format converter
-Golang tool to convert from JIRA Markdown text formatting to GitHub Flavored MarkDown.
-
-## Credits
-This fun toy was heavily inspired by the J2M project by Fokke Zandbergen (http://j2m.fokkezb.nl/). Major credit to Fokke, kylefarris (and other contributors) for establishing the RexExp patterns for this to work. The maintained JavaScript fork I based this on is [here](https://github.com/kylefarris/J2M)
-
-## Supported Conversions
-
-* Headers (H1-H6)
-* Bold
-* Italic
-* Bold + Italic
-* Un-ordered lists
-* Ordered lists
-* Programming Language-specific code blocks (with help from herbert-venancio)
-* Inline preformatted text spans
-* Un-named links
-* Named links
-* Monospaced Text
-* ~~Citations~~ (currently kinda buggy)
-* Strikethroughs
-* Inserts
-* Superscripts
-* Subscripts
-* Single-paragraph blockquotes
-* Tables
-* Panels
-
-
-## How to Use
-
-### Markdown String
-
-```
-**Some bold things**
-*Some italic stuff*
-## H2
-<http://google.com>
-```
-
-### Atlassian Wiki MarkUp Syntax (JIRA)
-
-We'll refer to this as the `jira` variable in the examples below.
-
-```
-*Some bold things**
-_Some italic stuff_
-h2. H2
-[http://google.com]
-```
-
-### Examples
-
-```
-cat j2m.jira | j2m
-```

vendor/github.com/StevenACoffman/j2m/go.mod

@@ -1,3 +0,0 @@
-module github.com/StevenACoffman/j2m
-
-go 1.12

vendor/github.com/StevenACoffman/j2m/j2m.go

@@ -1,153 +0,0 @@
-package j2m
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-type jiration struct {
-	re   *regexp.Regexp
-	repl interface{}
-}
-
-// JiraToMD takes a string in Jira Markdown, and outputs Github Markdown
-func JiraToMD(str string) string {
-	jirations := []jiration{
-		{ // UnOrdered Lists
-			re: regexp.MustCompile(`(?m)^[ \t]*(\*+)\s+`),
-			repl: func(groups []string) string {
-				_, stars := groups[0], groups[1]
-				return strings.Repeat("  ", len(stars)-1) + "* "
-			},
-		},
-		{ //Ordered Lists
-			re: regexp.MustCompile(`(?m)^[ \t]*(#+)\s+`),
-			repl: func(groups []string) string {
-				_, nums := groups[0], groups[1]
-				return strings.Repeat("  ", len(nums)-1) + "1. "
-			},
-		},
-		{ //Headers 1-6
-			re: regexp.MustCompile(`(?m)^h([0-6])\.(.*)$`),
-			repl: func(groups []string) string {
-				_, level, content := groups[0], groups[1], groups[2]
-				i, _ := strconv.Atoi(level)
-				return strings.Repeat("#", i) + content
-			},
-		},
-		{ // Bold
-			re:   regexp.MustCompile(`\*(\S.*)\*`),
-			repl: "**$1**",
-		},
-		{ // Italic
-			re:   regexp.MustCompile(`\_(\S.*)\_`),
-			repl: "*$1*",
-		},
-		{ // Monospaced text
-			re:   regexp.MustCompile(`\{\{([^}]+)\}\}`),
-			repl: "`$1`",
-		},
-		{ // Citations (buggy)
-			re:   regexp.MustCompile(`\?\?((?:.[^?]|[^?].)+)\?\?`),
-			repl: "<cite>$1</cite>",
-		},
-		{ // Inserts
-			re:   regexp.MustCompile(`\+([^+]*)\+`),
-			repl: "<ins>$1</ins>",
-		},
-		{ // Superscript
-			re:   regexp.MustCompile(`\^([^^]*)\^`),
-			repl: "<sup>$1</sup>",
-		},
-		{ // Subscript
-			re:   regexp.MustCompile(`~([^~]*)~`),
-			repl: "<sub>$1</sub>",
-		},
-		{ // Strikethrough
-			re:   regexp.MustCompile(`(\s+)-(\S+.*?\S)-(\s+)`),
-			repl: "$1~~$2~~$3",
-		},
-		{ // Code Block
-			re:   regexp.MustCompile(`\{code(:([a-z]+))?([:|]?(title|borderStyle|borderColor|borderWidth|bgColor|titleBGColor)=.+?)*\}`),
-			repl: "```$2",
-		},
-		{ // Code Block End
-			re:   regexp.MustCompile(`{code}`),
-			repl: "```",
-		},
-		{ // Pre-formatted text
-			re:   regexp.MustCompile(`{noformat}`),
-			repl: "```",
-		},
-		{ // Un-named Links
-			re:   regexp.MustCompile(`(?U)\[([^|]+)\]`),
-			repl: "<$1>",
-		},
-		{ // Images
-			re:   regexp.MustCompile(`!(.+)!`),
-			repl: "![]($1)",
-		},
-		{ // Named Links
-			re:   regexp.MustCompile(`\[(.+?)\|(.+)\]`),
-			repl: "[$1]($2)",
-		},
-		{ // Single Paragraph Blockquote
-			re:   regexp.MustCompile(`(?m)^bq\.\s+`),
-			repl: "> ",
-		},
-		{ // Remove color: unsupported in md
-			re:   regexp.MustCompile(`(?m)\{color:[^}]+\}(.*)\{color\}`),
-			repl: "$1",
-		},
-		{ // panel into table
-			re:   regexp.MustCompile(`(?m)\{panel:title=([^}]*)\}\n?(.*?)\n?\{panel\}`),
-			repl: "\n| $1 |\n| --- |\n| $2 |",
-		},
-		{ //table header
-			re: regexp.MustCompile(`(?m)^[ \t]*((?:\|\|.*?)+\|\|)[ \t]*$`),
-			repl: func(groups []string) string {
-				_, headers := groups[0], groups[1]
-				reBarred := regexp.MustCompile(`\|\|`)
-
-				singleBarred := reBarred.ReplaceAllString(headers, "|")
-				fillerRe := regexp.MustCompile(`\|[^|]+`)
-				return "\n" + singleBarred + "\n" + fillerRe.ReplaceAllString(singleBarred, "| --- ")
-			},
-		},
-		{ // remove leading-space of table headers and rows
-			re:   regexp.MustCompile(`(?m)^[ \t]*\|`),
-			repl: "|",
-		},
-	}
-	for _, jiration := range jirations {
-		switch v := jiration.repl.(type) {
-		case string:
-			str = jiration.re.ReplaceAllString(str, v)
-		case func([]string) string:
-			str = replaceAllStringSubmatchFunc(jiration.re, str, v)
-		default:
-			fmt.Printf("I don't know about type %T!\n", v)
-		}
-	}
-	return str
-}
-
-// https://gist.github.com/elliotchance/d419395aa776d632d897
-func replaceAllStringSubmatchFunc(re *regexp.Regexp, str string, repl func([]string) string) string {
-	result := ""
-	lastIndex := 0
-
-	for _, v := range re.FindAllSubmatchIndex([]byte(str), -1) {
-		groups := []string{}
-		for i := 0; i < len(v); i += 2 {
-			groups = append(groups, str[v[i]:v[i+1]])
-		}
-
-		result += str[lastIndex:v[0]] + repl(groups)
-		lastIndex = v[1]
-	}
-
-	return result + str[lastIndex:]
-}

vendor/github.com/StevenACoffman/j2m/j2m.jira

@@ -1,65 +0,0 @@
-h1. Biggest heading
-
-h2. Bigger heading
-
-h1. Biggest heading
-h2. Bigger heading
-h3. Big heading
-h4. Normal heading
-h5. Small heading
-h6. Smallest heading
-
-*strong*
-_emphasis_
-{{monospaced}}
--deleted-
-+inserted+
-^superscript^
-~subscript~
-
-{code:javascript}
-var hello = 'world';
-{code}
-
-!http://google.com/image!
-[!http://google.com/image!|http://google.com/link]
-
-[http://google.com]
-[Google|http://google.com]
-
-GitHub Flavor
--deleted-
-
-{code}
-  preformatted piece of text
-  so _no_ further _formatting_ is done here
-{code}
-
-_*Should be bold AND italic*_
-
-* First li
-* Second li
-** Indented li
-*** Three columns in li
-* Back to first level li
-
-# First li
-# Second li
-## Indented li
-### Three columns in li
-# Back to first level li
-
-* Here's _italic_ inside li
-* here's *bold* inside li
-* Here's _*bold + italic*_ inside li
-** Here they are in one line indented: _italic_ *bold*
-
-bq. Here's a long single-paragraph block quote. It should look pretty and stuff.
-
-{panel:title=A title}
-Panel text
-{panel}
-
-||Heading 1||Heading 2||
-|Col A1|Col A2|
-|Col B1|Col B2|

vendor/github.com/StevenACoffman/j2m/j2m.md

@@ -1,68 +0,0 @@
-# Biggest heading
-
-## Bigger heading
-
-# Biggest heading
-## Bigger heading
-### Big heading
-#### Normal heading
-##### Small heading
-###### Smallest heading
-
-**strong**
-*emphasis*
-`monospaced`
-~~deleted~~
-<ins>inserted</ins>
-<sup>superscript</sup>
-<sub>subscript</sub>
-
-```javascript
-var hello = 'world';
-```
-
-![](http://google.com/image)
-[![](http://google.com/image)](http://google.com/link)
-
-<http://google.com>
-[Google](http://google.com)
-
-GitHub Flavor
-~~deleted~~
-
-```
-  preformatted piece of text
-  so *no_ further _formatting* is done here
-```
-
-***Should be bold AND italic***
-
-* First li
-* Second li
-  * Indented li
-    * Three columns in li
-* Back to first level li
-
-1. First li
-1. Second li
-  1. Indented li
-    1. Three columns in li
-1. Back to first level li
-
-* Here's *italic* inside li
-* here's **bold** inside li
-* Here's ***bold + italic*** inside li
-  * Here they are in one line indented: *italic* **bold**
-
-> Here's a long single-paragraph block quote. It should look pretty and stuff.
-
-
-| A title |
-| --- |
-| Panel text |
-
-
-|Heading 1|Heading 2|
-| --- | --- |
-|Col A1|Col A2|
-|Col B1|Col B2|

vendor/github.com/fatih/color/LICENSE.md

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Fatih Arslan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/fatih/color/README.md

@@ -1,182 +0,0 @@
-# Archived project. No maintenance. 
-
-This project is not maintained anymore and is archived. Feel free to fork and
-make your own changes if needed. For more detail read my blog post: [Taking an indefinite sabbatical from my projects](https://arslan.io/2018/10/09/taking-an-indefinite-sabbatical-from-my-projects/)
-
-Thanks to everyone for their valuable feedback and contributions.
-
-
-# Color [![GoDoc](https://godoc.org/github.com/fatih/color?status.svg)](https://godoc.org/github.com/fatih/color) 
-
-Color lets you use colorized outputs in terms of [ANSI Escape
-Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It
-has support for Windows too! The API can be used in several ways, pick one that
-suits you.
-
-
-![Color](https://i.imgur.com/c1JI0lA.png)
-
-
-## Install
-
-```bash
-go get github.com/fatih/color
-```
-
-## Examples
-
-### Standard colors
-
-```go
-// Print with default helper functions
-color.Cyan("Prints text in cyan.")
-
-// A newline will be appended automatically
-color.Blue("Prints %s in blue.", "text")
-
-// These are using the default foreground colors
-color.Red("We have red")
-color.Magenta("And many others ..")
-
-```
-
-### Mix and reuse colors
-
-```go
-// Create a new color object
-c := color.New(color.FgCyan).Add(color.Underline)
-c.Println("Prints cyan text with an underline.")
-
-// Or just add them to New()
-d := color.New(color.FgCyan, color.Bold)
-d.Printf("This prints bold cyan %s\n", "too!.")
-
-// Mix up foreground and background colors, create new mixes!
-red := color.New(color.FgRed)
-
-boldRed := red.Add(color.Bold)
-boldRed.Println("This will print text in bold red.")
-
-whiteBackground := red.Add(color.BgWhite)
-whiteBackground.Println("Red text with white background.")
-```
-
-### Use your own output (io.Writer)
-
-```go
-// Use your own io.Writer output
-color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
-
-blue := color.New(color.FgBlue)
-blue.Fprint(writer, "This will print text in blue.")
-```
-
-### Custom print functions (PrintFunc)
-
-```go
-// Create a custom print function for convenience
-red := color.New(color.FgRed).PrintfFunc()
-red("Warning")
-red("Error: %s", err)
-
-// Mix up multiple attributes
-notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-notice("Don't forget this...")
-```
-
-### Custom fprint functions (FprintFunc)
-
-```go
-blue := color.New(FgBlue).FprintfFunc()
-blue(myWriter, "important notice: %s", stars)
-
-// Mix up with multiple attributes
-success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
-success(myWriter, "Don't forget this...")
-```
-
-### Insert into noncolor strings (SprintFunc)
-
-```go
-// Create SprintXxx functions to mix strings with other non-colorized strings:
-yellow := color.New(color.FgYellow).SprintFunc()
-red := color.New(color.FgRed).SprintFunc()
-fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-info := color.New(color.FgWhite, color.BgGreen).SprintFunc()
-fmt.Printf("This %s rocks!\n", info("package"))
-
-// Use helper functions
-fmt.Println("This", color.RedString("warning"), "should be not neglected.")
-fmt.Printf("%v %v\n", color.GreenString("Info:"), "an important message.")
-
-// Windows supported too! Just don't forget to change the output to color.Output
-fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-```
-
-### Plug into existing code
-
-```go
-// Use handy standard colors
-color.Set(color.FgYellow)
-
-fmt.Println("Existing text will now be in yellow")
-fmt.Printf("This one %s\n", "too")
-
-color.Unset() // Don't forget to unset
-
-// You can mix up parameters
-color.Set(color.FgMagenta, color.Bold)
-defer color.Unset() // Use it in your function
-
-fmt.Println("All text will now be bold magenta.")
-```
-
-### Disable/Enable color
- 
-There might be a case where you want to explicitly disable/enable color output. the 
-`go-isatty` package will automatically disable color output for non-tty output streams 
-(for example if the output were piped directly to `less`)
-
-`Color` has support to disable/enable colors both globally and for single color 
-definitions. For example suppose you have a CLI app and a `--no-color` bool flag. You 
-can easily disable the color output with:
-
-```go
-
-var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-if *flagNoColor {
-	color.NoColor = true // disables colorized output
-}
-```
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-```go
-c := color.New(color.FgCyan)
-c.Println("Prints cyan text")
-
-c.DisableColor()
-c.Println("This is printed without any color")
-
-c.EnableColor()
-c.Println("This prints again cyan...")
-```
-
-## Todo
-
-* Save/Return previous values
-* Evaluate fmt.Formatter interface
-
-
-## Credits
-
- * [Fatih Arslan](https://github.com/fatih)
- * Windows support via @mattn: [colorable](https://github.com/mattn/go-colorable)
-
-## License
-
-The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details
-

vendor/github.com/fatih/color/color.go

@@ -1,603 +0,0 @@
-package color
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-)
-
-var (
-	// NoColor defines if the output is colorized or not. It's dynamically set to
-	// false or true based on the stdout's file descriptor referring to a terminal
-	// or not. This is a global option and affects all colors. For more control
-	// over each color block use the methods DisableColor() individually.
-	NoColor = os.Getenv("TERM") == "dumb" ||
-		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
-
-	// Output defines the standard output of the print functions. By default
-	// os.Stdout is used.
-	Output = colorable.NewColorableStdout()
-
-	// Error defines a color supporting writer for os.Stderr.
-	Error = colorable.NewColorableStderr()
-
-	// colorsCache is used to reduce the count of created Color objects and
-	// allows to reuse already created objects with required Attribute.
-	colorsCache   = make(map[Attribute]*Color)
-	colorsCacheMu sync.Mutex // protects colorsCache
-)
-
-// Color defines a custom color object which is defined by SGR parameters.
-type Color struct {
-	params  []Attribute
-	noColor *bool
-}
-
-// Attribute defines a single SGR Code
-type Attribute int
-
-const escape = "\x1b"
-
-// Base attributes
-const (
-	Reset Attribute = iota
-	Bold
-	Faint
-	Italic
-	Underline
-	BlinkSlow
-	BlinkRapid
-	ReverseVideo
-	Concealed
-	CrossedOut
-)
-
-// Foreground text colors
-const (
-	FgBlack Attribute = iota + 30
-	FgRed
-	FgGreen
-	FgYellow
-	FgBlue
-	FgMagenta
-	FgCyan
-	FgWhite
-)
-
-// Foreground Hi-Intensity text colors
-const (
-	FgHiBlack Attribute = iota + 90
-	FgHiRed
-	FgHiGreen
-	FgHiYellow
-	FgHiBlue
-	FgHiMagenta
-	FgHiCyan
-	FgHiWhite
-)
-
-// Background text colors
-const (
-	BgBlack Attribute = iota + 40
-	BgRed
-	BgGreen
-	BgYellow
-	BgBlue
-	BgMagenta
-	BgCyan
-	BgWhite
-)
-
-// Background Hi-Intensity text colors
-const (
-	BgHiBlack Attribute = iota + 100
-	BgHiRed
-	BgHiGreen
-	BgHiYellow
-	BgHiBlue
-	BgHiMagenta
-	BgHiCyan
-	BgHiWhite
-)
-
-// New returns a newly created color object.
-func New(value ...Attribute) *Color {
-	c := &Color{params: make([]Attribute, 0)}
-	c.Add(value...)
-	return c
-}
-
-// Set sets the given parameters immediately. It will change the color of
-// output with the given SGR parameters until color.Unset() is called.
-func Set(p ...Attribute) *Color {
-	c := New(p...)
-	c.Set()
-	return c
-}
-
-// Unset resets all escape attributes and clears the output. Usually should
-// be called after Set().
-func Unset() {
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
-}
-
-// Set sets the SGR sequence.
-func (c *Color) Set() *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(Output, c.format())
-	return c
-}
-
-func (c *Color) unset() {
-	if c.isNoColorSet() {
-		return
-	}
-
-	Unset()
-}
-
-func (c *Color) setWriter(w io.Writer) *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(w, c.format())
-	return c
-}
-
-func (c *Color) unsetWriter(w io.Writer) {
-	if c.isNoColorSet() {
-		return
-	}
-
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(w, "%s[%dm", escape, Reset)
-}
-
-// Add is used to chain SGR parameters. Use as many as parameters to combine
-// and create custom color objects. Example: Add(color.FgRed, color.Underline).
-func (c *Color) Add(value ...Attribute) *Color {
-	c.params = append(c.params, value...)
-	return c
-}
-
-func (c *Color) prepend(value Attribute) {
-	c.params = append(c.params, 0)
-	copy(c.params[1:], c.params[0:])
-	c.params[0] = value
-}
-
-// Fprint formats using the default formats for its operands and writes to w.
-// Spaces are added between operands when neither is a string.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprint(w, a...)
-}
-
-// Print formats using the default formats for its operands and writes to
-// standard output. Spaces are added between operands when neither is a
-// string. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Print(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprint(Output, a...)
-}
-
-// Fprintf formats according to a format specifier and writes to w.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintf(w, format, a...)
-}
-
-// Printf formats according to a format specifier and writes to standard output.
-// It returns the number of bytes written and any write error encountered.
-// This is the standard fmt.Printf() method wrapped with the given color.
-func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintf(Output, format, a...)
-}
-
-// Fprintln formats using the default formats for its operands and writes to w.
-// Spaces are always added between operands and a newline is appended.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintln(w, a...)
-}
-
-// Println formats using the default formats for its operands and writes to
-// standard output. Spaces are always added between operands and a newline is
-// appended. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Println(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintln(Output, a...)
-}
-
-// Sprint is just like Print, but returns a string instead of printing it.
-func (c *Color) Sprint(a ...interface{}) string {
-	return c.wrap(fmt.Sprint(a...))
-}
-
-// Sprintln is just like Println, but returns a string instead of printing it.
-func (c *Color) Sprintln(a ...interface{}) string {
-	return c.wrap(fmt.Sprintln(a...))
-}
-
-// Sprintf is just like Printf, but returns a string instead of printing it.
-func (c *Color) Sprintf(format string, a ...interface{}) string {
-	return c.wrap(fmt.Sprintf(format, a...))
-}
-
-// FprintFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprint().
-func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprint(w, a...)
-	}
-}
-
-// PrintFunc returns a new function that prints the passed arguments as
-// colorized with color.Print().
-func (c *Color) PrintFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Print(a...)
-	}
-}
-
-// FprintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintf().
-func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
-	return func(w io.Writer, format string, a ...interface{}) {
-		c.Fprintf(w, format, a...)
-	}
-}
-
-// PrintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Printf().
-func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
-	return func(format string, a ...interface{}) {
-		c.Printf(format, a...)
-	}
-}
-
-// FprintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintln().
-func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprintln(w, a...)
-	}
-}
-
-// PrintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Println().
-func (c *Color) PrintlnFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Println(a...)
-	}
-}
-
-// SprintFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprint(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output, example:
-//
-//	put := New(FgYellow).SprintFunc()
-//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
-func (c *Color) SprintFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprint(a...))
-	}
-}
-
-// SprintfFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintf(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
-	return func(format string, a ...interface{}) string {
-		return c.wrap(fmt.Sprintf(format, a...))
-	}
-}
-
-// SprintlnFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintln(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintlnFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprintln(a...))
-	}
-}
-
-// sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
-// an example output might be: "1;36" -> bold cyan
-func (c *Color) sequence() string {
-	format := make([]string, len(c.params))
-	for i, v := range c.params {
-		format[i] = strconv.Itoa(int(v))
-	}
-
-	return strings.Join(format, ";")
-}
-
-// wrap wraps the s string with the colors attributes. The string is ready to
-// be printed.
-func (c *Color) wrap(s string) string {
-	if c.isNoColorSet() {
-		return s
-	}
-
-	return c.format() + s + c.unformat()
-}
-
-func (c *Color) format() string {
-	return fmt.Sprintf("%s[%sm", escape, c.sequence())
-}
-
-func (c *Color) unformat() string {
-	return fmt.Sprintf("%s[%dm", escape, Reset)
-}
-
-// DisableColor disables the color output. Useful to not change any existing
-// code and still being able to output. Can be used for flags like
-// "--no-color". To enable back use EnableColor() method.
-func (c *Color) DisableColor() {
-	c.noColor = boolPtr(true)
-}
-
-// EnableColor enables the color output. Use it in conjunction with
-// DisableColor(). Otherwise this method has no side effects.
-func (c *Color) EnableColor() {
-	c.noColor = boolPtr(false)
-}
-
-func (c *Color) isNoColorSet() bool {
-	// check first if we have user setted action
-	if c.noColor != nil {
-		return *c.noColor
-	}
-
-	// if not return the global option, which is disabled by default
-	return NoColor
-}
-
-// Equals returns a boolean value indicating whether two colors are equal.
-func (c *Color) Equals(c2 *Color) bool {
-	if len(c.params) != len(c2.params) {
-		return false
-	}
-
-	for _, attr := range c.params {
-		if !c2.attrExists(attr) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *Color) attrExists(a Attribute) bool {
-	for _, attr := range c.params {
-		if attr == a {
-			return true
-		}
-	}
-
-	return false
-}
-
-func boolPtr(v bool) *bool {
-	return &v
-}
-
-func getCachedColor(p Attribute) *Color {
-	colorsCacheMu.Lock()
-	defer colorsCacheMu.Unlock()
-
-	c, ok := colorsCache[p]
-	if !ok {
-		c = New(p)
-		colorsCache[p] = c
-	}
-
-	return c
-}
-
-func colorPrint(format string, p Attribute, a ...interface{}) {
-	c := getCachedColor(p)
-
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-
-	if len(a) == 0 {
-		c.Print(format)
-	} else {
-		c.Printf(format, a...)
-	}
-}
-
-func colorString(format string, p Attribute, a ...interface{}) string {
-	c := getCachedColor(p)
-
-	if len(a) == 0 {
-		return c.SprintFunc()(format)
-	}
-
-	return c.SprintfFunc()(format, a...)
-}
-
-// Black is a convenient helper function to print with black foreground. A
-// newline is appended to format by default.
-func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
-
-// Red is a convenient helper function to print with red foreground. A
-// newline is appended to format by default.
-func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
-
-// Green is a convenient helper function to print with green foreground. A
-// newline is appended to format by default.
-func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
-
-// Yellow is a convenient helper function to print with yellow foreground.
-// A newline is appended to format by default.
-func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
-
-// Blue is a convenient helper function to print with blue foreground. A
-// newline is appended to format by default.
-func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
-
-// Magenta is a convenient helper function to print with magenta foreground.
-// A newline is appended to format by default.
-func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
-
-// Cyan is a convenient helper function to print with cyan foreground. A
-// newline is appended to format by default.
-func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
-
-// White is a convenient helper function to print with white foreground. A
-// newline is appended to format by default.
-func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
-
-// BlackString is a convenient helper function to return a string with black
-// foreground.
-func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
-
-// RedString is a convenient helper function to return a string with red
-// foreground.
-func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
-
-// GreenString is a convenient helper function to return a string with green
-// foreground.
-func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
-
-// YellowString is a convenient helper function to return a string with yellow
-// foreground.
-func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
-
-// BlueString is a convenient helper function to return a string with blue
-// foreground.
-func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
-
-// MagentaString is a convenient helper function to return a string with magenta
-// foreground.
-func MagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgMagenta, a...)
-}
-
-// CyanString is a convenient helper function to return a string with cyan
-// foreground.
-func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
-
-// WhiteString is a convenient helper function to return a string with white
-// foreground.
-func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
-
-// HiBlack is a convenient helper function to print with hi-intensity black foreground. A
-// newline is appended to format by default.
-func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
-
-// HiRed is a convenient helper function to print with hi-intensity red foreground. A
-// newline is appended to format by default.
-func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
-
-// HiGreen is a convenient helper function to print with hi-intensity green foreground. A
-// newline is appended to format by default.
-func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
-
-// HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
-// A newline is appended to format by default.
-func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
-
-// HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
-// newline is appended to format by default.
-func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
-
-// HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
-// A newline is appended to format by default.
-func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
-
-// HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
-// newline is appended to format by default.
-func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
-
-// HiWhite is a convenient helper function to print with hi-intensity white foreground. A
-// newline is appended to format by default.
-func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
-
-// HiBlackString is a convenient helper function to return a string with hi-intensity black
-// foreground.
-func HiBlackString(format string, a ...interface{}) string {
-	return colorString(format, FgHiBlack, a...)
-}
-
-// HiRedString is a convenient helper function to return a string with hi-intensity red
-// foreground.
-func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
-
-// HiGreenString is a convenient helper function to return a string with hi-intensity green
-// foreground.
-func HiGreenString(format string, a ...interface{}) string {
-	return colorString(format, FgHiGreen, a...)
-}
-
-// HiYellowString is a convenient helper function to return a string with hi-intensity yellow
-// foreground.
-func HiYellowString(format string, a ...interface{}) string {
-	return colorString(format, FgHiYellow, a...)
-}
-
-// HiBlueString is a convenient helper function to return a string with hi-intensity blue
-// foreground.
-func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
-
-// HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
-// foreground.
-func HiMagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgHiMagenta, a...)
-}
-
-// HiCyanString is a convenient helper function to return a string with hi-intensity cyan
-// foreground.
-func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
-
-// HiWhiteString is a convenient helper function to return a string with hi-intensity white
-// foreground.
-func HiWhiteString(format string, a ...interface{}) string {
-	return colorString(format, FgHiWhite, a...)
-}

vendor/github.com/fatih/color/doc.go

@@ -1,133 +0,0 @@
-/*
-Package color is an ANSI color package to output colorized or SGR defined
-output to the standard output. The API can be used in several way, pick one
-that suits you.
-
-Use simple and default helper functions with predefined foreground colors:
-
-    color.Cyan("Prints text in cyan.")
-
-    // a newline will be appended automatically
-    color.Blue("Prints %s in blue.", "text")
-
-    // More default foreground colors..
-    color.Red("We have red")
-    color.Yellow("Yellow color too!")
-    color.Magenta("And many others ..")
-
-    // Hi-intensity colors
-    color.HiGreen("Bright green color.")
-    color.HiBlack("Bright black means gray..")
-    color.HiWhite("Shiny white color!")
-
-However there are times where custom color mixes are required. Below are some
-examples to create custom color objects and use the print functions of each
-separate color object.
-
-    // Create a new color object
-    c := color.New(color.FgCyan).Add(color.Underline)
-    c.Println("Prints cyan text with an underline.")
-
-    // Or just add them to New()
-    d := color.New(color.FgCyan, color.Bold)
-    d.Printf("This prints bold cyan %s\n", "too!.")
-
-
-    // Mix up foreground and background colors, create new mixes!
-    red := color.New(color.FgRed)
-
-    boldRed := red.Add(color.Bold)
-    boldRed.Println("This will print text in bold red.")
-
-    whiteBackground := red.Add(color.BgWhite)
-    whiteBackground.Println("Red text with White background.")
-
-    // Use your own io.Writer output
-    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
-
-    blue := color.New(color.FgBlue)
-    blue.Fprint(myWriter, "This will print text in blue.")
-
-You can create PrintXxx functions to simplify even more:
-
-    // Create a custom print function for convenient
-    red := color.New(color.FgRed).PrintfFunc()
-    red("warning")
-    red("error: %s", err)
-
-    // Mix up multiple attributes
-    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-    notice("don't forget this...")
-
-You can also FprintXxx functions to pass your own io.Writer:
-
-    blue := color.New(FgBlue).FprintfFunc()
-    blue(myWriter, "important notice: %s", stars)
-
-    // Mix up with multiple attributes
-    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
-    success(myWriter, don't forget this...")
-
-
-Or create SprintXxx functions to mix strings with other non-colorized strings:
-
-    yellow := New(FgYellow).SprintFunc()
-    red := New(FgRed).SprintFunc()
-
-    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Printf("this %s rocks!\n", info("package"))
-
-Windows support is enabled by default. All Print functions work as intended.
-However only for color.SprintXXX functions, user should use fmt.FprintXXX and
-set the output to color.Output:
-
-    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
-
-Using with existing code is possible. Just use the Set() method to set the
-standard output to the given parameters. That way a rewrite of an existing
-code is not required.
-
-    // Use handy standard colors.
-    color.Set(color.FgYellow)
-
-    fmt.Println("Existing text will be now in Yellow")
-    fmt.Printf("This one %s\n", "too")
-
-    color.Unset() // don't forget to unset
-
-    // You can mix up parameters
-    color.Set(color.FgMagenta, color.Bold)
-    defer color.Unset() // use it in your function
-
-    fmt.Println("All text will be now bold magenta.")
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-    if *flagNoColor {
-    	color.NoColor = true // disables colorized output
-    }
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-     c := color.New(color.FgCyan)
-     c.Println("Prints cyan text")
-
-     c.DisableColor()
-     c.Println("This is printed without any color")
-
-     c.EnableColor()
-     c.Println("This prints again cyan...")
-*/
-package color

vendor/github.com/fatih/color/go.mod

@@ -1,8 +0,0 @@
-module github.com/fatih/color
-
-go 1.13
-
-require (
-	github.com/mattn/go-colorable v0.1.4
-	github.com/mattn/go-isatty v0.0.11
-)

vendor/github.com/fatih/color/go.sum

@@ -1,8 +0,0 @@
-github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
-github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
-github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037 h1:YyJpGZS1sBuBCzLAR1VEpK193GlqGZbnPFnPV/5Rsb4=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

vendor/github.com/fatih/structs/.gitignore

@@ -1,23 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test

vendor/github.com/fatih/structs/.travis.yml

@@ -1,13 +0,0 @@
-language: go
-go: 
- - 1.7.x
- - 1.8.x
- - 1.9.x
- - tip
-sudo: false
-before_install:
-- go get github.com/axw/gocov/gocov
-- go get github.com/mattn/goveralls
-- if ! go get github.com/golang/tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
-script:
-- $HOME/gopath/bin/goveralls -service=travis-ci

vendor/github.com/fatih/structs/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Fatih Arslan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/fatih/structs/README.md

@@ -1,163 +0,0 @@
-# Structs [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/structs) [![Build Status](http://img.shields.io/travis/fatih/structs.svg?style=flat-square)](https://travis-ci.org/fatih/structs) [![Coverage Status](http://img.shields.io/coveralls/fatih/structs.svg?style=flat-square)](https://coveralls.io/r/fatih/structs)
-
-Structs contains various utilities to work with Go (Golang) structs. It was
-initially used by me to convert a struct into a `map[string]interface{}`. With
-time I've added other utilities for structs.  It's basically a high level
-package based on primitives from the reflect package. Feel free to add new
-functions or improve the existing code.
-
-## Install
-
-```bash
-go get github.com/fatih/structs
-```
-
-## Usage and Examples
-
-Just like the standard lib `strings`, `bytes` and co packages, `structs` has
-many global functions to manipulate or organize your struct data. Lets define
-and declare a struct:
-
-```go
-type Server struct {
-	Name        string `json:"name,omitempty"`
-	ID          int
-	Enabled     bool
-	users       []string // not exported
-	http.Server          // embedded
-}
-
-server := &Server{
-	Name:    "gopher",
-	ID:      123456,
-	Enabled: true,
-}
-```
-
-```go
-// Convert a struct to a map[string]interface{}
-// => {"Name":"gopher", "ID":123456, "Enabled":true}
-m := structs.Map(server)
-
-// Convert the values of a struct to a []interface{}
-// => ["gopher", 123456, true]
-v := structs.Values(server)
-
-// Convert the names of a struct to a []string
-// (see "Names methods" for more info about fields)
-n := structs.Names(server)
-
-// Convert the values of a struct to a []*Field
-// (see "Field methods" for more info about fields)
-f := structs.Fields(server)
-
-// Return the struct name => "Server"
-n := structs.Name(server)
-
-// Check if any field of a struct is initialized or not.
-h := structs.HasZero(server)
-
-// Check if all fields of a struct is initialized or not.
-z := structs.IsZero(server)
-
-// Check if server is a struct or a pointer to struct
-i := structs.IsStruct(server)
-```
-
-### Struct methods
-
-The structs functions can be also used as independent methods by creating a new
-`*structs.Struct`. This is handy if you want to have more control over the
-structs (such as retrieving a single Field).
-
-```go
-// Create a new struct type:
-s := structs.New(server)
-
-m := s.Map()              // Get a map[string]interface{}
-v := s.Values()           // Get a []interface{}
-f := s.Fields()           // Get a []*Field
-n := s.Names()            // Get a []string
-f := s.Field(name)        // Get a *Field based on the given field name
-f, ok := s.FieldOk(name)  // Get a *Field based on the given field name
-n := s.Name()             // Get the struct name
-h := s.HasZero()          // Check if any field is uninitialized
-z := s.IsZero()           // Check if all fields are uninitialized
-```
-
-### Field methods
-
-We can easily examine a single Field for more detail. Below you can see how we
-get and interact with various field methods:
-
-
-```go
-s := structs.New(server)
-
-// Get the Field struct for the "Name" field
-name := s.Field("Name")
-
-// Get the underlying value,  value => "gopher"
-value := name.Value().(string)
-
-// Set the field's value
-name.Set("another gopher")
-
-// Get the field's kind, kind =>  "string"
-name.Kind()
-
-// Check if the field is exported or not
-if name.IsExported() {
-	fmt.Println("Name field is exported")
-}
-
-// Check if the value is a zero value, such as "" for string, 0 for int
-if !name.IsZero() {
-	fmt.Println("Name is initialized")
-}
-
-// Check if the field is an anonymous (embedded) field
-if !name.IsEmbedded() {
-	fmt.Println("Name is not an embedded field")
-}
-
-// Get the Field's tag value for tag name "json", tag value => "name,omitempty"
-tagValue := name.Tag("json")
-```
-
-Nested structs are supported too:
-
-```go
-addrField := s.Field("Server").Field("Addr")
-
-// Get the value for addr
-a := addrField.Value().(string)
-
-// Or get all fields
-httpServer := s.Field("Server").Fields()
-```
-
-We can also get a slice of Fields from the Struct type to iterate over all
-fields. This is handy if you wish to examine all fields:
-
-```go
-s := structs.New(server)
-
-for _, f := range s.Fields() {
-	fmt.Printf("field name: %+v\n", f.Name())
-
-	if f.IsExported() {
-		fmt.Printf("value   : %+v\n", f.Value())
-		fmt.Printf("is zero : %+v\n", f.IsZero())
-	}
-}
-```
-
-## Credits
-
- * [Fatih Arslan](https://github.com/fatih)
- * [Cihangir Savas](https://github.com/cihangir)
-
-## License
-
-The MIT License (MIT) - see LICENSE.md for more details

vendor/github.com/fatih/structs/field.go

@@ -1,141 +0,0 @@
-package structs
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-var (
-	errNotExported = errors.New("field is not exported")
-	errNotSettable = errors.New("field is not settable")
-)
-
-// Field represents a single struct field that encapsulates high level
-// functions around the field.
-type Field struct {
-	value      reflect.Value
-	field      reflect.StructField
-	defaultTag string
-}
-
-// Tag returns the value associated with key in the tag string. If there is no
-// such key in the tag, Tag returns the empty string.
-func (f *Field) Tag(key string) string {
-	return f.field.Tag.Get(key)
-}
-
-// Value returns the underlying value of the field. It panics if the field
-// is not exported.
-func (f *Field) Value() interface{} {
-	return f.value.Interface()
-}
-
-// IsEmbedded returns true if the given field is an anonymous field (embedded)
-func (f *Field) IsEmbedded() bool {
-	return f.field.Anonymous
-}
-
-// IsExported returns true if the given field is exported.
-func (f *Field) IsExported() bool {
-	return f.field.PkgPath == ""
-}
-
-// IsZero returns true if the given field is not initialized (has a zero value).
-// It panics if the field is not exported.
-func (f *Field) IsZero() bool {
-	zero := reflect.Zero(f.value.Type()).Interface()
-	current := f.Value()
-
-	return reflect.DeepEqual(current, zero)
-}
-
-// Name returns the name of the given field
-func (f *Field) Name() string {
-	return f.field.Name
-}
-
-// Kind returns the fields kind, such as "string", "map", "bool", etc ..
-func (f *Field) Kind() reflect.Kind {
-	return f.value.Kind()
-}
-
-// Set sets the field to given value v. It returns an error if the field is not
-// settable (not addressable or not exported) or if the given value's type
-// doesn't match the fields type.
-func (f *Field) Set(val interface{}) error {
-	// we can't set unexported fields, so be sure this field is exported
-	if !f.IsExported() {
-		return errNotExported
-	}
-
-	// do we get here? not sure...
-	if !f.value.CanSet() {
-		return errNotSettable
-	}
-
-	given := reflect.ValueOf(val)
-
-	if f.value.Kind() != given.Kind() {
-		return fmt.Errorf("wrong kind. got: %s want: %s", given.Kind(), f.value.Kind())
-	}
-
-	f.value.Set(given)
-	return nil
-}
-
-// Zero sets the field to its zero value. It returns an error if the field is not
-// settable (not addressable or not exported).
-func (f *Field) Zero() error {
-	zero := reflect.Zero(f.value.Type()).Interface()
-	return f.Set(zero)
-}
-
-// Fields returns a slice of Fields. This is particular handy to get the fields
-// of a nested struct . A struct tag with the content of "-" ignores the
-// checking of that particular field. Example:
-//
-//   // Field is ignored by this package.
-//   Field *http.Request `structs:"-"`
-//
-// It panics if field is not exported or if field's kind is not struct
-func (f *Field) Fields() []*Field {
-	return getFields(f.value, f.defaultTag)
-}
-
-// Field returns the field from a nested struct. It panics if the nested struct
-// is not exported or if the field was not found.
-func (f *Field) Field(name string) *Field {
-	field, ok := f.FieldOk(name)
-	if !ok {
-		panic("field not found")
-	}
-
-	return field
-}
-
-// FieldOk returns the field from a nested struct. The boolean returns whether
-// the field was found (true) or not (false).
-func (f *Field) FieldOk(name string) (*Field, bool) {
-	value := &f.value
-	// value must be settable so we need to make sure it holds the address of the
-	// variable and not a copy, so we can pass the pointer to strctVal instead of a
-	// copy (which is not assigned to any variable, hence not settable).
-	// see "https://blog.golang.org/laws-of-reflection#TOC_8."
-	if f.value.Kind() != reflect.Ptr {
-		a := f.value.Addr()
-		value = &a
-	}
-	v := strctVal(value.Interface())
-	t := v.Type()
-
-	field, ok := t.FieldByName(name)
-	if !ok {
-		return nil, false
-	}
-
-	return &Field{
-		field: field,
-		value: v.FieldByName(name),
-	}, true
-}

vendor/github.com/fatih/structs/structs.go

@@ -1,584 +0,0 @@
-// Package structs contains various utilities functions to work with structs.
-package structs
-
-import (
-	"fmt"
-
-	"reflect"
-)
-
-var (
-	// DefaultTagName is the default tag name for struct fields which provides
-	// a more granular to tweak certain structs. Lookup the necessary functions
-	// for more info.
-	DefaultTagName = "structs" // struct's field default tag name
-)
-
-// Struct encapsulates a struct type to provide several high level functions
-// around the struct.
-type Struct struct {
-	raw     interface{}
-	value   reflect.Value
-	TagName string
-}
-
-// New returns a new *Struct with the struct s. It panics if the s's kind is
-// not struct.
-func New(s interface{}) *Struct {
-	return &Struct{
-		raw:     s,
-		value:   strctVal(s),
-		TagName: DefaultTagName,
-	}
-}
-
-// Map converts the given struct to a map[string]interface{}, where the keys
-// of the map are the field names and the values of the map the associated
-// values of the fields. The default key string is the struct field name but
-// can be changed in the struct field's tag value. The "structs" key in the
-// struct's field tag value is the key name. Example:
-//
-//   // Field appears in map as key "myName".
-//   Name string `structs:"myName"`
-//
-// A tag value with the content of "-" ignores that particular field. Example:
-//
-//   // Field is ignored by this package.
-//   Field bool `structs:"-"`
-//
-// A tag value with the content of "string" uses the stringer to get the value. Example:
-//
-//   // The value will be output of Animal's String() func.
-//   // Map will panic if Animal does not implement String().
-//   Field *Animal `structs:"field,string"`
-//
-// A tag value with the option of "flatten" used in a struct field is to flatten its fields
-// in the output map. Example:
-//
-//   // The FieldStruct's fields will be flattened into the output map.
-//   FieldStruct time.Time `structs:",flatten"`
-//
-// A tag value with the option of "omitnested" stops iterating further if the type
-// is a struct. Example:
-//
-//   // Field is not processed further by this package.
-//   Field time.Time     `structs:"myName,omitnested"`
-//   Field *http.Request `structs:",omitnested"`
-//
-// A tag value with the option of "omitempty" ignores that particular field if
-// the field value is empty. Example:
-//
-//   // Field appears in map as key "myName", but the field is
-//   // skipped if empty.
-//   Field string `structs:"myName,omitempty"`
-//
-//   // Field appears in map as key "Field" (the default), but
-//   // the field is skipped if empty.
-//   Field string `structs:",omitempty"`
-//
-// Note that only exported fields of a struct can be accessed, non exported
-// fields will be neglected.
-func (s *Struct) Map() map[string]interface{} {
-	out := make(map[string]interface{})
-	s.FillMap(out)
-	return out
-}
-
-// FillMap is the same as Map. Instead of returning the output, it fills the
-// given map.
-func (s *Struct) FillMap(out map[string]interface{}) {
-	if out == nil {
-		return
-	}
-
-	fields := s.structFields()
-
-	for _, field := range fields {
-		name := field.Name
-		val := s.value.FieldByName(name)
-		isSubStruct := false
-		var finalVal interface{}
-
-		tagName, tagOpts := parseTag(field.Tag.Get(s.TagName))
-		if tagName != "" {
-			name = tagName
-		}
-
-		// if the value is a zero value and the field is marked as omitempty do
-		// not include
-		if tagOpts.Has("omitempty") {
-			zero := reflect.Zero(val.Type()).Interface()
-			current := val.Interface()
-
-			if reflect.DeepEqual(current, zero) {
-				continue
-			}
-		}
-
-		if !tagOpts.Has("omitnested") {
-			finalVal = s.nested(val)
-
-			v := reflect.ValueOf(val.Interface())
-			if v.Kind() == reflect.Ptr {
-				v = v.Elem()
-			}
-
-			switch v.Kind() {
-			case reflect.Map, reflect.Struct:
-				isSubStruct = true
-			}
-		} else {
-			finalVal = val.Interface()
-		}
-
-		if tagOpts.Has("string") {
-			s, ok := val.Interface().(fmt.Stringer)
-			if ok {
-				out[name] = s.String()
-			}
-			continue
-		}
-
-		if isSubStruct && (tagOpts.Has("flatten")) {
-			for k := range finalVal.(map[string]interface{}) {
-				out[k] = finalVal.(map[string]interface{})[k]
-			}
-		} else {
-			out[name] = finalVal
-		}
-	}
-}
-
-// Values converts the given s struct's field values to a []interface{}.  A
-// struct tag with the content of "-" ignores the that particular field.
-// Example:
-//
-//   // Field is ignored by this package.
-//   Field int `structs:"-"`
-//
-// A value with the option of "omitnested" stops iterating further if the type
-// is a struct. Example:
-//
-//   // Fields is not processed further by this package.
-//   Field time.Time     `structs:",omitnested"`
-//   Field *http.Request `structs:",omitnested"`
-//
-// A tag value with the option of "omitempty" ignores that particular field and
-// is not added to the values if the field value is empty. Example:
-//
-//   // Field is skipped if empty
-//   Field string `structs:",omitempty"`
-//
-// Note that only exported fields of a struct can be accessed, non exported
-// fields  will be neglected.
-func (s *Struct) Values() []interface{} {
-	fields := s.structFields()
-
-	var t []interface{}
-
-	for _, field := range fields {
-		val := s.value.FieldByName(field.Name)
-
-		_, tagOpts := parseTag(field.Tag.Get(s.TagName))
-
-		// if the value is a zero value and the field is marked as omitempty do
-		// not include
-		if tagOpts.Has("omitempty") {
-			zero := reflect.Zero(val.Type()).Interface()
-			current := val.Interface()
-
-			if reflect.DeepEqual(current, zero) {
-				continue
-			}
-		}
-
-		if tagOpts.Has("string") {
-			s, ok := val.Interface().(fmt.Stringer)
-			if ok {
-				t = append(t, s.String())
-			}
-			continue
-		}
-
-		if IsStruct(val.Interface()) && !tagOpts.Has("omitnested") {
-			// look out for embedded structs, and convert them to a
-			// []interface{} to be added to the final values slice
-			t = append(t, Values(val.Interface())...)
-		} else {
-			t = append(t, val.Interface())
-		}
-	}
-
-	return t
-}
-
-// Fields returns a slice of Fields. A struct tag with the content of "-"
-// ignores the checking of that particular field. Example:
-//
-//   // Field is ignored by this package.
-//   Field bool `structs:"-"`
-//
-// It panics if s's kind is not struct.
-func (s *Struct) Fields() []*Field {
-	return getFields(s.value, s.TagName)
-}
-
-// Names returns a slice of field names. A struct tag with the content of "-"
-// ignores the checking of that particular field. Example:
-//
-//   // Field is ignored by this package.
-//   Field bool `structs:"-"`
-//
-// It panics if s's kind is not struct.
-func (s *Struct) Names() []string {
-	fields := getFields(s.value, s.TagName)
-
-	names := make([]string, len(fields))
-
-	for i, field := range fields {
-		names[i] = field.Name()
-	}
-
-	return names
-}
-
-func getFields(v reflect.Value, tagName string) []*Field {
-	if v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	t := v.Type()
-
-	var fields []*Field
-
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-
-		if tag := field.Tag.Get(tagName); tag == "-" {
-			continue
-		}
-
-		f := &Field{
-			field: field,
-			value: v.FieldByName(field.Name),
-		}
-
-		fields = append(fields, f)
-
-	}
-
-	return fields
-}
-
-// Field returns a new Field struct that provides several high level functions
-// around a single struct field entity. It panics if the field is not found.
-func (s *Struct) Field(name string) *Field {
-	f, ok := s.FieldOk(name)
-	if !ok {
-		panic("field not found")
-	}
-
-	return f
-}
-
-// FieldOk returns a new Field struct that provides several high level functions
-// around a single struct field entity. The boolean returns true if the field
-// was found.
-func (s *Struct) FieldOk(name string) (*Field, bool) {
-	t := s.value.Type()
-
-	field, ok := t.FieldByName(name)
-	if !ok {
-		return nil, false
-	}
-
-	return &Field{
-		field:      field,
-		value:      s.value.FieldByName(name),
-		defaultTag: s.TagName,
-	}, true
-}
-
-// IsZero returns true if all fields in a struct is a zero value (not
-// initialized) A struct tag with the content of "-" ignores the checking of
-// that particular field. Example:
-//
-//   // Field is ignored by this package.
-//   Field bool `structs:"-"`
-//
-// A value with the option of "omitnested" stops iterating further if the type
-// is a struct. Example:
-//
-//   // Field is not processed further by this package.
-//   Field time.Time     `structs:"myName,omitnested"`
-//   Field *http.Request `structs:",omitnested"`
-//
-// Note that only exported fields of a struct can be accessed, non exported
-// fields  will be neglected. It panics if s's kind is not struct.
-func (s *Struct) IsZero() bool {
-	fields := s.structFields()
-
-	for _, field := range fields {
-		val := s.value.FieldByName(field.Name)
-
-		_, tagOpts := parseTag(field.Tag.Get(s.TagName))
-
-		if IsStruct(val.Interface()) && !tagOpts.Has("omitnested") {
-			ok := IsZero(val.Interface())
-			if !ok {
-				return false
-			}
-
-			continue
-		}
-
-		// zero value of the given field, such as "" for string, 0 for int
-		zero := reflect.Zero(val.Type()).Interface()
-
-		//  current value of the given field
-		current := val.Interface()
-
-		if !reflect.DeepEqual(current, zero) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// HasZero returns true if a field in a struct is not initialized (zero value).
-// A struct tag with the content of "-" ignores the checking of that particular
-// field. Example:
-//
-//   // Field is ignored by this package.
-//   Field bool `structs:"-"`
-//
-// A value with the option of "omitnested" stops iterating further if the type
-// is a struct. Example:
-//
-//   // Field is not processed further by this package.
-//   Field time.Time     `structs:"myName,omitnested"`
-//   Field *http.Request `structs:",omitnested"`
-//
-// Note that only exported fields of a struct can be accessed, non exported
-// fields  will be neglected. It panics if s's kind is not struct.
-func (s *Struct) HasZero() bool {
-	fields := s.structFields()
-
-	for _, field := range fields {
-		val := s.value.FieldByName(field.Name)
-
-		_, tagOpts := parseTag(field.Tag.Get(s.TagName))
-
-		if IsStruct(val.Interface()) && !tagOpts.Has("omitnested") {
-			ok := HasZero(val.Interface())
-			if ok {
-				return true
-			}
-
-			continue
-		}
-
-		// zero value of the given field, such as "" for string, 0 for int
-		zero := reflect.Zero(val.Type()).Interface()
-
-		//  current value of the given field
-		current := val.Interface()
-
-		if reflect.DeepEqual(current, zero) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Name returns the structs's type name within its package. For more info refer
-// to Name() function.
-func (s *Struct) Name() string {
-	return s.value.Type().Name()
-}
-
-// structFields returns the exported struct fields for a given s struct. This
-// is a convenient helper method to avoid duplicate code in some of the
-// functions.
-func (s *Struct) structFields() []reflect.StructField {
-	t := s.value.Type()
-
-	var f []reflect.StructField
-
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		// we can't access the value of unexported fields
-		if field.PkgPath != "" {
-			continue
-		}
-
-		// don't check if it's omitted
-		if tag := field.Tag.Get(s.TagName); tag == "-" {
-			continue
-		}
-
-		f = append(f, field)
-	}
-
-	return f
-}
-
-func strctVal(s interface{}) reflect.Value {
-	v := reflect.ValueOf(s)
-
-	// if pointer get the underlying element≤
-	for v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	if v.Kind() != reflect.Struct {
-		panic("not struct")
-	}
-
-	return v
-}
-
-// Map converts the given struct to a map[string]interface{}. For more info
-// refer to Struct types Map() method. It panics if s's kind is not struct.
-func Map(s interface{}) map[string]interface{} {
-	return New(s).Map()
-}
-
-// FillMap is the same as Map. Instead of returning the output, it fills the
-// given map.
-func FillMap(s interface{}, out map[string]interface{}) {
-	New(s).FillMap(out)
-}
-
-// Values converts the given struct to a []interface{}. For more info refer to
-// Struct types Values() method.  It panics if s's kind is not struct.
-func Values(s interface{}) []interface{} {
-	return New(s).Values()
-}
-
-// Fields returns a slice of *Field. For more info refer to Struct types
-// Fields() method.  It panics if s's kind is not struct.
-func Fields(s interface{}) []*Field {
-	return New(s).Fields()
-}
-
-// Names returns a slice of field names. For more info refer to Struct types
-// Names() method.  It panics if s's kind is not struct.
-func Names(s interface{}) []string {
-	return New(s).Names()
-}
-
-// IsZero returns true if all fields is equal to a zero value. For more info
-// refer to Struct types IsZero() method.  It panics if s's kind is not struct.
-func IsZero(s interface{}) bool {
-	return New(s).IsZero()
-}
-
-// HasZero returns true if any field is equal to a zero value. For more info
-// refer to Struct types HasZero() method.  It panics if s's kind is not struct.
-func HasZero(s interface{}) bool {
-	return New(s).HasZero()
-}
-
-// IsStruct returns true if the given variable is a struct or a pointer to
-// struct.
-func IsStruct(s interface{}) bool {
-	v := reflect.ValueOf(s)
-	if v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	// uninitialized zero value of a struct
-	if v.Kind() == reflect.Invalid {
-		return false
-	}
-
-	return v.Kind() == reflect.Struct
-}
-
-// Name returns the structs's type name within its package. It returns an
-// empty string for unnamed types. It panics if s's kind is not struct.
-func Name(s interface{}) string {
-	return New(s).Name()
-}
-
-// nested retrieves recursively all types for the given value and returns the
-// nested value.
-func (s *Struct) nested(val reflect.Value) interface{} {
-	var finalVal interface{}
-
-	v := reflect.ValueOf(val.Interface())
-	if v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	switch v.Kind() {
-	case reflect.Struct:
-		n := New(val.Interface())
-		n.TagName = s.TagName
-		m := n.Map()
-
-		// do not add the converted value if there are no exported fields, ie:
-		// time.Time
-		if len(m) == 0 {
-			finalVal = val.Interface()
-		} else {
-			finalVal = m
-		}
-	case reflect.Map:
-		// get the element type of the map
-		mapElem := val.Type()
-		switch val.Type().Kind() {
-		case reflect.Ptr, reflect.Array, reflect.Map,
-			reflect.Slice, reflect.Chan:
-			mapElem = val.Type().Elem()
-			if mapElem.Kind() == reflect.Ptr {
-				mapElem = mapElem.Elem()
-			}
-		}
-
-		// only iterate over struct types, ie: map[string]StructType,
-		// map[string][]StructType,
-		if mapElem.Kind() == reflect.Struct ||
-			(mapElem.Kind() == reflect.Slice &&
-				mapElem.Elem().Kind() == reflect.Struct) {
-			m := make(map[string]interface{}, val.Len())
-			for _, k := range val.MapKeys() {
-				m[k.String()] = s.nested(val.MapIndex(k))
-			}
-			finalVal = m
-			break
-		}
-
-		// TODO(arslan): should this be optional?
-		finalVal = val.Interface()
-	case reflect.Slice, reflect.Array:
-		if val.Type().Kind() == reflect.Interface {
-			finalVal = val.Interface()
-			break
-		}
-
-		// TODO(arslan): should this be optional?
-		// do not iterate of non struct types, just pass the value. Ie: []int,
-		// []string, co... We only iterate further if it's a struct.
-		// i.e []foo or []*foo
-		if val.Type().Elem().Kind() != reflect.Struct &&
-			!(val.Type().Elem().Kind() == reflect.Ptr &&
-				val.Type().Elem().Elem().Kind() == reflect.Struct) {
-			finalVal = val.Interface()
-			break
-		}
-
-		slices := make([]interface{}, val.Len())
-		for x := 0; x < val.Len(); x++ {
-			slices[x] = s.nested(val.Index(x))
-		}
-		finalVal = slices
-	default:
-		finalVal = val.Interface()
-	}
-
-	return finalVal
-}

vendor/github.com/fatih/structs/tags.go

@@ -1,32 +0,0 @@
-package structs
-
-import "strings"
-
-// tagOptions contains a slice of tag options
-type tagOptions []string
-
-// Has returns true if the given option is available in tagOptions
-func (t tagOptions) Has(opt string) bool {
-	for _, tagOpt := range t {
-		if tagOpt == opt {
-			return true
-		}
-	}
-
-	return false
-}
-
-// parseTag splits a struct field's tag into its name and a list of options
-// which comes after a name. A tag is in the form of: "name,option1,option2".
-// The name can be neglectected.
-func parseTag(tag string) (string, tagOptions) {
-	// tag is one of followings:
-	// ""
-	// "name"
-	// "name,opt"
-	// "name,opt,opt2"
-	// ",opt"
-
-	res := strings.Split(tag, ",")
-	return res[0], res[1:]
-}

vendor/github.com/golang/protobuf/AUTHORS

@@ -1,3 +0,0 @@
-# This source code refers to The Go Authors for copyright purposes.
-# The master list of authors is in the main Go distribution,
-# visible at http://tip.golang.org/AUTHORS.

vendor/github.com/golang/protobuf/CONTRIBUTORS

@@ -1,3 +0,0 @@
-# This source code was written by the Go contributors.
-# The master list of contributors is in the main Go distribution,
-# visible at http://tip.golang.org/CONTRIBUTORS.

vendor/github.com/golang/protobuf/LICENSE

@@ -1,28 +0,0 @@
-Copyright 2010 The Go Authors.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

vendor/github.com/golang/protobuf/proto/clone.go

@@ -1,253 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer deep copy and merge.
-// TODO: RawMessage.
-
-package proto
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"strings"
-)
-
-// Clone returns a deep copy of a protocol buffer.
-func Clone(src Message) Message {
-	in := reflect.ValueOf(src)
-	if in.IsNil() {
-		return src
-	}
-	out := reflect.New(in.Type().Elem())
-	dst := out.Interface().(Message)
-	Merge(dst, src)
-	return dst
-}
-
-// Merger is the interface representing objects that can merge messages of the same type.
-type Merger interface {
-	// Merge merges src into this message.
-	// Required and optional fields that are set in src will be set to that value in dst.
-	// Elements of repeated fields will be appended.
-	//
-	// Merge may panic if called with a different argument type than the receiver.
-	Merge(src Message)
-}
-
-// generatedMerger is the custom merge method that generated protos will have.
-// We must add this method since a generate Merge method will conflict with
-// many existing protos that have a Merge data field already defined.
-type generatedMerger interface {
-	XXX_Merge(src Message)
-}
-
-// Merge merges src into dst.
-// Required and optional fields that are set in src will be set to that value in dst.
-// Elements of repeated fields will be appended.
-// Merge panics if src and dst are not the same type, or if dst is nil.
-func Merge(dst, src Message) {
-	if m, ok := dst.(Merger); ok {
-		m.Merge(src)
-		return
-	}
-
-	in := reflect.ValueOf(src)
-	out := reflect.ValueOf(dst)
-	if out.IsNil() {
-		panic("proto: nil destination")
-	}
-	if in.Type() != out.Type() {
-		panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
-	}
-	if in.IsNil() {
-		return // Merge from nil src is a noop
-	}
-	if m, ok := dst.(generatedMerger); ok {
-		m.XXX_Merge(src)
-		return
-	}
-	mergeStruct(out.Elem(), in.Elem())
-}
-
-func mergeStruct(out, in reflect.Value) {
-	sprop := GetProperties(in.Type())
-	for i := 0; i < in.NumField(); i++ {
-		f := in.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
-	}
-
-	if emIn, err := extendable(in.Addr().Interface()); err == nil {
-		emOut, _ := extendable(out.Addr().Interface())
-		mIn, muIn := emIn.extensionsRead()
-		if mIn != nil {
-			mOut := emOut.extensionsWrite()
-			muIn.Lock()
-			mergeExtension(mOut, mIn)
-			muIn.Unlock()
-		}
-	}
-
-	uf := in.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return
-	}
-	uin := uf.Bytes()
-	if len(uin) > 0 {
-		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
-	}
-}
-
-// mergeAny performs a merge between two values of the same type.
-// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
-// prop is set if this is a struct field (it may be nil).
-func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
-	if in.Type() == protoMessageType {
-		if !in.IsNil() {
-			if out.IsNil() {
-				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
-			} else {
-				Merge(out.Interface().(Message), in.Interface().(Message))
-			}
-		}
-		return
-	}
-	switch in.Kind() {
-	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-		reflect.String, reflect.Uint32, reflect.Uint64:
-		if !viaPtr && isProto3Zero(in) {
-			return
-		}
-		out.Set(in)
-	case reflect.Interface:
-		// Probably a oneof field; copy non-nil values.
-		if in.IsNil() {
-			return
-		}
-		// Allocate destination if it is not set, or set to a different type.
-		// Otherwise we will merge as normal.
-		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
-			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
-		}
-		mergeAny(out.Elem(), in.Elem(), false, nil)
-	case reflect.Map:
-		if in.Len() == 0 {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.MakeMap(in.Type()))
-		}
-		// For maps with value types of *T or []byte we need to deep copy each value.
-		elemKind := in.Type().Elem().Kind()
-		for _, key := range in.MapKeys() {
-			var val reflect.Value
-			switch elemKind {
-			case reflect.Ptr:
-				val = reflect.New(in.Type().Elem().Elem())
-				mergeAny(val, in.MapIndex(key), false, nil)
-			case reflect.Slice:
-				val = in.MapIndex(key)
-				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
-			default:
-				val = in.MapIndex(key)
-			}
-			out.SetMapIndex(key, val)
-		}
-	case reflect.Ptr:
-		if in.IsNil() {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.New(in.Elem().Type()))
-		}
-		mergeAny(out.Elem(), in.Elem(), true, nil)
-	case reflect.Slice:
-		if in.IsNil() {
-			return
-		}
-		if in.Type().Elem().Kind() == reflect.Uint8 {
-			// []byte is a scalar bytes field, not a repeated field.
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value, and should not
-			// be merged.
-			if prop != nil && prop.proto3 && in.Len() == 0 {
-				return
-			}
-
-			// Make a deep copy.
-			// Append to []byte{} instead of []byte(nil) so that we never end up
-			// with a nil result.
-			out.SetBytes(append([]byte{}, in.Bytes()...))
-			return
-		}
-		n := in.Len()
-		if out.IsNil() {
-			out.Set(reflect.MakeSlice(in.Type(), 0, n))
-		}
-		switch in.Type().Elem().Kind() {
-		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-			reflect.String, reflect.Uint32, reflect.Uint64:
-			out.Set(reflect.AppendSlice(out, in))
-		default:
-			for i := 0; i < n; i++ {
-				x := reflect.Indirect(reflect.New(in.Type().Elem()))
-				mergeAny(x, in.Index(i), false, nil)
-				out.Set(reflect.Append(out, x))
-			}
-		}
-	case reflect.Struct:
-		mergeStruct(out, in)
-	default:
-		// unknown type, so not a protocol buffer
-		log.Printf("proto: don't know how to copy %v", in)
-	}
-}
-
-func mergeExtension(out, in map[int32]Extension) {
-	for extNum, eIn := range in {
-		eOut := Extension{desc: eIn.desc}
-		if eIn.value != nil {
-			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
-			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
-			eOut.value = v.Interface()
-		}
-		if eIn.enc != nil {
-			eOut.enc = make([]byte, len(eIn.enc))
-			copy(eOut.enc, eIn.enc)
-		}
-
-		out[extNum] = eOut
-	}
-}

vendor/github.com/golang/protobuf/proto/decode.go

@@ -1,427 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for decoding protocol buffer data to construct in-memory representations.
- */
-
-import (
-	"errors"
-	"fmt"
-	"io"
-)
-
-// errOverflow is returned when an integer is too large to be represented.
-var errOverflow = errors.New("proto: integer overflow")
-
-// ErrInternalBadWireType is returned by generated code when an incorrect
-// wire type is encountered. It does not get returned to user code.
-var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
-
-// DecodeVarint reads a varint-encoded integer from the slice.
-// It returns the integer and the number of bytes consumed, or
-// zero if there is not enough.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func DecodeVarint(buf []byte) (x uint64, n int) {
-	for shift := uint(0); shift < 64; shift += 7 {
-		if n >= len(buf) {
-			return 0, 0
-		}
-		b := uint64(buf[n])
-		n++
-		x |= (b & 0x7F) << shift
-		if (b & 0x80) == 0 {
-			return x, n
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	return 0, 0
-}
-
-func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
-	i := p.index
-	l := len(p.buf)
-
-	for shift := uint(0); shift < 64; shift += 7 {
-		if i >= l {
-			err = io.ErrUnexpectedEOF
-			return
-		}
-		b := p.buf[i]
-		i++
-		x |= (uint64(b) & 0x7F) << shift
-		if b < 0x80 {
-			p.index = i
-			return
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	err = errOverflow
-	return
-}
-
-// DecodeVarint reads a varint-encoded integer from the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) DecodeVarint() (x uint64, err error) {
-	i := p.index
-	buf := p.buf
-
-	if i >= len(buf) {
-		return 0, io.ErrUnexpectedEOF
-	} else if buf[i] < 0x80 {
-		p.index++
-		return uint64(buf[i]), nil
-	} else if len(buf)-i < 10 {
-		return p.decodeVarintSlow()
-	}
-
-	var b uint64
-	// we already checked the first byte
-	x = uint64(buf[i]) - 0x80
-	i++
-
-	b = uint64(buf[i])
-	i++
-	x += b << 7
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 7
-
-	b = uint64(buf[i])
-	i++
-	x += b << 14
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 14
-
-	b = uint64(buf[i])
-	i++
-	x += b << 21
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 21
-
-	b = uint64(buf[i])
-	i++
-	x += b << 28
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 28
-
-	b = uint64(buf[i])
-	i++
-	x += b << 35
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 35
-
-	b = uint64(buf[i])
-	i++
-	x += b << 42
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 42
-
-	b = uint64(buf[i])
-	i++
-	x += b << 49
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 49
-
-	b = uint64(buf[i])
-	i++
-	x += b << 56
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 56
-
-	b = uint64(buf[i])
-	i++
-	x += b << 63
-	if b&0x80 == 0 {
-		goto done
-	}
-
-	return 0, errOverflow
-
-done:
-	p.index = i
-	return x, nil
-}
-
-// DecodeFixed64 reads a 64-bit integer from the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) DecodeFixed64() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 8
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-8])
-	x |= uint64(p.buf[i-7]) << 8
-	x |= uint64(p.buf[i-6]) << 16
-	x |= uint64(p.buf[i-5]) << 24
-	x |= uint64(p.buf[i-4]) << 32
-	x |= uint64(p.buf[i-3]) << 40
-	x |= uint64(p.buf[i-2]) << 48
-	x |= uint64(p.buf[i-1]) << 56
-	return
-}
-
-// DecodeFixed32 reads a 32-bit integer from the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) DecodeFixed32() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 4
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-4])
-	x |= uint64(p.buf[i-3]) << 8
-	x |= uint64(p.buf[i-2]) << 16
-	x |= uint64(p.buf[i-1]) << 24
-	return
-}
-
-// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
-// from the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
-	return
-}
-
-// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
-// from  the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
-	return
-}
-
-// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
-	n, err := p.DecodeVarint()
-	if err != nil {
-		return nil, err
-	}
-
-	nb := int(n)
-	if nb < 0 {
-		return nil, fmt.Errorf("proto: bad byte length %d", nb)
-	}
-	end := p.index + nb
-	if end < p.index || end > len(p.buf) {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	if !alloc {
-		// todo: check if can get more uses of alloc=false
-		buf = p.buf[p.index:end]
-		p.index += nb
-		return
-	}
-
-	buf = make([]byte, nb)
-	copy(buf, p.buf[p.index:])
-	p.index += nb
-	return
-}
-
-// DecodeStringBytes reads an encoded string from the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) DecodeStringBytes() (s string, err error) {
-	buf, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return
-	}
-	return string(buf), nil
-}
-
-// Unmarshaler is the interface representing objects that can
-// unmarshal themselves.  The argument points to data that may be
-// overwritten, so implementations should not keep references to the
-// buffer.
-// Unmarshal implementations should not clear the receiver.
-// Any unmarshaled data should be merged into the receiver.
-// Callers of Unmarshal that do not want to retain existing data
-// should Reset the receiver before calling Unmarshal.
-type Unmarshaler interface {
-	Unmarshal([]byte) error
-}
-
-// newUnmarshaler is the interface representing objects that can
-// unmarshal themselves. The semantics are identical to Unmarshaler.
-//
-// This exists to support protoc-gen-go generated messages.
-// The proto package will stop type-asserting to this interface in the future.
-//
-// DO NOT DEPEND ON THIS.
-type newUnmarshaler interface {
-	XXX_Unmarshal([]byte) error
-}
-
-// Unmarshal parses the protocol buffer representation in buf and places the
-// decoded result in pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// Unmarshal resets pb before starting to unmarshal, so any
-// existing data in pb is always removed. Use UnmarshalMerge
-// to preserve and append to existing data.
-func Unmarshal(buf []byte, pb Message) error {
-	pb.Reset()
-	if u, ok := pb.(newUnmarshaler); ok {
-		return u.XXX_Unmarshal(buf)
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		return u.Unmarshal(buf)
-	}
-	return NewBuffer(buf).Unmarshal(pb)
-}
-
-// UnmarshalMerge parses the protocol buffer representation in buf and
-// writes the decoded result to pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// UnmarshalMerge merges into existing data in pb.
-// Most code should use Unmarshal instead.
-func UnmarshalMerge(buf []byte, pb Message) error {
-	if u, ok := pb.(newUnmarshaler); ok {
-		return u.XXX_Unmarshal(buf)
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		// NOTE: The history of proto have unfortunately been inconsistent
-		// whether Unmarshaler should or should not implicitly clear itself.
-		// Some implementations do, most do not.
-		// Thus, calling this here may or may not do what people want.
-		//
-		// See https://github.com/golang/protobuf/issues/424
-		return u.Unmarshal(buf)
-	}
-	return NewBuffer(buf).Unmarshal(pb)
-}
-
-// DecodeMessage reads a count-delimited message from the Buffer.
-func (p *Buffer) DecodeMessage(pb Message) error {
-	enc, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-	return NewBuffer(enc).Unmarshal(pb)
-}
-
-// DecodeGroup reads a tag-delimited group from the Buffer.
-// StartGroup tag is already consumed. This function consumes
-// EndGroup tag.
-func (p *Buffer) DecodeGroup(pb Message) error {
-	b := p.buf[p.index:]
-	x, y := findEndGroup(b)
-	if x < 0 {
-		return io.ErrUnexpectedEOF
-	}
-	err := Unmarshal(b[:x], pb)
-	p.index += y
-	return err
-}
-
-// Unmarshal parses the protocol buffer representation in the
-// Buffer and places the decoded result in pb.  If the struct
-// underlying pb does not match the data in the buffer, the results can be
-// unpredictable.
-//
-// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
-func (p *Buffer) Unmarshal(pb Message) error {
-	// If the object can unmarshal itself, let it.
-	if u, ok := pb.(newUnmarshaler); ok {
-		err := u.XXX_Unmarshal(p.buf[p.index:])
-		p.index = len(p.buf)
-		return err
-	}
-	if u, ok := pb.(Unmarshaler); ok {
-		// NOTE: The history of proto have unfortunately been inconsistent
-		// whether Unmarshaler should or should not implicitly clear itself.
-		// Some implementations do, most do not.
-		// Thus, calling this here may or may not do what people want.
-		//
-		// See https://github.com/golang/protobuf/issues/424
-		err := u.Unmarshal(p.buf[p.index:])
-		p.index = len(p.buf)
-		return err
-	}
-
-	// Slow workaround for messages that aren't Unmarshalers.
-	// This includes some hand-coded .pb.go files and
-	// bootstrap protos.
-	// TODO: fix all of those and then add Unmarshal to
-	// the Message interface. Then:
-	// The cast above and code below can be deleted.
-	// The old unmarshaler can be deleted.
-	// Clients can call Unmarshal directly (can already do that, actually).
-	var info InternalMessageInfo
-	err := info.Unmarshal(pb, p.buf[p.index:])
-	p.index = len(p.buf)
-	return err
-}

vendor/github.com/golang/protobuf/proto/deprecated.go

@@ -1,63 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2018 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import "errors"
-
-// Deprecated: do not use.
-type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
-
-// Deprecated: do not use.
-func GetStats() Stats { return Stats{} }
-
-// Deprecated: do not use.
-func MarshalMessageSet(interface{}) ([]byte, error) {
-	return nil, errors.New("proto: not implemented")
-}
-
-// Deprecated: do not use.
-func UnmarshalMessageSet([]byte, interface{}) error {
-	return errors.New("proto: not implemented")
-}
-
-// Deprecated: do not use.
-func MarshalMessageSetJSON(interface{}) ([]byte, error) {
-	return nil, errors.New("proto: not implemented")
-}
-
-// Deprecated: do not use.
-func UnmarshalMessageSetJSON([]byte, interface{}) error {
-	return errors.New("proto: not implemented")
-}
-
-// Deprecated: do not use.
-func RegisterMessageSetType(Message, int32, string) {}

vendor/github.com/golang/protobuf/proto/discard.go

@@ -1,350 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2017 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"sync/atomic"
-)
-
-type generatedDiscarder interface {
-	XXX_DiscardUnknown()
-}
-
-// DiscardUnknown recursively discards all unknown fields from this message
-// and all embedded messages.
-//
-// When unmarshaling a message with unrecognized fields, the tags and values
-// of such fields are preserved in the Message. This allows a later call to
-// marshal to be able to produce a message that continues to have those
-// unrecognized fields. To avoid this, DiscardUnknown is used to
-// explicitly clear the unknown fields after unmarshaling.
-//
-// For proto2 messages, the unknown fields of message extensions are only
-// discarded from messages that have been accessed via GetExtension.
-func DiscardUnknown(m Message) {
-	if m, ok := m.(generatedDiscarder); ok {
-		m.XXX_DiscardUnknown()
-		return
-	}
-	// TODO: Dynamically populate a InternalMessageInfo for legacy messages,
-	// but the master branch has no implementation for InternalMessageInfo,
-	// so it would be more work to replicate that approach.
-	discardLegacy(m)
-}
-
-// DiscardUnknown recursively discards all unknown fields.
-func (a *InternalMessageInfo) DiscardUnknown(m Message) {
-	di := atomicLoadDiscardInfo(&a.discard)
-	if di == nil {
-		di = getDiscardInfo(reflect.TypeOf(m).Elem())
-		atomicStoreDiscardInfo(&a.discard, di)
-	}
-	di.discard(toPointer(&m))
-}
-
-type discardInfo struct {
-	typ reflect.Type
-
-	initialized int32 // 0: only typ is valid, 1: everything is valid
-	lock        sync.Mutex
-
-	fields       []discardFieldInfo
-	unrecognized field
-}
-
-type discardFieldInfo struct {
-	field   field // Offset of field, guaranteed to be valid
-	discard func(src pointer)
-}
-
-var (
-	discardInfoMap  = map[reflect.Type]*discardInfo{}
-	discardInfoLock sync.Mutex
-)
-
-func getDiscardInfo(t reflect.Type) *discardInfo {
-	discardInfoLock.Lock()
-	defer discardInfoLock.Unlock()
-	di := discardInfoMap[t]
-	if di == nil {
-		di = &discardInfo{typ: t}
-		discardInfoMap[t] = di
-	}
-	return di
-}
-
-func (di *discardInfo) discard(src pointer) {
-	if src.isNil() {
-		return // Nothing to do.
-	}
-
-	if atomic.LoadInt32(&di.initialized) == 0 {
-		di.computeDiscardInfo()
-	}
-
-	for _, fi := range di.fields {
-		sfp := src.offset(fi.field)
-		fi.discard(sfp)
-	}
-
-	// For proto2 messages, only discard unknown fields in message extensions
-	// that have been accessed via GetExtension.
-	if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
-		// Ignore lock since DiscardUnknown is not concurrency safe.
-		emm, _ := em.extensionsRead()
-		for _, mx := range emm {
-			if m, ok := mx.value.(Message); ok {
-				DiscardUnknown(m)
-			}
-		}
-	}
-
-	if di.unrecognized.IsValid() {
-		*src.offset(di.unrecognized).toBytes() = nil
-	}
-}
-
-func (di *discardInfo) computeDiscardInfo() {
-	di.lock.Lock()
-	defer di.lock.Unlock()
-	if di.initialized != 0 {
-		return
-	}
-	t := di.typ
-	n := t.NumField()
-
-	for i := 0; i < n; i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-
-		dfi := discardFieldInfo{field: toField(&f)}
-		tf := f.Type
-
-		// Unwrap tf to get its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
-		}
-
-		switch tf.Kind() {
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
-			case isSlice: // E.g., []*pb.T
-				di := getDiscardInfo(tf)
-				dfi.discard = func(src pointer) {
-					sps := src.getPointerSlice()
-					for _, sp := range sps {
-						if !sp.isNil() {
-							di.discard(sp)
-						}
-					}
-				}
-			default: // E.g., *pb.T
-				di := getDiscardInfo(tf)
-				dfi.discard = func(src pointer) {
-					sp := src.getPointer()
-					if !sp.isNil() {
-						di.discard(sp)
-					}
-				}
-			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
-			default: // E.g., map[K]V
-				if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
-					dfi.discard = func(src pointer) {
-						sm := src.asPointerTo(tf).Elem()
-						if sm.Len() == 0 {
-							return
-						}
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							DiscardUnknown(val.Interface().(Message))
-						}
-					}
-				} else {
-					dfi.discard = func(pointer) {} // Noop
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
-			default: // E.g., interface{}
-				// TODO: Make this faster?
-				dfi.discard = func(src pointer) {
-					su := src.asPointerTo(tf).Elem()
-					if !su.IsNil() {
-						sv := su.Elem().Elem().Field(0)
-						if sv.Kind() == reflect.Ptr && sv.IsNil() {
-							return
-						}
-						switch sv.Type().Kind() {
-						case reflect.Ptr: // Proto struct (e.g., *T)
-							DiscardUnknown(sv.Interface().(Message))
-						}
-					}
-				}
-			}
-		default:
-			continue
-		}
-		di.fields = append(di.fields, dfi)
-	}
-
-	di.unrecognized = invalidField
-	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
-		if f.Type != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		di.unrecognized = toField(&f)
-	}
-
-	atomic.StoreInt32(&di.initialized, 1)
-}
-
-func discardLegacy(m Message) {
-	v := reflect.ValueOf(m)
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return
-	}
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return
-	}
-	t := v.Type()
-
-	for i := 0; i < v.NumField(); i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		vf := v.Field(i)
-		tf := f.Type
-
-		// Unwrap tf to get its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
-		}
-
-		switch tf.Kind() {
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
-			case isSlice: // E.g., []*pb.T
-				for j := 0; j < vf.Len(); j++ {
-					discardLegacy(vf.Index(j).Interface().(Message))
-				}
-			default: // E.g., *pb.T
-				discardLegacy(vf.Interface().(Message))
-			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
-			default: // E.g., map[K]V
-				tv := vf.Type().Elem()
-				if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
-					for _, key := range vf.MapKeys() {
-						val := vf.MapIndex(key)
-						discardLegacy(val.Interface().(Message))
-					}
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
-			default: // E.g., test_proto.isCommunique_Union interface
-				if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
-					vf = vf.Elem() // E.g., *test_proto.Communique_Msg
-					if !vf.IsNil() {
-						vf = vf.Elem()   // E.g., test_proto.Communique_Msg
-						vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
-						if vf.Kind() == reflect.Ptr {
-							discardLegacy(vf.Interface().(Message))
-						}
-					}
-				}
-			}
-		}
-	}
-
-	if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
-		if vf.Type() != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		vf.Set(reflect.ValueOf([]byte(nil)))
-	}
-
-	// For proto2 messages, only discard unknown fields in message extensions
-	// that have been accessed via GetExtension.
-	if em, err := extendable(m); err == nil {
-		// Ignore lock since discardLegacy is not concurrency safe.
-		emm, _ := em.extensionsRead()
-		for _, mx := range emm {
-			if m, ok := mx.value.(Message); ok {
-				discardLegacy(m)
-			}
-		}
-	}
-}

vendor/github.com/golang/protobuf/proto/encode.go

@@ -1,203 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
-import (
-	"errors"
-	"reflect"
-)
-
-var (
-	// errRepeatedHasNil is the error returned if Marshal is called with
-	// a struct with a repeated field containing a nil element.
-	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
-
-	// errOneofHasNil is the error returned if Marshal is called with
-	// a struct with a oneof field containing a nil element.
-	errOneofHasNil = errors.New("proto: oneof field has nil value")
-
-	// ErrNil is the error returned if Marshal is called with nil.
-	ErrNil = errors.New("proto: Marshal called with nil")
-
-	// ErrTooLarge is the error returned if Marshal is called with a
-	// message that encodes to >2GB.
-	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
-)
-
-// The fundamental encoders that put bytes on the wire.
-// Those that take integer types all accept uint64 and are
-// therefore of type valueEncoder.
-
-const maxVarintBytes = 10 // maximum length of a varint
-
-// EncodeVarint returns the varint encoding of x.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-// Not used by the package itself, but helpful to clients
-// wishing to use the same encoding.
-func EncodeVarint(x uint64) []byte {
-	var buf [maxVarintBytes]byte
-	var n int
-	for n = 0; x > 127; n++ {
-		buf[n] = 0x80 | uint8(x&0x7F)
-		x >>= 7
-	}
-	buf[n] = uint8(x)
-	n++
-	return buf[0:n]
-}
-
-// EncodeVarint writes a varint-encoded integer to the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) EncodeVarint(x uint64) error {
-	for x >= 1<<7 {
-		p.buf = append(p.buf, uint8(x&0x7f|0x80))
-		x >>= 7
-	}
-	p.buf = append(p.buf, uint8(x))
-	return nil
-}
-
-// SizeVarint returns the varint encoding size of an integer.
-func SizeVarint(x uint64) int {
-	switch {
-	case x < 1<<7:
-		return 1
-	case x < 1<<14:
-		return 2
-	case x < 1<<21:
-		return 3
-	case x < 1<<28:
-		return 4
-	case x < 1<<35:
-		return 5
-	case x < 1<<42:
-		return 6
-	case x < 1<<49:
-		return 7
-	case x < 1<<56:
-		return 8
-	case x < 1<<63:
-		return 9
-	}
-	return 10
-}
-
-// EncodeFixed64 writes a 64-bit integer to the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) EncodeFixed64(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24),
-		uint8(x>>32),
-		uint8(x>>40),
-		uint8(x>>48),
-		uint8(x>>56))
-	return nil
-}
-
-// EncodeFixed32 writes a 32-bit integer to the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) EncodeFixed32(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24))
-	return nil
-}
-
-// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
-// to the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) EncodeZigzag64(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-
-// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
-// to the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) EncodeZigzag32(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
-}
-
-// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) EncodeRawBytes(b []byte) error {
-	p.EncodeVarint(uint64(len(b)))
-	p.buf = append(p.buf, b...)
-	return nil
-}
-
-// EncodeStringBytes writes an encoded string to the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) EncodeStringBytes(s string) error {
-	p.EncodeVarint(uint64(len(s)))
-	p.buf = append(p.buf, s...)
-	return nil
-}
-
-// Marshaler is the interface representing objects that can marshal themselves.
-type Marshaler interface {
-	Marshal() ([]byte, error)
-}
-
-// EncodeMessage writes the protocol buffer to the Buffer,
-// prefixed by a varint-encoded length.
-func (p *Buffer) EncodeMessage(pb Message) error {
-	siz := Size(pb)
-	p.EncodeVarint(uint64(siz))
-	return p.Marshal(pb)
-}
-
-// All protocol buffer fields are nillable, but be careful.
-func isNil(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return v.IsNil()
-	}
-	return false
-}

vendor/github.com/golang/protobuf/proto/equal.go

@@ -1,301 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer comparison.
-
-package proto
-
-import (
-	"bytes"
-	"log"
-	"reflect"
-	"strings"
-)
-
-/*
-Equal returns true iff protocol buffers a and b are equal.
-The arguments must both be pointers to protocol buffer structs.
-
-Equality is defined in this way:
-  - Two messages are equal iff they are the same type,
-    corresponding fields are equal, unknown field sets
-    are equal, and extensions sets are equal.
-  - Two set scalar fields are equal iff their values are equal.
-    If the fields are of a floating-point type, remember that
-    NaN != x for all x, including NaN. If the message is defined
-    in a proto3 .proto file, fields are not "set"; specifically,
-    zero length proto3 "bytes" fields are equal (nil == {}).
-  - Two repeated fields are equal iff their lengths are the same,
-    and their corresponding elements are equal. Note a "bytes" field,
-    although represented by []byte, is not a repeated field and the
-    rule for the scalar fields described above applies.
-  - Two unset fields are equal.
-  - Two unknown field sets are equal if their current
-    encoded state is equal.
-  - Two extension sets are equal iff they have corresponding
-    elements that are pairwise equal.
-  - Two map fields are equal iff their lengths are the same,
-    and they contain the same set of elements. Zero-length map
-    fields are equal.
-  - Every other combination of things are not equal.
-
-The return value is undefined if a and b are not protocol buffers.
-*/
-func Equal(a, b Message) bool {
-	if a == nil || b == nil {
-		return a == b
-	}
-	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
-	if v1.Type() != v2.Type() {
-		return false
-	}
-	if v1.Kind() == reflect.Ptr {
-		if v1.IsNil() {
-			return v2.IsNil()
-		}
-		if v2.IsNil() {
-			return false
-		}
-		v1, v2 = v1.Elem(), v2.Elem()
-	}
-	if v1.Kind() != reflect.Struct {
-		return false
-	}
-	return equalStruct(v1, v2)
-}
-
-// v1 and v2 are known to have the same type.
-func equalStruct(v1, v2 reflect.Value) bool {
-	sprop := GetProperties(v1.Type())
-	for i := 0; i < v1.NumField(); i++ {
-		f := v1.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		f1, f2 := v1.Field(i), v2.Field(i)
-		if f.Type.Kind() == reflect.Ptr {
-			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
-				// both unset
-				continue
-			} else if n1 != n2 {
-				// set/unset mismatch
-				return false
-			}
-			f1, f2 = f1.Elem(), f2.Elem()
-		}
-		if !equalAny(f1, f2, sprop.Prop[i]) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_InternalExtensions")
-		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_extensions")
-		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
-			return false
-		}
-	}
-
-	uf := v1.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return true
-	}
-
-	u1 := uf.Bytes()
-	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
-	return bytes.Equal(u1, u2)
-}
-
-// v1 and v2 are known to have the same type.
-// prop may be nil.
-func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
-	if v1.Type() == protoMessageType {
-		m1, _ := v1.Interface().(Message)
-		m2, _ := v2.Interface().(Message)
-		return Equal(m1, m2)
-	}
-	switch v1.Kind() {
-	case reflect.Bool:
-		return v1.Bool() == v2.Bool()
-	case reflect.Float32, reflect.Float64:
-		return v1.Float() == v2.Float()
-	case reflect.Int32, reflect.Int64:
-		return v1.Int() == v2.Int()
-	case reflect.Interface:
-		// Probably a oneof field; compare the inner values.
-		n1, n2 := v1.IsNil(), v2.IsNil()
-		if n1 || n2 {
-			return n1 == n2
-		}
-		e1, e2 := v1.Elem(), v2.Elem()
-		if e1.Type() != e2.Type() {
-			return false
-		}
-		return equalAny(e1, e2, nil)
-	case reflect.Map:
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for _, key := range v1.MapKeys() {
-			val2 := v2.MapIndex(key)
-			if !val2.IsValid() {
-				// This key was not found in the second map.
-				return false
-			}
-			if !equalAny(v1.MapIndex(key), val2, nil) {
-				return false
-			}
-		}
-		return true
-	case reflect.Ptr:
-		// Maps may have nil values in them, so check for nil.
-		if v1.IsNil() && v2.IsNil() {
-			return true
-		}
-		if v1.IsNil() != v2.IsNil() {
-			return false
-		}
-		return equalAny(v1.Elem(), v2.Elem(), prop)
-	case reflect.Slice:
-		if v1.Type().Elem().Kind() == reflect.Uint8 {
-			// short circuit: []byte
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value.
-			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
-				return true
-			}
-			if v1.IsNil() != v2.IsNil() {
-				return false
-			}
-			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
-		}
-
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for i := 0; i < v1.Len(); i++ {
-			if !equalAny(v1.Index(i), v2.Index(i), prop) {
-				return false
-			}
-		}
-		return true
-	case reflect.String:
-		return v1.Interface().(string) == v2.Interface().(string)
-	case reflect.Struct:
-		return equalStruct(v1, v2)
-	case reflect.Uint32, reflect.Uint64:
-		return v1.Uint() == v2.Uint()
-	}
-
-	// unknown type, so not a protocol buffer
-	log.Printf("proto: don't know how to compare %v", v1)
-	return false
-}
-
-// base is the struct type that the extensions are based on.
-// x1 and x2 are InternalExtensions.
-func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
-	em1, _ := x1.extensionsRead()
-	em2, _ := x2.extensionsRead()
-	return equalExtMap(base, em1, em2)
-}
-
-func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
-	if len(em1) != len(em2) {
-		return false
-	}
-
-	for extNum, e1 := range em1 {
-		e2, ok := em2[extNum]
-		if !ok {
-			return false
-		}
-
-		m1 := extensionAsLegacyType(e1.value)
-		m2 := extensionAsLegacyType(e2.value)
-
-		if m1 == nil && m2 == nil {
-			// Both have only encoded form.
-			if bytes.Equal(e1.enc, e2.enc) {
-				continue
-			}
-			// The bytes are different, but the extensions might still be
-			// equal. We need to decode them to compare.
-		}
-
-		if m1 != nil && m2 != nil {
-			// Both are unencoded.
-			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-				return false
-			}
-			continue
-		}
-
-		// At least one is encoded. To do a semantically correct comparison
-		// we need to unmarshal them first.
-		var desc *ExtensionDesc
-		if m := extensionMaps[base]; m != nil {
-			desc = m[extNum]
-		}
-		if desc == nil {
-			// If both have only encoded form and the bytes are the same,
-			// it is handled above. We get here when the bytes are different.
-			// We don't know how to decode it, so just compare them as byte
-			// slices.
-			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
-			return false
-		}
-		var err error
-		if m1 == nil {
-			m1, err = decodeExtension(e1.enc, desc)
-		}
-		if m2 == nil && err == nil {
-			m2, err = decodeExtension(e2.enc, desc)
-		}
-		if err != nil {
-			// The encoded form is invalid.
-			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
-			return false
-		}
-		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-			return false
-		}
-	}
-
-	return true
-}

vendor/github.com/golang/protobuf/proto/extensions.go

@@ -1,607 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Types and routines for supporting protocol buffer extensions.
- */
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"sync"
-)
-
-// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
-var ErrMissingExtension = errors.New("proto: missing extension")
-
-// ExtensionRange represents a range of message extensions for a protocol buffer.
-// Used in code generated by the protocol compiler.
-type ExtensionRange struct {
-	Start, End int32 // both inclusive
-}
-
-// extendableProto is an interface implemented by any protocol buffer generated by the current
-// proto compiler that may be extended.
-type extendableProto interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	extensionsWrite() map[int32]Extension
-	extensionsRead() (map[int32]Extension, sync.Locker)
-}
-
-// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
-// version of the proto compiler that may be extended.
-type extendableProtoV1 interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	ExtensionMap() map[int32]Extension
-}
-
-// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
-type extensionAdapter struct {
-	extendableProtoV1
-}
-
-func (e extensionAdapter) extensionsWrite() map[int32]Extension {
-	return e.ExtensionMap()
-}
-
-func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
-	return e.ExtensionMap(), notLocker{}
-}
-
-// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
-type notLocker struct{}
-
-func (n notLocker) Lock()   {}
-func (n notLocker) Unlock() {}
-
-// extendable returns the extendableProto interface for the given generated proto message.
-// If the proto message has the old extension format, it returns a wrapper that implements
-// the extendableProto interface.
-func extendable(p interface{}) (extendableProto, error) {
-	switch p := p.(type) {
-	case extendableProto:
-		if isNilPtr(p) {
-			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
-		}
-		return p, nil
-	case extendableProtoV1:
-		if isNilPtr(p) {
-			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
-		}
-		return extensionAdapter{p}, nil
-	}
-	// Don't allocate a specific error containing %T:
-	// this is the hot path for Clone and MarshalText.
-	return nil, errNotExtendable
-}
-
-var errNotExtendable = errors.New("proto: not an extendable proto.Message")
-
-func isNilPtr(x interface{}) bool {
-	v := reflect.ValueOf(x)
-	return v.Kind() == reflect.Ptr && v.IsNil()
-}
-
-// XXX_InternalExtensions is an internal representation of proto extensions.
-//
-// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
-// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
-//
-// The methods of XXX_InternalExtensions are not concurrency safe in general,
-// but calls to logically read-only methods such as has and get may be executed concurrently.
-type XXX_InternalExtensions struct {
-	// The struct must be indirect so that if a user inadvertently copies a
-	// generated message and its embedded XXX_InternalExtensions, they
-	// avoid the mayhem of a copied mutex.
-	//
-	// The mutex serializes all logically read-only operations to p.extensionMap.
-	// It is up to the client to ensure that write operations to p.extensionMap are
-	// mutually exclusive with other accesses.
-	p *struct {
-		mu           sync.Mutex
-		extensionMap map[int32]Extension
-	}
-}
-
-// extensionsWrite returns the extension map, creating it on first use.
-func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
-	if e.p == nil {
-		e.p = new(struct {
-			mu           sync.Mutex
-			extensionMap map[int32]Extension
-		})
-		e.p.extensionMap = make(map[int32]Extension)
-	}
-	return e.p.extensionMap
-}
-
-// extensionsRead returns the extensions map for read-only use.  It may be nil.
-// The caller must hold the returned mutex's lock when accessing Elements within the map.
-func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
-	if e.p == nil {
-		return nil, nil
-	}
-	return e.p.extensionMap, &e.p.mu
-}
-
-// ExtensionDesc represents an extension specification.
-// Used in generated code from the protocol compiler.
-type ExtensionDesc struct {
-	ExtendedType  Message     // nil pointer to the type that is being extended
-	ExtensionType interface{} // nil pointer to the extension type
-	Field         int32       // field number
-	Name          string      // fully-qualified name of extension, for text formatting
-	Tag           string      // protobuf tag style
-	Filename      string      // name of the file in which the extension is defined
-}
-
-func (ed *ExtensionDesc) repeated() bool {
-	t := reflect.TypeOf(ed.ExtensionType)
-	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
-}
-
-// Extension represents an extension in a message.
-type Extension struct {
-	// When an extension is stored in a message using SetExtension
-	// only desc and value are set. When the message is marshaled
-	// enc will be set to the encoded form of the message.
-	//
-	// When a message is unmarshaled and contains extensions, each
-	// extension will have only enc set. When such an extension is
-	// accessed using GetExtension (or GetExtensions) desc and value
-	// will be set.
-	desc *ExtensionDesc
-
-	// value is a concrete value for the extension field. Let the type of
-	// desc.ExtensionType be the "API type" and the type of Extension.value
-	// be the "storage type". The API type and storage type are the same except:
-	//	* For scalars (except []byte), the API type uses *T,
-	//	while the storage type uses T.
-	//	* For repeated fields, the API type uses []T, while the storage type
-	//	uses *[]T.
-	//
-	// The reason for the divergence is so that the storage type more naturally
-	// matches what is expected of when retrieving the values through the
-	// protobuf reflection APIs.
-	//
-	// The value may only be populated if desc is also populated.
-	value interface{}
-
-	// enc is the raw bytes for the extension field.
-	enc []byte
-}
-
-// SetRawExtension is for testing only.
-func SetRawExtension(base Message, id int32, b []byte) {
-	epb, err := extendable(base)
-	if err != nil {
-		return
-	}
-	extmap := epb.extensionsWrite()
-	extmap[id] = Extension{enc: b}
-}
-
-// isExtensionField returns true iff the given field number is in an extension range.
-func isExtensionField(pb extendableProto, field int32) bool {
-	for _, er := range pb.ExtensionRangeArray() {
-		if er.Start <= field && field <= er.End {
-			return true
-		}
-	}
-	return false
-}
-
-// checkExtensionTypes checks that the given extension is valid for pb.
-func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
-	var pbi interface{} = pb
-	// Check the extended type.
-	if ea, ok := pbi.(extensionAdapter); ok {
-		pbi = ea.extendableProtoV1
-	}
-	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
-		return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
-	}
-	// Check the range.
-	if !isExtensionField(pb, extension.Field) {
-		return errors.New("proto: bad extension number; not in declared ranges")
-	}
-	return nil
-}
-
-// extPropKey is sufficient to uniquely identify an extension.
-type extPropKey struct {
-	base  reflect.Type
-	field int32
-}
-
-var extProp = struct {
-	sync.RWMutex
-	m map[extPropKey]*Properties
-}{
-	m: make(map[extPropKey]*Properties),
-}
-
-func extensionProperties(ed *ExtensionDesc) *Properties {
-	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
-
-	extProp.RLock()
-	if prop, ok := extProp.m[key]; ok {
-		extProp.RUnlock()
-		return prop
-	}
-	extProp.RUnlock()
-
-	extProp.Lock()
-	defer extProp.Unlock()
-	// Check again.
-	if prop, ok := extProp.m[key]; ok {
-		return prop
-	}
-
-	prop := new(Properties)
-	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
-	extProp.m[key] = prop
-	return prop
-}
-
-// HasExtension returns whether the given extension is present in pb.
-func HasExtension(pb Message, extension *ExtensionDesc) bool {
-	// TODO: Check types, field numbers, etc.?
-	epb, err := extendable(pb)
-	if err != nil {
-		return false
-	}
-	extmap, mu := epb.extensionsRead()
-	if extmap == nil {
-		return false
-	}
-	mu.Lock()
-	_, ok := extmap[extension.Field]
-	mu.Unlock()
-	return ok
-}
-
-// ClearExtension removes the given extension from pb.
-func ClearExtension(pb Message, extension *ExtensionDesc) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return
-	}
-	// TODO: Check types, field numbers, etc.?
-	extmap := epb.extensionsWrite()
-	delete(extmap, extension.Field)
-}
-
-// GetExtension retrieves a proto2 extended field from pb.
-//
-// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
-// then GetExtension parses the encoded field and returns a Go value of the specified type.
-// If the field is not present, then the default value is returned (if one is specified),
-// otherwise ErrMissingExtension is reported.
-//
-// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
-// then GetExtension returns the raw encoded bytes of the field extension.
-func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
-	}
-
-	if extension.ExtendedType != nil {
-		// can only check type if this is a complete descriptor
-		if err := checkExtensionTypes(epb, extension); err != nil {
-			return nil, err
-		}
-	}
-
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return defaultExtensionValue(extension)
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	e, ok := emap[extension.Field]
-	if !ok {
-		// defaultExtensionValue returns the default value or
-		// ErrMissingExtension if there is no default.
-		return defaultExtensionValue(extension)
-	}
-
-	if e.value != nil {
-		// Already decoded. Check the descriptor, though.
-		if e.desc != extension {
-			// This shouldn't happen. If it does, it means that
-			// GetExtension was called twice with two different
-			// descriptors with the same field number.
-			return nil, errors.New("proto: descriptor conflict")
-		}
-		return extensionAsLegacyType(e.value), nil
-	}
-
-	if extension.ExtensionType == nil {
-		// incomplete descriptor
-		return e.enc, nil
-	}
-
-	v, err := decodeExtension(e.enc, extension)
-	if err != nil {
-		return nil, err
-	}
-
-	// Remember the decoded version and drop the encoded version.
-	// That way it is safe to mutate what we return.
-	e.value = extensionAsStorageType(v)
-	e.desc = extension
-	e.enc = nil
-	emap[extension.Field] = e
-	return extensionAsLegacyType(e.value), nil
-}
-
-// defaultExtensionValue returns the default value for extension.
-// If no default for an extension is defined ErrMissingExtension is returned.
-func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
-	if extension.ExtensionType == nil {
-		// incomplete descriptor, so no default
-		return nil, ErrMissingExtension
-	}
-
-	t := reflect.TypeOf(extension.ExtensionType)
-	props := extensionProperties(extension)
-
-	sf, _, err := fieldDefault(t, props)
-	if err != nil {
-		return nil, err
-	}
-
-	if sf == nil || sf.value == nil {
-		// There is no default value.
-		return nil, ErrMissingExtension
-	}
-
-	if t.Kind() != reflect.Ptr {
-		// We do not need to return a Ptr, we can directly return sf.value.
-		return sf.value, nil
-	}
-
-	// We need to return an interface{} that is a pointer to sf.value.
-	value := reflect.New(t).Elem()
-	value.Set(reflect.New(value.Type().Elem()))
-	if sf.kind == reflect.Int32 {
-		// We may have an int32 or an enum, but the underlying data is int32.
-		// Since we can't set an int32 into a non int32 reflect.value directly
-		// set it as a int32.
-		value.Elem().SetInt(int64(sf.value.(int32)))
-	} else {
-		value.Elem().Set(reflect.ValueOf(sf.value))
-	}
-	return value.Interface(), nil
-}
-
-// decodeExtension decodes an extension encoded in b.
-func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
-	t := reflect.TypeOf(extension.ExtensionType)
-	unmarshal := typeUnmarshaler(t, extension.Tag)
-
-	// t is a pointer to a struct, pointer to basic type or a slice.
-	// Allocate space to store the pointer/slice.
-	value := reflect.New(t).Elem()
-
-	var err error
-	for {
-		x, n := decodeVarint(b)
-		if n == 0 {
-			return nil, io.ErrUnexpectedEOF
-		}
-		b = b[n:]
-		wire := int(x) & 7
-
-		b, err = unmarshal(b, valToPointer(value.Addr()), wire)
-		if err != nil {
-			return nil, err
-		}
-
-		if len(b) == 0 {
-			break
-		}
-	}
-	return value.Interface(), nil
-}
-
-// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
-// The returned slice has the same length as es; missing extensions will appear as nil elements.
-func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
-	}
-	extensions = make([]interface{}, len(es))
-	for i, e := range es {
-		extensions[i], err = GetExtension(epb, e)
-		if err == ErrMissingExtension {
-			err = nil
-		}
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
-// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
-// just the Field field, which defines the extension's field number.
-func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return nil, err
-	}
-	registeredExtensions := RegisteredExtensions(pb)
-
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return nil, nil
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	extensions := make([]*ExtensionDesc, 0, len(emap))
-	for extid, e := range emap {
-		desc := e.desc
-		if desc == nil {
-			desc = registeredExtensions[extid]
-			if desc == nil {
-				desc = &ExtensionDesc{Field: extid}
-			}
-		}
-
-		extensions = append(extensions, desc)
-	}
-	return extensions, nil
-}
-
-// SetExtension sets the specified extension of pb to the specified value.
-func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
-	epb, err := extendable(pb)
-	if err != nil {
-		return err
-	}
-	if err := checkExtensionTypes(epb, extension); err != nil {
-		return err
-	}
-	typ := reflect.TypeOf(extension.ExtensionType)
-	if typ != reflect.TypeOf(value) {
-		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
-	}
-	// nil extension values need to be caught early, because the
-	// encoder can't distinguish an ErrNil due to a nil extension
-	// from an ErrNil due to a missing field. Extensions are
-	// always optional, so the encoder would just swallow the error
-	// and drop all the extensions from the encoded message.
-	if reflect.ValueOf(value).IsNil() {
-		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
-	}
-
-	extmap := epb.extensionsWrite()
-	extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
-	return nil
-}
-
-// ClearAllExtensions clears all extensions from pb.
-func ClearAllExtensions(pb Message) {
-	epb, err := extendable(pb)
-	if err != nil {
-		return
-	}
-	m := epb.extensionsWrite()
-	for k := range m {
-		delete(m, k)
-	}
-}
-
-// A global registry of extensions.
-// The generated code will register the generated descriptors by calling RegisterExtension.
-
-var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
-
-// RegisterExtension is called from the generated code.
-func RegisterExtension(desc *ExtensionDesc) {
-	st := reflect.TypeOf(desc.ExtendedType).Elem()
-	m := extensionMaps[st]
-	if m == nil {
-		m = make(map[int32]*ExtensionDesc)
-		extensionMaps[st] = m
-	}
-	if _, ok := m[desc.Field]; ok {
-		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
-	}
-	m[desc.Field] = desc
-}
-
-// RegisteredExtensions returns a map of the registered extensions of a
-// protocol buffer struct, indexed by the extension number.
-// The argument pb should be a nil pointer to the struct type.
-func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
-	return extensionMaps[reflect.TypeOf(pb).Elem()]
-}
-
-// extensionAsLegacyType converts an value in the storage type as the API type.
-// See Extension.value.
-func extensionAsLegacyType(v interface{}) interface{} {
-	switch rv := reflect.ValueOf(v); rv.Kind() {
-	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
-		// Represent primitive types as a pointer to the value.
-		rv2 := reflect.New(rv.Type())
-		rv2.Elem().Set(rv)
-		v = rv2.Interface()
-	case reflect.Ptr:
-		// Represent slice types as the value itself.
-		switch rv.Type().Elem().Kind() {
-		case reflect.Slice:
-			if rv.IsNil() {
-				v = reflect.Zero(rv.Type().Elem()).Interface()
-			} else {
-				v = rv.Elem().Interface()
-			}
-		}
-	}
-	return v
-}
-
-// extensionAsStorageType converts an value in the API type as the storage type.
-// See Extension.value.
-func extensionAsStorageType(v interface{}) interface{} {
-	switch rv := reflect.ValueOf(v); rv.Kind() {
-	case reflect.Ptr:
-		// Represent slice types as the value itself.
-		switch rv.Type().Elem().Kind() {
-		case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
-			if rv.IsNil() {
-				v = reflect.Zero(rv.Type().Elem()).Interface()
-			} else {
-				v = rv.Elem().Interface()
-			}
-		}
-	case reflect.Slice:
-		// Represent slice types as a pointer to the value.
-		if rv.Type().Elem().Kind() != reflect.Uint8 {
-			rv2 := reflect.New(rv.Type())
-			rv2.Elem().Set(rv)
-			v = rv2.Interface()
-		}
-	}
-	return v
-}

vendor/github.com/golang/protobuf/proto/lib.go

@@ -1,965 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-Package proto converts data structures to and from the wire format of
-protocol buffers.  It works in concert with the Go source code generated
-for .proto files by the protocol compiler.
-
-A summary of the properties of the protocol buffer interface
-for a protocol buffer variable v:
-
-  - Names are turned from camel_case to CamelCase for export.
-  - There are no methods on v to set fields; just treat
-	them as structure fields.
-  - There are getters that return a field's value if set,
-	and return the field's default value if unset.
-	The getters work even if the receiver is a nil message.
-  - The zero value for a struct is its correct initialization state.
-	All desired fields must be set before marshaling.
-  - A Reset() method will restore a protobuf struct to its zero state.
-  - Non-repeated fields are pointers to the values; nil means unset.
-	That is, optional or required field int32 f becomes F *int32.
-  - Repeated fields are slices.
-  - Helper functions are available to aid the setting of fields.
-	msg.Foo = proto.String("hello") // set field
-  - Constants are defined to hold the default values of all fields that
-	have them.  They have the form Default_StructName_FieldName.
-	Because the getter methods handle defaulted values,
-	direct use of these constants should be rare.
-  - Enums are given type names and maps from names to values.
-	Enum values are prefixed by the enclosing message's name, or by the
-	enum's type name if it is a top-level enum. Enum types have a String
-	method, and a Enum method to assist in message construction.
-  - Nested messages, groups and enums have type names prefixed with the name of
-	the surrounding message type.
-  - Extensions are given descriptor names that start with E_,
-	followed by an underscore-delimited list of the nested messages
-	that contain it (if any) followed by the CamelCased name of the
-	extension field itself.  HasExtension, ClearExtension, GetExtension
-	and SetExtension are functions for manipulating extensions.
-  - Oneof field sets are given a single field in their message,
-	with distinguished wrapper types for each possible field value.
-  - Marshal and Unmarshal are functions to encode and decode the wire format.
-
-When the .proto file specifies `syntax="proto3"`, there are some differences:
-
-  - Non-repeated fields of non-message type are values instead of pointers.
-  - Enum types do not get an Enum method.
-
-The simplest way to describe this is to see an example.
-Given file test.proto, containing
-
-	package example;
-
-	enum FOO { X = 17; }
-
-	message Test {
-	  required string label = 1;
-	  optional int32 type = 2 [default=77];
-	  repeated int64 reps = 3;
-	  optional group OptionalGroup = 4 {
-	    required string RequiredField = 5;
-	  }
-	  oneof union {
-	    int32 number = 6;
-	    string name = 7;
-	  }
-	}
-
-The resulting file, test.pb.go, is:
-
-	package example
-
-	import proto "github.com/golang/protobuf/proto"
-	import math "math"
-
-	type FOO int32
-	const (
-		FOO_X FOO = 17
-	)
-	var FOO_name = map[int32]string{
-		17: "X",
-	}
-	var FOO_value = map[string]int32{
-		"X": 17,
-	}
-
-	func (x FOO) Enum() *FOO {
-		p := new(FOO)
-		*p = x
-		return p
-	}
-	func (x FOO) String() string {
-		return proto.EnumName(FOO_name, int32(x))
-	}
-	func (x *FOO) UnmarshalJSON(data []byte) error {
-		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
-		if err != nil {
-			return err
-		}
-		*x = FOO(value)
-		return nil
-	}
-
-	type Test struct {
-		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
-		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
-		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
-		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
-		// Types that are valid to be assigned to Union:
-		//	*Test_Number
-		//	*Test_Name
-		Union            isTest_Union `protobuf_oneof:"union"`
-		XXX_unrecognized []byte       `json:"-"`
-	}
-	func (m *Test) Reset()         { *m = Test{} }
-	func (m *Test) String() string { return proto.CompactTextString(m) }
-	func (*Test) ProtoMessage() {}
-
-	type isTest_Union interface {
-		isTest_Union()
-	}
-
-	type Test_Number struct {
-		Number int32 `protobuf:"varint,6,opt,name=number"`
-	}
-	type Test_Name struct {
-		Name string `protobuf:"bytes,7,opt,name=name"`
-	}
-
-	func (*Test_Number) isTest_Union() {}
-	func (*Test_Name) isTest_Union()   {}
-
-	func (m *Test) GetUnion() isTest_Union {
-		if m != nil {
-			return m.Union
-		}
-		return nil
-	}
-	const Default_Test_Type int32 = 77
-
-	func (m *Test) GetLabel() string {
-		if m != nil && m.Label != nil {
-			return *m.Label
-		}
-		return ""
-	}
-
-	func (m *Test) GetType() int32 {
-		if m != nil && m.Type != nil {
-			return *m.Type
-		}
-		return Default_Test_Type
-	}
-
-	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
-		if m != nil {
-			return m.Optionalgroup
-		}
-		return nil
-	}
-
-	type Test_OptionalGroup struct {
-		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
-	}
-	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
-	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
-
-	func (m *Test_OptionalGroup) GetRequiredField() string {
-		if m != nil && m.RequiredField != nil {
-			return *m.RequiredField
-		}
-		return ""
-	}
-
-	func (m *Test) GetNumber() int32 {
-		if x, ok := m.GetUnion().(*Test_Number); ok {
-			return x.Number
-		}
-		return 0
-	}
-
-	func (m *Test) GetName() string {
-		if x, ok := m.GetUnion().(*Test_Name); ok {
-			return x.Name
-		}
-		return ""
-	}
-
-	func init() {
-		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
-	}
-
-To create and play with a Test object:
-
-	package main
-
-	import (
-		"log"
-
-		"github.com/golang/protobuf/proto"
-		pb "./example.pb"
-	)
-
-	func main() {
-		test := &pb.Test{
-			Label: proto.String("hello"),
-			Type:  proto.Int32(17),
-			Reps:  []int64{1, 2, 3},
-			Optionalgroup: &pb.Test_OptionalGroup{
-				RequiredField: proto.String("good bye"),
-			},
-			Union: &pb.Test_Name{"fred"},
-		}
-		data, err := proto.Marshal(test)
-		if err != nil {
-			log.Fatal("marshaling error: ", err)
-		}
-		newTest := &pb.Test{}
-		err = proto.Unmarshal(data, newTest)
-		if err != nil {
-			log.Fatal("unmarshaling error: ", err)
-		}
-		// Now test and newTest contain the same data.
-		if test.GetLabel() != newTest.GetLabel() {
-			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
-		}
-		// Use a type switch to determine which oneof was set.
-		switch u := test.Union.(type) {
-		case *pb.Test_Number: // u.Number contains the number.
-		case *pb.Test_Name: // u.Name contains the string.
-		}
-		// etc.
-	}
-*/
-package proto
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"reflect"
-	"sort"
-	"strconv"
-	"sync"
-)
-
-// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
-// Marshal reports this when a required field is not initialized.
-// Unmarshal reports this when a required field is missing from the wire data.
-type RequiredNotSetError struct{ field string }
-
-func (e *RequiredNotSetError) Error() string {
-	if e.field == "" {
-		return fmt.Sprintf("proto: required field not set")
-	}
-	return fmt.Sprintf("proto: required field %q not set", e.field)
-}
-func (e *RequiredNotSetError) RequiredNotSet() bool {
-	return true
-}
-
-type invalidUTF8Error struct{ field string }
-
-func (e *invalidUTF8Error) Error() string {
-	if e.field == "" {
-		return "proto: invalid UTF-8 detected"
-	}
-	return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
-}
-func (e *invalidUTF8Error) InvalidUTF8() bool {
-	return true
-}
-
-// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
-// This error should not be exposed to the external API as such errors should
-// be recreated with the field information.
-var errInvalidUTF8 = &invalidUTF8Error{}
-
-// isNonFatal reports whether the error is either a RequiredNotSet error
-// or a InvalidUTF8 error.
-func isNonFatal(err error) bool {
-	if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
-		return true
-	}
-	if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
-		return true
-	}
-	return false
-}
-
-type nonFatal struct{ E error }
-
-// Merge merges err into nf and reports whether it was successful.
-// Otherwise it returns false for any fatal non-nil errors.
-func (nf *nonFatal) Merge(err error) (ok bool) {
-	if err == nil {
-		return true // not an error
-	}
-	if !isNonFatal(err) {
-		return false // fatal error
-	}
-	if nf.E == nil {
-		nf.E = err // store first instance of non-fatal error
-	}
-	return true
-}
-
-// Message is implemented by generated protocol buffer messages.
-type Message interface {
-	Reset()
-	String() string
-	ProtoMessage()
-}
-
-// A Buffer is a buffer manager for marshaling and unmarshaling
-// protocol buffers.  It may be reused between invocations to
-// reduce memory usage.  It is not necessary to use a Buffer;
-// the global functions Marshal and Unmarshal create a
-// temporary Buffer and are fine for most applications.
-type Buffer struct {
-	buf   []byte // encode/decode byte stream
-	index int    // read point
-
-	deterministic bool
-}
-
-// NewBuffer allocates a new Buffer and initializes its internal data to
-// the contents of the argument slice.
-func NewBuffer(e []byte) *Buffer {
-	return &Buffer{buf: e}
-}
-
-// Reset resets the Buffer, ready for marshaling a new protocol buffer.
-func (p *Buffer) Reset() {
-	p.buf = p.buf[0:0] // for reading/writing
-	p.index = 0        // for reading
-}
-
-// SetBuf replaces the internal buffer with the slice,
-// ready for unmarshaling the contents of the slice.
-func (p *Buffer) SetBuf(s []byte) {
-	p.buf = s
-	p.index = 0
-}
-
-// Bytes returns the contents of the Buffer.
-func (p *Buffer) Bytes() []byte { return p.buf }
-
-// SetDeterministic sets whether to use deterministic serialization.
-//
-// Deterministic serialization guarantees that for a given binary, equal
-// messages will always be serialized to the same bytes. This implies:
-//
-//   - Repeated serialization of a message will return the same bytes.
-//   - Different processes of the same binary (which may be executing on
-//     different machines) will serialize equal messages to the same bytes.
-//
-// Note that the deterministic serialization is NOT canonical across
-// languages. It is not guaranteed to remain stable over time. It is unstable
-// across different builds with schema changes due to unknown fields.
-// Users who need canonical serialization (e.g., persistent storage in a
-// canonical form, fingerprinting, etc.) should define their own
-// canonicalization specification and implement their own serializer rather
-// than relying on this API.
-//
-// If deterministic serialization is requested, map entries will be sorted
-// by keys in lexographical order. This is an implementation detail and
-// subject to change.
-func (p *Buffer) SetDeterministic(deterministic bool) {
-	p.deterministic = deterministic
-}
-
-/*
- * Helper routines for simplifying the creation of optional fields of basic type.
- */
-
-// Bool is a helper routine that allocates a new bool value
-// to store v and returns a pointer to it.
-func Bool(v bool) *bool {
-	return &v
-}
-
-// Int32 is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it.
-func Int32(v int32) *int32 {
-	return &v
-}
-
-// Int is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it, but unlike Int32
-// its argument value is an int.
-func Int(v int) *int32 {
-	p := new(int32)
-	*p = int32(v)
-	return p
-}
-
-// Int64 is a helper routine that allocates a new int64 value
-// to store v and returns a pointer to it.
-func Int64(v int64) *int64 {
-	return &v
-}
-
-// Float32 is a helper routine that allocates a new float32 value
-// to store v and returns a pointer to it.
-func Float32(v float32) *float32 {
-	return &v
-}
-
-// Float64 is a helper routine that allocates a new float64 value
-// to store v and returns a pointer to it.
-func Float64(v float64) *float64 {
-	return &v
-}
-
-// Uint32 is a helper routine that allocates a new uint32 value
-// to store v and returns a pointer to it.
-func Uint32(v uint32) *uint32 {
-	return &v
-}
-
-// Uint64 is a helper routine that allocates a new uint64 value
-// to store v and returns a pointer to it.
-func Uint64(v uint64) *uint64 {
-	return &v
-}
-
-// String is a helper routine that allocates a new string value
-// to store v and returns a pointer to it.
-func String(v string) *string {
-	return &v
-}
-
-// EnumName is a helper function to simplify printing protocol buffer enums
-// by name.  Given an enum map and a value, it returns a useful string.
-func EnumName(m map[int32]string, v int32) string {
-	s, ok := m[v]
-	if ok {
-		return s
-	}
-	return strconv.Itoa(int(v))
-}
-
-// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
-// from their JSON-encoded representation. Given a map from the enum's symbolic
-// names to its int values, and a byte buffer containing the JSON-encoded
-// value, it returns an int32 that can be cast to the enum type by the caller.
-//
-// The function can deal with both JSON representations, numeric and symbolic.
-func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
-	if data[0] == '"' {
-		// New style: enums are strings.
-		var repr string
-		if err := json.Unmarshal(data, &repr); err != nil {
-			return -1, err
-		}
-		val, ok := m[repr]
-		if !ok {
-			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
-		}
-		return val, nil
-	}
-	// Old style: enums are ints.
-	var val int32
-	if err := json.Unmarshal(data, &val); err != nil {
-		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
-	}
-	return val, nil
-}
-
-// DebugPrint dumps the encoded data in b in a debugging format with a header
-// including the string s. Used in testing but made available for general debugging.
-func (p *Buffer) DebugPrint(s string, b []byte) {
-	var u uint64
-
-	obuf := p.buf
-	index := p.index
-	p.buf = b
-	p.index = 0
-	depth := 0
-
-	fmt.Printf("\n--- %s ---\n", s)
-
-out:
-	for {
-		for i := 0; i < depth; i++ {
-			fmt.Print("  ")
-		}
-
-		index := p.index
-		if index == len(p.buf) {
-			break
-		}
-
-		op, err := p.DecodeVarint()
-		if err != nil {
-			fmt.Printf("%3d: fetching op err %v\n", index, err)
-			break out
-		}
-		tag := op >> 3
-		wire := op & 7
-
-		switch wire {
-		default:
-			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
-				index, tag, wire)
-			break out
-
-		case WireBytes:
-			var r []byte
-
-			r, err = p.DecodeRawBytes(false)
-			if err != nil {
-				break out
-			}
-			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
-			if len(r) <= 6 {
-				for i := 0; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			} else {
-				for i := 0; i < 3; i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-				fmt.Printf(" ..")
-				for i := len(r) - 3; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			}
-			fmt.Printf("\n")
-
-		case WireFixed32:
-			u, err = p.DecodeFixed32()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
-
-		case WireFixed64:
-			u, err = p.DecodeFixed64()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
-
-		case WireVarint:
-			u, err = p.DecodeVarint()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
-
-		case WireStartGroup:
-			fmt.Printf("%3d: t=%3d start\n", index, tag)
-			depth++
-
-		case WireEndGroup:
-			depth--
-			fmt.Printf("%3d: t=%3d end\n", index, tag)
-		}
-	}
-
-	if depth != 0 {
-		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
-	}
-	fmt.Printf("\n")
-
-	p.buf = obuf
-	p.index = index
-}
-
-// SetDefaults sets unset protocol buffer fields to their default values.
-// It only modifies fields that are both unset and have defined defaults.
-// It recursively sets default values in any non-nil sub-messages.
-func SetDefaults(pb Message) {
-	setDefaults(reflect.ValueOf(pb), true, false)
-}
-
-// v is a pointer to a struct.
-func setDefaults(v reflect.Value, recur, zeros bool) {
-	v = v.Elem()
-
-	defaultMu.RLock()
-	dm, ok := defaults[v.Type()]
-	defaultMu.RUnlock()
-	if !ok {
-		dm = buildDefaultMessage(v.Type())
-		defaultMu.Lock()
-		defaults[v.Type()] = dm
-		defaultMu.Unlock()
-	}
-
-	for _, sf := range dm.scalars {
-		f := v.Field(sf.index)
-		if !f.IsNil() {
-			// field already set
-			continue
-		}
-		dv := sf.value
-		if dv == nil && !zeros {
-			// no explicit default, and don't want to set zeros
-			continue
-		}
-		fptr := f.Addr().Interface() // **T
-		// TODO: Consider batching the allocations we do here.
-		switch sf.kind {
-		case reflect.Bool:
-			b := new(bool)
-			if dv != nil {
-				*b = dv.(bool)
-			}
-			*(fptr.(**bool)) = b
-		case reflect.Float32:
-			f := new(float32)
-			if dv != nil {
-				*f = dv.(float32)
-			}
-			*(fptr.(**float32)) = f
-		case reflect.Float64:
-			f := new(float64)
-			if dv != nil {
-				*f = dv.(float64)
-			}
-			*(fptr.(**float64)) = f
-		case reflect.Int32:
-			// might be an enum
-			if ft := f.Type(); ft != int32PtrType {
-				// enum
-				f.Set(reflect.New(ft.Elem()))
-				if dv != nil {
-					f.Elem().SetInt(int64(dv.(int32)))
-				}
-			} else {
-				// int32 field
-				i := new(int32)
-				if dv != nil {
-					*i = dv.(int32)
-				}
-				*(fptr.(**int32)) = i
-			}
-		case reflect.Int64:
-			i := new(int64)
-			if dv != nil {
-				*i = dv.(int64)
-			}
-			*(fptr.(**int64)) = i
-		case reflect.String:
-			s := new(string)
-			if dv != nil {
-				*s = dv.(string)
-			}
-			*(fptr.(**string)) = s
-		case reflect.Uint8:
-			// exceptional case: []byte
-			var b []byte
-			if dv != nil {
-				db := dv.([]byte)
-				b = make([]byte, len(db))
-				copy(b, db)
-			} else {
-				b = []byte{}
-			}
-			*(fptr.(*[]byte)) = b
-		case reflect.Uint32:
-			u := new(uint32)
-			if dv != nil {
-				*u = dv.(uint32)
-			}
-			*(fptr.(**uint32)) = u
-		case reflect.Uint64:
-			u := new(uint64)
-			if dv != nil {
-				*u = dv.(uint64)
-			}
-			*(fptr.(**uint64)) = u
-		default:
-			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
-		}
-	}
-
-	for _, ni := range dm.nested {
-		f := v.Field(ni)
-		// f is *T or []*T or map[T]*T
-		switch f.Kind() {
-		case reflect.Ptr:
-			if f.IsNil() {
-				continue
-			}
-			setDefaults(f, recur, zeros)
-
-		case reflect.Slice:
-			for i := 0; i < f.Len(); i++ {
-				e := f.Index(i)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-
-		case reflect.Map:
-			for _, k := range f.MapKeys() {
-				e := f.MapIndex(k)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-		}
-	}
-}
-
-var (
-	// defaults maps a protocol buffer struct type to a slice of the fields,
-	// with its scalar fields set to their proto-declared non-zero default values.
-	defaultMu sync.RWMutex
-	defaults  = make(map[reflect.Type]defaultMessage)
-
-	int32PtrType = reflect.TypeOf((*int32)(nil))
-)
-
-// defaultMessage represents information about the default values of a message.
-type defaultMessage struct {
-	scalars []scalarField
-	nested  []int // struct field index of nested messages
-}
-
-type scalarField struct {
-	index int          // struct field index
-	kind  reflect.Kind // element type (the T in *T or []T)
-	value interface{}  // the proto-declared default value, or nil
-}
-
-// t is a struct type.
-func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
-	sprop := GetProperties(t)
-	for _, prop := range sprop.Prop {
-		fi, ok := sprop.decoderTags.get(prop.Tag)
-		if !ok {
-			// XXX_unrecognized
-			continue
-		}
-		ft := t.Field(fi).Type
-
-		sf, nested, err := fieldDefault(ft, prop)
-		switch {
-		case err != nil:
-			log.Print(err)
-		case nested:
-			dm.nested = append(dm.nested, fi)
-		case sf != nil:
-			sf.index = fi
-			dm.scalars = append(dm.scalars, *sf)
-		}
-	}
-
-	return dm
-}
-
-// fieldDefault returns the scalarField for field type ft.
-// sf will be nil if the field can not have a default.
-// nestedMessage will be true if this is a nested message.
-// Note that sf.index is not set on return.
-func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
-	var canHaveDefault bool
-	switch ft.Kind() {
-	case reflect.Ptr:
-		if ft.Elem().Kind() == reflect.Struct {
-			nestedMessage = true
-		} else {
-			canHaveDefault = true // proto2 scalar field
-		}
-
-	case reflect.Slice:
-		switch ft.Elem().Kind() {
-		case reflect.Ptr:
-			nestedMessage = true // repeated message
-		case reflect.Uint8:
-			canHaveDefault = true // bytes field
-		}
-
-	case reflect.Map:
-		if ft.Elem().Kind() == reflect.Ptr {
-			nestedMessage = true // map with message values
-		}
-	}
-
-	if !canHaveDefault {
-		if nestedMessage {
-			return nil, true, nil
-		}
-		return nil, false, nil
-	}
-
-	// We now know that ft is a pointer or slice.
-	sf = &scalarField{kind: ft.Elem().Kind()}
-
-	// scalar fields without defaults
-	if !prop.HasDefault {
-		return sf, false, nil
-	}
-
-	// a scalar field: either *T or []byte
-	switch ft.Elem().Kind() {
-	case reflect.Bool:
-		x, err := strconv.ParseBool(prop.Default)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Float32:
-		x, err := strconv.ParseFloat(prop.Default, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
-		}
-		sf.value = float32(x)
-	case reflect.Float64:
-		x, err := strconv.ParseFloat(prop.Default, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Int32:
-		x, err := strconv.ParseInt(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
-		}
-		sf.value = int32(x)
-	case reflect.Int64:
-		x, err := strconv.ParseInt(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.String:
-		sf.value = prop.Default
-	case reflect.Uint8:
-		// []byte (not *uint8)
-		sf.value = []byte(prop.Default)
-	case reflect.Uint32:
-		x, err := strconv.ParseUint(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
-		}
-		sf.value = uint32(x)
-	case reflect.Uint64:
-		x, err := strconv.ParseUint(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	default:
-		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
-	}
-
-	return sf, false, nil
-}
-
-// mapKeys returns a sort.Interface to be used for sorting the map keys.
-// Map fields may have key types of non-float scalars, strings and enums.
-func mapKeys(vs []reflect.Value) sort.Interface {
-	s := mapKeySorter{vs: vs}
-
-	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
-	if len(vs) == 0 {
-		return s
-	}
-	switch vs[0].Kind() {
-	case reflect.Int32, reflect.Int64:
-		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
-	case reflect.Uint32, reflect.Uint64:
-		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
-	case reflect.Bool:
-		s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
-	case reflect.String:
-		s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
-	default:
-		panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
-	}
-
-	return s
-}
-
-type mapKeySorter struct {
-	vs   []reflect.Value
-	less func(a, b reflect.Value) bool
-}
-
-func (s mapKeySorter) Len() int      { return len(s.vs) }
-func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
-func (s mapKeySorter) Less(i, j int) bool {
-	return s.less(s.vs[i], s.vs[j])
-}
-
-// isProto3Zero reports whether v is a zero proto3 value.
-func isProto3Zero(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint32, reflect.Uint64:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.String:
-		return v.String() == ""
-	}
-	return false
-}
-
-const (
-	// ProtoPackageIsVersion3 is referenced from generated protocol buffer files
-	// to assert that that code is compatible with this version of the proto package.
-	ProtoPackageIsVersion3 = true
-
-	// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
-	// to assert that that code is compatible with this version of the proto package.
-	ProtoPackageIsVersion2 = true
-
-	// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
-	// to assert that that code is compatible with this version of the proto package.
-	ProtoPackageIsVersion1 = true
-)
-
-// InternalMessageInfo is a type used internally by generated .pb.go files.
-// This type is not intended to be used by non-generated code.
-// This type is not subject to any compatibility guarantee.
-type InternalMessageInfo struct {
-	marshal   *marshalInfo
-	unmarshal *unmarshalInfo
-	merge     *mergeInfo
-	discard   *discardInfo
-}

vendor/github.com/golang/protobuf/proto/message_set.go

@@ -1,181 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Support for message sets.
- */
-
-import (
-	"errors"
-)
-
-// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
-// A message type ID is required for storing a protocol buffer in a message set.
-var errNoMessageTypeID = errors.New("proto does not have a message type ID")
-
-// The first two types (_MessageSet_Item and messageSet)
-// model what the protocol compiler produces for the following protocol message:
-//   message MessageSet {
-//     repeated group Item = 1 {
-//       required int32 type_id = 2;
-//       required string message = 3;
-//     };
-//   }
-// That is the MessageSet wire format. We can't use a proto to generate these
-// because that would introduce a circular dependency between it and this package.
-
-type _MessageSet_Item struct {
-	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
-	Message []byte `protobuf:"bytes,3,req,name=message"`
-}
-
-type messageSet struct {
-	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
-	XXX_unrecognized []byte
-	// TODO: caching?
-}
-
-// Make sure messageSet is a Message.
-var _ Message = (*messageSet)(nil)
-
-// messageTypeIder is an interface satisfied by a protocol buffer type
-// that may be stored in a MessageSet.
-type messageTypeIder interface {
-	MessageTypeId() int32
-}
-
-func (ms *messageSet) find(pb Message) *_MessageSet_Item {
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return nil
-	}
-	id := mti.MessageTypeId()
-	for _, item := range ms.Item {
-		if *item.TypeId == id {
-			return item
-		}
-	}
-	return nil
-}
-
-func (ms *messageSet) Has(pb Message) bool {
-	return ms.find(pb) != nil
-}
-
-func (ms *messageSet) Unmarshal(pb Message) error {
-	if item := ms.find(pb); item != nil {
-		return Unmarshal(item.Message, pb)
-	}
-	if _, ok := pb.(messageTypeIder); !ok {
-		return errNoMessageTypeID
-	}
-	return nil // TODO: return error instead?
-}
-
-func (ms *messageSet) Marshal(pb Message) error {
-	msg, err := Marshal(pb)
-	if err != nil {
-		return err
-	}
-	if item := ms.find(pb); item != nil {
-		// reuse existing item
-		item.Message = msg
-		return nil
-	}
-
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return errNoMessageTypeID
-	}
-
-	mtid := mti.MessageTypeId()
-	ms.Item = append(ms.Item, &_MessageSet_Item{
-		TypeId:  &mtid,
-		Message: msg,
-	})
-	return nil
-}
-
-func (ms *messageSet) Reset()         { *ms = messageSet{} }
-func (ms *messageSet) String() string { return CompactTextString(ms) }
-func (*messageSet) ProtoMessage()     {}
-
-// Support for the message_set_wire_format message option.
-
-func skipVarint(buf []byte) []byte {
-	i := 0
-	for ; buf[i]&0x80 != 0; i++ {
-	}
-	return buf[i+1:]
-}
-
-// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
-// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
-func unmarshalMessageSet(buf []byte, exts interface{}) error {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		m = exts.extensionsWrite()
-	case map[int32]Extension:
-		m = exts
-	default:
-		return errors.New("proto: not an extension map")
-	}
-
-	ms := new(messageSet)
-	if err := Unmarshal(buf, ms); err != nil {
-		return err
-	}
-	for _, item := range ms.Item {
-		id := *item.TypeId
-		msg := item.Message
-
-		// Restore wire type and field number varint, plus length varint.
-		// Be careful to preserve duplicate items.
-		b := EncodeVarint(uint64(id)<<3 | WireBytes)
-		if ext, ok := m[id]; ok {
-			// Existing data; rip off the tag and length varint
-			// so we join the new data correctly.
-			// We can assume that ext.enc is set because we are unmarshaling.
-			o := ext.enc[len(b):]   // skip wire type and field number
-			_, n := DecodeVarint(o) // calculate length of length varint
-			o = o[n:]               // skip length varint
-			msg = append(o, msg...) // join old data and new data
-		}
-		b = append(b, EncodeVarint(uint64(len(msg)))...)
-		b = append(b, msg...)
-
-		m[id] = Extension{enc: b}
-	}
-	return nil
-}

vendor/github.com/golang/protobuf/proto/pointer_reflect.go

@@ -1,360 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build purego appengine js
-
-// This file contains an implementation of proto field accesses using package reflect.
-// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
-// be used on App Engine.
-
-package proto
-
-import (
-	"reflect"
-	"sync"
-)
-
-const unsafeAllowed = false
-
-// A field identifies a field in a struct, accessible from a pointer.
-// In this implementation, a field is identified by the sequence of field indices
-// passed to reflect's FieldByIndex.
-type field []int
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return f.Index
-}
-
-// invalidField is an invalid field identifier.
-var invalidField = field(nil)
-
-// zeroField is a noop when calling pointer.offset.
-var zeroField = field([]int{})
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool { return f != nil }
-
-// The pointer type is for the table-driven decoder.
-// The implementation here uses a reflect.Value of pointer type to
-// create a generic pointer. In pointer_unsafe.go we use unsafe
-// instead of reflect to implement the same (but faster) interface.
-type pointer struct {
-	v reflect.Value
-}
-
-// toPointer converts an interface of pointer type to a pointer
-// that points to the same target.
-func toPointer(i *Message) pointer {
-	return pointer{v: reflect.ValueOf(*i)}
-}
-
-// toAddrPointer converts an interface to a pointer that points to
-// the interface data.
-func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
-	v := reflect.ValueOf(*i)
-	u := reflect.New(v.Type())
-	u.Elem().Set(v)
-	if deref {
-		u = u.Elem()
-	}
-	return pointer{v: u}
-}
-
-// valToPointer converts v to a pointer.  v must be of pointer type.
-func valToPointer(v reflect.Value) pointer {
-	return pointer{v: v}
-}
-
-// offset converts from a pointer to a structure to a pointer to
-// one of its fields.
-func (p pointer) offset(f field) pointer {
-	return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
-}
-
-func (p pointer) isNil() bool {
-	return p.v.IsNil()
-}
-
-// grow updates the slice s in place to make it one element longer.
-// s must be addressable.
-// Returns the (addressable) new element.
-func grow(s reflect.Value) reflect.Value {
-	n, m := s.Len(), s.Cap()
-	if n < m {
-		s.SetLen(n + 1)
-	} else {
-		s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
-	}
-	return s.Index(n)
-}
-
-func (p pointer) toInt64() *int64 {
-	return p.v.Interface().(*int64)
-}
-func (p pointer) toInt64Ptr() **int64 {
-	return p.v.Interface().(**int64)
-}
-func (p pointer) toInt64Slice() *[]int64 {
-	return p.v.Interface().(*[]int64)
-}
-
-var int32ptr = reflect.TypeOf((*int32)(nil))
-
-func (p pointer) toInt32() *int32 {
-	return p.v.Convert(int32ptr).Interface().(*int32)
-}
-
-// The toInt32Ptr/Slice methods don't work because of enums.
-// Instead, we must use set/get methods for the int32ptr/slice case.
-/*
-	func (p pointer) toInt32Ptr() **int32 {
-		return p.v.Interface().(**int32)
-}
-	func (p pointer) toInt32Slice() *[]int32 {
-		return p.v.Interface().(*[]int32)
-}
-*/
-func (p pointer) getInt32Ptr() *int32 {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		return p.v.Elem().Interface().(*int32)
-	}
-	// an enum
-	return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
-}
-func (p pointer) setInt32Ptr(v int32) {
-	// Allocate value in a *int32. Possibly convert that to a *enum.
-	// Then assign it to a **int32 or **enum.
-	// Note: we can convert *int32 to *enum, but we can't convert
-	// **int32 to **enum!
-	p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
-}
-
-// getInt32Slice copies []int32 from p as a new slice.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) getInt32Slice() []int32 {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		return p.v.Elem().Interface().([]int32)
-	}
-	// an enum
-	// Allocate a []int32, then assign []enum's values into it.
-	// Note: we can't convert []enum to []int32.
-	slice := p.v.Elem()
-	s := make([]int32, slice.Len())
-	for i := 0; i < slice.Len(); i++ {
-		s[i] = int32(slice.Index(i).Int())
-	}
-	return s
-}
-
-// setInt32Slice copies []int32 into p as a new slice.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) setInt32Slice(v []int32) {
-	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
-		// raw int32 type
-		p.v.Elem().Set(reflect.ValueOf(v))
-		return
-	}
-	// an enum
-	// Allocate a []enum, then assign []int32's values into it.
-	// Note: we can't convert []enum to []int32.
-	slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
-	for i, x := range v {
-		slice.Index(i).SetInt(int64(x))
-	}
-	p.v.Elem().Set(slice)
-}
-func (p pointer) appendInt32Slice(v int32) {
-	grow(p.v.Elem()).SetInt(int64(v))
-}
-
-func (p pointer) toUint64() *uint64 {
-	return p.v.Interface().(*uint64)
-}
-func (p pointer) toUint64Ptr() **uint64 {
-	return p.v.Interface().(**uint64)
-}
-func (p pointer) toUint64Slice() *[]uint64 {
-	return p.v.Interface().(*[]uint64)
-}
-func (p pointer) toUint32() *uint32 {
-	return p.v.Interface().(*uint32)
-}
-func (p pointer) toUint32Ptr() **uint32 {
-	return p.v.Interface().(**uint32)
-}
-func (p pointer) toUint32Slice() *[]uint32 {
-	return p.v.Interface().(*[]uint32)
-}
-func (p pointer) toBool() *bool {
-	return p.v.Interface().(*bool)
-}
-func (p pointer) toBoolPtr() **bool {
-	return p.v.Interface().(**bool)
-}
-func (p pointer) toBoolSlice() *[]bool {
-	return p.v.Interface().(*[]bool)
-}
-func (p pointer) toFloat64() *float64 {
-	return p.v.Interface().(*float64)
-}
-func (p pointer) toFloat64Ptr() **float64 {
-	return p.v.Interface().(**float64)
-}
-func (p pointer) toFloat64Slice() *[]float64 {
-	return p.v.Interface().(*[]float64)
-}
-func (p pointer) toFloat32() *float32 {
-	return p.v.Interface().(*float32)
-}
-func (p pointer) toFloat32Ptr() **float32 {
-	return p.v.Interface().(**float32)
-}
-func (p pointer) toFloat32Slice() *[]float32 {
-	return p.v.Interface().(*[]float32)
-}
-func (p pointer) toString() *string {
-	return p.v.Interface().(*string)
-}
-func (p pointer) toStringPtr() **string {
-	return p.v.Interface().(**string)
-}
-func (p pointer) toStringSlice() *[]string {
-	return p.v.Interface().(*[]string)
-}
-func (p pointer) toBytes() *[]byte {
-	return p.v.Interface().(*[]byte)
-}
-func (p pointer) toBytesSlice() *[][]byte {
-	return p.v.Interface().(*[][]byte)
-}
-func (p pointer) toExtensions() *XXX_InternalExtensions {
-	return p.v.Interface().(*XXX_InternalExtensions)
-}
-func (p pointer) toOldExtensions() *map[int32]Extension {
-	return p.v.Interface().(*map[int32]Extension)
-}
-func (p pointer) getPointer() pointer {
-	return pointer{v: p.v.Elem()}
-}
-func (p pointer) setPointer(q pointer) {
-	p.v.Elem().Set(q.v)
-}
-func (p pointer) appendPointer(q pointer) {
-	grow(p.v.Elem()).Set(q.v)
-}
-
-// getPointerSlice copies []*T from p as a new []pointer.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) getPointerSlice() []pointer {
-	if p.v.IsNil() {
-		return nil
-	}
-	n := p.v.Elem().Len()
-	s := make([]pointer, n)
-	for i := 0; i < n; i++ {
-		s[i] = pointer{v: p.v.Elem().Index(i)}
-	}
-	return s
-}
-
-// setPointerSlice copies []pointer into p as a new []*T.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) setPointerSlice(v []pointer) {
-	if v == nil {
-		p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
-		return
-	}
-	s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
-	for _, p := range v {
-		s = reflect.Append(s, p.v)
-	}
-	p.v.Elem().Set(s)
-}
-
-// getInterfacePointer returns a pointer that points to the
-// interface data of the interface pointed by p.
-func (p pointer) getInterfacePointer() pointer {
-	if p.v.Elem().IsNil() {
-		return pointer{v: p.v.Elem()}
-	}
-	return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
-}
-
-func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
-	// TODO: check that p.v.Type().Elem() == t?
-	return p.v
-}
-
-func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	return *p
-}
-func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
-	atomicLock.Lock()
-	defer atomicLock.Unlock()
-	*p = v
-}
-
-var atomicLock sync.Mutex

vendor/github.com/golang/protobuf/proto/pointer_unsafe.go

@@ -1,313 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build !purego,!appengine,!js
-
-// This file contains the implementation of the proto field accesses using package unsafe.
-
-package proto
-
-import (
-	"reflect"
-	"sync/atomic"
-	"unsafe"
-)
-
-const unsafeAllowed = true
-
-// A field identifies a field in a struct, accessible from a pointer.
-// In this implementation, a field is identified by its byte offset from the start of the struct.
-type field uintptr
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return field(f.Offset)
-}
-
-// invalidField is an invalid field identifier.
-const invalidField = ^field(0)
-
-// zeroField is a noop when calling pointer.offset.
-const zeroField = field(0)
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool {
-	return f != invalidField
-}
-
-// The pointer type below is for the new table-driven encoder/decoder.
-// The implementation here uses unsafe.Pointer to create a generic pointer.
-// In pointer_reflect.go we use reflect instead of unsafe to implement
-// the same (but slower) interface.
-type pointer struct {
-	p unsafe.Pointer
-}
-
-// size of pointer
-var ptrSize = unsafe.Sizeof(uintptr(0))
-
-// toPointer converts an interface of pointer type to a pointer
-// that points to the same target.
-func toPointer(i *Message) pointer {
-	// Super-tricky - read pointer out of data word of interface value.
-	// Saves ~25ns over the equivalent:
-	// return valToPointer(reflect.ValueOf(*i))
-	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
-}
-
-// toAddrPointer converts an interface to a pointer that points to
-// the interface data.
-func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
-	// Super-tricky - read or get the address of data word of interface value.
-	if isptr {
-		// The interface is of pointer type, thus it is a direct interface.
-		// The data word is the pointer data itself. We take its address.
-		p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
-	} else {
-		// The interface is not of pointer type. The data word is the pointer
-		// to the data.
-		p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
-	}
-	if deref {
-		p.p = *(*unsafe.Pointer)(p.p)
-	}
-	return p
-}
-
-// valToPointer converts v to a pointer. v must be of pointer type.
-func valToPointer(v reflect.Value) pointer {
-	return pointer{p: unsafe.Pointer(v.Pointer())}
-}
-
-// offset converts from a pointer to a structure to a pointer to
-// one of its fields.
-func (p pointer) offset(f field) pointer {
-	// For safety, we should panic if !f.IsValid, however calling panic causes
-	// this to no longer be inlineable, which is a serious performance cost.
-	/*
-		if !f.IsValid() {
-			panic("invalid field")
-		}
-	*/
-	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
-}
-
-func (p pointer) isNil() bool {
-	return p.p == nil
-}
-
-func (p pointer) toInt64() *int64 {
-	return (*int64)(p.p)
-}
-func (p pointer) toInt64Ptr() **int64 {
-	return (**int64)(p.p)
-}
-func (p pointer) toInt64Slice() *[]int64 {
-	return (*[]int64)(p.p)
-}
-func (p pointer) toInt32() *int32 {
-	return (*int32)(p.p)
-}
-
-// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
-/*
-	func (p pointer) toInt32Ptr() **int32 {
-		return (**int32)(p.p)
-	}
-	func (p pointer) toInt32Slice() *[]int32 {
-		return (*[]int32)(p.p)
-	}
-*/
-func (p pointer) getInt32Ptr() *int32 {
-	return *(**int32)(p.p)
-}
-func (p pointer) setInt32Ptr(v int32) {
-	*(**int32)(p.p) = &v
-}
-
-// getInt32Slice loads a []int32 from p.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) getInt32Slice() []int32 {
-	return *(*[]int32)(p.p)
-}
-
-// setInt32Slice stores a []int32 to p.
-// The value set is aliased with the input slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) setInt32Slice(v []int32) {
-	*(*[]int32)(p.p) = v
-}
-
-// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
-func (p pointer) appendInt32Slice(v int32) {
-	s := (*[]int32)(p.p)
-	*s = append(*s, v)
-}
-
-func (p pointer) toUint64() *uint64 {
-	return (*uint64)(p.p)
-}
-func (p pointer) toUint64Ptr() **uint64 {
-	return (**uint64)(p.p)
-}
-func (p pointer) toUint64Slice() *[]uint64 {
-	return (*[]uint64)(p.p)
-}
-func (p pointer) toUint32() *uint32 {
-	return (*uint32)(p.p)
-}
-func (p pointer) toUint32Ptr() **uint32 {
-	return (**uint32)(p.p)
-}
-func (p pointer) toUint32Slice() *[]uint32 {
-	return (*[]uint32)(p.p)
-}
-func (p pointer) toBool() *bool {
-	return (*bool)(p.p)
-}
-func (p pointer) toBoolPtr() **bool {
-	return (**bool)(p.p)
-}
-func (p pointer) toBoolSlice() *[]bool {
-	return (*[]bool)(p.p)
-}
-func (p pointer) toFloat64() *float64 {
-	return (*float64)(p.p)
-}
-func (p pointer) toFloat64Ptr() **float64 {
-	return (**float64)(p.p)
-}
-func (p pointer) toFloat64Slice() *[]float64 {
-	return (*[]float64)(p.p)
-}
-func (p pointer) toFloat32() *float32 {
-	return (*float32)(p.p)
-}
-func (p pointer) toFloat32Ptr() **float32 {
-	return (**float32)(p.p)
-}
-func (p pointer) toFloat32Slice() *[]float32 {
-	return (*[]float32)(p.p)
-}
-func (p pointer) toString() *string {
-	return (*string)(p.p)
-}
-func (p pointer) toStringPtr() **string {
-	return (**string)(p.p)
-}
-func (p pointer) toStringSlice() *[]string {
-	return (*[]string)(p.p)
-}
-func (p pointer) toBytes() *[]byte {
-	return (*[]byte)(p.p)
-}
-func (p pointer) toBytesSlice() *[][]byte {
-	return (*[][]byte)(p.p)
-}
-func (p pointer) toExtensions() *XXX_InternalExtensions {
-	return (*XXX_InternalExtensions)(p.p)
-}
-func (p pointer) toOldExtensions() *map[int32]Extension {
-	return (*map[int32]Extension)(p.p)
-}
-
-// getPointerSlice loads []*T from p as a []pointer.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) getPointerSlice() []pointer {
-	// Super-tricky - p should point to a []*T where T is a
-	// message type. We load it as []pointer.
-	return *(*[]pointer)(p.p)
-}
-
-// setPointerSlice stores []pointer into p as a []*T.
-// The value set is aliased with the input slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) setPointerSlice(v []pointer) {
-	// Super-tricky - p should point to a []*T where T is a
-	// message type. We store it as []pointer.
-	*(*[]pointer)(p.p) = v
-}
-
-// getPointer loads the pointer at p and returns it.
-func (p pointer) getPointer() pointer {
-	return pointer{p: *(*unsafe.Pointer)(p.p)}
-}
-
-// setPointer stores the pointer q at p.
-func (p pointer) setPointer(q pointer) {
-	*(*unsafe.Pointer)(p.p) = q.p
-}
-
-// append q to the slice pointed to by p.
-func (p pointer) appendPointer(q pointer) {
-	s := (*[]unsafe.Pointer)(p.p)
-	*s = append(*s, q.p)
-}
-
-// getInterfacePointer returns a pointer that points to the
-// interface data of the interface pointed by p.
-func (p pointer) getInterfacePointer() pointer {
-	// Super-tricky - read pointer out of data word of interface value.
-	return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
-}
-
-// asPointerTo returns a reflect.Value that is a pointer to an
-// object of type t stored at p.
-func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
-	return reflect.NewAt(t, p.p)
-}
-
-func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
-	return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
-	return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
-	return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}
-func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
-	return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
-}
-func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
-}

vendor/github.com/golang/protobuf/proto/properties.go

@@ -1,544 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-const debug bool = false
-
-// Constants that identify the encoding of a value on the wire.
-const (
-	WireVarint     = 0
-	WireFixed64    = 1
-	WireBytes      = 2
-	WireStartGroup = 3
-	WireEndGroup   = 4
-	WireFixed32    = 5
-)
-
-// tagMap is an optimization over map[int]int for typical protocol buffer
-// use-cases. Encoded protocol buffers are often in tag order with small tag
-// numbers.
-type tagMap struct {
-	fastTags []int
-	slowTags map[int]int
-}
-
-// tagMapFastLimit is the upper bound on the tag number that will be stored in
-// the tagMap slice rather than its map.
-const tagMapFastLimit = 1024
-
-func (p *tagMap) get(t int) (int, bool) {
-	if t > 0 && t < tagMapFastLimit {
-		if t >= len(p.fastTags) {
-			return 0, false
-		}
-		fi := p.fastTags[t]
-		return fi, fi >= 0
-	}
-	fi, ok := p.slowTags[t]
-	return fi, ok
-}
-
-func (p *tagMap) put(t int, fi int) {
-	if t > 0 && t < tagMapFastLimit {
-		for len(p.fastTags) < t+1 {
-			p.fastTags = append(p.fastTags, -1)
-		}
-		p.fastTags[t] = fi
-		return
-	}
-	if p.slowTags == nil {
-		p.slowTags = make(map[int]int)
-	}
-	p.slowTags[t] = fi
-}
-
-// StructProperties represents properties for all the fields of a struct.
-// decoderTags and decoderOrigNames should only be used by the decoder.
-type StructProperties struct {
-	Prop             []*Properties  // properties for each field
-	reqCount         int            // required count
-	decoderTags      tagMap         // map from proto tag to struct field number
-	decoderOrigNames map[string]int // map from original name to struct field number
-	order            []int          // list of struct field numbers in tag order
-
-	// OneofTypes contains information about the oneof fields in this message.
-	// It is keyed by the original name of a field.
-	OneofTypes map[string]*OneofProperties
-}
-
-// OneofProperties represents information about a specific field in a oneof.
-type OneofProperties struct {
-	Type  reflect.Type // pointer to generated struct type for this oneof field
-	Field int          // struct field number of the containing oneof in the message
-	Prop  *Properties
-}
-
-// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
-// See encode.go, (*Buffer).enc_struct.
-
-func (sp *StructProperties) Len() int { return len(sp.order) }
-func (sp *StructProperties) Less(i, j int) bool {
-	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
-}
-func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
-
-// Properties represents the protocol-specific behavior of a single struct field.
-type Properties struct {
-	Name     string // name of the field, for error messages
-	OrigName string // original name before protocol compiler (always set)
-	JSONName string // name to use for JSON; determined by protoc
-	Wire     string
-	WireType int
-	Tag      int
-	Required bool
-	Optional bool
-	Repeated bool
-	Packed   bool   // relevant for repeated primitives only
-	Enum     string // set for enum types only
-	proto3   bool   // whether this is known to be a proto3 field
-	oneof    bool   // whether this is a oneof field
-
-	Default    string // default value
-	HasDefault bool   // whether an explicit default was provided
-
-	stype reflect.Type      // set for struct types only
-	sprop *StructProperties // set for struct types only
-
-	mtype      reflect.Type // set for map types only
-	MapKeyProp *Properties  // set for map types only
-	MapValProp *Properties  // set for map types only
-}
-
-// String formats the properties in the protobuf struct field tag style.
-func (p *Properties) String() string {
-	s := p.Wire
-	s += ","
-	s += strconv.Itoa(p.Tag)
-	if p.Required {
-		s += ",req"
-	}
-	if p.Optional {
-		s += ",opt"
-	}
-	if p.Repeated {
-		s += ",rep"
-	}
-	if p.Packed {
-		s += ",packed"
-	}
-	s += ",name=" + p.OrigName
-	if p.JSONName != p.OrigName {
-		s += ",json=" + p.JSONName
-	}
-	if p.proto3 {
-		s += ",proto3"
-	}
-	if p.oneof {
-		s += ",oneof"
-	}
-	if len(p.Enum) > 0 {
-		s += ",enum=" + p.Enum
-	}
-	if p.HasDefault {
-		s += ",def=" + p.Default
-	}
-	return s
-}
-
-// Parse populates p by parsing a string in the protobuf struct field tag style.
-func (p *Properties) Parse(s string) {
-	// "bytes,49,opt,name=foo,def=hello!"
-	fields := strings.Split(s, ",") // breaks def=, but handled below.
-	if len(fields) < 2 {
-		log.Printf("proto: tag has too few fields: %q", s)
-		return
-	}
-
-	p.Wire = fields[0]
-	switch p.Wire {
-	case "varint":
-		p.WireType = WireVarint
-	case "fixed32":
-		p.WireType = WireFixed32
-	case "fixed64":
-		p.WireType = WireFixed64
-	case "zigzag32":
-		p.WireType = WireVarint
-	case "zigzag64":
-		p.WireType = WireVarint
-	case "bytes", "group":
-		p.WireType = WireBytes
-		// no numeric converter for non-numeric types
-	default:
-		log.Printf("proto: tag has unknown wire type: %q", s)
-		return
-	}
-
-	var err error
-	p.Tag, err = strconv.Atoi(fields[1])
-	if err != nil {
-		return
-	}
-
-outer:
-	for i := 2; i < len(fields); i++ {
-		f := fields[i]
-		switch {
-		case f == "req":
-			p.Required = true
-		case f == "opt":
-			p.Optional = true
-		case f == "rep":
-			p.Repeated = true
-		case f == "packed":
-			p.Packed = true
-		case strings.HasPrefix(f, "name="):
-			p.OrigName = f[5:]
-		case strings.HasPrefix(f, "json="):
-			p.JSONName = f[5:]
-		case strings.HasPrefix(f, "enum="):
-			p.Enum = f[5:]
-		case f == "proto3":
-			p.proto3 = true
-		case f == "oneof":
-			p.oneof = true
-		case strings.HasPrefix(f, "def="):
-			p.HasDefault = true
-			p.Default = f[4:] // rest of string
-			if i+1 < len(fields) {
-				// Commas aren't escaped, and def is always last.
-				p.Default += "," + strings.Join(fields[i+1:], ",")
-				break outer
-			}
-		}
-	}
-}
-
-var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
-
-// setFieldProps initializes the field properties for submessages and maps.
-func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
-	switch t1 := typ; t1.Kind() {
-	case reflect.Ptr:
-		if t1.Elem().Kind() == reflect.Struct {
-			p.stype = t1.Elem()
-		}
-
-	case reflect.Slice:
-		if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
-			p.stype = t2.Elem()
-		}
-
-	case reflect.Map:
-		p.mtype = t1
-		p.MapKeyProp = &Properties{}
-		p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
-		p.MapValProp = &Properties{}
-		vtype := p.mtype.Elem()
-		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
-			// The value type is not a message (*T) or bytes ([]byte),
-			// so we need encoders for the pointer to this type.
-			vtype = reflect.PtrTo(vtype)
-		}
-		p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
-	}
-
-	if p.stype != nil {
-		if lockGetProp {
-			p.sprop = GetProperties(p.stype)
-		} else {
-			p.sprop = getPropertiesLocked(p.stype)
-		}
-	}
-}
-
-var (
-	marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
-)
-
-// Init populates the properties from a protocol buffer struct tag.
-func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
-	p.init(typ, name, tag, f, true)
-}
-
-func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
-	// "bytes,49,opt,def=hello!"
-	p.Name = name
-	p.OrigName = name
-	if tag == "" {
-		return
-	}
-	p.Parse(tag)
-	p.setFieldProps(typ, f, lockGetProp)
-}
-
-var (
-	propertiesMu  sync.RWMutex
-	propertiesMap = make(map[reflect.Type]*StructProperties)
-)
-
-// GetProperties returns the list of properties for the type represented by t.
-// t must represent a generated struct type of a protocol message.
-func GetProperties(t reflect.Type) *StructProperties {
-	if t.Kind() != reflect.Struct {
-		panic("proto: type must have kind struct")
-	}
-
-	// Most calls to GetProperties in a long-running program will be
-	// retrieving details for types we have seen before.
-	propertiesMu.RLock()
-	sprop, ok := propertiesMap[t]
-	propertiesMu.RUnlock()
-	if ok {
-		return sprop
-	}
-
-	propertiesMu.Lock()
-	sprop = getPropertiesLocked(t)
-	propertiesMu.Unlock()
-	return sprop
-}
-
-type (
-	oneofFuncsIface interface {
-		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
-	}
-	oneofWrappersIface interface {
-		XXX_OneofWrappers() []interface{}
-	}
-)
-
-// getPropertiesLocked requires that propertiesMu is held.
-func getPropertiesLocked(t reflect.Type) *StructProperties {
-	if prop, ok := propertiesMap[t]; ok {
-		return prop
-	}
-
-	prop := new(StructProperties)
-	// in case of recursive protos, fill this in now.
-	propertiesMap[t] = prop
-
-	// build properties
-	prop.Prop = make([]*Properties, t.NumField())
-	prop.order = make([]int, t.NumField())
-
-	for i := 0; i < t.NumField(); i++ {
-		f := t.Field(i)
-		p := new(Properties)
-		name := f.Name
-		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
-
-		oneof := f.Tag.Get("protobuf_oneof") // special case
-		if oneof != "" {
-			// Oneof fields don't use the traditional protobuf tag.
-			p.OrigName = oneof
-		}
-		prop.Prop[i] = p
-		prop.order[i] = i
-		if debug {
-			print(i, " ", f.Name, " ", t.String(), " ")
-			if p.Tag > 0 {
-				print(p.String())
-			}
-			print("\n")
-		}
-	}
-
-	// Re-order prop.order.
-	sort.Sort(prop)
-
-	var oots []interface{}
-	switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
-	case oneofFuncsIface:
-		_, _, _, oots = m.XXX_OneofFuncs()
-	case oneofWrappersIface:
-		oots = m.XXX_OneofWrappers()
-	}
-	if len(oots) > 0 {
-		// Interpret oneof metadata.
-		prop.OneofTypes = make(map[string]*OneofProperties)
-		for _, oot := range oots {
-			oop := &OneofProperties{
-				Type: reflect.ValueOf(oot).Type(), // *T
-				Prop: new(Properties),
-			}
-			sft := oop.Type.Elem().Field(0)
-			oop.Prop.Name = sft.Name
-			oop.Prop.Parse(sft.Tag.Get("protobuf"))
-			// There will be exactly one interface field that
-			// this new value is assignable to.
-			for i := 0; i < t.NumField(); i++ {
-				f := t.Field(i)
-				if f.Type.Kind() != reflect.Interface {
-					continue
-				}
-				if !oop.Type.AssignableTo(f.Type) {
-					continue
-				}
-				oop.Field = i
-				break
-			}
-			prop.OneofTypes[oop.Prop.OrigName] = oop
-		}
-	}
-
-	// build required counts
-	// build tags
-	reqCount := 0
-	prop.decoderOrigNames = make(map[string]int)
-	for i, p := range prop.Prop {
-		if strings.HasPrefix(p.Name, "XXX_") {
-			// Internal fields should not appear in tags/origNames maps.
-			// They are handled specially when encoding and decoding.
-			continue
-		}
-		if p.Required {
-			reqCount++
-		}
-		prop.decoderTags.put(p.Tag, i)
-		prop.decoderOrigNames[p.OrigName] = i
-	}
-	prop.reqCount = reqCount
-
-	return prop
-}
-
-// A global registry of enum types.
-// The generated code will register the generated maps by calling RegisterEnum.
-
-var enumValueMaps = make(map[string]map[string]int32)
-
-// RegisterEnum is called from the generated code to install the enum descriptor
-// maps into the global table to aid parsing text format protocol buffers.
-func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
-	if _, ok := enumValueMaps[typeName]; ok {
-		panic("proto: duplicate enum registered: " + typeName)
-	}
-	enumValueMaps[typeName] = valueMap
-}
-
-// EnumValueMap returns the mapping from names to integers of the
-// enum type enumType, or a nil if not found.
-func EnumValueMap(enumType string) map[string]int32 {
-	return enumValueMaps[enumType]
-}
-
-// A registry of all linked message types.
-// The string is a fully-qualified proto name ("pkg.Message").
-var (
-	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
-	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
-	revProtoTypes  = make(map[reflect.Type]string)
-)
-
-// RegisterType is called from generated code and maps from the fully qualified
-// proto name to the type (pointer to struct) of the protocol buffer.
-func RegisterType(x Message, name string) {
-	if _, ok := protoTypedNils[name]; ok {
-		// TODO: Some day, make this a panic.
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
-		// Generated code always calls RegisterType with nil x.
-		// This check is just for extra safety.
-		protoTypedNils[name] = x
-	} else {
-		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
-	}
-	revProtoTypes[t] = name
-}
-
-// RegisterMapType is called from generated code and maps from the fully qualified
-// proto name to the native map type of the proto map definition.
-func RegisterMapType(x interface{}, name string) {
-	if reflect.TypeOf(x).Kind() != reflect.Map {
-		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
-	}
-	if _, ok := protoMapTypes[name]; ok {
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	protoMapTypes[name] = t
-	revProtoTypes[t] = name
-}
-
-// MessageName returns the fully-qualified proto name for the given message type.
-func MessageName(x Message) string {
-	type xname interface {
-		XXX_MessageName() string
-	}
-	if m, ok := x.(xname); ok {
-		return m.XXX_MessageName()
-	}
-	return revProtoTypes[reflect.TypeOf(x)]
-}
-
-// MessageType returns the message type (pointer to struct) for a named message.
-// The type is not guaranteed to implement proto.Message if the name refers to a
-// map entry.
-func MessageType(name string) reflect.Type {
-	if t, ok := protoTypedNils[name]; ok {
-		return reflect.TypeOf(t)
-	}
-	return protoMapTypes[name]
-}
-
-// A registry of all linked proto files.
-var (
-	protoFiles = make(map[string][]byte) // file name => fileDescriptor
-)
-
-// RegisterFile is called from generated code and maps from the
-// full file name of a .proto file to its compressed FileDescriptorProto.
-func RegisterFile(filename string, fileDescriptor []byte) {
-	protoFiles[filename] = fileDescriptor
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
-func FileDescriptor(filename string) []byte { return protoFiles[filename] }

vendor/github.com/golang/protobuf/proto/table_merge.go

@@ -1,654 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2016 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"sync/atomic"
-)
-
-// Merge merges the src message into dst.
-// This assumes that dst and src of the same type and are non-nil.
-func (a *InternalMessageInfo) Merge(dst, src Message) {
-	mi := atomicLoadMergeInfo(&a.merge)
-	if mi == nil {
-		mi = getMergeInfo(reflect.TypeOf(dst).Elem())
-		atomicStoreMergeInfo(&a.merge, mi)
-	}
-	mi.merge(toPointer(&dst), toPointer(&src))
-}
-
-type mergeInfo struct {
-	typ reflect.Type
-
-	initialized int32 // 0: only typ is valid, 1: everything is valid
-	lock        sync.Mutex
-
-	fields       []mergeFieldInfo
-	unrecognized field // Offset of XXX_unrecognized
-}
-
-type mergeFieldInfo struct {
-	field field // Offset of field, guaranteed to be valid
-
-	// isPointer reports whether the value in the field is a pointer.
-	// This is true for the following situations:
-	//	* Pointer to struct
-	//	* Pointer to basic type (proto2 only)
-	//	* Slice (first value in slice header is a pointer)
-	//	* String (first value in string header is a pointer)
-	isPointer bool
-
-	// basicWidth reports the width of the field assuming that it is directly
-	// embedded in the struct (as is the case for basic types in proto3).
-	// The possible values are:
-	// 	0: invalid
-	//	1: bool
-	//	4: int32, uint32, float32
-	//	8: int64, uint64, float64
-	basicWidth int
-
-	// Where dst and src are pointers to the types being merged.
-	merge func(dst, src pointer)
-}
-
-var (
-	mergeInfoMap  = map[reflect.Type]*mergeInfo{}
-	mergeInfoLock sync.Mutex
-)
-
-func getMergeInfo(t reflect.Type) *mergeInfo {
-	mergeInfoLock.Lock()
-	defer mergeInfoLock.Unlock()
-	mi := mergeInfoMap[t]
-	if mi == nil {
-		mi = &mergeInfo{typ: t}
-		mergeInfoMap[t] = mi
-	}
-	return mi
-}
-
-// merge merges src into dst assuming they are both of type *mi.typ.
-func (mi *mergeInfo) merge(dst, src pointer) {
-	if dst.isNil() {
-		panic("proto: nil destination")
-	}
-	if src.isNil() {
-		return // Nothing to do.
-	}
-
-	if atomic.LoadInt32(&mi.initialized) == 0 {
-		mi.computeMergeInfo()
-	}
-
-	for _, fi := range mi.fields {
-		sfp := src.offset(fi.field)
-
-		// As an optimization, we can avoid the merge function call cost
-		// if we know for sure that the source will have no effect
-		// by checking if it is the zero value.
-		if unsafeAllowed {
-			if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
-				continue
-			}
-			if fi.basicWidth > 0 {
-				switch {
-				case fi.basicWidth == 1 && !*sfp.toBool():
-					continue
-				case fi.basicWidth == 4 && *sfp.toUint32() == 0:
-					continue
-				case fi.basicWidth == 8 && *sfp.toUint64() == 0:
-					continue
-				}
-			}
-		}
-
-		dfp := dst.offset(fi.field)
-		fi.merge(dfp, sfp)
-	}
-
-	// TODO: Make this faster?
-	out := dst.asPointerTo(mi.typ).Elem()
-	in := src.asPointerTo(mi.typ).Elem()
-	if emIn, err := extendable(in.Addr().Interface()); err == nil {
-		emOut, _ := extendable(out.Addr().Interface())
-		mIn, muIn := emIn.extensionsRead()
-		if mIn != nil {
-			mOut := emOut.extensionsWrite()
-			muIn.Lock()
-			mergeExtension(mOut, mIn)
-			muIn.Unlock()
-		}
-	}
-
-	if mi.unrecognized.IsValid() {
-		if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
-			*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
-		}
-	}
-}
-
-func (mi *mergeInfo) computeMergeInfo() {
-	mi.lock.Lock()
-	defer mi.lock.Unlock()
-	if mi.initialized != 0 {
-		return
-	}
-	t := mi.typ
-	n := t.NumField()
-
-	props := GetProperties(t)
-	for i := 0; i < n; i++ {
-		f := t.Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-
-		mfi := mergeFieldInfo{field: toField(&f)}
-		tf := f.Type
-
-		// As an optimization, we can avoid the merge function call cost
-		// if we know for sure that the source will have no effect
-		// by checking if it is the zero value.
-		if unsafeAllowed {
-			switch tf.Kind() {
-			case reflect.Ptr, reflect.Slice, reflect.String:
-				// As a special case, we assume slices and strings are pointers
-				// since we know that the first field in the SliceSlice or
-				// StringHeader is a data pointer.
-				mfi.isPointer = true
-			case reflect.Bool:
-				mfi.basicWidth = 1
-			case reflect.Int32, reflect.Uint32, reflect.Float32:
-				mfi.basicWidth = 4
-			case reflect.Int64, reflect.Uint64, reflect.Float64:
-				mfi.basicWidth = 8
-			}
-		}
-
-		// Unwrap tf to get at its most basic type.
-		var isPointer, isSlice bool
-		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
-			isSlice = true
-			tf = tf.Elem()
-		}
-		if tf.Kind() == reflect.Ptr {
-			isPointer = true
-			tf = tf.Elem()
-		}
-		if isPointer && isSlice && tf.Kind() != reflect.Struct {
-			panic("both pointer and slice for basic type in " + tf.Name())
-		}
-
-		switch tf.Kind() {
-		case reflect.Int32:
-			switch {
-			case isSlice: // E.g., []int32
-				mfi.merge = func(dst, src pointer) {
-					// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
-					/*
-						sfsp := src.toInt32Slice()
-						if *sfsp != nil {
-							dfsp := dst.toInt32Slice()
-							*dfsp = append(*dfsp, *sfsp...)
-							if *dfsp == nil {
-								*dfsp = []int64{}
-							}
-						}
-					*/
-					sfs := src.getInt32Slice()
-					if sfs != nil {
-						dfs := dst.getInt32Slice()
-						dfs = append(dfs, sfs...)
-						if dfs == nil {
-							dfs = []int32{}
-						}
-						dst.setInt32Slice(dfs)
-					}
-				}
-			case isPointer: // E.g., *int32
-				mfi.merge = func(dst, src pointer) {
-					// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
-					/*
-						sfpp := src.toInt32Ptr()
-						if *sfpp != nil {
-							dfpp := dst.toInt32Ptr()
-							if *dfpp == nil {
-								*dfpp = Int32(**sfpp)
-							} else {
-								**dfpp = **sfpp
-							}
-						}
-					*/
-					sfp := src.getInt32Ptr()
-					if sfp != nil {
-						dfp := dst.getInt32Ptr()
-						if dfp == nil {
-							dst.setInt32Ptr(*sfp)
-						} else {
-							*dfp = *sfp
-						}
-					}
-				}
-			default: // E.g., int32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toInt32(); v != 0 {
-						*dst.toInt32() = v
-					}
-				}
-			}
-		case reflect.Int64:
-			switch {
-			case isSlice: // E.g., []int64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toInt64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toInt64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []int64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *int64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toInt64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toInt64Ptr()
-						if *dfpp == nil {
-							*dfpp = Int64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., int64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toInt64(); v != 0 {
-						*dst.toInt64() = v
-					}
-				}
-			}
-		case reflect.Uint32:
-			switch {
-			case isSlice: // E.g., []uint32
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toUint32Slice()
-					if *sfsp != nil {
-						dfsp := dst.toUint32Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []uint32{}
-						}
-					}
-				}
-			case isPointer: // E.g., *uint32
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toUint32Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toUint32Ptr()
-						if *dfpp == nil {
-							*dfpp = Uint32(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., uint32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toUint32(); v != 0 {
-						*dst.toUint32() = v
-					}
-				}
-			}
-		case reflect.Uint64:
-			switch {
-			case isSlice: // E.g., []uint64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toUint64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toUint64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []uint64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *uint64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toUint64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toUint64Ptr()
-						if *dfpp == nil {
-							*dfpp = Uint64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., uint64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toUint64(); v != 0 {
-						*dst.toUint64() = v
-					}
-				}
-			}
-		case reflect.Float32:
-			switch {
-			case isSlice: // E.g., []float32
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toFloat32Slice()
-					if *sfsp != nil {
-						dfsp := dst.toFloat32Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []float32{}
-						}
-					}
-				}
-			case isPointer: // E.g., *float32
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toFloat32Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toFloat32Ptr()
-						if *dfpp == nil {
-							*dfpp = Float32(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., float32
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toFloat32(); v != 0 {
-						*dst.toFloat32() = v
-					}
-				}
-			}
-		case reflect.Float64:
-			switch {
-			case isSlice: // E.g., []float64
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toFloat64Slice()
-					if *sfsp != nil {
-						dfsp := dst.toFloat64Slice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []float64{}
-						}
-					}
-				}
-			case isPointer: // E.g., *float64
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toFloat64Ptr()
-					if *sfpp != nil {
-						dfpp := dst.toFloat64Ptr()
-						if *dfpp == nil {
-							*dfpp = Float64(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., float64
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toFloat64(); v != 0 {
-						*dst.toFloat64() = v
-					}
-				}
-			}
-		case reflect.Bool:
-			switch {
-			case isSlice: // E.g., []bool
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toBoolSlice()
-					if *sfsp != nil {
-						dfsp := dst.toBoolSlice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []bool{}
-						}
-					}
-				}
-			case isPointer: // E.g., *bool
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toBoolPtr()
-					if *sfpp != nil {
-						dfpp := dst.toBoolPtr()
-						if *dfpp == nil {
-							*dfpp = Bool(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., bool
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toBool(); v {
-						*dst.toBool() = v
-					}
-				}
-			}
-		case reflect.String:
-			switch {
-			case isSlice: // E.g., []string
-				mfi.merge = func(dst, src pointer) {
-					sfsp := src.toStringSlice()
-					if *sfsp != nil {
-						dfsp := dst.toStringSlice()
-						*dfsp = append(*dfsp, *sfsp...)
-						if *dfsp == nil {
-							*dfsp = []string{}
-						}
-					}
-				}
-			case isPointer: // E.g., *string
-				mfi.merge = func(dst, src pointer) {
-					sfpp := src.toStringPtr()
-					if *sfpp != nil {
-						dfpp := dst.toStringPtr()
-						if *dfpp == nil {
-							*dfpp = String(**sfpp)
-						} else {
-							**dfpp = **sfpp
-						}
-					}
-				}
-			default: // E.g., string
-				mfi.merge = func(dst, src pointer) {
-					if v := *src.toString(); v != "" {
-						*dst.toString() = v
-					}
-				}
-			}
-		case reflect.Slice:
-			isProto3 := props.Prop[i].proto3
-			switch {
-			case isPointer:
-				panic("bad pointer in byte slice case in " + tf.Name())
-			case tf.Elem().Kind() != reflect.Uint8:
-				panic("bad element kind in byte slice case in " + tf.Name())
-			case isSlice: // E.g., [][]byte
-				mfi.merge = func(dst, src pointer) {
-					sbsp := src.toBytesSlice()
-					if *sbsp != nil {
-						dbsp := dst.toBytesSlice()
-						for _, sb := range *sbsp {
-							if sb == nil {
-								*dbsp = append(*dbsp, nil)
-							} else {
-								*dbsp = append(*dbsp, append([]byte{}, sb...))
-							}
-						}
-						if *dbsp == nil {
-							*dbsp = [][]byte{}
-						}
-					}
-				}
-			default: // E.g., []byte
-				mfi.merge = func(dst, src pointer) {
-					sbp := src.toBytes()
-					if *sbp != nil {
-						dbp := dst.toBytes()
-						if !isProto3 || len(*sbp) > 0 {
-							*dbp = append([]byte{}, *sbp...)
-						}
-					}
-				}
-			}
-		case reflect.Struct:
-			switch {
-			case !isPointer:
-				panic(fmt.Sprintf("message field %s without pointer", tf))
-			case isSlice: // E.g., []*pb.T
-				mi := getMergeInfo(tf)
-				mfi.merge = func(dst, src pointer) {
-					sps := src.getPointerSlice()
-					if sps != nil {
-						dps := dst.getPointerSlice()
-						for _, sp := range sps {
-							var dp pointer
-							if !sp.isNil() {
-								dp = valToPointer(reflect.New(tf))
-								mi.merge(dp, sp)
-							}
-							dps = append(dps, dp)
-						}
-						if dps == nil {
-							dps = []pointer{}
-						}
-						dst.setPointerSlice(dps)
-					}
-				}
-			default: // E.g., *pb.T
-				mi := getMergeInfo(tf)
-				mfi.merge = func(dst, src pointer) {
-					sp := src.getPointer()
-					if !sp.isNil() {
-						dp := dst.getPointer()
-						if dp.isNil() {
-							dp = valToPointer(reflect.New(tf))
-							dst.setPointer(dp)
-						}
-						mi.merge(dp, sp)
-					}
-				}
-			}
-		case reflect.Map:
-			switch {
-			case isPointer || isSlice:
-				panic("bad pointer or slice in map case in " + tf.Name())
-			default: // E.g., map[K]V
-				mfi.merge = func(dst, src pointer) {
-					sm := src.asPointerTo(tf).Elem()
-					if sm.Len() == 0 {
-						return
-					}
-					dm := dst.asPointerTo(tf).Elem()
-					if dm.IsNil() {
-						dm.Set(reflect.MakeMap(tf))
-					}
-
-					switch tf.Elem().Kind() {
-					case reflect.Ptr: // Proto struct (e.g., *T)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							val = reflect.ValueOf(Clone(val.Interface().(Message)))
-							dm.SetMapIndex(key, val)
-						}
-					case reflect.Slice: // E.g. Bytes type (e.g., []byte)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
-							dm.SetMapIndex(key, val)
-						}
-					default: // Basic type (e.g., string)
-						for _, key := range sm.MapKeys() {
-							val := sm.MapIndex(key)
-							dm.SetMapIndex(key, val)
-						}
-					}
-				}
-			}
-		case reflect.Interface:
-			// Must be oneof field.
-			switch {
-			case isPointer || isSlice:
-				panic("bad pointer or slice in interface case in " + tf.Name())
-			default: // E.g., interface{}
-				// TODO: Make this faster?
-				mfi.merge = func(dst, src pointer) {
-					su := src.asPointerTo(tf).Elem()
-					if !su.IsNil() {
-						du := dst.asPointerTo(tf).Elem()
-						typ := su.Elem().Type()
-						if du.IsNil() || du.Elem().Type() != typ {
-							du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
-						}
-						sv := su.Elem().Elem().Field(0)
-						if sv.Kind() == reflect.Ptr && sv.IsNil() {
-							return
-						}
-						dv := du.Elem().Elem().Field(0)
-						if dv.Kind() == reflect.Ptr && dv.IsNil() {
-							dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
-						}
-						switch sv.Type().Kind() {
-						case reflect.Ptr: // Proto struct (e.g., *T)
-							Merge(dv.Interface().(Message), sv.Interface().(Message))
-						case reflect.Slice: // E.g. Bytes type (e.g., []byte)
-							dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
-						default: // Basic type (e.g., string)
-							dv.Set(sv)
-						}
-					}
-				}
-			}
-		default:
-			panic(fmt.Sprintf("merger not found for type:%s", tf))
-		}
-		mi.fields = append(mi.fields, mfi)
-	}
-
-	mi.unrecognized = invalidField
-	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
-		if f.Type != reflect.TypeOf([]byte{}) {
-			panic("expected XXX_unrecognized to be of type []byte")
-		}
-		mi.unrecognized = toField(&f)
-	}
-
-	atomic.StoreInt32(&mi.initialized, 1)
-}

vendor/github.com/golang/protobuf/proto/text.go

@@ -1,843 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for writing the text protocol buffer format.
-
-import (
-	"bufio"
-	"bytes"
-	"encoding"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"math"
-	"reflect"
-	"sort"
-	"strings"
-)
-
-var (
-	newline         = []byte("\n")
-	spaces          = []byte("                                        ")
-	endBraceNewline = []byte("}\n")
-	backslashN      = []byte{'\\', 'n'}
-	backslashR      = []byte{'\\', 'r'}
-	backslashT      = []byte{'\\', 't'}
-	backslashDQ     = []byte{'\\', '"'}
-	backslashBS     = []byte{'\\', '\\'}
-	posInf          = []byte("inf")
-	negInf          = []byte("-inf")
-	nan             = []byte("nan")
-)
-
-type writer interface {
-	io.Writer
-	WriteByte(byte) error
-}
-
-// textWriter is an io.Writer that tracks its indentation level.
-type textWriter struct {
-	ind      int
-	complete bool // if the current position is a complete line
-	compact  bool // whether to write out as a one-liner
-	w        writer
-}
-
-func (w *textWriter) WriteString(s string) (n int, err error) {
-	if !strings.Contains(s, "\n") {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		w.complete = false
-		return io.WriteString(w.w, s)
-	}
-	// WriteString is typically called without newlines, so this
-	// codepath and its copy are rare.  We copy to avoid
-	// duplicating all of Write's logic here.
-	return w.Write([]byte(s))
-}
-
-func (w *textWriter) Write(p []byte) (n int, err error) {
-	newlines := bytes.Count(p, newline)
-	if newlines == 0 {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		n, err = w.w.Write(p)
-		w.complete = false
-		return n, err
-	}
-
-	frags := bytes.SplitN(p, newline, newlines+1)
-	if w.compact {
-		for i, frag := range frags {
-			if i > 0 {
-				if err := w.w.WriteByte(' '); err != nil {
-					return n, err
-				}
-				n++
-			}
-			nn, err := w.w.Write(frag)
-			n += nn
-			if err != nil {
-				return n, err
-			}
-		}
-		return n, nil
-	}
-
-	for i, frag := range frags {
-		if w.complete {
-			w.writeIndent()
-		}
-		nn, err := w.w.Write(frag)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-		if i+1 < len(frags) {
-			if err := w.w.WriteByte('\n'); err != nil {
-				return n, err
-			}
-			n++
-		}
-	}
-	w.complete = len(frags[len(frags)-1]) == 0
-	return n, nil
-}
-
-func (w *textWriter) WriteByte(c byte) error {
-	if w.compact && c == '\n' {
-		c = ' '
-	}
-	if !w.compact && w.complete {
-		w.writeIndent()
-	}
-	err := w.w.WriteByte(c)
-	w.complete = c == '\n'
-	return err
-}
-
-func (w *textWriter) indent() { w.ind++ }
-
-func (w *textWriter) unindent() {
-	if w.ind == 0 {
-		log.Print("proto: textWriter unindented too far")
-		return
-	}
-	w.ind--
-}
-
-func writeName(w *textWriter, props *Properties) error {
-	if _, err := w.WriteString(props.OrigName); err != nil {
-		return err
-	}
-	if props.Wire != "group" {
-		return w.WriteByte(':')
-	}
-	return nil
-}
-
-func requiresQuotes(u string) bool {
-	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
-	for _, ch := range u {
-		switch {
-		case ch == '.' || ch == '/' || ch == '_':
-			continue
-		case '0' <= ch && ch <= '9':
-			continue
-		case 'A' <= ch && ch <= 'Z':
-			continue
-		case 'a' <= ch && ch <= 'z':
-			continue
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-// isAny reports whether sv is a google.protobuf.Any message
-func isAny(sv reflect.Value) bool {
-	type wkt interface {
-		XXX_WellKnownType() string
-	}
-	t, ok := sv.Addr().Interface().(wkt)
-	return ok && t.XXX_WellKnownType() == "Any"
-}
-
-// writeProto3Any writes an expanded google.protobuf.Any message.
-//
-// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
-// required messages are not linked in).
-//
-// It returns (true, error) when sv was written in expanded format or an error
-// was encountered.
-func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
-	turl := sv.FieldByName("TypeUrl")
-	val := sv.FieldByName("Value")
-	if !turl.IsValid() || !val.IsValid() {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	b, ok := val.Interface().([]byte)
-	if !ok {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	parts := strings.Split(turl.String(), "/")
-	mt := MessageType(parts[len(parts)-1])
-	if mt == nil {
-		return false, nil
-	}
-	m := reflect.New(mt.Elem())
-	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
-		return false, nil
-	}
-	w.Write([]byte("["))
-	u := turl.String()
-	if requiresQuotes(u) {
-		writeString(w, u)
-	} else {
-		w.Write([]byte(u))
-	}
-	if w.compact {
-		w.Write([]byte("]:<"))
-	} else {
-		w.Write([]byte("]: <\n"))
-		w.ind++
-	}
-	if err := tm.writeStruct(w, m.Elem()); err != nil {
-		return true, err
-	}
-	if w.compact {
-		w.Write([]byte("> "))
-	} else {
-		w.ind--
-		w.Write([]byte(">\n"))
-	}
-	return true, nil
-}
-
-func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
-	if tm.ExpandAny && isAny(sv) {
-		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
-			return err
-		}
-	}
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < sv.NumField(); i++ {
-		fv := sv.Field(i)
-		props := sprops.Prop[i]
-		name := st.Field(i).Name
-
-		if name == "XXX_NoUnkeyedLiteral" {
-			continue
-		}
-
-		if strings.HasPrefix(name, "XXX_") {
-			// There are two XXX_ fields:
-			//   XXX_unrecognized []byte
-			//   XXX_extensions   map[int32]proto.Extension
-			// The first is handled here;
-			// the second is handled at the bottom of this function.
-			if name == "XXX_unrecognized" && !fv.IsNil() {
-				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Ptr && fv.IsNil() {
-			// Field not filled in. This could be an optional field or
-			// a required field that wasn't filled in. Either way, there
-			// isn't anything we can show for it.
-			continue
-		}
-		if fv.Kind() == reflect.Slice && fv.IsNil() {
-			// Repeated field that is empty, or a bytes field that is unused.
-			continue
-		}
-
-		if props.Repeated && fv.Kind() == reflect.Slice {
-			// Repeated field.
-			for j := 0; j < fv.Len(); j++ {
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				v := fv.Index(j)
-				if v.Kind() == reflect.Ptr && v.IsNil() {
-					// A nil message in a repeated field is not valid,
-					// but we can handle that more gracefully than panicking.
-					if _, err := w.Write([]byte("<nil>\n")); err != nil {
-						return err
-					}
-					continue
-				}
-				if err := tm.writeAny(w, v, props); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Map {
-			// Map fields are rendered as a repeated struct with key/value fields.
-			keys := fv.MapKeys()
-			sort.Sort(mapKeys(keys))
-			for _, key := range keys {
-				val := fv.MapIndex(key)
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				// open struct
-				if err := w.WriteByte('<'); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				w.indent()
-				// key
-				if _, err := w.WriteString("key:"); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-				// nil values aren't legal, but we can avoid panicking because of them.
-				if val.Kind() != reflect.Ptr || !val.IsNil() {
-					// value
-					if _, err := w.WriteString("value:"); err != nil {
-						return err
-					}
-					if !w.compact {
-						if err := w.WriteByte(' '); err != nil {
-							return err
-						}
-					}
-					if err := tm.writeAny(w, val, props.MapValProp); err != nil {
-						return err
-					}
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				// close struct
-				w.unindent()
-				if err := w.WriteByte('>'); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
-			// empty bytes field
-			continue
-		}
-		if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
-			// proto3 non-repeated scalar field; skip if zero value
-			if isProto3Zero(fv) {
-				continue
-			}
-		}
-
-		if fv.Kind() == reflect.Interface {
-			// Check if it is a oneof.
-			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
-				// fv is nil, or holds a pointer to generated struct.
-				// That generated struct has exactly one field,
-				// which has a protobuf struct tag.
-				if fv.IsNil() {
-					continue
-				}
-				inner := fv.Elem().Elem() // interface -> *T -> T
-				tag := inner.Type().Field(0).Tag.Get("protobuf")
-				props = new(Properties) // Overwrite the outer props var, but not its pointee.
-				props.Parse(tag)
-				// Write the value in the oneof, not the oneof itself.
-				fv = inner.Field(0)
-
-				// Special case to cope with malformed messages gracefully:
-				// If the value in the oneof is a nil pointer, don't panic
-				// in writeAny.
-				if fv.Kind() == reflect.Ptr && fv.IsNil() {
-					// Use errors.New so writeAny won't render quotes.
-					msg := errors.New("/* nil */")
-					fv = reflect.ValueOf(&msg).Elem()
-				}
-			}
-		}
-
-		if err := writeName(w, props); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-
-		// Enums have a String method, so writeAny will work fine.
-		if err := tm.writeAny(w, fv, props); err != nil {
-			return err
-		}
-
-		if err := w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-
-	// Extensions (the XXX_extensions field).
-	pv := sv.Addr()
-	if _, err := extendable(pv.Interface()); err == nil {
-		if err := tm.writeExtensions(w, pv); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// writeAny writes an arbitrary field.
-func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
-	v = reflect.Indirect(v)
-
-	// Floats have special cases.
-	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
-		x := v.Float()
-		var b []byte
-		switch {
-		case math.IsInf(x, 1):
-			b = posInf
-		case math.IsInf(x, -1):
-			b = negInf
-		case math.IsNaN(x):
-			b = nan
-		}
-		if b != nil {
-			_, err := w.Write(b)
-			return err
-		}
-		// Other values are handled below.
-	}
-
-	// We don't attempt to serialise every possible value type; only those
-	// that can occur in protocol buffers.
-	switch v.Kind() {
-	case reflect.Slice:
-		// Should only be a []byte; repeated fields are handled in writeStruct.
-		if err := writeString(w, string(v.Bytes())); err != nil {
-			return err
-		}
-	case reflect.String:
-		if err := writeString(w, v.String()); err != nil {
-			return err
-		}
-	case reflect.Struct:
-		// Required/optional group/message.
-		var bra, ket byte = '<', '>'
-		if props != nil && props.Wire == "group" {
-			bra, ket = '{', '}'
-		}
-		if err := w.WriteByte(bra); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte('\n'); err != nil {
-				return err
-			}
-		}
-		w.indent()
-		if v.CanAddr() {
-			// Calling v.Interface on a struct causes the reflect package to
-			// copy the entire struct. This is racy with the new Marshaler
-			// since we atomically update the XXX_sizecache.
-			//
-			// Thus, we retrieve a pointer to the struct if possible to avoid
-			// a race since v.Interface on the pointer doesn't copy the struct.
-			//
-			// If v is not addressable, then we are not worried about a race
-			// since it implies that the binary Marshaler cannot possibly be
-			// mutating this value.
-			v = v.Addr()
-		}
-		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
-			text, err := etm.MarshalText()
-			if err != nil {
-				return err
-			}
-			if _, err = w.Write(text); err != nil {
-				return err
-			}
-		} else {
-			if v.Kind() == reflect.Ptr {
-				v = v.Elem()
-			}
-			if err := tm.writeStruct(w, v); err != nil {
-				return err
-			}
-		}
-		w.unindent()
-		if err := w.WriteByte(ket); err != nil {
-			return err
-		}
-	default:
-		_, err := fmt.Fprint(w, v.Interface())
-		return err
-	}
-	return nil
-}
-
-// equivalent to C's isprint.
-func isprint(c byte) bool {
-	return c >= 0x20 && c < 0x7f
-}
-
-// writeString writes a string in the protocol buffer text format.
-// It is similar to strconv.Quote except we don't use Go escape sequences,
-// we treat the string as a byte sequence, and we use octal escapes.
-// These differences are to maintain interoperability with the other
-// languages' implementations of the text format.
-func writeString(w *textWriter, s string) error {
-	// use WriteByte here to get any needed indent
-	if err := w.WriteByte('"'); err != nil {
-		return err
-	}
-	// Loop over the bytes, not the runes.
-	for i := 0; i < len(s); i++ {
-		var err error
-		// Divergence from C++: we don't escape apostrophes.
-		// There's no need to escape them, and the C++ parser
-		// copes with a naked apostrophe.
-		switch c := s[i]; c {
-		case '\n':
-			_, err = w.w.Write(backslashN)
-		case '\r':
-			_, err = w.w.Write(backslashR)
-		case '\t':
-			_, err = w.w.Write(backslashT)
-		case '"':
-			_, err = w.w.Write(backslashDQ)
-		case '\\':
-			_, err = w.w.Write(backslashBS)
-		default:
-			if isprint(c) {
-				err = w.w.WriteByte(c)
-			} else {
-				_, err = fmt.Fprintf(w.w, "\\%03o", c)
-			}
-		}
-		if err != nil {
-			return err
-		}
-	}
-	return w.WriteByte('"')
-}
-
-func writeUnknownStruct(w *textWriter, data []byte) (err error) {
-	if !w.compact {
-		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
-			return err
-		}
-	}
-	b := NewBuffer(data)
-	for b.index < len(b.buf) {
-		x, err := b.DecodeVarint()
-		if err != nil {
-			_, err := fmt.Fprintf(w, "/* %v */\n", err)
-			return err
-		}
-		wire, tag := x&7, x>>3
-		if wire == WireEndGroup {
-			w.unindent()
-			if _, err := w.Write(endBraceNewline); err != nil {
-				return err
-			}
-			continue
-		}
-		if _, err := fmt.Fprint(w, tag); err != nil {
-			return err
-		}
-		if wire != WireStartGroup {
-			if err := w.WriteByte(':'); err != nil {
-				return err
-			}
-		}
-		if !w.compact || wire == WireStartGroup {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-		switch wire {
-		case WireBytes:
-			buf, e := b.DecodeRawBytes(false)
-			if e == nil {
-				_, err = fmt.Fprintf(w, "%q", buf)
-			} else {
-				_, err = fmt.Fprintf(w, "/* %v */", e)
-			}
-		case WireFixed32:
-			x, err = b.DecodeFixed32()
-			err = writeUnknownInt(w, x, err)
-		case WireFixed64:
-			x, err = b.DecodeFixed64()
-			err = writeUnknownInt(w, x, err)
-		case WireStartGroup:
-			err = w.WriteByte('{')
-			w.indent()
-		case WireVarint:
-			x, err = b.DecodeVarint()
-			err = writeUnknownInt(w, x, err)
-		default:
-			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
-		}
-		if err != nil {
-			return err
-		}
-		if err = w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeUnknownInt(w *textWriter, x uint64, err error) error {
-	if err == nil {
-		_, err = fmt.Fprint(w, x)
-	} else {
-		_, err = fmt.Fprintf(w, "/* %v */", err)
-	}
-	return err
-}
-
-type int32Slice []int32
-
-func (s int32Slice) Len() int           { return len(s) }
-func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
-func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-// writeExtensions writes all the extensions in pv.
-// pv is assumed to be a pointer to a protocol message struct that is extendable.
-func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
-	emap := extensionMaps[pv.Type().Elem()]
-	ep, _ := extendable(pv.Interface())
-
-	// Order the extensions by ID.
-	// This isn't strictly necessary, but it will give us
-	// canonical output, which will also make testing easier.
-	m, mu := ep.extensionsRead()
-	if m == nil {
-		return nil
-	}
-	mu.Lock()
-	ids := make([]int32, 0, len(m))
-	for id := range m {
-		ids = append(ids, id)
-	}
-	sort.Sort(int32Slice(ids))
-	mu.Unlock()
-
-	for _, extNum := range ids {
-		ext := m[extNum]
-		var desc *ExtensionDesc
-		if emap != nil {
-			desc = emap[extNum]
-		}
-		if desc == nil {
-			// Unknown extension.
-			if err := writeUnknownStruct(w, ext.enc); err != nil {
-				return err
-			}
-			continue
-		}
-
-		pb, err := GetExtension(ep, desc)
-		if err != nil {
-			return fmt.Errorf("failed getting extension: %v", err)
-		}
-
-		// Repeated extensions will appear as a slice.
-		if !desc.repeated() {
-			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
-				return err
-			}
-		} else {
-			v := reflect.ValueOf(pb)
-			for i := 0; i < v.Len(); i++ {
-				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
-	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
-		return err
-	}
-	if !w.compact {
-		if err := w.WriteByte(' '); err != nil {
-			return err
-		}
-	}
-	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
-		return err
-	}
-	if err := w.WriteByte('\n'); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (w *textWriter) writeIndent() {
-	if !w.complete {
-		return
-	}
-	remain := w.ind * 2
-	for remain > 0 {
-		n := remain
-		if n > len(spaces) {
-			n = len(spaces)
-		}
-		w.w.Write(spaces[:n])
-		remain -= n
-	}
-	w.complete = false
-}
-
-// TextMarshaler is a configurable text format marshaler.
-type TextMarshaler struct {
-	Compact   bool // use compact text format (one line).
-	ExpandAny bool // expand google.protobuf.Any messages of known types
-}
-
-// Marshal writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
-	val := reflect.ValueOf(pb)
-	if pb == nil || val.IsNil() {
-		w.Write([]byte("<nil>"))
-		return nil
-	}
-	var bw *bufio.Writer
-	ww, ok := w.(writer)
-	if !ok {
-		bw = bufio.NewWriter(w)
-		ww = bw
-	}
-	aw := &textWriter{
-		w:        ww,
-		complete: true,
-		compact:  tm.Compact,
-	}
-
-	if etm, ok := pb.(encoding.TextMarshaler); ok {
-		text, err := etm.MarshalText()
-		if err != nil {
-			return err
-		}
-		if _, err = aw.Write(text); err != nil {
-			return err
-		}
-		if bw != nil {
-			return bw.Flush()
-		}
-		return nil
-	}
-	// Dereference the received pointer so we don't have outer < and >.
-	v := reflect.Indirect(val)
-	if err := tm.writeStruct(aw, v); err != nil {
-		return err
-	}
-	if bw != nil {
-		return bw.Flush()
-	}
-	return nil
-}
-
-// Text is the same as Marshal, but returns the string directly.
-func (tm *TextMarshaler) Text(pb Message) string {
-	var buf bytes.Buffer
-	tm.Marshal(&buf, pb)
-	return buf.String()
-}
-
-var (
-	defaultTextMarshaler = TextMarshaler{}
-	compactTextMarshaler = TextMarshaler{Compact: true}
-)
-
-// TODO: consider removing some of the Marshal functions below.
-
-// MarshalText writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
-
-// MarshalTextString is the same as MarshalText, but returns the string directly.
-func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
-
-// CompactText writes a given protocol buffer in compact text format (one line).
-func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
-
-// CompactTextString is the same as CompactText, but returns the string directly.
-func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }

vendor/github.com/golang/protobuf/proto/text_parser.go

@@ -1,880 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for parsing the Text protocol buffer format.
-// TODO: message sets.
-
-import (
-	"encoding"
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-)
-
-// Error string emitted when deserializing Any and fields are already set
-const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
-
-type ParseError struct {
-	Message string
-	Line    int // 1-based line number
-	Offset  int // 0-based byte offset from start of input
-}
-
-func (p *ParseError) Error() string {
-	if p.Line == 1 {
-		// show offset only for first line
-		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
-	}
-	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
-}
-
-type token struct {
-	value    string
-	err      *ParseError
-	line     int    // line number
-	offset   int    // byte number from start of input, not start of line
-	unquoted string // the unquoted version of value, if it was a quoted string
-}
-
-func (t *token) String() string {
-	if t.err == nil {
-		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
-	}
-	return fmt.Sprintf("parse error: %v", t.err)
-}
-
-type textParser struct {
-	s            string // remaining input
-	done         bool   // whether the parsing is finished (success or error)
-	backed       bool   // whether back() was called
-	offset, line int
-	cur          token
-}
-
-func newTextParser(s string) *textParser {
-	p := new(textParser)
-	p.s = s
-	p.line = 1
-	p.cur.line = 1
-	return p
-}
-
-func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
-	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
-	p.cur.err = pe
-	p.done = true
-	return pe
-}
-
-// Numbers and identifiers are matched by [-+._A-Za-z0-9]
-func isIdentOrNumberChar(c byte) bool {
-	switch {
-	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
-		return true
-	case '0' <= c && c <= '9':
-		return true
-	}
-	switch c {
-	case '-', '+', '.', '_':
-		return true
-	}
-	return false
-}
-
-func isWhitespace(c byte) bool {
-	switch c {
-	case ' ', '\t', '\n', '\r':
-		return true
-	}
-	return false
-}
-
-func isQuote(c byte) bool {
-	switch c {
-	case '"', '\'':
-		return true
-	}
-	return false
-}
-
-func (p *textParser) skipWhitespace() {
-	i := 0
-	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
-		if p.s[i] == '#' {
-			// comment; skip to end of line or input
-			for i < len(p.s) && p.s[i] != '\n' {
-				i++
-			}
-			if i == len(p.s) {
-				break
-			}
-		}
-		if p.s[i] == '\n' {
-			p.line++
-		}
-		i++
-	}
-	p.offset += i
-	p.s = p.s[i:len(p.s)]
-	if len(p.s) == 0 {
-		p.done = true
-	}
-}
-
-func (p *textParser) advance() {
-	// Skip whitespace
-	p.skipWhitespace()
-	if p.done {
-		return
-	}
-
-	// Start of non-whitespace
-	p.cur.err = nil
-	p.cur.offset, p.cur.line = p.offset, p.line
-	p.cur.unquoted = ""
-	switch p.s[0] {
-	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
-		// Single symbol
-		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
-	case '"', '\'':
-		// Quoted string
-		i := 1
-		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
-			if p.s[i] == '\\' && i+1 < len(p.s) {
-				// skip escaped char
-				i++
-			}
-			i++
-		}
-		if i >= len(p.s) || p.s[i] != p.s[0] {
-			p.errorf("unmatched quote")
-			return
-		}
-		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
-		if err != nil {
-			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
-			return
-		}
-		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
-		p.cur.unquoted = unq
-	default:
-		i := 0
-		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
-			i++
-		}
-		if i == 0 {
-			p.errorf("unexpected byte %#x", p.s[0])
-			return
-		}
-		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
-	}
-	p.offset += len(p.cur.value)
-}
-
-var (
-	errBadUTF8 = errors.New("proto: bad UTF-8")
-)
-
-func unquoteC(s string, quote rune) (string, error) {
-	// This is based on C++'s tokenizer.cc.
-	// Despite its name, this is *not* parsing C syntax.
-	// For instance, "\0" is an invalid quoted string.
-
-	// Avoid allocation in trivial cases.
-	simple := true
-	for _, r := range s {
-		if r == '\\' || r == quote {
-			simple = false
-			break
-		}
-	}
-	if simple {
-		return s, nil
-	}
-
-	buf := make([]byte, 0, 3*len(s)/2)
-	for len(s) > 0 {
-		r, n := utf8.DecodeRuneInString(s)
-		if r == utf8.RuneError && n == 1 {
-			return "", errBadUTF8
-		}
-		s = s[n:]
-		if r != '\\' {
-			if r < utf8.RuneSelf {
-				buf = append(buf, byte(r))
-			} else {
-				buf = append(buf, string(r)...)
-			}
-			continue
-		}
-
-		ch, tail, err := unescape(s)
-		if err != nil {
-			return "", err
-		}
-		buf = append(buf, ch...)
-		s = tail
-	}
-	return string(buf), nil
-}
-
-func unescape(s string) (ch string, tail string, err error) {
-	r, n := utf8.DecodeRuneInString(s)
-	if r == utf8.RuneError && n == 1 {
-		return "", "", errBadUTF8
-	}
-	s = s[n:]
-	switch r {
-	case 'a':
-		return "\a", s, nil
-	case 'b':
-		return "\b", s, nil
-	case 'f':
-		return "\f", s, nil
-	case 'n':
-		return "\n", s, nil
-	case 'r':
-		return "\r", s, nil
-	case 't':
-		return "\t", s, nil
-	case 'v':
-		return "\v", s, nil
-	case '?':
-		return "?", s, nil // trigraph workaround
-	case '\'', '"', '\\':
-		return string(r), s, nil
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		if len(s) < 2 {
-			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
-		}
-		ss := string(r) + s[:2]
-		s = s[2:]
-		i, err := strconv.ParseUint(ss, 8, 8)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
-		}
-		return string([]byte{byte(i)}), s, nil
-	case 'x', 'X', 'u', 'U':
-		var n int
-		switch r {
-		case 'x', 'X':
-			n = 2
-		case 'u':
-			n = 4
-		case 'U':
-			n = 8
-		}
-		if len(s) < n {
-			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
-		}
-		ss := s[:n]
-		s = s[n:]
-		i, err := strconv.ParseUint(ss, 16, 64)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
-		}
-		if r == 'x' || r == 'X' {
-			return string([]byte{byte(i)}), s, nil
-		}
-		if i > utf8.MaxRune {
-			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
-		}
-		return string(i), s, nil
-	}
-	return "", "", fmt.Errorf(`unknown escape \%c`, r)
-}
-
-// Back off the parser by one token. Can only be done between calls to next().
-// It makes the next advance() a no-op.
-func (p *textParser) back() { p.backed = true }
-
-// Advances the parser and returns the new current token.
-func (p *textParser) next() *token {
-	if p.backed || p.done {
-		p.backed = false
-		return &p.cur
-	}
-	p.advance()
-	if p.done {
-		p.cur.value = ""
-	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
-		// Look for multiple quoted strings separated by whitespace,
-		// and concatenate them.
-		cat := p.cur
-		for {
-			p.skipWhitespace()
-			if p.done || !isQuote(p.s[0]) {
-				break
-			}
-			p.advance()
-			if p.cur.err != nil {
-				return &p.cur
-			}
-			cat.value += " " + p.cur.value
-			cat.unquoted += p.cur.unquoted
-		}
-		p.done = false // parser may have seen EOF, but we want to return cat
-		p.cur = cat
-	}
-	return &p.cur
-}
-
-func (p *textParser) consumeToken(s string) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != s {
-		p.back()
-		return p.errorf("expected %q, found %q", s, tok.value)
-	}
-	return nil
-}
-
-// Return a RequiredNotSetError indicating which required field was not set.
-func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < st.NumField(); i++ {
-		if !isNil(sv.Field(i)) {
-			continue
-		}
-
-		props := sprops.Prop[i]
-		if props.Required {
-			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
-		}
-	}
-	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
-}
-
-// Returns the index in the struct for the named field, as well as the parsed tag properties.
-func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
-	i, ok := sprops.decoderOrigNames[name]
-	if ok {
-		return i, sprops.Prop[i], true
-	}
-	return -1, nil, false
-}
-
-// Consume a ':' from the input stream (if the next token is a colon),
-// returning an error if a colon is needed but not present.
-func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ":" {
-		// Colon is optional when the field is a group or message.
-		needColon := true
-		switch props.Wire {
-		case "group":
-			needColon = false
-		case "bytes":
-			// A "bytes" field is either a message, a string, or a repeated field;
-			// those three become *T, *string and []T respectively, so we can check for
-			// this field being a pointer to a non-string.
-			if typ.Kind() == reflect.Ptr {
-				// *T or *string
-				if typ.Elem().Kind() == reflect.String {
-					break
-				}
-			} else if typ.Kind() == reflect.Slice {
-				// []T or []*T
-				if typ.Elem().Kind() != reflect.Ptr {
-					break
-				}
-			} else if typ.Kind() == reflect.String {
-				// The proto3 exception is for a string field,
-				// which requires a colon.
-				break
-			}
-			needColon = false
-		}
-		if needColon {
-			return p.errorf("expected ':', found %q", tok.value)
-		}
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	reqCount := sprops.reqCount
-	var reqFieldErr error
-	fieldSet := make(map[string]bool)
-	// A struct is a sequence of "name: value", terminated by one of
-	// '>' or '}', or the end of the input.  A name may also be
-	// "[extension]" or "[type/url]".
-	//
-	// The whole struct can also be an expanded Any message, like:
-	// [type/url] < ... struct contents ... >
-	for {
-		tok := p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		if tok.value == terminator {
-			break
-		}
-		if tok.value == "[" {
-			// Looks like an extension or an Any.
-			//
-			// TODO: Check whether we need to handle
-			// namespace rooted names (e.g. ".something.Foo").
-			extName, err := p.consumeExtName()
-			if err != nil {
-				return err
-			}
-
-			if s := strings.LastIndex(extName, "/"); s >= 0 {
-				// If it contains a slash, it's an Any type URL.
-				messageName := extName[s+1:]
-				mt := MessageType(messageName)
-				if mt == nil {
-					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
-				}
-				tok = p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				// consume an optional colon
-				if tok.value == ":" {
-					tok = p.next()
-					if tok.err != nil {
-						return tok.err
-					}
-				}
-				var terminator string
-				switch tok.value {
-				case "<":
-					terminator = ">"
-				case "{":
-					terminator = "}"
-				default:
-					return p.errorf("expected '{' or '<', found %q", tok.value)
-				}
-				v := reflect.New(mt.Elem())
-				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
-					return pe
-				}
-				b, err := Marshal(v.Interface().(Message))
-				if err != nil {
-					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
-				}
-				if fieldSet["type_url"] {
-					return p.errorf(anyRepeatedlyUnpacked, "type_url")
-				}
-				if fieldSet["value"] {
-					return p.errorf(anyRepeatedlyUnpacked, "value")
-				}
-				sv.FieldByName("TypeUrl").SetString(extName)
-				sv.FieldByName("Value").SetBytes(b)
-				fieldSet["type_url"] = true
-				fieldSet["value"] = true
-				continue
-			}
-
-			var desc *ExtensionDesc
-			// This could be faster, but it's functional.
-			// TODO: Do something smarter than a linear scan.
-			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
-				if d.Name == extName {
-					desc = d
-					break
-				}
-			}
-			if desc == nil {
-				return p.errorf("unrecognized extension %q", extName)
-			}
-
-			props := &Properties{}
-			props.Parse(desc.Tag)
-
-			typ := reflect.TypeOf(desc.ExtensionType)
-			if err := p.checkForColon(props, typ); err != nil {
-				return err
-			}
-
-			rep := desc.repeated()
-
-			// Read the extension structure, and set it in
-			// the value we're constructing.
-			var ext reflect.Value
-			if !rep {
-				ext = reflect.New(typ).Elem()
-			} else {
-				ext = reflect.New(typ.Elem()).Elem()
-			}
-			if err := p.readAny(ext, props); err != nil {
-				if _, ok := err.(*RequiredNotSetError); !ok {
-					return err
-				}
-				reqFieldErr = err
-			}
-			ep := sv.Addr().Interface().(Message)
-			if !rep {
-				SetExtension(ep, desc, ext.Interface())
-			} else {
-				old, err := GetExtension(ep, desc)
-				var sl reflect.Value
-				if err == nil {
-					sl = reflect.ValueOf(old) // existing slice
-				} else {
-					sl = reflect.MakeSlice(typ, 0, 1)
-				}
-				sl = reflect.Append(sl, ext)
-				SetExtension(ep, desc, sl.Interface())
-			}
-			if err := p.consumeOptionalSeparator(); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// This is a normal, non-extension field.
-		name := tok.value
-		var dst reflect.Value
-		fi, props, ok := structFieldByName(sprops, name)
-		if ok {
-			dst = sv.Field(fi)
-		} else if oop, ok := sprops.OneofTypes[name]; ok {
-			// It is a oneof.
-			props = oop.Prop
-			nv := reflect.New(oop.Type.Elem())
-			dst = nv.Elem().Field(0)
-			field := sv.Field(oop.Field)
-			if !field.IsNil() {
-				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
-			}
-			field.Set(nv)
-		}
-		if !dst.IsValid() {
-			return p.errorf("unknown field name %q in %v", name, st)
-		}
-
-		if dst.Kind() == reflect.Map {
-			// Consume any colon.
-			if err := p.checkForColon(props, dst.Type()); err != nil {
-				return err
-			}
-
-			// Construct the map if it doesn't already exist.
-			if dst.IsNil() {
-				dst.Set(reflect.MakeMap(dst.Type()))
-			}
-			key := reflect.New(dst.Type().Key()).Elem()
-			val := reflect.New(dst.Type().Elem()).Elem()
-
-			// The map entry should be this sequence of tokens:
-			//	< key : KEY value : VALUE >
-			// However, implementations may omit key or value, and technically
-			// we should support them in any order.  See b/28924776 for a time
-			// this went wrong.
-
-			tok := p.next()
-			var terminator string
-			switch tok.value {
-			case "<":
-				terminator = ">"
-			case "{":
-				terminator = "}"
-			default:
-				return p.errorf("expected '{' or '<', found %q", tok.value)
-			}
-			for {
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == terminator {
-					break
-				}
-				switch tok.value {
-				case "key":
-					if err := p.consumeToken(":"); err != nil {
-						return err
-					}
-					if err := p.readAny(key, props.MapKeyProp); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				case "value":
-					if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
-						return err
-					}
-					if err := p.readAny(val, props.MapValProp); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				default:
-					p.back()
-					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
-				}
-			}
-
-			dst.SetMapIndex(key, val)
-			continue
-		}
-
-		// Check that it's not already set if it's not a repeated field.
-		if !props.Repeated && fieldSet[name] {
-			return p.errorf("non-repeated field %q was repeated", name)
-		}
-
-		if err := p.checkForColon(props, dst.Type()); err != nil {
-			return err
-		}
-
-		// Parse into the field.
-		fieldSet[name] = true
-		if err := p.readAny(dst, props); err != nil {
-			if _, ok := err.(*RequiredNotSetError); !ok {
-				return err
-			}
-			reqFieldErr = err
-		}
-		if props.Required {
-			reqCount--
-		}
-
-		if err := p.consumeOptionalSeparator(); err != nil {
-			return err
-		}
-
-	}
-
-	if reqCount > 0 {
-		return p.missingRequiredFieldError(sv)
-	}
-	return reqFieldErr
-}
-
-// consumeExtName consumes extension name or expanded Any type URL and the
-// following ']'. It returns the name or URL consumed.
-func (p *textParser) consumeExtName() (string, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return "", tok.err
-	}
-
-	// If extension name or type url is quoted, it's a single token.
-	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
-		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
-		if err != nil {
-			return "", err
-		}
-		return name, p.consumeToken("]")
-	}
-
-	// Consume everything up to "]"
-	var parts []string
-	for tok.value != "]" {
-		parts = append(parts, tok.value)
-		tok = p.next()
-		if tok.err != nil {
-			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
-		}
-		if p.done && tok.value != "]" {
-			return "", p.errorf("unclosed type_url or extension name")
-		}
-	}
-	return strings.Join(parts, ""), nil
-}
-
-// consumeOptionalSeparator consumes an optional semicolon or comma.
-// It is used in readStruct to provide backward compatibility.
-func (p *textParser) consumeOptionalSeparator() error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ";" && tok.value != "," {
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readAny(v reflect.Value, props *Properties) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value == "" {
-		return p.errorf("unexpected EOF")
-	}
-
-	switch fv := v; fv.Kind() {
-	case reflect.Slice:
-		at := v.Type()
-		if at.Elem().Kind() == reflect.Uint8 {
-			// Special case for []byte
-			if tok.value[0] != '"' && tok.value[0] != '\'' {
-				// Deliberately written out here, as the error after
-				// this switch statement would write "invalid []byte: ...",
-				// which is not as user-friendly.
-				return p.errorf("invalid string: %v", tok.value)
-			}
-			bytes := []byte(tok.unquoted)
-			fv.Set(reflect.ValueOf(bytes))
-			return nil
-		}
-		// Repeated field.
-		if tok.value == "[" {
-			// Repeated field with list notation, like [1,2,3].
-			for {
-				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-				err := p.readAny(fv.Index(fv.Len()-1), props)
-				if err != nil {
-					return err
-				}
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == "]" {
-					break
-				}
-				if tok.value != "," {
-					return p.errorf("Expected ']' or ',' found %q", tok.value)
-				}
-			}
-			return nil
-		}
-		// One value of the repeated field.
-		p.back()
-		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-		return p.readAny(fv.Index(fv.Len()-1), props)
-	case reflect.Bool:
-		// true/1/t/True or false/f/0/False.
-		switch tok.value {
-		case "true", "1", "t", "True":
-			fv.SetBool(true)
-			return nil
-		case "false", "0", "f", "False":
-			fv.SetBool(false)
-			return nil
-		}
-	case reflect.Float32, reflect.Float64:
-		v := tok.value
-		// Ignore 'f' for compatibility with output generated by C++, but don't
-		// remove 'f' when the value is "-inf" or "inf".
-		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
-			v = v[:len(v)-1]
-		}
-		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
-			fv.SetFloat(f)
-			return nil
-		}
-	case reflect.Int32:
-		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-		if len(props.Enum) == 0 {
-			break
-		}
-		m, ok := enumValueMaps[props.Enum]
-		if !ok {
-			break
-		}
-		x, ok := m[tok.value]
-		if !ok {
-			break
-		}
-		fv.SetInt(int64(x))
-		return nil
-	case reflect.Int64:
-		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-	case reflect.Ptr:
-		// A basic field (indirected through pointer), or a repeated message/group
-		p.back()
-		fv.Set(reflect.New(fv.Type().Elem()))
-		return p.readAny(fv.Elem(), props)
-	case reflect.String:
-		if tok.value[0] == '"' || tok.value[0] == '\'' {
-			fv.SetString(tok.unquoted)
-			return nil
-		}
-	case reflect.Struct:
-		var terminator string
-		switch tok.value {
-		case "{":
-			terminator = "}"
-		case "<":
-			terminator = ">"
-		default:
-			return p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
-		return p.readStruct(fv, terminator)
-	case reflect.Uint32:
-		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-			fv.SetUint(uint64(x))
-			return nil
-		}
-	case reflect.Uint64:
-		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
-			fv.SetUint(x)
-			return nil
-		}
-	}
-	return p.errorf("invalid %v: %v", v.Type(), tok.value)
-}
-
-// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
-// before starting to unmarshal, so any existing data in pb is always removed.
-// If a required field is not set and no other error occurs,
-// UnmarshalText returns *RequiredNotSetError.
-func UnmarshalText(s string, pb Message) error {
-	if um, ok := pb.(encoding.TextUnmarshaler); ok {
-		return um.UnmarshalText([]byte(s))
-	}
-	pb.Reset()
-	v := reflect.ValueOf(pb)
-	return newTextParser(s).readStruct(v.Elem(), "")
-}

vendor/github.com/google/go-github/v29/AUTHORS

@@ -1,276 +0,0 @@
-# This is the official list of go-github authors for copyright purposes.
-#
-# This does not necessarily list everyone who has contributed code, since in
-# some cases, their employer may be the copyright holder. To see the full list
-# of contributors, see the revision history in source control or
-# https://github.com/google/go-github/graphs/contributors.
-#
-# Authors who wish to be recognized in this file should add themselves (or
-# their employer, as appropriate).
-
-178inaba <masahiro.furudate@gmail.com>
-413x <dedifferentiator@gmail.com>
-Abhinav Gupta <mail@abhinavg.net>
-adrienzieba <adrien.zieba@appdirect.com>
-Ahmed Hagy <a.akram93@gmail.com>
-Aidan Steele <aidan.steele@glassechidna.com.au>
-Ainsley Chong <ainsley.chong@gmail.com>
-Akeda Bagus <akeda@x-team.com>
-Akhil Mohan <akhilerm@gmail.com>
-Alec Thomas <alec@swapoff.org>
-Aleks Clark <aleks.clark@gmail.com>
-Alex Bramley <a.bramley@gmail.com>
-Alexander Harkness <me@bearbin.net>
-Allen Sun <shlallen1990@gmail.com>
-Amey Sakhadeo <me@ameyms.com>
-Andreas Garnæs <https://github.com/andreas>
-Andrew Ryabchun <aryabchun@mail.ua>
-Andy Grunwald <andygrunwald@gmail.com>
-Andy Hume <andyhume@gmail.com>
-Andy Lindeman <andy@lindeman.io>
-anjanashenoy <anjanashenoy1@gmail.com>
-Anshuman Bhartiya <anshuman.bhartiya@gmail.com>
-Antoine <antoine.tu@mail.mcgill.ca>
-Antoine Pelisse <apelisse@gmail.com>
-Anubha Kushwaha <anubha_bt2k14@dtu.ac.in>
-appilon <apilon@hashicorp.com>
-Aravind <aravindkp@outlook.in>
-Arda Kuyumcu <kuyumcuarda@gmail.com>
-Arıl Bozoluk <arilbozoluk@hotmail.com>
-Austin Dizzy <dizzy@wow.com>
-Ben Batha <bhbatha@gmail.com>
-Benjamen Keroack <benjamen@dollarshaveclub.com>
-Beshr Kayali <beshrkayali@gmail.com>
-Beyang Liu <beyang.liu@gmail.com>
-Billy Lynch <wlynch92@gmail.com>
-Björn Häuser <b.haeuser@rebuy.de>
-Brad Harris <bmharris@gmail.com>
-Brad Moylan <moylan.brad@gmail.com>
-Bradley Falzon <brad@teambrad.net>
-Brandon Cook <phylake@gmail.com>
-Brian Egizi <brian@mojotech.com>
-Bryan Boreham <bryan@weave.works>
-Cami Diez <diezcami@gmail.com>
-Carlos Alexandro Becker <caarlos0@gmail.com>
-Carlos Tadeu Panato Junior <ctadeu@gmail.com>
-chandresh-pancholi <chandreshpancholi007@gmail.com>
-Charles Fenwick Elliott <Charles@FenwickElliott.io>
-Charlie Yan <charlieyan08@gmail.com>
-Chris King <chriskingnet@gmail.com>
-Chris Raborg <craborg57@gmail.com>
-Chris Roche <chris@vsco.co>
-Chris Schaefer <chris@dtzq.com>
-chrisforrette <chris@chrisforrette.com>
-Christian Muehlhaeuser <muesli@gmail.com>
-Christoph Sassenberg <defsprite@gmail.com>
-Colin Misare <github.com/cmisare>
-Craig Peterson <cpeterson@stackoverflow.com>
-Cristian Maglie <c.maglie@bug.st>
-Daehyeok Mun <daehyeok@gmail.com>
-Daniel Leavitt <daniel.leavitt@gmail.com>
-Daniel Nilsson <daniel.nilsson1989@gmail.com>
-Daoq <masseto2002@gmail.com>
-Dave Du Cros <davidducros@gmail.com>
-Dave Henderson <dhenderson@gmail.com>
-Dave Protasowski <dprotaso@gmail.com>
-David Deng <daviddengcn@gmail.com>
-David Jannotta <djannotta@gmail.com>
-David Ji <github.com/davidji99>
-David Lopez Reyes <davidlopezre@gmail.com>
-Davide Zipeto <dawez1@gmail.com>
-Dennis Webb <dennis@bluesentryit.com>
-Dhi Aurrahman <diorahman@rockybars.com>
-Diego Lapiduz <diego.lapiduz@cfpb.gov>
-Dmitri Shuralyov <shurcooL@gmail.com>
-dmnlk <seikima2demon@gmail.com>
-Don Petersen <don@donpetersen.net>
-Doug Turner <doug.turner@gmail.com>
-Drew Fradette <drew.fradette@gmail.com>
-Eivind <eivindkn@gmail.com>
-Eli Uriegas <seemethere101@gmail.com>
-Elliott Beach <elliott2.71828@gmail.com>
-Emerson Wood <emersonwood94@gmail.com>
-eperm <staffordworrell@gmail.com>
-Erick Fejta <erick@fejta.com>
-erwinvaneyk <erwinvaneyk@gmail.com>
-Evan Elias <evanjelias@gmail.com>
-Fabrice <fabrice.vaillant@student.ecp.fr>
-Felix Geisendörfer <felix@debuggable.com>
-Filippo Valsorda <hi@filippo.io>
-Florian Forster <ff@octo.it>
-Francesc Gil <xescugil@gmail.com>
-Francis <hello@francismakes.com>
-Francisco Guimarães <francisco.cpg@gmail.com>
-Fredrik Jönsson <fredrik.jonsson@izettle.com>
-Garrett Squire <garrettsquire@gmail.com>
-George Kontridze <george.kontridze@gmail.com>
-Georgy Buranov <gburanov@gmail.com>
-Glen Mailer <glenjamin@gmail.com>
-Gnahz <p@oath.pl>
-Google Inc.
-Grachev Mikhail <work@mgrachev.com>
-griffin_stewie <panterathefamilyguy@gmail.com>
-Guillaume Jacquet <guillaume.jacquet@gmail.com>
-Guz Alexander <kalimatas@gmail.com>
-Guðmundur Bjarni Ólafsson <gudmundur@github.com>
-Hanno Hecker <hanno.hecker@zalando.de>
-Hari haran <hariharan.uno@gmail.com>
-haya14busa <haya14busa@gmail.com>
-haya14busa <hayabusa1419@gmail.com>
-Huy Tr <kingbazoka@gmail.com>
-huydx <doxuanhuy@gmail.com>
-i2bskn <i2bskn@gmail.com>
-Ioannis Georgoulas <igeorgoulas21@gmail.com>
-Isao Jonas <isao.jonas@gmail.com>
-isqua <isqua@isqua.ru>
-Jameel Haffejee <RC1140@republiccommandos.co.za>
-James Cockbain <james.cockbain@ibm.com>
-Jan Kosecki <jan.kosecki91@gmail.com>
-Javier Campanini <jcampanini@palantir.com>
-Jens Rantil <jens.rantil@gmail.com>
-Jeremy Morris <jeremylevanmorris@gmail.com>
-Jesse Newland <jesse@jnewland.com>
-Jihoon Chung <j.c@navercorp.com>
-Jimmi Dyson <jimmidyson@gmail.com>
-Joan Saum <joan.saum@epitech.eu>
-Joe Tsai <joetsai@digital-static.net>
-John Barton <jrbarton@gmail.com>
-John Engelman <john.r.engelman@gmail.com>
-Jordan Brockopp <jdbro94@gmail.com>
-Jordan Sussman <jordansail22@gmail.com>
-Joshua Bezaleel Abednego <joshua.bezaleel@gmail.com>
-JP Phillips <jonphill9@gmail.com>
-jpbelanger-mtl <jp.belanger@gmail.com>
-Juan Basso <jrbasso@gmail.com>
-Julien Garcia Gonzalez <garciagonzalez.julien@gmail.com>
-Julien Rostand <jrostand@users.noreply.github.com>
-Junya Kono <junya03dance@gmail.com>
-Justin Abrahms <justin@abrah.ms>
-Jusung Lee <e.jusunglee@gmail.com>
-jzhoucliqr <jzhou@cliqr.com>
-Katrina Owen <kytrinyx@github.com>
-Kautilya Tripathi < tripathi.kautilya@gmail.com>
-Kautilya Tripathi <tripathi.kautilya@gmail.com>
-Keita Urashima <ursm@ursm.jp>
-Kevin Burke <kev@inburke.com>
-Konrad Malawski <konrad.malawski@project13.pl>
-Kookheon Kwon <kucuny@gmail.com>
-Krzysztof Kowalczyk <kkowalczyk@gmail.com>
-Kshitij Saraogi <KshitijSaraogi@gmail.com>
-kyokomi <kyoko1220adword@gmail.com>
-Laurent Verdoïa <verdoialaurent@gmail.com>
-Liam Galvin <liam@liam-galvin.co.uk>
-Lovro Mažgon <lovro.mazgon@gmail.com>
-Lucas Alcantara <lucasalcantaraf@gmail.com>
-Luke Evers <me@lukevers.com>
-Luke Kysow <lkysow@gmail.com>
-Luke Roberts <email@luke-roberts.co.uk>
-Luke Young <luke@hydrantlabs.org>
-Maksim Zhylinski <uzzable@gmail.com>
-Mark Tareshawty <tarebyte@github.com>
-Martin-Louis Bright <mlbright@gmail.com>
-Marwan Sulaiman <marwan.sameer@gmail.com>
-Masayuki Izumi <m@izum.in>
-Mat Geist <matgeist@gmail.com>
-Matt <alpmatthew@gmail.com>
-Matt Brender <mjbrender@gmail.com>
-Matt Gaunt <matt@gauntface.co.uk>
-Matt Landis <landis.matt@gmail.com>
-Maxime Bury <maxime.bury@gmail.com>
-Michael Spiegel <michael.m.spiegel@gmail.com>
-Michael Tiller <michael.tiller@gmail.com>
-Michał Glapa <michal.glapa@gmail.com>
-Nadav Kaner <nadavkaner1@gmail.com>
-Nathan VanBenschoten <nvanbenschoten@gmail.com>
-Navaneeth Suresh <navaneeths1998@gmail.com>
-Neil O'Toole <neilotoole@apache.org>
-Nick Miyake <nmiyake@palantir.com>
-Nick Spragg <nick.spragg@bbc.co.uk>
-Nikhita Raghunath <nikitaraghunath@gmail.com>
-Noah Zoschke <noah+sso2@convox.com>
-ns-cweber <cweber@narrativescience.com>
-Oleg Kovalov <iamolegkovalov@gmail.com>
-Ole Orhagen <ole.orhagen@northern.tech>
-Ondřej Kupka <ondra.cap@gmail.com>
-Palash Nigam <npalash25@gmail.com>
-Panagiotis Moustafellos <pmoust@gmail.com>
-Parham Alvani <parham.alvani@gmail.com>
-Parker Moore <parkrmoore@gmail.com>
-parkhyukjun89 <park.hyukjun89@gmail.com>
-Pavel Shtanko <pavel.shtanko@gmail.com>
-Pete Wagner <thepwagner@github.com>
-Petr Shevtsov <petr.shevtsov@gmail.com>
-Pierre Carrier <pierre@meteor.com>
-Piotr Zurek <p.zurek@gmail.com>
-Quang Le Hong <iamquang95@gmail.com>
-Quentin Leffray <fiahil@gmail.com>
-Quinn Slack <qslack@qslack.com>
-Rackspace US, Inc.
-Radek Simko <radek.simko@gmail.com>
-Radliński Ignacy <radlinsk@student.agh.edu.pl>
-Rajat Jindal <rajatjindal83@gmail.com>
-Rajendra arora <rajendraarora16@yahoo.com>
-Ranbir Singh <binkkatal.r@gmail.com>
-RaviTeja Pothana <ravi-teja@live.com>
-rc1140 <jameel@republiccommandos.co.za>
-Red Hat, Inc.
-Ricco Førgaard <ricco@fiskeben.dk>
-Rob Figueiredo <robfig@yext.com>
-Rohit Upadhyay <urohit011@gmail.com>
-Ronak Jain <ronakjain@outlook.in>
-Ruben Vereecken <rubenvereecken@gmail.com>
-Ryan Leung <rleungx@gmail.com>
-Ryan Lower <rpjlower@gmail.com>
-Safwan Olaimat <safwan.olaimat@gmail.com>
-Sahil Dua <sahildua2305@gmail.com>
-saisi <saisi@users.noreply.github.com>
-Sam Minnée <sam@silverstripe.com>
-Sandeep Sukhani <sandeep.d.sukhani@gmail.com>
-Sander Knape <s.knape88@gmail.com>
-Sander van Harmelen <svanharmelen@schubergphilis.com>
-Sanket Payghan <sanket.payghan8@gmail.com>
-Sarasa Kisaragi <lingsamuelgrace@gmail.com>
-Sean Wang <sean@decrypted.org>
-Sebastian Mandrean <sebastian.mandrean@gmail.com>
-Sebastian Mæland Pedersen <sem.pedersen@stud.uis.no>
-Sergey Romanov <xxsmotur@gmail.com>
-Sergio Garcia <sergio.garcia@gmail.com>
-Sevki <s@sevki.org>
-Shagun Khemka <shagun.khemka60@gmail.com>
-shakeelrao <shakeelrao79@gmail.com>
-Shawn Catanzarite <me@shawncatz.com>
-Shawn Smith <shawnpsmith@gmail.com>
-Shibasis Patel <patelshibasis@gmail.com>
-Shrikrishna Singh <krishnasingh.ss30@gmail.com>
-sona-tar <sona.zip@gmail.com>
-SoundCloud, Ltd.
-Sridhar Mocherla <srmocher@microsoft.com>
-SriVignessh Pss <sriknowledge@gmail.com>
-Stian Eikeland <stian@eikeland.se>
-Suhaib Mujahid <suhaibmujahid@gmail.com>
-Szymon Kodrebski <simonkey007@gmail.com>
-Takayuki Watanabe <takanabe.w@gmail.com>
-Taketoshi Fujiwara <taketoshi.fujiwara@gmail.com>
-Tasya Aditya Rukmana <tadityar@gmail.com>
-Thomas Bruyelle <thomas.bruyelle@gmail.com>
-Timothée Peignier <timothee.peignier@tryphon.org>
-tkhandel <tarunkhandelwal.iitr@gmail.com>
-Trey Tacon <ttacon@gmail.com>
-ttacon <ttacon@gmail.com>
-Vaibhav Singh <vaibhav.singh.14cse@bml.edu.in>
-Varadarajan Aravamudhan <varadaraajan@gmail.com>
-Victor Castell <victor@victorcastell.com>
-Victor Vrantchan <vrancean+github@gmail.com>
-Vlad Ungureanu <vladu@palantir.com>
-Wasim Thabraze <wasim@thabraze.me>
-Will Maier <wcmaier@gmail.com>
-Willem D'Haeseleer <dhwillem@gmail.com>
-William Bailey <mail@williambailey.org.uk>
-William Cooke <pipeston@gmail.com>
-xibz <impactbchang@gmail.com>
-Yann Malet <yann.malet@gmail.com>
-Yannick Utard <yannickutard@gmail.com>
-Yicheng Qin <qycqycqycqycqyc@gmail.com>
-Yosuke Akatsuka <yosuke.akatsuka@access-company.com>
-Yumikiyo Osanai <yumios.art@gmail.com>
-Zach Latta <zach@zachlatta.com>

vendor/github.com/google/go-github/v29/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2013 The go-github AUTHORS. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/google/go-github/v29/github/actions.go

@@ -1,12 +0,0 @@
-// Copyright 2020 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-// ActionsService handles communication with the actions related
-// methods of the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/
-type ActionsService service

vendor/github.com/google/go-github/v29/github/actions_secrets.go

@@ -1,132 +0,0 @@
-// Copyright 2020 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// PublicKey represents the public key that should be used to encrypt secrets.
-type PublicKey struct {
-	KeyID *string `json:"key_id"`
-	Key   *string `json:"key"`
-}
-
-// GetPublicKey gets a public key that should be used for secret encryption.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/secrets/#get-your-public-key
-func (s *ActionsService) GetPublicKey(ctx context.Context, owner, repo string) (*PublicKey, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/secrets/public-key", owner, repo)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	pubKey := new(PublicKey)
-	resp, err := s.client.Do(ctx, req, pubKey)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return pubKey, resp, nil
-}
-
-// Secret represents a repository action secret.
-type Secret struct {
-	Name      string    `json:"name"`
-	CreatedAt Timestamp `json:"created_at"`
-	UpdatedAt Timestamp `json:"updated_at"`
-}
-
-// Secrets represents one item from the ListSecrets response.
-type Secrets struct {
-	TotalCount int       `json:"total_count"`
-	Secrets    []*Secret `json:"secrets"`
-}
-
-// ListSecrets lists all secrets available in a repository
-// without revealing their encrypted values.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/secrets/#list-secrets-for-a-repository
-func (s *ActionsService) ListSecrets(ctx context.Context, owner, repo string, opts *ListOptions) (*Secrets, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/actions/secrets", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	secrets := new(Secrets)
-	resp, err := s.client.Do(ctx, req, &secrets)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return secrets, resp, nil
-}
-
-// GetSecret gets a single secret without revealing its encrypted value.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/secrets/#get-a-secret
-func (s *ActionsService) GetSecret(ctx context.Context, owner, repo, name string) (*Secret, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, name)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	secret := new(Secret)
-	resp, err := s.client.Do(ctx, req, secret)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return secret, resp, nil
-}
-
-// EncryptedSecret represents a secret that is encrypted using a public key.
-//
-// The value of EncryptedValue must be your secret, encrypted with
-// LibSodium (see documentation here: https://libsodium.gitbook.io/doc/bindings_for_other_languages)
-// using the public key retrieved using the GetPublicKey method.
-type EncryptedSecret struct {
-	Name           string `json:"-"`
-	KeyID          string `json:"key_id"`
-	EncryptedValue string `json:"encrypted_value"`
-}
-
-// CreateOrUpdateSecret creates or updates a secret with an encrypted value.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/secrets/#create-or-update-a-secret-for-a-repository
-func (s *ActionsService) CreateOrUpdateSecret(ctx context.Context, owner, repo string, eSecret *EncryptedSecret) (*Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, eSecret.Name)
-
-	req, err := s.client.NewRequest("PUT", u, eSecret)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// DeleteSecret deletes a secret in a repository using the secret name.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/secrets/#delete-a-secret-from-a-repository
-func (s *ActionsService) DeleteSecret(ctx context.Context, owner, repo, name string) (*Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, name)
-
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/actions_workflows.go

@@ -1,88 +0,0 @@
-// Copyright 2020 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// Workflow represents a repository action workflow.
-type Workflow struct {
-	ID        int64     `json:"id"`
-	NodeID    string    `json:"node_id"`
-	Name      string    `json:"name"`
-	Path      string    `json:"path"`
-	State     string    `json:"state"`
-	CreatedAt Timestamp `json:"created_at"`
-	UpdatedAt Timestamp `json:"updated_at"`
-	URL       string    `json:"url"`
-	HTMLURL   string    `json:"html_url"`
-	BadgeURL  string    `json:"badge_url"`
-}
-
-// Workflows represents a slice of repository action workflows.
-type Workflows struct {
-	TotalCount int         `json:"total_count"`
-	Workflows  []*Workflow `json:"workflows"`
-}
-
-// ListWorkflows lists all workflows in a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/workflows/#list-repository-workflows
-func (s *ActionsService) ListWorkflows(ctx context.Context, owner, repo string, opts *ListOptions) (*Workflows, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/actions/workflows", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	workflows := new(Workflows)
-	resp, err := s.client.Do(ctx, req, &workflows)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return workflows, resp, nil
-}
-
-// GetWorkflowByID gets a specific workflow by ID.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/workflows/#get-a-workflow
-func (s *ActionsService) GetWorkflowByID(ctx context.Context, owner, repo string, workflowID int64) (*Workflow, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v", owner, repo, workflowID)
-
-	return s.getWorkflow(ctx, u)
-}
-
-// GetWorkflowByFileName gets a specific workflow by file name.
-//
-// GitHub API docs: https://developer.github.com/v3/actions/workflows/#get-a-workflow
-func (s *ActionsService) GetWorkflowByFileName(ctx context.Context, owner, repo, workflowFileName string) (*Workflow, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v", owner, repo, workflowFileName)
-
-	return s.getWorkflow(ctx, u)
-}
-
-func (s *ActionsService) getWorkflow(ctx context.Context, url string) (*Workflow, *Response, error) {
-	req, err := s.client.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	workflow := new(Workflow)
-	resp, err := s.client.Do(ctx, req, workflow)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return workflow, resp, nil
-}

vendor/github.com/google/go-github/v29/github/activity.go

@@ -1,69 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import "context"
-
-// ActivityService handles communication with the activity related
-// methods of the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/
-type ActivityService service
-
-// FeedLink represents a link to a related resource.
-type FeedLink struct {
-	HRef *string `json:"href,omitempty"`
-	Type *string `json:"type,omitempty"`
-}
-
-// Feeds represents timeline resources in Atom format.
-type Feeds struct {
-	TimelineURL                 *string  `json:"timeline_url,omitempty"`
-	UserURL                     *string  `json:"user_url,omitempty"`
-	CurrentUserPublicURL        *string  `json:"current_user_public_url,omitempty"`
-	CurrentUserURL              *string  `json:"current_user_url,omitempty"`
-	CurrentUserActorURL         *string  `json:"current_user_actor_url,omitempty"`
-	CurrentUserOrganizationURL  *string  `json:"current_user_organization_url,omitempty"`
-	CurrentUserOrganizationURLs []string `json:"current_user_organization_urls,omitempty"`
-	Links                       *struct {
-		Timeline                 *FeedLink  `json:"timeline,omitempty"`
-		User                     *FeedLink  `json:"user,omitempty"`
-		CurrentUserPublic        *FeedLink  `json:"current_user_public,omitempty"`
-		CurrentUser              *FeedLink  `json:"current_user,omitempty"`
-		CurrentUserActor         *FeedLink  `json:"current_user_actor,omitempty"`
-		CurrentUserOrganization  *FeedLink  `json:"current_user_organization,omitempty"`
-		CurrentUserOrganizations []FeedLink `json:"current_user_organizations,omitempty"`
-	} `json:"_links,omitempty"`
-}
-
-// ListFeeds lists all the feeds available to the authenticated user.
-//
-// GitHub provides several timeline resources in Atom format:
-//     Timeline: The GitHub global public timeline
-//     User: The public timeline for any user, using URI template
-//     Current user public: The public timeline for the authenticated user
-//     Current user: The private timeline for the authenticated user
-//     Current user actor: The private timeline for activity created by the
-//         authenticated user
-//     Current user organizations: The private timeline for the organizations
-//         the authenticated user is a member of.
-//
-// Note: Private feeds are only returned when authenticating via Basic Auth
-// since current feed URIs use the older, non revocable auth tokens.
-func (s *ActivityService) ListFeeds(ctx context.Context) (*Feeds, *Response, error) {
-	req, err := s.client.NewRequest("GET", "feeds", nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	f := &Feeds{}
-	resp, err := s.client.Do(ctx, req, f)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return f, resp, nil
-}

vendor/github.com/google/go-github/v29/github/activity_events.go

@@ -1,215 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// ListEvents drinks from the firehose of all public events across GitHub.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events
-func (s *ActivityService) ListEvents(ctx context.Context, opts *ListOptions) ([]*Event, *Response, error) {
-	u, err := addOptions("events", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListRepositoryEvents lists events for a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-repository-events
-func (s *ActivityService) ListRepositoryEvents(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Event, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/events", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListIssueEventsForRepository lists issue events for a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-issue-events-for-a-repository
-func (s *ActivityService) ListIssueEventsForRepository(ctx context.Context, owner, repo string, opts *ListOptions) ([]*IssueEvent, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/issues/events", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*IssueEvent
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListEventsForRepoNetwork lists public events for a network of repositories.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events-for-a-network-of-repositories
-func (s *ActivityService) ListEventsForRepoNetwork(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Event, *Response, error) {
-	u := fmt.Sprintf("networks/%v/%v/events", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListEventsForOrganization lists public events for an organization.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events-for-an-organization
-func (s *ActivityService) ListEventsForOrganization(ctx context.Context, org string, opts *ListOptions) ([]*Event, *Response, error) {
-	u := fmt.Sprintf("orgs/%v/events", org)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListEventsPerformedByUser lists the events performed by a user. If publicOnly is
-// true, only public events will be returned.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-performed-by-a-user
-func (s *ActivityService) ListEventsPerformedByUser(ctx context.Context, user string, publicOnly bool, opts *ListOptions) ([]*Event, *Response, error) {
-	var u string
-	if publicOnly {
-		u = fmt.Sprintf("users/%v/events/public", user)
-	} else {
-		u = fmt.Sprintf("users/%v/events", user)
-	}
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListEventsReceivedByUser lists the events received by a user. If publicOnly is
-// true, only public events will be returned.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-that-a-user-has-received
-func (s *ActivityService) ListEventsReceivedByUser(ctx context.Context, user string, publicOnly bool, opts *ListOptions) ([]*Event, *Response, error) {
-	var u string
-	if publicOnly {
-		u = fmt.Sprintf("users/%v/received_events/public", user)
-	} else {
-		u = fmt.Sprintf("users/%v/received_events", user)
-	}
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}
-
-// ListUserEventsForOrganization provides the user’s organization dashboard. You
-// must be authenticated as the user to view this.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-for-an-organization
-func (s *ActivityService) ListUserEventsForOrganization(ctx context.Context, org, user string, opts *ListOptions) ([]*Event, *Response, error) {
-	u := fmt.Sprintf("users/%v/events/orgs/%v", user, org)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var events []*Event
-	resp, err := s.client.Do(ctx, req, &events)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return events, resp, nil
-}

vendor/github.com/google/go-github/v29/github/activity_notifications.go

@@ -1,223 +0,0 @@
-// Copyright 2014 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-// Notification identifies a GitHub notification for a user.
-type Notification struct {
-	ID         *string              `json:"id,omitempty"`
-	Repository *Repository          `json:"repository,omitempty"`
-	Subject    *NotificationSubject `json:"subject,omitempty"`
-
-	// Reason identifies the event that triggered the notification.
-	//
-	// GitHub API docs: https://developer.github.com/v3/activity/notifications/#notification-reasons
-	Reason *string `json:"reason,omitempty"`
-
-	Unread     *bool      `json:"unread,omitempty"`
-	UpdatedAt  *time.Time `json:"updated_at,omitempty"`
-	LastReadAt *time.Time `json:"last_read_at,omitempty"`
-	URL        *string    `json:"url,omitempty"`
-}
-
-// NotificationSubject identifies the subject of a notification.
-type NotificationSubject struct {
-	Title            *string `json:"title,omitempty"`
-	URL              *string `json:"url,omitempty"`
-	LatestCommentURL *string `json:"latest_comment_url,omitempty"`
-	Type             *string `json:"type,omitempty"`
-}
-
-// NotificationListOptions specifies the optional parameters to the
-// ActivityService.ListNotifications method.
-type NotificationListOptions struct {
-	All           bool      `url:"all,omitempty"`
-	Participating bool      `url:"participating,omitempty"`
-	Since         time.Time `url:"since,omitempty"`
-	Before        time.Time `url:"before,omitempty"`
-
-	ListOptions
-}
-
-// ListNotifications lists all notifications for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications
-func (s *ActivityService) ListNotifications(ctx context.Context, opts *NotificationListOptions) ([]*Notification, *Response, error) {
-	u := fmt.Sprintf("notifications")
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var notifications []*Notification
-	resp, err := s.client.Do(ctx, req, &notifications)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return notifications, resp, nil
-}
-
-// ListRepositoryNotifications lists all notifications in a given repository
-// for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
-func (s *ActivityService) ListRepositoryNotifications(ctx context.Context, owner, repo string, opts *NotificationListOptions) ([]*Notification, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var notifications []*Notification
-	resp, err := s.client.Do(ctx, req, &notifications)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return notifications, resp, nil
-}
-
-type markReadOptions struct {
-	LastReadAt time.Time `json:"last_read_at,omitempty"`
-}
-
-// MarkNotificationsRead marks all notifications up to lastRead as read.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-as-read
-func (s *ActivityService) MarkNotificationsRead(ctx context.Context, lastRead time.Time) (*Response, error) {
-	opts := &markReadOptions{
-		LastReadAt: lastRead,
-	}
-	req, err := s.client.NewRequest("PUT", "notifications", opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// MarkRepositoryNotificationsRead marks all notifications up to lastRead in
-// the specified repository as read.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
-func (s *ActivityService) MarkRepositoryNotificationsRead(ctx context.Context, owner, repo string, lastRead time.Time) (*Response, error) {
-	opts := &markReadOptions{
-		LastReadAt: lastRead,
-	}
-	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
-	req, err := s.client.NewRequest("PUT", u, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// GetThread gets the specified notification thread.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#view-a-single-thread
-func (s *ActivityService) GetThread(ctx context.Context, id string) (*Notification, *Response, error) {
-	u := fmt.Sprintf("notifications/threads/%v", id)
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	notification := new(Notification)
-	resp, err := s.client.Do(ctx, req, notification)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return notification, resp, nil
-}
-
-// MarkThreadRead marks the specified thread as read.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
-func (s *ActivityService) MarkThreadRead(ctx context.Context, id string) (*Response, error) {
-	u := fmt.Sprintf("notifications/threads/%v", id)
-
-	req, err := s.client.NewRequest("PATCH", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// GetThreadSubscription checks to see if the authenticated user is subscribed
-// to a thread.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
-func (s *ActivityService) GetThreadSubscription(ctx context.Context, id string) (*Subscription, *Response, error) {
-	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	sub := new(Subscription)
-	resp, err := s.client.Do(ctx, req, sub)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return sub, resp, nil
-}
-
-// SetThreadSubscription sets the subscription for the specified thread for the
-// authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
-func (s *ActivityService) SetThreadSubscription(ctx context.Context, id string, subscription *Subscription) (*Subscription, *Response, error) {
-	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
-
-	req, err := s.client.NewRequest("PUT", u, subscription)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	sub := new(Subscription)
-	resp, err := s.client.Do(ctx, req, sub)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return sub, resp, nil
-}
-
-// DeleteThreadSubscription deletes the subscription for the specified thread
-// for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
-func (s *ActivityService) DeleteThreadSubscription(ctx context.Context, id string) (*Response, error) {
-	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/activity_star.go

@@ -1,137 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"strings"
-)
-
-// StarredRepository is returned by ListStarred.
-type StarredRepository struct {
-	StarredAt  *Timestamp  `json:"starred_at,omitempty"`
-	Repository *Repository `json:"repo,omitempty"`
-}
-
-// Stargazer represents a user that has starred a repository.
-type Stargazer struct {
-	StarredAt *Timestamp `json:"starred_at,omitempty"`
-	User      *User      `json:"user,omitempty"`
-}
-
-// ListStargazers lists people who have starred the specified repo.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/starring/#list-stargazers
-func (s *ActivityService) ListStargazers(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Stargazer, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/stargazers", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches
-	req.Header.Set("Accept", mediaTypeStarringPreview)
-
-	var stargazers []*Stargazer
-	resp, err := s.client.Do(ctx, req, &stargazers)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return stargazers, resp, nil
-}
-
-// ActivityListStarredOptions specifies the optional parameters to the
-// ActivityService.ListStarred method.
-type ActivityListStarredOptions struct {
-	// How to sort the repository list. Possible values are: created, updated,
-	// pushed, full_name. Default is "full_name".
-	Sort string `url:"sort,omitempty"`
-
-	// Direction in which to sort repositories. Possible values are: asc, desc.
-	// Default is "asc" when sort is "full_name", otherwise default is "desc".
-	Direction string `url:"direction,omitempty"`
-
-	ListOptions
-}
-
-// ListStarred lists all the repos starred by a user. Passing the empty string
-// will list the starred repositories for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/starring/#list-repositories-being-starred
-func (s *ActivityService) ListStarred(ctx context.Context, user string, opts *ActivityListStarredOptions) ([]*StarredRepository, *Response, error) {
-	var u string
-	if user != "" {
-		u = fmt.Sprintf("users/%v/starred", user)
-	} else {
-		u = "user/starred"
-	}
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when APIs fully launch
-	acceptHeaders := []string{mediaTypeStarringPreview, mediaTypeTopicsPreview}
-	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
-
-	var repos []*StarredRepository
-	resp, err := s.client.Do(ctx, req, &repos)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return repos, resp, nil
-}
-
-// IsStarred checks if a repository is starred by authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository
-func (s *ActivityService) IsStarred(ctx context.Context, owner, repo string) (bool, *Response, error) {
-	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return false, nil, err
-	}
-	resp, err := s.client.Do(ctx, req, nil)
-	starred, err := parseBoolResponse(err)
-	return starred, resp, err
-}
-
-// Star a repository as the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/starring/#star-a-repository
-func (s *ActivityService) Star(ctx context.Context, owner, repo string) (*Response, error) {
-	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
-	req, err := s.client.NewRequest("PUT", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	return s.client.Do(ctx, req, nil)
-}
-
-// Unstar a repository as the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/starring/#unstar-a-repository
-func (s *ActivityService) Unstar(ctx context.Context, owner, repo string) (*Response, error) {
-	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/activity_watching.go

@@ -1,146 +0,0 @@
-// Copyright 2014 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// Subscription identifies a repository or thread subscription.
-type Subscription struct {
-	Subscribed *bool      `json:"subscribed,omitempty"`
-	Ignored    *bool      `json:"ignored,omitempty"`
-	Reason     *string    `json:"reason,omitempty"`
-	CreatedAt  *Timestamp `json:"created_at,omitempty"`
-	URL        *string    `json:"url,omitempty"`
-
-	// only populated for repository subscriptions
-	RepositoryURL *string `json:"repository_url,omitempty"`
-
-	// only populated for thread subscriptions
-	ThreadURL *string `json:"thread_url,omitempty"`
-}
-
-// ListWatchers lists watchers of a particular repo.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/watching/#list-watchers
-func (s *ActivityService) ListWatchers(ctx context.Context, owner, repo string, opts *ListOptions) ([]*User, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/subscribers", owner, repo)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var watchers []*User
-	resp, err := s.client.Do(ctx, req, &watchers)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return watchers, resp, nil
-}
-
-// ListWatched lists the repositories the specified user is watching. Passing
-// the empty string will fetch watched repos for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/watching/#list-repositories-being-watched
-func (s *ActivityService) ListWatched(ctx context.Context, user string, opts *ListOptions) ([]*Repository, *Response, error) {
-	var u string
-	if user != "" {
-		u = fmt.Sprintf("users/%v/subscriptions", user)
-	} else {
-		u = "user/subscriptions"
-	}
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var watched []*Repository
-	resp, err := s.client.Do(ctx, req, &watched)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return watched, resp, nil
-}
-
-// GetRepositorySubscription returns the subscription for the specified
-// repository for the authenticated user. If the authenticated user is not
-// watching the repository, a nil Subscription is returned.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/watching/#get-a-repository-subscription
-func (s *ActivityService) GetRepositorySubscription(ctx context.Context, owner, repo string) (*Subscription, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	sub := new(Subscription)
-	resp, err := s.client.Do(ctx, req, sub)
-	if err != nil {
-		// if it's just a 404, don't return that as an error
-		_, err = parseBoolResponse(err)
-		return nil, resp, err
-	}
-
-	return sub, resp, nil
-}
-
-// SetRepositorySubscription sets the subscription for the specified repository
-// for the authenticated user.
-//
-// To watch a repository, set subscription.Subscribed to true.
-// To ignore notifications made within a repository, set subscription.Ignored to true.
-// To stop watching a repository, use DeleteRepositorySubscription.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/watching/#set-a-repository-subscription
-func (s *ActivityService) SetRepositorySubscription(ctx context.Context, owner, repo string, subscription *Subscription) (*Subscription, *Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
-
-	req, err := s.client.NewRequest("PUT", u, subscription)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	sub := new(Subscription)
-	resp, err := s.client.Do(ctx, req, sub)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return sub, resp, nil
-}
-
-// DeleteRepositorySubscription deletes the subscription for the specified
-// repository for the authenticated user.
-//
-// This is used to stop watching a repository. To control whether or not to
-// receive notifications from a repository, use SetRepositorySubscription.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/watching/#delete-a-repository-subscription
-func (s *ActivityService) DeleteRepositorySubscription(ctx context.Context, owner, repo string) (*Response, error) {
-	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/admin.go

@@ -1,119 +0,0 @@
-// Copyright 2016 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// AdminService handles communication with the admin related methods of the
-// GitHub API. These API routes are normally only accessible for GitHub
-// Enterprise installations.
-//
-// GitHub API docs: https://developer.github.com/v3/enterprise/
-type AdminService service
-
-// TeamLDAPMapping represents the mapping between a GitHub team and an LDAP group.
-type TeamLDAPMapping struct {
-	ID          *int64  `json:"id,omitempty"`
-	LDAPDN      *string `json:"ldap_dn,omitempty"`
-	URL         *string `json:"url,omitempty"`
-	Name        *string `json:"name,omitempty"`
-	Slug        *string `json:"slug,omitempty"`
-	Description *string `json:"description,omitempty"`
-	Privacy     *string `json:"privacy,omitempty"`
-	Permission  *string `json:"permission,omitempty"`
-
-	MembersURL      *string `json:"members_url,omitempty"`
-	RepositoriesURL *string `json:"repositories_url,omitempty"`
-}
-
-func (m TeamLDAPMapping) String() string {
-	return Stringify(m)
-}
-
-// UserLDAPMapping represents the mapping between a GitHub user and an LDAP user.
-type UserLDAPMapping struct {
-	ID         *int64  `json:"id,omitempty"`
-	LDAPDN     *string `json:"ldap_dn,omitempty"`
-	Login      *string `json:"login,omitempty"`
-	AvatarURL  *string `json:"avatar_url,omitempty"`
-	GravatarID *string `json:"gravatar_id,omitempty"`
-	Type       *string `json:"type,omitempty"`
-	SiteAdmin  *bool   `json:"site_admin,omitempty"`
-
-	URL               *string `json:"url,omitempty"`
-	EventsURL         *string `json:"events_url,omitempty"`
-	FollowingURL      *string `json:"following_url,omitempty"`
-	FollowersURL      *string `json:"followers_url,omitempty"`
-	GistsURL          *string `json:"gists_url,omitempty"`
-	OrganizationsURL  *string `json:"organizations_url,omitempty"`
-	ReceivedEventsURL *string `json:"received_events_url,omitempty"`
-	ReposURL          *string `json:"repos_url,omitempty"`
-	StarredURL        *string `json:"starred_url,omitempty"`
-	SubscriptionsURL  *string `json:"subscriptions_url,omitempty"`
-}
-
-func (m UserLDAPMapping) String() string {
-	return Stringify(m)
-}
-
-// Enterprise represents the GitHub enterprise profile.
-type Enterprise struct {
-	ID          *int       `json:"id,omitempty"`
-	Slug        *string    `json:"slug,omitempty"`
-	Name        *string    `json:"name,omitempty"`
-	NodeID      *string    `json:"node_id,omitempty"`
-	AvatarURL   *string    `json:"avatar_url,omitempty"`
-	Description *string    `json:"description,omitempty"`
-	WebsiteURL  *string    `json:"website_url,omitempty"`
-	HTMLURL     *string    `json:"html_url,omitempty"`
-	CreatedAt   *Timestamp `json:"created_at,omitempty"`
-	UpdatedAt   *Timestamp `json:"updated_at,omitempty"`
-}
-
-func (m Enterprise) String() string {
-	return Stringify(m)
-}
-
-// UpdateUserLDAPMapping updates the mapping between a GitHub user and an LDAP user.
-//
-// GitHub API docs: https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
-func (s *AdminService) UpdateUserLDAPMapping(ctx context.Context, user string, mapping *UserLDAPMapping) (*UserLDAPMapping, *Response, error) {
-	u := fmt.Sprintf("admin/ldap/users/%v/mapping", user)
-	req, err := s.client.NewRequest("PATCH", u, mapping)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	m := new(UserLDAPMapping)
-	resp, err := s.client.Do(ctx, req, m)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return m, resp, nil
-}
-
-// UpdateTeamLDAPMapping updates the mapping between a GitHub team and an LDAP group.
-//
-// GitHub API docs: https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
-func (s *AdminService) UpdateTeamLDAPMapping(ctx context.Context, team int64, mapping *TeamLDAPMapping) (*TeamLDAPMapping, *Response, error) {
-	u := fmt.Sprintf("admin/ldap/teams/%v/mapping", team)
-	req, err := s.client.NewRequest("PATCH", u, mapping)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	m := new(TeamLDAPMapping)
-	resp, err := s.client.Do(ctx, req, m)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return m, resp, nil
-}

vendor/github.com/google/go-github/v29/github/admin_orgs.go

@@ -1,43 +0,0 @@
-// Copyright 2019 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import "context"
-
-// createOrgRequest is a subset of Organization and is used internally
-// by CreateOrg to pass only the known fields for the endpoint.
-type createOrgRequest struct {
-	Login *string `json:"login,omitempty"`
-	Admin *string `json:"admin,omitempty"`
-}
-
-// CreateOrg creates a new organization in GitHub Enterprise.
-//
-// Note that only a subset of the org fields are used and org must
-// not be nil.
-//
-// GitHub Enterprise API docs: https://developer.github.com/enterprise/v3/enterprise-admin/orgs/#create-an-organization
-func (s *AdminService) CreateOrg(ctx context.Context, org *Organization, admin string) (*Organization, *Response, error) {
-	u := "admin/organizations"
-
-	orgReq := &createOrgRequest{
-		Login: org.Login,
-		Admin: &admin,
-	}
-
-	req, err := s.client.NewRequest("POST", u, orgReq)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	o := new(Organization)
-	resp, err := s.client.Do(ctx, req, o)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return o, resp, nil
-}

vendor/github.com/google/go-github/v29/github/admin_stats.go

@@ -1,171 +0,0 @@
-// Copyright 2017 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// AdminStats represents a variety of stats of a GitHub Enterprise
-// installation.
-type AdminStats struct {
-	Issues     *IssueStats     `json:"issues,omitempty"`
-	Hooks      *HookStats      `json:"hooks,omitempty"`
-	Milestones *MilestoneStats `json:"milestones,omitempty"`
-	Orgs       *OrgStats       `json:"orgs,omitempty"`
-	Comments   *CommentStats   `json:"comments,omitempty"`
-	Pages      *PageStats      `json:"pages,omitempty"`
-	Users      *UserStats      `json:"users,omitempty"`
-	Gists      *GistStats      `json:"gists,omitempty"`
-	Pulls      *PullStats      `json:"pulls,omitempty"`
-	Repos      *RepoStats      `json:"repos,omitempty"`
-}
-
-func (s AdminStats) String() string {
-	return Stringify(s)
-}
-
-// IssueStats represents the number of total, open and closed issues.
-type IssueStats struct {
-	TotalIssues  *int `json:"total_issues,omitempty"`
-	OpenIssues   *int `json:"open_issues,omitempty"`
-	ClosedIssues *int `json:"closed_issues,omitempty"`
-}
-
-func (s IssueStats) String() string {
-	return Stringify(s)
-}
-
-// HookStats represents the number of total, active and inactive hooks.
-type HookStats struct {
-	TotalHooks    *int `json:"total_hooks,omitempty"`
-	ActiveHooks   *int `json:"active_hooks,omitempty"`
-	InactiveHooks *int `json:"inactive_hooks,omitempty"`
-}
-
-func (s HookStats) String() string {
-	return Stringify(s)
-}
-
-// MilestoneStats represents the number of total, open and close milestones.
-type MilestoneStats struct {
-	TotalMilestones  *int `json:"total_milestones,omitempty"`
-	OpenMilestones   *int `json:"open_milestones,omitempty"`
-	ClosedMilestones *int `json:"closed_milestones,omitempty"`
-}
-
-func (s MilestoneStats) String() string {
-	return Stringify(s)
-}
-
-// OrgStats represents the number of total, disabled organizations and the team
-// and team member count.
-type OrgStats struct {
-	TotalOrgs        *int `json:"total_orgs,omitempty"`
-	DisabledOrgs     *int `json:"disabled_orgs,omitempty"`
-	TotalTeams       *int `json:"total_teams,omitempty"`
-	TotalTeamMembers *int `json:"total_team_members,omitempty"`
-}
-
-func (s OrgStats) String() string {
-	return Stringify(s)
-}
-
-// CommentStats represents the number of total comments on commits, gists, issues
-// and pull requests.
-type CommentStats struct {
-	TotalCommitComments      *int `json:"total_commit_comments,omitempty"`
-	TotalGistComments        *int `json:"total_gist_comments,omitempty"`
-	TotalIssueComments       *int `json:"total_issue_comments,omitempty"`
-	TotalPullRequestComments *int `json:"total_pull_request_comments,omitempty"`
-}
-
-func (s CommentStats) String() string {
-	return Stringify(s)
-}
-
-// PageStats represents the total number of github pages.
-type PageStats struct {
-	TotalPages *int `json:"total_pages,omitempty"`
-}
-
-func (s PageStats) String() string {
-	return Stringify(s)
-}
-
-// UserStats represents the number of total, admin and suspended users.
-type UserStats struct {
-	TotalUsers     *int `json:"total_users,omitempty"`
-	AdminUsers     *int `json:"admin_users,omitempty"`
-	SuspendedUsers *int `json:"suspended_users,omitempty"`
-}
-
-func (s UserStats) String() string {
-	return Stringify(s)
-}
-
-// GistStats represents the number of total, private and public gists.
-type GistStats struct {
-	TotalGists   *int `json:"total_gists,omitempty"`
-	PrivateGists *int `json:"private_gists,omitempty"`
-	PublicGists  *int `json:"public_gists,omitempty"`
-}
-
-func (s GistStats) String() string {
-	return Stringify(s)
-}
-
-// PullStats represents the number of total, merged, mergable and unmergeable
-// pull-requests.
-type PullStats struct {
-	TotalPulls      *int `json:"total_pulls,omitempty"`
-	MergedPulls     *int `json:"merged_pulls,omitempty"`
-	MergablePulls   *int `json:"mergeable_pulls,omitempty"`
-	UnmergablePulls *int `json:"unmergeable_pulls,omitempty"`
-}
-
-func (s PullStats) String() string {
-	return Stringify(s)
-}
-
-// RepoStats represents the number of total, root, fork, organization repositories
-// together with the total number of pushes and wikis.
-type RepoStats struct {
-	TotalRepos  *int `json:"total_repos,omitempty"`
-	RootRepos   *int `json:"root_repos,omitempty"`
-	ForkRepos   *int `json:"fork_repos,omitempty"`
-	OrgRepos    *int `json:"org_repos,omitempty"`
-	TotalPushes *int `json:"total_pushes,omitempty"`
-	TotalWikis  *int `json:"total_wikis,omitempty"`
-}
-
-func (s RepoStats) String() string {
-	return Stringify(s)
-}
-
-// GetAdminStats returns a variety of metrics about a GitHub Enterprise
-// installation.
-//
-// Please note that this is only available to site administrators,
-// otherwise it will error with a 404 not found (instead of 401 or 403).
-//
-// GitHub API docs: https://developer.github.com/v3/enterprise-admin/admin_stats/
-func (s *AdminService) GetAdminStats(ctx context.Context) (*AdminStats, *Response, error) {
-	u := fmt.Sprintf("enterprise/stats/all")
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	m := new(AdminStats)
-	resp, err := s.client.Do(ctx, req, m)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return m, resp, nil
-}

vendor/github.com/google/go-github/v29/github/admin_users.go

@@ -1,133 +0,0 @@
-// Copyright 2019 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// createUserRequest is a subset of User and is used internally
-// by CreateUser to pass only the known fields for the endpoint.
-type createUserRequest struct {
-	Login *string `json:"login,omitempty"`
-	Email *string `json:"email,omitempty"`
-}
-
-// CreateUser creates a new user in GitHub Enterprise.
-//
-// GitHub Enterprise API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#create-a-new-user
-func (s *AdminService) CreateUser(ctx context.Context, login, email string) (*User, *Response, error) {
-	u := "admin/users"
-
-	userReq := &createUserRequest{
-		Login: &login,
-		Email: &email,
-	}
-
-	req, err := s.client.NewRequest("POST", u, userReq)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var user User
-	resp, err := s.client.Do(ctx, req, &user)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return &user, resp, nil
-}
-
-// DeleteUser deletes a user in GitHub Enterprise.
-//
-// GitHub Enterprise API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#delete-a-user
-func (s *AdminService) DeleteUser(ctx context.Context, username string) (*Response, error) {
-	u := "admin/users/" + username
-
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := s.client.Do(ctx, req, nil)
-	if err != nil {
-		return resp, err
-	}
-
-	return resp, nil
-}
-
-// ImpersonateUserOptions represents the scoping for the OAuth token.
-type ImpersonateUserOptions struct {
-	Scopes []string `json:"scopes,omitempty"`
-}
-
-// OAuthAPP represents the GitHub Site Administrator OAuth app.
-type OAuthAPP struct {
-	URL      *string `json:"url,omitempty"`
-	Name     *string `json:"name,omitempty"`
-	ClientID *string `json:"client_id,omitempty"`
-}
-
-func (s OAuthAPP) String() string {
-	return Stringify(s)
-}
-
-// UserAuthorization represents the impersonation response.
-type UserAuthorization struct {
-	ID             *int64     `json:"id,omitempty"`
-	URL            *string    `json:"url,omitempty"`
-	Scopes         []string   `json:"scopes,omitempty"`
-	Token          *string    `json:"token,omitempty"`
-	TokenLastEight *string    `json:"token_last_eight,omitempty"`
-	HashedToken    *string    `json:"hashed_token,omitempty"`
-	App            *OAuthAPP  `json:"app,omitempty"`
-	Note           *string    `json:"note,omitempty"`
-	NoteURL        *string    `json:"note_url,omitempty"`
-	UpdatedAt      *Timestamp `json:"updated_at,omitempty"`
-	CreatedAt      *Timestamp `json:"created_at,omitempty"`
-	Fingerprint    *string    `json:"fingerprint,omitempty"`
-}
-
-// CreateUserImpersonation creates an impersonation OAuth token.
-//
-// GitHub Enterprise API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#create-an-impersonation-oauth-token
-func (s *AdminService) CreateUserImpersonation(ctx context.Context, username string, opts *ImpersonateUserOptions) (*UserAuthorization, *Response, error) {
-	u := fmt.Sprintf("admin/users/%s/authorizations", username)
-
-	req, err := s.client.NewRequest("POST", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(UserAuthorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return a, resp, nil
-}
-
-// DeleteUserImpersonation deletes an impersonation OAuth token.
-//
-// GitHub Enterprise API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#delete-an-impersonation-oauth-token
-func (s *AdminService) DeleteUserImpersonation(ctx context.Context, username string) (*Response, error) {
-	u := fmt.Sprintf("admin/users/%s/authorizations", username)
-
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := s.client.Do(ctx, req, nil)
-	if err != nil {
-		return resp, err
-	}
-
-	return resp, nil
-}

vendor/github.com/google/go-github/v29/github/apps.go

@@ -1,303 +0,0 @@
-// Copyright 2016 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-// AppsService provides access to the installation related functions
-// in the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/
-type AppsService service
-
-// App represents a GitHub App.
-type App struct {
-	ID          *int64                   `json:"id,omitempty"`
-	Slug        *string                  `json:"slug,omitempty"`
-	NodeID      *string                  `json:"node_id,omitempty"`
-	Owner       *User                    `json:"owner,omitempty"`
-	Name        *string                  `json:"name,omitempty"`
-	Description *string                  `json:"description,omitempty"`
-	ExternalURL *string                  `json:"external_url,omitempty"`
-	HTMLURL     *string                  `json:"html_url,omitempty"`
-	CreatedAt   *Timestamp               `json:"created_at,omitempty"`
-	UpdatedAt   *Timestamp               `json:"updated_at,omitempty"`
-	Permissions *InstallationPermissions `json:"permissions,omitempty"`
-	Events      []string                 `json:"events,omitempty"`
-}
-
-// InstallationToken represents an installation token.
-type InstallationToken struct {
-	Token        *string                  `json:"token,omitempty"`
-	ExpiresAt    *time.Time               `json:"expires_at,omitempty"`
-	Permissions  *InstallationPermissions `json:"permissions,omitempty"`
-	Repositories []*Repository            `json:"repositories,omitempty"`
-}
-
-// InstallationTokenOptions allow restricting a token's access to specific repositories.
-type InstallationTokenOptions struct {
-	// The IDs of the repositories that the installation token can access.
-	// Providing repository IDs restricts the access of an installation token to specific repositories.
-	RepositoryIDs []int64 `json:"repository_ids,omitempty"`
-
-	// The permissions granted to the access token.
-	// The permissions object includes the permission names and their access type.
-	Permissions *InstallationPermissions `json:"permissions,omitempty"`
-}
-
-// InstallationPermissions lists the repository and organization permissions for an installation.
-//
-// Permission names taken from:
-//   https://developer.github.com/v3/apps/permissions/
-//   https://developer.github.com/enterprise/v3/apps/permissions/
-type InstallationPermissions struct {
-	Administration              *string `json:"administration,omitempty"`
-	Blocking                    *string `json:"blocking,omitempty"`
-	Checks                      *string `json:"checks,omitempty"`
-	Contents                    *string `json:"contents,omitempty"`
-	ContentReferences           *string `json:"content_references,omitempty"`
-	Deployments                 *string `json:"deployments,omitempty"`
-	Emails                      *string `json:"emails,omitempty"`
-	Followers                   *string `json:"followers,omitempty"`
-	Issues                      *string `json:"issues,omitempty"`
-	Metadata                    *string `json:"metadata,omitempty"`
-	Members                     *string `json:"members,omitempty"`
-	OrganizationAdministration  *string `json:"organization_administration,omitempty"`
-	OrganizationHooks           *string `json:"organization_hooks,omitempty"`
-	OrganizationPlan            *string `json:"organization_plan,omitempty"`
-	OrganizationPreReceiveHooks *string `json:"organization_pre_receive_hooks,omitempty"`
-	OrganizationProjects        *string `json:"organization_projects,omitempty"`
-	OrganizationUserBlocking    *string `json:"organization_user_blocking,omitempty"`
-	Packages                    *string `json:"packages,omitempty"`
-	Pages                       *string `json:"pages,omitempty"`
-	PullRequests                *string `json:"pull_requests,omitempty"`
-	RepositoryHooks             *string `json:"repository_hooks,omitempty"`
-	RepositoryProjects          *string `json:"repository_projects,omitempty"`
-	RepositoryPreReceiveHooks   *string `json:"repository_pre_receive_hooks,omitempty"`
-	SingleFile                  *string `json:"single_file,omitempty"`
-	Statuses                    *string `json:"statuses,omitempty"`
-	TeamDiscussions             *string `json:"team_discussions,omitempty"`
-	VulnerabilityAlerts         *string `json:"vulnerability_alerts,omitempty"`
-}
-
-// Installation represents a GitHub Apps installation.
-type Installation struct {
-	ID                  *int64                   `json:"id,omitempty"`
-	AppID               *int64                   `json:"app_id,omitempty"`
-	TargetID            *int64                   `json:"target_id,omitempty"`
-	Account             *User                    `json:"account,omitempty"`
-	AccessTokensURL     *string                  `json:"access_tokens_url,omitempty"`
-	RepositoriesURL     *string                  `json:"repositories_url,omitempty"`
-	HTMLURL             *string                  `json:"html_url,omitempty"`
-	TargetType          *string                  `json:"target_type,omitempty"`
-	SingleFileName      *string                  `json:"single_file_name,omitempty"`
-	RepositorySelection *string                  `json:"repository_selection,omitempty"`
-	Events              []string                 `json:"events,omitempty"`
-	Permissions         *InstallationPermissions `json:"permissions,omitempty"`
-	CreatedAt           *Timestamp               `json:"created_at,omitempty"`
-	UpdatedAt           *Timestamp               `json:"updated_at,omitempty"`
-}
-
-// Attachment represents a GitHub Apps attachment.
-type Attachment struct {
-	ID    *int64  `json:"id,omitempty"`
-	Title *string `json:"title,omitempty"`
-	Body  *string `json:"body,omitempty"`
-}
-
-func (i Installation) String() string {
-	return Stringify(i)
-}
-
-// Get a single GitHub App. Passing the empty string will get
-// the authenticated GitHub App.
-//
-// Note: appSlug is just the URL-friendly name of your GitHub App.
-// You can find this on the settings page for your GitHub App
-// (e.g., https://github.com/settings/apps/:app_slug).
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#get-a-single-github-app
-func (s *AppsService) Get(ctx context.Context, appSlug string) (*App, *Response, error) {
-	var u string
-	if appSlug != "" {
-		u = fmt.Sprintf("apps/%v", appSlug)
-	} else {
-		u = "app"
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	app := new(App)
-	resp, err := s.client.Do(ctx, req, app)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return app, resp, nil
-}
-
-// ListInstallations lists the installations that the current GitHub App has.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#list-installations
-func (s *AppsService) ListInstallations(ctx context.Context, opts *ListOptions) ([]*Installation, *Response, error) {
-	u, err := addOptions("app/installations", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	var i []*Installation
-	resp, err := s.client.Do(ctx, req, &i)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return i, resp, nil
-}
-
-// GetInstallation returns the specified installation.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#get-a-single-installation
-func (s *AppsService) GetInstallation(ctx context.Context, id int64) (*Installation, *Response, error) {
-	return s.getInstallation(ctx, fmt.Sprintf("app/installations/%v", id))
-}
-
-// ListUserInstallations lists installations that are accessible to the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#list-installations-for-user
-func (s *AppsService) ListUserInstallations(ctx context.Context, opts *ListOptions) ([]*Installation, *Response, error) {
-	u, err := addOptions("user/installations", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	var i struct {
-		Installations []*Installation `json:"installations"`
-	}
-	resp, err := s.client.Do(ctx, req, &i)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return i.Installations, resp, nil
-}
-
-// CreateInstallationToken creates a new installation token.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#create-a-new-installation-token
-func (s *AppsService) CreateInstallationToken(ctx context.Context, id int64, opts *InstallationTokenOptions) (*InstallationToken, *Response, error) {
-	u := fmt.Sprintf("app/installations/%v/access_tokens", id)
-
-	req, err := s.client.NewRequest("POST", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	t := new(InstallationToken)
-	resp, err := s.client.Do(ctx, req, t)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return t, resp, nil
-}
-
-// CreateAttachment creates a new attachment on user comment containing a url.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#create-a-content-attachment
-func (s *AppsService) CreateAttachment(ctx context.Context, contentReferenceID int64, title, body string) (*Attachment, *Response, error) {
-	u := fmt.Sprintf("content_references/%v/attachments", contentReferenceID)
-	payload := &Attachment{Title: String(title), Body: String(body)}
-	req, err := s.client.NewRequest("POST", u, payload)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept headers when APIs fully launch.
-	req.Header.Set("Accept", mediaTypeReactionsPreview)
-
-	m := &Attachment{}
-	resp, err := s.client.Do(ctx, req, m)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return m, resp, nil
-}
-
-// FindOrganizationInstallation finds the organization's installation information.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#get-an-organization-installation
-func (s *AppsService) FindOrganizationInstallation(ctx context.Context, org string) (*Installation, *Response, error) {
-	return s.getInstallation(ctx, fmt.Sprintf("orgs/%v/installation", org))
-}
-
-// FindRepositoryInstallation finds the repository's installation information.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#get-a-repository-installation
-func (s *AppsService) FindRepositoryInstallation(ctx context.Context, owner, repo string) (*Installation, *Response, error) {
-	return s.getInstallation(ctx, fmt.Sprintf("repos/%v/%v/installation", owner, repo))
-}
-
-// FindRepositoryInstallationByID finds the repository's installation information.
-//
-// Note: FindRepositoryInstallationByID uses the undocumented GitHub API endpoint /repositories/:id/installation.
-func (s *AppsService) FindRepositoryInstallationByID(ctx context.Context, id int64) (*Installation, *Response, error) {
-	return s.getInstallation(ctx, fmt.Sprintf("repositories/%d/installation", id))
-}
-
-// FindUserInstallation finds the user's installation information.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/#get-a-user-installation
-func (s *AppsService) FindUserInstallation(ctx context.Context, user string) (*Installation, *Response, error) {
-	return s.getInstallation(ctx, fmt.Sprintf("users/%v/installation", user))
-}
-
-func (s *AppsService) getInstallation(ctx context.Context, url string) (*Installation, *Response, error) {
-	req, err := s.client.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	i := new(Installation)
-	resp, err := s.client.Do(ctx, req, i)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return i, resp, nil
-}

vendor/github.com/google/go-github/v29/github/apps_installation.go

@@ -1,117 +0,0 @@
-// Copyright 2016 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// ListRepos lists the repositories that are accessible to the authenticated installation.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/installations/#list-repositories
-func (s *AppsService) ListRepos(ctx context.Context, opts *ListOptions) ([]*Repository, *Response, error) {
-	u, err := addOptions("installation/repositories", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	var r struct {
-		Repositories []*Repository `json:"repositories"`
-	}
-	resp, err := s.client.Do(ctx, req, &r)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return r.Repositories, resp, nil
-}
-
-// ListUserRepos lists repositories that are accessible
-// to the authenticated user for an installation.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/installations/#list-repositories-accessible-to-the-user-for-an-installation
-func (s *AppsService) ListUserRepos(ctx context.Context, id int64, opts *ListOptions) ([]*Repository, *Response, error) {
-	u := fmt.Sprintf("user/installations/%v/repositories", id)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	var r struct {
-		Repositories []*Repository `json:"repositories"`
-	}
-	resp, err := s.client.Do(ctx, req, &r)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return r.Repositories, resp, nil
-}
-
-// AddRepository adds a single repository to an installation.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/installations/#add-repository-to-installation
-func (s *AppsService) AddRepository(ctx context.Context, instID, repoID int64) (*Repository, *Response, error) {
-	u := fmt.Sprintf("user/installations/%v/repositories/%v", instID, repoID)
-	req, err := s.client.NewRequest("PUT", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	r := new(Repository)
-	resp, err := s.client.Do(ctx, req, r)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return r, resp, nil
-}
-
-// RemoveRepository removes a single repository from an installation.
-//
-// GitHub docs: https://developer.github.com/v3/apps/installations/#remove-repository-from-installation
-func (s *AppsService) RemoveRepository(ctx context.Context, instID, repoID int64) (*Response, error) {
-	u := fmt.Sprintf("user/installations/%v/repositories/%v", instID, repoID)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", mediaTypeIntegrationPreview)
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// RevokeInstallationToken revokes an installation token.
-//
-// GitHub docs: https://developer.github.com/v3/apps/installations/#revoke-an-installation-token
-func (s *AppsService) RevokeInstallationToken(ctx context.Context) (*Response, error) {
-	u := "installation/token"
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", mediaTypeRevokeTokenPreview)
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/apps_manifest.go

@@ -1,53 +0,0 @@
-// Copyright 2019 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-const (
-	mediaTypeAppManifestPreview = "application/vnd.github.fury-preview+json"
-)
-
-// AppConfig describes the configuration of a GitHub App.
-type AppConfig struct {
-	ID            *int64     `json:"id,omitempty"`
-	NodeID        *string    `json:"node_id,omitempty"`
-	Owner         *User      `json:"owner,omitempty"`
-	Name          *string    `json:"name,omitempty"`
-	Description   *string    `json:"description,omitempty"`
-	ExternalURL   *string    `json:"external_url,omitempty"`
-	HTMLURL       *string    `json:"html_url,omitempty"`
-	CreatedAt     *Timestamp `json:"created_at,omitempty"`
-	UpdatedAt     *Timestamp `json:"updated_at,omitempty"`
-	ClientID      *string    `json:"client_id,omitempty"`
-	ClientSecret  *string    `json:"client_secret,omitempty"`
-	WebhookSecret *string    `json:"webhook_secret,omitempty"`
-	PEM           *string    `json:"pem,omitempty"`
-}
-
-// CompleteAppManifest completes the App manifest handshake flow for the given
-// code.
-//
-// GitHub API docs: https://developer.github.com/apps/building-github-apps/creating-github-apps-from-a-manifest/#3-you-exchange-the-temporary-code-to-retrieve-the-app-configuration
-func (s *AppsService) CompleteAppManifest(ctx context.Context, code string) (*AppConfig, *Response, error) {
-	u := fmt.Sprintf("app-manifests/%s/conversions", code)
-	req, err := s.client.NewRequest("POST", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-	req.Header.Set("Accept", mediaTypeAppManifestPreview)
-
-	cfg := new(AppConfig)
-	resp, err := s.client.Do(ctx, req, cfg)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return cfg, resp, nil
-}

vendor/github.com/google/go-github/v29/github/apps_marketplace.go

@@ -1,184 +0,0 @@
-// Copyright 2017 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// MarketplaceService handles communication with the marketplace related
-// methods of the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/marketplace/
-type MarketplaceService struct {
-	client *Client
-	// Stubbed controls whether endpoints that return stubbed data are used
-	// instead of production endpoints. Stubbed data is fake data that's useful
-	// for testing your GitHub Apps. Stubbed data is hard-coded and will not
-	// change based on actual subscriptions.
-	//
-	// GitHub API docs: https://developer.github.com/v3/apps/marketplace/
-	Stubbed bool
-}
-
-// MarketplacePlan represents a GitHub Apps Marketplace Listing Plan.
-type MarketplacePlan struct {
-	URL                 *string `json:"url,omitempty"`
-	AccountsURL         *string `json:"accounts_url,omitempty"`
-	ID                  *int64  `json:"id,omitempty"`
-	Name                *string `json:"name,omitempty"`
-	Description         *string `json:"description,omitempty"`
-	MonthlyPriceInCents *int    `json:"monthly_price_in_cents,omitempty"`
-	YearlyPriceInCents  *int    `json:"yearly_price_in_cents,omitempty"`
-	// The pricing model for this listing.  Can be one of "flat-rate", "per-unit", or "free".
-	PriceModel *string   `json:"price_model,omitempty"`
-	UnitName   *string   `json:"unit_name,omitempty"`
-	Bullets    *[]string `json:"bullets,omitempty"`
-	// State can be one of the values "draft" or "published".
-	State        *string `json:"state,omitempty"`
-	HasFreeTrial *bool   `json:"has_free_trial,omitempty"`
-}
-
-// MarketplacePurchase represents a GitHub Apps Marketplace Purchase.
-type MarketplacePurchase struct {
-	// BillingCycle can be one of the values "yearly", "monthly" or nil.
-	BillingCycle    *string                 `json:"billing_cycle,omitempty"`
-	NextBillingDate *Timestamp              `json:"next_billing_date,omitempty"`
-	UnitCount       *int                    `json:"unit_count,omitempty"`
-	Plan            *MarketplacePlan        `json:"plan,omitempty"`
-	Account         *MarketplacePlanAccount `json:"account,omitempty"`
-	OnFreeTrial     *bool                   `json:"on_free_trial,omitempty"`
-	FreeTrialEndsOn *Timestamp              `json:"free_trial_ends_on,omitempty"`
-}
-
-// MarketplacePendingChange represents a pending change to a GitHub Apps Marketplace Plan.
-type MarketplacePendingChange struct {
-	EffectiveDate *Timestamp       `json:"effective_date,omitempty"`
-	UnitCount     *int             `json:"unit_count,omitempty"`
-	ID            *int64           `json:"id,omitempty"`
-	Plan          *MarketplacePlan `json:"plan,omitempty"`
-}
-
-// MarketplacePlanAccount represents a GitHub Account (user or organization) on a specific plan.
-type MarketplacePlanAccount struct {
-	URL                      *string                   `json:"url,omitempty"`
-	Type                     *string                   `json:"type,omitempty"`
-	ID                       *int64                    `json:"id,omitempty"`
-	NodeID                   *string                   `json:"node_id,omitempty"`
-	Login                    *string                   `json:"login,omitempty"`
-	Email                    *string                   `json:"email,omitempty"`
-	OrganizationBillingEmail *string                   `json:"organization_billing_email,omitempty"`
-	MarketplacePurchase      *MarketplacePurchase      `json:"marketplace_purchase,omitempty"`
-	MarketplacePendingChange *MarketplacePendingChange `json:"marketplace_pending_change,omitempty"`
-}
-
-// ListPlans lists all plans for your Marketplace listing.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/marketplace/#list-all-plans-for-your-marketplace-listing
-func (s *MarketplaceService) ListPlans(ctx context.Context, opts *ListOptions) ([]*MarketplacePlan, *Response, error) {
-	uri := s.marketplaceURI("plans")
-	u, err := addOptions(uri, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var plans []*MarketplacePlan
-	resp, err := s.client.Do(ctx, req, &plans)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return plans, resp, nil
-}
-
-// ListPlanAccountsForPlan lists all GitHub accounts (user or organization) on a specific plan.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/marketplace/#list-all-github-accounts-user-or-organization-on-a-specific-plan
-func (s *MarketplaceService) ListPlanAccountsForPlan(ctx context.Context, planID int64, opts *ListOptions) ([]*MarketplacePlanAccount, *Response, error) {
-	uri := s.marketplaceURI(fmt.Sprintf("plans/%v/accounts", planID))
-	u, err := addOptions(uri, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var accounts []*MarketplacePlanAccount
-	resp, err := s.client.Do(ctx, req, &accounts)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return accounts, resp, nil
-}
-
-// ListPlanAccountsForAccount lists all GitHub accounts (user or organization) associated with an account.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/marketplace/#check-if-a-github-account-is-associated-with-any-marketplace-listing
-func (s *MarketplaceService) ListPlanAccountsForAccount(ctx context.Context, accountID int64, opts *ListOptions) ([]*MarketplacePlanAccount, *Response, error) {
-	uri := s.marketplaceURI(fmt.Sprintf("accounts/%v", accountID))
-	u, err := addOptions(uri, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var accounts []*MarketplacePlanAccount
-	resp, err := s.client.Do(ctx, req, &accounts)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return accounts, resp, nil
-}
-
-// ListMarketplacePurchasesForUser lists all GitHub marketplace purchases made by a user.
-//
-// GitHub API docs: https://developer.github.com/v3/apps/marketplace/#get-a-users-marketplace-purchases
-func (s *MarketplaceService) ListMarketplacePurchasesForUser(ctx context.Context, opts *ListOptions) ([]*MarketplacePurchase, *Response, error) {
-	uri := "user/marketplace_purchases"
-	if s.Stubbed {
-		uri = "user/marketplace_purchases/stubbed"
-	}
-
-	u, err := addOptions(uri, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var purchases []*MarketplacePurchase
-	resp, err := s.client.Do(ctx, req, &purchases)
-	if err != nil {
-		return nil, resp, err
-	}
-	return purchases, resp, nil
-}
-
-func (s *MarketplaceService) marketplaceURI(endpoint string) string {
-	url := "marketplace_listing"
-	if s.Stubbed {
-		url = "marketplace_listing/stubbed"
-	}
-	return url + "/" + endpoint
-}

vendor/github.com/google/go-github/v29/github/authorizations.go

@@ -1,435 +0,0 @@
-// Copyright 2015 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-)
-
-// Scope models a GitHub authorization scope.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth/#scopes
-type Scope string
-
-// This is the set of scopes for GitHub API V3
-const (
-	ScopeNone           Scope = "(no scope)" // REVISIT: is this actually returned, or just a documentation artifact?
-	ScopeUser           Scope = "user"
-	ScopeUserEmail      Scope = "user:email"
-	ScopeUserFollow     Scope = "user:follow"
-	ScopePublicRepo     Scope = "public_repo"
-	ScopeRepo           Scope = "repo"
-	ScopeRepoDeployment Scope = "repo_deployment"
-	ScopeRepoStatus     Scope = "repo:status"
-	ScopeDeleteRepo     Scope = "delete_repo"
-	ScopeNotifications  Scope = "notifications"
-	ScopeGist           Scope = "gist"
-	ScopeReadRepoHook   Scope = "read:repo_hook"
-	ScopeWriteRepoHook  Scope = "write:repo_hook"
-	ScopeAdminRepoHook  Scope = "admin:repo_hook"
-	ScopeAdminOrgHook   Scope = "admin:org_hook"
-	ScopeReadOrg        Scope = "read:org"
-	ScopeWriteOrg       Scope = "write:org"
-	ScopeAdminOrg       Scope = "admin:org"
-	ScopeReadPublicKey  Scope = "read:public_key"
-	ScopeWritePublicKey Scope = "write:public_key"
-	ScopeAdminPublicKey Scope = "admin:public_key"
-	ScopeReadGPGKey     Scope = "read:gpg_key"
-	ScopeWriteGPGKey    Scope = "write:gpg_key"
-	ScopeAdminGPGKey    Scope = "admin:gpg_key"
-)
-
-// AuthorizationsService handles communication with the authorization related
-// methods of the GitHub API.
-//
-// This service requires HTTP Basic Authentication; it cannot be accessed using
-// an OAuth token.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/
-type AuthorizationsService service
-
-// Authorization represents an individual GitHub authorization.
-type Authorization struct {
-	ID             *int64            `json:"id,omitempty"`
-	URL            *string           `json:"url,omitempty"`
-	Scopes         []Scope           `json:"scopes,omitempty"`
-	Token          *string           `json:"token,omitempty"`
-	TokenLastEight *string           `json:"token_last_eight,omitempty"`
-	HashedToken    *string           `json:"hashed_token,omitempty"`
-	App            *AuthorizationApp `json:"app,omitempty"`
-	Note           *string           `json:"note,omitempty"`
-	NoteURL        *string           `json:"note_url,omitempty"`
-	UpdatedAt      *Timestamp        `json:"updated_at,omitempty"`
-	CreatedAt      *Timestamp        `json:"created_at,omitempty"`
-	Fingerprint    *string           `json:"fingerprint,omitempty"`
-
-	// User is only populated by the Check and Reset methods.
-	User *User `json:"user,omitempty"`
-}
-
-func (a Authorization) String() string {
-	return Stringify(a)
-}
-
-// AuthorizationApp represents an individual GitHub app (in the context of authorization).
-type AuthorizationApp struct {
-	URL      *string `json:"url,omitempty"`
-	Name     *string `json:"name,omitempty"`
-	ClientID *string `json:"client_id,omitempty"`
-}
-
-func (a AuthorizationApp) String() string {
-	return Stringify(a)
-}
-
-// Grant represents an OAuth application that has been granted access to an account.
-type Grant struct {
-	ID        *int64            `json:"id,omitempty"`
-	URL       *string           `json:"url,omitempty"`
-	App       *AuthorizationApp `json:"app,omitempty"`
-	CreatedAt *Timestamp        `json:"created_at,omitempty"`
-	UpdatedAt *Timestamp        `json:"updated_at,omitempty"`
-	Scopes    []string          `json:"scopes,omitempty"`
-}
-
-func (g Grant) String() string {
-	return Stringify(g)
-}
-
-// AuthorizationRequest represents a request to create an authorization.
-type AuthorizationRequest struct {
-	Scopes       []Scope `json:"scopes,omitempty"`
-	Note         *string `json:"note,omitempty"`
-	NoteURL      *string `json:"note_url,omitempty"`
-	ClientID     *string `json:"client_id,omitempty"`
-	ClientSecret *string `json:"client_secret,omitempty"`
-	Fingerprint  *string `json:"fingerprint,omitempty"`
-}
-
-func (a AuthorizationRequest) String() string {
-	return Stringify(a)
-}
-
-// AuthorizationUpdateRequest represents a request to update an authorization.
-//
-// Note that for any one update, you must only provide one of the "scopes"
-// fields. That is, you may provide only one of "Scopes", or "AddScopes", or
-// "RemoveScopes".
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
-type AuthorizationUpdateRequest struct {
-	Scopes       []string `json:"scopes,omitempty"`
-	AddScopes    []string `json:"add_scopes,omitempty"`
-	RemoveScopes []string `json:"remove_scopes,omitempty"`
-	Note         *string  `json:"note,omitempty"`
-	NoteURL      *string  `json:"note_url,omitempty"`
-	Fingerprint  *string  `json:"fingerprint,omitempty"`
-}
-
-func (a AuthorizationUpdateRequest) String() string {
-	return Stringify(a)
-}
-
-// List the authorizations for the authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations
-func (s *AuthorizationsService) List(ctx context.Context, opts *ListOptions) ([]*Authorization, *Response, error) {
-	u := "authorizations"
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var auths []*Authorization
-	resp, err := s.client.Do(ctx, req, &auths)
-	if err != nil {
-		return nil, resp, err
-	}
-	return auths, resp, nil
-}
-
-// Get a single authorization.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization
-func (s *AuthorizationsService) Get(ctx context.Context, id int64) (*Authorization, *Response, error) {
-	u := fmt.Sprintf("authorizations/%d", id)
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-	return a, resp, nil
-}
-
-// Create a new authorization for the specified OAuth application.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization
-func (s *AuthorizationsService) Create(ctx context.Context, auth *AuthorizationRequest) (*Authorization, *Response, error) {
-	u := "authorizations"
-
-	req, err := s.client.NewRequest("POST", u, auth)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-	return a, resp, nil
-}
-
-// GetOrCreateForApp creates a new authorization for the specified OAuth
-// application, only if an authorization for that application doesn’t already
-// exist for the user.
-//
-// If a new token is created, the HTTP status code will be "201 Created", and
-// the returned Authorization.Token field will be populated. If an existing
-// token is returned, the status code will be "200 OK" and the
-// Authorization.Token field will be empty.
-//
-// clientID is the OAuth Client ID with which to create the token.
-//
-// GitHub API docs:
-// https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
-// https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app-and-fingerprint
-func (s *AuthorizationsService) GetOrCreateForApp(ctx context.Context, clientID string, auth *AuthorizationRequest) (*Authorization, *Response, error) {
-	var u string
-	if auth.Fingerprint == nil || *auth.Fingerprint == "" {
-		u = fmt.Sprintf("authorizations/clients/%v", clientID)
-	} else {
-		u = fmt.Sprintf("authorizations/clients/%v/%v", clientID, *auth.Fingerprint)
-	}
-
-	req, err := s.client.NewRequest("PUT", u, auth)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return a, resp, nil
-}
-
-// Edit a single authorization.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
-func (s *AuthorizationsService) Edit(ctx context.Context, id int64, auth *AuthorizationUpdateRequest) (*Authorization, *Response, error) {
-	u := fmt.Sprintf("authorizations/%d", id)
-
-	req, err := s.client.NewRequest("PATCH", u, auth)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return a, resp, nil
-}
-
-// Delete a single authorization.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization
-func (s *AuthorizationsService) Delete(ctx context.Context, id int64) (*Response, error) {
-	u := fmt.Sprintf("authorizations/%d", id)
-
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// Check if an OAuth token is valid for a specific app.
-//
-// Note that this operation requires the use of BasicAuth, but where the
-// username is the OAuth application clientID, and the password is its
-// clientSecret. Invalid tokens will return a 404 Not Found.
-//
-// The returned Authorization.User field will be populated.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#check-an-authorization
-func (s *AuthorizationsService) Check(ctx context.Context, clientID string, token string) (*Authorization, *Response, error) {
-	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return a, resp, nil
-}
-
-// Reset is used to reset a valid OAuth token without end user involvement.
-// Applications must save the "token" property in the response, because changes
-// take effect immediately.
-//
-// Note that this operation requires the use of BasicAuth, but where the
-// username is the OAuth application clientID, and the password is its
-// clientSecret. Invalid tokens will return a 404 Not Found.
-//
-// The returned Authorization.User field will be populated.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization
-func (s *AuthorizationsService) Reset(ctx context.Context, clientID string, token string) (*Authorization, *Response, error) {
-	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
-
-	req, err := s.client.NewRequest("POST", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return a, resp, nil
-}
-
-// Revoke an authorization for an application.
-//
-// Note that this operation requires the use of BasicAuth, but where the
-// username is the OAuth application clientID, and the password is its
-// clientSecret. Invalid tokens will return a 404 Not Found.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application
-func (s *AuthorizationsService) Revoke(ctx context.Context, clientID string, token string) (*Response, error) {
-	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
-
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// ListGrants lists the set of OAuth applications that have been granted
-// access to a user's account. This will return one entry for each application
-// that has been granted access to the account, regardless of the number of
-// tokens an application has generated for the user.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#list-your-grants
-func (s *AuthorizationsService) ListGrants(ctx context.Context, opts *ListOptions) ([]*Grant, *Response, error) {
-	u, err := addOptions("applications/grants", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	grants := []*Grant{}
-	resp, err := s.client.Do(ctx, req, &grants)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return grants, resp, nil
-}
-
-// GetGrant gets a single OAuth application grant.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#get-a-single-grant
-func (s *AuthorizationsService) GetGrant(ctx context.Context, id int64) (*Grant, *Response, error) {
-	u := fmt.Sprintf("applications/grants/%d", id)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	grant := new(Grant)
-	resp, err := s.client.Do(ctx, req, grant)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return grant, resp, nil
-}
-
-// DeleteGrant deletes an OAuth application grant. Deleting an application's
-// grant will also delete all OAuth tokens associated with the application for
-// the user.
-//
-// GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#delete-a-grant
-func (s *AuthorizationsService) DeleteGrant(ctx context.Context, id int64) (*Response, error) {
-	u := fmt.Sprintf("applications/grants/%d", id)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}
-
-// CreateImpersonation creates an impersonation OAuth token.
-//
-// This requires admin permissions. With the returned Authorization.Token
-// you can e.g. create or delete a user's public SSH key. NOTE: creating a
-// new token automatically revokes an existing one.
-//
-// GitHub API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#create-an-impersonation-oauth-token
-func (s *AuthorizationsService) CreateImpersonation(ctx context.Context, username string, authReq *AuthorizationRequest) (*Authorization, *Response, error) {
-	u := fmt.Sprintf("admin/users/%v/authorizations", username)
-	req, err := s.client.NewRequest("POST", u, authReq)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	a := new(Authorization)
-	resp, err := s.client.Do(ctx, req, a)
-	if err != nil {
-		return nil, resp, err
-	}
-	return a, resp, nil
-}
-
-// DeleteImpersonation deletes an impersonation OAuth token.
-//
-// NOTE: there can be only one at a time.
-//
-// GitHub API docs: https://developer.github.com/enterprise/v3/enterprise-admin/users/#delete-an-impersonation-oauth-token
-func (s *AuthorizationsService) DeleteImpersonation(ctx context.Context, username string) (*Response, error) {
-	u := fmt.Sprintf("admin/users/%v/authorizations", username)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/checks.go

@@ -1,434 +0,0 @@
-// Copyright 2018 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"net/url"
-)
-
-// ChecksService provides access to the Checks API in the
-// GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/
-type ChecksService service
-
-// CheckRun represents a GitHub check run on a repository associated with a GitHub app.
-type CheckRun struct {
-	ID           *int64          `json:"id,omitempty"`
-	NodeID       *string         `json:"node_id,omitempty"`
-	HeadSHA      *string         `json:"head_sha,omitempty"`
-	ExternalID   *string         `json:"external_id,omitempty"`
-	URL          *string         `json:"url,omitempty"`
-	HTMLURL      *string         `json:"html_url,omitempty"`
-	DetailsURL   *string         `json:"details_url,omitempty"`
-	Status       *string         `json:"status,omitempty"`
-	Conclusion   *string         `json:"conclusion,omitempty"`
-	StartedAt    *Timestamp      `json:"started_at,omitempty"`
-	CompletedAt  *Timestamp      `json:"completed_at,omitempty"`
-	Output       *CheckRunOutput `json:"output,omitempty"`
-	Name         *string         `json:"name,omitempty"`
-	CheckSuite   *CheckSuite     `json:"check_suite,omitempty"`
-	App          *App            `json:"app,omitempty"`
-	PullRequests []*PullRequest  `json:"pull_requests,omitempty"`
-}
-
-// CheckRunOutput represents the output of a CheckRun.
-type CheckRunOutput struct {
-	Title            *string               `json:"title,omitempty"`
-	Summary          *string               `json:"summary,omitempty"`
-	Text             *string               `json:"text,omitempty"`
-	AnnotationsCount *int                  `json:"annotations_count,omitempty"`
-	AnnotationsURL   *string               `json:"annotations_url,omitempty"`
-	Annotations      []*CheckRunAnnotation `json:"annotations,omitempty"`
-	Images           []*CheckRunImage      `json:"images,omitempty"`
-}
-
-// CheckRunAnnotation represents an annotation object for a CheckRun output.
-type CheckRunAnnotation struct {
-	Path            *string `json:"path,omitempty"`
-	StartLine       *int    `json:"start_line,omitempty"`
-	EndLine         *int    `json:"end_line,omitempty"`
-	StartColumn     *int    `json:"start_column,omitempty"`
-	EndColumn       *int    `json:"end_column,omitempty"`
-	AnnotationLevel *string `json:"annotation_level,omitempty"`
-	Message         *string `json:"message,omitempty"`
-	Title           *string `json:"title,omitempty"`
-	RawDetails      *string `json:"raw_details,omitempty"`
-}
-
-// CheckRunImage represents an image object for a CheckRun output.
-type CheckRunImage struct {
-	Alt      *string `json:"alt,omitempty"`
-	ImageURL *string `json:"image_url,omitempty"`
-	Caption  *string `json:"caption,omitempty"`
-}
-
-// CheckSuite represents a suite of check runs.
-type CheckSuite struct {
-	ID           *int64         `json:"id,omitempty"`
-	NodeID       *string        `json:"node_id,omitempty"`
-	HeadBranch   *string        `json:"head_branch,omitempty"`
-	HeadSHA      *string        `json:"head_sha,omitempty"`
-	URL          *string        `json:"url,omitempty"`
-	BeforeSHA    *string        `json:"before,omitempty"`
-	AfterSHA     *string        `json:"after,omitempty"`
-	Status       *string        `json:"status,omitempty"`
-	Conclusion   *string        `json:"conclusion,omitempty"`
-	App          *App           `json:"app,omitempty"`
-	Repository   *Repository    `json:"repository,omitempty"`
-	PullRequests []*PullRequest `json:"pull_requests,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	HeadCommit *Commit `json:"head_commit,omitempty"`
-}
-
-func (c CheckRun) String() string {
-	return Stringify(c)
-}
-
-func (c CheckSuite) String() string {
-	return Stringify(c)
-}
-
-// GetCheckRun gets a check-run for a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#get-a-single-check-run
-func (s *ChecksService) GetCheckRun(ctx context.Context, owner, repo string, checkRunID int64) (*CheckRun, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-runs/%v", owner, repo, checkRunID)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	checkRun := new(CheckRun)
-	resp, err := s.client.Do(ctx, req, checkRun)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRun, resp, nil
-}
-
-// GetCheckSuite gets a single check suite.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/suites/#get-a-single-check-suite
-func (s *ChecksService) GetCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64) (*CheckSuite, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-suites/%v", owner, repo, checkSuiteID)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	checkSuite := new(CheckSuite)
-	resp, err := s.client.Do(ctx, req, checkSuite)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkSuite, resp, nil
-}
-
-// CreateCheckRunOptions sets up parameters needed to create a CheckRun.
-type CreateCheckRunOptions struct {
-	Name        string            `json:"name"`                   // The name of the check (e.g., "code-coverage"). (Required.)
-	HeadSHA     string            `json:"head_sha"`               // The SHA of the commit. (Required.)
-	DetailsURL  *string           `json:"details_url,omitempty"`  // The URL of the integrator's site that has the full details of the check. (Optional.)
-	ExternalID  *string           `json:"external_id,omitempty"`  // A reference for the run on the integrator's system. (Optional.)
-	Status      *string           `json:"status,omitempty"`       // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
-	Conclusion  *string           `json:"conclusion,omitempty"`   // Can be one of "success", "failure", "neutral", "cancelled", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
-	StartedAt   *Timestamp        `json:"started_at,omitempty"`   // The time that the check run began. (Optional.)
-	CompletedAt *Timestamp        `json:"completed_at,omitempty"` // The time the check completed. (Optional. Required if you provide conclusion.)
-	Output      *CheckRunOutput   `json:"output,omitempty"`       // Provide descriptive details about the run. (Optional)
-	Actions     []*CheckRunAction `json:"actions,omitempty"`      // Possible further actions the integrator can perform, which a user may trigger. (Optional.)
-}
-
-// CheckRunAction exposes further actions the integrator can perform, which a user may trigger.
-type CheckRunAction struct {
-	Label       string `json:"label"`       // The text to be displayed on a button in the web UI. The maximum size is 20 characters. (Required.)
-	Description string `json:"description"` // A short explanation of what this action would do. The maximum size is 40 characters. (Required.)
-	Identifier  string `json:"identifier"`  // A reference for the action on the integrator's system. The maximum size is 20 characters. (Required.)
-}
-
-// CreateCheckRun creates a check run for repository.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#create-a-check-run
-func (s *ChecksService) CreateCheckRun(ctx context.Context, owner, repo string, opts CreateCheckRunOptions) (*CheckRun, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-runs", owner, repo)
-	req, err := s.client.NewRequest("POST", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	checkRun := new(CheckRun)
-	resp, err := s.client.Do(ctx, req, checkRun)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRun, resp, nil
-}
-
-// UpdateCheckRunOptions sets up parameters needed to update a CheckRun.
-type UpdateCheckRunOptions struct {
-	Name        string            `json:"name"`                   // The name of the check (e.g., "code-coverage"). (Required.)
-	HeadSHA     *string           `json:"head_sha,omitempty"`     // The SHA of the commit. (Optional.)
-	DetailsURL  *string           `json:"details_url,omitempty"`  // The URL of the integrator's site that has the full details of the check. (Optional.)
-	ExternalID  *string           `json:"external_id,omitempty"`  // A reference for the run on the integrator's system. (Optional.)
-	Status      *string           `json:"status,omitempty"`       // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
-	Conclusion  *string           `json:"conclusion,omitempty"`   // Can be one of "success", "failure", "neutral", "cancelled", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
-	CompletedAt *Timestamp        `json:"completed_at,omitempty"` // The time the check completed. (Optional. Required if you provide conclusion.)
-	Output      *CheckRunOutput   `json:"output,omitempty"`       // Provide descriptive details about the run. (Optional)
-	Actions     []*CheckRunAction `json:"actions,omitempty"`      // Possible further actions the integrator can perform, which a user may trigger. (Optional.)
-}
-
-// UpdateCheckRun updates a check run for a specific commit in a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#update-a-check-run
-func (s *ChecksService) UpdateCheckRun(ctx context.Context, owner, repo string, checkRunID int64, opts UpdateCheckRunOptions) (*CheckRun, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-runs/%v", owner, repo, checkRunID)
-	req, err := s.client.NewRequest("PATCH", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	checkRun := new(CheckRun)
-	resp, err := s.client.Do(ctx, req, checkRun)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRun, resp, nil
-}
-
-// ListCheckRunAnnotations lists the annotations for a check run.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#list-annotations-for-a-check-run
-func (s *ChecksService) ListCheckRunAnnotations(ctx context.Context, owner, repo string, checkRunID int64, opts *ListOptions) ([]*CheckRunAnnotation, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-runs/%v/annotations", owner, repo, checkRunID)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	var checkRunAnnotations []*CheckRunAnnotation
-	resp, err := s.client.Do(ctx, req, &checkRunAnnotations)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRunAnnotations, resp, nil
-}
-
-// ListCheckRunsOptions represents parameters to list check runs.
-type ListCheckRunsOptions struct {
-	CheckName *string `url:"check_name,omitempty"` // Returns check runs with the specified name.
-	Status    *string `url:"status,omitempty"`     // Returns check runs with the specified status. Can be one of "queued", "in_progress", or "completed".
-	Filter    *string `url:"filter,omitempty"`     // Filters check runs by their completed_at timestamp. Can be one of "latest" (returning the most recent check runs) or "all". Default: "latest"
-
-	ListOptions
-}
-
-// ListCheckRunsResults represents the result of a check run list.
-type ListCheckRunsResults struct {
-	Total     *int        `json:"total_count,omitempty"`
-	CheckRuns []*CheckRun `json:"check_runs,omitempty"`
-}
-
-// ListCheckRunsForRef lists check runs for a specific ref.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#list-check-runs-for-a-specific-ref
-func (s *ChecksService) ListCheckRunsForRef(ctx context.Context, owner, repo, ref string, opts *ListCheckRunsOptions) (*ListCheckRunsResults, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/commits/%v/check-runs", owner, repo, url.QueryEscape(ref))
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	var checkRunResults *ListCheckRunsResults
-	resp, err := s.client.Do(ctx, req, &checkRunResults)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRunResults, resp, nil
-}
-
-// ListCheckRunsCheckSuite lists check runs for a check suite.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/runs/#list-check-runs-in-a-check-suite
-func (s *ChecksService) ListCheckRunsCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64, opts *ListCheckRunsOptions) (*ListCheckRunsResults, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-suites/%v/check-runs", owner, repo, checkSuiteID)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	var checkRunResults *ListCheckRunsResults
-	resp, err := s.client.Do(ctx, req, &checkRunResults)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkRunResults, resp, nil
-}
-
-// ListCheckSuiteOptions represents parameters to list check suites.
-type ListCheckSuiteOptions struct {
-	CheckName *string `url:"check_name,omitempty"` // Filters checks suites by the name of the check run.
-	AppID     *int    `url:"app_id,omitempty"`     // Filters check suites by GitHub App id.
-
-	ListOptions
-}
-
-// ListCheckSuiteResults represents the result of a check run list.
-type ListCheckSuiteResults struct {
-	Total       *int          `json:"total_count,omitempty"`
-	CheckSuites []*CheckSuite `json:"check_suites,omitempty"`
-}
-
-// ListCheckSuitesForRef lists check suite for a specific ref.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/suites/#list-check-suites-for-a-specific-ref
-func (s *ChecksService) ListCheckSuitesForRef(ctx context.Context, owner, repo, ref string, opts *ListCheckSuiteOptions) (*ListCheckSuiteResults, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/commits/%v/check-suites", owner, repo, url.QueryEscape(ref))
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	var checkSuiteResults *ListCheckSuiteResults
-	resp, err := s.client.Do(ctx, req, &checkSuiteResults)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkSuiteResults, resp, nil
-}
-
-// AutoTriggerCheck enables or disables automatic creation of CheckSuite events upon pushes to the repository.
-type AutoTriggerCheck struct {
-	AppID   *int64 `json:"app_id,omitempty"`  // The id of the GitHub App. (Required.)
-	Setting *bool  `json:"setting,omitempty"` // Set to "true" to enable automatic creation of CheckSuite events upon pushes to the repository, or "false" to disable them. Default: "true" (Required.)
-}
-
-// CheckSuitePreferenceOptions set options for check suite preferences for a repository.
-type CheckSuitePreferenceOptions struct {
-	AutoTriggerChecks []*AutoTriggerCheck `json:"auto_trigger_checks,omitempty"` // A slice of auto trigger checks that can be set for a check suite in a repository.
-}
-
-// CheckSuitePreferenceResults represents the results of the preference set operation.
-type CheckSuitePreferenceResults struct {
-	Preferences *PreferenceList `json:"preferences,omitempty"`
-	Repository  *Repository     `json:"repository,omitempty"`
-}
-
-// PreferenceList represents a list of auto trigger checks for repository
-type PreferenceList struct {
-	AutoTriggerChecks []*AutoTriggerCheck `json:"auto_trigger_checks,omitempty"` // A slice of auto trigger checks that can be set for a check suite in a repository.
-}
-
-// SetCheckSuitePreferences changes the default automatic flow when creating check suites.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/suites/#set-preferences-for-check-suites-on-a-repository
-func (s *ChecksService) SetCheckSuitePreferences(ctx context.Context, owner, repo string, opts CheckSuitePreferenceOptions) (*CheckSuitePreferenceResults, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-suites/preferences", owner, repo)
-	req, err := s.client.NewRequest("PATCH", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	var checkSuitePrefResults *CheckSuitePreferenceResults
-	resp, err := s.client.Do(ctx, req, &checkSuitePrefResults)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkSuitePrefResults, resp, nil
-}
-
-// CreateCheckSuiteOptions sets up parameters to manually create a check suites
-type CreateCheckSuiteOptions struct {
-	HeadSHA    string  `json:"head_sha"`              // The sha of the head commit. (Required.)
-	HeadBranch *string `json:"head_branch,omitempty"` // The name of the head branch where the code changes are implemented.
-}
-
-// CreateCheckSuite manually creates a check suite for a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/suites/#create-a-check-suite
-func (s *ChecksService) CreateCheckSuite(ctx context.Context, owner, repo string, opts CreateCheckSuiteOptions) (*CheckSuite, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-suites", owner, repo)
-	req, err := s.client.NewRequest("POST", u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	checkSuite := new(CheckSuite)
-	resp, err := s.client.Do(ctx, req, checkSuite)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return checkSuite, resp, nil
-}
-
-// ReRequestCheckSuite triggers GitHub to rerequest an existing check suite, without pushing new code to a repository.
-//
-// GitHub API docs: https://developer.github.com/v3/checks/suites/#rerequest-check-suite
-func (s *ChecksService) ReRequestCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64) (*Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-suites/%v/rerequest", owner, repo, checkSuiteID)
-
-	req, err := s.client.NewRequest("POST", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
-
-	resp, err := s.client.Do(ctx, req, nil)
-	return resp, err
-}

vendor/github.com/google/go-github/v29/github/doc.go

@@ -1,188 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Package github provides a client for using the GitHub API.
-
-Usage:
-
-	import "github.com/google/go-github/v29/github"	// with go modules enabled (GO111MODULE=on or outside GOPATH)
-	import "github.com/google/go-github/github"     // with go modules disabled
-
-Construct a new GitHub client, then use the various services on the client to
-access different parts of the GitHub API. For example:
-
-	client := github.NewClient(nil)
-
-	// list all organizations for user "willnorris"
-	orgs, _, err := client.Organizations.List(ctx, "willnorris", nil)
-
-Some API methods have optional parameters that can be passed. For example:
-
-	client := github.NewClient(nil)
-
-	// list public repositories for org "github"
-	opt := &github.RepositoryListByOrgOptions{Type: "public"}
-	repos, _, err := client.Repositories.ListByOrg(ctx, "github", opt)
-
-The services of a client divide the API into logical chunks and correspond to
-the structure of the GitHub API documentation at
-https://developer.github.com/v3/.
-
-NOTE: Using the https://godoc.org/context package, one can easily
-pass cancelation signals and deadlines to various services of the client for
-handling a request. In case there is no context available, then context.Background()
-can be used as a starting point.
-
-For more sample code snippets, head over to the https://github.com/google/go-github/tree/master/example directory.
-
-Authentication
-
-The go-github library does not directly handle authentication. Instead, when
-creating a new client, pass an http.Client that can handle authentication for
-you. The easiest and recommended way to do this is using the golang.org/x/oauth2
-library, but you can always use any other library that provides an http.Client.
-If you have an OAuth2 access token (for example, a personal API token), you can
-use it with the oauth2 library using:
-
-	import "golang.org/x/oauth2"
-
-	func main() {
-		ctx := context.Background()
-		ts := oauth2.StaticTokenSource(
-			&oauth2.Token{AccessToken: "... your access token ..."},
-		)
-		tc := oauth2.NewClient(ctx, ts)
-
-		client := github.NewClient(tc)
-
-		// list all repositories for the authenticated user
-		repos, _, err := client.Repositories.List(ctx, "", nil)
-	}
-
-Note that when using an authenticated Client, all calls made by the client will
-include the specified OAuth token. Therefore, authenticated clients should
-almost never be shared between different users.
-
-See the oauth2 docs for complete instructions on using that library.
-
-For API methods that require HTTP Basic Authentication, use the
-BasicAuthTransport.
-
-GitHub Apps authentication can be provided by the
-https://github.com/bradleyfalzon/ghinstallation package.
-
-	import "github.com/bradleyfalzon/ghinstallation"
-
-	func main() {
-		// Wrap the shared transport for use with the integration ID 1 authenticating with installation ID 99.
-		itr, err := ghinstallation.NewKeyFromFile(http.DefaultTransport, 1, 99, "2016-10-19.private-key.pem")
-		if err != nil {
-			// Handle error.
-		}
-
-		// Use installation transport with client
-		client := github.NewClient(&http.Client{Transport: itr})
-
-		// Use client...
-	}
-
-Rate Limiting
-
-GitHub imposes a rate limit on all API clients. Unauthenticated clients are
-limited to 60 requests per hour, while authenticated clients can make up to
-5,000 requests per hour. The Search API has a custom rate limit. Unauthenticated
-clients are limited to 10 requests per minute, while authenticated clients
-can make up to 30 requests per minute. To receive the higher rate limit when
-making calls that are not issued on behalf of a user,
-use UnauthenticatedRateLimitedTransport.
-
-The returned Response.Rate value contains the rate limit information
-from the most recent API call. If a recent enough response isn't
-available, you can use RateLimits to fetch the most up-to-date rate
-limit data for the client.
-
-To detect an API rate limit error, you can check if its type is *github.RateLimitError:
-
-	repos, _, err := client.Repositories.List(ctx, "", nil)
-	if _, ok := err.(*github.RateLimitError); ok {
-		log.Println("hit rate limit")
-	}
-
-Learn more about GitHub rate limiting at
-https://developer.github.com/v3/#rate-limiting.
-
-Accepted Status
-
-Some endpoints may return a 202 Accepted status code, meaning that the
-information required is not yet ready and was scheduled to be gathered on
-the GitHub side. Methods known to behave like this are documented specifying
-this behavior.
-
-To detect this condition of error, you can check if its type is
-*github.AcceptedError:
-
-	stats, _, err := client.Repositories.ListContributorsStats(ctx, org, repo)
-	if _, ok := err.(*github.AcceptedError); ok {
-		log.Println("scheduled on GitHub side")
-	}
-
-Conditional Requests
-
-The GitHub API has good support for conditional requests which will help
-prevent you from burning through your rate limit, as well as help speed up your
-application. go-github does not handle conditional requests directly, but is
-instead designed to work with a caching http.Transport. We recommend using
-https://github.com/gregjones/httpcache for that.
-
-Learn more about GitHub conditional requests at
-https://developer.github.com/v3/#conditional-requests.
-
-Creating and Updating Resources
-
-All structs for GitHub resources use pointer values for all non-repeated fields.
-This allows distinguishing between unset fields and those set to a zero-value.
-Helper functions have been provided to easily create these pointers for string,
-bool, and int values. For example:
-
-	// create a new private repository named "foo"
-	repo := &github.Repository{
-		Name:    github.String("foo"),
-		Private: github.Bool(true),
-	}
-	client.Repositories.Create(ctx, "", repo)
-
-Users who have worked with protocol buffers should find this pattern familiar.
-
-Pagination
-
-All requests for resource collections (repos, pull requests, issues, etc.)
-support pagination. Pagination options are described in the
-github.ListOptions struct and passed to the list methods directly or as an
-embedded type of a more specific list options struct (for example
-github.PullRequestListOptions). Pages information is available via the
-github.Response struct.
-
-	client := github.NewClient(nil)
-
-	opt := &github.RepositoryListByOrgOptions{
-		ListOptions: github.ListOptions{PerPage: 10},
-	}
-	// get all pages of results
-	var allRepos []*github.Repository
-	for {
-		repos, resp, err := client.Repositories.ListByOrg(ctx, "github", opt)
-		if err != nil {
-			return err
-		}
-		allRepos = append(allRepos, repos...)
-		if resp.NextPage == 0 {
-			break
-		}
-		opt.Page = resp.NextPage
-	}
-
-*/
-package github

vendor/github.com/google/go-github/v29/github/event.go

@@ -1,136 +0,0 @@
-// Copyright 2018 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"encoding/json"
-	"time"
-)
-
-// Event represents a GitHub event.
-type Event struct {
-	Type       *string          `json:"type,omitempty"`
-	Public     *bool            `json:"public,omitempty"`
-	RawPayload *json.RawMessage `json:"payload,omitempty"`
-	Repo       *Repository      `json:"repo,omitempty"`
-	Actor      *User            `json:"actor,omitempty"`
-	Org        *Organization    `json:"org,omitempty"`
-	CreatedAt  *time.Time       `json:"created_at,omitempty"`
-	ID         *string          `json:"id,omitempty"`
-}
-
-func (e Event) String() string {
-	return Stringify(e)
-}
-
-// ParsePayload parses the event payload. For recognized event types,
-// a value of the corresponding struct type will be returned.
-func (e *Event) ParsePayload() (payload interface{}, err error) {
-	switch *e.Type {
-	case "CheckRunEvent":
-		payload = &CheckRunEvent{}
-	case "CheckSuiteEvent":
-		payload = &CheckSuiteEvent{}
-	case "CommitCommentEvent":
-		payload = &CommitCommentEvent{}
-	case "CreateEvent":
-		payload = &CreateEvent{}
-	case "DeleteEvent":
-		payload = &DeleteEvent{}
-	case "DeployKeyEvent":
-		payload = &DeployKeyEvent{}
-	case "DeploymentEvent":
-		payload = &DeploymentEvent{}
-	case "DeploymentStatusEvent":
-		payload = &DeploymentStatusEvent{}
-	case "ForkEvent":
-		payload = &ForkEvent{}
-	case "GitHubAppAuthorizationEvent":
-		payload = &GitHubAppAuthorizationEvent{}
-	case "GollumEvent":
-		payload = &GollumEvent{}
-	case "InstallationEvent":
-		payload = &InstallationEvent{}
-	case "InstallationRepositoriesEvent":
-		payload = &InstallationRepositoriesEvent{}
-	case "IssueCommentEvent":
-		payload = &IssueCommentEvent{}
-	case "IssuesEvent":
-		payload = &IssuesEvent{}
-	case "LabelEvent":
-		payload = &LabelEvent{}
-	case "MarketplacePurchaseEvent":
-		payload = &MarketplacePurchaseEvent{}
-	case "MemberEvent":
-		payload = &MemberEvent{}
-	case "MembershipEvent":
-		payload = &MembershipEvent{}
-	case "MetaEvent":
-		payload = &MetaEvent{}
-	case "MilestoneEvent":
-		payload = &MilestoneEvent{}
-	case "OrganizationEvent":
-		payload = &OrganizationEvent{}
-	case "OrgBlockEvent":
-		payload = &OrgBlockEvent{}
-	case "PageBuildEvent":
-		payload = &PageBuildEvent{}
-	case "PingEvent":
-		payload = &PingEvent{}
-	case "ProjectEvent":
-		payload = &ProjectEvent{}
-	case "ProjectCardEvent":
-		payload = &ProjectCardEvent{}
-	case "ProjectColumnEvent":
-		payload = &ProjectColumnEvent{}
-	case "PublicEvent":
-		payload = &PublicEvent{}
-	case "PullRequestEvent":
-		payload = &PullRequestEvent{}
-	case "PullRequestReviewEvent":
-		payload = &PullRequestReviewEvent{}
-	case "PullRequestReviewCommentEvent":
-		payload = &PullRequestReviewCommentEvent{}
-	case "PushEvent":
-		payload = &PushEvent{}
-	case "ReleaseEvent":
-		payload = &ReleaseEvent{}
-	case "RepositoryEvent":
-		payload = &RepositoryEvent{}
-	case "RepositoryDispatchEvent":
-		payload = &RepositoryDispatchEvent{}
-	case "RepositoryVulnerabilityAlertEvent":
-		payload = &RepositoryVulnerabilityAlertEvent{}
-	case "StarEvent":
-		payload = &StarEvent{}
-	case "StatusEvent":
-		payload = &StatusEvent{}
-	case "TeamEvent":
-		payload = &TeamEvent{}
-	case "TeamAddEvent":
-		payload = &TeamAddEvent{}
-	case "UserEvent":
-		payload = &UserEvent{}
-	case "WatchEvent":
-		payload = &WatchEvent{}
-	}
-	err = json.Unmarshal(*e.RawPayload, &payload)
-	return payload, err
-}
-
-// Payload returns the parsed event payload. For recognized event types,
-// a value of the corresponding struct type will be returned.
-//
-// Deprecated: Use ParsePayload instead, which returns an error
-// rather than panics if JSON unmarshaling raw payload fails.
-func (e *Event) Payload() (payload interface{}) {
-	var err error
-	payload, err = e.ParsePayload()
-	if err != nil {
-		panic(err)
-	}
-	return payload
-}

vendor/github.com/google/go-github/v29/github/event_types.go

@@ -1,928 +0,0 @@
-// Copyright 2016 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// These event types are shared between the Events API and used as Webhook payloads.
-
-package github
-
-import "encoding/json"
-
-// RequestedAction is included in a CheckRunEvent when a user has invoked an action,
-// i.e. when the CheckRunEvent's Action field is "requested_action".
-type RequestedAction struct {
-	Identifier string `json:"identifier"` // The integrator reference of the action requested by the user.
-}
-
-// CheckRunEvent is triggered when a check run is "created", "updated", or "rerequested".
-// The Webhook event name is "check_run".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#checkrunevent
-type CheckRunEvent struct {
-	CheckRun *CheckRun `json:"check_run,omitempty"`
-	// The action performed. Possible values are: "created", "updated", "rerequested" or "requested_action".
-	Action *string `json:"action,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-
-	// The action requested by the user. Populated when the Action is "requested_action".
-	RequestedAction *RequestedAction `json:"requested_action,omitempty"` //
-}
-
-// CheckSuiteEvent is triggered when a check suite is "completed", "requested", or "rerequested".
-// The Webhook event name is "check_suite".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#checksuiteevent
-type CheckSuiteEvent struct {
-	CheckSuite *CheckSuite `json:"check_suite,omitempty"`
-	// The action performed. Possible values are: "completed", "requested" or "rerequested".
-	Action *string `json:"action,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// CommitCommentEvent is triggered when a commit comment is created.
-// The Webhook event name is "commit_comment".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#commitcommentevent
-type CommitCommentEvent struct {
-	Comment *RepositoryComment `json:"comment,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Action       *string       `json:"action,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// CreateEvent represents a created repository, branch, or tag.
-// The Webhook event name is "create".
-//
-// Note: webhooks will not receive this event for created repositories.
-// Additionally, webhooks will not receive this event for tags if more
-// than three tags are pushed at once.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#createevent
-type CreateEvent struct {
-	Ref *string `json:"ref,omitempty"`
-	// RefType is the object that was created. Possible values are: "repository", "branch", "tag".
-	RefType      *string `json:"ref_type,omitempty"`
-	MasterBranch *string `json:"master_branch,omitempty"`
-	Description  *string `json:"description,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	PusherType   *string       `json:"pusher_type,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// DeleteEvent represents a deleted branch or tag.
-// The Webhook event name is "delete".
-//
-// Note: webhooks will not receive this event for tags if more than three tags
-// are deleted at once.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deleteevent
-type DeleteEvent struct {
-	Ref *string `json:"ref,omitempty"`
-	// RefType is the object that was deleted. Possible values are: "branch", "tag".
-	RefType *string `json:"ref_type,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	PusherType   *string       `json:"pusher_type,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// DeployKeyEvent is triggered when a deploy key is added or removed from a repository.
-// The Webhook event name is "deploy_key".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deploykeyevent
-type DeployKeyEvent struct {
-	// Action is the action that was performed. Possible values are:
-	// "created" or "deleted".
-	Action *string `json:"action,omitempty"`
-
-	// The deploy key resource.
-	Key *Key `json:"key,omitempty"`
-}
-
-// DeploymentEvent represents a deployment.
-// The Webhook event name is "deployment".
-//
-// Events of this type are not visible in timelines, they are only used to trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deploymentevent
-type DeploymentEvent struct {
-	Deployment *Deployment `json:"deployment,omitempty"`
-	Repo       *Repository `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// DeploymentStatusEvent represents a deployment status.
-// The Webhook event name is "deployment_status".
-//
-// Events of this type are not visible in timelines, they are only used to trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deploymentstatusevent
-type DeploymentStatusEvent struct {
-	Deployment       *Deployment       `json:"deployment,omitempty"`
-	DeploymentStatus *DeploymentStatus `json:"deployment_status,omitempty"`
-	Repo             *Repository       `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// ForkEvent is triggered when a user forks a repository.
-// The Webhook event name is "fork".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#forkevent
-type ForkEvent struct {
-	// Forkee is the created repository.
-	Forkee *Repository `json:"forkee,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// GitHubAppAuthorizationEvent is triggered when a user's authorization for a
-// GitHub Application is revoked.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#githubappauthorizationevent
-type GitHubAppAuthorizationEvent struct {
-	// The action performed. Possible value is: "revoked".
-	Action *string `json:"action,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Sender *User `json:"sender,omitempty"`
-}
-
-// Page represents a single Wiki page.
-type Page struct {
-	PageName *string `json:"page_name,omitempty"`
-	Title    *string `json:"title,omitempty"`
-	Summary  *string `json:"summary,omitempty"`
-	Action   *string `json:"action,omitempty"`
-	SHA      *string `json:"sha,omitempty"`
-	HTMLURL  *string `json:"html_url,omitempty"`
-}
-
-// GollumEvent is triggered when a Wiki page is created or updated.
-// The Webhook event name is "gollum".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#gollumevent
-type GollumEvent struct {
-	Pages []*Page `json:"pages,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// EditChange represents the changes when an issue, pull request, or comment has
-// been edited.
-type EditChange struct {
-	Title *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"title,omitempty"`
-	Body *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"body,omitempty"`
-}
-
-// ProjectChange represents the changes when a project has been edited.
-type ProjectChange struct {
-	Name *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"name,omitempty"`
-	Body *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"body,omitempty"`
-}
-
-// ProjectCardChange represents the changes when a project card has been edited.
-type ProjectCardChange struct {
-	Note *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"note,omitempty"`
-}
-
-// ProjectColumnChange represents the changes when a project column has been edited.
-type ProjectColumnChange struct {
-	Name *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"name,omitempty"`
-}
-
-// TeamChange represents the changes when a team has been edited.
-type TeamChange struct {
-	Description *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"description,omitempty"`
-	Name *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"name,omitempty"`
-	Privacy *struct {
-		From *string `json:"from,omitempty"`
-	} `json:"privacy,omitempty"`
-	Repository *struct {
-		Permissions *struct {
-			From *struct {
-				Admin *bool `json:"admin,omitempty"`
-				Pull  *bool `json:"pull,omitempty"`
-				Push  *bool `json:"push,omitempty"`
-			} `json:"from,omitempty"`
-		} `json:"permissions,omitempty"`
-	} `json:"repository,omitempty"`
-}
-
-// InstallationEvent is triggered when a GitHub App has been installed or uninstalled.
-// The Webhook event name is "installation".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#installationevent
-type InstallationEvent struct {
-	// The action that was performed. Can be either "created" or "deleted".
-	Action       *string       `json:"action,omitempty"`
-	Repositories []*Repository `json:"repositories,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// InstallationRepositoriesEvent is triggered when a repository is added or
-// removed from an installation. The Webhook event name is "installation_repositories".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#installationrepositoriesevent
-type InstallationRepositoriesEvent struct {
-	// The action that was performed. Can be either "added" or "removed".
-	Action              *string       `json:"action,omitempty"`
-	RepositoriesAdded   []*Repository `json:"repositories_added,omitempty"`
-	RepositoriesRemoved []*Repository `json:"repositories_removed,omitempty"`
-	RepositorySelection *string       `json:"repository_selection,omitempty"`
-	Sender              *User         `json:"sender,omitempty"`
-	Installation        *Installation `json:"installation,omitempty"`
-}
-
-// IssueCommentEvent is triggered when an issue comment is created on an issue
-// or pull request.
-// The Webhook event name is "issue_comment".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#issuecommentevent
-type IssueCommentEvent struct {
-	// Action is the action that was performed on the comment.
-	// Possible values are: "created", "edited", "deleted".
-	Action  *string       `json:"action,omitempty"`
-	Issue   *Issue        `json:"issue,omitempty"`
-	Comment *IssueComment `json:"comment,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes      *EditChange   `json:"changes,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// IssuesEvent is triggered when an issue is opened, edited, deleted, transferred,
-// pinned, unpinned, closed, reopened, assigned, unassigned, labeled, unlabeled,
-// locked, unlocked, milestoned, or demilestoned.
-// The Webhook event name is "issues".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#issuesevent
-type IssuesEvent struct {
-	// Action is the action that was performed. Possible values are: "opened",
-	// "edited", "deleted", "transferred", "pinned", "unpinned", "closed", "reopened",
-	// "assigned", "unassigned", "labeled", "unlabeled", "locked", "unlocked",
-	// "milestoned", or "demilestoned".
-	Action   *string `json:"action,omitempty"`
-	Issue    *Issue  `json:"issue,omitempty"`
-	Assignee *User   `json:"assignee,omitempty"`
-	Label    *Label  `json:"label,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes      *EditChange   `json:"changes,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// LabelEvent is triggered when a repository's label is created, edited, or deleted.
-// The Webhook event name is "label"
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#labelevent
-type LabelEvent struct {
-	// Action is the action that was performed. Possible values are:
-	// "created", "edited", "deleted"
-	Action *string `json:"action,omitempty"`
-	Label  *Label  `json:"label,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes      *EditChange   `json:"changes,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// MarketplacePurchaseEvent is triggered when a user purchases, cancels, or changes
-// their GitHub Marketplace plan.
-// Webhook event name "marketplace_purchase".
-//
-// Github API docs: https://developer.github.com/v3/activity/events/types/#marketplacepurchaseevent
-type MarketplacePurchaseEvent struct {
-	// Action is the action that was performed. Possible values are:
-	// "purchased", "cancelled", "pending_change", "pending_change_cancelled", "changed".
-	Action *string `json:"action,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	EffectiveDate               *Timestamp           `json:"effective_date,omitempty"`
-	MarketplacePurchase         *MarketplacePurchase `json:"marketplace_purchase,omitempty"`
-	PreviousMarketplacePurchase *MarketplacePurchase `json:"previous_marketplace_purchase,omitempty"`
-	Sender                      *User                `json:"sender,omitempty"`
-	Installation                *Installation        `json:"installation,omitempty"`
-}
-
-// MemberEvent is triggered when a user is added as a collaborator to a repository.
-// The Webhook event name is "member".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#memberevent
-type MemberEvent struct {
-	// Action is the action that was performed. Possible value is: "added".
-	Action *string `json:"action,omitempty"`
-	Member *User   `json:"member,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// MembershipEvent is triggered when a user is added or removed from a team.
-// The Webhook event name is "membership".
-//
-// Events of this type are not visible in timelines, they are only used to
-// trigger organization webhooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#membershipevent
-type MembershipEvent struct {
-	// Action is the action that was performed. Possible values are: "added", "removed".
-	Action *string `json:"action,omitempty"`
-	// Scope is the scope of the membership. Possible value is: "team".
-	Scope  *string `json:"scope,omitempty"`
-	Member *User   `json:"member,omitempty"`
-	Team   *Team   `json:"team,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// MetaEvent is triggered when the webhook that this event is configured on is deleted.
-// This event will only listen for changes to the particular hook the event is installed on.
-// Therefore, it must be selected for each hook that you'd like to receive meta events for.
-// The Webhook event name is "meta".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#metaevent
-type MetaEvent struct {
-	// Action is the action that was performed. Possible value is: "deleted".
-	Action *string `json:"action,omitempty"`
-	// The ID of the modified webhook.
-	HookID *int64 `json:"hook_id,omitempty"`
-	// The modified webhook.
-	// This will contain different keys based on the type of webhook it is: repository,
-	// organization, business, app, or GitHub Marketplace.
-	Hook *Hook `json:"hook,omitempty"`
-}
-
-// MilestoneEvent is triggered when a milestone is created, closed, opened, edited, or deleted.
-// The Webhook event name is "milestone".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#milestoneevent
-type MilestoneEvent struct {
-	// Action is the action that was performed. Possible values are:
-	// "created", "closed", "opened", "edited", "deleted"
-	Action    *string    `json:"action,omitempty"`
-	Milestone *Milestone `json:"milestone,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes      *EditChange   `json:"changes,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// OrganizationEvent is triggered when an organization is deleted and renamed, and when a user is added,
-// removed, or invited to an organization.
-// Events of this type are not visible in timelines. These events are only used to trigger organization hooks.
-// Webhook event name is "organization".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#organizationevent
-type OrganizationEvent struct {
-	// Action is the action that was performed.
-	// Possible values are: "deleted", "renamed", "member_added", "member_removed", or "member_invited".
-	Action *string `json:"action,omitempty"`
-
-	// Invitation is the invitation for the user or email if the action is "member_invited".
-	Invitation *Invitation `json:"invitation,omitempty"`
-
-	// Membership is the membership between the user and the organization.
-	// Not present when the action is "member_invited".
-	Membership *Membership `json:"membership,omitempty"`
-
-	Organization *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// OrgBlockEvent is triggered when an organization blocks or unblocks a user.
-// The Webhook event name is "org_block".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#orgblockevent
-type OrgBlockEvent struct {
-	// Action is the action that was performed.
-	// Can be "blocked" or "unblocked".
-	Action       *string       `json:"action,omitempty"`
-	BlockedUser  *User         `json:"blocked_user,omitempty"`
-	Organization *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// PageBuildEvent represents an attempted build of a GitHub Pages site, whether
-// successful or not.
-// The Webhook event name is "page_build".
-//
-// This event is triggered on push to a GitHub Pages enabled branch (gh-pages
-// for project pages, master for user and organization pages).
-//
-// Events of this type are not visible in timelines, they are only used to trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pagebuildevent
-type PageBuildEvent struct {
-	Build *PagesBuild `json:"build,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	ID           *int64        `json:"id,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// PingEvent is triggered when a Webhook is added to GitHub.
-//
-// GitHub API docs: https://developer.github.com/webhooks/#ping-event
-type PingEvent struct {
-	// Random string of GitHub zen.
-	Zen *string `json:"zen,omitempty"`
-	// The ID of the webhook that triggered the ping.
-	HookID *int64 `json:"hook_id,omitempty"`
-	// The webhook configuration.
-	Hook         *Hook         `json:"hook,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// ProjectEvent is triggered when project is created, modified or deleted.
-// The webhook event name is "project".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectevent
-type ProjectEvent struct {
-	Action  *string        `json:"action,omitempty"`
-	Changes *ProjectChange `json:"changes,omitempty"`
-	Project *Project       `json:"project,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// ProjectCardEvent is triggered when a project card is created, updated, moved, converted to an issue, or deleted.
-// The webhook event name is "project_card".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectcardevent
-type ProjectCardEvent struct {
-	Action      *string            `json:"action,omitempty"`
-	Changes     *ProjectCardChange `json:"changes,omitempty"`
-	AfterID     *int64             `json:"after_id,omitempty"`
-	ProjectCard *ProjectCard       `json:"project_card,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// ProjectColumnEvent is triggered when a project column is created, updated, moved, or deleted.
-// The webhook event name is "project_column".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectcolumnevent
-type ProjectColumnEvent struct {
-	Action        *string              `json:"action,omitempty"`
-	Changes       *ProjectColumnChange `json:"changes,omitempty"`
-	AfterID       *int64               `json:"after_id,omitempty"`
-	ProjectColumn *ProjectColumn       `json:"project_column,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// PublicEvent is triggered when a private repository is open sourced.
-// According to GitHub: "Without a doubt: the best GitHub event."
-// The Webhook event name is "public".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#publicevent
-type PublicEvent struct {
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// PullRequestEvent is triggered when a pull request is assigned, unassigned, labeled,
-// unlabeled, opened, edited, closed, reopened, synchronize, ready_for_review,
-// locked, unlocked, a pull request review is requested, or a review request is removed.
-// The Webhook event name is "pull_request".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestevent
-type PullRequestEvent struct {
-	// Action is the action that was performed. Possible values are:
-	// "assigned", "unassigned", "review_requested", "review_request_removed", "labeled", "unlabeled",
-	// "opened", "edited", "closed", "ready_for_review", "locked", "unlocked", or "reopened".
-	// If the action is "closed" and the "merged" key is "false", the pull request was closed with unmerged commits.
-	// If the action is "closed" and the "merged" key is "true", the pull request was merged.
-	// While webhooks are also triggered when a pull request is synchronized, Events API timelines
-	// don't include pull request events with the "synchronize" action.
-	Action      *string      `json:"action,omitempty"`
-	Assignee    *User        `json:"assignee,omitempty"`
-	Number      *int         `json:"number,omitempty"`
-	PullRequest *PullRequest `json:"pull_request,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes *EditChange `json:"changes,omitempty"`
-	// RequestedReviewer is populated in "review_requested", "review_request_removed" event deliveries.
-	// A request affecting multiple reviewers at once is split into multiple
-	// such event deliveries, each with a single, different RequestedReviewer.
-	RequestedReviewer *User `json:"requested_reviewer,omitempty"`
-	// In the event that a team is requested instead of a user, "requested_team" gets sent in place of
-	// "requested_user" with the same delivery behavior.
-	RequestedTeam *Team         `json:"requested_team,omitempty"`
-	Repo          *Repository   `json:"repository,omitempty"`
-	Sender        *User         `json:"sender,omitempty"`
-	Installation  *Installation `json:"installation,omitempty"`
-	Label         *Label        `json:"label,omitempty"` // Populated in "labeled" event deliveries.
-
-	// The following field is only present when the webhook is triggered on
-	// a repository belonging to an organization.
-	Organization *Organization `json:"organization,omitempty"`
-
-	// The following fields are only populated when the Action is "synchronize".
-	Before *string `json:"before,omitempty"`
-	After  *string `json:"after,omitempty"`
-}
-
-// PullRequestReviewEvent is triggered when a review is submitted on a pull
-// request.
-// The Webhook event name is "pull_request_review".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewevent
-type PullRequestReviewEvent struct {
-	// Action is always "submitted".
-	Action      *string            `json:"action,omitempty"`
-	Review      *PullRequestReview `json:"review,omitempty"`
-	PullRequest *PullRequest       `json:"pull_request,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-
-	// The following field is only present when the webhook is triggered on
-	// a repository belonging to an organization.
-	Organization *Organization `json:"organization,omitempty"`
-}
-
-// PullRequestReviewCommentEvent is triggered when a comment is created on a
-// portion of the unified diff of a pull request.
-// The Webhook event name is "pull_request_review_comment".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewcommentevent
-type PullRequestReviewCommentEvent struct {
-	// Action is the action that was performed on the comment.
-	// Possible values are: "created", "edited", "deleted".
-	Action      *string             `json:"action,omitempty"`
-	PullRequest *PullRequest        `json:"pull_request,omitempty"`
-	Comment     *PullRequestComment `json:"comment,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Changes      *EditChange   `json:"changes,omitempty"`
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// PushEvent represents a git push to a GitHub repository.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pushevent
-type PushEvent struct {
-	PushID       *int64            `json:"push_id,omitempty"`
-	Head         *string           `json:"head,omitempty"`
-	Ref          *string           `json:"ref,omitempty"`
-	Size         *int              `json:"size,omitempty"`
-	Commits      []PushEventCommit `json:"commits,omitempty"`
-	Before       *string           `json:"before,omitempty"`
-	DistinctSize *int              `json:"distinct_size,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	After        *string              `json:"after,omitempty"`
-	Created      *bool                `json:"created,omitempty"`
-	Deleted      *bool                `json:"deleted,omitempty"`
-	Forced       *bool                `json:"forced,omitempty"`
-	BaseRef      *string              `json:"base_ref,omitempty"`
-	Compare      *string              `json:"compare,omitempty"`
-	Repo         *PushEventRepository `json:"repository,omitempty"`
-	HeadCommit   *PushEventCommit     `json:"head_commit,omitempty"`
-	Pusher       *User                `json:"pusher,omitempty"`
-	Sender       *User                `json:"sender,omitempty"`
-	Installation *Installation        `json:"installation,omitempty"`
-}
-
-func (p PushEvent) String() string {
-	return Stringify(p)
-}
-
-// PushEventCommit represents a git commit in a GitHub PushEvent.
-type PushEventCommit struct {
-	Message  *string       `json:"message,omitempty"`
-	Author   *CommitAuthor `json:"author,omitempty"`
-	URL      *string       `json:"url,omitempty"`
-	Distinct *bool         `json:"distinct,omitempty"`
-
-	// The following fields are only populated by Events API.
-	SHA *string `json:"sha,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	ID        *string       `json:"id,omitempty"`
-	TreeID    *string       `json:"tree_id,omitempty"`
-	Timestamp *Timestamp    `json:"timestamp,omitempty"`
-	Committer *CommitAuthor `json:"committer,omitempty"`
-	Added     []string      `json:"added,omitempty"`
-	Removed   []string      `json:"removed,omitempty"`
-	Modified  []string      `json:"modified,omitempty"`
-}
-
-func (p PushEventCommit) String() string {
-	return Stringify(p)
-}
-
-// PushEventRepository represents the repo object in a PushEvent payload.
-type PushEventRepository struct {
-	ID              *int64     `json:"id,omitempty"`
-	NodeID          *string    `json:"node_id,omitempty"`
-	Name            *string    `json:"name,omitempty"`
-	FullName        *string    `json:"full_name,omitempty"`
-	Owner           *User      `json:"owner,omitempty"`
-	Private         *bool      `json:"private,omitempty"`
-	Description     *string    `json:"description,omitempty"`
-	Fork            *bool      `json:"fork,omitempty"`
-	CreatedAt       *Timestamp `json:"created_at,omitempty"`
-	PushedAt        *Timestamp `json:"pushed_at,omitempty"`
-	UpdatedAt       *Timestamp `json:"updated_at,omitempty"`
-	Homepage        *string    `json:"homepage,omitempty"`
-	PullsURL        *string    `json:"pulls_url,omitempty"`
-	Size            *int       `json:"size,omitempty"`
-	StargazersCount *int       `json:"stargazers_count,omitempty"`
-	WatchersCount   *int       `json:"watchers_count,omitempty"`
-	Language        *string    `json:"language,omitempty"`
-	HasIssues       *bool      `json:"has_issues,omitempty"`
-	HasDownloads    *bool      `json:"has_downloads,omitempty"`
-	HasWiki         *bool      `json:"has_wiki,omitempty"`
-	HasPages        *bool      `json:"has_pages,omitempty"`
-	ForksCount      *int       `json:"forks_count,omitempty"`
-	Archived        *bool      `json:"archived,omitempty"`
-	Disabled        *bool      `json:"disabled,omitempty"`
-	OpenIssuesCount *int       `json:"open_issues_count,omitempty"`
-	DefaultBranch   *string    `json:"default_branch,omitempty"`
-	MasterBranch    *string    `json:"master_branch,omitempty"`
-	Organization    *string    `json:"organization,omitempty"`
-	URL             *string    `json:"url,omitempty"`
-	ArchiveURL      *string    `json:"archive_url,omitempty"`
-	HTMLURL         *string    `json:"html_url,omitempty"`
-	StatusesURL     *string    `json:"statuses_url,omitempty"`
-	GitURL          *string    `json:"git_url,omitempty"`
-	SSHURL          *string    `json:"ssh_url,omitempty"`
-	CloneURL        *string    `json:"clone_url,omitempty"`
-	SVNURL          *string    `json:"svn_url,omitempty"`
-}
-
-// PushEventRepoOwner is a basic representation of user/org in a PushEvent payload.
-type PushEventRepoOwner struct {
-	Name  *string `json:"name,omitempty"`
-	Email *string `json:"email,omitempty"`
-}
-
-// ReleaseEvent is triggered when a release is published, unpublished, created,
-// edited, deleted, or prereleased.
-// The Webhook event name is "release".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#releaseevent
-type ReleaseEvent struct {
-	// Action is the action that was performed. Possible values are: "published", "unpublished",
-	// "created", "edited", "deleted", or "prereleased".
-	Action  *string            `json:"action,omitempty"`
-	Release *RepositoryRelease `json:"release,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// RepositoryEvent is triggered when a repository is created, archived, unarchived,
-// renamed, edited, transferred, made public, or made private. Organization hooks are
-// also trigerred when a repository is deleted.
-// The Webhook event name is "repository".
-//
-// Events of this type are not visible in timelines, they are only used to
-// trigger organization webhooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#repositoryevent
-type RepositoryEvent struct {
-	// Action is the action that was performed. Possible values are: "created",
-	// "deleted" (organization hooks only), "archived", "unarchived", "edited", "renamed",
-	// "transferred", "publicized", or "privatized".
-	Action *string     `json:"action,omitempty"`
-	Repo   *Repository `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// RepositoryDispatchEvent is triggered when a client sends a POST request to the repository dispatch event endpoint.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#repositorydispatchevent
-type RepositoryDispatchEvent struct {
-	// Action is the event_type that submitted with the repository dispatch payload. Value can be any string.
-	Action        *string         `json:"action,omitempty"`
-	Branch        *string         `json:"branch,omitempty"`
-	ClientPayload json.RawMessage `json:"client_payload,omitempty"`
-	Repo          *Repository     `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// RepositoryVulnerabilityAlertEvent is triggered when a security alert is created, dismissed, or resolved.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#repositoryvulnerabilityalertevent
-type RepositoryVulnerabilityAlertEvent struct {
-	// Action is the action that was performed. Possible values are: "create", "dismiss", "resolve".
-	Action *string `json:"action,omitempty"`
-
-	//The security alert of the vulnerable dependency.
-	Alert *struct {
-		ID                  *int64     `json:"id,omitempty"`
-		AffectedRange       *string    `json:"affected_range,omitempty"`
-		AffectedPackageName *string    `json:"affected_package_name,omitempty"`
-		ExternalReference   *string    `json:"external_reference,omitempty"`
-		ExternalIdentifier  *string    `json:"external_identifier,omitempty"`
-		FixedIn             *string    `json:"fixed_in,omitempty"`
-		Dismisser           *User      `json:"dismisser,omitempty"`
-		DismissReason       *string    `json:"dismiss_reason,omitempty"`
-		DismissedAt         *Timestamp `json:"dismissed_at,omitempty"`
-	} `json:"alert,omitempty"`
-}
-
-// StarEvent is triggered when a star is added or removed from a repository.
-// The Webhook event name is "star".
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#starevent
-type StarEvent struct {
-	// Action is the action that was performed. Possible values are: "created" or "deleted".
-	Action *string `json:"action,omitempty"`
-
-	// StarredAt is the time the star was created. It will be null for the "deleted" action.
-	StarredAt *Timestamp `json:"starred_at,omitempty"`
-}
-
-// StatusEvent is triggered when the status of a Git commit changes.
-// The Webhook event name is "status".
-//
-// Events of this type are not visible in timelines, they are only used to
-// trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#statusevent
-type StatusEvent struct {
-	SHA *string `json:"sha,omitempty"`
-	// State is the new state. Possible values are: "pending", "success", "failure", "error".
-	State       *string   `json:"state,omitempty"`
-	Description *string   `json:"description,omitempty"`
-	TargetURL   *string   `json:"target_url,omitempty"`
-	Branches    []*Branch `json:"branches,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	ID           *int64            `json:"id,omitempty"`
-	Name         *string           `json:"name,omitempty"`
-	Context      *string           `json:"context,omitempty"`
-	Commit       *RepositoryCommit `json:"commit,omitempty"`
-	CreatedAt    *Timestamp        `json:"created_at,omitempty"`
-	UpdatedAt    *Timestamp        `json:"updated_at,omitempty"`
-	Repo         *Repository       `json:"repository,omitempty"`
-	Sender       *User             `json:"sender,omitempty"`
-	Installation *Installation     `json:"installation,omitempty"`
-}
-
-// TeamEvent is triggered when an organization's team is created, modified or deleted.
-// The Webhook event name is "team".
-//
-// Events of this type are not visible in timelines. These events are only used
-// to trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#teamevent
-type TeamEvent struct {
-	Action  *string     `json:"action,omitempty"`
-	Team    *Team       `json:"team,omitempty"`
-	Changes *TeamChange `json:"changes,omitempty"`
-	Repo    *Repository `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// TeamAddEvent is triggered when a repository is added to a team.
-// The Webhook event name is "team_add".
-//
-// Events of this type are not visible in timelines. These events are only used
-// to trigger hooks.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#teamaddevent
-type TeamAddEvent struct {
-	Team *Team       `json:"team,omitempty"`
-	Repo *Repository `json:"repository,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Org          *Organization `json:"organization,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}
-
-// UserEvent is triggered when a user is created or deleted.
-// The Webhook event name is "user".
-//
-// Only global webhooks can subscribe to this event type.
-//
-// GitHub API docs: https://developer.github.com/enterprise/v3/activity/events/types/#userevent-enterprise
-type UserEvent struct {
-	User *User `json:"user,omitempty"`
-	// The action performed. Possible values are: "created" or "deleted".
-	Action     *string     `json:"action,omitempty"`
-	Enterprise *Enterprise `json:"enterprise,omitempty"`
-	Sender     *User       `json:"sender,omitempty"`
-}
-
-// WatchEvent is related to starring a repository, not watching. See this API
-// blog post for an explanation: https://developer.github.com/changes/2012-09-05-watcher-api/
-//
-// The event’s actor is the user who starred a repository, and the event’s
-// repository is the repository that was starred.
-//
-// GitHub API docs: https://developer.github.com/v3/activity/events/types/#watchevent
-type WatchEvent struct {
-	// Action is the action that was performed. Possible value is: "started".
-	Action *string `json:"action,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo         *Repository   `json:"repository,omitempty"`
-	Sender       *User         `json:"sender,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
-}

vendor/github.com/google/go-github/v29/github/gists.go

@@ -1,363 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-// GistsService handles communication with the Gist related
-// methods of the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/
-type GistsService service
-
-// Gist represents a GitHub's gist.
-type Gist struct {
-	ID          *string                   `json:"id,omitempty"`
-	Description *string                   `json:"description,omitempty"`
-	Public      *bool                     `json:"public,omitempty"`
-	Owner       *User                     `json:"owner,omitempty"`
-	Files       map[GistFilename]GistFile `json:"files,omitempty"`
-	Comments    *int                      `json:"comments,omitempty"`
-	HTMLURL     *string                   `json:"html_url,omitempty"`
-	GitPullURL  *string                   `json:"git_pull_url,omitempty"`
-	GitPushURL  *string                   `json:"git_push_url,omitempty"`
-	CreatedAt   *time.Time                `json:"created_at,omitempty"`
-	UpdatedAt   *time.Time                `json:"updated_at,omitempty"`
-	NodeID      *string                   `json:"node_id,omitempty"`
-}
-
-func (g Gist) String() string {
-	return Stringify(g)
-}
-
-// GistFilename represents filename on a gist.
-type GistFilename string
-
-// GistFile represents a file on a gist.
-type GistFile struct {
-	Size     *int    `json:"size,omitempty"`
-	Filename *string `json:"filename,omitempty"`
-	Language *string `json:"language,omitempty"`
-	Type     *string `json:"type,omitempty"`
-	RawURL   *string `json:"raw_url,omitempty"`
-	Content  *string `json:"content,omitempty"`
-}
-
-func (g GistFile) String() string {
-	return Stringify(g)
-}
-
-// GistCommit represents a commit on a gist.
-type GistCommit struct {
-	URL          *string      `json:"url,omitempty"`
-	Version      *string      `json:"version,omitempty"`
-	User         *User        `json:"user,omitempty"`
-	ChangeStatus *CommitStats `json:"change_status,omitempty"`
-	CommittedAt  *Timestamp   `json:"committed_at,omitempty"`
-	NodeID       *string      `json:"node_id,omitempty"`
-}
-
-func (gc GistCommit) String() string {
-	return Stringify(gc)
-}
-
-// GistFork represents a fork of a gist.
-type GistFork struct {
-	URL       *string    `json:"url,omitempty"`
-	User      *User      `json:"user,omitempty"`
-	ID        *string    `json:"id,omitempty"`
-	CreatedAt *Timestamp `json:"created_at,omitempty"`
-	UpdatedAt *Timestamp `json:"updated_at,omitempty"`
-	NodeID    *string    `json:"node_id,omitempty"`
-}
-
-func (gf GistFork) String() string {
-	return Stringify(gf)
-}
-
-// GistListOptions specifies the optional parameters to the
-// GistsService.List, GistsService.ListAll, and GistsService.ListStarred methods.
-type GistListOptions struct {
-	// Since filters Gists by time.
-	Since time.Time `url:"since,omitempty"`
-
-	ListOptions
-}
-
-// List gists for a user. Passing the empty string will list
-// all public gists if called anonymously. However, if the call
-// is authenticated, it will returns all gists for the authenticated
-// user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) List(ctx context.Context, user string, opts *GistListOptions) ([]*Gist, *Response, error) {
-	var u string
-	if user != "" {
-		u = fmt.Sprintf("users/%v/gists", user)
-	} else {
-		u = "gists"
-	}
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var gists []*Gist
-	resp, err := s.client.Do(ctx, req, &gists)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gists, resp, nil
-}
-
-// ListAll lists all public gists.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) ListAll(ctx context.Context, opts *GistListOptions) ([]*Gist, *Response, error) {
-	u, err := addOptions("gists/public", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var gists []*Gist
-	resp, err := s.client.Do(ctx, req, &gists)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gists, resp, nil
-}
-
-// ListStarred lists starred gists of authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) ListStarred(ctx context.Context, opts *GistListOptions) ([]*Gist, *Response, error) {
-	u, err := addOptions("gists/starred", opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var gists []*Gist
-	resp, err := s.client.Do(ctx, req, &gists)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gists, resp, nil
-}
-
-// Get a single gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#get-a-single-gist
-func (s *GistsService) Get(ctx context.Context, id string) (*Gist, *Response, error) {
-	u := fmt.Sprintf("gists/%v", id)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	gist := new(Gist)
-	resp, err := s.client.Do(ctx, req, gist)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gist, resp, nil
-}
-
-// GetRevision gets a specific revision of a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist
-func (s *GistsService) GetRevision(ctx context.Context, id, sha string) (*Gist, *Response, error) {
-	u := fmt.Sprintf("gists/%v/%v", id, sha)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	gist := new(Gist)
-	resp, err := s.client.Do(ctx, req, gist)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gist, resp, nil
-}
-
-// Create a gist for authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#create-a-gist
-func (s *GistsService) Create(ctx context.Context, gist *Gist) (*Gist, *Response, error) {
-	u := "gists"
-	req, err := s.client.NewRequest("POST", u, gist)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	g := new(Gist)
-	resp, err := s.client.Do(ctx, req, g)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return g, resp, nil
-}
-
-// Edit a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#edit-a-gist
-func (s *GistsService) Edit(ctx context.Context, id string, gist *Gist) (*Gist, *Response, error) {
-	u := fmt.Sprintf("gists/%v", id)
-	req, err := s.client.NewRequest("PATCH", u, gist)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	g := new(Gist)
-	resp, err := s.client.Do(ctx, req, g)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return g, resp, nil
-}
-
-// ListCommits lists commits of a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#list-gist-commits
-func (s *GistsService) ListCommits(ctx context.Context, id string, opts *ListOptions) ([]*GistCommit, *Response, error) {
-	u := fmt.Sprintf("gists/%v/commits", id)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var gistCommits []*GistCommit
-	resp, err := s.client.Do(ctx, req, &gistCommits)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gistCommits, resp, nil
-}
-
-// Delete a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#delete-a-gist
-func (s *GistsService) Delete(ctx context.Context, id string) (*Response, error) {
-	u := fmt.Sprintf("gists/%v", id)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	return s.client.Do(ctx, req, nil)
-}
-
-// Star a gist on behalf of authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#star-a-gist
-func (s *GistsService) Star(ctx context.Context, id string) (*Response, error) {
-	u := fmt.Sprintf("gists/%v/star", id)
-	req, err := s.client.NewRequest("PUT", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	return s.client.Do(ctx, req, nil)
-}
-
-// Unstar a gist on a behalf of authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#unstar-a-gist
-func (s *GistsService) Unstar(ctx context.Context, id string) (*Response, error) {
-	u := fmt.Sprintf("gists/%v/star", id)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-	return s.client.Do(ctx, req, nil)
-}
-
-// IsStarred checks if a gist is starred by authenticated user.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#check-if-a-gist-is-starred
-func (s *GistsService) IsStarred(ctx context.Context, id string) (bool, *Response, error) {
-	u := fmt.Sprintf("gists/%v/star", id)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return false, nil, err
-	}
-	resp, err := s.client.Do(ctx, req, nil)
-	starred, err := parseBoolResponse(err)
-	return starred, resp, err
-}
-
-// Fork a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#fork-a-gist
-func (s *GistsService) Fork(ctx context.Context, id string) (*Gist, *Response, error) {
-	u := fmt.Sprintf("gists/%v/forks", id)
-	req, err := s.client.NewRequest("POST", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	g := new(Gist)
-	resp, err := s.client.Do(ctx, req, g)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return g, resp, nil
-}
-
-// ListForks lists forks of a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/#list-gist-forks
-func (s *GistsService) ListForks(ctx context.Context, id string, opts *ListOptions) ([]*GistFork, *Response, error) {
-	u := fmt.Sprintf("gists/%v/forks", id)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var gistForks []*GistFork
-	resp, err := s.client.Do(ctx, req, &gistForks)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return gistForks, resp, nil
-}

vendor/github.com/google/go-github/v29/github/gists_comments.go

@@ -1,119 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-// GistComment represents a Gist comment.
-type GistComment struct {
-	ID        *int64     `json:"id,omitempty"`
-	URL       *string    `json:"url,omitempty"`
-	Body      *string    `json:"body,omitempty"`
-	User      *User      `json:"user,omitempty"`
-	CreatedAt *time.Time `json:"created_at,omitempty"`
-}
-
-func (g GistComment) String() string {
-	return Stringify(g)
-}
-
-// ListComments lists all comments for a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist
-func (s *GistsService) ListComments(ctx context.Context, gistID string, opts *ListOptions) ([]*GistComment, *Response, error) {
-	u := fmt.Sprintf("gists/%v/comments", gistID)
-	u, err := addOptions(u, opts)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var comments []*GistComment
-	resp, err := s.client.Do(ctx, req, &comments)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return comments, resp, nil
-}
-
-// GetComment retrieves a single comment from a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/comments/#get-a-single-comment
-func (s *GistsService) GetComment(ctx context.Context, gistID string, commentID int64) (*GistComment, *Response, error) {
-	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c := new(GistComment)
-	resp, err := s.client.Do(ctx, req, c)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return c, resp, nil
-}
-
-// CreateComment creates a comment for a gist.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/comments/#create-a-comment
-func (s *GistsService) CreateComment(ctx context.Context, gistID string, comment *GistComment) (*GistComment, *Response, error) {
-	u := fmt.Sprintf("gists/%v/comments", gistID)
-	req, err := s.client.NewRequest("POST", u, comment)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c := new(GistComment)
-	resp, err := s.client.Do(ctx, req, c)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return c, resp, nil
-}
-
-// EditComment edits an existing gist comment.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/comments/#edit-a-comment
-func (s *GistsService) EditComment(ctx context.Context, gistID string, commentID int64, comment *GistComment) (*GistComment, *Response, error) {
-	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
-	req, err := s.client.NewRequest("PATCH", u, comment)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c := new(GistComment)
-	resp, err := s.client.Do(ctx, req, c)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return c, resp, nil
-}
-
-// DeleteComment deletes a gist comment.
-//
-// GitHub API docs: https://developer.github.com/v3/gists/comments/#delete-a-comment
-func (s *GistsService) DeleteComment(ctx context.Context, gistID string, commentID int64) (*Response, error) {
-	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
-	req, err := s.client.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return s.client.Do(ctx, req, nil)
-}

vendor/github.com/google/go-github/v29/github/git.go

@@ -1,12 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-// GitService handles communication with the git data related
-// methods of the GitHub API.
-//
-// GitHub API docs: https://developer.github.com/v3/git/
-type GitService service

vendor/github.com/google/go-github/v29/github/git_blobs.go

@@ -1,69 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-)
-
-// Blob represents a blob object.
-type Blob struct {
-	Content  *string `json:"content,omitempty"`
-	Encoding *string `json:"encoding,omitempty"`
-	SHA      *string `json:"sha,omitempty"`
-	Size     *int    `json:"size,omitempty"`
-	URL      *string `json:"url,omitempty"`
-	NodeID   *string `json:"node_id,omitempty"`
-}
-
-// GetBlob fetches a blob from a repo given a SHA.
-//
-// GitHub API docs: https://developer.github.com/v3/git/blobs/#get-a-blob
-func (s *GitService) GetBlob(ctx context.Context, owner string, repo string, sha string) (*Blob, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	blob := new(Blob)
-	resp, err := s.client.Do(ctx, req, blob)
-	return blob, resp, err
-}
-
-// GetBlobRaw fetches a blob's contents from a repo.
-// Unlike GetBlob, it returns the raw bytes rather than the base64-encoded data.
-//
-// GitHub API docs: https://developer.github.com/v3/git/blobs/#get-a-blob
-func (s *GitService) GetBlobRaw(ctx context.Context, owner, repo, sha string) ([]byte, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-	req.Header.Set("Accept", "application/vnd.github.v3.raw")
-
-	var buf bytes.Buffer
-	resp, err := s.client.Do(ctx, req, &buf)
-	return buf.Bytes(), resp, err
-}
-
-// CreateBlob creates a blob object.
-//
-// GitHub API docs: https://developer.github.com/v3/git/blobs/#create-a-blob
-func (s *GitService) CreateBlob(ctx context.Context, owner string, repo string, blob *Blob) (*Blob, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/git/blobs", owner, repo)
-	req, err := s.client.NewRequest("POST", u, blob)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	t := new(Blob)
-	resp, err := s.client.Do(ctx, req, t)
-	return t, resp, err
-}

vendor/github.com/google/go-github/v29/github/git_commits.go

@@ -1,200 +0,0 @@
-// Copyright 2013 The go-github AUTHORS. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package github
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"golang.org/x/crypto/openpgp"
-)
-
-// SignatureVerification represents GPG signature verification.
-type SignatureVerification struct {
-	Verified  *bool   `json:"verified,omitempty"`
-	Reason    *string `json:"reason,omitempty"`
-	Signature *string `json:"signature,omitempty"`
-	Payload   *string `json:"payload,omitempty"`
-}
-
-// Commit represents a GitHub commit.
-type Commit struct {
-	SHA          *string                `json:"sha,omitempty"`
-	Author       *CommitAuthor          `json:"author,omitempty"`
-	Committer    *CommitAuthor          `json:"committer,omitempty"`
-	Message      *string                `json:"message,omitempty"`
-	Tree         *Tree                  `json:"tree,omitempty"`
-	Parents      []Commit               `json:"parents,omitempty"`
-	Stats        *CommitStats           `json:"stats,omitempty"`
-	HTMLURL      *string                `json:"html_url,omitempty"`
-	URL          *string                `json:"url,omitempty"`
-	Verification *SignatureVerification `json:"verification,omitempty"`
-	NodeID       *string                `json:"node_id,omitempty"`
-
-	// CommentCount is the number of GitHub comments on the commit. This
-	// is only populated for requests that fetch GitHub data like
-	// Pulls.ListCommits, Repositories.ListCommits, etc.
-	CommentCount *int `json:"comment_count,omitempty"`
-
-	// SigningKey denotes a key to sign the commit with. If not nil this key will
-	// be used to sign the commit. The private key must be present and already
-	// decrypted. Ignored if Verification.Signature is defined.
-	SigningKey *openpgp.Entity `json:"-"`
-}
-
-func (c Commit) String() string {
-	return Stringify(c)
-}
-
-// CommitAuthor represents the author or committer of a commit. The commit
-// author may not correspond to a GitHub User.
-type CommitAuthor struct {
-	Date  *time.Time `json:"date,omitempty"`
-	Name  *string    `json:"name,omitempty"`
-	Email *string    `json:"email,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Login *string `json:"username,omitempty"` // Renamed for go-github consistency.
-}
-
-func (c CommitAuthor) String() string {
-	return Stringify(c)
-}
-
-// GetCommit fetches the Commit object for a given SHA.
-//
-// GitHub API docs: https://developer.github.com/v3/git/commits/#get-a-commit
-func (s *GitService) GetCommit(ctx context.Context, owner string, repo string, sha string) (*Commit, *Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/git/commits/%v", owner, repo, sha)
-	req, err := s.client.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c := new(Commit)
-	resp, err := s.client.Do(ctx, req, c)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return c, resp, nil
-}
-
-// createCommit represents the body of a CreateCommit request.
-type createCommit struct {
-	Author    *CommitAuthor `json:"author,omitempty"`
-	Committer *CommitAuthor `json:"committer,omitempty"`
-	Message   *string       `json:"message,omitempty"`
-	Tree      *string       `json:"tree,omitempty"`
-	Parents   []string      `json:"parents,omitempty"`
-	Signature *string       `json:"signature,omitempty"`
-}
-
-// CreateCommit creates a new commit in a repository.
-// commit must not be nil.
-//
-// The commit.Committer is optional and will be filled with the commit.Author
-// data if omitted. If the commit.Author is omitted, it will be filled in with
-// the authenticated user’s information and the current date.
-//
-// GitHub API docs: https://developer.github.com/v3/git/commits/#create-a-commit
-func (s *GitService) CreateCommit(ctx context.Context, owner string, repo string, commit *Commit) (*Commit, *Response, error) {
-	if commit == nil {
-		return nil, nil, fmt.Errorf("commit must be provided")
-	}
-
-	u := fmt.Sprintf("repos/%v/%v/git/commits", owner, repo)
-
-	parents := make([]string, len(commit.Parents))
-	for i, parent := range commit.Parents {
-		parents[i] = *parent.SHA
-	}
-
-	body := &createCommit{
-		Author:    commit.Author,
-		Committer: commit.Committer,
-		Message:   commit.Message,
-		Parents:   parents,
-	}
-	if commit.Tree != nil {
-		body.Tree = commit.Tree.SHA
-	}
-	if commit.SigningKey != nil {
-		signature, err := createSignature(commit.SigningKey, body)
-		if err != nil {
-			return nil, nil, err
-		}
-		body.Signature = &signature
-	}
-	if commit.Verification != nil {
-		body.Signature = commit.Verification.Signature
-	}
-
-	req, err := s.client.NewRequest("POST", u, body)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c := new(Commit)
-	resp, err := s.client.Do(ctx, req, c)
-	if err != nil {
-		return nil, resp, err
-	}
-
-	return c, resp, nil
-}
-
-func createSignature(signingKey *openpgp.Entity, commit *createCommit) (string, error) {
-	if signingKey == nil || commit == nil {
-		return "", errors.New("createSignature: invalid parameters")
-	}
-
-	message, err := createSignatureMessage(commit)
-	if err != nil {
-		return "", err
-	}
-
-	writer := new(bytes.Buffer)
-	reader := bytes.NewReader([]byte(message))
-	if err := openpgp.ArmoredDetachSign(writer, signingKey, reader, nil); err != nil {
-		return "", err
-	}
-
-	return writer.String(), nil
-}
-
-func createSignatureMessage(commit *createCommit) (string, error) {
-	if commit == nil || commit.Message == nil || *commit.Message == "" || commit.Author == nil {
-		return "", errors.New("createSignatureMessage: invalid parameters")
-	}
-
-	var message []string
-
-	if commit.Tree != nil {
-		message = append(message, fmt.Sprintf("tree %s", *commit.Tree))
-	}
-
-	for _, parent := range commit.Parents {
-		message = append(message, fmt.Sprintf("parent %s", parent))
-	}
-
-	message = append(message, fmt.Sprintf("author %s <%s> %d %s", commit.Author.GetName(), commit.Author.GetEmail(), commit.Author.GetDate().Unix(), commit.Author.GetDate().Format("-0700")))
-
-	committer := commit.Committer
-	if committer == nil {
-		committer = commit.Author
-	}
-
-	// There needs to be a double newline after committer
-	message = append(message, fmt.Sprintf("committer %s <%s> %d %s\n", committer.GetName(), committer.GetEmail(), committer.GetDate().Unix(), committer.GetDate().Format("-0700")))
-	message = append(message, *commit.Message)
-
-	return strings.Join(message, "\n"), nil
-}