Script that checks which component dependencies need to be updated.

check.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"
	"sync"

	"golang.org/x/oauth2"

	"github.com/blang/semver"
	"github.com/google/go-github/github"
	"github.com/tj/docopt"
)

const (
	usage = `Script to check which component dependencies need to be updated.
Usage:
  check [--token=<token>] [--file=<file>]
  check -h | --help
  check --version
Options:
  --token=<token>  Github Token [default: ].
  --file=<file>    File to check [default: component.json].
  -h --help        Show this screen.
  --version        Show version.`

	version = "1.0.0"
)

var client *github.Client

func main() {
	args, err := docopt.Parse(usage, nil, true, version, false)
	check(err)

	token := args["--token"].(string)
	if token == "" {
		token = os.Getenv("GITHUB_TOKEN")
		if token == "" {
			log.Fatal("github token is required")
		}
	}
	file := args["--file"].(string)

	client = newGithub(token)

	var wg sync.WaitGroup
	component := readComponent(file)
	for dep, version := range component.Dependencies {
		wg.Add(1)
		go func(dep, version string) {
			defer wg.Done()
			checkForUpdates(dep, version)
		}(dep, version)
	}

	wg.Wait()
}

func checkForUpdates(dep, version string) {
	parts := strings.Split(dep, "/")
	org := parts[0]
	name := parts[1]

	pinned := replaceAll(version, "^~")

	v, err := semver.Make(pinned)
	if err != nil {
		fmt.Println("unknown dependency", dep, version)
		return
	}

	tagged := latestVersion(org, name)

	if tagged.Compare(v) > 0 {
		fmt.Printf("update \033[35m%s/%s\033[0m from \033[36m%s\033[0m to \033[36m%s\033[0m\n", org, name, v, tagged)
	}
}

func replaceAll(s, parts string) string {
	for _, p := range parts {
		s = strings.Replace(s, string(p), "", -1)
	}
	return s
}

type Component struct {
	Dependencies map[string]string `json"dependencies"`
}

func readComponent(file string) Component {
	f, err := os.Open(file)
	check(err)
	defer f.Close()

	var c Component
	e := json.NewDecoder(f)
	err = e.Decode(&c)
	check(err)
	return c
}

func newGithub(token string) *github.Client {
	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
	tc := oauth2.NewClient(oauth2.NoContext, ts)
	return github.NewClient(tc)
}

func latestVersion(org, name string) semver.Version {
	opt := &github.ListOptions{PerPage: 100}

	latest, err := semver.Make("0.0.1")
	check(err)

	for {
		newTags, resp, err := client.Repositories.ListTags(org, name, opt)
		check(err)

		for _, tag := range newTags {
			version, err := semver.Make(*tag.Name)
			if err != nil {
				continue
			}

			if version.Compare(latest) > 0 {
				latest = version
			}
		}

		if resp.NextPage == 0 {
			break
		}

		opt.Page = resp.NextPage
	}

	return latest
}

func check(err error) {
	if err != nil {
		log.Fatal(err.Error())
	}
}