changlog

32 # FIX using a slice variable, enter the default greedy mode

address

https://github.com/guonaihong/clop

https://gitee.com/guonaihong/clop

clop

clop is a struct-based command-line parser, small but perfectly formed. (From zero realization)

feature

Support environment variable binding env DEBUG=xx ./proc
Support parameters collection cat a.txt b.txt, you can put a.txt, b.txtthe bulk member, is classified classify, collect your designated structure members in
Support options short proc -d or long option proc --debugcinch
posix-style command line support, support command combination ls -ltris ls -l -t -rshorthand facilitate the achievement of common posix standard commands
Child support order to facilitate the realization git sub-command style git add , simple sub-command registration, as long as the structure mentioned will write on the line, 3,4,5 to endless sub-command is also supported, as long as you like, and use can be achieved clop
The default value support default:"1", support for multiple data types, type conversion let you save trouble
Intimate repeat command error
Strict short option, a long option error. Avoid ambiguity birth options
Efficacy mode support, do not need to write a bunch of if x!= "" or if y!=0wasted youth code

content

Installation

go get github.com/guonaihong/clop

Quick start

package main

import (
	"fmt"
	"github.com/guonaihong/clop"
)

type Hello struct {
	File string `clop:"-f; --file" usage:"file"`
}

func main() {

	h := Hello{}
	clop.Bind(&h)
	fmt.Printf("%#v\n", h)
}
// ./one -f test
// main.Hello{File:"test"}
// ./one --file test
// main.Hello{File:"test"}

example

required flag

 package main

import (
    "fmt"
    "github.com/guonaihong/clop"
)

type curl struct {
    Url string `clop:"-u; --url" usage:"url" valid:"required"`
}

func main() {

    c := curl{}
    clop.Bind(&c)
}

set default value

Default tag may be used to set the default values, write directly ordinary type, composite type is represented by json

package mainimport (
    "fmt""github.com/guonaihong/clop"
)typedefaultExamplestruct {
    Intint`default:"1"`Float64float64`default:"3.64"`Float32float32`default:"3.32"`SliceString  []string`default:"[\"one\", \"two\"]"`SliceInt     []int`default:"[1,2,3,4,5]"`SliceFloat64 []float64`default:"[1.1,2.2,3.3,4.4,5.5]"` =
    a() {mainFunction
}


    

                   
             
             
      
         
     

  defaultExample{}
    clop.Bind(&de)
    fmt.Printf("%v\n", de) 
}
// run
//         ./use_def
// output:
//         {1 3.64 3.32 [one two] [1 2 3 4 5] [1.1 2.2 3.3 4.4 5.5]}

Support environment variables

// file name use_env.go
package mainimport (
	"fmt""github.com/guonaihong/clop"
)typeenvstruct {
	OmpNumThreadstring`clop:"env=omp_num_thread" usage:"omp num thread"`Pathstring`clop:"env=XPATH" usage:"xpath"`Maxint`clop:"env=MAX" usage:"max thread"`
}funcmain() {
	e :=env{}
	clop.Bind(&e)
	fmt.Printf("%#v\n",e) // run
}


	

    
	          
	              

  

// env XPATH=`pwd` omp_num_thread=3 MAX=4 ./use_env 
// output
// main.env{OmpNumThread:"3", Path:"/home/guo", Max:4}

subcommand

package main

import (
	"fmt"
	"github.com/guonaihong/clop"
)

type add struct {
	All      bool     `clop:"-A; --all" usage:"add changes from all tracked and untracked files"`
	Force    bool     `clop:"-f; --force" usage:"allow adding otherwise ignored files"`
	Pathspec []string `clop:"args=pathspec"`
}

type mv struct {
	Force bool `clop:"-f; --force" usage:"allow adding otherwise ignored files"`
}

type git struct {
	Add add `clop:"subcommand=add" usage:"Add file contents to the index"`
	Mv  mv  `clop:"subcommand=mv" usage:"Move or rename a file, a directory, or a symlink"`
}

func main() {
	g := git{}
	clop.Bind(&g)
	fmt.Printf("git:%#v\n", g)
	fmt.Printf("git:set mv(%t) or set add(%t)\n", clop.IsSetSubcommand("mv"), clop.IsSetSubcommand("add"))
}
// run:
// ./git add -f

// output:
// git:main.git{Add:main.add{All:false, Force:true, Pathspec:[]string(nil)}, Mv:main.mv{Force:false}}
// git:set mv(false) or set add(true)

Implementing linux command options

cat

package main

import (
	"fmt"
	"github.com/guonaihong/clop"
)

type cat struct {
	NumberNonblank bool `clop:"-c;--number-nonblank" 
	                     usage:"number nonempty output lines, overrides"`

	ShowEnds bool `clop:"-E;--show-ends" 
	               usage:"display $ at end of each line"`

	Number bool `clop:"-n;--number" 
	             usage:"number all output lines"`

	SqueezeBlank bool `clop:"-s;--squeeze-blank" 
	                   usage:"suppress repeated empty output lines"`

	ShowTab bool `clop:"-T;--show-tabs" 
	              usage:"display TAB characters as ^I"`

	ShowNonprinting bool `clop:"-v;--show-nonprinting" 
	                      usage:"use ^ and M- notation, except for LFD and TAB" `

	Files []string `clop:"args=files"`
}

func main() {

	c := cat{}
	err := clop.Bind(&c)

	fmt.Printf("%#v, %s\n", c, err)
}

/*
Usage:
    ./cat [Flags] <files> 

Flags:
    -E,--show-ends           display $ at end of each line 
    -T,--show-tabs           display TAB characters as ^I 
    -c,--number-nonblank     number nonempty output lines, overrides 
    -n,--number              number all output lines 
    -s,--squeeze-blank       suppress repeated empty output lines 
    -v,--show-nonprinting    use ^ and M- notation, except for LFD and TAB 

Args:
    <files>
*/

clop v0.0.2 release, golang achieve command-line parsing library