Go 言語用 CLI プログラミング支援パッケージ

package main

import (
    "os"

    "github.com/goark/gocli/exitcode"
    "github.com/goark/gocli/rwi"
)

func run(ui *rwi.RWI) exitcode.ExitCode {
    ui.Outputln("Hello world")
    return exitcode.Normal
}

func main() {
    run(rwi.New(
        rwi.WithReader(os.Stdin),
        rwi.WithWriter(os.Stdout),
        rwi.WithErrorWriter(os.Stderr),
    )).Exit()
}

outBuf := new(bytes.Buffer)
outErrBuf := new(bytes.Buffer)
code := run(rwi.New(
    rwi.WithWriter(outBuf),
    rwi.WithErrorWriter(outErrBuf),
))

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    "github.com/goark/gocli/signal"
)

func ticker(ctx context.Context) error {
    t := time.NewTicker(1 * time.Second) // 1 second cycle
    defer t.Stop()

    for {
        select {
        case now := <-t.C: // ticker event
            fmt.Println(now.Format(time.RFC3339))
        case <-ctx.Done(): // cancel event from context
            fmt.Println("Stop ticker")
            return ctx.Err()
        }
    }
}

func Run() error {
    errCh := make(chan error, 1)
    defer close(errCh)

    go func() {
        child, cancelChild := context.WithTimeout(
            signal.Context(context.Background(), os.Interrupt), // cancel event by SIGNAL
            10*time.Second, // timeout after 10 seconds
        )
        defer cancelChild()
        errCh <- ticker(child)
    }()

    err := <-errCh
    fmt.Println("Done")
    return err
}

func main() {
    if err := Run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

package main

import (
    "fmt"

    "github.com/goark/gocli/file"
)

func main() {
    result := file.Glob("**/*.[ch]", nil)
    fmt.Println(result)
    // Output:
    // [testdata/include/source.h testdata/source.c]
}

package main

import (
    "fmt"

    "github.com/goark/gocli/file"
)

func main() {
    result := file.Glob(
        "**/*.[ch]",
        file.NewGlobOption(file.WithFlags(file.GlobStdFlags|file.GlobAbsolutePath)))
    fmt.Println(result)
    // Output:
    // [/home/username/work/gocli/file/testdata/include/source.h /home/username/work/gocli/file/testdata/source.c]
}

//Operation flag in Glob() function.
const (
    GlobContainsFile GlobFlag = 1 << iota
    GlobContainsDir
    GlobSeparatorSlash
    GlobAbsolutePath
    GlobStdFlags = GlobContainsFile | GlobContainsDir
)

package main

import (
    "fmt"

    "github.com/goark/gocli/config"
)

func main() {
    path := config.Path("app", "config.json")
    fmt.Println(path)
    // Output:
    // /home/username/.config/app/config.json
}

// UserConfigDir returns the default root directory to use for user-specific
// configuration data. Users should create their own application-specific
// subdirectory within this one and use that.
//
// On Unix systems, it returns $XDG_CONFIG_HOME as specified by
// https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html if
// non-empty, else $HOME/.config.
// On Darwin, it returns $HOME/Library/Application Support.
// On Windows, it returns %AppData%.
// On Plan 9, it returns $home/lib.
//
// If the location cannot be determined (for example, $HOME is not defined),
// then it will return an error.
func UserConfigDir() (string, error) {
    var dir string

    switch runtime.GOOS {
    case "windows":
        dir = Getenv("AppData")
        if dir == "" {
            return "", errors.New("%AppData% is not defined")
        }

    case "darwin":
        dir = Getenv("HOME")
        if dir == "" {
            return "", errors.New("$HOME is not defined")
        }
        dir += "/Library/Application Support"

    case "plan9":
        dir = Getenv("home")
        if dir == "" {
            return "", errors.New("$home is not defined")
        }
        dir += "/lib"

    default: // Unix
        dir = Getenv("XDG_CONFIG_HOME")
        if dir == "" {
            dir = Getenv("HOME")
            if dir == "" {
                return "", errors.New("neither $XDG_CONFIG_HOME nor $HOME are defined")
            }
            dir += "/.config"
        }
    }

    return dir, nil
}

package main

import (
    "fmt"

    "github.com/goark/gocli/cache"
)

func main() {
    path := cache.Path("app", "access.log")
    fmt.Println(path)
    // Output:
    // /home/username/.cache/app/access.log
}

// UserCacheDir returns the default root directory to use for user-specific
// cached data. Users should create their own application-specific subdirectory
// within this one and use that.
//
// On Unix systems, it returns $XDG_CACHE_HOME as specified by
// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html if
// non-empty, else $HOME/.cache.
// On Darwin, it returns $HOME/Library/Caches.
// On Windows, it returns %LocalAppData%.
// On Plan 9, it returns $home/lib/cache.
//
// If the location cannot be determined (for example, $HOME is not defined),
// then it will return an error.
func UserCacheDir() (string, error) {
    var dir string

    switch runtime.GOOS {
    case "windows":
        dir = Getenv("LocalAppData")
        if dir == "" {
            return "", errors.New("%LocalAppData% is not defined")
        }

    case "darwin", "ios":
        dir = Getenv("HOME")
        if dir == "" {
            return "", errors.New("$HOME is not defined")
        }
        dir += "/Library/Caches"

    case "plan9":
        dir = Getenv("home")
        if dir == "" {
            return "", errors.New("$home is not defined")
        }
        dir += "/lib/cache"

    default: // Unix
        dir = Getenv("XDG_CACHE_HOME")
        if dir == "" {
            dir = Getenv("HOME")
            if dir == "" {
                return "", errors.New("neither $XDG_CACHE_HOME nor $HOME are defined")
            }
            dir += "/.cache"
        }
    }

    return dir, nil
}