Generate go package heatmap

heatmap.go

package main

import (
    "os"
    "fmt"
    "sort"
    "sync"
    "runtime"
    "go/token"
    "go/parser"
    "path/filepath"
)

type sortMap struct {
    keys []string
    vals []int
}

func main() {
    dir := "."
    if len(os.Args) > 1 {
        dir = os.Args[1]
    }
    wg := sync.WaitGroup{}
    mux := sync.Mutex{}
    sem := make(chan struct{}, runtime.NumCPU())
    fset := token.NewFileSet()
    imports := make(map[string]int)
    filepath.Walk(dir, func(path string, ent os.FileInfo, err error) error {
        if filepath.Ext(path) != ".go" {
            return nil
        }
        wg.Add(1)
        go func() {
            semadd(sem)
            f, err := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
            if err != nil {
                semrem(sem)
                wg.Done()
                return
            }
            mux.Lock()
            for i := 0; i < len(f.Imports); i++ {
                imports[f.Imports[i].Path.Value]++
            }
            mux.Unlock()
            semrem(sem)
            wg.Done()
        }()
        return nil
    })
    wg.Wait()
    s := sortMap{
        keys: make([]string, len(imports)),
        vals: make([]int, len(imports)),
    }
    var i int
    for pkg, num := range imports {
        s.keys[i] = pkg
        s.vals[i] = num
        i++
    }
    sort.Sort(s)
    for i := 0; i < len(s.keys); i++ {
        fmt.Printf("%d\t%s\n", s.vals[i], s.keys[i])
    }
}

func (s sortMap) Len() int {
    return len(s.vals)
}

func (s sortMap) Less(i, j int) bool {
    if s.vals[i] == s.vals[j] {
        return s.keys[i] < s.keys[j]
    }
    return s.vals[i] > s.vals[j]
}

func (s sortMap) Swap(i, j int) {
    s.keys[i], s.keys[j] = s.keys[j], s.keys[i]
    s.vals[i], s.vals[j] = s.vals[j], s.vals[i]
}

func semadd(sem chan<- struct{}) {
    sem <- struct{}{}
}

func semrem(sem <-chan struct{}) {
    <-sem
}