func cliSetup() *cliOptions {
options := newCliOptions()
var httpVerb = goopt.StringWithLabel([]string{"-X", "--command"}, options.httpVerb,
"COMMAND", fmt.Sprintf("HTTP verb for request: %s", HttpVerbs))
var httpHeaders = goopt.Strings([]string{"-H", "--header"},
"KEY:VALUE", "Custom HTTP Headers to be sent with request (can pass multiple times)")
var postData = goopt.StringWithLabel([]string{"-d", "--data"}, options.postData,
"DATA", "HTTP Data for POST")
var timeOut = goopt.IntWithLabel([]string{"-t", "--timeout"}, options.timeout,
"TIMEOUT", "Timeout in seconds for request")
var shouldRedirect = goopt.Flag([]string{"-r", "--redirect"}, []string{}, "Follow redirects", "")
var isVerbose = goopt.Flag([]string{"-v", "--verbose"}, []string{}, "Verbose output", "")
var hasColor = goopt.Flag([]string{"-c", "--color"}, []string{}, "Colored output", "")
var isInsecureSSL = goopt.Flag([]string{"-k", "--insecure"}, []string{}, "Allow insecure https connections", "")
goopt.Summary = "Golang based http client program"
goopt.Parse(nil)
options.httpVerb = *httpVerb
options.httpHeaders = *httpHeaders
options.postData = *postData
options.timeout = *timeOut
options.verbose = *isVerbose
options.redirect = *shouldRedirect
options.color = *hasColor
options.sslInsecure = *isInsecureSSL
options.arguments = goopt.Args
exitWithMessageIfNonZero(validateOptions(options))
exitWithMessageIfNonZero(validateArguments(options))
return options
}
func main() {
var no_cog = goopt.Flag([]string{"-C", "--no-cog"}, []string{"-c", "--cog"},
"skip opening in cog", "open in cog")
var no_delete = goopt.Flag([]string{"-D", "--no-delete"}, []string{"-d", "--delete"},
"skip deleting original zip", "delete original zip")
goopt.Parse(nil)
boomkat(goopt.Args[0], *no_cog, *no_delete)
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Rmdir"
goopt.Summary = "Remove each DIRECTORY if it is empty"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... DIRECTORY...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
ignorefail := goopt.Flag([]string{"--ignore-fail-on-non-empty"}, nil,
"Ignore each failure that is from a directory not being empty", "")
parents := goopt.Flag([]string{"-p", "--parents"}, nil, "Remove DIRECTORY and ancestors if ancestors become empty", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each directory as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
for i := range goopt.Args {
filelisting, err := ioutil.ReadDir(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to remove %s: %v\n", os.Args[i+1], err)
defer os.Exit(1)
continue
}
if !*ignorefail && len(filelisting) > 0 {
fmt.Fprintf(os.Stderr, "Failed to remove '%s' directory is non-empty\n", goopt.Args[i])
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Removing directory %s\n", goopt.Args[i])
}
err = os.Remove(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to remove %s: %v\n", goopt.Args[i], err)
defer os.Exit(1)
continue
}
if !*parents {
continue
}
dir := goopt.Args[i]
if dir[len(dir)-1] == '/' {
dir = filepath.Dir(dir)
}
if removeEmptyParents(dir, *verbose, *ignorefail) {
defer os.Exit(1)
}
}
return
}
func main() {
atime = time.Now()
mtime = time.Now()
goopt.Author = "William Pearson"
goopt.Version = "Touch"
goopt.Summary = "Change access or modification time of each FILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... FILE...\n", os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
access := goopt.Flag([]string{"-a"}, nil, "Only change access time", "")
modify := goopt.Flag([]string{"-m"}, nil, "Only change modification time", "")
create := goopt.Flag([]string{"-c"}, nil, "Only change modification time", "")
Nodereference = goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
goopt.OptArg([]string{"-r", "--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
goopt.OptArg([]string{"-t"}, "STAMP", "Use [[CC]YY]MMDDhhmm[.ss] instead of now. Note hh is interpreted as from 00 to 23", fromStamp)
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
coreutils.Noderef = *Nodereference
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
if !*access && !*modify {
*access, *modify = true, true
}
for i := range goopt.Args {
if !*access {
atime, _ = GetAtimeMtime(goopt.Args[i], *Nodereference)
}
if !*modify {
_, mtime = GetAtimeMtime(goopt.Args[i], *Nodereference)
}
if err := os.Chtimes(goopt.Args[i], atime, mtime); err != nil {
if os.IsNotExist(err) {
var err error
if !*create {
f, err := os.Create(goopt.Args[i])
if err == nil {
f.Close()
}
}
if err == nil {
continue
}
}
fmt.Fprintf(os.Stderr, "Error touching file '%s': %v\n", goopt.Args[i], err)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Chmod"
goopt.Summary = "Change file mode of each FILE to MODE\nWith reference, change file mode of each FILE to that of RFILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [MODE] FILE...\n or:\t%s [OPTION]... --reference=RFILE FILE...\n", os.Args[0], os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
silent := goopt.Flag([]string{"-f", "--silent", "--quiet"}, nil, "Suppress most error messages", "")
/*changes := goopt.Flag([]string{"-c", "--changes"}, nil, "Like verbose but only report changes", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")*/
nodereference := goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
preserveroot := goopt.Flag([]string{"--preserve-root"}, []string{"--no-preserve-root"}, "Don't recurse on '/'", "Treat '/' normally (This is default)")
goopt.OptArg([]string{"--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
recurse := goopt.Flag([]string{"-R", "--recursive"}, nil, "Operate recursively on files and directories", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
coreutils.Noderef = *nodereference
coreutils.Preserveroot = *preserveroot
if !usingreference {
coreutils.ParseMode(goopt.Args[0])
}
var filestomod []string
for i := range goopt.Args[1:] {
filestomod = append(filestomod, goopt.Args[i+1])
if *recurse && (!*preserveroot || goopt.Args[i+1] != "/") {
if coreutils.Recurse(&filestomod) {
defer os.Exit(1)
}
}
}
for i := range filestomod {
err := os.Chmod(filestomod[i], coreutils.Mode)
if err != nil && !*silent {
fmt.Fprintf(os.Stderr, "Error changing mode for file '%s': %v\n", filestomod[i], err)
defer os.Exit(1)
continue
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Echo"
goopt.Summary = "Echo ARGs to stdout."
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [SHORT-OPTION] ARGS...\n or:\t%s LONG-OPTION\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nValid backslash escape sequences go here."
}
goopt.NoArg([]string{"-v", "--version"}, "outputs version information and exits", coreutils.Version)
newline := goopt.Flag([]string{"-n"}, nil, "Don't print out a newline after ARGS", "")
backslashescape := goopt.Flag([]string{"-e"}, []string{"-E"}, "Enable interpretation of backslash escapes", "Disable interpretation of backslash escapes")
goopt.Parse(nil)
argstring := strings.Join(goopt.Args, " ")
if *backslashescape {
argstring = fmt.Sprintf("%q", argstring)
argstring = strings.Replace(argstring, "\\\\", "\\", -1)
validEscapeSeqs := "\\abcefnrtv0x"
for i := 0; i < len(argstring); i++ {
if argstring[i] != '\\' {
continue
}
if !strings.Contains(validEscapeSeqs, string(argstring[i+1])) {
argstring = argstring[:i] + "\\" + argstring[i:]
}
i++
}
backslashstring, err := strconv.Unquote(argstring)
if err != nil {
fmt.Fprintf(os.Stderr, "Error encountered when interpreting escape sequences: %v\n", err)
os.Exit(1)
}
argstring = backslashstring
}
nl := "\n"
if *newline {
nl = ""
}
fmt.Printf("%s%s", argstring, nl)
return
}
func main() {
coreutils.Mode = 1<<31 | coreutils.Mode
goopt.Author = "William Pearson"
goopt.Version = "Mkdir"
goopt.Summary = "Create each DIRECTORY, if it does not already exist."
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... DIRECTORY...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
goopt.OptArg([]string{"-m", "--mode"}, "MODE", "Set file mode permissions", coreutils.ParseMode)
parents := goopt.Flag([]string{"-p", "--parents"}, nil, "Make parent directories as needed, no error if existing", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each directory as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
for i := range goopt.Args {
if *parents {
if createParents(goopt.Args[i], *verbose) {
defer os.Exit(1)
}
continue
}
if *verbose {
fmt.Printf("Creating directory %s\n", goopt.Args[i])
}
err := os.Mkdir(goopt.Args[i], coreutils.Mode)
if err != nil {
fmt.Fprintf(os.Stderr, "Error creating direction %s: %v\n", goopt.Args[i], err)
defer os.Exit(1)
}
}
return
}
func init() {
format = goopt.String([]string{"--fmt", "--format"}, "",
"Log format (e.g. '$remote_addr [$time_local] \"$request\"')")
nginxConfig = goopt.String([]string{"--nginx"}, "",
"Nginx config to look for 'log_format' directive. You also should specify --nginx-format")
nginxFormat = goopt.String([]string{"--nginx-format"}, "",
"Name of nginx 'log_format', should be passed with --nginx option")
aggField = goopt.String([]string{"-a", "--aggregate"}, "request_time",
"Nginx access log variable to aggregate")
groupBy = goopt.String([]string{"-g", "--group-by"}, "request",
"Nginx access log variable to group by")
groupByRegexp = goopt.String([]string{"-r", "--regexp"}, "",
"You can specify regular expression to extract exact data from group by data. "+
"For example, you might want to group by a path inside $request, so you should "+
"set this option to '^\\S+\\s(.*)(?:\\?.*)?$'.")
groupByGeneralize = goopt.String([]string{"--generalize"}, "",
"Regular expression to generalize data. For example to make /foo/123 and /foo/234 equal")
debug = goopt.Flag([]string{"--debug"}, []string{"--no-debug"},
"Log debug information", "Do not log debug information")
jsonOutput = goopt.String([]string{"-o", "--json"}, "",
"Save result as json encoded file")
}
func main() {
var progname = os.Args[0][strings.LastIndex(os.Args[0], "/")+1:]
var algorithm = goopt.StringWithLabel([]string{"-a", "--algorithm"}, algorithms[0],
"ALG", fmt.Sprintf("Hashing algorithm: %s", algorithms))
var version = goopt.Flag([]string{"-V", "--version"}, []string{}, "Display version", "")
goopt.Summary = fmt.Sprintf("%s [OPTIONS] FILENAME\n\nMessage digest calculator with various hashing algorithms.\n\nArguments:\n FILENAME File(s) to hash\n", progname)
goopt.Parse(nil)
var files []string = goopt.Args
if *version {
fmt.Printf("%s version %s\n", progname, Version)
os.Exit(0)
}
validateAlgorithm(goopt.Usage(), *algorithm)
valildateFiles(goopt.Usage(), files)
calculateDigest(files, *algorithm)
os.Exit(0)
}
func init() {
goopt.Description = func() string {
return "conchk v" + goopt.Version
}
goopt.Author = "Bruce Fitzsimons <*****@*****.**>"
goopt.Version = "0.3"
goopt.Summary = "conchk is an IP connectivity test tool designed to validate that all configured IP connectivity actually works\n " +
"It reads a list of tests and executes them, in a parallel manner, based on the contents of each line" +
"conchk supports tcp and udp based tests (IPv4 and IPv6), at this time.\n\n" +
"==Notes==\n" +
"* The incuded Excel sheet is a useful way to create and maintain the tests\n" +
"* testing a range of supports is supported. In this case the rules for a successful test are somewhat different\n" +
"** If one of the ports gets a successful connect, and the rest are refused (connection refused) as nothing is listening\n" +
"\tthen this is considered to be a successful test of the range. This is the most common scenario in our experience;\n" +
"\tthe firewalls and routing are demonstrably working, and at least one destination service is ok. If you need all ports to work\n" +
"\tthen consider using individual tests\n" +
"* If all tests for this host pass, then conchk will exit(0). Otherwise it will exit(1)\n" +
"* conchk will use the current hostname, or the commandline parameter, to find the tests approprate to execute - matches on field 3.\n" +
"\tThis means all the tests for a system, or project can be placed in one file\n" +
"* The .csv output option will write a file much like the input file, but with two additional columns and without any comments\n" +
"\t This file can be fed back into conchk without error.\n\n" +
"See http://bwooce.github.io/conchk/ for more information.\n\n(c)2013 Bruce Fitzsimons.\n\n"
Hostname, _ := os.Hostname()
params.Debug = goopt.Flag([]string{"-d", "--debug"}, []string{}, "additional debugging output", "")
params.TestsFile = goopt.String([]string{"-T", "--tests"}, "./tests.conchk", "test file to load")
params.OutputFile = goopt.String([]string{"-O", "--outputcsv"}, "", "name of results .csv file to write to. A pre-existing file will be overwritten.")
params.MyHost = goopt.String([]string{"-H", "--host"}, Hostname, "Hostname to use for config lookup")
params.MaxStreams = goopt.Int([]string{"--maxstreams"}, 8, "Maximum simultaneous checks")
params.Timeout = goopt.String([]string{"--timeout"}, "5s", "TCP connectivity timeout, UDP delay for ICMP responses")
semStreams = make(semaphore, *params.MaxStreams)
runtime.GOMAXPROCS(runtime.NumCPU())
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Du"
goopt.Summary = "Estimate file sizes"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [FILE]...\n or:\t%s [OPTION]... --files0-from=F\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
null := goopt.Flag([]string{"-0", "--null"}, nil, "End output with \\0 instead of \\n", "")
all := goopt.Flag([]string{"-a", "--all"}, nil, "Write counts for all files instead of only directories", "")
goopt.OptArg([]string{"-B", "--block-size"}, "SIZE", "Set the block size that is used when printing.", setBlockSize)
/*bytes := goopt.Flag([]string{"-b", "--bytes"}, nil, "Equivalent to --block-size=1", "")*/
/*total := goopt.Flag([]string{"-c", "--total"}, nil, "Add up all the sizes to create a total", "")*/
derefargs := goopt.Flag([]string{"-D", "--dereference-args", "-H"}, nil, "Dereference symlinks if they are a commandline argument", "")
goopt.OptArg([]string{"-d", "--max-depth"}, "N", "Print total for directory that is N or fewer levels deep", setMaxDepth)
goopt.OptArg([]string{"--files0-from"}, "F", "Use \\0 terminated file names from file F as commandline arguments", setFile0From)
human = goopt.Flag([]string{"-h", "--human-readable"}, nil, "Output using human readable suffices", "")
/*kilo := goopt.Flag([]string{"-k"}, nil, "Equivalent to --block-size=1K", "")*/
dereference := goopt.Flag([]string{"-L", "--dereference"}, []string{"-P", "--no-dereference"}, "Dereference symbolic links", "Do not dereference any symbolic links (this is default)")
separate := goopt.Flag([]string{"-S", "--separate-dirs"}, nil, "Do not add subdirectories to a directory's size", "")
summarize := goopt.Flag([]string{"-s", "--summarize"}, nil, "Display totals only for each argument", "")
goopt.OptArg([]string{"-t", "--threshold"}, "SIZE", "Only include entries whose size is greater than or equal to SIZE", setThreshold)
/* Time and Exclude options go here */
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if *null {
lastchar = "\0000"
}
if len(goopt.Args) == 0 {
goopt.Args = append([]string{}, ".")
}
if *all && *summarize {
fmt.Fprintf(os.Stderr, "Cannot both summarize and display all. Pick ONE.\n")
coreutils.PrintUsage()
}
sysblocksize := int64(1)
kiloconst := int64(1)
for i := range goopt.Args {
fileinfo := Stat(goopt.Args[i], *dereference, *derefargs, true)
if sysblocksize == 1 && fileinfo.Mode < 32768 {
sizeperblock := int64(fileinfo.Size) / int64(fileinfo.Blocks)
sysblocksize := int64(1)
for sysblocksize < sizeperblock {
sysblocksize *= 2
}
if sysblocksize < 1024 {
kiloconst = 1024 / sysblocksize
}
}
deeper := append([]string{}, goopt.Args[i])
coreutils.Recurse(&deeper)
orig := true
startdepth := len(strings.Split(goopt.Args[i], string(os.PathSeparator)))
foldertosize := make(map[string]int64)
deepest := startdepth
maxdepth += startdepth
for j := range deeper {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] = 0
if len(strings.Split(deeper[j], string(os.PathSeparator))) > deepest {
deepest = len(strings.Split(deeper[j], string(os.PathSeparator)))
}
}
for deepest >= startdepth {
for j := range deeper {
if len(strings.Split(deeper[j], string(os.PathSeparator))) != deepest {
continue
}
fileinfo = Stat(deeper[j], *dereference, *derefargs, orig)
if fileinfo.Mode > 32768 {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] += fileinfo.Blocks / kiloconst
if maxdepth != startdepth && maxdepth < deepest {
continue
}
if *all {
fmt.Printf("%s\t%s%s", fmtSize(fileinfo.Blocks/2), deeper[j], lastchar)
}
} else {
foldertosize[filepath.Clean(deeper[j])] += fileinfo.Blocks / kiloconst
if !*separate && filepath.Dir(filepath.Clean(deeper[j])) != filepath.Clean(deeper[j]) {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] += foldertosize[filepath.Clean(deeper[j])]
}
if *summarize || (maxdepth < deepest && maxdepth != startdepth) {
continue
}
fmt.Printf("%s\t%s%s", fmtSize(foldertosize[filepath.Clean(deeper[j])]), deeper[j], lastchar)
}
}
deepest--
}
if *summarize {
fmt.Printf("%s\t%s%s", fmtSize(foldertosize[filepath.Dir(filepath.Clean(goopt.Args[i]))]), goopt.Args[i], lastchar)
}
}
return
}
"encoding/json"
"fmt"
goopt "github.com/droundy/goopt"
"net/http"
"path/filepath"
"strings"
)
var Version = "0.1"
var Summary = `gostatic path/to/config
Build a site.
`
var showVersion = goopt.Flag([]string{"-V", "--version"}, []string{},
"show version and exit", "")
var showProcessors = goopt.Flag([]string{"--processors"}, []string{},
"show internal processors", "")
var showSummary = goopt.Flag([]string{"--summary"}, []string{},
"print everything on stdout", "")
var showConfig = goopt.Flag([]string{"--show-config"}, []string{},
"dump config as JSON on stdout", "")
var doWatch = goopt.Flag([]string{"-w", "--watch"}, []string{},
"watch for changes and serve them as http", "")
var port = goopt.String([]string{"-p", "--port"}, "8000",
"port to serve on")
var verbose = goopt.Flag([]string{"-v", "--verbose"}, []string{},
"enable verbose output", "")
// used in Page.Changed()
var force = goopt.Flag([]string{"-f", "--force"}, []string{},
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Rm"
goopt.Summary = "Remove each FILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... FILE...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
force = goopt.Flag([]string{"-f", "--force"}, nil, "Ignore nonexistent files, don't prompt user", "")
prompteach = goopt.Flag([]string{"-i"}, nil, "Prompt before each removal", "")
promptonce = goopt.Flag([]string{"-I"}, nil, "Prompt before removing multiple files at once", "")
goopt.OptArg([]string{"--interactive"}, "WHEN", "Prompt according to WHEN", setPrompt)
/*onefs := goopt.Flag([]string{"--one-file-system"}, nil, "When -r is specified, skip directories on different filesystems", "")*/
nopreserveroot := goopt.Flag([]string{"--no-preserve-root"}, []string{"--preserve-root"}, "Do not treat '/' specially", "Do not remove '/' (This is default)")
recurse := goopt.Flag([]string{"-r", "-R", "--recursive"}, nil, "Recursively remove directories and their contents", "")
emptydir := goopt.Flag([]string{"-d", "--dir"}, nil, "Remove empty directories", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
promptno := true
var filenames []string
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
coreutils.Preserveroot = !*nopreserveroot
coreutils.Silent = *force
coreutils.Prompt = *prompteach || *promptonce
coreutils.PromptFunc = func(filename string, remove bool) bool {
var prompt string
if remove {
prompt = "Remove " + filename + "?"
} else {
prompt = "Recurse into " + filename + "?"
}
var response string
trueresponse := "yes"
falseresponse := "no"
for {
fmt.Print(prompt)
fmt.Scanln(&response)
response = strings.ToLower(response)
if strings.Contains(trueresponse, response) {
return true
} else if strings.Contains(falseresponse, response) || response == "" {
return false
}
}
}
for i := range goopt.Args {
_, err := os.Lstat(goopt.Args[i])
if *force && os.IsNotExist(err) {
continue
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", goopt.Args[i], err)
defer os.Exit(1)
continue
}
filenames = append(filenames, goopt.Args[i])
if *recurse {
if coreutils.Recurse(&filenames) {
defer os.Exit(1)
}
}
}
sort.Strings(filenames)
l := len(filenames) - 1
for i := range filenames {
fileinfo, err := os.Lstat(filenames[l-i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", filenames[l-i], err)
defer os.Exit(1)
continue
}
isadir := fileinfo.IsDir()
if *prompteach || *promptonce && (l-i)%3 == 1 {
promptno = coreutils.PromptFunc(filenames[l-i], true)
}
if !promptno {
continue
}
if !*emptydir && !*recurse && isadir {
fmt.Fprintf(os.Stderr, "Could not remove '%s': Is a directory\n", filenames[l-i])
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Removing '%s'\n", filenames[l-i])
}
err = os.Remove(filenames[l-i])
if err != nil && !(*force && os.IsNotExist(err)) {
fmt.Fprintf(os.Stderr, "Could not remove '%s': %v\n", filenames[l-i], err)
defer os.Exit(1)
}
}
return
}
"metrics.txt",
"the name of the file that contains the list of metric names")
var maxMetrics = goopt.Int([]string{"-x", "--maxmetrics"},
5000,
"the maximum number of metric names that will be used. if the number exceeds the number of names in the metric file the max in the file will be used")
var target = goopt.Alternatives(
[]string{"-t", "--target"},
[]string{TARGET_MONGO, TARGET_ZMQ, TARGET_TSDB},
"sets the destination of metrics generated, default is mongo")
var sendMode = goopt.Alternatives(
[]string{"-m", "--sendmode"},
[]string{MODE_CONNECT, MODE_BIND},
"mode used when sending requests over ZeroMQ, default is connect")
var doBatching = goopt.Flag(
[]string{"--batch"},
[]string{"--nobatch"},
"inserts into the database will be batched",
"inserts into the database will not be batched")
var batchSize = goopt.Int(
[]string{"-z", "--size", "--batchsize"},
1000,
"sets the size of batches when inserting into the database")
// Connects to a mongo database and sends a continuous stream of metric updates
// (inserts) to the server for a specified amount of time (default 60 seconds).
// At the end of the cycle the number of metrics inserted is displayed.
func main() {
goopt.Description = func() string {
return "Go test writer program for MongoDB."
}
goopt.Version = "1.0"
package promptcommit
import (
"github.com/droundy/goopt"
"../git/git"
"../git/plumbing"
"../util/out"
"../util/error"
"../util/exit"
"../util/debug"
box "./gotgo/box(git.CommitHash,git.Commitish)"
)
// To make --all the default, set *prompt.All to true.
var All = goopt.Flag([]string{"-a","--all"}, []string{"--interactive"},
"verb all commits", "prompt for commits interactively")
var Dryrun = goopt.Flag([]string{"--dry-run"}, []string{},
"just show commits that would be verbed", "xxxs")
var Verbose = goopt.Flag([]string{"-v","--verbose"}, []string{"-q","--quiet"},
"output commits that are verbed", "don't output commits that are verbed")
func Select(since, upto git.Commitish) (outh git.CommitHash) {
hs,e := plumbing.RevListDifference([]git.Commitish{upto}, []git.Commitish{since})
error.FailOn(e)
if len(hs) == 0 {
out.Println(goopt.Expand("No commits to verb!"))
exit.Exit(0)
}
if *Dryrun {
if err != 0 {
return 0, err1
}
// Handle exception for darwin
if darwin && r2 == 1 {
r1 = 0
}
return r1, 0
}
var config_file = goopt.String([]string{"-c", "--config"}, "/etc/ranger.conf", "config file")
var install_api_key = goopt.String([]string{"-i", "--install-api-key"}, "", "install api key")
var amForeground = goopt.Flag([]string{"--foreground"}, []string{"--background"}, "run foreground", "run background")
func setup_logger() {
filename := "/var/log/ranger/ranger.log"
// Create a default logger that is logging messages of FINE or higher to filename, no rotation
// log.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter(filename, false))
// =OR= Can also specify manually via the following: (these are the defaults, this is equivalent to above)
flw := l4g.NewFileLogWriter(filename, false)
if flw == nil {
fmt.Printf("No permission to write to %s, going to switch to stdout only\n", filename)
} else {
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(false)
flw.SetRotateSize(0)
import goopt "github.com/droundy/goopt"
import config "github.com/kless/goconfig/config"
var version = "0.1"
///////////////////////////////////
//
// Taken form goopt example
//
///////////////////////////////////
// The Flag function creates a boolean flag, possibly with a negating
// alternative. Note that you can specify either long or short flags
// naturally in the same list.
var amVerbose = goopt.Flag([]string{"-v", "--verbose"}, []string{"--quiet"},
"output verbosely this will also show the graphite data", "be quiet, instead")
// This is just a logging function that uses the verbosity flags to
// decide whether or not to log anything.
func log(x ...interface{}) {
if *amVerbose {
fmt.Println(x...)
}
}
///////////////////////////////////
///////////////////////////////////
func exists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Cp"
goopt.Summary = "Copy each SOURCE to DEST"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... SOURCE(...) DEST\n or:\t%s [OPTION]... -t DEST SOURCE\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
backup := goopt.Flag([]string{"-b", "--backup"}, nil, "Backup files before overwriting", "")
prompt := goopt.Flag([]string{"-i", "--interactive"}, nil, "Prompt before an overwrite. Override -f and -n.", "")
noclobber := goopt.Flag([]string{"-n", "--no-clobber"}, []string{"-f", "--force"}, "Do not overwrite", "Never prompt before an overwrite")
hardlink := goopt.Flag([]string{"-l", "--link"}, nil, "Make hard links instead of copying", "")
nodereference := goopt.Flag([]string{"-P", "--no-dereference"}, []string{"-L", "--dereference"}, "Never follow symlinks", "Always follow symlinks")
/*preserve := goopt.Flag([]string{"-p", "--preserve"}, nil, "Preserve mode, ownership and timestamp attributes", "")*/
recurse := goopt.Flag([]string{"-r", "-R", "--recurse"}, nil, "Recursively copy files from SOURCE to TARGET", "")
goopt.OptArg([]string{"-S", "--suffix"}, "SUFFIX", "Override the usual backup suffix", setBackupSuffix)
symlink := goopt.Flag([]string{"-s", "--symbolic-link"}, nil, "Make symlinks instead of copying", "")
goopt.OptArg([]string{"-t", "--target"}, "TARGET", "Set the target with a flag instead of at the end", setTarget)
update := goopt.Flag([]string{"-u", "--update"}, nil, "Move only when DEST is missing or older than SOURCE", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) < 2 {
coreutils.PrintUsage()
}
coreutils.Noderef = *nodereference
j := 0
if target == "" {
target = goopt.Args[len(goopt.Args)-1]
j = 1
}
var sources []string
for i := range goopt.Args[j:] {
sources = append(sources, goopt.Args[i])
if *recurse {
if coreutils.Recurse(&sources) {
defer os.Exit(1)
}
}
}
destinfo, err := coreutils.Stat(target)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error trying to get info to check if DEST is a directory: %v\n", err)
os.Exit(1)
}
isadir := err == nil && destinfo.IsDir()
if (len(goopt.Args) > 2 || (target != goopt.Args[len(goopt.Args)-1] && len(goopt.Args) > 1)) && !isadir {
fmt.Fprintf(os.Stderr, "Too many arguments for non-directory destination")
os.Exit(1)
}
for i := range sources {
dest := target
if sources[i] == "" {
continue
}
destinfo, err := coreutils.Stat(target)
exist := !os.IsNotExist(err)
if err != nil && exist {
fmt.Fprintf(os.Stderr, "Error trying to get info on target: %v\n", err)
os.Exit(1)
}
srcinfo, err := coreutils.Stat(sources[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error trying to get mod time on SRC: %v\n", err)
os.Exit(1)
}
mkdir := false
if srcinfo.IsDir() {
if isadir {
dest = dest + string(os.PathSeparator) + sources[i]
}
if !*recurse {
fmt.Printf("Skipping directory %s\n", sources[i])
continue
}
mkdir = true
} else if isadir {
dest = dest + string(os.PathSeparator) + filepath.Base(sources[i])
}
newer := true
if *update && exist {
newer = srcinfo.ModTime().After(destinfo.ModTime())
}
if !newer {
continue
}
promptres := true
if exist {
promptres = !*noclobber
if *prompt {
promptres = coreutils.PromptFunc(dest, false)
}
if promptres && *backup {
if err = os.Rename(dest, dest+backupsuffix); err != nil {
fmt.Fprintf(os.Stderr, "Error while backing up '%s' to '%s': %v\n", dest, dest+backupsuffix, err)
defer os.Exit(1)
continue
}
}
}
if !promptres {
continue
}
switch {
case mkdir:
if err = os.Mkdir(dest, coreutils.Mode); err != nil {
fmt.Fprintf(os.Stderr, "Error while making directory '%s': %v\n", dest, err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Copying directory '%s' to '%s'\n", sources[i], dest)
}
case *hardlink:
if err := os.Link(sources[i], dest); err != nil {
fmt.Fprintf(os.Stderr, "Error while linking '%s' to '%s': %v\n", dest, sources[i], err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Linked '%s' to '%s'\n", dest, sources[i])
}
case *symlink:
if err := os.Symlink(sources[i], dest); err != nil {
fmt.Fprintf(os.Stderr, "Error while linking '%s' to '%s': %v\n", dest, sources[i], err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Symlinked '%s' to '%s'\n", dest, sources[i])
}
default:
source, err := os.Open(sources[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error while opening source file '%s': %v\n", sources[i], err)
defer os.Exit(1)
continue
}
filebuf, err := ioutil.ReadAll(source)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while reading source file, '%s', for copying: %v\n", sources[i], err)
defer os.Exit(1)
continue
}
destfile, err := os.Create(dest)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while creating destination file, '%s': %v\n", dest, err)
defer os.Exit(1)
continue
}
destfile.Write(filebuf)
if *verbose {
fmt.Printf("'%s' copied to '%s'\n", sources[i], dest)
}
}
}
return
}
import (
"bytes"
"log"
"net"
"os/exec"
"regexp"
"strings"
"time"
"github.com/droundy/goopt"
)
var connect = goopt.String([]string{"-s", "--server"}, "127.0.0.1", "Server to connect to (and listen if listening)")
var port = goopt.Int([]string{"-p", "--port"}, 2222, "Port to connect to (and listen to if listening)")
var listen = goopt.Flag([]string{"-l", "--listen"}, []string{}, "Create a listening TFO socket", "")
func main() {
goopt.Parse(nil)
// IPv4 only for no real reason, could be v6 by adjusting the sizes
// here and where it's used
var serverAddr [4]byte
IP := net.ParseIP(*connect)
if IP == nil {
log.Fatal("Unable to process IP: ", *connect)
}
copy(serverAddr[:], IP[12:16])
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Chown"
goopt.Summary = "Change owner or group of each FILE to OWNER or GROUP\nWith reference, change owner and group of each FILE to the owner and group of RFILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [OWNER][:[GROUP]] FILE...\n or:\t%s [OPTION]... --reference=RFILE FILE...\n", os.Args[0], os.Args[0], os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
changes := goopt.Flag([]string{"-c", "--changes"}, nil, "Like verbose but only report changes", "")
silent := goopt.Flag([]string{"-f", "--silent", "--quiet"}, nil, "Suppress most error messages", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
nodereference := goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
preserveroot := goopt.Flag([]string{"--preserve-root"}, []string{"--no-preserve-root"}, "Don't recurse on '/'", "Treat '/' normally (This is default)")
goopt.OptArg([]string{"--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
recurse := goopt.Flag([]string{"-R", "--recursive"}, nil, "Operate recursively on files and directories", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
if !usingreference {
usergroup := strings.Split(goopt.Args[0], ":")
owner, err := user.Lookup(usergroup[0])
if err != nil {
uid = -1
} else {
uid, err = strconv.Atoi(owner.Uid)
if err != nil && !*silent {
}
/* hack until Go matures */
gid, err = strconv.Atoi(owner.Gid)
if err != nil && !*silent {
/* stuff */
}
}
}
for j := range goopt.Args[1:] {
filenames := []string{goopt.Args[j+1]}
for h := 0; h < len(filenames); h++ {
/* Fix to only print when changes occur for *changes */
if *changes || *verbose {
fmt.Printf("Modifying ownership of %s\n", filenames[h])
}
if *nodereference {
os.Lchown(filenames[h], uid, gid)
} else {
os.Chown(filenames[h], uid, gid)
}
if *recurse && (!*preserveroot || filenames[h] != "/") {
filelisting, err := ioutil.ReadDir(filenames[h])
if err != nil {
fmt.Fprintf(os.Stderr, "Could not recurse into '%s'\n", filenames[h])
defer os.Exit(1)
continue
}
for g := range filelisting {
filenames = append(filenames, filelisting[g].Name())
}
}
}
}
return
}
package prompt
import (
"github.com/droundy/goopt"
"strings"
"./core"
"../git/color"
"../util/out"
"../util/error"
"../util/debug"
"../util/patience"
ss "../util/slice(string)"
)
// To make --all the default, set *prompt.All to true.
var All = goopt.Flag([]string{"-a","--all"}, []string{"--interactive"},
"verb all patches", "prompt for patches interactively")
func Run(ds []core.FileDiff, f func(core.FileDiff)) {
if *All {
for _,d := range ds {
f(d)
}
} else {
files: for _,d := range ds {
for {
if !d.HasChange() {
continue files
}
// Just keep asking until we get a reasonable answer...
c,e := out.PromptForChar(goopt.Expand("Verb changes to %s? "), d.Name)
error.FailOn(e)
import "fmt"
import "os"
import (
goopt "github.com/droundy/goopt"
"github.com/rhettg/ftl/ftl"
"launchpad.net/goamz/aws"
"path/filepath"
"strings"
)
const DOWNLOAD_WORKERS = 4
const Version = "0.2.6"
var amVerbose = goopt.Flag([]string{"-v", "--verbose"}, []string{"--quiet"},
"output verbosely", "be quiet, instead")
var amMaster = goopt.Flag([]string{"--master"}, nil, "Execute against master repository", "")
var amVersion = goopt.Flag([]string{"--version"}, nil, "Display current version", "")
func optToRegion(regionName string) (region aws.Region) {
region = aws.USEast
switch regionName {
case "us-east":
region = aws.USEast
case "us-west-1":
region = aws.USWest
case "us-west-2":
region = aws.USWest2
package main
import (
"fmt"
goopt "github.com/droundy/goopt"
"github.com/xaviershay/erg"
"os"
"strconv"
)
var port = goopt.Int([]string{"-p", "--port"}, 8080, "Port to connect to. Can also be set with RANGE_PORT environment variable.")
var host = goopt.String([]string{"-h", "--host"}, "localhost", "Host to connect to. Can also be set with RANGE_HOST environment variable.")
var ssl = goopt.Flag([]string{"-s", "--ssl"}, []string{"--no-ssl"},
"Don't use SSL", "Use SSL. Can also be set with RANGE_SSL environment variable.")
var expand = goopt.Flag([]string{"-e", "--expand"}, []string{"--no-expand"},
"Do not compress results", "Compress results (default)")
func main() {
if envHost := os.Getenv("RANGE_HOST"); len(envHost) > 0 {
*host = envHost
}
if envSsl := os.Getenv("RANGE_SSL"); len(envSsl) > 0 {
*ssl = true
}
if envPort := os.Getenv("RANGE_PORT"); len(envPort) > 0 {
x, err := strconv.Atoi(envPort)
if err == nil {
*port = x
} else {
func main() {
goopt.Summary = "Command line tool to merge minimaps from custom clients in Hafen."
var sessionFodler = goopt.StringWithLabel([]string{"-d", "--sessions-dir"}, "sessions", "<path>",
"Specify input folder (instead of default \"sessions\")")
var mode = goopt.Alternatives([]string{"-m", "--mode"}, []string{"merger", "zoomer", "picture"},
"Specify mode (instead of default \"merger\")")
var zoomPath = goopt.StringWithLabel([]string{"-z", "--zoom"}, "", "<session>",
"Create zoom layers for specific <session> and place them into \"zoommap\" folder")
var zoomSize = goopt.IntWithLabel([]string{"--zoom-tile-size"}, 100, "<size>",
"Specify generated tiles size (instead of default 100)")
var zoomMax = goopt.IntWithLabel([]string{"--zoom-max"}, 5, "<num>",
"Specify zoom max (instead of default 5)")
var zoomMin = goopt.IntWithLabel([]string{"--zoom-min"}, 1, "<num>",
"Specify zoom min (instead of default 1)")
var picturePath = goopt.StringWithLabel([]string{"-p", "--picture"}, "", "<session>",
"Create single map picture for specific <session>")
var outputFodler = goopt.StringWithLabel([]string{"-o", "--output-dir"}, "zoommap", "<path>",
"Specify output folder for zoom mode (instead of default \"zoommap\")")
var trimSessions = goopt.IntWithLabel([]string{"-t", "--trim"}, -1, "<count>",
"Remove sessions with tiles < <count> from result (good for removing cave sessions)")
var removeNonStandard = goopt.Flag([]string{"-c", "--clean-non-standard"}, []string{},
"Remove all non-standard maps (size != 100x100)", "")
var hashCode = goopt.Alternatives([]string{"--hash-method"}, []string{"simple", "border"},
"Specify hash method (instead of default \"simple\")")
// Parse CMD
goopt.Parse(nil)
// Force change mode for backward compatibility
if *picturePath != "" && *mode == "merger" {
*mode = "picture"
}
if *zoomPath != "" && *mode == "merger" {
*mode = "zoomer"
}
SESSION_FOLDER = *sessionFodler
var hashMethod HashMethod
switch *hashCode {
case "simple":
hashMethod = HashMethod{CodeName: *hashCode, Func: generateSimpleHash}
break
case "border":
hashMethod = HashMethod{CodeName: *hashCode, Func: generateBorderHash}
break
default:
panic("Unrecognized hash method!") // this should never happen!
}
workingDirectory, _ := filepath.Abs(SESSION_FOLDER)
if *zoomSize%100 != 0 {
fmt.Println("Tile size must be in multiples of 100")
return
}
var composeCount = int(*zoomSize / 100)
// Generate zoom levels for specific session
if *mode == "zoomer" {
generateTiles(workingDirectory, *zoomPath, *outputFodler, composeCount, hashMethod, *zoomMin, *zoomMax)
return
}
// Generate single picture for specific session
if *mode == "picture" {
generatePicture(workingDirectory, *picturePath)
return
}
// Otherwise, let's make cross-merge
files, _ := ioutil.ReadDir(workingDirectory)
if len(files) < 2 {
fmt.Println("No folders found")
return
}
if *removeNonStandard == true {
// Remove all sessions with tile size != 100x100
for j := 0; j < len(files); j++ {
tiles, _ := ioutil.ReadDir(filepath.Join(workingDirectory, files[j].Name()))
for i := 0; i < len(tiles); i++ {
if strings.Contains(tiles[i].Name(), "tile_") {
sx, sy := getImageDimension(filepath.Join(workingDirectory, files[j].Name(), tiles[i].Name()))
if sx != 100 || sy != 100 {
fmt.Printf("Old session removed: %s\n", files[j].Name())
os.RemoveAll(filepath.Join(workingDirectory, files[j].Name()))
}
break
}
}
}
}
files, _ = ioutil.ReadDir(workingDirectory)
if len(files) < 2 {
fmt.Println("No folders found")
return
}
for j := 0; j < len(files); j++ {
info, err := os.Stat(filepath.Join(workingDirectory, files[j].Name()))
if err != nil {
continue
}
if info.IsDir() == false {
continue
}
coreFolder := files[j]
for i := 1; i < len(files); i++ {
if i == j {
continue
}
dirInfo, err := os.Stat(filepath.Join(workingDirectory, files[i].Name()))
if err != nil {
continue
}
if dirInfo.IsDir() == false {
continue
}
res := mergeFolders(filepath.Join(workingDirectory, files[i].Name()), filepath.Join(workingDirectory, coreFolder.Name()), hashMethod)
if res == true {
fmt.Printf("Merged (%s, %s)\n", coreFolder.Name(), files[i].Name())
} else {
fmt.Printf("Sessions are not mergeable (%s, %s)\n", coreFolder.Name(), files[i].Name())
}
}
}
files, _ = ioutil.ReadDir(workingDirectory)
var sessionsJS string = "var sessionsJS = ["
for j := 0; j < len(files); j++ {
tiles, _ := ioutil.ReadDir(filepath.Join(workingDirectory, files[j].Name()))
if *trimSessions > 0 {
if len(tiles) < *trimSessions {
err := os.RemoveAll(filepath.Join(workingDirectory, files[j].Name()))
if err != nil {
fmt.Printf("Cannot trim session %s: %s\n", files[j].Name(), err.Error())
continue
} else {
fmt.Printf("Trimmed session %s\n", files[j].Name())
continue
}
}
}
sessionsJS += "\"" + SESSION_FOLDER + "/" + files[j].Name() + "\", "
}
sessionsJS += "];"
ioutil.WriteFile("session.js", []byte(sessionsJS), 0777)
}
"fmt"
"github.com/droundy/goopt"
"github.com/wsxiaoys/terminal/color"
"os"
"path/filepath"
"regexp"
)
var (
Author = "Alexander Solovyov"
Version = "0.4.3"
Summary = "gr [OPTS] string-to-search\n"
byteNewLine []byte = []byte("\n")
ignoreCase = goopt.Flag([]string{"-i", "--ignore-case"}, []string{},
"ignore pattern case", "")
onlyName = goopt.Flag([]string{"-n", "--filename"}, []string{},
"print only filenames", "")
ignoreFiles = goopt.Strings([]string{"-x", "--exclude"}, "RE",
"exclude files that match the regexp from search")
singleline = goopt.Flag([]string{"-s", "--singleline"}, []string{},
"match on a single line (^/$ will be beginning/end of line)", "")
plaintext = goopt.Flag([]string{"-p", "--plain"}, []string{},
"search plain text", "")
replace = goopt.String([]string{"-r", "--replace"}, "",
"replace found substrings with this string")
force = goopt.Flag([]string{"--force"}, []string{},
"force replacement in binary files", "")
showVersion = goopt.Flag([]string{"-V", "--version"}, []string{},
"show version and exit", "")
noIgnoresGlobal = goopt.Flag([]string{"-I", "--no-autoignore"}, []string{},
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Mv"
goopt.Summary = "Move (rename) each SOURCE to DEST"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... SOURCE(...) DEST\n or:\t%s [OPTION]... -t DEST SOURCE\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
prompt := goopt.Flag([]string{"-i", "--interactive"}, nil, "Prompt before an overwrite. Override -f and -n.", "")
noclobber := goopt.Flag([]string{"-n", "--no-clobber"}, []string{"-f", "--force"}, "Do not overwrite", "Never prompt before an overwrite")
backup := goopt.Flag([]string{"-b", "--backup"}, nil, "Backup files before overwriting", "")
goopt.OptArg([]string{"-S", "--suffix"}, "SUFFIX", "Override the usual backup suffix", coreutils.SetBackupSuffix)
goopt.OptArg([]string{"-t", "--target"}, "TARGET", "Set the target with a flag instead of at the end", coreutils.SetTarget)
update := goopt.Flag([]string{"-u", "--update"}, nil, "Move only when DEST is missing or older than SOURCE", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) < 2 {
coreutils.PrintUsage()
}
if coreutils.Target == "" {
coreutils.Target = goopt.Args[len(goopt.Args)-1]
}
destinfo, err := os.Lstat(coreutils.Target)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error trying to get info to check if DEST is a directory: %v\n", err)
os.Exit(1)
}
isadir := err == nil && destinfo.IsDir()
if (len(goopt.Args) > 2 || (coreutils.Target != goopt.Args[len(goopt.Args)-1] && len(goopt.Args) > 1)) && !isadir {
fmt.Fprintf(os.Stderr, "Too many arguments for non-directory destination")
os.Exit(1)
}
for i := range goopt.Args[1:] {
dest := coreutils.Target
if isadir {
dest = dest + string(os.PathSeparator) + filepath.Base(goopt.Args[i])
}
destinfo, err := os.Lstat(dest)
exist := !os.IsNotExist(err)
newer := true
if err != nil && exist {
fmt.Fprintf(os.Stderr, "Error trying to get info on target: %v\n", err)
os.Exit(1)
}
if *update && exist {
srcinfo, err := os.Lstat(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error trying to get mod time on SRC: %v\n", err)
os.Exit(1)
}
newer = srcinfo.ModTime().After(destinfo.ModTime())
}
if !newer {
continue
}
promptres := true
if exist {
promptres = !*noclobber
if *prompt {
promptres = coreutils.PromptFunc(dest, false)
}
if promptres && *backup {
coreutils.Backup(dest)
}
}
if promptres {
err = os.Rename(goopt.Args[i], dest)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while moving '%s' to '%s': %v\n", goopt.Args[i], dest, err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("%s -> %s\n", goopt.Args[i], dest)
}
}
}
return
}
package main
import (
"exec"
"fmt"
"github.com/droundy/go-crazy/parser"
"github.com/droundy/goopt"
"go/printer"
"os"
)
var just_translate = goopt.Flag([]string{"--just-translate"}, []string{},
"just build the -compiled.go file", "build and compile and link")
var toinline = goopt.Strings([]string{"--inline"}, "FUNC", "specify function to inline")
func panicon(err os.Error) {
if err != nil {
panic(err)
}
}
func archnum() string {
switch os.Getenv("GOARCH") {
case "386":
return "8"
case "amd64":
return "6"
// what was the other one called?
}
return "5"
package main
// test out the goopt package...
import (
"fmt"
goopt "github.com/droundy/goopt"
"strings"
)
var amVerbose = goopt.Flag([]string{"--verbose"}, []string{},
"output verbosely", "")
var amHappy = goopt.Flag([]string{"-h", "--happy"}, []string{"-u", "--unhappy", "--sad"}, "be happy", "be unhappy")
var foo = goopt.String([]string{"--name"}, "anonymous", "pick your name")
var bar = goopt.String([]string{"-b"}, "BOO!", "pick your scary sound")
var baz = goopt.String([]string{"-o"}, "", "test whether a silent default works")
var speed = goopt.Alternatives([]string{"--speed", "--velocity"},
[]string{"slow", "medium", "fast"},
"set the speed")
var words = goopt.Strings([]string{"--word", "--saying", "-w", "-s"}, "word",
"specify a word to speak")
var width = goopt.Int([]string{"-l", "--length"}, 1, "number of ?s")
func main() {
goopt.Summary = "silly test program"
goopt.Parse(nil)
if *amVerbose {
fmt.Println("I am verbose.")
limitations under the License.
*/
package main
import (
"fmt"
goopt "github.com/droundy/goopt"
"os"
"strconv"
"strings"
"time"
)
// Actions
var addFlag = goopt.Flag([]string{"-a", "--add"}, nil, "add a task", "")
var editFlag = goopt.Flag([]string{"-e", "--edit"}, nil, "edit a task, replacing its text", "")
var markDoneFlag = goopt.Flag([]string{"-d", "--done"}, nil, "mark the given tasks as done", "")
var markNotDoneFlag = goopt.Flag([]string{"-D", "--not-done"}, nil, "mark the given tasks as not done", "")
var removeFlag = goopt.Flag([]string{"--remove"}, nil, "remove the given tasks", "")
var reparentFlag = goopt.Flag([]string{"-R", "--reparent"}, nil, "reparent task A below task B", "")
var titleFlag = goopt.Flag([]string{"--title"}, nil, "set the task list title", "")
var versionFlag = goopt.Flag([]string{"--version"}, nil, "show version", "")
var infoFlag = goopt.Flag([]string{"-i", "--info"}, nil, "show information on a task", "")
var importFlag = goopt.Flag([]string{"--import"}, nil, "import and synchronise TODO items from source code", "")
// Options
var priorityFlag = goopt.String([]string{"-p", "--priority"}, "medium", "priority of newly created tasks (veryhigh,high,medium,low,verylow)")
var graftFlag = goopt.String([]string{"-g", "--graft"}, "root", "task to graft new tasks to")
var fileFlag = goopt.String([]string{"--file"}, ".todo2", "file to load task lists from")
var legacyFileFlag = goopt.String([]string{"--legacy-file"}, ".todo", "file to load legacy task lists from")
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package main
import (
"bufio"
"fmt"
flag "github.com/droundy/goopt"
zmq "github.com/pebbe/zmq4"
"os"
)
var null = flag.Flag([]string{"-0"}, []string{}, "Separate messages on input/output should be ", "")
var mode = flag.Flag([]string{"-c", "--connect"},
[]string{"-b", "--bind"},
"Connect to the specified address(es).",
"Bind to the specified address(es).")
var number = flag.Int([]string{"-n"}, -1, "Receive/send only NUM messages. By default, zmqc "+
"lives forever in 'read' mode, or until the end of input "+
"in 'write' mode.")
var socket_type = flag.Alternatives([]string{"-s"},
[]string{"PUSH", "PULL", "PUB", "SUB", "REQ", "REP", "PAIR"},
"Which type of socket to create. Must be one of 'PUSH', 'PULL', "+
"'PUB', 'SUB', 'REQ', 'REP' or 'PAIR'. See `man zmq_socket` for an "+
"explanation of the different types. 'DEALER' and 'ROUTER' sockets are "+