package main import ( "bytes" "context" "fmt" "io" "io/ioutil" "os" "regexp" "strings" "golang.org/x/oauth2" "github.com/Luzifer/go_helpers/str" "github.com/Luzifer/rconfig" "github.com/flosch/pongo2" "github.com/google/go-github/github" log "github.com/sirupsen/logrus" ) var ( cfg = struct { Blacklist []string `flag:"blacklist,b" default:"" description:"Repos to ignore even when matched through filters"` ExpandMatches bool `flag:"expand-matches" default:"false" description:"Replace matched repos with their full version"` Filters []string `flag:"filter,f" default:"" description:"Filters to match the repos against"` GithubToken string `flag:"token" default:"" env:"GITHUB_TOKEN" description:"Token to access Github API"` LogLevel string `flag:"log-level" default:"info" description:"Log level for output (debug, info, warn, error, fatal)"` NameRegex string `flag:"name-regex" default:".*" description:"Regex to match the name against"` Output string `flag:"out,o" default:"-" description:"File to write to (- = stdout)"` Template string `flag:"template" default:"" description:"Template file to use for rendering" validate:"nonzero"` VersionAndExit bool `flag:"version" default:"false" description:"Prints current version and exits"` }{} client *github.Client version = "dev" ) func init() { if err := rconfig.ParseAndValidate(&cfg); err != nil { log.Fatalf("Unable to parse commandline options: %s", err) } if l, err := log.ParseLevel(cfg.LogLevel); err != nil { log.WithError(err).Fatalf("Could not parse log level") } else { log.SetLevel(l) } if cfg.VersionAndExit { fmt.Printf("repo-template %s\n", version) os.Exit(0) } } func main() { ctx := context.Background() ts := oauth2.StaticTokenSource( &oauth2.Token{AccessToken: cfg.GithubToken}, ) tc := oauth2.NewClient(ctx, ts) client = github.NewClient(tc) repos, err := fetchRepos() if err != nil { log.WithError(err).Fatal("Error while fetching repos") } for _, repo := range repos { if !regexp.MustCompile(cfg.NameRegex).MatchString(*repo.FullName) { continue } if str.StringInSlice(*repo.FullName, cfg.Blacklist) { continue } skip := false for _, f := range cfg.Filters { if f == "" { continue } var ( inverse = false filter = f ) if strings.HasPrefix(filter, "no-") { inverse = true filter = filter[3:] } if filters[filter](repo) == inverse { log.WithFields(log.Fields{ "filter": filter, "repo": *repo.FullName, }).Debug("Repo was filtered") skip = true } } if skip { continue } if cfg.ExpandMatches { if err := expandRepo(repo); err != nil { log.WithError(err).Error("Unable to expand repo") } } log.WithFields(log.Fields{ "repo": *repo.FullName, "private": *repo.Private, "fork": *repo.Fork, }).Print("Found repo") if err := render(repo); err != nil { log.WithError(err).Error("Unable to render output") continue } } } func expandRepo(repo *github.Repository) error { ctx := context.Background() r, _, err := client.Repositories.Get(ctx, *repo.Owner.Login, *repo.Name) if err != nil { return err } *repo = *r return nil } func fetchRepos() ([]*github.Repository, error) { var ( ctx = context.Background() repos = []*github.Repository{} ) opt := &github.RepositoryListOptions{ ListOptions: github.ListOptions{PerPage: 100}, } for { rs, res, err := client.Repositories.List(ctx, "", opt) if err != nil { return nil, err } repos = append(repos, rs...) if res.NextPage == 0 { break } opt.Page = res.NextPage } return repos, nil } func render(repo *github.Repository) error { var outFile io.Writer if cfg.Output == "-" { outFile = os.Stdout } else { outName, err := getOutfile(repo) if err != nil { return err } log.WithFields(log.Fields{ "repo": *repo.FullName, "outName": outName, }).Debug("") f, err := os.Create(outName) if err != nil { return err } defer f.Close() outFile = f } tplRaw, err := ioutil.ReadFile(cfg.Template) if err != nil { return err } tpl, err := pongo2.FromString(string(tplRaw)) if err != nil { return err } return tpl.ExecuteWriter(pongo2.Context{ "repo": repo, }, outFile) } func getOutfile(repo *github.Repository) (string, error) { tpl, err := pongo2.FromString(cfg.Output) if err != nil { return "", err } buf := new(bytes.Buffer) err = tpl.ExecuteWriter(pongo2.Context{ "repo": repo, }, buf) return buf.String(), err } func simpleReplace(s, old, new string) string { return strings.Replace(s, old, new, -1) }