kit

README

Kit

This project is a collection of often-used io related methods with sane defaults to make coding less verbose.

Modules

os

Covers most used os related functions that are missing from the stdlib.

Such as the smart glob that handles git ignore properly:

package main

import "github.com/ysmood/kit"

func main() {
    kit.Log(kit.Walk("**/*.go", "**/*.md", kit.WalkGitIgnore).MustList())
}

A better Exec alternative:

package main

import "github.com/ysmood/kit"

func main() {
    kit.Exec("echo", "ok").MustDo()

    str := kit.Exec("echo", "ok").MustString()

    kit.Log(str)
}

http

The http lib from stdlib is pretty verbose to use. The kit.Req is a much better alternative to use with its fluent api design. It helps to reduce the code without sacrificing performance and flexibility. No api is hidden from the origin of http lib.

package main

import "github.com/ysmood/kit"

func main() {
    val := kit.Req("http://test.com").Post().Form(
        "search", "keyword",
        "even", []string{"array", "is", "supported"},
    ).MustJSON().Get("json.path.value").String()

    kit.Log(val)
}

package main

import "github.com/ysmood/kit"

func main() {
    server := kit.MustServer(":8080")
    server.Engine.GET("/", func(ctx kit.GinContext) {
        ctx.String(200, "ok")
    })
    server.MustDo()
}

CLI tool

Goto the release page to download the executable for your OS. Or install with single line command below.

godev

A general dev tool for go project to lint, test, build, deploy cross-platform executable.

godev will release your project to your own github release page. Project released with godev can be installed via this shell script. godev itself is an example of how to use it.

Install godev: curl -L https://git.io/fjaxx | repo=ysmood/kit bin=godev sh

usage: godev [<flags>] <command> [<args> ...]

dev tool for common go project

Flags:
  --help                     Show context-sensitive help (also try --help-long
                             and --help-man).
  --version                  Show application version.
  --cov-path="coverage.txt"  path for coverage output

Commands:
  help [<command>...]
    Show help.

  test* [<flags>] [<match>]
    run go unit test

  lint [<path>...]
    lint project with golint and golangci-lint

  build [<flags>] [<pattern>...]
    build [and deploy] specified dirs

  cov
    view html coverage report

guard

Install guard: curl -L https://git.io/fjaxx | repo=ysmood/kit bin=guard sh

usage: guard [<flags>]

run and guard a command, kill and rerun it when watched files are modified

  Examples:

   # follow the "--" is the command and its arguments you want to execute
   # kill and restart the web server when a file changes
   guard -- node server.js

   # use ! prefix to ignore pattern, the below means watch all files but not those in tmp dir
   guard -w '**' -w '!tmp/**' -- echo changed

   # the special !g pattern will read the gitignore files and ignore patterns in them
   # the below is the default patterns guard will use
   guard -w '**' -w '!g' -- echo changed

   # support go template
   guard -- echo {{op}} {{path}} {{file}}

   # watch and sync current dir to another machine
   guard -n -- rsync {{path}} root@host:/home/me/app/{{path}}
   guard -n -- docker cp {{path}} my-container:/app/{{path}}

   # the patterns must be quoted
   guard -w '*.go' -w 'lib/**/*.go' -- go run main.go

   # the output will be prefix with red 'my-app | '
   guard -p 'my-app | @red' -- python test.py

   # use "---" as separator to guard multiple commands
   guard -w 'a/*' -- ls a --- -w 'b/*' -- ls b


Flags:
      --help             Show context-sensitive help (also try --help-long and
                         --help-man).
  -w, --watch=WATCH ...  the pattern to watch, can set multiple patterns
  -d, --dir=DIR          base dir path
  -p, --prefix="auto"    prefix for command output
  -c, --clear-screen     clear screen before each run
  -n, --no-init-run      don't execute the cmd on startup
      --poll=300ms       poll interval
      --debounce=300ms   suppress the frequency of the event
      --raw              when you need to interact with the subprocess
      --version          Show application version.

You can also use it as a lib:

package main

import "github.com/ysmood/kit"

func main() {
    kit.Guard("go", "run", "./server").ExecCtx(
        kit.Exec().Prefix("server | @yellow"),
    ).MustDo()
}

Test & Build

See the Github Actions config in this project.

Documentation

Index

• Variables
• type ErrInjector
• type ExecContext
• type GinContext
• type GuardContext
• type JSONResult
• type Matcher
• type MkdirOptions
• type Nil
• type OutputFileOptions
• type ReqContext
• type ServerContext
• type Sleeper
• type TaskCmd
• type TaskContext
• type TasksContext
• type WalkContext
• type WalkDirent
• type WalkFunc

Variables

var All = utils.All

All imported

var BackoffSleeper = utils.BackoffSleeper

BackoffSleeper imported

var C = utils.C

C imported

var CD = os.CD

CD imported

var Chmod = os.Chmod

Chmod imported

var ClearScreen = utils.ClearScreen

ClearScreen imported

var Copy = os.Copy

Copy imported

var CountSleeper = utils.CountSleeper

CountSleeper imported

var DefaultBackoff = utils.DefaultBackoff

DefaultBackoff imported

var DirExists = os.DirExists

DirExists imported

var Dump = utils.Dump

Dump imported

var E = utils.E

E imported

var E1 = utils.E1

E1 imported

var Err = utils.Err

Err imported

var ErrArg = utils.ErrArg

ErrArg imported

var ErrMaxSleepCount = utils.ErrMaxSleepCount

ErrMaxSleepCount imported

var Escape = os.Escape

Escape imported

var Exec = run.Exec

Exec imported

var ExecutableExt = os.ExecutableExt

ExecutableExt imported

var Exists = os.Exists

Exists imported

var FileExists = os.FileExists

FileExists imported

var GoBin = run.GoBin

GoBin imported

var GoPath = run.GoPath

GoPath imported

var Guard = run.Guard

Guard imported

var GuardDefaultPatterns = run.GuardDefaultPatterns

GuardDefaultPatterns imported

var HomeDir = os.HomeDir

HomeDir imported

var JSON = utils.JSON

JSON imported

var KillTree = run.KillTree

KillTree imported

var Log = utils.Log

Log imported

var LookPath = run.LookPath

LookPath imported

var MergeSleepers = utils.MergeSleepers

MergeSleepers imported

var Mkdir = os.Mkdir

Mkdir imported

var Move = os.Move

Move imported

var MustGoTool = run.MustGoTool

MustGoTool imported

var MustServer = http.MustServer

MustServer imported

var MustToJSON = utils.MustToJSON

MustToJSON imported

var MustToJSONBytes = utils.MustToJSONBytes

MustToJSONBytes imported

var NewMatcher = os.NewMatcher

NewMatcher imported

var Noop = utils.Noop

Noop imported

var OutputFile = os.OutputFile

OutputFile imported

var Pause = utils.Pause

Pause imported

var RandBytes = utils.RandBytes

RandBytes imported

var RandString = utils.RandString

RandString imported

var ReadFile = os.ReadFile

ReadFile imported

var ReadJSON = os.ReadJSON

ReadJSON imported

var ReadString = os.ReadString

ReadString imported

var Remove = os.Remove

Remove imported

var RemoveWithDir = os.RemoveWithDir

RemoveWithDir imported

var Req = http.Req

Req imported

var Retry = utils.Retry

Retry imported

var RetryPanic = os.RetryPanic

RetryPanic imported

var S = utils.S

S imported

var Sdump = utils.Sdump

Sdump imported

var SendSigInt = os.SendSigInt

SendSigInt imported

var Server = http.Server

Server imported

var Sleep = utils.Sleep

Sleep imported

var Stderr = utils.Stderr

Stderr imported

var Stdout = utils.Stdout

Stdout imported

var Task = run.Task

Task imported

var Tasks = run.Tasks

Tasks imported

var TasksNew = run.TasksNew

TasksNew imported

var Try = utils.Try

Try imported

var Version = utils.Version

Version imported

var WaitSignal = os.WaitSignal

WaitSignal imported

var Walk = os.Walk

Walk imported

var WalkGitIgnore = os.WalkGitIgnore

WalkGitIgnore imported

var WalkIgnoreHidden = os.WalkIgnoreHidden

WalkIgnoreHidden imported

Types

type ErrInjector

type ErrInjector = utils.ErrInjector

ErrInjector imported

type ExecContext

type ExecContext = run.ExecContext

ExecContext imported

type GinContext

type GinContext = http.GinContext

GinContext imported

type GuardContext

type GuardContext = run.GuardContext

GuardContext imported

type JSONResult

type JSONResult = utils.JSONResult

JSONResult imported

type Matcher

type Matcher = os.Matcher

Matcher imported

type MkdirOptions

type MkdirOptions = os.MkdirOptions

MkdirOptions imported

type Nil

type Nil = utils.Nil

Nil imported

type OutputFileOptions

type OutputFileOptions = os.OutputFileOptions

OutputFileOptions imported

type ReqContext

type ReqContext = http.ReqContext

ReqContext imported

type ServerContext

type ServerContext = http.ServerContext

ServerContext imported

type Sleeper

type Sleeper = utils.Sleeper

Sleeper imported

type TaskCmd

type TaskCmd = run.TaskCmd

TaskCmd imported

type TaskContext

type TaskContext = run.TaskContext

TaskContext imported

type TasksContext

type TasksContext = run.TasksContext

TasksContext imported

type WalkContext

type WalkContext = os.WalkContext

WalkContext imported

type WalkDirent

type WalkDirent = os.WalkDirent

WalkDirent imported

type WalkFunc

type WalkFunc = os.WalkFunc

WalkFunc imported