pax_global_header 0000666 0000000 0000000 00000000064 13502324010 0014500 g ustar 00root root 0000000 0000000 52 comment=eb5b6aa387fb8e39dfaa43d584488a29af617eed
easygen-4.1.0/ 0000775 0000000 0000000 00000000000 13502324010 0013135 5 ustar 00root root 0000000 0000000 easygen-4.1.0/.gitignore 0000664 0000000 0000000 00000000413 13502324010 0015123 0 ustar 00root root 0000000 0000000 # Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof
easygen-4.1.0/.travis.yml 0000664 0000000 0000000 00000000015 13502324010 0015242 0 ustar 00root root 0000000 0000000 language: go
easygen-4.1.0/LICENSE 0000664 0000000 0000000 00000002063 13502324010 0014143 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2015 suntong
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
easygen-4.1.0/README.e.md 0000664 0000000 0000000 00000017102 13502324010 0014640 0 ustar 00root root 0000000 0000000 # {{.Name}}
[](LICENSE)
{{template "badge/godoc" .}}
{{template "badge/goreport" .}}
{{template "badge/travis" .}}
[ ](https://codeship.com/projects/135255)
## {{toc 5}}
# {{.Name}} - Easy to use universal code/text generator
Command `{{.Name}}` is an easy to use universal code/text generator.
It can be used as a text or html generator for _arbitrary_ purposes with _arbitrary_ data and templates. It is a good [GSL](https://github.com/imatix/gsl) replacement, as it
- is more easy to define driving data, in form of YML instead of XML
- has more powerful template engine that based on Go template.
You can also write your own function in Go to customize your template.
You can even use easygen as a generic Go template testing tool using the `-ts` commandline option, and much more.
Note this document is for `{{.Name}}` versions 4.0+. For historic versions check out the [Different Versions](#different-versions) section.
## Usage
### $ {{exec "easygen" | color "sh"}}
## Install
### Install as Debian/Unbuntu package
apt install {{.Name}}
### Install from source
go get github.com/go-easygen/easygen/...
ls -l $GOPATH/bin
You should find an `{{.Name}}` executable newly created in there.
## Test
export PATH=$PATH:$GOPATH/bin
$ easygen $GOPATH/src/github.com/go-easygen/easygen/test/list0
The colors are: red, blue, white, .
cd $GOPATH/src/github.com/go-easygen/easygen
$ easygen test/list1
The quoted colors are: "red", "blue", "white", .
$ easygen test/listfunc1 test/list0
red, blue, white.
And also check out the provided [more examples](https://godoc.org/github.com/go-easygen/easygen#pkg-examples) in the [](https://godoc.org/github.com/go-easygen/easygen) document.
## Details
It can be used as a code generator, for example, command line parameter handling code generator, or anything that is structurally repetitive, like the following:
- [Introduction to easygen and its philosophy ](https://suntong.github.io/blogs/2016/01/01/easygen---easy-to-use-universal-code/text-generator)
- [Easygen is now coding itself ](https://sfxpt.wordpress.com/2015/07/04/easygen-is-now-coding-itself/)
- [Showcasing the power of easygen with ffcvt ](https://sfxpt.wordpress.com/2015/08/02/showcasing-the-power-of-easygen-with-ffcvt/)
- [Easygen for HTML mock-up ](https://sfxpt.wordpress.com/2015/07/10/easygen-for-mock-up/)
- [Moving beyond code-gen and mock-up, using easygen in real life creating GPT partitions](https://suntong.github.io/blogs/2015/12/26/creating-gpt-partitions-easily-on-the-command-line)
Ready to get started? Then check out [Getting Started](https://github.com/go-easygen/easygen/wiki/Getting-Started) to start building your way to turn your data into any form, any way you want.
## Command line flag handling code auto-generation
[ ](https://suntong.github.io/blogs/)
As explained above, one practical use of `easygen` is to auto-generating Go code for command line parameter handling, for both [`viper` and `cobra`](https://github.com/suntong/blog/blob/master/GoOptP7-easygen.md), and Go's [built-in `flag` package](https://sfxpt.wordpress.com/2015/07/04/easygen-is-now-coding-itself/).
### `easygen` itself
Currently, `easygen`'s command line parameter handling is built on top of Go's built-in `flag` package, and the handling code is entirely generated by `easygen` itself. Thus, showing how `easygen` is handling the command line parameters itself also means showing what functionality the auto-generated command line parameter handling code can do for you.
Currently, there are three tiers program parameters can be given:
1. Default values defined within the program, so that program parameters can have meaningful defaults to start with
1. Values defined in environment variables
1. Values passed from command line
The latter will have higher priority and will override values defined formerly. I.e., the values from command line will override that in environment variables, which in turn override program defaults.
We will use the `-ts`, template string, as an example to illustrate. The program defaults is empty, which means using the `.tmpl` template file the same as the `.yaml` data file. We will override that first by environment variable, then from command line, illustrated in next section.
### `cli` based
See,
[A cookbook on how to jump-start a `cli` based command line handling program](cli-project.md#cookbook)
## The `easygen` usage
### Command line
[Check here for more on using `easygen` the command line tool](using_easygen.md).
### The library
The `easygen` is a library as well as a command line tools. Not only it is super easy to use, it is super easy to extend as well.
The [restructured `easygen`](https://github.com/go-easygen/easygen/issues/10) can now be a building block that people can easily extend, any extra functionalities, or extra feature that it depends on, or any external dependencies are now moved out to sub modules. Thus the library users can now pick and choose exactly what they want from the library.
- The [egVar package example](http://godoc.org/github.com/go-easygen/easygen/egVar#example-package) shows how to add the variable name manipulation on top of the default library.
- The [egCal package example](http://godoc.org/github.com/go-easygen/easygen/egCal#example-package) shows how to add the variable name manipulation and generic calculation functionalities, together with the default functions, all at the same time.
To put them all together, check out the `easygen`'s `main.go`:
#### > cmd/easygen/main.go
```go
package main
import (
"flag"
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egVar"
)
//go:generate sh -v easygen.gen.sh
////////////////////////////////////////////////////////////////////////////
// Main
func main() {
flag.Usage = Usage
flag.Parse()
// One mandatory non-flag arguments
if flag.NArg() < 1 {
Usage()
}
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).
Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs())
args := flag.Args()
if len(easygen.Opts.TemplateStr) > 0 {
easygen.Process0(tmpl, os.Stdout, easygen.Opts.TemplateStr, args...)
} else {
easygen.Process(tmpl, os.Stdout, args...)
}
}
```
It has been as simple as this up until version 3. I.e., it's quite simple to make use of `easygen` as a package.
### Different Versions
The `easygen` has gone through four different versions whose API are a bit different between them.
To always stay at the latest version, `import`
"github.com/go-easygen/easygen"
in your Go code. However, to stay within a certain version, `import` the following package respectively to what you need:
- V4: "[gopkg.in/easygen.v4](https://gopkg.in/easygen.v4)"
- V3: "[gopkg.in/easygen.v3](https://gopkg.in/easygen.v3)"
- V2: "[gopkg.in/easygen.v2](https://gopkg.in/easygen.v2)"
- V1: "[gopkg.in/easygen.v1](https://gopkg.in/easygen.v1)"
To see the differences between them, check out
- [V4 vs V3](https://github.com/go-easygen/easygen/wiki/V4-vs-V3)
- [V3 vs V2](https://github.com/go-easygen/easygen/wiki/V3-vs-V2)
- [V2 vs V1](https://github.com/go-easygen/easygen/wiki/V2-vs-V1)
## Author(s) & Contributor(s)
Tong SUN
Gerrit Renker
https://github.com/grrtrr
All patches welcome.
easygen-4.1.0/README.md 0000664 0000000 0000000 00000023104 13502324010 0014414 0 ustar 00root root 0000000 0000000 # easygen
[](LICENSE)
[](http://godoc.org/github.com/go-easygen/easygen)
[](https://goreportcard.com/report/github.com/go-easygen/easygen)
[](https://travis-ci.org/go-easygen/easygen)
[ ](https://codeship.com/projects/135255)
## TOC
- [easygen - Easy to use universal code/text generator](#easygen---easy-to-use-universal-codetext-generator)
- [Usage](#usage)
- [$ easygen](#-easygen)
- [Install](#install)
- [Install as Debian/Unbuntu package](#install-as-debianunbuntu-package)
- [Install from source](#install-from-source)
- [Test](#test)
- [Details](#details)
- [Command line flag handling code auto-generation](#command-line-flag-handling-code-auto-generation)
- [`easygen` itself](#`easygen`-itself)
- [`cli` based](#`cli`-based)
- [The `easygen` usage](#the-`easygen`-usage)
- [Command line](#command-line)
- [The library ](#the-library-)
- [> cmd/easygen/main.go](#-cmdeasygenmaingo)
- [Different Versions](#different-versions)
- [Author(s) & Contributor(s)](#author(s)-&-contributor(s))
# easygen - Easy to use universal code/text generator
Command `easygen` is an easy to use universal code/text generator.
It can be used as a text or html generator for _arbitrary_ purposes with _arbitrary_ data and templates. It is a good [GSL](https://github.com/imatix/gsl) replacement, as it
- is more easy to define driving data, in form of YML instead of XML
- has more powerful template engine that based on Go template.
You can also write your own function in Go to customize your template.
You can even use easygen as a generic Go template testing tool using the `-ts` commandline option, and much more.
Note this document is for `easygen` versions 4.0+. For historic versions check out the [Different Versions](#different-versions) section.
## Usage
### $ easygen
```sh
easygen version 4.0.0
Usage:
easygen [flags] template_name [data_filename [data_filename...]]
Flags:
-debug level
debugging level
-ej extension
extension of json file (default ".json")
-et extension
extension of template file (default ".tmpl")
-ey extension
extension of yaml file (default ".yaml")
-ts string
template string (in text)
data_filename(s): The name for the .yaml or .json data.
- If omitted derive from the template_name.
- Can have the extension or without it. If withot extension,
will try .yaml first then .json
- Can include the path as well.
template_name: The name for the template file.
- Can have the extension or without it.
- Can include the path as well.
- Can be a comma-separated list giving many template files, in which case
at least one data_filename must be given.
Flag defaults can be overridden by corresponding environment variable, e.g.:
EASYGEN_EY=.yml EASYGEN_ET=.tpl easygen ...
```
## Install
### Install as Debian/Unbuntu package
apt install easygen
### Install from source
go get github.com/go-easygen/easygen/...
ls -l $GOPATH/bin
You should find an `easygen` executable newly created in there.
## Test
export PATH=$PATH:$GOPATH/bin
$ easygen $GOPATH/src/github.com/go-easygen/easygen/test/list0
The colors are: red, blue, white, .
cd $GOPATH/src/github.com/go-easygen/easygen
$ easygen test/list1
The quoted colors are: "red", "blue", "white", .
$ easygen test/listfunc1 test/list0
red, blue, white.
And also check out the provided [more examples](https://godoc.org/github.com/go-easygen/easygen#pkg-examples) in the [](https://godoc.org/github.com/go-easygen/easygen) document.
## Details
It can be used as a code generator, for example, command line parameter handling code generator, or anything that is structurally repetitive, like the following:
- [Introduction to easygen and its philosophy ](https://suntong.github.io/blogs/2016/01/01/easygen---easy-to-use-universal-code/text-generator)
- [Easygen is now coding itself ](https://sfxpt.wordpress.com/2015/07/04/easygen-is-now-coding-itself/)
- [Showcasing the power of easygen with ffcvt ](https://sfxpt.wordpress.com/2015/08/02/showcasing-the-power-of-easygen-with-ffcvt/)
- [Easygen for HTML mock-up ](https://sfxpt.wordpress.com/2015/07/10/easygen-for-mock-up/)
- [Moving beyond code-gen and mock-up, using easygen in real life creating GPT partitions](https://suntong.github.io/blogs/2015/12/26/creating-gpt-partitions-easily-on-the-command-line)
Ready to get started? Then check out [Getting Started](https://github.com/go-easygen/easygen/wiki/Getting-Started) to start building your way to turn your data into any form, any way you want.
## Command line flag handling code auto-generation
[ ](https://suntong.github.io/blogs/)
As explained above, one practical use of `easygen` is to auto-generating Go code for command line parameter handling, for both [`viper` and `cobra`](https://github.com/suntong/blog/blob/master/GoOptP7-easygen.md), and Go's [built-in `flag` package](https://sfxpt.wordpress.com/2015/07/04/easygen-is-now-coding-itself/).
### `easygen` itself
Currently, `easygen`'s command line parameter handling is built on top of Go's built-in `flag` package, and the handling code is entirely generated by `easygen` itself. Thus, showing how `easygen` is handling the command line parameters itself also means showing what functionality the auto-generated command line parameter handling code can do for you.
Currently, there are three tiers program parameters can be given:
1. Default values defined within the program, so that program parameters can have meaningful defaults to start with
1. Values defined in environment variables
1. Values passed from command line
The latter will have higher priority and will override values defined formerly. I.e., the values from command line will override that in environment variables, which in turn override program defaults.
We will use the `-ts`, template string, as an example to illustrate. The program defaults is empty, which means using the `.tmpl` template file the same as the `.yaml` data file. We will override that first by environment variable, then from command line, illustrated in next section.
### `cli` based
See,
[A cookbook on how to jump-start a `cli` based command line handling program](cli-project.md#cookbook)
## The `easygen` usage
### Command line
[Check here for more on using `easygen` the command line tool](using_easygen.md).
### The library
The `easygen` is a library as well as a command line tools. Not only it is super easy to use, it is super easy to extend as well.
The [restructured `easygen`](https://github.com/go-easygen/easygen/issues/10) can now be a building block that people can easily extend, any extra functionalities, or extra feature that it depends on, or any external dependencies are now moved out to sub modules. Thus the library users can now pick and choose exactly what they want from the library.
- The [egVar package example](http://godoc.org/github.com/go-easygen/easygen/egVar#example-package) shows how to add the variable name manipulation on top of the default library.
- The [egCal package example](http://godoc.org/github.com/go-easygen/easygen/egCal#example-package) shows how to add the variable name manipulation and generic calculation functionalities, together with the default functions, all at the same time.
To put them all together, check out the `easygen`'s `main.go`:
#### > cmd/easygen/main.go
```go
package main
import (
"flag"
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egVar"
)
//go:generate sh -v easygen.gen.sh
////////////////////////////////////////////////////////////////////////////
// Main
func main() {
flag.Usage = Usage
flag.Parse()
// One mandatory non-flag arguments
if flag.NArg() < 1 {
Usage()
}
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).
Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs())
args := flag.Args()
if len(easygen.Opts.TemplateStr) > 0 {
easygen.Process0(tmpl, os.Stdout, easygen.Opts.TemplateStr, args...)
} else {
easygen.Process(tmpl, os.Stdout, args...)
}
}
```
It has been as simple as this up until version 3. I.e., it's quite simple to make use of `easygen` as a package.
### Different Versions
The `easygen` has gone through four different versions whose API are a bit different between them.
To always stay at the latest version, `import`
"github.com/go-easygen/easygen"
in your Go code. However, to stay within a certain version, `import` the following package respectively to what you need:
- V4: "[gopkg.in/easygen.v4](https://gopkg.in/easygen.v4)"
- V3: "[gopkg.in/easygen.v3](https://gopkg.in/easygen.v3)"
- V2: "[gopkg.in/easygen.v2](https://gopkg.in/easygen.v2)"
- V1: "[gopkg.in/easygen.v1](https://gopkg.in/easygen.v1)"
To see the differences between them, check out
- [V4 vs V3](https://github.com/go-easygen/easygen/wiki/V4-vs-V3)
- [V3 vs V2](https://github.com/go-easygen/easygen/wiki/V3-vs-V2)
- [V2 vs V1](https://github.com/go-easygen/easygen/wiki/V2-vs-V1)
## Author(s) & Contributor(s)
Tong SUN
Gerrit Renker
https://github.com/grrtrr
All patches welcome.
easygen-4.1.0/cli-project.md 0000664 0000000 0000000 00000040355 13502324010 0015701 0 ustar 00root root 0000000 0000000 # Jump start the cli based project
This is on how to jump-start a [`cli`](https://github.com/mkideal/cli/) based project.
The [`cli`](https://github.com/mkideal/cli/) package really make it easy to code your command line handling program, especially when you need to deal with _sub commands_ like `apt-get`, `git` etc do. Now, want to make it even simpler?
## Usage
Yes! Use the code auto generation. It can make things even more simple. Run the following on command line so that you can see for yourself:
```
go get github.com/go-easygen/easygen
ls -l $GOPATH/bin
export PATH=$PATH:$GOPATH/bin
easygen $GOPATH/src/github.com/go-easygen/easygen/test/commandlineCLI-024
```
## Result
You should see the following Go code:
```go
// -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: gogo
// Purpose: Golang package manager
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var app = &cli.Register(&cli.Command{
Name: "gogo",
Desc: "Golang package manager",
Text: " gogo is a new golang package manager\n very very good",
Argv: func() interface{} { return new(gogoT) },
Fn: gogo,
NumArg: cli.ExactN(1),
})
type gogoT struct {
cli.Helper
Version bool `cli:"v,version" usage:"display version"`
List bool `cli:"l,list" usage:"list all sub commands or not"`
}
func gogo(ctx *cli.Context) error {
argv := ctx.Argv().(*gogoT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[gogo]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: build
// Purpose: Build golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var buildCmd = app.Register(&cli.Command{
Name: "build",
Desc: "Build golang application",
Text: "Usage:\n gogo build [Options] Arch(i386|amd64)",
Argv: func() interface{} { return new(buildT) },
Fn: build,
NumArg: cli.ExactN(1),
CanSubRoute: true,
})
type buildT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
func build(ctx *cli.Context) error {
argv := ctx.Argv().(*buildT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[build]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: install
// Purpose: Install golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var installCmd = app.Register(&cli.Command{
Name: "install",
Desc: "Install golang application",
Text: "Usage:\n gogo install [Options] package [package...]",
Argv: func() interface{} { return new(installT) },
Fn: install,
NumArg: cli.AtLeast(1),
CanSubRoute: true,
})
type installT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
func install(ctx *cli.Context) error {
argv := ctx.Argv().(*installT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[install]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: publish
// Purpose: Publish golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var publishCmd = app.Register(&cli.Command{
Name: "publish",
Desc: "Publish golang application",
Argv: func() interface{} { return new(publishT) },
Fn: publish,
})
type publishT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
List bool `cli:"l,list" usage:"list all sub commands"`
}
func publish(ctx *cli.Context) error {
argv := ctx.Argv().(*publishT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[publish]: %v\n", ctx.Args())
return nil
}
```
As you can see the skeleton of the program has been automatically generated.
## Source
So what's behind the scene of the "magic"? Take a look at the driving [Yaml file](https://github.com/go-easygen/easygen/blob/master/test/commandlineCLI-024.yaml), that's everything you specify to make the magic happen. I'm republishing it below for your reference:
```yaml
# program name, name for the executable
ProgramName: gogo
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: main
Name: gogo
Var: app
Desc: "Golang package manager"
Text: ' gogo is a new golang package manager\n very very good'
NumArg: cli.ExactN(1)
Options:
- Name: Version
Type: bool
Flag: v,version
Usage: display version
- Name: List
Type: bool
Flag: l,list
Usage: list all sub commands or not
Command:
- Name: build
Desc: "Build golang application"
Text: 'Usage:\n gogo build [Options] Arch(i386|amd64)'
NumArg: cli.ExactN(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: install
Desc: "Install golang application"
Text: 'Usage:\n gogo install [Options] package [package...]'
NumArg: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: publish
Desc: "Publish golang application"
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: List
Type: bool
Flag: l,list
Usage: "list all sub commands"
```
Yes, you are right -- that's all you need to have the above code skeleton generated.
## Takeaway
### Understanding how to use easygen for cli based project
Now, the question is, how it can help your own project. Assuming you have never code a `cli` based project before, what you need to do are,
- Take a look at the above [Yaml file](https://github.com/go-easygen/easygen/blob/master/test/commandlineCLI-024.yaml) and see the _generated Go code_, and see their relationship.
- Take a look at the [orginal finished Go code](https://github.com/mkideal/cli/tree/master/_examples/024-multi-command) that such code generation is for, and see what else you need to do to make it a working code.
- The generated Go code was meant to be cut into each corresponding Go code files, e.g., the `main.go`, `build.go`, `install.go` and `publish.go` as in the above [finished code](https://github.com/mkideal/cli/tree/master/_examples/024-multi-command)
- At this point, you have a good starting point already, because the code skeletons are already in place.
### Round-trip generation
This is for illustration only. However, for round-trip generation, I.e., you generate and use the generated code, and you find yourself need to add more options later, then such manual cut & paste (into each corresponding Go code) method will be flimsy. So what shall we do?
- Take a look at the [template file](https://github.com/go-easygen/easygen/blob/master/test/commandlineCLI.tmpl) that is being used to generate the Go code. This is where the _true_ magic happens.
- I recommend removing all the repeating part, and the sample implementation part out. I.e., your own `build.go`, `install.go` and `publish.go` contains the true implementation, and use the code-gen to automatically generate all the declaration part. This way the automatically-generated code can always been overwritten (with the latest definition) without affecting your existing implementation.
- For details on code automatic generation, refer to [easygen](https://github.com/go-easygen/easygen/) for all other information.
### Practical Example
There is a new `commandlineCLI-027` set of data and template, that is built after [code sample 027](https://github.com/mkideal/cli/tree/master/_examples/027-global-option). Replace the above `commandlineCLI-024` with `commandlineCLI-027`, you will get [code for the corresponding samples](https://github.com/go-easygen/easygen/blob/master/test/commandlineCLI-027.ref). Further more, the `commandlineCLI-027` is built with the above *"round-trip generation"* principle in mind. Take a look at [`redoCmds.go`](https://github.com/suntong/lang/blob/master/lang/Go/src/sys/CLI/027-global-redo/redoCmds.go) in the [027-global-redo](https://github.com/suntong/lang/tree/master/lang/Go/src/sys/CLI/027-global-redo) project, it is completely generated by [easygen](https://github.com/go-easygen/easygen/), and can be regenerated as many times as you want, and whenever you want, even after several releases.
## Cookbook
Since I've written the above how-to, I've followed it to generate lots of my code wire-frames, polishing and fine-tuning my approaches along the way. Now, the procedure has mostly been stabilized, so I think it is a good idea to share
how I am doing it, generating my cli-based code wire-frames. All the following code-gen are based on my [cli-t0.tmpl](https://github.com/suntong/cli/blob/78b8d5e8b97d0950faec5e7844f220a572577ba0/cli-t0.tmpl) template.
### Simple case, no sub-commands
Let's start with the simpler case, generating cli handling code that has no sub-commands. This is the way tradition Unix tools use, and there are many tradition *nix tools that are doing this way, e.g., `cp`, `rm`, `find`, `rsync` etc, to name a few.
Here is how to generate a cli handling code-base for this case, using [my picv v0.1.0 ](https://github.com/suntong/picv/tree/0.1.0) as the example:
1. Provide a `.yaml` file -- [picv.yaml](https://github.com/suntong/picv/blob/0.1.0/picv.yaml)
1. Provide a code-gen shell script -- [picvCLIGen.sh](https://github.com/suntong/picv/blob/0.1.0/picvCLIGen.sh) and run it to generate [picvCLIDef.go](https://github.com/suntong/picv/blob/0.1.0/picvCLIDef.go)
1. Extract the commented out code to [picvMain.go](https://github.com/suntong/picv/blob/0.1.0/picvMain.go) and [picvCLICmd.go](https://github.com/suntong/picv/blob/0.1.0/picvCLICmd.go)
1. Now the code wire-frame is done, and ready for compilation and execution.
```
$ picv -h
picture vault
built on 2017-06-03
Tool to deal with camera pictures and put them in vault
Usage:
picv [Options] dir [dirs...]
Options:
-h, --help display help information
-g, --gap[=5] Gap in days to be considered as different group/vault
-p, --pod[=15] Minimum number of picture to have before splitting to a different group/vault
-v, --verbose Verbose mode (Multiple -v options increase the verbosity.)
$ picv
{"Help":false,"Gap":5,"Pod":15,"Verbose":{}}{"Help":false,"Gap":5,"Pod":15,"Verbose":{}}
```
If you need to tweak the `.yaml` file further, just
1. Update the `.yaml` file
1. Run `go generate -x` to update the [picvCLIDef.go](https://github.com/suntong/picv/blob/0.1.0/picvCLIDef.go) file
1. And then do more editing to [picvCLICmd.go](https://github.com/suntong/picv/blob/0.1.0/picvCLICmd.go) to incorporate the new changes
### With sub-commands case
The _sub commands_ are modern way of providing cli interfaces, like `apt-get`, `git` etc. As a comparison, the tradition rcs (Revision Control System) tool uses different commands for version repo management, check-in, check-out, and view logs (`rcs`, `ci`, `co`, `rlog` respectively), but `git` provides these functionalities all under the same `git` command, but different sub commands instead (`clone`/`init` etc, `commit`, `checkout`, `log`).
How to generate cli handling code that has sub-commands? The procedure is exactly the same as above. I'm using [my picv v0.2.0 ](https://github.com/suntong/picv/tree/0.2.0) this time as the example:
1. Provide a `.yaml` file -- [picv.yaml](https://github.com/suntong/picv/blob/0.2.0/picv.yaml). You can see that the `.yaml` file only changes in its organization, while the content are reused nearly 100%, only that [new sub-commands are added](https://github.com/suntong/picv/blob/10daaa84d9545ffb129c4909de7019dc896fd0be/picv.yaml) and [options have been shifted around](https://github.com/suntong/picv/commit/10daaa84d9545ffb129c4909de7019dc896fd0be#diff-78301e4359962421c827625b6393ab5b).
1. Provide a code-gen shell script -- [picvCLIGen.sh](https://github.com/suntong/picv/blob/0.2.0/picvCLIGen.sh) and run it to generate [picvCLIDef.go](https://github.com/suntong/picv/blob/0.2.0/picvCLIDef.go). This step is exactly as above.
1. Extract the commented out code to [picvMain.go](https://github.com/suntong/picv/blob/0.2.0/picvMain.go), [cmdCut.go](https://github.com/suntong/picv/blob/0.2.0/cmdCut.go) and the new [cmdArch.go](https://github.com/suntong/picv/blob/0.2.0/cmdArch.go). Note that I leave the _Main dispatcher_ in `picvMain.go` in this case, because it is clearer, as each sub commands just need to deal with their own handling.
1. Now the code wire-frame is done, and ready for compilation and execution.
```
$ picv -h
picture vault
built on 2017-06-03
Tool to deal with camera pictures and put them in vault
Options:
-h, --help display help information
-v, --verbose Verbose mode (Multiple -v options increase the verbosity.)
Commands:
cut Separate picture into groups
arch Archive groups of picture into vaults
$ picv cut -h
Separate picture into groups
Options:
-h, --help display help information
-v, --verbose Verbose mode (Multiple -v options increase the verbosity.)
-g, --gap[=5] Gap in days to be considered as different group/vault
-p, --pod[=15] Minimum number of picture to have before splitting to a different group/vault
$ picv cut
{"Gap":5,"Pod":15,"Verbose":0}
$ picv cut -vv
{"Gap":5,"Pod":15,"Verbose":2}
```
The rest are the same as above as well.
## Further abstraction
Note the output of my picv [v0.1.0 ](https://github.com/suntong/picv/tree/0.1.0) and [v0.2.0 ](https://github.com/suntong/picv/tree/0.2.0) are different. This is because I've done a further abstraction step (manually, but could also be somewhat automated if you want) in [v0.1.1 ](https://github.com/suntong/picv/tree/0.1.1), which defined an option structure that is independent of the `mkideal/cli` package.
I view this further abstraction a _logical_ representation of the options the tool can use, while the option structure defined in [picvCLIDef.go](https://github.com/suntong/picv/blob/master/picvCLIDef.go) is a _"physical"_ representation of the options, because its foreign-package-depending nature.
This step is not absolutely necessary, but I found such practice more organized. Note [how it is masking/hiding the implementation detail that `-v` is from global option, and how easy it is to make the corresponding changes when the `-v` option changed its definition location](https://github.com/suntong/picv/commit/10daaa84d9545ffb129c4909de7019dc896fd0be#diff-e7c16ee367258e94c2fc12e8b273d921R32).
easygen-4.1.0/cmd/ 0000775 0000000 0000000 00000000000 13502324010 0013700 5 ustar 00root root 0000000 0000000 easygen-4.1.0/cmd/easygen/ 0000775 0000000 0000000 00000000000 13502324010 0015333 5 ustar 00root root 0000000 0000000 easygen-4.1.0/cmd/easygen/.gitignore 0000664 0000000 0000000 00000000010 13502324010 0017312 0 ustar 00root root 0000000 0000000 easygen
easygen-4.1.0/cmd/easygen/config.tmpl 0000664 0000000 0000000 00000000767 13502324010 0017510 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package {{.PackageName}}
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
const progname = "{{.ProgramName}}" // os.Args[0]
// The {{.StructName}} struct defines the structure to hold the commandline values
type {{.StructName}} struct { {{range .Options}}{{if ne .Name "SEPARATOR" }}
{{.Name}} {{.Type}} // {{.Usage}}{{end}}{{end}}
}
easygen-4.1.0/cmd/easygen/easygen.1.ronn 0000664 0000000 0000000 00000004063 13502324010 0020026 0 ustar 00root root 0000000 0000000 # easygen -- Easy to use universal code/text generator
## SYNOPSIS
easygen [flags] template_name [data_filename [data_filename...]]
data_filename(s): The name for the .yaml or .json data.
- If omitted derive from the template_name.
- Can have the extension or without it. If withot extension,
will try .yaml first then .json
- Can include the path as well.
template_name: The name for the template file.
- Can have the extension or without it.
- Can include the path as well.
- Can be a comma-separated list giving many template files, in which case
at least one data_filename must be given.
## DESCRIPTION
Command `easygen` is an easy to use universal code/text generator.
It can be used as a text or html generator for _arbitrary_ purposes with _arbitrary_ data and templates. It is a good GSL replacement, as it
- is more easy to define driving data, in form of YML instead of XML
- has more powerful template engine that based on Go template.
You can even write your own function in Go to customize your template.
You can even use easygen as a generic Go template testing tool using the `-ts` commandline option, and much more.
## Usage
It's very easy to use -- just type `easygen` and following the inline help.
Or try the following example to get started:
export PATH=$PATH:$GOPATH/bin
$ easygen $GOPATH/src/github.com/go-easygen/easygen/test/list0
The colors are: red, blue, white, .
cd $GOPATH/src/github.com/go-easygen/easygen
$ easygen test/list1
The quoted colors are: "red", "blue", "white", .
$ easygen -tf test/listfunc1 test/list0
red, blue, white.
## EXAMPLES
`easygen` comes with comprehensive online documents. For further details,
please go to:
https://github.com/go-easygen/easygen
https://suntong.github.io/blogs/2016/01/01/easygen---easy-to-use-universal-code/text-generator
https://github.com/go-easygen/easygen/blob/master/using_easygen.md
https://github.com/go-easygen/easygen/wiki/Getting-Started
https://godoc.org/github.com/go-easygen/easygen#pkg-examples
easygen-4.1.0/cmd/easygen/easygen.gen.sh 0000775 0000000 0000000 00000000205 13502324010 0020072 0 ustar 00root root 0000000 0000000 easygen config easygen | gofmt > ../../config.go
easygen flags easygen | sed 's/^package easygen/package main/' | gofmt > flags.go
easygen-4.1.0/cmd/easygen/easygen.yaml 0000664 0000000 0000000 00000004427 13502324010 0017661 0 ustar 00root root 0000000 0000000 # program name, name for the executable
ProgramName: easygen
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: easygen
# Name of the structure to hold the values for/from commandline
StructName: Options
# The actual variable that hold the commandline paramter values
StructVar: Opts
Options:
- Name: TemplateStr
Type: string
Flag: ts
Value: '""'
Usage: "template string (in text)"
- Name: ExtYaml
Type: string
Flag: ey
Value: '".yaml"'
Usage: "`extension` of yaml file"
- Name: ExtJson
Type: string
Flag: ej
Value: '".json"'
Usage: "`extension` of json file"
- Name: ExtTmpl
Type: string
Flag: et
Value: '".tmpl"'
Usage: "`extension` of template file"
- Name: Debug
Type: int
Flag: debug
Value: 0
Usage: "debugging `level`"
# Whether to use the USAGE_SUMMARY in Usage help
UsageSummary: ""
UsageLead: "\\nUsage:\\n %s [flags] template_name [data_filename [data_filename...]]\\n\\nFlags:\\n\\n"
UsageEnd: "\\ndata_filename(s): The name for the .yaml or .json data.\\n - If omitted derive from the template_name.\\n - Can have the extension or without it. If withot extension,\\n will try .yaml first then .json\\n - Can include the path as well.\\n\\ntemplate_name: The name for the template file.\\n - Can have the extension or without it.\\n - Can include the path as well.\\n - Can be a comma-separated list giving many template files, in which case\\n at least one data_filename must be given.\\n\\nFlag defaults can be overridden by corresponding environment variable, e.g.:\\n EASYGEN_EY=.yml EASYGEN_ET=.tpl easygen ...\\n"
easygen-4.1.0/cmd/easygen/flags.go 0000664 0000000 0000000 00000004731 13502324010 0016763 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package main
import (
"flag"
"fmt"
"os"
"github.com/go-easygen/easygen"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
//const progname = "easygen" // os.Args[0]
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
////////////////////////////////////////////////////////////////////////////
// Commandline definitions
func init() {
// set default values for command line parameters
flag.StringVar(&easygen.Opts.TemplateStr, "ts", "",
"template string (in text)")
flag.StringVar(&easygen.Opts.ExtYaml, "ey", ".yaml",
"`extension` of yaml file")
flag.StringVar(&easygen.Opts.ExtJson, "ej", ".json",
"`extension` of json file")
flag.StringVar(&easygen.Opts.ExtTmpl, "et", ".tmpl",
"`extension` of template file")
flag.IntVar(&easygen.Opts.Debug, "debug", 0,
"debugging `level`")
// Now override those default values from environment variables
if len(easygen.Opts.TemplateStr) == 0 ||
len(os.Getenv("EASYGEN_TS")) != 0 {
easygen.Opts.TemplateStr = os.Getenv("EASYGEN_TS")
}
if len(easygen.Opts.ExtYaml) == 0 ||
len(os.Getenv("EASYGEN_EY")) != 0 {
easygen.Opts.ExtYaml = os.Getenv("EASYGEN_EY")
}
if len(easygen.Opts.ExtJson) == 0 ||
len(os.Getenv("EASYGEN_EJ")) != 0 {
easygen.Opts.ExtJson = os.Getenv("EASYGEN_EJ")
}
if len(easygen.Opts.ExtTmpl) == 0 ||
len(os.Getenv("EASYGEN_ET")) != 0 {
easygen.Opts.ExtTmpl = os.Getenv("EASYGEN_ET")
}
}
// Usage function shows help on commandline usage
func Usage() {
fmt.Fprintf(os.Stderr,
"%s version %s\n\nUsage:\n %s [flags] template_name [data_filename [data_filename...]]\n\nFlags:\n\n",
progname, version, progname)
flag.PrintDefaults()
fmt.Fprintf(os.Stderr,
"\ndata_filename(s): The name for the .yaml or .json data.\n - If omitted derive from the template_name.\n - Can have the extension or without it. If withot extension,\n will try .yaml first then .json\n - Can include the path as well.\n\ntemplate_name: The name for the template file.\n - Can have the extension or without it.\n - Can include the path as well.\n - Can be a comma-separated list giving many template files, in which case\n at least one data_filename must be given.\n\nFlag defaults can be overridden by corresponding environment variable, e.g.:\n EASYGEN_EY=.yml EASYGEN_ET=.tpl easygen ...\n")
os.Exit(0)
}
easygen-4.1.0/cmd/easygen/flags.tmpl 0000664 0000000 0000000 00000003362 13502324010 0017331 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package {{.PackageName}}
import (
"flag"
"fmt"
"os"
"github.com/go-easygen/easygen"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
//const progname = "{{.ProgramName}}" // os.Args[0]
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
////////////////////////////////////////////////////////////////////////////
// Commandline definitions
func init() {
// set default values for command line parameters{{range .Options}}{{if eq .Name "SEPARATOR" }}
{{else}}
flag.{{clk2uc .Type}}Var(&easygen.{{$.StructVar}}.{{.Name}}, "{{.Flag}}", {{.Value}},
"{{.Usage}}"){{end}}{{end}}
// Now override those default values from environment variables{{range .Options}}{{if eq .Name "SEPARATOR" }}
{{else}}{{if eq .Type "string" }}{{$envVar := printf "%s_%s" (clk2ss $.ProgramName) (clk2ss .Flag)}}
if len(easygen.{{$.StructVar}}.{{.Name}}) == 0 ||
len(os.Getenv("{{$envVar}}")) != 0 {
easygen.{{$.StructVar}}.{{.Name}} = os.Getenv("{{$envVar}}")
}{{end}}{{end}}{{end}}
}
{{if eqf .UsageSummary "True" }}
const USAGE_SUMMARY = "{{range .Options}}{{if eq .Name "SEPARATOR" }}\n{{else}}{{$envVar := printf "%s_%s" (clk2ss $.ProgramName) (clk2ss .Flag)}} -{{.Flag}}\t{{.Usage}} ({{$envVar}})\n{{end}}{{end}}\nDetails:\n\n"
{{end}}
// Usage function shows help on commandline usage
func Usage() {
fmt.Fprintf(os.Stderr,
"%s version %s\n{{.UsageLead}}",
progname, version, progname){{if eq .UsageSummary "TRUE" }}
fmt.Fprintf(os.Stderr, USAGE_SUMMARY){{end}}
flag.PrintDefaults()
fmt.Fprintf(os.Stderr,
"{{.UsageEnd}}")
os.Exit(0)
}
easygen-4.1.0/cmd/easygen/main.go 0000664 0000000 0000000 00000004464 13502324010 0016616 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Porgram: easygen
// Purpose: Easy to use universal code/text generator
// Authors: Tong Sun (c) 2015-2019, All rights reserved
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// Program start
/*
Command easygen is an easy to use universal code/text generator.
It can be used as a text or html generator for arbitrary purposes with arbitrary data and templates.
It can be used as a code generator, or anything that is structurally repetitive. Some command line parameter handling code generator are provided as examples, including the Go's built-in flag package, and the viper & cobra package.
You can even use easygen as a generic Go template testing tool using the -ts commandline option.
*/
package main
import (
"flag"
"os"
"strings"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egFilePath"
"github.com/go-easygen/easygen/egVar"
)
//go:generate sh -v easygen.gen.sh
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
var (
progname = "easygen"
version = "4.1.0"
date = "2019-06-18"
)
////////////////////////////////////////////////////////////////////////////
// Main
func main() {
flag.Usage = Usage
flag.Parse()
// One mandatory non-flag arguments
if flag.NArg() < 1 {
Usage()
}
args := flag.Args()
// There is only one command line argument
if len(args) == 1 {
// when template_name is comma-separated list, data_filename must be given
if strings.Contains(args[0], ",") {
Usage()
}
// else, dup template_name as data_filename
args = append(args, args[0])
}
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).
Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs()).Funcs(egFilePath.FuncDefs())
var err error
if len(easygen.Opts.TemplateStr) > 0 {
err = easygen.Process0(tmpl, os.Stdout, easygen.Opts.TemplateStr, args...)
} else {
err = easygen.Process2(tmpl, os.Stdout, args[0], args[1:]...)
}
if err != nil {
panic(err)
}
}
easygen-4.1.0/cmd/easygen/main_test.go 0000664 0000000 0000000 00000006207 13502324010 0017652 0 ustar 00root root 0000000 0000000 package main_test
import (
"bytes"
"os"
"os/exec"
"strings"
"testing"
)
const (
cmdEasygen = "easygen"
dirTest = "../../test/"
extRef = ".ref" // extension for reference file
extGot = ".got" // extension for generated file
)
// testEasygen runs @cmdEasyGen with @argv and compares the generated
// output for @name with the corresponding @extRef
func testEasygen(t *testing.T, name string, argv ...string) {
var (
diffOut bytes.Buffer
generatedOutput = name + extGot
cmd = exec.Command(cmdEasygen, argv...)
)
t.Logf("Testing %s:\n\t%s %s", name, cmdEasygen, strings.Join(argv, " "))
// open the out file for writing
outfile, err := os.Create(generatedOutput)
if err != nil {
t.Errorf("write error [%s: %s] %s.", name, argv, err)
}
defer outfile.Close()
cmd.Stdout = outfile
err = cmd.Start()
if err != nil {
t.Errorf("start error [%s: %s] %s.", name, argv, err)
}
err = cmd.Wait()
if err != nil {
t.Errorf("exit error [%s: %s] %s.", name, argv, err)
}
cmd = exec.Command("diff", "-U1", name+extRef, generatedOutput)
cmd.Stdout = &diffOut
err = cmd.Start()
if err != nil {
t.Errorf("start error %s [%s: %s]", err, name, argv)
}
err = cmd.Wait()
if err != nil {
t.Errorf("cmp error %s [%s: %s]\n%s", err, name, argv, diffOut.String())
}
os.Remove(generatedOutput)
}
func TestExec(t *testing.T) {
os.Chdir(dirTest)
//Test Basic Functions
testEasygen(t, "list0", "list0")
// Filename suffixes are optional
testEasygen(t, "list0", "list0.yaml")
testEasygen(t, "list0", "list0", "list0")
testEasygen(t, "list0", "list0.tmpl", "list0")
testEasygen(t, "list0", "list0.tmpl", "list0.yaml")
testEasygen(t, "list0E", "list0E", "list0")
testEasygen(t, "list1", "list1")
testEasygen(t, "listfunc1", "listfunc1")
testEasygen(t, "listfunc2", "listfunc2")
//Test Basic Json Functions
testEasygen(t, "list0j", "list0j")
testEasygen(t, "list0j", "list0j", "list0j")
testEasygen(t, "list0j", "list0j", "list0j.json")
// template_name can be a comma-separated list
testEasygen(t, "list01", "list0,listfunc1", "list0")
//Test HTML
testEasygen(t, "list1HTML", "list1HTML", "list1")
// varcaser string functions
testEasygen(t, "var0", "-ts", "{{.Name}}", "var0")
testEasygen(t, "var1", "-ts", "{{clk2uc .Name}}", "var0")
testEasygen(t, "var2", "-ts", "{{clk2ss .Name}}", "var0")
//Test Bigger files
testEasygen(t, "commandlineCLI-024", "commandlineCLI-024")
testEasygen(t, "commandlineCLI-027", "commandlineCLI-027")
testEasygen(t, "commandlineCLI-027s", "commandlineCLI-027", "commandlineCLI-027s")
testEasygen(t, "commandlineCVFull", "commandlineCVFull")
testEasygen(t, "commandlineCV", "commandlineCV")
testEasygen(t, "commandlineFlag", "commandlineFlag")
// Enum generation: (a) run template with multiple data inputs,
// (b) run the same input with multiple template files:
testEasygen(t, "enum_multiple_data_files", "enum_c-header", "raid_type", "raid_driver")
testEasygen(t, "enum_multiple_template_files", "enum_c-header,enum_c-source", "raid_type.yaml")
testEasygen(t, "enum_multiple_template_and_data", "enum_c-header,enum_c-to_str", "raid_type", "raid_driver.yaml")
}
easygen-4.1.0/config.go 0000664 0000000 0000000 00000001140 13502324010 0014725 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package easygen
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
const progname = "easygen" // os.Args[0]
// The Options struct defines the structure to hold the commandline values
type Options struct {
TemplateStr string // template string (in text)
ExtYaml string // `extension` of yaml file
ExtJson string // `extension` of json file
ExtTmpl string // `extension` of template file
Debug int // debugging `level`
}
easygen-4.1.0/easygen.go 0000664 0000000 0000000 00000015670 13502324010 0015130 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: easygen
// Purpose: Easy to use universal code/text generator
// Authors: Tong Sun (c) 2015-2019, All rights reserved
////////////////////////////////////////////////////////////////////////////
/*
Package easygen is an easy to use universal code/text generator library.
It can be used as a text or html generator for arbitrary purposes with arbitrary data and templates.
It can be used as a code generator, or anything that is structurally repetitive. Some command line parameter handling code generator are provided as examples, including the Go's built-in flag package, and the viper & cobra package.
Many examples have been provided to showcase its functionality, and different ways to use it.
*/
package easygen
import (
"encoding/json"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"regexp"
"strings"
"gopkg.in/yaml.v2"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
// EgData -- EasyGen driven Data
type EgData interface{}
// Opts holds the actual values from the command line parameters
var Opts = Options{ExtYaml: ".yaml", ExtJson: ".json", ExtTmpl: ".tmpl"}
////////////////////////////////////////////////////////////////////////////
// Function definitions
// ReadDataFile reads in the driving data from the given file, which can
// be optionally without the defined extension
func ReadDataFile(fileName string) EgData {
if IsExist(fileName + Opts.ExtYaml) {
return ReadYamlFile(fileName + Opts.ExtYaml)
} else if IsExist(fileName + Opts.ExtJson) {
return ReadJsonFile(fileName + Opts.ExtJson)
} else if IsExist(fileName) {
verbose("Reading exist Data File", 2)
fext := filepath.Ext(fileName)
fext = fext[1:] // ignore the leading "."
if regexp.MustCompile(`(?i)^y`).MatchString(fext) {
verbose("Reading YAML file", 2)
return ReadYamlFile(fileName)
} else if regexp.MustCompile(`(?i)^j`).MatchString(fext) {
return ReadJsonFile(fileName)
} else {
checkError(fmt.Errorf("Unsupported file extension for DataFile '%s'", fileName))
}
}
checkError(fmt.Errorf("DataFile '%s' cannot be found", fileName))
return nil
}
// ReadYamlFile reads given YAML file as EgData
func ReadYamlFile(fileName string) EgData {
source, err := ioutil.ReadFile(fileName)
checkError(err)
m := make(map[interface{}]interface{})
err = yaml.Unmarshal(source, &m)
checkError(err)
return m
}
// ReadJsonFile reads given JSON file as EgData
func ReadJsonFile(fileName string) EgData {
source, err := ioutil.ReadFile(fileName)
checkError(err)
m := make(map[string]interface{})
err = json.Unmarshal(source, &m)
checkError(err)
return m
}
// IsExist checks if the given file exist
func IsExist(fileName string) bool {
//fmt.Printf("] Checking %s\n", fileName)
_, err := os.Stat(fileName)
return err == nil || os.IsExist(err)
// CAUTION! os.IsExist(err) != !os.IsNotExist(err)
// https://gist.github.com/mastef/05f46d3ab2f5ed6a6787#file-isexist_vs_isnotexist-go-L35-L56
}
// Process will process the standard easygen input: the `fileName` is for both template and data file name, and produce output from the template according to the corresponding driving data.
// Process() is using the V3's calling convention and *only* works properly in V4+ in the case that there is only one fileName passed to it. If need to pass more files, use Process2() instead.
func Process(t Template, wr io.Writer, fileNames ...string) error {
return Process2(t, wr, fileNames[0], fileNames[:1]...)
}
// Process2 will process the case that *both* template and data file names are given, and produce output according to the given template and driving data files,
// specified via fileNameTempl and fileNames respectively.
// fileNameTempl can be a comma-separated string giving many template files
func Process2(t Template, wr io.Writer, fileNameTempl string, fileNames ...string) error {
for _, dataFn := range fileNames {
for _, templateFn := range strings.Split(fileNameTempl, ",") {
err := Process1(t, wr, templateFn, dataFn)
checkError(err)
}
}
return nil
}
// Process1 will process a *single* case where both template and data file names are given, and produce output according to the given template and driving data files,
// specified via fileNameTempl and fileName respectively.
// fileNameTempl is not a comma-separated string, but for a single template file.
func Process1(t Template, wr io.Writer, fileNameTempl string, fileName string) error {
m := ReadDataFile(fileName)
//fmt.Printf("] %+v\n", m)
// template file
fileName = fileNameTempl
fileNameT := fileNameTempl
if IsExist(fileName + Opts.ExtTmpl) {
fileNameT = fileName + Opts.ExtTmpl
} else {
// guard against that fileNameTempl passed with Opts.ExtYaml extension
if fileName[len(fileName)-len(Opts.ExtYaml):] == Opts.ExtYaml {
idx := strings.LastIndex(fileName, ".")
fileName = fileName[:idx]
if IsExist(fileName + Opts.ExtTmpl) {
fileNameT = fileName + Opts.ExtTmpl
}
} else if IsExist(fileName) {
// fileNameTempl passed with Opts.ExtTmpl already
fileNameT = fileName
}
}
return Execute(t, wr, fileNameT, m)
}
// Execute will execute the Template on the given data map `m`.
func Execute(t Template, wr io.Writer, fileNameT string, m EgData) error {
// 1. Check locally
verbose("Checking for template locally: "+fileNameT, 1)
if !IsExist(fileNameT) {
// 2. Check under /etc/
command := filepath.Base(os.Args[0])
templateFile := fmt.Sprintf("/etc/%s/%s", command, fileNameT)
verbose("Checking at "+templateFile, 1)
if IsExist(templateFile) {
fileNameT = templateFile
} else {
// 3. Check where executable is
ex, e := os.Executable()
if e != nil {
return e
}
fileNameT = filepath.Dir(ex) + string(filepath.Separator) + fileNameT
verbose("Checking at "+fileNameT, 1)
if !IsExist(fileNameT) {
checkError(fmt.Errorf("Template file '%s' cannot be found", fileNameT))
}
}
}
tn, err := t.ParseFiles(fileNameT)
checkError(err)
return tn.ExecuteTemplate(wr, filepath.Base(fileNameT), m)
}
// Process0 will produce output according to the driving data *without* a template file, using the string from strTempl as the template
func Process0(t Template, wr io.Writer, strTempl string, fileNames ...string) error {
fileName := fileNames[0]
m := ReadDataFile(fileName)
tmpl, err := t.Parse(strTempl)
checkError(err)
return tmpl.Execute(wr, m)
}
////////////////////////////////////////////////////////////////////////////
// Support Function definitions
// Exit if error occurs
func checkError(err error) {
if err != nil {
fmt.Fprintf(os.Stderr, "[%s] Fatal error - %s\n", progname, err)
os.Exit(1)
}
}
// verbose will print info to stderr according to the verbose level setting
func verbose(step string, level int) {
if Opts.Debug >= level {
print("[", progname, "] ", step, "\n")
}
}
easygen-4.1.0/easygen_test.go 0000664 0000000 0000000 00000004241 13502324010 0016157 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"os"
"text/template"
"github.com/go-easygen/easygen"
)
var tmpl *template.Template
func init() {
tmpl = easygen.NewTemplate().Funcs(easygen.FuncDefs())
}
////////////////////////////////////////////////////////////////////////////
// Lists
//==========================================================================
// list0 data + string template
// I.e.: EasyGen -ts "{{range .Colors}}{{.}}, {{end}}" test/list0
// Test string template with list0 data
func ExampleProcess0_list0StrTemplate() {
// Equivalent testing on commandline:
// easygen -ts '{{range .Colors}}{{.}}, {{end}}' test/list0
easygen.Process0(tmpl, os.Stdout,
"{{range .Colors}}{{.}}, {{end}}", "test/list0")
// Output:
// red, blue, white,
}
// Test HTML template with list1 data
func ExampleProcess2_html() {
// Equivalent testing on commandline:
// easygen -tf test/list1HTML test/list1
easygen.Process2(tmpl, os.Stdout, "test/list1HTML", "test/list1")
// Output:
// The quoted colors are: "red", "blue", "white", .
}
////////////////////////////////////////////////////////////////////////////
// Strings Test
// Test string comparison in template
func ExampleProcess0_stringsCmp() {
// Equivalent testing on commandline:
// easygen -ts '{{The {{if ... {{end}}.' test/strings0
easygen.Process0(tmpl, os.Stdout,
`The {{if eq .StrTest "-AB-axxb- HTML Html html"}}eq says Yea{{else}}eq says Nay{{end}} but {{if eqf .StrTest "-AB-axxb- HTML Html html"}}eqf says Yea{{else}}eqf says Nay{{end}}.`, "test/strings0")
// Output:
// The eq says Nay but eqf says Yea.
}
// Test the string split function in template
func ExampleProcess0_split0() {
// Equivalent testing on commandline:
// easygen -ts '{{split .Colorlist}}' test/list0
easygen.Process0(tmpl, os.Stdout,
`{{split .Colorlist}}`, "test/list0")
// Output:
// [red blue white]
}
// Test the string split function in template again
func ExampleProcess0_split1() {
// Equivalent testing on commandline:
// easygen -ts '{{range ... {{end}}' test/list0
easygen.Process0(tmpl, os.Stdout,
`{{range (split .Colorlist)}}{{.}} {{end}}`, "test/list0")
// Output:
// red blue white
}
easygen-4.1.0/egCal/ 0000775 0000000 0000000 00000000000 13502324010 0014150 5 ustar 00root root 0000000 0000000 easygen-4.1.0/egCal/EgCal.go 0000664 0000000 0000000 00000002203 13502324010 0015447 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: egCal
// Purpose: easygen generic calculation functionalities
// Authors: Tong Sun (c) 2017, All rights reserved
////////////////////////////////////////////////////////////////////////////
/*
Package egCal provides generic calculation functionalities.
egCal provides the generic calculation functionalities from
consul template functions
https://github.com/hashicorp/consul-template / template_functions.go
*/
package egCal
import (
"text/template"
"github.com/go-easygen/easygen"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
// EgCal -- EasyGen Calculation
type EgCal struct {
*easygen.EgBase
}
var egFuncMap = easygen.FuncMap{
"add": add,
"subtract": subtract,
"multiply": multiply,
"divide": divide,
}
////////////////////////////////////////////////////////////////////////////
// Function definitions
// FuncDefs returns the custom definition mapping for this specific package.
func FuncDefs() template.FuncMap {
return template.FuncMap(egFuncMap)
}
easygen-4.1.0/egCal/LICENSE 0000664 0000000 0000000 00000037147 13502324010 0015171 0 ustar 00root root 0000000 0000000 Mozilla Public License, version 2.0
1. Definitions
1.1. “Contributor”
means each individual or legal entity that creates, contributes to the
creation of, or owns Covered Software.
1.2. “Contributor Version”
means the combination of the Contributions of others (if any) used by a
Contributor and that particular Contributor’s Contribution.
1.3. “Contribution”
means Covered Software of a particular Contributor.
1.4. “Covered Software”
means Source Code Form to which the initial Contributor has attached the
notice in Exhibit A, the Executable Form of such Source Code Form, and
Modifications of such Source Code Form, in each case including portions
thereof.
1.5. “Incompatible With Secondary Licenses”
means
a. that the initial Contributor has attached the notice described in
Exhibit B to the Covered Software; or
b. that the Covered Software was made available under the terms of version
1.1 or earlier of the License, but not also under the terms of a
Secondary License.
1.6. “Executable Form”
means any form of the work other than Source Code Form.
1.7. “Larger Work”
means a work that combines Covered Software with other material, in a separate
file or files, that is not Covered Software.
1.8. “License”
means this document.
1.9. “Licensable”
means having the right to grant, to the maximum extent possible, whether at the
time of the initial grant or subsequently, any and all of the rights conveyed by
this License.
1.10. “Modifications”
means any of the following:
a. any file in Source Code Form that results from an addition to, deletion
from, or modification of the contents of Covered Software; or
b. any new file in Source Code Form that contains any Covered Software.
1.11. “Patent Claims” of a Contributor
means any patent claim(s), including without limitation, method, process,
and apparatus claims, in any patent Licensable by such Contributor that
would be infringed, but for the grant of the License, by the making,
using, selling, offering for sale, having made, import, or transfer of
either its Contributions or its Contributor Version.
1.12. “Secondary License”
means either the GNU General Public License, Version 2.0, the GNU Lesser
General Public License, Version 2.1, the GNU Affero General Public
License, Version 3.0, or any later versions of those licenses.
1.13. “Source Code Form”
means the form of the work preferred for making modifications.
1.14. “You” (or “Your”)
means an individual or a legal entity exercising rights under this
License. For legal entities, “You” includes any entity that controls, is
controlled by, or is under common control with You. For purposes of this
definition, “control” means (a) the power, direct or indirect, to cause
the direction or management of such entity, whether by contract or
otherwise, or (b) ownership of more than fifty percent (50%) of the
outstanding shares or beneficial ownership of such entity.
2. License Grants and Conditions
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
a. under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or as
part of a Larger Work; and
b. under Patent Claims of such Contributor to make, use, sell, offer for
sale, have made, import, and otherwise transfer either its Contributions
or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution become
effective for each Contribution on the date the Contributor first distributes
such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under this
License. No additional rights or licenses will be implied from the distribution
or licensing of Covered Software under this License. Notwithstanding Section
2.1(b) above, no patent license is granted by a Contributor:
a. for any code that a Contributor has removed from Covered Software; or
b. for infringements caused by: (i) Your and any other third party’s
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
c. under Patent Claims infringed by Covered Software in the absence of its
Contributions.
This License does not grant any rights in the trademarks, service marks, or
logos of any Contributor (except as may be necessary to comply with the
notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this License
(see Section 10.2) or under the terms of a Secondary License (if permitted
under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its Contributions
are its original creation(s) or it has sufficient rights to grant the
rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under applicable
copyright doctrines of fair use, fair dealing, or other equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
Section 2.1.
3. Responsibilities
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under the
terms of this License. You must inform recipients that the Source Code Form
of the Covered Software is governed by the terms of this License, and how
they can obtain a copy of this License. You may not attempt to alter or
restrict the recipients’ rights in the Source Code Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
a. such Covered Software must also be made available in Source Code Form,
as described in Section 3.1, and You must inform recipients of the
Executable Form how they can obtain a copy of such Source Code Form by
reasonable means in a timely manner, at a charge no more than the cost
of distribution to the recipient; and
b. You may distribute such Executable Form under the terms of this License,
or sublicense it under different terms, provided that the license for
the Executable Form does not attempt to limit or alter the recipients’
rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for the
Covered Software. If the Larger Work is a combination of Covered Software
with a work governed by one or more Secondary Licenses, and the Covered
Software is not Incompatible With Secondary Licenses, this License permits
You to additionally distribute such Covered Software under the terms of
such Secondary License(s), so that the recipient of the Larger Work may, at
their option, further distribute the Covered Software under the terms of
either this License or such Secondary License(s).
3.4. Notices
You may not remove or alter the substance of any license notices (including
copyright notices, patent notices, disclaimers of warranty, or limitations
of liability) contained within the Source Code Form of the Covered
Software, except that You may alter any license notices to the extent
required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on behalf
of any Contributor. You must make it absolutely clear that any such
warranty, support, indemnity, or liability obligation is offered by You
alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
If it is impossible for You to comply with any of the terms of this License
with respect to some or all of the Covered Software due to statute, judicial
order, or regulation then You must: (a) comply with the terms of this License
to the maximum extent possible; and (b) describe the limitations and the code
they affect. Such description must be placed in a text file included with all
distributions of the Covered Software under this License. Except to the
extent prohibited by statute or regulation, such description must be
sufficiently detailed for a recipient of ordinary skill to be able to
understand it.
5. Termination
5.1. The rights granted under this License will terminate automatically if You
fail to comply with any of its terms. However, if You become compliant,
then the rights granted under this License from a particular Contributor
are reinstated (a) provisionally, unless and until such Contributor
explicitly and finally terminates Your grants, and (b) on an ongoing basis,
if such Contributor fails to notify You of the non-compliance by some
reasonable means prior to 60 days after You have come back into compliance.
Moreover, Your grants from a particular Contributor are reinstated on an
ongoing basis if such Contributor notifies You of the non-compliance by
some reasonable means, this is the first time You have received notice of
non-compliance with this License from such Contributor, and You become
compliant prior to 30 days after Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions, counter-claims,
and cross-claims) alleging that a Contributor Version directly or
indirectly infringes any patent, then the rights granted to You by any and
all Contributors for the Covered Software under Section 2.1 of this License
shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
license agreements (excluding distributors and resellers) which have been
validly granted by You or Your distributors under this License prior to
termination shall survive termination.
6. Disclaimer of Warranty
Covered Software is provided under this License on an “as is” basis, without
warranty of any kind, either expressed, implied, or statutory, including,
without limitation, warranties that the Covered Software is free of defects,
merchantable, fit for a particular purpose or non-infringing. The entire
risk as to the quality and performance of the Covered Software is with You.
Should any Covered Software prove defective in any respect, You (not any
Contributor) assume the cost of any necessary servicing, repair, or
correction. This disclaimer of warranty constitutes an essential part of this
License. No use of any Covered Software is authorized under this License
except under this disclaimer.
7. Limitation of Liability
Under no circumstances and under no legal theory, whether tort (including
negligence), contract, or otherwise, shall any Contributor, or anyone who
distributes Covered Software as permitted above, be liable to You for any
direct, indirect, special, incidental, or consequential damages of any
character including, without limitation, damages for lost profits, loss of
goodwill, work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses, even if such party shall have been
informed of the possibility of such damages. This limitation of liability
shall not apply to liability for death or personal injury resulting from such
party’s negligence to the extent applicable law prohibits such limitation.
Some jurisdictions do not allow the exclusion or limitation of incidental or
consequential damages, so this exclusion and limitation may not apply to You.
8. Litigation
Any litigation relating to this License may be brought only in the courts of
a jurisdiction where the defendant maintains its principal place of business
and such litigation shall be governed by laws of that jurisdiction, without
reference to its conflict-of-law provisions. Nothing in this Section shall
prevent a party’s ability to bring cross-claims or counter-claims.
9. Miscellaneous
This License represents the complete agreement concerning the subject matter
hereof. If any provision of this License is held to be unenforceable, such
provision shall be reformed only to the extent necessary to make it
enforceable. Any law or regulation which provides that the language of a
contract shall be construed against the drafter shall not be used to construe
this License against a Contributor.
10. Versions of the License
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version of
the License under which You originally received the Covered Software, or
under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a modified
version of this License if you rename the license and remove any
references to the name of the license steward (except to note that such
modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular file, then
You may include the notice in a location (such as a LICENSE file in a relevant
directory) where a recipient would be likely to look for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - “Incompatible With Secondary Licenses” Notice
This Source Code Form is “Incompatible
With Secondary Licenses”, as defined by
the Mozilla Public License, v. 2.0. easygen-4.1.0/egCal/consul-template_functions.go 0000664 0000000 0000000 00000016503 13502324010 0021710 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: egCal
// Purpose: easygen generic calculation functionalities
// Authors: @HashiCorp (c) 2013-17, All rights reserved
// https://github.com/hashicorp/consul-template/blob/de2ebf4/template_functions.go#L727-L901
////////////////////////////////////////////////////////////////////////////
package egCal
import (
"fmt"
"reflect"
)
// add returns the sum of a and b.
func add(a, b interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int() + bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Int() + int64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return float64(av.Int()) + bv.Float(), nil
default:
return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return int64(av.Uint()) + bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Uint() + bv.Uint(), nil
case reflect.Float32, reflect.Float64:
return float64(av.Uint()) + bv.Float(), nil
default:
return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
}
case reflect.Float32, reflect.Float64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Float() + float64(bv.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Float() + float64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return av.Float() + bv.Float(), nil
default:
return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
}
default:
return nil, fmt.Errorf("add: unknown type for %q (%T)", av, a)
}
}
// subtract returns the difference of b from a.
func subtract(a, b interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int() - bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Int() - int64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return float64(av.Int()) - bv.Float(), nil
default:
return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return int64(av.Uint()) - bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Uint() - bv.Uint(), nil
case reflect.Float32, reflect.Float64:
return float64(av.Uint()) - bv.Float(), nil
default:
return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
}
case reflect.Float32, reflect.Float64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Float() - float64(bv.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Float() - float64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return av.Float() - bv.Float(), nil
default:
return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
}
default:
return nil, fmt.Errorf("subtract: unknown type for %q (%T)", av, a)
}
}
// multiply returns the product of a and b.
func multiply(a, b interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int() * bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Int() * int64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return float64(av.Int()) * bv.Float(), nil
default:
return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return int64(av.Uint()) * bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Uint() * bv.Uint(), nil
case reflect.Float32, reflect.Float64:
return float64(av.Uint()) * bv.Float(), nil
default:
return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
}
case reflect.Float32, reflect.Float64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Float() * float64(bv.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Float() * float64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return av.Float() * bv.Float(), nil
default:
return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
}
default:
return nil, fmt.Errorf("multiply: unknown type for %q (%T)", av, a)
}
}
// divide returns the division of b from a.
func divide(a, b interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int() / bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Int() / int64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return float64(av.Int()) / bv.Float(), nil
default:
return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return int64(av.Uint()) / bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Uint() / bv.Uint(), nil
case reflect.Float32, reflect.Float64:
return float64(av.Uint()) / bv.Float(), nil
default:
return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
}
case reflect.Float32, reflect.Float64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Float() / float64(bv.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Float() / float64(bv.Uint()), nil
case reflect.Float32, reflect.Float64:
return av.Float() / bv.Float(), nil
default:
return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
}
default:
return nil, fmt.Errorf("divide: unknown type for %q (%T)", av, a)
}
}
easygen-4.1.0/egCal/example_test.go 0000664 0000000 0000000 00000001321 13502324010 0017166 0 ustar 00root root 0000000 0000000 package egCal_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egVar"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func Example() {
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs())
easygen.Process0(tmpl, os.Stdout,
"{{.Name}}: {{clk2uc .Name}} {{clk2ss .Name}}\n"+
"Cal: {{add 2 3}}, {{multiply 2 3}}, {{subtract 9 2}}, {{divide 24 3}}\n",
"../test/var0")
// Output:
// some-init-method: SomeInitMethod SOME_INIT_METHOD
// Cal: 5, 6, 7, 8
}
// To show the full code in GoDoc
type dummy struct {
}
easygen-4.1.0/egFilePath/ 0000775 0000000 0000000 00000000000 13502324010 0015145 5 ustar 00root root 0000000 0000000 easygen-4.1.0/egFilePath/EgFilePath.go 0000664 0000000 0000000 00000003736 13502324010 0017455 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: egFilePath
// Purpose: EasyGen Generic FilePath Functionalities
// Authors: Tong Sun (c) 2019, All rights reserved
////////////////////////////////////////////////////////////////////////////
/*
Package egFilePath provides filepath manupilation functionalities.
egFilePath provides filepath manupilation manipulation, provided by "path/filepath".
*/
package egFilePath
import (
"os"
"path/filepath"
"strings"
"text/template"
"github.com/go-easygen/easygen"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
// EgFilePath -- EasyGen FilePath manupilation functionalities
type EgFilePath struct {
*easygen.EgBase
}
var egFuncMap = easygen.FuncMap{
//"fpAbs": filepath.Abs,
"fpBase": filepath.Base,
"fpClean": filepath.Clean,
"fpDir": filepath.Dir,
//"fpEvalSymlinks": filepath.EvalSymlinks,
"fpExt": filepath.Ext,
"fpFromSlash": filepath.FromSlash,
//"fpGlob": filepath.Glob,
"fpHasPrefix": filepath.HasPrefix,
"fpIsAbs": filepath.IsAbs,
"fpJoin": filepath.Join,
//"fpMatch": filepath.Match,
"fpRel": filepath.Rel,
//"fpSplit": filepath.Split,
//"fpSplitList": filepath.SplitList,
"fpToSlash": filepath.ToSlash,
"fpVolumeName": filepath.VolumeName,
"isDir": IsDir,
"basename": Basename,
}
////////////////////////////////////////////////////////////////////////////
// Function definitions
// FuncDefs returns the custom definition mapping for this specific package.
func FuncDefs() template.FuncMap {
return template.FuncMap(egFuncMap)
}
//==========================================================================
// support functions
func IsDir(path string) bool {
info, _ := os.Stat(path)
return info.IsDir()
}
func Basename(s string) string {
s = filepath.Base(s)
n := strings.LastIndexByte(s, '.')
if n > 0 {
return s[:n]
}
return s
}
easygen-4.1.0/egFilePath/example_test.go 0000664 0000000 0000000 00000002513 13502324010 0020167 0 ustar 00root root 0000000 0000000 package egFilePath_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egFilePath"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func Example() {
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egFilePath.FuncDefs())
easygen.Process0(tmpl, os.Stdout,
// "Rel: {{fpRel `/a/b/c`}}, {{fpRel `/b/c`}}, {{fpRel `./b/c`}}\n",
"Base: {{fpBase `/a/b.c`}}, {{fpBase `/b.c/`}}, {{fpBase `./b.c`}}, {{fpBase `b.c`}}\n"+
"Clean: {{fpClean `/a//b.c/./..`}}, {{fpClean `//b.c///`}}, {{fpClean `/../b.c`}}\n"+
"Dir: {{fpDir `/a/b/c`}}, {{fpDir `/b/c/`}}, {{fpDir `./b/c`}}, {{fpDir `b.c`}}\n"+
"Ext: {{fpExt `index`}}, {{fpExt `index.js`}}, {{fpExt `main.test.js`}}\n"+
"Join: {{fpJoin `/a` `b` `c` `a//` `//b////c`}}, {{fpJoin `a` `b/c`}}, {{fpJoin `a/b` `c`}}\n"+
// "IsDir: {{isDir `.`}}, {{isDir `not-exist`}}.\n"+
"IsDir: {{isDir `.`}}.\n"+
"Basename: {{basename `/a/b.c`}}, {{basename `/b.c/`}}, {{basename `b.c`}}, {{basename `bc`}}",
"../test/var0")
// Output:
// Base: b.c, b.c, b.c, b.c
// Clean: /a, /b.c, /b.c
// Dir: /a/b, /b/c, b, .
// Ext: , .js, .js
// Join: /a/b/c/a/b/c, a/b/c, a/b/c
// IsDir: true.
// Basename: b, b, b, bc
}
// To show the full code in GoDoc
type dummy struct {
}
easygen-4.1.0/egVar/ 0000775 0000000 0000000 00000000000 13502324010 0014201 5 ustar 00root root 0000000 0000000 easygen-4.1.0/egVar/EgVar.go 0000664 0000000 0000000 00000010371 13502324010 0015536 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: egVar
// Purpose: easygen variable naming functionalities
// Authors: Tong Sun (c) 2016-17, All rights reserved
////////////////////////////////////////////////////////////////////////////
/*
Package egVar provides variable naming functionalities.
egVar provides variable naming manipulation, available from danverbraganza/varcaser.
*/
package egVar
import (
"text/template"
"github.com/danverbraganza/varcaser/varcaser"
"github.com/go-easygen/easygen"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
// EgVar -- EasyGen variable naming
//
// pre-configed varcaser caser converters
// the names are self-explanatory from their definitions
// https://github.com/danverbraganza/varcaser/
/*
ls - LowerSnakeCase: lower_snake_case
ss - ScreamingSnakeCase: SCREAMING_SNAKE_CASE
lk - KebabCase: kebab-case
ScreamingKebabCase: SCREAMING-KEBAB-CASE
hh - HttpHeaderCase: HTTP-Header-Case
UpperCamelCase: UpperCamelCase (renders HTTP as Http)
LowerCamelCase: lowerCamelCase (renders HTTP as Http)
uc - UpperCamelCaseKeepCaps: UpperCamelCaseKeepCaps (renders HTTP as HTTP)
lc - LowerCamelCaseKeepCaps: lowerCamelCaseKeepCaps (renders HTTP as hTTP)
*/
type EgVar struct {
*easygen.EgBase
}
var (
cls2lc = varcaser.Caser{
From: varcaser.LowerSnakeCase, To: varcaser.LowerCamelCaseKeepCaps}
cls2uc = varcaser.Caser{
From: varcaser.LowerSnakeCase, To: varcaser.UpperCamelCaseKeepCaps}
cls2ss = varcaser.Caser{
From: varcaser.LowerSnakeCase, To: varcaser.ScreamingSnakeCase}
cls2lk = varcaser.Caser{
From: varcaser.LowerSnakeCase, To: varcaser.KebabCase}
cls2hh = varcaser.Caser{
From: varcaser.LowerSnakeCase, To: varcaser.HttpHeaderCase}
css2lc = varcaser.Caser{
From: varcaser.ScreamingSnakeCase, To: varcaser.LowerCamelCaseKeepCaps}
css2uc = varcaser.Caser{
From: varcaser.ScreamingSnakeCase, To: varcaser.UpperCamelCaseKeepCaps}
css2ls = varcaser.Caser{
From: varcaser.ScreamingSnakeCase, To: varcaser.LowerSnakeCase}
css2lk = varcaser.Caser{
From: varcaser.ScreamingSnakeCase, To: varcaser.KebabCase}
css2hh = varcaser.Caser{
From: varcaser.ScreamingSnakeCase, To: varcaser.HttpHeaderCase}
clk2lc = varcaser.Caser{From: varcaser.KebabCase, To: varcaser.LowerCamelCaseKeepCaps}
clk2uc = varcaser.Caser{From: varcaser.KebabCase, To: varcaser.UpperCamelCaseKeepCaps}
clk2ls = varcaser.Caser{From: varcaser.KebabCase, To: varcaser.LowerSnakeCase}
clk2ss = varcaser.Caser{
From: varcaser.KebabCase, To: varcaser.ScreamingSnakeCase}
clc2uc = varcaser.Caser{
From: varcaser.LowerCamelCase, To: varcaser.UpperCamelCaseKeepCaps}
clc2ls = varcaser.Caser{
From: varcaser.LowerCamelCase, To: varcaser.LowerSnakeCase}
clc2ss = varcaser.Caser{
From: varcaser.LowerCamelCase, To: varcaser.ScreamingSnakeCase}
cuc2lc = varcaser.Caser{
From: varcaser.UpperCamelCase, To: varcaser.LowerCamelCase}
cuc2ls = varcaser.Caser{
From: varcaser.UpperCamelCase, To: varcaser.LowerSnakeCase}
cuc2ss = varcaser.Caser{
From: varcaser.UpperCamelCase, To: varcaser.ScreamingSnakeCase}
)
var egFuncMap = easygen.FuncMap{
"cls2lc": cls2lc.String,
"cls2uc": cls2uc.String,
"cls2ss": cls2ss.String,
"cls2lk": cls2lk.String,
"cls2hh": cls2hh.String,
"css2lc": css2lc.String,
"css2uc": css2uc.String,
"css2ls": css2ls.String,
"css2lk": css2lk.String,
"css2hh": css2hh.String,
"clk2lc": clk2lc.String,
"clk2uc": clk2uc.String,
"clk2ls": clk2ls.String,
"clk2ss": clk2ss.String,
"clc2uc": clc2uc.String,
"clc2ls": clc2ls.String,
"clc2ss": clc2ss.String,
"cuc2lc": cuc2lc.String,
"cuc2ls": cuc2ls.String,
"cuc2ss": cuc2ss.String,
// Aliases, for backwards-compatibility with earlier (>= v1) versions
"ck2lc": clk2lc.String,
"ck2uc": clk2uc.String,
"ck2ls": clk2ls.String,
"ck2ss": clk2ss.String,
}
////////////////////////////////////////////////////////////////////////////
// Function definitions
// FuncDefs returns the custom definition mapping for this specific package.
func FuncDefs() template.FuncMap {
return template.FuncMap(egFuncMap)
}
// NewTemplate returns a new Template for this specific package.
func NewTemplate() *EgVar {
return &EgVar{&easygen.EgBase{template.New("EgVar")}}
}
easygen-4.1.0/egVar/EgVar_test.go 0000664 0000000 0000000 00000007336 13502324010 0016604 0 ustar 00root root 0000000 0000000 package egVar_test
import (
"fmt"
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egVar"
)
func ExampleEgVar_output() {
// EgVar variable names converting full coverage test
tmpl0 := egVar.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs())
fmt.Println("\n## From lk - KebabCase => CamelCase/SnakeCase")
easygen.Process0(tmpl, os.Stdout,
"{{.Name}}: {{clk2lc .Name}} {{clk2uc .Name}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
"{{.Name}}: {{clk2ls .Name}} {{clk2ss .Name}}\n", "../test/listfunc2")
fmt.Println("\n## From ls/ss - LowerSnakeCase/ScreamingSnakeCase")
easygen.Process0(tmpl, os.Stdout,
"{{clk2ls .Name}} {{clk2ss .Name}} =>\n", "../test/listfunc2")
fmt.Println("### From ls")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ls .Name | cls2lc}} {{clk2ls .Name | cls2uc}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ls .Name | cls2ss}} {{clk2ls .Name | cls2lk}} {{clk2ls .Name | cls2hh}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ls .NameHTTP | cls2lc}} {{clk2ls .NameHTTP | cls2uc}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ls .NameHTTP | cls2ss}} {{clk2ls .NameHTTP | cls2lk}} {{clk2ls .NameHTTP | cls2hh}}\n", "../test/listfunc2")
fmt.Println("### From ss")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ss .Name | css2lc}} {{clk2ss .Name | css2uc}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ss .Name | css2ls}} {{clk2ss .Name | css2lk}} {{clk2ss .Name | css2hh}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ss .NameHTTP | css2lc}} {{clk2ss .NameHTTP | css2uc}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
" {{clk2ss .NameHTTP | css2ls}} {{clk2ss .NameHTTP | css2lk}} {{clk2ss .NameHTTP | css2hh}}\n", "../test/listfunc2")
fmt.Println("\n## From lc/uc - LowerCamelCase/UpperCamelCaseKeepCaps")
easygen.Process0(tmpl, os.Stdout,
"{{clk2lc .Name}} {{clk2uc .Name}} =>\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
"{{clk2lc .Name}}: {{clk2lc .Name | clc2uc}} {{clk2lc .Name | clc2ls}} {{clk2lc .Name | clc2ss}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
"{{clk2uc .Name}}: {{clk2uc .Name | cuc2lc}} {{clk2uc .Name | cuc2ls}} {{clk2uc .Name | cuc2ss}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
"{{.NameMixed}}: {{clc2uc .NameMixed}} {{clc2uc .NameMixed | cuc2lc}} {{clc2ls .NameMixed}} {{clc2ls .NameMixed | cls2lc}}\n", "../test/listfunc2")
easygen.Process0(tmpl, os.Stdout,
"{{.NameMixed}}: {{clc2ls .NameMixed | cls2ss}} {{clc2ls .NameMixed | cls2lk}} {{clc2ls .NameMixed | cls2hh}}\n", "../test/listfunc2")
// Output:
//
// ## From lk - KebabCase => CamelCase/SnakeCase
// some-init-method: someInitMethod SomeInitMethod
// some-init-method: some_init_method SOME_INIT_METHOD
//
// ## From ls/ss - LowerSnakeCase/ScreamingSnakeCase
// some_init_method SOME_INIT_METHOD =>
// ### From ls
// someInitMethod SomeInitMethod
// SOME_INIT_METHOD some-init-method Some-Init-Method
// httpHeaderCase HttpHeaderCase
// HTTP_HEADER_CASE http-header-case HTTP-Header-Case
// ### From ss
// someINITMETHOD SOMEINITMETHOD
// some_init_method some-init-method Some-Init-Method
// httpHEADERCASE HTTPHEADERCASE
// http_header_case http-header-case HTTP-Header-Case
//
// ## From lc/uc - LowerCamelCase/UpperCamelCaseKeepCaps
// someInitMethod SomeInitMethod =>
// someInitMethod: SomeInitMethod some_init_method SOME_INIT_METHOD
// SomeInitMethod: someInitMethod some_init_method SOME_INIT_METHOD
// some_InitMethod: Some_InitMethod some_InitMethod some__init_method someInitMethod
// some_InitMethod: SOME__INIT_METHOD some--init-method Some--Init-Method
}
easygen-4.1.0/egVar/example_test.go 0000664 0000000 0000000 00000001102 13502324010 0017214 0 ustar 00root root 0000000 0000000 package egVar_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egVar"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func Example() {
// Equivalent testing on commandline:
// easygen test/listfunc2
tmpl0 := egVar.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs())
easygen.Process(tmpl, os.Stdout, "../test/listfunc2")
// Output:
// some-init-method 5 5 someInitMethod SomeInitMethod
}
// To show the full code in GoDoc
type dummy struct {
}
easygen-4.1.0/example0_test.go 0000664 0000000 0000000 00000001331 13502324010 0016234 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egVar"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func ExampleProcess0() {
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs())
easygen.Process0(tmpl, os.Stdout,
"{{.Name}}: {{clk2uc .Name}} {{clk2ss .Name}}\n"+
"Cal: {{add 2 3}}, {{multiply 2 3}}, {{subtract 9 2}}, {{divide 24 3}}\n",
"test/var0")
// Output:
// some-init-method: SomeInitMethod SOME_INIT_METHOD
// Cal: 5, 6, 7, 8
}
// To show the full code in GoDoc
type dummy0 struct {
}
easygen-4.1.0/example_execute_test.go 0000664 0000000 0000000 00000002340 13502324010 0017677 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"fmt"
"os"
"strings"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egCal"
"github.com/go-easygen/easygen/egVar"
)
type variable struct {
Name string
}
// for standalone test, change package to `main` and the next func def to,
// func main() {
func ExampleExecute() {
easygen.Opts.Debug = 1
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs()).Funcs(egCal.FuncDefs())
// define driving data of any tye
v0 := variable{"some-init-method"}
// https://godoc.org/github.com/go-easygen/easygen#Execute
// provide full template file name with extension
easygen.Execute(tmpl, os.Stdout, "test/var0.tmpl", v0)
// Demo of using driving data of pure slice/array
v1 := []string{"red", "blue", "white"}
easygen.Execute(tmpl, os.Stdout, "test/list00.tmpl", v1)
// Demo output to string
var b strings.Builder
easygen.Execute(tmpl, &b, "test/list00f.tmpl", v1)
fmt.Print(b.String())
// Output:
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
// The colors are: red, blue, white, .
// The colors are: red, blue, white.
}
// To show the full code in GoDoc
type dummyExecute struct {
}
easygen-4.1.0/example_test.go 0000664 0000000 0000000 00000001746 13502324010 0016166 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egVar"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func ExampleProcess() {
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs())
tmplFileName := "test/var0"
easygen.Process(tmpl, os.Stdout, tmplFileName)
easygen.Process2(tmpl, os.Stdout, tmplFileName, tmplFileName)
// To use Execute(), TemplateFileName has to be exact
m := easygen.ReadDataFile(tmplFileName + ".yaml")
easygen.Execute(tmpl, os.Stdout, tmplFileName+".tmpl", m)
// Output:
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
}
// To show the full code in GoDoc
type dummy struct {
}
easygen-4.1.0/readdatafile_test.go 0000664 0000000 0000000 00000002353 13502324010 0017133 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"os"
"github.com/go-easygen/easygen"
"github.com/go-easygen/easygen/egVar"
)
// for standalone test, change package to `main` and the next func def to,
// func main() {
func ExampleReadDataFile() {
tmplFileName := "test/var0"
tmpl0 := easygen.NewTemplate().Customize()
tmpl := tmpl0.Funcs(easygen.FuncDefs()).Funcs(egVar.FuncDefs())
// To use Execute(), TemplateFileName has to be exact
tmplFileNameFull := tmplFileName + ".tmpl"
m := easygen.ReadDataFile(tmplFileName)
easygen.Execute(tmpl, os.Stdout, tmplFileNameFull, m)
easygen.Opts.Debug = 0
m = easygen.ReadDataFile(tmplFileName + ".yaml")
easygen.Execute(tmpl, os.Stdout, tmplFileNameFull, m)
tmplFileName = "test/list0j"
tmplFileNameFull = tmplFileName + ".tmpl"
m = easygen.ReadDataFile(tmplFileName)
easygen.Execute(tmpl, os.Stdout, tmplFileNameFull, m)
m = easygen.ReadDataFile(tmplFileName + ".json")
easygen.Execute(tmpl, os.Stdout, tmplFileNameFull, m)
// Output:
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
// Input: "some-init-method"
// Output 1: "SomeInitMethod"
// Output 2: "SOME_INIT_METHOD"
// The colors are: red, blue, white, .
// The colors are: red, blue, white, .
}
easygen-4.1.0/t_strings_test.go 0000664 0000000 0000000 00000007733 13502324010 0016551 0 ustar 00root root 0000000 0000000 package easygen_test
import (
"bytes"
"testing"
"github.com/go-easygen/easygen"
)
type testItem struct {
tmplStr, expected string
}
//var tmpl *template.Template
func testStringManipulation(t *testing.T, d []testItem) {
tmpl = easygen.NewTemplate().Funcs(easygen.FuncDefs())
for _, tc := range d {
buf := bytes.NewBufferString("")
easygen.Process0(tmpl, buf, tc.tmplStr, "test/strings")
v := buf.String()
//t.Log(v)
if v != tc.expected {
t.Errorf("'%s' expects '%s', got '%s'", tc.tmplStr, tc.expected, v)
}
}
}
// for standalone test, change package to `main` and the next func def to,
// func main() {
func TestStringManipulation(t *testing.T) {
testData := []testItem{
// == standard strings functions
{
`{{ stringsContains "seafood" "foo" }}`,
"true",
},
{
`{{ stringsContains "seafood" "bar" }}`,
"false",
},
{
`{{ stringsContainsAny "team" "i" }}`,
"false",
},
{
`{{ stringsContainsAny "failure" "u & i" }}`,
"true",
},
{
`{{ stringsCount "cheese" "e" }}`,
"3",
},
{
`{{ stringsEqualFold "Go" "go" }}`,
"true",
},
{
`{{ stringsFields " foo bar baz " }}`,
"[foo bar baz]",
},
{
`{{ stringsIndex "go gopher" "go" }}`,
"0",
},
{
`{{ stringsLastIndex "go gopher" "go" }}`,
"3",
},
{
`ba{{ stringsRepeat "na" 2 }}`,
"banana",
},
{
`{{ stringsReplace "oink oink oink" "k" "ky" 2 }}`,
"oinky oinky oink",
},
{
`{{ stringsReplace "oink oink oink" "oink" "moo" -1 }}`,
"moo moo moo",
},
{
`{{ stringsSplitN "a,b,c" "," 0 }}`,
`[]`,
},
{
`{{ stringsSplitAfter "a,b,c" "," }}`,
`[a, b, c]`,
},
{
`{{ stringsSplitAfterN "a,b,c" "," 2 }}`,
`[a, b,c]`,
},
{
`{{ stringsTitle "her royal highness" }}`,
"Her Royal Highness",
},
{
`{{ stringsToLower "Gopher" }}`,
"gopher",
},
{
`{{ stringsToUpper "Gopher" }}`,
"GOPHER",
},
{
`{{ stringsTrimSpace " \t\n a lone gopher \n\t\r\n" }}`,
"a lone gopher",
},
{
`{{ stringsTrim " !!! Achtung !!! " "! " }}`,
"Achtung",
},
{
`{{ stringsTrimPrefix "Goodbye,, world!" "Goodbye," }}`,
", world!",
},
{
`{{ stringsTrimSuffix "Hello, goodbye, etc!" "goodbye, etc!" }}`,
"Hello, ",
},
// aliases
{
`The {{if eq .StrTest "these rights belong to those people"}}eq says Yea{{else}}eq says Nay{{end}} but {{if eqf .StrTest "these rights belong to those people"}}eqf says Yea{{else}}eqf says Nay{{end}}.`,
"The eq says Nay but eqf says Yea.",
},
// == standard regexp functions
{
`{{ regexpFindString "peach punch" "p([a-z]+)ch" }}`,
"peach",
},
{
`{{ regexpFindAllString "peach punch" "p([a-z]+)ch" -1 }}`,
"[peach punch]",
},
{
`{{ regexpFindAllString "peach punch" "p([a-z]+)ch" 1 }}`,
"[peach]",
},
{
`{{ regexpFindStringIndex "peach punch" "p([a-z]+)ch" }}`,
"[0 5]",
},
{
`{{ regexpFindStringSubmatch "peach punch" "p([a-z]+)ch" }}`,
"[peach ea]",
},
{
`{{ regexpFindStringSubmatchIndex "peach punch" "p([a-z]+)ch" }}`,
"[0 5 1 3]",
},
//
{
`{{ regexpMatchString "HTTPS://site/" "(?i)^http" }}`,
"true",
},
//
{
`{{ regexpReplaceAllLiteralString "html HTML Html aa uml bb Uml" "(?i)html|uml" "XML" }}`,
"XML XML XML aa XML bb XML",
},
{
`{{ regexpReplaceAllString .StrTest "(?i)th[eo]se" "the" }}`,
"the rights belong to the people",
},
{
`{{ regexpReplaceAllString "This and these are for THOSE people" "(?i)(this|th[eo]se)" "${1}" }}`,
"This and these are for THOSE people",
},
// {
// `{{ regexpReplaceAllStringFunc "a peach" "p([a-z]+)ch" stringsToUpper }}`,
// "a PEACH",
// },
// == my added strings functions
{
`{{ coalesce "a" }}`,
"a",
},
{
`{{ coalesce "" "b" }}`,
"b",
},
{
`{{ coalesce "" "" "c" }}`,
"c",
},
{
`{{ coalesce "" "" "" "" }}`,
"",
},
{
`{{ coalesce "" }}`,
"",
},
}
testStringManipulation(t, testData)
}
/*
{
`{{ }}`,
"",
},
*/
easygen-4.1.0/template.go 0000664 0000000 0000000 00000011142 13502324010 0015276 0 ustar 00root root 0000000 0000000 ////////////////////////////////////////////////////////////////////////////
// Package: easygen
// Purpose: Easy to use universal code/text generator
// Authors: Tong Sun (c) 2015-17, All rights reserved
////////////////////////////////////////////////////////////////////////////
package easygen
import (
"io"
"os"
"strings"
"text/template"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
// The Template defines the common ground for both text and html Template
type Template interface {
Execute(wr io.Writer, data interface{}) error
ExecuteTemplate(wr io.Writer, name string, data interface{}) error
Parse(text string) (*template.Template, error)
ParseFiles(filenames ...string) (*template.Template, error)
Name() string
}
// EgBase -- EasyGen Template Base
type EgBase struct {
*template.Template
}
// The FuncMap defined in easygen will shield the dependency of either
// text or html template, giving an implementation agnostic abstraction
// that will works for both cases.
type FuncMap map[string]interface{}
var egFuncMap = FuncMap{
// == standard strings function definitions
"stringsCompare": strings.Compare,
"stringsContains": strings.Contains,
"stringsContainsAny": strings.ContainsAny,
"stringsContainsRune": strings.ContainsRune,
"stringsCount": strings.Count,
"stringsEqualFold": strings.EqualFold,
"stringsFields": strings.Fields,
"stringsFieldsFunc": strings.FieldsFunc,
"stringsHasPrefix": strings.HasPrefix,
"stringsHasSuffix": strings.HasSuffix,
"stringsIndex": strings.Index,
"stringsIndexAny": strings.IndexAny,
"stringsIndexByte": strings.IndexByte,
"stringsIndexFunc": strings.IndexFunc,
"stringsIndexRune": strings.IndexRune,
"stringsJoin": strings.Join,
"stringsLastIndex": strings.LastIndex,
"stringsLastIndexAny": strings.LastIndexAny,
"stringsLastIndexByte": strings.LastIndexByte,
"stringsLastIndexFunc": strings.LastIndexFunc,
"stringsMap": strings.Map,
"stringsRepeat": strings.Repeat,
"stringsReplace": strings.Replace,
"stringsSplit": strings.Split,
"stringsSplitAfter": strings.SplitAfter,
"stringsSplitAfterN": strings.SplitAfterN,
"stringsSplitN": strings.SplitN,
"stringsTitle": strings.Title,
"stringsToLower": strings.ToLower,
"stringsToLowerSpecial": strings.ToLowerSpecial,
"stringsToTitle": strings.ToTitle,
"stringsToTitleSpecial": strings.ToTitleSpecial,
"stringsToUpper": strings.ToUpper,
"stringsToUpperSpecial": strings.ToUpperSpecial,
"stringsTrim": strings.Trim,
"stringsTrimFunc": strings.TrimFunc,
"stringsTrimLeft": strings.TrimLeft,
"stringsTrimLeftFunc": strings.TrimLeftFunc,
"stringsTrimPrefix": strings.TrimPrefix,
"stringsTrimRight": strings.TrimRight,
"stringsTrimRightFunc": strings.TrimRightFunc,
"stringsTrimSpace": strings.TrimSpace,
"stringsTrimSuffix": strings.TrimSuffix,
// aliases
"eqf": strings.EqualFold,
"split": strings.Fields,
// == standard regexp function definitions
"regexpFindAllString": regexpFindAllString,
"regexpFindAllStringIndex": regexpFindAllStringIndex,
"regexpFindAllStringSubmatch": regexpFindAllStringSubmatch,
"regexpFindAllStringSubmatchIndex": regexpFindAllStringSubmatchIndex,
"regexpFindString": regexpFindString,
"regexpFindStringIndex": regexpFindStringIndex,
"regexpFindStringSubmatch": regexpFindStringSubmatch,
"regexpFindStringSubmatchIndex": regexpFindStringSubmatchIndex,
"regexpMatchString": regexpMatchString,
"regexpReplaceAllLiteralString": regexpReplaceAllLiteralString,
"regexpReplaceAllString": regexpReplaceAllString,
"regexpReplaceAllStringFunc": regexpReplaceAllStringFunc,
"regexpSplit": regexpSplit,
// == my added functions
"ENV": os.Getenv,
"coalesce": coalesce,
"quote4shell": quote4shell,
"minus1": minus1,
"date": date,
"timestamp": timestamp,
}
////////////////////////////////////////////////////////////////////////////
// Function definitions
// FuncDefs returns the custom definition mapping for this specific package.
func FuncDefs() template.FuncMap {
return template.FuncMap(egFuncMap)
}
// NewTemplate returns a new Template for this specific package.
func NewTemplate() *EgBase {
return &EgBase{template.New("EgBase")}
}
// Customize allows customization for this specific package.
func (t *EgBase) Customize() *EgBase {
return t
}
easygen-4.1.0/test/ 0000775 0000000 0000000 00000000000 13502324010 0014114 5 ustar 00root root 0000000 0000000 easygen-4.1.0/test/.gitignore 0000664 0000000 0000000 00000000110 13502324010 0016074 0 ustar 00root root 0000000 0000000 # Generated output, to be compared with the .ref reference output
*.got
easygen-4.1.0/test/commandlineCLI-024.ref 0000664 0000000 0000000 00000007061 13502324010 0017737 0 ustar 00root root 0000000 0000000 // -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: gogo
// Purpose: Golang package manager
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var app = &cli.Register(&cli.Command{
Name: "gogo",
Desc: "Golang package manager",
Text: " gogo is a new golang package manager\n very very good",
Argv: func() interface{} { return new(gogoT) },
Fn: gogo,
NumArg: cli.ExactN(1),
})
type gogoT struct {
cli.Helper
Version bool `cli:"v,version" usage:"display version"`
List bool `cli:"l,list" usage:"list all sub commands or not"`
}
func gogo(ctx *cli.Context) error {
argv := ctx.Argv().(*gogoT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[gogo]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: build
// Purpose: Build golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var buildCmd = app.Register(&cli.Command{
Name: "build",
Desc: "Build golang application",
Text: "Usage:\n gogo build [Options] Arch(i386|amd64)",
Argv: func() interface{} { return new(buildT) },
Fn: build,
NumArg: cli.ExactN(1),
CanSubRoute: true,
})
type buildT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
func build(ctx *cli.Context) error {
argv := ctx.Argv().(*buildT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[build]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: install
// Purpose: Install golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var installCmd = app.Register(&cli.Command{
Name: "install",
Desc: "Install golang application",
Text: "Usage:\n gogo install [Options] package [package...]",
Argv: func() interface{} { return new(installT) },
Fn: install,
NumArg: cli.AtLeast(1),
CanSubRoute: true,
})
type installT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
func install(ctx *cli.Context) error {
argv := ctx.Argv().(*installT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[install]: %v\n", ctx.Args())
return nil
}
////////////////////////////////////////////////////////////////////////////
// Program: publish
// Purpose: Publish golang application
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
var publishCmd = app.Register(&cli.Command{
Name: "publish",
Desc: "Publish golang application",
Argv: func() interface{} { return new(publishT) },
Fn: publish,
})
type publishT struct {
cli.Helper
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
List bool `cli:"l,list" usage:"list all sub commands"`
}
func publish(ctx *cli.Context) error {
argv := ctx.Argv().(*publishT)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[publish]: %v\n", ctx.Args())
return nil
}
easygen-4.1.0/test/commandlineCLI-024.tmpl 0000664 0000000 0000000 00000003367 13502324010 0020144 0 ustar 00root root 0000000 0000000 // -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: {{.Name}}
// Purpose: {{.Desc}}
////////////////////////////////////////////////////////////////////////////
package {{$.PackageName}}
import (
"github.com/mkideal/cli"
)
var {{.Var}} = &cli.Register(&cli.Command{
Name: "{{.Name}}",
Desc: "{{.Desc}}",
{{if .Text}} Text: "{{.Text}}",
{{end}} Argv: func() interface{} { return new({{.Name}}T) },
Fn: {{.Name}},
{{if .NumArg}}
NumArg: {{.NumArg}},
{{end}}})
type {{.Name}}T struct {
cli.Helper{{range .Options}}
{{.Name}} {{.Type}} `cli:"{{.Flag}}" usage:"{{.Usage}}"{{if .Value}} dft:{{.Value}}{{end}}`{{end}}
}
func {{.Name}}(ctx *cli.Context) error {
argv := ctx.Argv().(*{{.Name}}T)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[{{.Name}}]: %v\n", ctx.Args())
return nil
}
{{range .Command}}
////////////////////////////////////////////////////////////////////////////
// Program: {{.Name}}
// Purpose: {{.Desc}}
////////////////////////////////////////////////////////////////////////////
package {{$.PackageName}}
import (
"github.com/mkideal/cli"
)
var {{.Name}}Cmd = {{$.Var}}.Register(&cli.Command{
Name: "{{.Name}}",
Desc: "{{.Desc}}",
{{if .Text}} Text: "{{.Text}}",
{{end}} Argv: func() interface{} { return new({{.Name}}T) },
Fn: {{.Name}},
{{if .NumArg}}
NumArg: {{.NumArg}},
CanSubRoute: true,
{{end}}})
type {{.Name}}T struct {
cli.Helper{{range .Options}}
{{.Name}} {{.Type}} `cli:"{{.Flag}}" usage:"{{.Usage}}"{{if .Value}} dft:{{.Value}}{{end}}`{{end}}
}
func {{.Name}}(ctx *cli.Context) error {
argv := ctx.Argv().(*{{.Name}}T)
ctx.String("%s: %v", ctx.Path(), jsonIndent(argv))
ctx.String("[{{.Name}}]: %v\n", ctx.Args())
return nil
}
{{end}}
easygen-4.1.0/test/commandlineCLI-024.yaml 0000664 0000000 0000000 00000005126 13502324010 0020125 0 ustar 00root root 0000000 0000000 # program name, name for the executable
ProgramName: gogo
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: main
Name: gogo
Var: app
Desc: "Golang package manager"
Text: ' gogo is a new golang package manager\n very very good'
NumArg: cli.ExactN(1)
Options:
- Name: Version
Type: bool
Flag: v,version
Usage: display version
- Name: List
Type: bool
Flag: l,list
Usage: list all sub commands or not
Command:
- Name: build
Desc: "Build golang application"
Text: 'Usage:\n gogo build [Options] Arch(i386|amd64)'
NumArg: cli.ExactN(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: install
Desc: "Install golang application"
Text: 'Usage:\n gogo install [Options] package [package...]'
NumArg: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: publish
Desc: "Publish golang application"
Options:
- Name: Dir
Type: string
Flag: dir
Value: '"./"'
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: '".go,.c,.s"'
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: List
Type: bool
Flag: l,list
Usage: "list all sub commands"
easygen-4.1.0/test/commandlineCLI-027.ref 0000664 0000000 0000000 00000007212 13502324010 0017740 0 ustar 00root root 0000000 0000000 // -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
////////////////////////////////////////////////////////////////////////////
// redo
type rootT struct {
cli.Helper
Self *rootT `cli:"c,config" usage:"config file" json:"-" parser:"jsonfile" dft:"redo.json"`
Host string `cli:"H,host" usage:"host address" dft:"$HOST"`
Port int `cli:"p,port" usage:"listening port" dft:"80"`
}
var root = &cli.Command{
Name: "redo",
Desc: "global option redo",
Text: " redo global option via automatic code-gen",
Global: true,
Argv: func() interface{} { t := new(rootT); t.Self = t; return t },
Fn: redo,
NumArg: cli.ExactN(1),
}
// func main() {
// cli.SetUsageStyle(cli.ManualStyle) // up-down, for left-right, use NormalStyle
// //NOTE: You can set any writer implements io.Writer
// // default writer is os.Stdout
// if err := cli.Root(root,
// cli.Tree(buildDef),
// cli.Tree(installDef),
// cli.Tree(publishDef)).Run(os.Args[1:]); err != nil {
// fmt.Fprintln(os.Stderr, err)
// }
// fmt.Println("")
// }
// func redo(ctx *cli.Context) error {
// ctx.JSON(ctx.RootArgv())
// ctx.JSON(ctx.Argv())
// fmt.Println()
// return nil
// }
////////////////////////////////////////////////////////////////////////////
// build
// func buildCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*buildT)
// fmt.Printf("[build]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type buildT struct {
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
var buildDef = &cli.Command{
Name: "build",
Desc: "Build the network application",
Text: "Usage:\n redo build [Options] Arch(i386|amd64)",
Argv: func() interface{} { return new(buildT) },
Fn: buildCLI,
NumArg: cli.ExactN(1),
CanSubRoute: true,
}
////////////////////////////////////////////////////////////////////////////
// install
// func installCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*installT)
// fmt.Printf("[install]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type installT struct {
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
var installDef = &cli.Command{
Name: "install",
Desc: "Install the network application",
Text: "Usage:\n redo install [Options] package [package...]",
Argv: func() interface{} { return new(installT) },
Fn: installCLI,
NumArg: cli.AtLeast(1),
CanSubRoute: true,
}
////////////////////////////////////////////////////////////////////////////
// publish
// func publishCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*publishT)
// fmt.Printf("[publish]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type publishT struct {
Dir string `cli:"*d,dir" usage:"publish dir"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
List bool `cli:"l,list" usage:"list all sub commands"`
}
var publishDef = &cli.Command{
Name: "publish",
Desc: "Publish the network application",
Argv: func() interface{} { return new(publishT) },
Fn: publishCLI,
NumOption: cli.AtLeast(1),
}
easygen-4.1.0/test/commandlineCLI-027.tmpl 0000664 0000000 0000000 00000005157 13502324010 0020146 0 ustar 00root root 0000000 0000000 // -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: {{.Name}}
// Purpose: {{.Desc}}
////////////////////////////////////////////////////////////////////////////
package {{$.PackageName}}
import (
"github.com/mkideal/cli"
)
////////////////////////////////////////////////////////////////////////////
// {{.Name}}
type rootT struct {
cli.Helper{{range .Options}}
{{.Name}} {{.Type}} `cli:"{{.Flag}}" usage:"{{.Usage}}"{{if eq .Name "Self" }} json:"-" parser:"jsonfile"{{end}}{{if .Value}} dft:"{{.Value}}"{{end}}`{{end}}
}
var root = &cli.Command{
Name: "{{.Name}}",
Desc: "{{.Desc}}",
{{if .Text}} Text: "{{.Text}}",
{{end}}{{if .Global}} Global: {{.Global}},
{{end}}{{if .Self}} Argv: func() interface{} { t := new(rootT); t.Self = t; return t },
{{else}} Argv: func() interface{} { return new(rootT) },
{{end}} Fn: {{.Name}},
{{if .NumOption}}
NumOption: {{.NumOption}},
{{end}}{{if .NumArg}}
NumArg: {{.NumArg}},
{{end}}{{if .CanSubRoute}}
CanSubRoute: {{.CanSubRoute}},
{{end}}}
// func main() {
// cli.SetUsageStyle(cli.ManualStyle) // up-down, for left-right, use NormalStyle
// //NOTE: You can set any writer implements io.Writer
// // default writer is os.Stdout
// if err := cli.Root(root,{{range $i, $cmd := .Command}}
// cli.Tree({{$cmd.Name}}Def){{if lt $i ($.Command | len | minus1)}},{{end}}{{end}}).Run(os.Args[1:]); err != nil {
// fmt.Fprintln(os.Stderr, err)
// }
// fmt.Println("")
// }
// func {{.Name}}(ctx *cli.Context) error {
// ctx.JSON(ctx.RootArgv())
// ctx.JSON(ctx.Argv())
// fmt.Println()
// return nil
// }
{{range .Command}}
////////////////////////////////////////////////////////////////////////////
// {{.Name}}
// func {{.Name}}CLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*{{.Name}}T)
// fmt.Printf("[{{.Name}}]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type {{.Name}}T struct {
{{range .Options}}
{{.Name}} {{.Type}} `cli:"{{.Flag}}" usage:"{{.Usage}}"{{if eq .Name "Self" }} json:"-" parser:"jsonfile"{{end}}{{if .Value}} dft:"{{.Value}}"{{end}}`{{end}}
}
var {{.Name}}Def = &cli.Command{
Name: "{{.Name}}",
Desc: "{{.Desc}}",
{{if .Text}} Text: "{{.Text}}",
{{end}}{{if .Self}} Argv: func() interface{} { t := new({{.Name}}T); t.Self = t; return t },
{{else}} Argv: func() interface{} { return new({{.Name}}T) },
{{end}} Fn: {{.Name}}CLI,
{{if .NumOption}}
NumOption: {{.NumOption}},
{{end}}{{if .NumArg}}
NumArg: {{.NumArg}},
CanSubRoute: true,
{{end}}{{if .CanSubRoute}}
CanSubRoute: {{.CanSubRoute}},
{{end}}}
{{end}}
easygen-4.1.0/test/commandlineCLI-027.yaml 0000664 0000000 0000000 00000005312 13502324010 0020125 0 ustar 00root root 0000000 0000000 # program name, name for the executable
ProgramName: redo
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: main
Name: redo
Desc: "global option redo"
Text: ' redo global option via automatic code-gen'
Global: true
NumArg: cli.ExactN(1)
Self: true
Options:
- Name: Self
Type: '*rootT'
Flag: c,config
Usage: config file
Value: redo.json
- Name: Host
Type: string
Flag: H,host
Usage: host address
Value: "$HOST"
- Name: Port
Type: int
Flag: p,port
Usage: listening port
Value: 80
Command:
- Name: build
Desc: "Build the network application"
Text: 'Usage:\n redo build [Options] Arch(i386|amd64)'
NumArg: cli.ExactN(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: "./"
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: install
Desc: "Install the network application"
Text: 'Usage:\n redo install [Options] package [package...]'
NumArg: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: "./"
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: publish
Desc: "Publish the network application"
NumOption: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: '*d,dir'
Usage: publish dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: List
Type: bool
Flag: l,list
Usage: "list all sub commands"
easygen-4.1.0/test/commandlineCLI-027s.ref 0000664 0000000 0000000 00000007214 13502324010 0020125 0 ustar 00root root 0000000 0000000 // -*- go -*-
////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
////////////////////////////////////////////////////////////////////////////
package main
import (
"github.com/mkideal/cli"
)
////////////////////////////////////////////////////////////////////////////
// redo
type rootT struct {
cli.Helper
Host string `cli:"H,host" usage:"host address" dft:"$HOST"`
Port int `cli:"p,port" usage:"listening port" dft:"80"`
}
var root = &cli.Command{
Name: "redo",
Desc: "global option redo",
Text: " redo global option via automatic code-gen",
Global: true,
Argv: func() interface{} { return new(rootT) },
Fn: redo,
NumArg: cli.ExactN(1),
}
// func main() {
// cli.SetUsageStyle(cli.ManualStyle) // up-down, for left-right, use NormalStyle
// //NOTE: You can set any writer implements io.Writer
// // default writer is os.Stdout
// if err := cli.Root(root,
// cli.Tree(buildDef),
// cli.Tree(installDef),
// cli.Tree(publishDef)).Run(os.Args[1:]); err != nil {
// fmt.Fprintln(os.Stderr, err)
// }
// fmt.Println("")
// }
// func redo(ctx *cli.Context) error {
// ctx.JSON(ctx.RootArgv())
// ctx.JSON(ctx.Argv())
// fmt.Println()
// return nil
// }
////////////////////////////////////////////////////////////////////////////
// build
// func buildCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*buildT)
// fmt.Printf("[build]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type buildT struct {
Self *buildT `cli:"c,config" usage:"config file" json:"-" parser:"jsonfile" dft:"build.json"`
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
var buildDef = &cli.Command{
Name: "build",
Desc: "Build the network application",
Text: "Usage:\n redo build [Options] Arch(i386|amd64)",
Argv: func() interface{} { t := new(buildT); t.Self = t; return t },
Fn: buildCLI,
NumArg: cli.ExactN(1),
CanSubRoute: true,
}
////////////////////////////////////////////////////////////////////////////
// install
// func installCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*installT)
// fmt.Printf("[install]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type installT struct {
Dir string `cli:"dir" usage:"source code root dir" dft:"./"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
}
var installDef = &cli.Command{
Name: "install",
Desc: "Install the network application",
Text: "Usage:\n redo install [Options] package [package...]",
Argv: func() interface{} { return new(installT) },
Fn: installCLI,
NumArg: cli.AtLeast(1),
CanSubRoute: true,
}
////////////////////////////////////////////////////////////////////////////
// publish
// func publishCLI(ctx *cli.Context) error {
// rootArgv := ctx.RootArgv().(*rootT)
// argv := ctx.Argv().(*publishT)
// fmt.Printf("[publish]:\n %+v\n %+v\n %v\n", rootArgv, argv, ctx.Args())
// return nil
// }
type publishT struct {
Dir string `cli:"*d,dir" usage:"publish dir"`
Suffix string `cli:"suffix" usage:"source file suffix" dft:".go,.c,.s"`
Out string `cli:"o,out" usage:"output filename"`
List bool `cli:"l,list" usage:"list all sub commands"`
}
var publishDef = &cli.Command{
Name: "publish",
Desc: "Publish the network application",
Argv: func() interface{} { return new(publishT) },
Fn: publishCLI,
NumOption: cli.AtLeast(1),
}
easygen-4.1.0/test/commandlineCLI-027s.yaml 0000664 0000000 0000000 00000005344 13502324010 0020315 0 ustar 00root root 0000000 0000000 # program name, name for the executable
ProgramName: redo
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: main
Name: redo
Desc: "global option redo"
Text: ' redo global option via automatic code-gen'
Global: true
NumArg: cli.ExactN(1)
Options:
- Name: Host
Type: string
Flag: H,host
Usage: host address
Value: "$HOST"
- Name: Port
Type: int
Flag: p,port
Usage: listening port
Value: 80
Command:
- Name: build
Desc: "Build the network application"
Text: 'Usage:\n redo build [Options] Arch(i386|amd64)'
NumArg: cli.ExactN(1)
Self: true
Options:
- Name: Self
Type: '*buildT'
Flag: c,config
Usage: config file
Value: build.json
- Name: Dir
Type: string
Flag: dir
Value: "./"
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: install
Desc: "Install the network application"
Text: 'Usage:\n redo install [Options] package [package...]'
NumArg: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: dir
Value: "./"
Usage: source code root dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: publish
Desc: "Publish the network application"
NumOption: cli.AtLeast(1)
Options:
- Name: Dir
Type: string
Flag: '*d,dir'
Usage: publish dir
- Name: Suffix
Type: string
Flag: suffix
Value: ".go,.c,.s"
Usage: "source file suffix"
- Name: Out
Type: string
Flag: o,out
Usage: "output filename"
- Name: List
Type: bool
Flag: l,list
Usage: "list all sub commands"
easygen-4.1.0/test/commandlineCV.ref 0000664 0000000 0000000 00000001336 13502324010 0017334 0 ustar 00root root 0000000 0000000
flags.Bool("debug", false, "Turn on debugging.")
viper.BindPFlag("debug", flags.Lookup("debug"))
flags.String("addr", "localhost:5002", "Address of the service.")
viper.BindPFlag("addr", flags.Lookup("addr"))
flags.String("smtp-addr", "localhost:25", "Address of the SMTP server.")
viper.BindPFlag("smtp-addr", flags.Lookup("smtp-addr"))
flags.String("smtp-user", "", "User for the SMTP server.")
viper.BindPFlag("smtp-user", flags.Lookup("smtp-user"))
flags.String("smtp-password", "", "Password for the SMTP server.")
viper.BindPFlag("smtp-password", flags.Lookup("smtp-password"))
flags.String("email-from", "noreply@abc.com", "The from email address.")
viper.BindPFlag("email-from", flags.Lookup("email-from"))
easygen-4.1.0/test/commandlineCV.tmpl 0000664 0000000 0000000 00000000214 13502324010 0017526 0 ustar 00root root 0000000 0000000 {{range .Options}}
flags.{{.Type}}("{{.Name}}", {{.Value}}, "{{.Usage}}")
viper.BindPFlag("{{.Name}}", flags.Lookup("{{.Name}}"))
{{end}}
easygen-4.1.0/test/commandlineCV.yaml 0000664 0000000 0000000 00000001111 13502324010 0017511 0 ustar 00root root 0000000 0000000 Options:
- Name: debug
Type: Bool
Value: false
Usage: Turn on debugging.
- Name: addr
Type: String
Value: '"localhost:5002"'
Usage: Address of the service.
- Name: smtp-addr
Type: String
Value: '"localhost:25"'
Usage: Address of the SMTP server.
- Name: smtp-user
Type: String
Value: '""'
Usage: User for the SMTP server.
- Name: smtp-password
Type: String
Value: '""'
Usage: Password for the SMTP server.
- Name: email-from
Type: String
Value: '"noreply@abc.com"'
Usage: The from email address.
easygen-4.1.0/test/commandlineCVFull.ref 0000664 0000000 0000000 00000003100 13502324010 0020146 0 ustar 00root root 0000000 0000000 func init() {
viper.SetEnvPrefix("DISPATCH")
viper.AutomaticEnv()
/*
When AutomaticEnv called, Viper will check for an environment variable any
time a viper.Get request is made. It will apply the following rules. It
will check for a environment variable with a name matching the key
uppercased and prefixed with the EnvPrefix if set.
*/
flags := mainCmd.Flags()
flags.Bool("Debug", false, "Turn on debugging.")
viper.BindPFlag("Debug", flags.Lookup("Debug"))
flags.String("addr", "localhost:5002", "Address of the service.")
viper.BindPFlag("addr", flags.Lookup("addr"))
flags.String("smtp-addr", "localhost:25", "Address of the SMTP server.")
viper.BindPFlag("smtp-addr", flags.Lookup("smtp-addr"))
flags.String("smtp-user", "", "User for the SMTP server.")
viper.BindPFlag("smtp-user", flags.Lookup("smtp-user"))
flags.String("smtp-password", "", "Password for the SMTP server.")
viper.BindPFlag("smtp-password", flags.Lookup("smtp-password"))
flags.String("email-from", "noreply@abc.com", "The from email address.")
viper.BindPFlag("email-from", flags.Lookup("email-from"))
// Viper supports reading from yaml, toml and/or json files. Viper can
// search multiple paths. Paths will be searched in the order they are
// provided. Searches stopped once Config File found.
viper.SetConfigName("CommandLineCV") // name of config file (without extension)
viper.AddConfigPath("/tmp")
viper.AddConfigPath(".")
err := viper.ReadInConfig()
if err != nil {
println("No config file found. Using built-in defaults.")
}
}
easygen-4.1.0/test/commandlineCVFull.tmpl 0000664 0000000 0000000 00000001763 13502324010 0020363 0 ustar 00root root 0000000 0000000 func init() {
viper.SetEnvPrefix("{{.CmdPrefix}}")
viper.AutomaticEnv()
/*
When AutomaticEnv called, Viper will check for an environment variable any
time a viper.Get request is made. It will apply the following rules. It
will check for a environment variable with a name matching the key
uppercased and prefixed with the EnvPrefix if set.
*/
flags := {{.CmdMain}}.Flags()
{{range .Options}}
flags.{{.Type}}("{{.Name}}", {{.Value}}, "{{.Usage}}")
viper.BindPFlag("{{.Name}}", flags.Lookup("{{.Name}}"))
{{end}}
// Viper supports reading from yaml, toml and/or json files. Viper can
// search multiple paths. Paths will be searched in the order they are
// provided. Searches stopped once Config File found.
viper.SetConfigName("{{.ConfigName}}") // name of config file (without extension)
{{range .ConfigPath}}
viper.AddConfigPath("{{.}}"){{end}}
err := viper.ReadInConfig()
if err != nil {
println("No config file found. Using built-in defaults.")
}
}
easygen-4.1.0/test/commandlineCVFull.yaml 0000664 0000000 0000000 00000001246 13502324010 0020345 0 ustar 00root root 0000000 0000000 CmdMain: mainCmd
CmdPrefix: DISPATCH
Options:
- Name: Debug
Type: Bool
Value: false
Usage: Turn on debugging.
- Name: addr
Type: String
Value: '"localhost:5002"'
Usage: Address of the service.
- Name: smtp-addr
Type: String
Value: '"localhost:25"'
Usage: Address of the SMTP server.
- Name: smtp-user
Type: String
Value: '""'
Usage: User for the SMTP server.
- Name: smtp-password
Type: String
Value: '""'
Usage: Password for the SMTP server.
- Name: email-from
Type: String
Value: '"noreply@abc.com"'
Usage: The from email address.
ConfigName: CommandLineCV
ConfigPath:
- /tmp
- .
easygen-4.1.0/test/commandlineFlag 0000664 0000000 0000000 00000000167 13502324010 0017123 0 ustar 00root root 0000000 0000000 something invalid for .yaml file, to verify that it is preferable to pick the .yaml file with the full extension first
easygen-4.1.0/test/commandlineFlag.ref 0000664 0000000 0000000 00000006075 13502324010 0017702 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package easygenapi
import (
"flag"
"fmt"
"os"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
const progname = "easygen" // os.Args[0]
// The Options struct defines the structure to hold the commandline values
type Options struct {
HTML bool // treat the template file as html instead of text
TemplateStr string // template string (in text)
TemplateFile string // .tmpl (comma-separated) template file `name(s)` (default: same as .yaml file)
ExtYaml string // `extension` of yaml file
ExtTmpl string // `extension` of template file
StrFrom string // replace from, the from string used for the replace function
StrTo string // replace to, the to string used for the replace function
Debug int // debugging `level`
}
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
// Opts holds the actual values from the command line parameters
var Opts Options
////////////////////////////////////////////////////////////////////////////
// Commandline definitions
func init() {
// set default values for command line parameters
flag.BoolVar(&Opts.HTML, "html", false,
"treat the template file as html instead of text")
flag.StringVar(&Opts.TemplateStr, "ts", "",
"template string (in text)")
flag.StringVar(&Opts.TemplateFile, "tf", "",
".tmpl (comma-separated) template file `name(s)` (default: same as .yaml file)")
flag.StringVar(&Opts.ExtYaml, "ey", ".yaml",
"`extension` of yaml file")
flag.StringVar(&Opts.ExtTmpl, "et", ".tmpl",
"`extension` of template file")
flag.StringVar(&Opts.StrFrom, "rf", "",
"replace from, the from string used for the replace function")
flag.StringVar(&Opts.StrTo, "rt", "",
"replace to, the to string used for the replace function")
flag.IntVar(&Opts.Debug, "debug", 0,
"debugging `level`")
// Now override those default values from environment variables
if len(Opts.TemplateStr) == 0 ||
len(os.Getenv("EASYGEN_TS")) != 0 {
Opts.TemplateStr = os.Getenv("EASYGEN_TS")
}
if len(Opts.TemplateFile) == 0 ||
len(os.Getenv("EASYGEN_TF")) != 0 {
Opts.TemplateFile = os.Getenv("EASYGEN_TF")
}
if len(Opts.ExtYaml) == 0 ||
len(os.Getenv("EASYGEN_EY")) != 0 {
Opts.ExtYaml = os.Getenv("EASYGEN_EY")
}
if len(Opts.ExtTmpl) == 0 ||
len(os.Getenv("EASYGEN_ET")) != 0 {
Opts.ExtTmpl = os.Getenv("EASYGEN_ET")
}
if len(Opts.StrFrom) == 0 ||
len(os.Getenv("EASYGEN_RF")) != 0 {
Opts.StrFrom = os.Getenv("EASYGEN_RF")
}
if len(Opts.StrTo) == 0 ||
len(os.Getenv("EASYGEN_RT")) != 0 {
Opts.StrTo = os.Getenv("EASYGEN_RT")
}
}
// Usage function shows help on commandline usage
func Usage() {
fmt.Fprintf(os.Stderr,
"\nUsage:\n %s [flags] YamlFileName [YamlFileName...]\n\nFlags:\n\n",
progname)
flag.PrintDefaults()
fmt.Fprintf(os.Stderr,
"\nYamlFileName(s): The name for the .yaml data and .tmpl template file\n\tOnly the name part, without extension. Can include the path as well.\n")
os.Exit(0)
}
easygen-4.1.0/test/commandlineFlag.tmpl 0000664 0000000 0000000 00000003727 13502324010 0020103 0 ustar 00root root 0000000 0000000 // !!! !!!
// WARNING: Code automatically generated. Editing discouraged.
// !!! !!!
package {{.PackageName}}
import (
"flag"
"fmt"
"os"
)
////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions
const progname = "{{.ProgramName}}" // os.Args[0]
// The {{.StructName}} struct defines the structure to hold the commandline values
type {{.StructName}} struct { {{range .Options}}{{if ne .Name "SEPARATOR" }}
{{.Name}} {{.Type}} // {{.Usage}}{{end}}{{end}}
}
////////////////////////////////////////////////////////////////////////////
// Global variables definitions
// {{.StructVar}} holds the actual values from the command line parameters
var {{.StructVar}} {{.StructName}}
////////////////////////////////////////////////////////////////////////////
// Commandline definitions
func init() {
// set default values for command line parameters{{range .Options}}{{if eq .Name "SEPARATOR" }}
{{else}}
flag.{{clk2uc .Type}}Var(&{{$.StructVar}}.{{.Name}}, "{{.Flag}}", {{.Value}},
"{{.Usage}}"){{end}}{{end}}
// Now override those default values from environment variables{{range .Options}}{{if eq .Name "SEPARATOR" }}
{{else}}{{if eq .Type "string" }}{{$envVar := printf "%s_%s" (clk2ss $.ProgramName) (clk2ss .Flag)}}
if len({{$.StructVar}}.{{.Name}}) == 0 ||
len(os.Getenv("{{$envVar}}")) != 0 {
{{$.StructVar}}.{{.Name}} = os.Getenv("{{$envVar}}")
}{{end}}{{end}}{{end}}
}
{{if eqf .UsageSummary "True" }}
const USAGE_SUMMARY = "{{range .Options}}{{if eq .Name "SEPARATOR" }}\n{{else}}{{$envVar := printf "%s_%s" (clk2ss $.ProgramName) (clk2ss .Flag)}} -{{.Flag}}\t{{.Usage}} ({{$envVar}})\n{{end}}{{end}}\nDetails:\n\n"
{{end}}
// Usage function shows help on commandline usage
func Usage() {
fmt.Fprintf(os.Stderr,
"{{.UsageLead}}",
progname){{if eq .UsageSummary "TRUE" }}
fmt.Fprintf(os.Stderr, USAGE_SUMMARY){{end}}
flag.PrintDefaults()
fmt.Fprintf(os.Stderr,
"{{.UsageEnd}}")
os.Exit(0)
}
easygen-4.1.0/test/commandlineFlag.yaml 0000664 0000000 0000000 00000004344 13502324010 0020065 0 ustar 00root root 0000000 0000000 # program name, name for the executable
ProgramName: easygen
# package name
# - For standalone program that does not belong to any package, e.g.,
# https://github.com/suntong/easygen/blob/7791e4f0e5605543d27da1671a21376cdb9dcf2a/easygen/easygen.go
# just ignore the first line, the `package` output, and copy the rest
# - If you don't mind using a separated file to handle commandline paramters,
# then name the package as "main". see the spin-out "TF-minus1.go" file under
# https://github.com/suntong/easygen/tree/d1ab0b5fe80ddac57fe9ef51f6ccb3ab998cd5ee
# - If you are using it in a pacakge, look no further than
# https://github.com/suntong/easygen/blob/master/easygenapi/config.go
# which was a direct dump: easygen test/commandlineFlag | gofmt > easygenapi/config.go
#
PackageName: easygenapi
# Name of the structure to hold the values for/from commandline
StructName: Options
# The actual variable that hold the commandline paramter values
StructVar: Opts
Options:
- Name: HTML
Type: bool
Flag: html
Value: false
Usage: treat the template file as html instead of text
- Name: TemplateStr
Type: string
Flag: ts
Value: '""'
Usage: "template string (in text)"
- Name: TemplateFile
Type: string
Flag: tf
Value: '""'
Usage: ".tmpl (comma-separated) template file `name(s)` (default: same as .yaml file)"
- Name: ExtYaml
Type: string
Flag: ey
Value: '".yaml"'
Usage: "`extension` of yaml file"
- Name: ExtTmpl
Type: string
Flag: et
Value: '".tmpl"'
Usage: "`extension` of template file"
- Name: StrFrom
Type: string
Flag: rf
Value: '""'
Usage: "replace from, the from string used for the replace function"
- Name: StrTo
Type: string
Flag: rt
Value: '""'
Usage: "replace to, the to string used for the replace function"
- Name: Debug
Type: int
Flag: debug
Value: 0
Usage: "debugging `level`"
# Whether to use the USAGE_SUMMARY in Usage help
UsageSummary: ""
UsageLead: "\\nUsage:\\n %s [flags] YamlFileName [YamlFileName...]\\n\\nFlags:\\n\\n"
UsageEnd: "\\nYamlFileName(s): The name for the .yaml data and .tmpl template file\\n\\tOnly the name part, without extension. Can include the path as well.\\n"
easygen-4.1.0/test/enum_c-header.tmpl 0000664 0000000 0000000 00000000512 13502324010 0017504 0 ustar 00root root 0000000 0000000 {{- if .EnumComments -}}
{{- range .EnumComments }}
// {{.}}
{{- end -}}
{{- end }}
enum {{.EnumName}} {
{{- range $i, $val := .Values -}}
{{- if .Comment }}
{{- if gt $i 0 }}
{{ end }}
// {{.Comment}}
{{- end -}}
{{- if .Value }}
{{ .Name }} = {{.Value }},
{{- else }}
{{ .Name }},
{{- end -}}
{{- end }}
};
easygen-4.1.0/test/enum_c-source.tmpl 0000664 0000000 0000000 00000001661 13502324010 0017562 0 ustar 00root root 0000000 0000000 {{/*
Randomly pick the first element if no EnumDefault is set.
*/}}
{{ with $DEFAULT := or (.EnumDefault) (index .Values 0 "Name") -}}
/** Try to extract an enum {{$.EnumName}} value from @str; fall back to "{{$DEFAULT}}". */
const enum {{$.EnumName}}
str_to_{{$.EnumName}}(const char const *str)
{
{{- range $i, $val := $.Values }}
{{ if gt $i 0 -}}} else {{end -}}if (strcasecmp(str, "{{ if .String }}{{.String}}{{else}}{{.Name}}{{end}}") == 0) {
return {{ .Name }};
{{- range .AltString }}
} else if (strcasecmp(str, "{{.}}") == 0) {
return {{ $val.Name }};
{{- end }}
{{- if eq (len $.Values|minus1) ($i)}}{{/* Sentinel */}}
}
{{- end -}}
{{- end }}
return {{$DEFAULT}};
}
{{- end }}
/** Stringer function for {{.EnumName}}. */
const char *
{{.EnumName}}_to_str(const enum {{.EnumName}} val)
{
switch (val) {
{{- range .Values }}
case {{.Name}}:
return "{{ if .String }}{{.String}}{{else}}{{.Name}}{{end}}";
{{- end }}
}
}
easygen-4.1.0/test/enum_c-to_str.tmpl 0000664 0000000 0000000 00000000366 13502324010 0017575 0 ustar 00root root 0000000 0000000
/** Stringer function for {{.EnumName}}. */
const char *
{{.EnumName}}_to_str(const enum {{.EnumName}} val)
{
switch (val) {
{{- range .Values }}
case {{.Name}}:
return "{{ if .String }}{{.String}}{{else}}{{.Name}}{{end}}";
{{- end }}
}
}
easygen-4.1.0/test/enum_go.tmpl 0000664 0000000 0000000 00000006264 13502324010 0016453 0 ustar 00root root 0000000 0000000 {{/*
NOTE: This produces the _same_ enum values as for C enums, as long the input format is one of:
a) enum first { a, b, c}
b) enum second { a = 0x5, b, c }
The first is handled by iota, the other uses https://golang.org/ref/spec#ConstSpec
Currently NOT supported is a mixed form: enum mixed { a, b=0x20, c, d=0x30, e }
*/}}
import (
"database/sql/driver"
"encoding/json"
"fmt"
)
{{ if .EnumComments -}}
{{- range .EnumComments -}}
// {{.}}
{{- end -}}
{{- else -}}
// {{ cls2uc .EnumName }} is the representation of {{.EnumName -}}
{{- end }}
type {{ cls2uc .EnumName}} uint32
const (
{{- range $i, $j := .Values -}}
{{- if .Comment }}
{{- if gt $i 0 }}{{/* insert newline */}}
{{ end }}
// {{.Comment}}
{{- end -}}
{{- if eq $i 0 }}
{{ .Name }} {{ cls2uc $.EnumName }} = {{if .Value}}{{.Value}} + {{end}}iota
{{- else }}
{{ .Name }}{{if .Value}} {{ cls2uc $.EnumName }} = {{ .Value }}{{end}}
{{- end }}
{{- end }}
)
{{ with $type := cls2uc $.EnumName -}}
{{ with $m := index (clk2ls $type) 0 | printf "%c" -}}
// Implements encoding.TextMarshaler
func ({{$m}} {{$type}}) MarshalText() ([]byte, error) {
switch {{$m}} {
{{- range $.Values }}
case {{.Name}}:
return []byte("{{if .String}}{{.String}}{{else}}{{.Name}}{{end}}"), nil
{{- end }}
}
return nil, fmt.Errorf("invalid {{$type}} %d", {{$m}})
}
// Implements encoding.TextUnmarshaler
func ({{$m}} *{{$type}}) UnmarshalText(data []byte) error {
switch string(data) {
{{- range $i, $val := $.Values }}
case "{{ if .String }}{{.String}}{{else}}{{.Name}}{{end}}":
*{{$m}} = {{ .Name }}
{{- range .AltString }}
case "{{.}}":
*{{$m}} = {{ $val.Name }}
{{- end }}
{{- end }}
default:
return fmt.Errorf("invalid {{$type}} %q", string(data))
}
return nil
}
// Implements fmt.Stringer
func ({{$m}} {{$type}}) String() string {
if b, err := {{$m}}.MarshalText(); err != nil {
return err.Error()
} else {
return string(b)
}
}
// Implements database/sql/driver.Valuer
func ({{$m}} {{$type}}) Value() (driver.Value, error) {
return {{$m}}.String(), nil
}
// Implements database/sql.Scanner
func ({{$m}} *{{$type}}) Scan(src interface{}) error {
switch src := src.(type) {
case int64:
*{{$m}} = {{$type}}(src)
return nil
case []byte:
return {{$m}}.UnmarshalText(src)
case string:
return {{$m}}.UnmarshalText([]byte(src))
}
return fmt.Errorf("unable to convert %T to {{$type}}", src)
}
// Implements json.Marshaler
func ({{$m}} {{$type}}) MarshalJSON() ([]byte, error) {
return json.Marshal({{$m}}.String())
}
// Implements json.Unmarshaler
func ({{$m}} *{{$type}}) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return fmt.Errorf("failed to parse '%s' as {{$type}}: %s", string(data), err)
}
return {{$m}}.UnmarshalText([]byte(s))
}
// Implements yaml.Marshaler
func ({{$m}} {{$type}}) MarshalYAML() (interface{}, error) {
return {{$m}}.String(), nil
}
// Implements yaml.Unmarshaler
func ({{$m}} *{{$type}}) UnmarshalYAML(unmarshal func(interface{}) error) error {
var s string
if err := unmarshal(&s); err != nil {
return fmt.Errorf("failed to unmarshal {{$type}} from YAML: %s", err)
}
return {{$m}}.UnmarshalText([]byte(s))
}
{{- end}}
{{- end}}
easygen-4.1.0/test/enum_java.tmpl 0000664 0000000 0000000 00000000636 13502324010 0016764 0 ustar 00root root 0000000 0000000 {{- if .EnumComments -}}
/**
{{- range .EnumComments }}
* {{.}}
{{- end }}
*/
{{- else -}}
/** {{ cls2uc .EnumName }} is the representation of {{.EnumName}} */
{{- end }}
public enum {{cls2uc .EnumName}} {
{{- range $i, $val := .Values -}}
{{- if .Comment }}
{{- if gt $i 0 }}
{{ end }}
// {{.Comment}}
{{- end }}
{{ .Name }}{{if eq (len $.Values|minus1) ($i)}};{{else}},{{end}}
{{- end }}
}
easygen-4.1.0/test/enum_multiple_data_files.ref 0000664 0000000 0000000 00000000200 13502324010 0021634 0 ustar 00root root 0000000 0000000
// Simplified enumeration of available RAID devices
enum raid_type {
RAID0 = 100,
RAID1,
};
enum raid_driver {
HW,
SW,
};
easygen-4.1.0/test/enum_multiple_template_and_data.ref 0000664 0000000 0000000 00000000776 13502324010 0023211 0 ustar 00root root 0000000 0000000
// Simplified enumeration of available RAID devices
enum raid_type {
RAID0 = 100,
RAID1,
};
/** Stringer function for raid_type. */
const char *
raid_type_to_str(const enum raid_type val)
{
switch (val) {
case RAID0:
return "RAID0";
case RAID1:
return "RAID1";
}
}
enum raid_driver {
HW,
SW,
};
/** Stringer function for raid_driver. */
const char *
raid_driver_to_str(const enum raid_driver val)
{
switch (val) {
case HW:
return "Hardware-RAID";
case SW:
return "Software-RAID";
}
}
easygen-4.1.0/test/enum_multiple_template_files.ref 0000664 0000000 0000000 00000001250 13502324010 0022544 0 ustar 00root root 0000000 0000000
// Simplified enumeration of available RAID devices
enum raid_type {
RAID0 = 100,
RAID1,
};
/** Try to extract an enum raid_type value from @str; fall back to "RAID0". */
const enum raid_type
str_to_raid_type(const char const *str)
{
if (strcasecmp(str, "RAID0") == 0) {
return RAID0;
} else if (strcasecmp(str, "RAID-0") == 0) {
return RAID0;
} else if (strcasecmp(str, "RAID1") == 0) {
return RAID1;
} else if (strcasecmp(str, "RAID-1") == 0) {
return RAID1;
}
return RAID0;
}
/** Stringer function for raid_type. */
const char *
raid_type_to_str(const enum raid_type val)
{
switch (val) {
case RAID0:
return "RAID0";
case RAID1:
return "RAID1";
}
}
easygen-4.1.0/test/example.yaml 0000664 0000000 0000000 00000000271 13502324010 0016433 0 ustar 00root root 0000000 0000000 ColorRed: red
ColorBlue: blue
ColorWhite: white
Colorlist: red blue white
Colors:
- red
- blue
- white
Cars:
- Make: Ford
Module: T1
- Make: GM
Module: T2
easygen-4.1.0/test/html-Checkbox-Group.tmpl 0000664 0000000 0000000 00000011160 13502324010 0020573 0 ustar 00root root 0000000 0000000
Multiple Checkbox Select/Deselect - DEMO
Multiple Checkbox Group Select/Deselect - DEMO
This extends the Multiple Checkbox Select/Deselect Using JQuery which has an Online Demo here, which demonstrates the functionality of selecting multiple items from a list to process them.
This extends the demo further -- it now includes several groups instead merely a single one.
- There is a select all checkbox for each group (in the table header). If user select/deselect the selectall checkbox, all the checkbox withing that group will get selected or deselected accordingly. Other groups are not affected.
- Also,
- if user select all the checkbox one by one then the selectall checkbox should be automatically gets selected.
- And if user click selectall first and then unchecks any of the checkbox, then the selectall also should be unchecked automatically.
- Again, this is for withing that group. Other groups are not affected.
FYI, this full working html source code is generated automatically by easygen with this template. This html test code is the reason that I wrote easygen, to make it easy to write whatever test cases whatever the way I like. Further, changing is a breeze, you just change once and the script will do a "replace-all" for you, however complicated it can be. No any other tools can do such complicated "replace-all" for you.
easygen-4.1.0/test/html-Checkbox-Group.yaml 0000664 0000000 0000000 00000000441 13502324010 0020561 0 ustar 00root root 0000000 0000000 phone:
- Type: Android
Modules:
- Samsung Galaxy
- Droid X
- HTC Desire
- Type: iPhone
Modules:
- Apple iPhone 4
- Apple iPhone 5
- Apple iPhone 6
- Type: BlackBerry
Modules:
- BlackBerry Bold 9650
- BlackBerry 10
easygen-4.1.0/test/html-Checkbox-Post.tmpl 0000664 0000000 0000000 00000005535 13502324010 0020435 0 ustar 00root root 0000000 0000000
Multiple Checkbox Select/Deselect - DEMO
Multiple Checkbox Group Select/Deselect - DEMO
easygen-4.1.0/test/html-Table-RWD.html 0000664 0000000 0000000 00000006565 13502324010 0017441 0 ustar 00root root 0000000 0000000
Android Cell phones
| Module A |
Module B |
Module C |
| Samsung Galaxy A |
Samsung Galaxy B |
Samsung Galaxy C |
| Droid X A |
Droid X B |
Droid X C |
| HTC Desire A |
HTC Desire B |
HTC Desire C |
iPhone Cell phones
| Module A |
Module B |
Module C |
| Apple iPhone 4 A |
Apple iPhone 4 B |
Apple iPhone 4 C |
| Apple iPhone 5 A |
Apple iPhone 5 B |
Apple iPhone 5 C |
| Apple iPhone 6 A |
Apple iPhone 6 B |
Apple iPhone 6 C |
BlackBerry Cell phones
| Module A |
Module B |
Module C |
| BlackBerry Bold 9650 A |
BlackBerry Bold 9650 B |
BlackBerry Bold 9650 C |
| BlackBerry 10 A |
BlackBerry 10 B |
BlackBerry 10 C |
easygen-4.1.0/test/html-Table-RWD.tmpl 0000664 0000000 0000000 00000004642 13502324010 0017443 0 ustar 00root root 0000000 0000000
{{range .phone}}{{$phoneType := clk2ls .Type}}
{{.Type}} Cell phones
| Module A |
Module B |
Module C |
{{range .Modules}}
| {{.}} A |
{{.}} B |
{{.}} C |
{{end}}
{{end}}
easygen-4.1.0/test/jq-test_0.go_ 0000664 0000000 0000000 00000003675 13502324010 0016423 0 ustar 00root root 0000000 0000000 // Copyright (c) 2016 Matt Ho
//
// Test cases code automatically generated by easygen:
// https://github.com/go-easygen/easygen
// Editing discouraged.
// Test cases code Copyright (c) 2016 of project
// https://github.com/stedolan/jq
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package jq_test
import (
"testing"
"github.com/savaki/jq"
)
func TestParse(t *testing.T) {
testCases := map[string]struct {
In string
Op string
Expected string
HasError bool
}{
// Tests are groups of three lines: program, input, expected output
// Blank lines and lines starting with # are ignored
//
// Simple value tests to check parser. Input is irrelevant
//
"simple": {
In: `{"hello":"world"}`,
Op: `.hello`,
Expected: `"world"`,
},
"nested": {
In: `{"a":{"b":"world"}}`,
Op: `.a.b`,
Expected: `"world"`,
},
"index": {
In: `["a","b","c"]`,
Op: `.[1]`,
Expected: `"b"`,
},
"range": {
In: `["a","b","c"]`,
Op: `.[1:2]`,
Expected: `["b","c"]`,
},
}
for label, tc := range testCases {
t.Run(label, func(t *testing.T) {
op, err := jq.Parse(tc.Op)
if err != nil {
t.FailNow()
}
data, err := op.Apply([]byte(tc.In))
if tc.HasError {
if err == nil {
t.FailNow()
}
} else {
if string(data) != tc.Expected {
t.FailNow()
}
if err != nil {
t.FailNow()
}
}
})
}
}
easygen-4.1.0/test/jq-test_0.yaml 0000664 0000000 0000000 00000001312 13502324010 0016603 0 ustar 00root root 0000000 0000000 Cases:
- Comment:
Str: 'Tests are groups of three lines: program, input, expected output'
- Comment:
Str: 'Blank lines and lines starting with # are ignored'
- Comment:
Str:
- Comment:
Str: 'Simple value tests to check parser. Input is irrelevant'
- Comment:
Str:
- TestCase:
Name: simple
Op: '.hello'
In: '{"hello":"world"}'
Out: '"world"'
- TestCase:
Name: nested
Op: '.a.b'
In: '{"a":{"b":"world"}}'
Out: '"world"'
- TestCase:
Name: index
Op: '.[1]'
In: '["a","b","c"]'
Out: '"b"'
- TestCase:
Name: range
Op: '.[1:2]'
In: '["a","b","c"]'
Out: '["b","c"]'
easygen-4.1.0/test/jq-test_1.go_ 0000664 0000000 0000000 00000122600 13502324010 0016412 0 ustar 00root root 0000000 0000000 // Copyright (c) 2016 Matt Ho
//
// Test cases code automatically generated by easygen:
// https://github.com/go-easygen/easygen
// Editing discouraged.
// Test cases code Copyright (c) 2016 of project
// https://github.com/stedolan/jq
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package jq_test
import (
"testing"
"github.com/savaki/jq"
)
func TestParse(t *testing.T) {
testCases := map[string]struct {
In string
Op string
Expected string
HasError bool
}{
// Tests are groups of three lines: program, input, expected output
// Blank lines and lines starting with # are ignored
//
// Simple value tests to check parser. Input is irrelevant
//
"case1": {
In: `null`,
Op: `true`,
Expected: `true`,
},
"case2": {
In: `null`,
Op: `false`,
Expected: `false`,
},
"case3": {
In: `42`,
Op: `null`,
Expected: `null`,
},
"case4": {
In: `null`,
Op: `1`,
Expected: `1`,
},
"case5": {
In: `null`,
Op: `-1`,
Expected: `-1`,
},
// FIXME: much more number testing needed
"case6": {
In: `null`,
Op: `{}`,
Expected: `{}`,
},
"case7": {
In: `null`,
Op: `[]`,
Expected: `[]`,
},
"case8": {
In: `null`,
Op: `{x: -1}`,
Expected: `{"x": -1}`,
},
// The input line starts with a 0xFEFF (byte order mark) codepoint
// No, there is no reason to have a byte order mark in UTF8 text.
// But apparently people do, so jq shouldnt break on it.
// We test escapes by matching them against Unicode codepoints
// FIXME: more tests needed for weird unicode stuff (e.g. utf16 pairs)
"case9": {
In: `null`,
Op: `"Aa\r\n\t\b\f\u03bc"`,
Expected: `"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"`,
},
"case10": {
In: `"Aa\r\n\t\b\f\u03bc"`,
Op: `.`,
Expected: `"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"`,
},
"case11": {
In: `null`,
Op: `"inter\("pol" + "ation")"`,
Expected: `"interpolation"`,
},
"case12": {
In: `<>&'" `,
Op: `@text,@json,([1,.] | (@csv, @tsv)),@html,@uri,@sh,@base64`,
Expected: `<>&'" `,
},
// regression test for #436
"case13": {
In: `"foóbar\n"`,
Op: `@base64`,
Expected: `"Zm/Ds2Jhcgo="`,
},
"case14": {
In: `"\u03bc"`,
Op: `@uri`,
Expected: `"%CE%BC"`,
},
"case15": {
In: `""`,
Op: `@html "\(.)"`,
Expected: `"<script>hax</script>"`,
},
"case16": {
In: `["foo", 1, ["a", 1, "b", 2, {"foo":"bar"}]]`,
Op: `[.[]|tojson|fromjson]`,
Expected: `["foo",1,["a",1,"b",2,{"foo":"bar"}]]`,
},
//
// Dictionary construction syntax
//
"case17": {
In: `null`,
Op: `{a: 1}`,
Expected: `{"a":1}`,
},
"case18": {
In: `{"a":1, "b":2, "c":3, "d":"c"}`,
Op: `{a,b,(.d):.a,e:.b}`,
Expected: `{"a":1, "b":2, "c":1, "e":2}`,
},
"case19": {
In: `{"a":1, "b":2, "c":3, "a$2":4}`,
Op: `{"a",b,"a$\(1+1)"}`,
Expected: `{"a":1, "b":2, "a$2":4}`,
},
//
// Field access, piping
//
"case20": {
In: `{"foo": 42, "bar": 43}`,
Op: `.foo`,
Expected: `42`,
},
"case21": {
In: `{"foo": {"bar": 42}, "bar": "badvalue"}`,
Op: `.foo | .bar`,
Expected: `42`,
},
"case22": {
In: `{"foo": {"bar": 42}, "bar": "badvalue"}`,
Op: `.foo.bar`,
Expected: `42`,
},
"case23": {
In: `{"foo_bar": 2}`,
Op: `.foo_bar`,
Expected: `2`,
},
"case24": {
In: `{"foo": {"bar": 42}, "bar": "badvalue"}`,
Op: `.["foo"].bar`,
Expected: `42`,
},
"case25": {
In: `{"foo": {"bar": 20}}`,
Op: `."foo"."bar"`,
Expected: `20`,
},
"case26": {
In: `[1,[2],{"foo":3,"bar":4},{},{"foo":5}]`,
Op: `[.[]|.foo?]`,
Expected: `[3,null,5]`,
},
"case27": {
In: `[1,[2],[],{"foo":3},{"foo":{"bar":4}},{}]`,
Op: `[.[]|.foo?.bar?]`,
Expected: `[4,null]`,
},
"case28": {
In: `[1,[[2]],{ "a":[1]}]`,
Op: `[..]`,
Expected: `[[1,[[2]],{"a":[1]}],1,[[2]],[2],2,{"a":[1]},[1],1]`,
},
"case29": {
In: `[1,null,[],[1,[2,[[3]]]],[{}],[{"a":[1,[2]]}]]`,
Op: `[.[]|.[]?]`,
Expected: `[1,[2,[[3]]],{},{"a":[1,[2]]}]`,
},
"case30": {
In: `[1,null,true,false,"abcdef",{},{"a":1,"b":2},[],[1,2,3,4,5],[1,2]]`,
Op: `[.[]|.[1:3]?]`,
Expected: `[null,"bc",[],[2,3],[2]]`,
},
//
// Negative array indices
//
"case31": {
In: `null`,
Op: `try (.foo[-1] = 0) catch .`,
Expected: `"Out of bounds negative array index"`,
},
"case32": {
In: `null`,
Op: `try (.foo[-2] = 0) catch .`,
Expected: `"Out of bounds negative array index"`,
},
"case33": {
In: `[0,1,2]`,
Op: `.[-1] = 5`,
Expected: `[0,1,5]`,
},
"case34": {
In: `[0,1,2]`,
Op: `.[-2] = 5`,
Expected: `[0,5,2]`,
},
//
// Multiple outputs, iteration
//
"case35": {
In: `[1,2,3]`,
Op: `.[]`,
Expected: `1`,
},
"case36": {
In: `[]`,
Op: `1,1`,
Expected: `1`,
},
"case37": {
In: `[]`,
Op: `1,.`,
Expected: `1`,
},
"case38": {
In: `[2]`,
Op: `[.]`,
Expected: `[[2]]`,
},
"case39": {
In: `[3]`,
Op: `[[2]]`,
Expected: `[[2]]`,
},
"case40": {
In: `[2]`,
Op: `[{}]`,
Expected: `[{}]`,
},
"case41": {
In: `["a"]`,
Op: `[.[]]`,
Expected: `["a"]`,
},
"case42": {
In: `["a","b"]`,
Op: `[(.,1),((.,.[]),(2,3))]`,
Expected: `[["a","b"],1,["a","b"],"a","b",2,3]`,
},
"case43": {
In: `[1,2,3]`,
Op: `[([5,5][]),.,.[]]`,
Expected: `[5,5,[1,2,3],1,2,3]`,
},
"case44": {
In: `null`,
Op: `{x: (1,2)},{x:3} | .x`,
Expected: `1`,
},
"case45": {
In: `[1,2,3]`,
Op: `.[-2]`,
Expected: `2`,
},
"case46": {
In: `null`,
Op: `[range(0;10)]`,
Expected: `[0,1,2,3,4,5,6,7,8,9]`,
},
"case47": {
In: `null`,
Op: `[range(0,1;3,4)]`,
Expected: `[0,1,2, 0,1,2,3, 1,2, 1,2,3]`,
},
"case48": {
In: `null`,
Op: `[range(0;10;3)]`,
Expected: `[0,3,6,9]`,
},
"case49": {
In: `null`,
Op: `[range(0;10;-1)]`,
Expected: `[]`,
},
"case50": {
In: `null`,
Op: `[range(0;-5;-1)]`,
Expected: `[0,-1,-2,-3,-4]`,
},
"case51": {
In: `null`,
Op: `[range(0,1;4,5;1,2)]`,
Expected: `[0,1,2,3,0,2, 0,1,2,3,4,0,2,4, 1,2,3,1,3, 1,2,3,4,1,3]`,
},
"case52": {
In: `1`,
Op: `[while(.<100; .*2)]`,
Expected: `[1,2,4,8,16,32,64]`,
},
"case53": {
In: `[0,1,2]`,
Op: `[(label $here | .[] | if .>1 then break $here else . end), "hi!"]`,
Expected: `[0,1,"hi!"]`,
},
"case54": {
In: `[0,2,1]`,
Op: `[(label $here | .[] | if .>1 then break $here else . end), "hi!"]`,
Expected: `[0,"hi!"]`,
},
"case55": {
In: `[1,2,3,4,5]`,
Op: `[.[]|[.,1]|until(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]]`,
Expected: `[1,2,6,24,120]`,
},
"case56": {
In: `[11,22,33,44,55,66,77,88,99]`,
Op: `[label $out | foreach .[] as $item ([3, null]; if .[0] < 1 then break $out else [.[0] -1, $item] end; .[1])]`,
Expected: `[11,22,33]`,
},
"case57": {
In: `null`,
Op: `[foreach range(5) as $item (0; $item)]`,
Expected: `[0,1,2,3,4]`,
},
"case58": {
In: `[[2,1], [5,3], [6,4]]`,
Op: `[foreach .[] as [$i, $j] (0; . + $i - $j)]`,
Expected: `[1,3,5]`,
},
"case59": {
In: `[{"a":1}, {"b":2}, {"a":3, "b":4}]`,
Op: `[foreach .[] as {a:$a} (0; . + $a; -.)]`,
Expected: `[-1, -1, -4]`,
},
"case60": {
In: `[11,22,33,44,55,66,77,88,99]`,
Op: `[limit(3; .[])]`,
Expected: `[11,22,33]`,
},
"case61": {
In: `10`,
Op: `[first(range(.)), last(range(.)), nth(0; range(.)), nth(5; range(.)), try nth(-1; range(.)) catch .]`,
Expected: `[0 9 0 5 nth doesn't support negative indices]`,
},
//
// Check that various builtins evalute all arguments where appropriate,
// doing cartesian products where appropriate.
//
// Check that limit does work for each value produced by n!
"case62": {
In: `null`,
Op: `[limit(5,7; range(9))]`,
Expected: `[0,1,2,3,4,0,1,2,3,4,5,6]`,
},
// Same check for nth
"case63": {
In: `null`,
Op: `[nth(5,7; range(9;0;-1))]`,
Expected: `[4,2]`,
},
// Same check for range/3
"case64": {
In: `null`,
Op: `[range(0,1,2;4,3,2;2,3)]`,
Expected: `[0,2,0,3,0,2,0,0,0,1,3,1,1,1,1,1,2,2,2,2]`,
},
// Same check for range/1
"case65": {
In: `null`,
Op: `[range(3,5)]`,
Expected: `[0,1,2,0,1,2,3,4]`,
},
// Same check for index/1, rindex/1, indices/1
"case66": {
In: `"a,b|c,d,e||f,g,h,|,|,i,j"`,
Op: `[(index(",","|"), rindex(",","|")), indices(",","|")]`,
Expected: `[1,3,22,19,[1,5,7,12,14,16,18,20,22],[3,9,10,17,19]]`,
},
// Same check for join/1
"case67": {
In: `["a","b","c","d"]`,
Op: `join(",","/")`,
Expected: `"a,b,c,d"`,
},
"case68": {
In: `[[],[""],["",""],["","",""]]`,
Op: `[.[]|join("a")]`,
Expected: `["","","a","aa"]`,
},
// Same check for flatten/1
"case69": {
In: `[0, [1], [[2]], [[[3]]]]`,
Op: `flatten(3,2,1)`,
Expected: `[0,1,2,3]`,
},
//
// Slices
//
"case70": {
In: `[0,1,2,3,4,5,6]`,
Op: `[.[3:2], .[-5:4], .[:-2], .[-2:], .[3:3][1:], .[10:]]`,
Expected: `[[], [2,3], [0,1,2,3,4], [5,6], [], []]`,
},
"case71": {
In: `"abcdefghi"`,
Op: `[.[3:2], .[-5:4], .[:-2], .[-2:], .[3:3][1:], .[10:]]`,
Expected: `["","","abcdefg","hi","",""]`,
},
"case72": {
In: `[0,1,2,3,4,5,6,7]`,
Op: `del(.[2:4],.[0],.[-2:])`,
Expected: `[1,4,5]`,
},
"case73": {
In: `[0,1,2,3,4,5,6,7]`,
Op: `.[2:4] = ([], ["a","b"], ["a","b","c"])`,
Expected: `[0,1,4,5,6,7]`,
},
//
// Variables
//
"case74": {
In: `null`,
Op: `1 as $x | 2 as $y | [$x,$y,$x]`,
Expected: `[1,2,1]`,
},
"case75": {
In: `null`,
Op: `[1,2,3][] as $x | [[4,5,6,7][$x]]`,
Expected: `[5]`,
},
"case76": {
In: `34324`,
Op: `42 as $x | . | . | . + 432 | $x + 1`,
Expected: `43`,
},
"case77": {
In: `null`,
Op: `1 as $x | [$x,$x,$x as $x | $x]`,
Expected: `[1,1,1]`,
},
"case78": {
In: `null`,
Op: `[1, {c:3, d:4}] as [$a, {c:$b, b:$c}] | $a, $b, $c`,
Expected: `1`,
},
"case79": {
In: `{"as": 1, "str": 2, "exp": 3}`,
Op: `. as {as: $kw, "str": $str, ("e"+"x"+"p"): $exp} | [$kw, $str, $exp]`,
Expected: `[1, 2, 3]`,
},
"case80": {
In: `[[1], [1, 2, 3]]`,
Op: `.[] as [$a, $b] | [$b, $a]`,
Expected: `[null, 1]`,
},
"case81": {
In: `[0]`,
Op: `. as $i | . as [$i] | $i`,
Expected: `0`,
},
"case82": {
In: `[0]`,
Op: `. as [$i] | . as $i | $i`,
Expected: `[0]`,
},
// [.,(.[] | {x:.},.),.,.[]]
//
// Builtin functions
//
"case83": {
In: `null`,
Op: `1+1`,
Expected: `2`,
},
"case84": {
In: `"wtasdf"`,
Op: `1+1`,
Expected: `2.0`,
},
"case85": {
In: `null`,
Op: `2-1`,
Expected: `1`,
},
"case86": {
In: `null`,
Op: `2-(-1)`,
Expected: `3`,
},
"case87": {
In: `"I wonder what this will be?"`,
Op: `1e+0+0.001e3`,
Expected: `20e-1`,
},
"case88": {
In: `15`,
Op: `.+4`,
Expected: `19.0`,
},
"case89": {
In: `{"a":42}`,
Op: `.+null`,
Expected: `{"a":42}`,
},
"case90": {
In: `null`,
Op: `null+.`,
Expected: `null`,
},
"case91": {
In: `{"a":42}`,
Op: `.a+.b`,
Expected: `42`,
},
"case92": {
In: `null`,
Op: `[1,2,3] + [.]`,
Expected: `[1,2,3,null]`,
},
"case93": {
In: `"asdfasdf"`,
Op: `{"a":1} + {"b":2} + {"c":3}`,
Expected: `{"a":1, "b":2, "c":3}`,
},
"case94": {
In: `"some string"`,
Op: `"asdf" + "jkl;" + . + . + .`,
Expected: `"asdfjkl;some stringsome stringsome string"`,
},
"case95": {
In: `"\u0000\u0020\u0000"`,
Op: `"\u0000\u0020\u0000" + .`,
Expected: `"\u0000 \u0000\u0000 \u0000"`,
},
"case96": {
In: `11`,
Op: `42 - .`,
Expected: `31`,
},
"case97": {
In: `1`,
Op: `[1,2,3,4,1] - [.,3]`,
Expected: `[2,4]`,
},
"case98": {
In: `4`,
Op: `[10 * 20, 20 / .]`,
Expected: `[200, 5]`,
},
"case99": {
In: `null`,
Op: `1 + 2 * 2 + 10 / 2`,
Expected: `10`,
},
"case100": {
In: `null`,
Op: `[16 / 4 / 2, 16 / 4 * 2, 16 - 4 - 2, 16 - 4 + 2]`,
Expected: `[2, 8, 10, 14]`,
},
"case101": {
In: `null`,
Op: `25 % 7`,
Expected: `4`,
},
"case102": {
In: `null`,
Op: `49732 % 472`,
Expected: `172`,
},
"case103": {
In: `4`,
Op: `1 + tonumber + ("10" | tonumber)`,
Expected: `15`,
},
"case104": {
In: `{"object": {"a":42}, "num":10.0}`,
Op: `[{"a":42},.object,10,.num,false,true,null,"b",[1,4]] | .[] as $x | [$x == .[]]`,
Expected: `[true, true, false, false, false, false, false, false, false]`,
},
"case105": {
In: `[[], {}, [1,2], {"a":42}, "asdf", "\u03bc"]`,
Op: `[.[] | length]`,
Expected: `[0, 0, 2, 1, 4, 1]`,
},
"case106": {
In: `"asdf\u03bc"`,
Op: `utf8bytelength`,
Expected: `6`,
},
"case107": {
In: `[[], {}, [1,2], 55, true, false]`,
Op: `[.[] | try utf8bytelength catch .]`,
Expected: `["array ([]) only strings have UTF-8 byte length","object ({}) only strings have UTF-8 byte length","array ([1,2]) only strings have UTF-8 byte length","number (55) only strings have UTF-8 byte length","boolean (true) only strings have UTF-8 byte length","boolean (false) only strings have UTF-8 byte length"]`,
},
"case108": {
In: `[{}, {"abcd":1,"abc":2,"abcde":3}, {"x":1, "z": 3, "y":2}]`,
Op: `map(keys)`,
Expected: `[[], ["abc","abcd","abcde"], ["x","y","z"]]`,
},
"case109": {
In: `null`,
Op: `[1,2,empty,3,empty,4]`,
Expected: `[1,2,3,4]`,
},
"case110": {
In: `[[], [1,2,3], ["a","b","c"], [[3],[4,5],[6]], [{"a":1}, {"b":2}, {"a":3}]]`,
Op: `map(add)`,
Expected: `[null, 6, "abc", [3,4,5,6], {"a":3, "b": 2}]`,
},
"case111": {
In: `[0,1,2]`,
Op: `map_values(.+1)`,
Expected: `[1,2,3]`,
},
//
// User-defined functions
// Oh god.
//
"case112": {
In: `3.0`,
Op: `def f: . + 1; def g: def g: . + 100; f | g | f; (f | g), g`,
Expected: `106.0`,
},
"case113": {
In: `123412345`,
Op: `def f: (1000,2000); f`,
Expected: `1000`,
},
"case114": {
In: `[1,2]`,
Op: `def f(a;b;c;d;e;f): [a+1,b,c,d,e,f]; f(.[0];.[1];.[0];.[0];.[0];.[0])`,
Expected: `[2,2,1,1,1,1]`,
},
// Test precedence of def vs |
"case115": {
In: `null`,
Op: `def a: 0; . | a`,
Expected: `0`,
},
// Many arguments
"case116": {
In: `[0,1,2,3,4,5,6,7,8,9]`,
Op: `def f(a;b;c;d;e;f;g;h;i;j): [j,i,h,g,f,e,d,c,b,a]; f(.[0];.[1];.[2];.[3];.[4];.[5];.[6];.[7];.[8];.[9])`,
Expected: `[9,8,7,6,5,4,3,2,1,0]`,
},
"case117": {
In: `[1,2,3]`,
Op: `([1,2] + [4,5])`,
Expected: `[1,2,4,5]`,
},
"case118": {
In: `[1]`,
Op: `true`,
Expected: `true`,
},
"case119": {
In: `"hello"`,
Op: `null,1,null`,
Expected: `null`,
},
"case120": {
In: `[5,6]`,
Op: `[1,2,3]`,
Expected: `[1,2,3]`,
},
"case121": {
In: `[-1.1,1.1,1.9]`,
Op: `[.[]|floor]`,
Expected: `[-2, 1, 1]`,
},
"case122": {
In: `[4,9]`,
Op: `[.[]|sqrt]`,
Expected: `[2,3]`,
},
"case123": {
In: `[2,4,4,4,5,5,7,9]`,
Op: `(add / length) as $m | map((. - $m) as $d | $d * $d) | add / length | sqrt`,
Expected: `2`,
},
// Should write a test that calls the -lm function from C (or bc(1)) to
// check that they match the corresponding jq functions. However,
// theres so little template code standing between that it suffices to
// test a handful of these. The results were checked by eye against
// bc(1).
"case124": {
In: `1`,
Op: `atan * 4 * 1000000|floor / 1000000`,
Expected: `3.141592`,
},
"case125": {
In: `null`,
Op: `[(3.141592 / 2) * (range(0;20) / 20)|cos * 1000000|floor / 1000000]`,
Expected: `[1,0.996917,0.987688,0.972369,0.951056,0.923879,0.891006,0.85264,0.809017,0.760406,0.707106,0.649448,0.587785,0.522498,0.45399,0.382683,0.309017,0.233445,0.156434,0.078459]`,
},
"case126": {
In: `null`,
Op: `[(3.141592 / 2) * (range(0;20) / 20)|sin * 1000000|floor / 1000000]`,
Expected: `[0,0.078459,0.156434,0.233445,0.309016,0.382683,0.45399,0.522498,0.587785,0.649447,0.707106,0.760405,0.809016,0.85264,0.891006,0.923879,0.951056,0.972369,0.987688,0.996917]`,
},
"case127": {
In: `[1,2,3]`,
Op: `def f(x): x | x; f([.], . + [42])`,
Expected: `[[[1,2,3]]]`,
},
// test multiple function arities and redefinition
"case128": {
In: `1`,
Op: `def f: .+1; def g: f; def f: .+100; def f(a):a+.+11; [(g|f(20)), f]`,
Expected: `[33,101]`,
},
// test closures and lexical scoping
"case129": {
In: `"more testing"`,
Op: `def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x | f($x,$x+x); g($x)`,
Expected: `[1,100,2100.0,100,2100.0]`,
},
// test def f($a) syntax
"case130": {
In: `[1,2,3]`,
Op: `def x(a;b): a as $a | b as $b | $a + $b; def y($a;$b): $a + $b; def check(a;b): [x(a;b)] == [y(a;b)]; check(.[];.[]*2)`,
Expected: `true`,
},
// test backtracking through function calls and returns
// this test is *evil*
"case131": {
In: `999999999`,
Op: `[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]`,
Expected: `[[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]`,
},
// test recursion
"case132": {
In: `[1,2,3,4]`,
Op: `def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]`,
Expected: `[1,2,6,24]`,
},
// test stack overflow and reallocation
// this test is disabled for now, it takes a realllllly long time.
// def f: if length > 1000 then . else .+[1]|f end; f | length
// []
// 1001
"case133": {
In: `[1,2,4]`,
Op: `reduce .[] as $x (0; . + $x)`,
Expected: `7`,
},
"case134": {
In: `[[2,{"j":1}], [5,{"j":3}], [6,{"j":4}]]`,
Op: `reduce .[] as [$i, {j:$j}] (0; . + $i - $j)`,
Expected: `5`,
},
"case135": {
In: `null`,
Op: `reduce [[1,2,10], [3,4,10]][] as [$i,$j] (0; . + $i * $j)`,
Expected: `14`,
},
"case136": {
In: `[1,2,3,4,true,false,1,2,3,4,5]`,
Op: `. as $dot|any($dot[];not)`,
Expected: `true`,
},
"case137": {
In: `[1,2,3,4,true]`,
Op: `. as $dot|any($dot[];not)`,
Expected: `false`,
},
"case138": {
In: `[1,2,3,4,true,false,1,2,3,4,5]`,
Op: `. as $dot|all($dot[];.)`,
Expected: `false`,
},
"case139": {
In: `[1,2,3,4,true]`,
Op: `. as $dot|all($dot[];.)`,
Expected: `true`,
},
//
// Paths
//
"case140": {
In: `null`,
Op: `path(.foo[0,1])`,
Expected: `["foo", 0]`,
},
"case141": {
In: `[1,5,3]`,
Op: `path(.[] | select(.>3))`,
Expected: `[1]`,
},
"case142": {
In: `42`,
Op: `path(.)`,
Expected: `[]`,
},
"case143": {
In: `{"a":[{"b":0}]}`,
Op: `try path(.a | map(select(.b == 0))) catch .`,
Expected: `"Invalid path expression with result [{\"b\":0}]"`,
},
"case144": {
In: `{"a":[{"b":0}]}`,
Op: `try path(.a | map(select(.b == 0)) | .[0]) catch .`,
Expected: `"Invalid path expression near attempt to access element 0 of [{\"b\":0}]"`,
},
"case145": {
In: `{"a":[{"b":0}]}`,
Op: `try path(.a | map(select(.b == 0)) | .c) catch .`,
Expected: `"Invalid path expression near attempt to access element \"c\" of [{\"b\":0}]"`,
},
"case146": {
In: `{"a":[{"b":0}]}`,
Op: `try path(.a | map(select(.b == 0)) | .[]) catch .`,
Expected: `"Invalid path expression near attempt to iterate through [{\"b\":0}]"`,
},
"case147": {
In: `{"a":{"b":0}}`,
Op: `path(.a[path(.b)[0]])`,
Expected: `["a","b"]`,
},
"case148": {
In: `[1,[[],{"a":2}]]`,
Op: `[paths]`,
Expected: `[[0],[1],[1,0],[1,1],[1,1,"a"]]`,
},
"case149": {
In: `[1,[[],{"a":2}]]`,
Op: `[leaf_paths]`,
Expected: `[[0],[1,1,"a"]]`,
},
"case150": {
In: `{"bar": 42, "foo": ["a", "b", "c", "d"]}`,
Op: `["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])`,
Expected: `"b"`,
},
"case151": {
In: `[[0], [0,1], [0,1,2]]`,
Op: `map(getpath([2])), map(setpath([2]; 42)), map(delpaths([[2]]))`,
Expected: `[null, null, 2]`,
},
"case152": {
In: `[[{"foo":2, "x":1}], [{"bar":2}]]`,
Op: `map(delpaths([[0,"foo"]]))`,
Expected: `[[{"x":1}], [{"bar":2}]]`,
},
"case153": {
In: `{"bar":false}`,
Op: `["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])`,
Expected: `null`,
},
"case154": {
In: `[1,2,3]`,
Op: `delpaths([[-200]])`,
Expected: `[1,2,3]`,
},
"case155": {
In: `{}`,
Op: `try delpaths(0) catch .`,
Expected: `"Paths must be specified as an array"`,
},
"case156": {
In: `{"foo": [0,1,2,3,4], "bar": [0,1]}`,
Op: `del(.), del(empty), del((.foo,.bar,.baz) | .[2,3,0]), del(.foo[0], .bar[0], .foo, .baz.bar[0].x)`,
Expected: `null`,
},
"case157": {
In: `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]`,
Op: `del(.[1], .[-6], .[2], .[-3:9])`,
Expected: `[0, 3, 5, 6, 9]`,
},
//
// Assignment
//
"case158": {
In: `{"message": "hello"}`,
Op: `.message = "goodbye"`,
Expected: `{"message": "goodbye"}`,
},
"case159": {
In: `{"bar":42}`,
Op: `.foo = .bar`,
Expected: `{"foo":42, "bar":42}`,
},
"case160": {
In: `{"foo": 42}`,
Op: `.foo |= .+1`,
Expected: `{"foo": 43}`,
},
"case161": {
In: `[1,3,5]`,
Op: `.[] += 2, .[] *= 2, .[] -= 2, .[] /= 2, .[] %=2`,
Expected: `[3,5,7]`,
},
"case162": {
In: `[-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7]`,
Op: `[.[] % 7]`,
Expected: `[0,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,0]`,
},
"case163": {
In: `{"foo":2}`,
Op: `.foo += .foo`,
Expected: `{"foo":4}`,
},
"case164": {
In: `[{"a":1,"b":2}]`,
Op: `.[0].a |= {"old":., "new":(.+1)}`,
Expected: `[{"a":{"old":1, "new":2},"b":2}]`,
},
"case165": {
In: `[{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]`,
Op: `def inc(x): x |= .+1; inc(.[].a)`,
Expected: `[{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]`,
},
"case166": {
In: `[4]`,
Op: `.[2][3] = 1`,
Expected: `[4, null, [null, null, null, 1]]`,
},
"case167": {
In: `{"foo":[11], "bar":42}`,
Op: `.foo[2].bar = 1`,
Expected: `{"foo":[11,null,{"bar":1}], "bar":42}`,
},
"case168": {
In: `[{"a":0},{"a":1}]`,
Op: `try ((map(select(.a == 1))[].b) = 10) catch .`,
Expected: `"Invalid path expression near attempt to iterate through [{\"a\":1}]"`,
},
"case169": {
In: `[{"a":0},{"a":1}]`,
Op: `try ((map(select(.a == 1))[].a) |= .+1) catch .`,
Expected: `"Invalid path expression near attempt to iterate through [{\"a\":1}]"`,
},
"case170": {
In: `[0,1,2]`,
Op: `def x: .[1,2]; x=10`,
Expected: `[0,10,10]`,
},
"case171": {
In: `[0,1,2]`,
Op: `try (def x: reverse; x=10) catch .`,
Expected: `"Invalid path expression with result [2,1,0]"`,
},
"case172": {
In: `[1,null,Infinity,-Infinity,NaN,-NaN]`,
Op: `.[] = 1`,
Expected: `[1,1,1,1,1,1]`,
},
//
// Conditionals
//
"case173": {
In: `[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]`,
Op: `[.[] | if .foo then "yep" else "nope" end]`,
Expected: `["yep","yep","yep","yep","nope","nope","yep","nope"]`,
},
"case174": {
In: `[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]`,
Op: `[.[] | if .baz then "strange" elif .foo then "yep" else "nope" end]`,
Expected: `["yep","yep","yep","yep","nope","nope","yep","nope"]`,
},
"case175": {
In: `null`,
Op: `[if 1,null,2 then 3 else 4 end]`,
Expected: `[3,4,3]`,
},
"case176": {
In: `null`,
Op: `[if empty then 3 else 4 end]`,
Expected: `[]`,
},
"case177": {
In: `null`,
Op: `[if 1 then 3,4 else 5 end]`,
Expected: `[3,4]`,
},
"case178": {
In: `null`,
Op: `[if null then 3 else 5,6 end]`,
Expected: `[5,6]`,
},
"case179": {
In: `[{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]`,
Op: `[.[] | [.foo[] // .bar]]`,
Expected: `[[1,2], [1], [3], [42], [41]]`,
},
"case180": {
In: `["hello",true,false,[false],null]`,
Op: `.[] //= .[0]`,
Expected: `["hello",true,"hello",[false],"hello"]`,
},
"case181": {
In: `[[true,[]], [false,1], [42,null], [null,false]]`,
Op: `.[] | [.[0] and .[1], .[0] or .[1]]`,
Expected: `[true,true]`,
},
"case182": {
In: `[1,0,false,null,true,"hello"]`,
Op: `[.[] | not]`,
Expected: `[false,false,true,true,false,false]`,
},
// Check numeric comparison binops
"case183": {
In: `{}`,
Op: `[10 > 0, 10 > 10, 10 > 20, 10 < 0, 10 < 10, 10 < 20]`,
Expected: `[true,false,false,false,false,true]`,
},
"case184": {
In: `{}`,
Op: `[10 >= 0, 10 >= 10, 10 >= 20, 10 <= 0, 10 <= 10, 10 <= 20]`,
Expected: `[true,true,false,false,true,true]`,
},
// And some in/equality tests
"case185": {
In: `{}`,
Op: `[ 10 == 10, 10 != 10, 10 != 11, 10 == 11]`,
Expected: `[true,false,true,false]`,
},
"case186": {
In: `{}`,
Op: `["hello" == "hello", "hello" != "hello", "hello" == "world", "hello" != "world" ]`,
Expected: `[true,false,false,true]`,
},
"case187": {
In: `{}`,
Op: `[[1,2,3] == [1,2,3], [1,2,3] != [1,2,3], [1,2,3] == [4,5,6], [1,2,3] != [4,5,6]]`,
Expected: `[true,false,false,true]`,
},
"case188": {
In: `{}`,
Op: `[{"foo":42} == {"foo":42},{"foo":42} != {"foo":42}, {"foo":42} != {"bar":42}, {"foo":42} == {"bar":42}]`,
Expected: `[true,false,true,false]`,
},
// ugly complicated thing
"case189": {
In: `{}`,
Op: `[{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":18},"world"]},{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":19},"world"]}]`,
Expected: `[true,false]`,
},
// containment operator
"case190": {
In: `{}`,
Op: `[("foo" | contains("foo")), ("foobar" | contains("foo")), ("foo" | contains("foobar"))]`,
Expected: `[true, true, false]`,
},
// Try/catch and general `?` operator
"case191": {
In: `[0,1,2,3]`,
Op: `[.[]|try if . == 0 then error("foo") elif . == 1 then .a elif . == 2 then empty else . end catch .]`,
Expected: `["foo","Cannot index number with string \"a\"",3]`,
},
"case192": {
In: `[null,true,{"a":1}]`,
Op: `[.[]|(.a, .a)?]`,
Expected: `[null,null,1,1]`,
},
"case193": {
In: `[null,true,{"a":1}]`,
Op: `[[.[]|[.a,.a]]?]`,
Expected: `[]`,
},
"case194": {
In: `null`,
Op: `try error("\($__loc__)") catch .`,
Expected: `"{\"file\":\"\",\"line\":1}"`,
},
// string operations
"case195": {
In: `["fo", "foo", "barfoo", "foobar", "barfoob"]`,
Op: `[.[]|startswith("foo")]`,
Expected: `[false, true, false, true, false]`,
},
"case196": {
In: `["fo", "foo", "barfoo", "foobar", "barfoob"]`,
Op: `[.[]|endswith("foo")]`,
Expected: `[false, true, true, false, false]`,
},
"case197": {
In: `["a,b, c, d, e,f",", a,b, c, d, e,f, "]`,
Op: `[.[] | split(", ")]`,
Expected: `[["a,b","c","d","e,f"],["","a,b","c","d","e,f",""]]`,
},
"case198": {
In: `"abc"`,
Op: `split("")`,
Expected: `["a","b","c"]`,
},
"case199": {
In: `["fo", "foo", "barfoo", "foobar", "afoo"]`,
Op: `[.[]|ltrimstr("foo")]`,
Expected: `["fo","","barfoo","bar","afoo"]`,
},
"case200": {
In: `["fo", "foo", "barfoo", "foobar", "foob"]`,
Op: `[.[]|rtrimstr("foo")]`,
Expected: `["fo","","bar","foobar","foob"]`,
},
"case201": {
In: `"a,bc,def,ghij,klmno"`,
Op: `[(index(","), rindex(",")), indices(",")]`,
Expected: `[1,13,[1,4,8,13]]`,
},
"case202": {
In: `[0,1,1,2,3,4,1,5]`,
Op: `indices(1)`,
Expected: `[1,2,6]`,
},
"case203": {
In: `[0,1,2,3,1,4,2,5,1,2,6,7]`,
Op: `indices([1,2])`,
Expected: `[1,8]`,
},
"case204": {
In: `[1]`,
Op: `indices([1,2])`,
Expected: `[]`,
},
"case205": {
In: `"a,b, cd,e, fgh, ijkl"`,
Op: `indices(", ")`,
Expected: `[3,9,14]`,
},
"case206": {
In: `["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]`,
Op: `[.[]|split(",")]`,
Expected: `[["a"," bc"," def"," ghij"," jklmn"," a","b"," c","d"," e","f"],["a","b","c","d"," e","f","g","h"]]`,
},
"case207": {
In: `["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]`,
Op: `[.[]|split(", ")]`,
Expected: `[["a","bc","def","ghij","jklmn","a,b","c,d","e,f"],["a,b,c,d","e,f,g,h"]]`,
},
"case208": {
In: `["a", "ab", "abc"]`,
Op: `[.[] * 3]`,
Expected: `["aaa", "ababab", "abcabcabc"]`,
},
"case209": {
In: `["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]`,
Op: `[.[] / ","]`,
Expected: `[["a"," bc"," def"," ghij"," jklmn"," a","b"," c","d"," e","f"],["a","b","c","d"," e","f","g","h"]]`,
},
"case210": {
In: `["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]`,
Op: `[.[] / ", "]`,
Expected: `[["a","bc","def","ghij","jklmn","a,b","c,d","e,f"],["a,b,c,d","e,f,g,h"]]`,
},
"case211": {
In: `[[[],[]], [[1,2,3], [1,2]], [[1,2,3], [3,1]], [[1,2,3], [4]], [[1,2,3], [1,4]]]`,
Op: `map(.[1] as $needle | .[0] | contains($needle))`,
Expected: `[true, true, true, false, false]`,
},
"case212": {
In: `[[["foobar", "foobaz"], ["baz", "bar"]], [["foobar", "foobaz"], ["foo"]], [["foobar", "foobaz"], ["blap"]]]`,
Op: `map(.[1] as $needle | .[0] | contains($needle))`,
Expected: `[true, true, false]`,
},
"case213": {
In: `{}`,
Op: `[({foo: 12, bar:13} | contains({foo: 12})), ({foo: 12} | contains({})), ({foo: 12, bar:13} | contains({baz:14}))]`,
Expected: `[true, true, false]`,
},
"case214": {
In: `{}`,
Op: `{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {}}})`,
Expected: `true`,
},
"case215": {
In: `{}`,
Op: `{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {bar: 14}}})`,
Expected: `false`,
},
"case216": {
In: `[42,[2,5,3,11],10,{"a":42,"b":2},{"a":42},true,2,[2,6],"hello",null,[2,5,6],{"a":[],"b":1},"abc","ab",[3,10],{},false,"abcd",null]`,
Op: `sort`,
Expected: `[null,null,false,true,2,10,42,"ab","abc","abcd","hello",[2,5,3,11],[2,5,6],[2,6],[3,10],{},{"a":42},{"a":42,"b":2},{"a":[],"b":1}]`,
},
"case217": {
In: `[{"a": 1, "b": 4, "c": 14}, {"a": 4, "b": 1, "c": 3}, {"a": 1, "b": 4, "c": 3}, {"a": 0, "b": 2, "c": 43}]`,
Op: `(sort_by(.b) | sort_by(.a)), sort_by(.a, .b), sort_by(.b, .c), group_by(.b), group_by(.a + .b - .c == 2)`,
Expected: `[{"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}, {"a": 4, "b": 1, "c": 3}]`,
},
"case218": {
In: `[1,2,5,3,5,3,1,3]`,
Op: `unique`,
Expected: `[1,2,3,5]`,
},
"case219": {
In: `[]`,
Op: `unique`,
Expected: `[]`,
},
"case220": {
In: `[[4,2,"a"],[3,1,"a"],[2,4,"a"],[1,3,"a"]]`,
Op: `[min, max, min_by(.[1]), max_by(.[1]), min_by(.[2]), max_by(.[2])]`,
Expected: `[[1,3,"a"],[4,2,"a"],[3,1,"a"],[2,4,"a"],[4,2,"a"],[1,3,"a"]]`,
},
"case221": {
In: `[]`,
Op: `[min,max,min_by(.),max_by(.)]`,
Expected: `[null,null,null,null]`,
},
"case222": {
In: `{"foo":{"bar":4},"baz":"bar"}`,
Op: `.foo[.baz]`,
Expected: `4`,
},
"case223": {
In: `[{"error":true}]`,
Op: `.[] | .error = "no, it's OK"`,
Expected: `map[error:no, it's OK]`,
},
"case224": {
In: `null`,
Op: `[{a:1}] | .[] | .a=999`,
Expected: `{"a": 999}`,
},
"case225": {
In: `{"a": 1, "b": 2}`,
Op: `to_entries`,
Expected: `[{"key":"a", "value":1}, {"key":"b", "value":2}]`,
},
"case226": {
In: `[{"key":"a", "value":1}, {"Key":"b", "Value":2}, {"name":"c", "value":3}, {"Name":"d", "Value":4}]`,
Op: `from_entries`,
Expected: `{"a": 1, "b": 2, "c": 3, "d": 4}`,
},
"case227": {
In: `{"a": 1, "b": 2}`,
Op: `with_entries(.key |= "KEY_" + .)`,
Expected: `{"KEY_a": 1, "KEY_b": 2}`,
},
"case228": {
In: `[{"foo": 42}, {}]`,
Op: `map(has("foo"))`,
Expected: `[true, false]`,
},
"case229": {
In: `[[0,1], ["a","b","c"]]`,
Op: `map(has(2))`,
Expected: `[false, true]`,
},
"case230": {
In: `[42,3,35]`,
Op: `keys`,
Expected: `[0,1,2]`,
},
"case231": {
In: `1000000000000000000`,
Op: `[][.]`,
Expected: `null`,
},
"case232": {
In: `[-1, 1, 2, 3, 1000000000000000000]`,
Op: `map([1,2][0:.])`,
Expected: `[[1], [1], [1,2], [1,2], [1,2]]`,
},
// Test recursive object merge
"case233": {
In: `{"k": {"a": 0,"c": 3}}`,
Op: `{"k": {"a": 1, "b": 2}} * .`,
Expected: `{"k": {"a": 0, "b": 2, "c": 3}}`,
},
"case234": {
In: `{"k": {"a": 0,"c": 3}, "hello": 1}`,
Op: `{"k": {"a": 1, "b": 2}, "hello": {"x": 1}} * .`,
Expected: `{"k": {"a": 0, "b": 2, "c": 3}, "hello": 1}`,
},
"case235": {
In: `{"k": {"a": 0,"c": 3}, "hello": {"x": 1}}`,
Op: `{"k": {"a": 1, "b": 2}, "hello": 1} * .`,
Expected: `{"k": {"a": 0, "b": 2, "c": 3}, "hello": {"x": 1}}`,
},
"case236": {
In: `{"a": {"b": 2}, "c": {"d": 3, "f": 9}}`,
Op: `{"a": {"b": 1}, "c": {"d": 2}, "e": 5} * .`,
Expected: `{"a": {"b": 2}, "c": {"d": 3, "f": 9}, "e": 5}`,
},
"case237": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|arrays]`,
Expected: `[[],[3,[]]]`,
},
"case238": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|objects]`,
Expected: `[{}]`,
},
"case239": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|iterables]`,
Expected: `[[],[3,[]],{}]`,
},
"case240": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|scalars]`,
Expected: `[1,2,"foo",true,false,null]`,
},
"case241": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|values]`,
Expected: `[1,2,"foo",[],[3,[]],{},true,false]`,
},
"case242": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|booleans]`,
Expected: `[true,false]`,
},
"case243": {
In: `[1,2,"foo",[],[3,[]],{},true,false,null]`,
Op: `[.[]|nulls]`,
Expected: `[null]`,
},
"case244": {
In: `[0, [1], [[2]], [[[3]]]]`,
Op: `flatten`,
Expected: `[0, 1, 2, 3]`,
},
"case245": {
In: `[0, [1], [[2]], [[[3]]]]`,
Op: `flatten(0)`,
Expected: `[0, [1], [[2]], [[[3]]]]`,
},
"case246": {
In: `[0, [1], [[2]], [[[3]]]]`,
Op: `flatten(2)`,
Expected: `[0, 1, 2, [3]]`,
},
"case247": {
In: `[0, [1, [2]], [1, [[3], 2]]]`,
Op: `flatten(2)`,
Expected: `[0, 1, 2, 1, [3], 2]`,
},
"case248": {
In: `[0, [1], [[2]], [[[3]]]]`,
Op: `try flatten(-1) catch .`,
Expected: `"flatten depth must not be negative"`,
},
"case249": {
In: `[[1], [2,3]]`,
Op: `transpose`,
Expected: `[[1,2],[null,3]]`,
},
"case250": {
In: `"useful but not for é"`,
Op: `ascii_upcase`,
Expected: `"USEFUL BUT NOT FOR é"`,
},
"case251": {
In: `[1,2,3]`,
Op: `bsearch(4)`,
Expected: `-4`,
},
// strptime tests are in optional.test
"case252": {
In: `[2015,2,5,23,51,47,4,63]`,
Op: `strftime("%Y-%m-%dT%H:%M:%SZ")`,
Expected: `"2015-03-05T23:51:47Z"`,
},
"case253": {
In: `1435677542.822351`,
Op: `strftime("%A, %B %d, %Y")`,
Expected: `"Tuesday, June 30, 2015"`,
},
"case254": {
In: `1425599507`,
Op: `gmtime`,
Expected: `[2015,2,5,23,51,47,4,63]`,
},
// module system
"case255": {
In: `null`,
Op: `import "a" as foo; import "b" as bar; def fooa: foo::a; [fooa, bar::a, bar::b, foo::a]`,
Expected: `["a","b","c","a"]`,
},
"case256": {
In: `null`,
Op: `import "c" as foo; [foo::a, foo::c]`,
Expected: `[0,"acmehbah"]`,
},
"case257": {
In: `null`,
Op: `include "c"; [a, c]`,
Expected: `[0,"acmehbah"]`,
},
"case258": {
In: `"c"`,
Op: `modulemeta`,
Expected: `{"whatever":null,"deps":[{"as":"foo","is_data":false,"relpath":"a"},{"search":"./","as":"d","is_data":false,"relpath":"d"},{"search":"./","as":"d2","is_data":false,"relpath":"d"},{"search":"./../lib/jq","as":"e","is_data":false,"relpath":"e"},{"search":"./../lib/jq","as":"f","is_data":false,"relpath":"f"},{"as":"d","is_data":true,"relpath":"data"}]}`,
},
"case259": {
In: `null`,
Op: `import "test_bind_order" as check; check::check`,
Expected: `true`,
},
"case260": {
In: `"very-long-string"`,
Op: `try -. catch .`,
Expected: `"string (\"very-long-...) cannot be negated"`,
},
"case261": {
In: `["1",2,true,false,3.4]`,
Op: `join(",")`,
Expected: `"1,2,true,false,3.4"`,
},
"case262": {
In: `[[], [null], [null,null], [null,null,null]]`,
Op: `.[] | join(",")`,
Expected: `""`,
},
"case263": {
In: `[["a",null], [null,"a"]]`,
Op: `.[] | join(",")`,
Expected: `"a,"`,
},
"case264": {
In: `["1","2",{"a":{"b":{"c":33}}}]`,
Op: `try join(",") catch .`,
Expected: `"string (\"1,2,\") and object ({\"a\":{\"b\":{...) cannot be added"`,
},
"case265": {
In: `["1","2",[3,4,5]]`,
Op: `try join(",") catch .`,
Expected: `"string (\"1,2,\") and array ([3,4,5]) cannot be added"`,
},
"case266": {
In: `null`,
Op: `{if:0,and:1,or:2,then:3,else:4,elif:5,end:6,as:7,def:8,reduce:9,foreach:10,try:11,catch:12,label:13,import:14,include:15,module:16}`,
Expected: `{"if":0,"and":1,"or":2,"then":3,"else":4,"elif":5,"end":6,"as":7,"def":8,"reduce":9,"foreach":10,"try":11,"catch":12,"label":13,"import":14,"include":15,"module":16}`,
},
"case267": {
In: `0`,
Op: `try (1/.) catch .`,
Expected: `"number (1) and number (0) cannot be divided because the divisor is zero"`,
},
"case268": {
In: `0`,
Op: `try (1%.) catch .`,
Expected: `"number (1) and number (0) cannot be divided (remainder) because the divisor is zero"`,
},
// Basic numbers tests: integers, powers of two
"case269": {
In: `null`,
Op: `[range(-52;52;1)] as $powers | [$powers[]|pow(2;.)|log2] == $powers`,
Expected: `true`,
},
"case270": {
In: `null`,
Op: `[range(-99/2;99/2;1)] as $orig | [$orig[]|pow(2;.)|log2] as $back | ($orig|keys)[]|. as $k | (($orig|.[$k])-($back|.[$k]))|if . < 0 then . * -1 else . end|select(.>.00005)`,
Expected: ``,
},
"case271": {
In: `null`,
Op: `(.[{}] = 0)?`,
Expected: ``,
},
}
for label, tc := range testCases {
t.Run(label, func(t *testing.T) {
op, err := jq.Parse(tc.Op)
if err != nil {
t.FailNow()
}
data, err := op.Apply([]byte(tc.In))
if tc.HasError {
if err == nil {
t.FailNow()
}
} else {
if string(data) != tc.Expected {
t.FailNow()
}
if err != nil {
t.FailNow()
}
}
})
}
}
easygen-4.1.0/test/jq-test_1.y0 0000664 0000000 0000000 00000001517 13502324010 0016201 0 ustar 00root root 0000000 0000000 # Test cases Copyright (c) 2016 of project
# https://github.com/stedolan/jq
# Test cases converted to YAML format by
# Tong Sun Copyright (c) 2016
# https://github.com/go-easygen/easygen
# To update,
# cp jq-test_1.y0 jq-test_1.yaml
# curl -s https://raw.githubusercontent.com/stedolan/jq/master/tests/jq.test | tr -d '\015' | sed '/^#/s/$/\n/' | perl -n0000e 'if (/^ *#/) { s|^ *# *||; print " - Comment:\n Str: $_" } elsif (/jq: error: |byte order mark/) { next; } else { @tc= split /\n/, $_; print " - TestCase:\n Name: case". ++$i. "\n Op: $tc[0]\n In: $tc[1]\n Out: $tc[2]\n\n" }' | sed -r "/^ Str: .*'/s/'//g; /^ Str: |^ (Op|In|Out): [^']*$/{ s/((Str|Op|In|Out): )/\1'/; s/\$/'/; }" >> jq-test_1.yaml
# easygen -tf jq-test_jq jq-test_1 | sed 's|// *$|//|' | gofmt > jq-test_1.go_
Cases:
easygen-4.1.0/test/jq-test_1.yaml 0000664 0000000 0000000 00000127440 13502324010 0016617 0 ustar 00root root 0000000 0000000 # Test cases Copyright (c) 2016 of project
# https://github.com/stedolan/jq
# Test cases converted to YAML format by
# Tong Sun Copyright (c) 2016
# https://github.com/go-easygen/easygen
# To update,
# cp jq-test_1.y0 jq-test_1.yaml
# curl -s https://raw.githubusercontent.com/stedolan/jq/master/tests/jq.test | tr -d '\015' | sed '/^#/s/$/\n/' | perl -n0000e 'if (/^ *#/) { s|^ *# *||; print " - Comment:\n Str: $_" } elsif (/jq: error: |byte order mark/) { next; } else { @tc= split /\n/, $_; print " - TestCase:\n Name: case". ++$i. "\n Op: $tc[0]\n In: $tc[1]\n Out: $tc[2]\n\n" }' | sed -r "/^ Str: .*'/s/'//g; /^ Str: |^ (Op|In|Out): [^']*$/{ s/((Str|Op|In|Out): )/\1'/; s/\$/'/; }" >> jq-test_1.yaml
# easygen -tf jq-test_jq jq-test_1 | sed 's|// *$|//|' | gofmt > jq-test_1.go_
Cases:
- Comment:
Str: 'Tests are groups of three lines: program, input, expected output'
- Comment:
Str: 'Blank lines and lines starting with # are ignored'
- Comment:
Str: ''
- Comment:
Str: 'Simple value tests to check parser. Input is irrelevant'
- Comment:
Str: ''
- TestCase:
Name: case1
Op: 'true'
In: 'null'
Out: 'true'
- TestCase:
Name: case2
Op: 'false'
In: 'null'
Out: 'false'
- TestCase:
Name: case3
Op: 'null'
In: '42'
Out: 'null'
- TestCase:
Name: case4
Op: '1'
In: 'null'
Out: '1'
- TestCase:
Name: case5
Op: '-1'
In: 'null'
Out: '-1'
- Comment:
Str: 'FIXME: much more number testing needed'
- TestCase:
Name: case6
Op: '{}'
In: 'null'
Out: '{}'
- TestCase:
Name: case7
Op: '[]'
In: 'null'
Out: '[]'
- TestCase:
Name: case8
Op: '{x: -1}'
In: 'null'
Out: '{"x": -1}'
- Comment:
Str: 'The input line starts with a 0xFEFF (byte order mark) codepoint'
- Comment:
Str: 'No, there is no reason to have a byte order mark in UTF8 text.'
- Comment:
Str: 'But apparently people do, so jq shouldnt break on it.'
- Comment:
Str: 'We test escapes by matching them against Unicode codepoints'
- Comment:
Str: 'FIXME: more tests needed for weird unicode stuff (e.g. utf16 pairs)'
- TestCase:
Name: case9
Op: '"Aa\r\n\t\b\f\u03bc"'
In: 'null'
Out: '"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"'
- TestCase:
Name: case10
Op: '.'
In: '"Aa\r\n\t\b\f\u03bc"'
Out: '"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"'
- TestCase:
Name: case11
Op: '"inter\("pol" + "ation")"'
In: 'null'
Out: '"interpolation"'
- TestCase:
Name: case12
Op: '@text,@json,([1,.] | (@csv, @tsv)),@html,@uri,@sh,@base64'
In: "<>&'\"\t"
Out: "<>&'\"\t"
- Comment:
Str: 'regression test for #436'
- TestCase:
Name: case13
Op: '@base64'
In: '"foóbar\n"'
Out: '"Zm/Ds2Jhcgo="'
- TestCase:
Name: case14
Op: '@uri'
In: '"\u03bc"'
Out: '"%CE%BC"'
- TestCase:
Name: case15
Op: '@html "\(.)"'
In: '""'
Out: '"<script>hax</script>"'
- TestCase:
Name: case16
Op: '[.[]|tojson|fromjson]'
In: '["foo", 1, ["a", 1, "b", 2, {"foo":"bar"}]]'
Out: '["foo",1,["a",1,"b",2,{"foo":"bar"}]]'
- Comment:
Str: ''
- Comment:
Str: 'Dictionary construction syntax'
- Comment:
Str: ''
- TestCase:
Name: case17
Op: '{a: 1}'
In: 'null'
Out: '{"a":1}'
- TestCase:
Name: case18
Op: '{a,b,(.d):.a,e:.b}'
In: '{"a":1, "b":2, "c":3, "d":"c"}'
Out: '{"a":1, "b":2, "c":1, "e":2}'
- TestCase:
Name: case19
Op: '{"a",b,"a$\(1+1)"}'
In: '{"a":1, "b":2, "c":3, "a$2":4}'
Out: '{"a":1, "b":2, "a$2":4}'
- Comment:
Str: ''
- Comment:
Str: 'Field access, piping'
- Comment:
Str: ''
- TestCase:
Name: case20
Op: '.foo'
In: '{"foo": 42, "bar": 43}'
Out: '42'
- TestCase:
Name: case21
Op: '.foo | .bar'
In: '{"foo": {"bar": 42}, "bar": "badvalue"}'
Out: '42'
- TestCase:
Name: case22
Op: '.foo.bar'
In: '{"foo": {"bar": 42}, "bar": "badvalue"}'
Out: '42'
- TestCase:
Name: case23
Op: '.foo_bar'
In: '{"foo_bar": 2}'
Out: '2'
- TestCase:
Name: case24
Op: '.["foo"].bar'
In: '{"foo": {"bar": 42}, "bar": "badvalue"}'
Out: '42'
- TestCase:
Name: case25
Op: '."foo"."bar"'
In: '{"foo": {"bar": 20}}'
Out: '20'
- TestCase:
Name: case26
Op: '[.[]|.foo?]'
In: '[1,[2],{"foo":3,"bar":4},{},{"foo":5}]'
Out: '[3,null,5]'
- TestCase:
Name: case27
Op: '[.[]|.foo?.bar?]'
In: '[1,[2],[],{"foo":3},{"foo":{"bar":4}},{}]'
Out: '[4,null]'
- TestCase:
Name: case28
Op: '[..]'
In: '[1,[[2]],{ "a":[1]}]'
Out: '[[1,[[2]],{"a":[1]}],1,[[2]],[2],2,{"a":[1]},[1],1]'
- TestCase:
Name: case29
Op: '[.[]|.[]?]'
In: '[1,null,[],[1,[2,[[3]]]],[{}],[{"a":[1,[2]]}]]'
Out: '[1,[2,[[3]]],{},{"a":[1,[2]]}]'
- TestCase:
Name: case30
Op: '[.[]|.[1:3]?]'
In: '[1,null,true,false,"abcdef",{},{"a":1,"b":2},[],[1,2,3,4,5],[1,2]]'
Out: '[null,"bc",[],[2,3],[2]]'
- Comment:
Str: ''
- Comment:
Str: 'Negative array indices'
- Comment:
Str: ''
- TestCase:
Name: case31
Op: 'try (.foo[-1] = 0) catch .'
In: 'null'
Out: '"Out of bounds negative array index"'
- TestCase:
Name: case32
Op: 'try (.foo[-2] = 0) catch .'
In: 'null'
Out: '"Out of bounds negative array index"'
- TestCase:
Name: case33
Op: '.[-1] = 5'
In: '[0,1,2]'
Out: '[0,1,5]'
- TestCase:
Name: case34
Op: '.[-2] = 5'
In: '[0,1,2]'
Out: '[0,5,2]'
- Comment:
Str: ''
- Comment:
Str: 'Multiple outputs, iteration'
- Comment:
Str: ''
- TestCase:
Name: case35
Op: '.[]'
In: '[1,2,3]'
Out: '1'
- TestCase:
Name: case36
Op: '1,1'
In: '[]'
Out: '1'
- TestCase:
Name: case37
Op: '1,.'
In: '[]'
Out: '1'
- TestCase:
Name: case38
Op: '[.]'
In: '[2]'
Out: '[[2]]'
- TestCase:
Name: case39
Op: '[[2]]'
In: '[3]'
Out: '[[2]]'
- TestCase:
Name: case40
Op: '[{}]'
In: '[2]'
Out: '[{}]'
- TestCase:
Name: case41
Op: '[.[]]'
In: '["a"]'
Out: '["a"]'
- TestCase:
Name: case42
Op: '[(.,1),((.,.[]),(2,3))]'
In: '["a","b"]'
Out: '[["a","b"],1,["a","b"],"a","b",2,3]'
- TestCase:
Name: case43
Op: '[([5,5][]),.,.[]]'
In: '[1,2,3]'
Out: '[5,5,[1,2,3],1,2,3]'
- TestCase:
Name: case44
Op: '{x: (1,2)},{x:3} | .x'
In: 'null'
Out: '1'
- TestCase:
Name: case45
Op: '.[-2]'
In: '[1,2,3]'
Out: '2'
- TestCase:
Name: case46
Op: '[range(0;10)]'
In: 'null'
Out: '[0,1,2,3,4,5,6,7,8,9]'
- TestCase:
Name: case47
Op: '[range(0,1;3,4)]'
In: 'null'
Out: '[0,1,2, 0,1,2,3, 1,2, 1,2,3]'
- TestCase:
Name: case48
Op: '[range(0;10;3)]'
In: 'null'
Out: '[0,3,6,9]'
- TestCase:
Name: case49
Op: '[range(0;10;-1)]'
In: 'null'
Out: '[]'
- TestCase:
Name: case50
Op: '[range(0;-5;-1)]'
In: 'null'
Out: '[0,-1,-2,-3,-4]'
- TestCase:
Name: case51
Op: '[range(0,1;4,5;1,2)]'
In: 'null'
Out: '[0,1,2,3,0,2, 0,1,2,3,4,0,2,4, 1,2,3,1,3, 1,2,3,4,1,3]'
- TestCase:
Name: case52
Op: '[while(.<100; .*2)]'
In: '1'
Out: '[1,2,4,8,16,32,64]'
- TestCase:
Name: case53
Op: '[(label $here | .[] | if .>1 then break $here else . end), "hi!"]'
In: '[0,1,2]'
Out: '[0,1,"hi!"]'
- TestCase:
Name: case54
Op: '[(label $here | .[] | if .>1 then break $here else . end), "hi!"]'
In: '[0,2,1]'
Out: '[0,"hi!"]'
- TestCase:
Name: case55
Op: '[.[]|[.,1]|until(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]]'
In: '[1,2,3,4,5]'
Out: '[1,2,6,24,120]'
- TestCase:
Name: case56
Op: '[label $out | foreach .[] as $item ([3, null]; if .[0] < 1 then break $out else [.[0] -1, $item] end; .[1])]'
In: '[11,22,33,44,55,66,77,88,99]'
Out: '[11,22,33]'
- TestCase:
Name: case57
Op: '[foreach range(5) as $item (0; $item)]'
In: 'null'
Out: '[0,1,2,3,4]'
- TestCase:
Name: case58
Op: '[foreach .[] as [$i, $j] (0; . + $i - $j)]'
In: '[[2,1], [5,3], [6,4]]'
Out: '[1,3,5]'
- TestCase:
Name: case59
Op: '[foreach .[] as {a:$a} (0; . + $a; -.)]'
In: '[{"a":1}, {"b":2}, {"a":3, "b":4}]'
Out: '[-1, -1, -4]'
- TestCase:
Name: case60
Op: '[limit(3; .[])]'
In: '[11,22,33,44,55,66,77,88,99]'
Out: '[11,22,33]'
- TestCase:
Name: case61
Op: '[first(range(.)), last(range(.)), nth(0; range(.)), nth(5; range(.)), try nth(-1; range(.)) catch .]'
In: '10'
Out: [0,9,0,5,"nth doesn't support negative indices"]
- Comment:
Str: ''
- Comment:
Str: 'Check that various builtins evalute all arguments where appropriate,'
- Comment:
Str: 'doing cartesian products where appropriate.'
- Comment:
Str: ''
- Comment:
Str: 'Check that limit does work for each value produced by n!'
- TestCase:
Name: case62
Op: '[limit(5,7; range(9))]'
In: 'null'
Out: '[0,1,2,3,4,0,1,2,3,4,5,6]'
- Comment:
Str: 'Same check for nth'
- TestCase:
Name: case63
Op: '[nth(5,7; range(9;0;-1))]'
In: 'null'
Out: '[4,2]'
- Comment:
Str: 'Same check for range/3'
- TestCase:
Name: case64
Op: '[range(0,1,2;4,3,2;2,3)]'
In: 'null'
Out: '[0,2,0,3,0,2,0,0,0,1,3,1,1,1,1,1,2,2,2,2]'
- Comment:
Str: 'Same check for range/1'
- TestCase:
Name: case65
Op: '[range(3,5)]'
In: 'null'
Out: '[0,1,2,0,1,2,3,4]'
- Comment:
Str: 'Same check for index/1, rindex/1, indices/1'
- TestCase:
Name: case66
Op: '[(index(",","|"), rindex(",","|")), indices(",","|")]'
In: '"a,b|c,d,e||f,g,h,|,|,i,j"'
Out: '[1,3,22,19,[1,5,7,12,14,16,18,20,22],[3,9,10,17,19]]'
- Comment:
Str: 'Same check for join/1'
- TestCase:
Name: case67
Op: 'join(",","/")'
In: '["a","b","c","d"]'
Out: '"a,b,c,d"'
- TestCase:
Name: case68
Op: '[.[]|join("a")]'
In: '[[],[""],["",""],["","",""]]'
Out: '["","","a","aa"]'
- Comment:
Str: 'Same check for flatten/1'
- TestCase:
Name: case69
Op: 'flatten(3,2,1)'
In: '[0, [1], [[2]], [[[3]]]]'
Out: '[0,1,2,3]'
- Comment:
Str: ''
- Comment:
Str: 'Slices'
- Comment:
Str: ''
- TestCase:
Name: case70
Op: '[.[3:2], .[-5:4], .[:-2], .[-2:], .[3:3][1:], .[10:]]'
In: '[0,1,2,3,4,5,6]'
Out: '[[], [2,3], [0,1,2,3,4], [5,6], [], []]'
- TestCase:
Name: case71
Op: '[.[3:2], .[-5:4], .[:-2], .[-2:], .[3:3][1:], .[10:]]'
In: '"abcdefghi"'
Out: '["","","abcdefg","hi","",""]'
- TestCase:
Name: case72
Op: 'del(.[2:4],.[0],.[-2:])'
In: '[0,1,2,3,4,5,6,7]'
Out: '[1,4,5]'
- TestCase:
Name: case73
Op: '.[2:4] = ([], ["a","b"], ["a","b","c"])'
In: '[0,1,2,3,4,5,6,7]'
Out: '[0,1,4,5,6,7]'
- Comment:
Str: ''
- Comment:
Str: 'Variables'
- Comment:
Str: ''
- TestCase:
Name: case74
Op: '1 as $x | 2 as $y | [$x,$y,$x]'
In: 'null'
Out: '[1,2,1]'
- TestCase:
Name: case75
Op: '[1,2,3][] as $x | [[4,5,6,7][$x]]'
In: 'null'
Out: '[5]'
- TestCase:
Name: case76
Op: '42 as $x | . | . | . + 432 | $x + 1'
In: '34324'
Out: '43'
- TestCase:
Name: case77
Op: '1 as $x | [$x,$x,$x as $x | $x]'
In: 'null'
Out: '[1,1,1]'
- TestCase:
Name: case78
Op: '[1, {c:3, d:4}] as [$a, {c:$b, b:$c}] | $a, $b, $c'
In: 'null'
Out: '1'
- TestCase:
Name: case79
Op: '. as {as: $kw, "str": $str, ("e"+"x"+"p"): $exp} | [$kw, $str, $exp]'
In: '{"as": 1, "str": 2, "exp": 3}'
Out: '[1, 2, 3]'
- TestCase:
Name: case80
Op: '.[] as [$a, $b] | [$b, $a]'
In: '[[1], [1, 2, 3]]'
Out: '[null, 1]'
- TestCase:
Name: case81
Op: '. as $i | . as [$i] | $i'
In: '[0]'
Out: '0'
- TestCase:
Name: case82
Op: '. as [$i] | . as $i | $i'
In: '[0]'
Out: '[0]'
- Comment:
Str: '[.,(.[] | {x:.},.),.,.[]]'
- Comment:
Str: ''
- Comment:
Str: 'Builtin functions'
- Comment:
Str: ''
- TestCase:
Name: case83
Op: '1+1'
In: 'null'
Out: '2'
- TestCase:
Name: case84
Op: '1+1'
In: '"wtasdf"'
Out: '2.0'
- TestCase:
Name: case85
Op: '2-1'
In: 'null'
Out: '1'
- TestCase:
Name: case86
Op: '2-(-1)'
In: 'null'
Out: '3'
- TestCase:
Name: case87
Op: '1e+0+0.001e3'
In: '"I wonder what this will be?"'
Out: '20e-1'
- TestCase:
Name: case88
Op: '.+4'
In: '15'
Out: '19.0'
- TestCase:
Name: case89
Op: '.+null'
In: '{"a":42}'
Out: '{"a":42}'
- TestCase:
Name: case90
Op: 'null+.'
In: 'null'
Out: 'null'
- TestCase:
Name: case91
Op: '.a+.b'
In: '{"a":42}'
Out: '42'
- TestCase:
Name: case92
Op: '[1,2,3] + [.]'
In: 'null'
Out: '[1,2,3,null]'
- TestCase:
Name: case93
Op: '{"a":1} + {"b":2} + {"c":3}'
In: '"asdfasdf"'
Out: '{"a":1, "b":2, "c":3}'
- TestCase:
Name: case94
Op: '"asdf" + "jkl;" + . + . + .'
In: '"some string"'
Out: '"asdfjkl;some stringsome stringsome string"'
- TestCase:
Name: case95
Op: '"\u0000\u0020\u0000" + .'
In: '"\u0000\u0020\u0000"'
Out: '"\u0000 \u0000\u0000 \u0000"'
- TestCase:
Name: case96
Op: '42 - .'
In: '11'
Out: '31'
- TestCase:
Name: case97
Op: '[1,2,3,4,1] - [.,3]'
In: '1'
Out: '[2,4]'
- TestCase:
Name: case98
Op: '[10 * 20, 20 / .]'
In: '4'
Out: '[200, 5]'
- TestCase:
Name: case99
Op: '1 + 2 * 2 + 10 / 2'
In: 'null'
Out: '10'
- TestCase:
Name: case100
Op: '[16 / 4 / 2, 16 / 4 * 2, 16 - 4 - 2, 16 - 4 + 2]'
In: 'null'
Out: '[2, 8, 10, 14]'
- TestCase:
Name: case101
Op: '25 % 7'
In: 'null'
Out: '4'
- TestCase:
Name: case102
Op: '49732 % 472'
In: 'null'
Out: '172'
- TestCase:
Name: case103
Op: '1 + tonumber + ("10" | tonumber)'
In: '4'
Out: '15'
- TestCase:
Name: case104
Op: '[{"a":42},.object,10,.num,false,true,null,"b",[1,4]] | .[] as $x | [$x == .[]]'
In: '{"object": {"a":42}, "num":10.0}'
Out: '[true, true, false, false, false, false, false, false, false]'
- TestCase:
Name: case105
Op: '[.[] | length]'
In: '[[], {}, [1,2], {"a":42}, "asdf", "\u03bc"]'
Out: '[0, 0, 2, 1, 4, 1]'
- TestCase:
Name: case106
Op: 'utf8bytelength'
In: '"asdf\u03bc"'
Out: '6'
- TestCase:
Name: case107
Op: '[.[] | try utf8bytelength catch .]'
In: '[[], {}, [1,2], 55, true, false]'
Out: '["array ([]) only strings have UTF-8 byte length","object ({}) only strings have UTF-8 byte length","array ([1,2]) only strings have UTF-8 byte length","number (55) only strings have UTF-8 byte length","boolean (true) only strings have UTF-8 byte length","boolean (false) only strings have UTF-8 byte length"]'
- TestCase:
Name: case108
Op: 'map(keys)'
In: '[{}, {"abcd":1,"abc":2,"abcde":3}, {"x":1, "z": 3, "y":2}]'
Out: '[[], ["abc","abcd","abcde"], ["x","y","z"]]'
- TestCase:
Name: case109
Op: '[1,2,empty,3,empty,4]'
In: 'null'
Out: '[1,2,3,4]'
- TestCase:
Name: case110
Op: 'map(add)'
In: '[[], [1,2,3], ["a","b","c"], [[3],[4,5],[6]], [{"a":1}, {"b":2}, {"a":3}]]'
Out: '[null, 6, "abc", [3,4,5,6], {"a":3, "b": 2}]'
- TestCase:
Name: case111
Op: 'map_values(.+1)'
In: '[0,1,2]'
Out: '[1,2,3]'
- Comment:
Str: ''
- Comment:
Str: 'User-defined functions'
- Comment:
Str: 'Oh god.'
- Comment:
Str: ''
- TestCase:
Name: case112
Op: 'def f: . + 1; def g: def g: . + 100; f | g | f; (f | g), g'
In: '3.0'
Out: '106.0'
- TestCase:
Name: case113
Op: 'def f: (1000,2000); f'
In: '123412345'
Out: '1000'
- TestCase:
Name: case114
Op: 'def f(a;b;c;d;e;f): [a+1,b,c,d,e,f]; f(.[0];.[1];.[0];.[0];.[0];.[0])'
In: '[1,2]'
Out: '[2,2,1,1,1,1]'
- Comment:
Str: 'Test precedence of def vs |'
- TestCase:
Name: case115
Op: 'def a: 0; . | a'
In: 'null'
Out: '0'
- Comment:
Str: 'Many arguments'
- TestCase:
Name: case116
Op: 'def f(a;b;c;d;e;f;g;h;i;j): [j,i,h,g,f,e,d,c,b,a]; f(.[0];.[1];.[2];.[3];.[4];.[5];.[6];.[7];.[8];.[9])'
In: '[0,1,2,3,4,5,6,7,8,9]'
Out: '[9,8,7,6,5,4,3,2,1,0]'
- TestCase:
Name: case117
Op: '([1,2] + [4,5])'
In: '[1,2,3]'
Out: '[1,2,4,5]'
- TestCase:
Name: case118
Op: 'true'
In: '[1]'
Out: 'true'
- TestCase:
Name: case119
Op: 'null,1,null'
In: '"hello"'
Out: 'null'
- TestCase:
Name: case120
Op: '[1,2,3]'
In: '[5,6]'
Out: '[1,2,3]'
- TestCase:
Name: case121
Op: '[.[]|floor]'
In: '[-1.1,1.1,1.9]'
Out: '[-2, 1, 1]'
- TestCase:
Name: case122
Op: '[.[]|sqrt]'
In: '[4,9]'
Out: '[2,3]'
- TestCase:
Name: case123
Op: '(add / length) as $m | map((. - $m) as $d | $d * $d) | add / length | sqrt'
In: '[2,4,4,4,5,5,7,9]'
Out: '2'
- Comment:
Str: 'Should write a test that calls the -lm function from C (or bc(1)) to'
- Comment:
Str: 'check that they match the corresponding jq functions. However,'
- Comment:
Str: 'theres so little template code standing between that it suffices to'
- Comment:
Str: 'test a handful of these. The results were checked by eye against'
- Comment:
Str: 'bc(1).'
- TestCase:
Name: case124
Op: 'atan * 4 * 1000000|floor / 1000000'
In: '1'
Out: '3.141592'
- TestCase:
Name: case125
Op: '[(3.141592 / 2) * (range(0;20) / 20)|cos * 1000000|floor / 1000000]'
In: 'null'
Out: '[1,0.996917,0.987688,0.972369,0.951056,0.923879,0.891006,0.85264,0.809017,0.760406,0.707106,0.649448,0.587785,0.522498,0.45399,0.382683,0.309017,0.233445,0.156434,0.078459]'
- TestCase:
Name: case126
Op: '[(3.141592 / 2) * (range(0;20) / 20)|sin * 1000000|floor / 1000000]'
In: 'null'
Out: '[0,0.078459,0.156434,0.233445,0.309016,0.382683,0.45399,0.522498,0.587785,0.649447,0.707106,0.760405,0.809016,0.85264,0.891006,0.923879,0.951056,0.972369,0.987688,0.996917]'
- TestCase:
Name: case127
Op: 'def f(x): x | x; f([.], . + [42])'
In: '[1,2,3]'
Out: '[[[1,2,3]]]'
- Comment:
Str: 'test multiple function arities and redefinition'
- TestCase:
Name: case128
Op: 'def f: .+1; def g: f; def f: .+100; def f(a):a+.+11; [(g|f(20)), f]'
In: '1'
Out: '[33,101]'
- Comment:
Str: 'test closures and lexical scoping'
- TestCase:
Name: case129
Op: 'def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x | f($x,$x+x); g($x)'
In: '"more testing"'
Out: '[1,100,2100.0,100,2100.0]'
- Comment:
Str: 'test def f($a) syntax'
- TestCase:
Name: case130
Op: 'def x(a;b): a as $a | b as $b | $a + $b; def y($a;$b): $a + $b; def check(a;b): [x(a;b)] == [y(a;b)]; check(.[];.[]*2)'
In: '[1,2,3]'
Out: 'true'
- Comment:
Str: 'test backtracking through function calls and returns'
- Comment:
Str: 'this test is *evil*'
- TestCase:
Name: case131
Op: '[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]'
In: '999999999'
Out: '[[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]'
- Comment:
Str: 'test recursion'
- TestCase:
Name: case132
Op: 'def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]'
In: '[1,2,3,4]'
Out: '[1,2,6,24]'
- Comment:
Str: 'test stack overflow and reallocation'
- Comment:
Str: 'this test is disabled for now, it takes a realllllly long time.'
- Comment:
Str: 'def f: if length > 1000 then . else .+[1]|f end; f | length'
- Comment:
Str: '[]'
- Comment:
Str: '1001'
- TestCase:
Name: case133
Op: 'reduce .[] as $x (0; . + $x)'
In: '[1,2,4]'
Out: '7'
- TestCase:
Name: case134
Op: 'reduce .[] as [$i, {j:$j}] (0; . + $i - $j)'
In: '[[2,{"j":1}], [5,{"j":3}], [6,{"j":4}]]'
Out: '5'
- TestCase:
Name: case135
Op: 'reduce [[1,2,10], [3,4,10]][] as [$i,$j] (0; . + $i * $j)'
In: 'null'
Out: '14'
- TestCase:
Name: case136
Op: '. as $dot|any($dot[];not)'
In: '[1,2,3,4,true,false,1,2,3,4,5]'
Out: 'true'
- TestCase:
Name: case137
Op: '. as $dot|any($dot[];not)'
In: '[1,2,3,4,true]'
Out: 'false'
- TestCase:
Name: case138
Op: '. as $dot|all($dot[];.)'
In: '[1,2,3,4,true,false,1,2,3,4,5]'
Out: 'false'
- TestCase:
Name: case139
Op: '. as $dot|all($dot[];.)'
In: '[1,2,3,4,true]'
Out: 'true'
- Comment:
Str: ''
- Comment:
Str: 'Paths'
- Comment:
Str: ''
- TestCase:
Name: case140
Op: 'path(.foo[0,1])'
In: 'null'
Out: '["foo", 0]'
- TestCase:
Name: case141
Op: 'path(.[] | select(.>3))'
In: '[1,5,3]'
Out: '[1]'
- TestCase:
Name: case142
Op: 'path(.)'
In: '42'
Out: '[]'
- TestCase:
Name: case143
Op: 'try path(.a | map(select(.b == 0))) catch .'
In: '{"a":[{"b":0}]}'
Out: '"Invalid path expression with result [{\"b\":0}]"'
- TestCase:
Name: case144
Op: 'try path(.a | map(select(.b == 0)) | .[0]) catch .'
In: '{"a":[{"b":0}]}'
Out: '"Invalid path expression near attempt to access element 0 of [{\"b\":0}]"'
- TestCase:
Name: case145
Op: 'try path(.a | map(select(.b == 0)) | .c) catch .'
In: '{"a":[{"b":0}]}'
Out: '"Invalid path expression near attempt to access element \"c\" of [{\"b\":0}]"'
- TestCase:
Name: case146
Op: 'try path(.a | map(select(.b == 0)) | .[]) catch .'
In: '{"a":[{"b":0}]}'
Out: '"Invalid path expression near attempt to iterate through [{\"b\":0}]"'
- TestCase:
Name: case147
Op: 'path(.a[path(.b)[0]])'
In: '{"a":{"b":0}}'
Out: '["a","b"]'
- TestCase:
Name: case148
Op: '[paths]'
In: '[1,[[],{"a":2}]]'
Out: '[[0],[1],[1,0],[1,1],[1,1,"a"]]'
- TestCase:
Name: case149
Op: '[leaf_paths]'
In: '[1,[[],{"a":2}]]'
Out: '[[0],[1,1,"a"]]'
- TestCase:
Name: case150
Op: '["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])'
In: '{"bar": 42, "foo": ["a", "b", "c", "d"]}'
Out: '"b"'
- TestCase:
Name: case151
Op: 'map(getpath([2])), map(setpath([2]; 42)), map(delpaths([[2]]))'
In: '[[0], [0,1], [0,1,2]]'
Out: '[null, null, 2]'
- TestCase:
Name: case152
Op: 'map(delpaths([[0,"foo"]]))'
In: '[[{"foo":2, "x":1}], [{"bar":2}]]'
Out: '[[{"x":1}], [{"bar":2}]]'
- TestCase:
Name: case153
Op: '["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])'
In: '{"bar":false}'
Out: 'null'
- TestCase:
Name: case154
Op: 'delpaths([[-200]])'
In: '[1,2,3]'
Out: '[1,2,3]'
- TestCase:
Name: case155
Op: 'try delpaths(0) catch .'
In: '{}'
Out: '"Paths must be specified as an array"'
- TestCase:
Name: case156
Op: 'del(.), del(empty), del((.foo,.bar,.baz) | .[2,3,0]), del(.foo[0], .bar[0], .foo, .baz.bar[0].x)'
In: '{"foo": [0,1,2,3,4], "bar": [0,1]}'
Out: 'null'
- TestCase:
Name: case157
Op: 'del(.[1], .[-6], .[2], .[-3:9])'
In: '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
Out: '[0, 3, 5, 6, 9]'
- Comment:
Str: ''
- Comment:
Str: 'Assignment'
- Comment:
Str: ''
- TestCase:
Name: case158
Op: '.message = "goodbye"'
In: '{"message": "hello"}'
Out: '{"message": "goodbye"}'
- TestCase:
Name: case159
Op: '.foo = .bar'
In: '{"bar":42}'
Out: '{"foo":42, "bar":42}'
- TestCase:
Name: case160
Op: '.foo |= .+1'
In: '{"foo": 42}'
Out: '{"foo": 43}'
- TestCase:
Name: case161
Op: '.[] += 2, .[] *= 2, .[] -= 2, .[] /= 2, .[] %=2'
In: '[1,3,5]'
Out: '[3,5,7]'
- TestCase:
Name: case162
Op: '[.[] % 7]'
In: '[-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7]'
Out: '[0,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,0]'
- TestCase:
Name: case163
Op: '.foo += .foo'
In: '{"foo":2}'
Out: '{"foo":4}'
- TestCase:
Name: case164
Op: '.[0].a |= {"old":., "new":(.+1)}'
In: '[{"a":1,"b":2}]'
Out: '[{"a":{"old":1, "new":2},"b":2}]'
- TestCase:
Name: case165
Op: 'def inc(x): x |= .+1; inc(.[].a)'
In: '[{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]'
Out: '[{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]'
- TestCase:
Name: case166
Op: '.[2][3] = 1'
In: '[4]'
Out: '[4, null, [null, null, null, 1]]'
- TestCase:
Name: case167
Op: '.foo[2].bar = 1'
In: '{"foo":[11], "bar":42}'
Out: '{"foo":[11,null,{"bar":1}], "bar":42}'
- TestCase:
Name: case168
Op: 'try ((map(select(.a == 1))[].b) = 10) catch .'
In: '[{"a":0},{"a":1}]'
Out: '"Invalid path expression near attempt to iterate through [{\"a\":1}]"'
- TestCase:
Name: case169
Op: 'try ((map(select(.a == 1))[].a) |= .+1) catch .'
In: '[{"a":0},{"a":1}]'
Out: '"Invalid path expression near attempt to iterate through [{\"a\":1}]"'
- TestCase:
Name: case170
Op: 'def x: .[1,2]; x=10'
In: '[0,1,2]'
Out: '[0,10,10]'
- TestCase:
Name: case171
Op: 'try (def x: reverse; x=10) catch .'
In: '[0,1,2]'
Out: '"Invalid path expression with result [2,1,0]"'
- TestCase:
Name: case172
Op: '.[] = 1'
In: '[1,null,Infinity,-Infinity,NaN,-NaN]'
Out: '[1,1,1,1,1,1]'
- Comment:
Str: ''
- Comment:
Str: 'Conditionals'
- Comment:
Str: ''
- TestCase:
Name: case173
Op: '[.[] | if .foo then "yep" else "nope" end]'
In: '[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]'
Out: '["yep","yep","yep","yep","nope","nope","yep","nope"]'
- TestCase:
Name: case174
Op: '[.[] | if .baz then "strange" elif .foo then "yep" else "nope" end]'
In: '[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]'
Out: '["yep","yep","yep","yep","nope","nope","yep","nope"]'
- TestCase:
Name: case175
Op: '[if 1,null,2 then 3 else 4 end]'
In: 'null'
Out: '[3,4,3]'
- TestCase:
Name: case176
Op: '[if empty then 3 else 4 end]'
In: 'null'
Out: '[]'
- TestCase:
Name: case177
Op: '[if 1 then 3,4 else 5 end]'
In: 'null'
Out: '[3,4]'
- TestCase:
Name: case178
Op: '[if null then 3 else 5,6 end]'
In: 'null'
Out: '[5,6]'
- TestCase:
Name: case179
Op: '[.[] | [.foo[] // .bar]]'
In: '[{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]'
Out: '[[1,2], [1], [3], [42], [41]]'
- TestCase:
Name: case180
Op: '.[] //= .[0]'
In: '["hello",true,false,[false],null]'
Out: '["hello",true,"hello",[false],"hello"]'
- TestCase:
Name: case181
Op: '.[] | [.[0] and .[1], .[0] or .[1]]'
In: '[[true,[]], [false,1], [42,null], [null,false]]'
Out: '[true,true]'
- TestCase:
Name: case182
Op: '[.[] | not]'
In: '[1,0,false,null,true,"hello"]'
Out: '[false,false,true,true,false,false]'
- Comment:
Str: 'Check numeric comparison binops'
- TestCase:
Name: case183
Op: '[10 > 0, 10 > 10, 10 > 20, 10 < 0, 10 < 10, 10 < 20]'
In: '{}'
Out: '[true,false,false,false,false,true]'
- TestCase:
Name: case184
Op: '[10 >= 0, 10 >= 10, 10 >= 20, 10 <= 0, 10 <= 10, 10 <= 20]'
In: '{}'
Out: '[true,true,false,false,true,true]'
- Comment:
Str: 'And some in/equality tests'
- TestCase:
Name: case185
Op: '[ 10 == 10, 10 != 10, 10 != 11, 10 == 11]'
In: '{}'
Out: '[true,false,true,false]'
- TestCase:
Name: case186
Op: '["hello" == "hello", "hello" != "hello", "hello" == "world", "hello" != "world" ]'
In: '{}'
Out: '[true,false,false,true]'
- TestCase:
Name: case187
Op: '[[1,2,3] == [1,2,3], [1,2,3] != [1,2,3], [1,2,3] == [4,5,6], [1,2,3] != [4,5,6]]'
In: '{}'
Out: '[true,false,false,true]'
- TestCase:
Name: case188
Op: '[{"foo":42} == {"foo":42},{"foo":42} != {"foo":42}, {"foo":42} != {"bar":42}, {"foo":42} == {"bar":42}]'
In: '{}'
Out: '[true,false,true,false]'
- Comment:
Str: 'ugly complicated thing'
- TestCase:
Name: case189
Op: '[{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":18},"world"]},{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":19},"world"]}]'
In: '{}'
Out: '[true,false]'
- Comment:
Str: 'containment operator'
- TestCase:
Name: case190
Op: '[("foo" | contains("foo")), ("foobar" | contains("foo")), ("foo" | contains("foobar"))]'
In: '{}'
Out: '[true, true, false]'
- Comment:
Str: 'Try/catch and general `?` operator'
- TestCase:
Name: case191
Op: '[.[]|try if . == 0 then error("foo") elif . == 1 then .a elif . == 2 then empty else . end catch .]'
In: '[0,1,2,3]'
Out: '["foo","Cannot index number with string \"a\"",3]'
- TestCase:
Name: case192
Op: '[.[]|(.a, .a)?]'
In: '[null,true,{"a":1}]'
Out: '[null,null,1,1]'
- TestCase:
Name: case193
Op: '[[.[]|[.a,.a]]?]'
In: '[null,true,{"a":1}]'
Out: '[]'
- TestCase:
Name: case194
Op: 'try error("\($__loc__)") catch .'
In: 'null'
Out: '"{\"file\":\"\",\"line\":1}"'
- Comment:
Str: 'string operations'
- TestCase:
Name: case195
Op: '[.[]|startswith("foo")]'
In: '["fo", "foo", "barfoo", "foobar", "barfoob"]'
Out: '[false, true, false, true, false]'
- TestCase:
Name: case196
Op: '[.[]|endswith("foo")]'
In: '["fo", "foo", "barfoo", "foobar", "barfoob"]'
Out: '[false, true, true, false, false]'
- TestCase:
Name: case197
Op: '[.[] | split(", ")]'
In: '["a,b, c, d, e,f",", a,b, c, d, e,f, "]'
Out: '[["a,b","c","d","e,f"],["","a,b","c","d","e,f",""]]'
- TestCase:
Name: case198
Op: 'split("")'
In: '"abc"'
Out: '["a","b","c"]'
- TestCase:
Name: case199
Op: '[.[]|ltrimstr("foo")]'
In: '["fo", "foo", "barfoo", "foobar", "afoo"]'
Out: '["fo","","barfoo","bar","afoo"]'
- TestCase:
Name: case200
Op: '[.[]|rtrimstr("foo")]'
In: '["fo", "foo", "barfoo", "foobar", "foob"]'
Out: '["fo","","bar","foobar","foob"]'
- TestCase:
Name: case201
Op: '[(index(","), rindex(",")), indices(",")]'
In: '"a,bc,def,ghij,klmno"'
Out: '[1,13,[1,4,8,13]]'
- TestCase:
Name: case202
Op: 'indices(1)'
In: '[0,1,1,2,3,4,1,5]'
Out: '[1,2,6]'
- TestCase:
Name: case203
Op: 'indices([1,2])'
In: '[0,1,2,3,1,4,2,5,1,2,6,7]'
Out: '[1,8]'
- TestCase:
Name: case204
Op: 'indices([1,2])'
In: '[1]'
Out: '[]'
- TestCase:
Name: case205
Op: 'indices(", ")'
In: '"a,b, cd,e, fgh, ijkl"'
Out: '[3,9,14]'
- TestCase:
Name: case206
Op: '[.[]|split(",")]'
In: '["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]'
Out: '[["a"," bc"," def"," ghij"," jklmn"," a","b"," c","d"," e","f"],["a","b","c","d"," e","f","g","h"]]'
- TestCase:
Name: case207
Op: '[.[]|split(", ")]'
In: '["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]'
Out: '[["a","bc","def","ghij","jklmn","a,b","c,d","e,f"],["a,b,c,d","e,f,g,h"]]'
- TestCase:
Name: case208
Op: '[.[] * 3]'
In: '["a", "ab", "abc"]'
Out: '["aaa", "ababab", "abcabcabc"]'
- TestCase:
Name: case209
Op: '[.[] / ","]'
In: '["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]'
Out: '[["a"," bc"," def"," ghij"," jklmn"," a","b"," c","d"," e","f"],["a","b","c","d"," e","f","g","h"]]'
- TestCase:
Name: case210
Op: '[.[] / ", "]'
In: '["a, bc, def, ghij, jklmn, a,b, c,d, e,f", "a,b,c,d, e,f,g,h"]'
Out: '[["a","bc","def","ghij","jklmn","a,b","c,d","e,f"],["a,b,c,d","e,f,g,h"]]'
- TestCase:
Name: case211
Op: 'map(.[1] as $needle | .[0] | contains($needle))'
In: '[[[],[]], [[1,2,3], [1,2]], [[1,2,3], [3,1]], [[1,2,3], [4]], [[1,2,3], [1,4]]]'
Out: '[true, true, true, false, false]'
- TestCase:
Name: case212
Op: 'map(.[1] as $needle | .[0] | contains($needle))'
In: '[[["foobar", "foobaz"], ["baz", "bar"]], [["foobar", "foobaz"], ["foo"]], [["foobar", "foobaz"], ["blap"]]]'
Out: '[true, true, false]'
- TestCase:
Name: case213
Op: '[({foo: 12, bar:13} | contains({foo: 12})), ({foo: 12} | contains({})), ({foo: 12, bar:13} | contains({baz:14}))]'
In: '{}'
Out: '[true, true, false]'
- TestCase:
Name: case214
Op: '{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {}}})'
In: '{}'
Out: 'true'
- TestCase:
Name: case215
Op: '{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {bar: 14}}})'
In: '{}'
Out: 'false'
- TestCase:
Name: case216
Op: 'sort'
In: '[42,[2,5,3,11],10,{"a":42,"b":2},{"a":42},true,2,[2,6],"hello",null,[2,5,6],{"a":[],"b":1},"abc","ab",[3,10],{},false,"abcd",null]'
Out: '[null,null,false,true,2,10,42,"ab","abc","abcd","hello",[2,5,3,11],[2,5,6],[2,6],[3,10],{},{"a":42},{"a":42,"b":2},{"a":[],"b":1}]'
- TestCase:
Name: case217
Op: '(sort_by(.b) | sort_by(.a)), sort_by(.a, .b), sort_by(.b, .c), group_by(.b), group_by(.a + .b - .c == 2)'
In: '[{"a": 1, "b": 4, "c": 14}, {"a": 4, "b": 1, "c": 3}, {"a": 1, "b": 4, "c": 3}, {"a": 0, "b": 2, "c": 43}]'
Out: '[{"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}, {"a": 4, "b": 1, "c": 3}]'
- TestCase:
Name: case218
Op: 'unique'
In: '[1,2,5,3,5,3,1,3]'
Out: '[1,2,3,5]'
- TestCase:
Name: case219
Op: 'unique'
In: '[]'
Out: '[]'
- TestCase:
Name: case220
Op: '[min, max, min_by(.[1]), max_by(.[1]), min_by(.[2]), max_by(.[2])]'
In: '[[4,2,"a"],[3,1,"a"],[2,4,"a"],[1,3,"a"]]'
Out: '[[1,3,"a"],[4,2,"a"],[3,1,"a"],[2,4,"a"],[4,2,"a"],[1,3,"a"]]'
- TestCase:
Name: case221
Op: '[min,max,min_by(.),max_by(.)]'
In: '[]'
Out: '[null,null,null,null]'
- TestCase:
Name: case222
Op: '.foo[.baz]'
In: '{"foo":{"bar":4},"baz":"bar"}'
Out: '4'
- TestCase:
Name: case223
Op: .[] | .error = "no, it's OK"
In: '[{"error":true}]'
Out: {"error": "no, it's OK"}
- TestCase:
Name: case224
Op: '[{a:1}] | .[] | .a=999'
In: 'null'
Out: '{"a": 999}'
- TestCase:
Name: case225
Op: 'to_entries'
In: '{"a": 1, "b": 2}'
Out: '[{"key":"a", "value":1}, {"key":"b", "value":2}]'
- TestCase:
Name: case226
Op: 'from_entries'
In: '[{"key":"a", "value":1}, {"Key":"b", "Value":2}, {"name":"c", "value":3}, {"Name":"d", "Value":4}]'
Out: '{"a": 1, "b": 2, "c": 3, "d": 4}'
- TestCase:
Name: case227
Op: 'with_entries(.key |= "KEY_" + .)'
In: '{"a": 1, "b": 2}'
Out: '{"KEY_a": 1, "KEY_b": 2}'
- TestCase:
Name: case228
Op: 'map(has("foo"))'
In: '[{"foo": 42}, {}]'
Out: '[true, false]'
- TestCase:
Name: case229
Op: 'map(has(2))'
In: '[[0,1], ["a","b","c"]]'
Out: '[false, true]'
- TestCase:
Name: case230
Op: 'keys'
In: '[42,3,35]'
Out: '[0,1,2]'
- TestCase:
Name: case231
Op: '[][.]'
In: '1000000000000000000'
Out: 'null'
- TestCase:
Name: case232
Op: 'map([1,2][0:.])'
In: '[-1, 1, 2, 3, 1000000000000000000]'
Out: '[[1], [1], [1,2], [1,2], [1,2]]'
- Comment:
Str: 'Test recursive object merge'
- TestCase:
Name: case233
Op: '{"k": {"a": 1, "b": 2}} * .'
In: '{"k": {"a": 0,"c": 3}}'
Out: '{"k": {"a": 0, "b": 2, "c": 3}}'
- TestCase:
Name: case234
Op: '{"k": {"a": 1, "b": 2}, "hello": {"x": 1}} * .'
In: '{"k": {"a": 0,"c": 3}, "hello": 1}'
Out: '{"k": {"a": 0, "b": 2, "c": 3}, "hello": 1}'
- TestCase:
Name: case235
Op: '{"k": {"a": 1, "b": 2}, "hello": 1} * .'
In: '{"k": {"a": 0,"c": 3}, "hello": {"x": 1}}'
Out: '{"k": {"a": 0, "b": 2, "c": 3}, "hello": {"x": 1}}'
- TestCase:
Name: case236
Op: '{"a": {"b": 1}, "c": {"d": 2}, "e": 5} * .'
In: '{"a": {"b": 2}, "c": {"d": 3, "f": 9}}'
Out: '{"a": {"b": 2}, "c": {"d": 3, "f": 9}, "e": 5}'
- TestCase:
Name: case237
Op: '[.[]|arrays]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[[],[3,[]]]'
- TestCase:
Name: case238
Op: '[.[]|objects]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[{}]'
- TestCase:
Name: case239
Op: '[.[]|iterables]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[[],[3,[]],{}]'
- TestCase:
Name: case240
Op: '[.[]|scalars]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[1,2,"foo",true,false,null]'
- TestCase:
Name: case241
Op: '[.[]|values]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[1,2,"foo",[],[3,[]],{},true,false]'
- TestCase:
Name: case242
Op: '[.[]|booleans]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[true,false]'
- TestCase:
Name: case243
Op: '[.[]|nulls]'
In: '[1,2,"foo",[],[3,[]],{},true,false,null]'
Out: '[null]'
- TestCase:
Name: case244
Op: 'flatten'
In: '[0, [1], [[2]], [[[3]]]]'
Out: '[0, 1, 2, 3]'
- TestCase:
Name: case245
Op: 'flatten(0)'
In: '[0, [1], [[2]], [[[3]]]]'
Out: '[0, [1], [[2]], [[[3]]]]'
- TestCase:
Name: case246
Op: 'flatten(2)'
In: '[0, [1], [[2]], [[[3]]]]'
Out: '[0, 1, 2, [3]]'
- TestCase:
Name: case247
Op: 'flatten(2)'
In: '[0, [1, [2]], [1, [[3], 2]]]'
Out: '[0, 1, 2, 1, [3], 2]'
- TestCase:
Name: case248
Op: 'try flatten(-1) catch .'
In: '[0, [1], [[2]], [[[3]]]]'
Out: '"flatten depth must not be negative"'
- TestCase:
Name: case249
Op: 'transpose'
In: '[[1], [2,3]]'
Out: '[[1,2],[null,3]]'
- TestCase:
Name: case250
Op: 'ascii_upcase'
In: '"useful but not for é"'
Out: '"USEFUL BUT NOT FOR é"'
- TestCase:
Name: case251
Op: 'bsearch(4)'
In: '[1,2,3]'
Out: '-4'
- Comment:
Str: 'strptime tests are in optional.test'
- TestCase:
Name: case252
Op: 'strftime("%Y-%m-%dT%H:%M:%SZ")'
In: '[2015,2,5,23,51,47,4,63]'
Out: '"2015-03-05T23:51:47Z"'
- TestCase:
Name: case253
Op: 'strftime("%A, %B %d, %Y")'
In: '1435677542.822351'
Out: '"Tuesday, June 30, 2015"'
- TestCase:
Name: case254
Op: 'gmtime'
In: '1425599507'
Out: '[2015,2,5,23,51,47,4,63]'
- Comment:
Str: 'module system'
- TestCase:
Name: case255
Op: 'import "a" as foo; import "b" as bar; def fooa: foo::a; [fooa, bar::a, bar::b, foo::a]'
In: 'null'
Out: '["a","b","c","a"]'
- TestCase:
Name: case256
Op: 'import "c" as foo; [foo::a, foo::c]'
In: 'null'
Out: '[0,"acmehbah"]'
- TestCase:
Name: case257
Op: 'include "c"; [a, c]'
In: 'null'
Out: '[0,"acmehbah"]'
- TestCase:
Name: case258
Op: 'modulemeta'
In: '"c"'
Out: '{"whatever":null,"deps":[{"as":"foo","is_data":false,"relpath":"a"},{"search":"./","as":"d","is_data":false,"relpath":"d"},{"search":"./","as":"d2","is_data":false,"relpath":"d"},{"search":"./../lib/jq","as":"e","is_data":false,"relpath":"e"},{"search":"./../lib/jq","as":"f","is_data":false,"relpath":"f"},{"as":"d","is_data":true,"relpath":"data"}]}'
- TestCase:
Name: case259
Op: 'import "test_bind_order" as check; check::check'
In: 'null'
Out: 'true'
- TestCase:
Name: case260
Op: 'try -. catch .'
In: '"very-long-string"'
Out: '"string (\"very-long-...) cannot be negated"'
- TestCase:
Name: case261
Op: 'join(",")'
In: '["1",2,true,false,3.4]'
Out: '"1,2,true,false,3.4"'
- TestCase:
Name: case262
Op: '.[] | join(",")'
In: '[[], [null], [null,null], [null,null,null]]'
Out: '""'
- TestCase:
Name: case263
Op: '.[] | join(",")'
In: '[["a",null], [null,"a"]]'
Out: '"a,"'
- TestCase:
Name: case264
Op: 'try join(",") catch .'
In: '["1","2",{"a":{"b":{"c":33}}}]'
Out: '"string (\"1,2,\") and object ({\"a\":{\"b\":{...) cannot be added"'
- TestCase:
Name: case265
Op: 'try join(",") catch .'
In: '["1","2",[3,4,5]]'
Out: '"string (\"1,2,\") and array ([3,4,5]) cannot be added"'
- TestCase:
Name: case266
Op: '{if:0,and:1,or:2,then:3,else:4,elif:5,end:6,as:7,def:8,reduce:9,foreach:10,try:11,catch:12,label:13,import:14,include:15,module:16}'
In: 'null'
Out: '{"if":0,"and":1,"or":2,"then":3,"else":4,"elif":5,"end":6,"as":7,"def":8,"reduce":9,"foreach":10,"try":11,"catch":12,"label":13,"import":14,"include":15,"module":16}'
- TestCase:
Name: case267
Op: 'try (1/.) catch .'
In: '0'
Out: '"number (1) and number (0) cannot be divided because the divisor is zero"'
- TestCase:
Name: case268
Op: 'try (1%.) catch .'
In: '0'
Out: '"number (1) and number (0) cannot be divided (remainder) because the divisor is zero"'
- Comment:
Str: 'Basic numbers tests: integers, powers of two'
- TestCase:
Name: case269
Op: '[range(-52;52;1)] as $powers | [$powers[]|pow(2;.)|log2] == $powers'
In: 'null'
Out: 'true'
- TestCase:
Name: case270
Op: '[range(-99/2;99/2;1)] as $orig | [$orig[]|pow(2;.)|log2] as $back | ($orig|keys)[]|. as $k | (($orig|.[$k])-($back|.[$k]))|if . < 0 then . * -1 else . end|select(.>.00005)'
In: 'null'
Out: ''
- TestCase:
Name: case271
Op: '(.[{}] = 0)?'
In: 'null'
Out: ''
easygen-4.1.0/test/jq-test_jq.tmpl 0000664 0000000 0000000 00000003125 13502324010 0017074 0 ustar 00root root 0000000 0000000 // Copyright (c) 2016 Matt Ho
//
// Test cases code automatically generated by easygen:
// https://github.com/go-easygen/easygen
// Editing discouraged.
// Test cases code Copyright (c) 2016 of project
// https://github.com/stedolan/jq
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package jq_test
import (
"testing"
"github.com/savaki/jq"
)
func TestParse(t *testing.T) {
testCases := map[string]struct {
In string
Op string
Expected string
HasError bool
}{ {{range .Cases}}{{if .TestCase}}
"{{.TestCase.Name}}": {
In: `{{.TestCase.In}}`,
Op: `{{.TestCase.Op}}`,
Expected: `{{.TestCase.Out}}`,
},{{end}}{{if .Comment}}
// {{.Comment.Str}}{{end}}{{end}}
}
for label, tc := range testCases {
t.Run(label, func(t *testing.T) {
op, err := jq.Parse(tc.Op)
if err != nil {
t.FailNow()
}
data, err := op.Apply([]byte(tc.In))
if tc.HasError {
if err == nil {
t.FailNow()
}
} else {
if string(data) != tc.Expected {
t.FailNow()
}
if err != nil {
t.FailNow()
}
}
})
}
}
easygen-4.1.0/test/list0.ref 0000664 0000000 0000000 00000000044 13502324010 0015643 0 ustar 00root root 0000000 0000000 The colors are: red, blue, white, .
easygen-4.1.0/test/list0.tmpl 0000664 0000000 0000000 00000000061 13502324010 0016042 0 ustar 00root root 0000000 0000000 The colors are: {{range .Colors}}{{.}}, {{end}}.
easygen-4.1.0/test/list0.yaml 0000664 0000000 0000000 00000000077 13502324010 0016037 0 ustar 00root root 0000000 0000000 Colors:
- red
- blue
- white
Colorlist: red blue white
easygen-4.1.0/test/list00.tmpl 0000664 0000000 0000000 00000000053 13502324010 0016123 0 ustar 00root root 0000000 0000000 The colors are: {{range .}}{{.}}, {{end}}.
easygen-4.1.0/test/list00f.tmpl 0000664 0000000 0000000 00000000144 13502324010 0016272 0 ustar 00root root 0000000 0000000 The colors are: {{range $i, $color := .}}{{$color}}{{if lt $i ($ | len | minus1)}}, {{end}}{{end}}.
easygen-4.1.0/test/list01.ref 0000664 0000000 0000000 00000000066 13502324010 0015730 0 ustar 00root root 0000000 0000000 The colors are: red, blue, white, .
red, blue, white.
easygen-4.1.0/test/list0E.ref 0000664 0000000 0000000 00000000212 13502324010 0015745 0 ustar 00root root 0000000 0000000 The colors are: red, blue, white, .
The system shell is: /bin/bash
Different shells are: /bin/bash-red, /bin/bash-blue, /bin/bash-white,
easygen-4.1.0/test/list0E.tmpl 0000664 0000000 0000000 00000000234 13502324010 0016151 0 ustar 00root root 0000000 0000000 The colors are: {{range .Colors}}{{.}}, {{end}}.
The system shell is: {{ENV "SHELL"}}
Different shells are: {{range .Colors}}{{ENV "SHELL"}}-{{.}}, {{end}}
easygen-4.1.0/test/list0j.json 0000664 0000000 0000000 00000000100 13502324010 0016203 0 ustar 00root root 0000000 0000000 {
"Colors": [
"red",
"blue",
"white"
]
} easygen-4.1.0/test/list0j.ref 0000777 0000000 0000000 00000000000 13502324010 0017543 2list0.ref ustar 00root root 0000000 0000000 easygen-4.1.0/test/list0j.tmpl 0000777 0000000 0000000 00000000000 13502324010 0020143 2list0.tmpl ustar 00root root 0000000 0000000 easygen-4.1.0/test/list1.ref 0000664 0000000 0000000 00000000061 13502324010 0015643 0 ustar 00root root 0000000 0000000 The quoted colors are: "red", "blue", "white", .
easygen-4.1.0/test/list1.tmpl 0000664 0000000 0000000 00000000070 13502324010 0016043 0 ustar 00root root 0000000 0000000 The quoted colors are: {{range .Colors}}{{.}}, {{end}}.
easygen-4.1.0/test/list1.yaml 0000664 0000000 0000000 00000000062 13502324010 0016032 0 ustar 00root root 0000000 0000000 Colors:
- '"red"'
- '"blue"'
- '"white"'
easygen-4.1.0/test/list1HTML.ref 0000664 0000000 0000000 00000000111 13502324010 0016324 0 ustar 00root root 0000000 0000000 The quoted colors are: "red", "blue", "white", .
easygen-4.1.0/test/list1HTML.tmpl 0000664 0000000 0000000 00000000077 13502324010 0016537 0 ustar 00root root 0000000 0000000 The quoted colors are: {{range .Colors}}{{. | html}}, {{end}}.
easygen-4.1.0/test/listfunc1.ref 0000664 0000000 0000000 00000000022 13502324010 0016514 0 ustar 00root root 0000000 0000000 red, blue, white.
easygen-4.1.0/test/listfunc1.tmpl 0000664 0000000 0000000 00000000141 13502324010 0016716 0 ustar 00root root 0000000 0000000 {{range $i, $color := .Colors}}{{$color}}{{if lt $i ($.Colors | len | minus1)}}, {{end}}{{end}}.
easygen-4.1.0/test/listfunc1.yaml 0000777 0000000 0000000 00000000000 13502324010 0020622 2list0.yaml ustar 00root root 0000000 0000000 easygen-4.1.0/test/listfunc2.ref 0000664 0000000 0000000 00000000063 13502324010 0016522 0 ustar 00root root 0000000 0000000 some-init-method 5 5 someInitMethod SomeInitMethod
easygen-4.1.0/test/listfunc2.tmpl 0000664 0000000 0000000 00000000110 13502324010 0016713 0 ustar 00root root 0000000 0000000 {{.Name}} {{6 | minus1}} {{minus1 6}} {{clk2lc .Name}} {{clk2uc .Name}}
easygen-4.1.0/test/listfunc2.yaml 0000664 0000000 0000000 00000000115 13502324010 0016706 0 ustar 00root root 0000000 0000000 Name: some-init-method
NameHTTP: HTTP-header-case
NameMixed: some_InitMethod
easygen-4.1.0/test/raid_driver.yaml 0000664 0000000 0000000 00000000161 13502324010 0017270 0 ustar 00root root 0000000 0000000 EnumName: raid_driver
Values:
- Name: HW
String: "Hardware-RAID"
- Name: SW
String: "Software-RAID"
easygen-4.1.0/test/raid_type.yaml 0000664 0000000 0000000 00000001060 13502324010 0016755 0 ustar 00root root 0000000 0000000 # EnumName is the type of the Enum in C (Java/Go will use CamelCase)
EnumName: raid_type
# EnumComments contain documentation that goes above @EnumName
EnumComments:
- Simplified enumeration of available RAID devices
# List of enum values
Values:
- Name: RAID0
String: "RAID0" # stringified value (defaults to @Name as string)
Value: 100
AltString: [ "RAID-0" ] # list of alternatives that translate into @Value
- Name: RAID1
AltString: [ "RAID-1" ]
# The default value to return if nothing else is known
EnumDefault: RAID0
easygen-4.1.0/test/sgdisk-fstab.tmpl 0000664 0000000 0000000 00000000150 13502324010 0017367 0 ustar 00root root 0000000 0000000 {{range .Partitions}}
LABEL={{.Name}} /mnt/{{.Name}} auto noauto,defaults,noatime,nodiratime 0 2{{end}}
easygen-4.1.0/test/sgdisk-mp.tmpl 0000664 0000000 0000000 00000000167 13502324010 0016714 0 ustar 00root root 0000000 0000000 {{range .Partitions}}
mkdir /mnt/{{.Name}}{{end}}
{{range .Partitions}}
mount LABEL={{.Name}} /mnt/{{.Name}}{{end}}
easygen-4.1.0/test/sgdisk.sh 0000664 0000000 0000000 00000001125 13502324010 0015733 0 ustar 00root root 0000000 0000000 # format /dev/sdb as GPT, GUID Partition Table
sgdisk -Z /dev/sdb
sgdisk -n 0:0:+200M -t 0:ef02 -c 0:"bios_boot" /dev/sdb
sgdisk -n 0:0:+20G -t 0:8300 -c 0:"linux_boot" /dev/sdb
sgdisk -n 0:0:+30G -t 0:0700 -c 0:"windows" /dev/sdb
sgdisk -n 0:0:+10G -t 0:8200 -c 0:"linux_swap" /dev/sdb
sgdisk -n 0:0:+12G -t 0:8300 -c 0:"os1" /dev/sdb
sgdisk -n 0:0:+12G -t 0:8300 -c 0:"os2" /dev/sdb
sgdisk -n 0:0:+12G -t 0:8300 -c 0:"os3" /dev/sdb
sgdisk -n 0:0:0 -t 0:8300 -c 0:"data" /dev/sdb
sgdisk -p /dev/sdb
# inform the OS of partition table changes
partprobe /dev/sdb
fdisk -l /dev/sdb
easygen-4.1.0/test/sgdisk.tmpl 0000664 0000000 0000000 00000000423 13502324010 0016275 0 ustar 00root root 0000000 0000000 # format {{.Disk}} as GPT, GUID Partition Table
sgdisk -Z {{.Disk}}
{{range .Partitions}}
sgdisk -n 0:0:{{.Size}} -t 0:{{.Type}} -c 0:"{{.Name}}" {{$.Disk}}{{end}}
sgdisk -p {{.Disk}}
# inform the OS of partition table changes
partprobe {{.Disk}}
fdisk -l {{.Disk}}
easygen-4.1.0/test/sgdisk.txt 0000664 0000000 0000000 00000003365 13502324010 0016150 0 ustar 00root root 0000000 0000000 $ sgdisk -p /dev/sdb
Disk /dev/sdb: 732558336 sectors, 2.7 TiB
Logical sector size: 4096 bytes
Disk identifier (GUID): C4426321-9726-4022-BB20-2EF00B490465
Partition table holds up to 128 entries
First usable sector is 6, last usable sector is 732558330
Partitions will be aligned on 256-sector boundaries
Total free space is 250 sectors (1000.0 KiB)
Number Start (sector) End (sector) Size Code Name
1 256 51455 200.0 MiB EF02 bios_boot
2 51456 5294335 20.0 GiB 8300 linux_boot
3 5294336 13158655 30.0 GiB 0700 windows
4 13158656 15780095 10.0 GiB 8200 linux_swap
5 15780096 18925823 12.0 GiB 8300 os1
6 18925824 22071551 12.0 GiB 8300 os2
7 22071552 25217279 12.0 GiB 8300 os3
8 25217280 732558330 2.6 TiB 8300 data
$ fdisk -l /dev/sdb
Disk /dev/sdb: 2.7 TiB, 3000558944256 bytes, 732558336 sectors
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disklabel type: gpt
Disk identifier: C4426321-9726-4022-BB20-2EF00B490465
Device Start End Sectors Size Type
/dev/sdb1 256 51455 51200 200M BIOS boot
/dev/sdb2 51456 5294335 5242880 20G Linux filesystem
/dev/sdb3 5294336 13158655 7864320 30G Microsoft basic data
/dev/sdb4 13158656 15780095 2621440 10G Linux swap
/dev/sdb5 15780096 18925823 3145728 12G Linux filesystem
/dev/sdb6 18925824 22071551 3145728 12G Linux filesystem
/dev/sdb7 22071552 25217279 3145728 12G Linux filesystem
/dev/sdb8 25217280 732558330 707341051 2.7T Linux filesystem
easygen-4.1.0/test/sgdisk.yaml 0000664 0000000 0000000 00000001141 13502324010 0016261 0 ustar 00root root 0000000 0000000 Disk: /dev/sdb
# Common Partitions Types
#
# 8300 Linux filesystem
# 8200 linux swap
# fd00 linux raid
# ef02 BIOS boot
# 0700 Microsoft basic data
#
# For more GPT Partitions Types,
# echo L | gdisk /dev/sdb
Partitions:
- Name: bios_boot
Type: ef02
Size: +200M
- Name: linux_boot
Type: 8300
Size: +20G
- Name: windows
Type: "0700"
Size: +30G
- Name: linux_swap
Type: 8200
Size: +10G
- Name: os1
Type: 8300
Size: +12G
- Name: os2
Type: 8300
Size: +12G
- Name: os3
Type: 8300
Size: +12G
- Name: data
Type: 8300
Size: "0"
easygen-4.1.0/test/strings.yaml 0000664 0000000 0000000 00000000057 13502324010 0016473 0 ustar 00root root 0000000 0000000 StrTest: "These rights belong to those people"
easygen-4.1.0/test/strings0.ref 0000664 0000000 0000000 00000000107 13502324010 0016361 0 ustar 00root root 0000000 0000000 -ab-axxb- HTML Html html
-W-xxW- HTML Html html
-W-xxW- HTML Html html
easygen-4.1.0/test/strings0.tmpl 0000664 0000000 0000000 00000000071 13502324010 0016561 0 ustar 00root root 0000000 0000000 {{.StrTest}}
{{replace .StrTest}}
{{.StrTest | replace}}
easygen-4.1.0/test/strings0.yaml 0000664 0000000 0000000 00000000044 13502324010 0016547 0 ustar 00root root 0000000 0000000 StrTest: "-ab-axxb- HTML Html html"
easygen-4.1.0/test/strings1.ref 0000664 0000000 0000000 00000000107 13502324010 0016362 0 ustar 00root root 0000000 0000000 -ab-axxb- HTML Html html
-ab-axxb- XML Html html
-ab-axxb- XML XML XML
easygen-4.1.0/test/strings1.tmpl 0000664 0000000 0000000 00000000070 13502324010 0016561 0 ustar 00root root 0000000 0000000 {{.StrTest}}
{{replacec .StrTest}}
{{replace .StrTest}}
easygen-4.1.0/test/var0.ref 0000664 0000000 0000000 00000000020 13502324010 0015452 0 ustar 00root root 0000000 0000000 some-init-method easygen-4.1.0/test/var0.tmpl 0000664 0000000 0000000 00000000157 13502324010 0015665 0 ustar 00root root 0000000 0000000 Input: {{printf "%q" .Name}}
Output 1: {{clk2uc .Name | printf "%q"}}
Output 2: {{clk2ss .Name | printf "%q"}}
easygen-4.1.0/test/var0.yaml 0000664 0000000 0000000 00000000027 13502324010 0015647 0 ustar 00root root 0000000 0000000 Name: some-init-method
easygen-4.1.0/test/var1.ref 0000664 0000000 0000000 00000000016 13502324010 0015460 0 ustar 00root root 0000000 0000000 SomeInitMethod easygen-4.1.0/test/var2.ref 0000664 0000000 0000000 00000000020 13502324010 0015454 0 ustar 00root root 0000000 0000000 SOME_INIT_METHOD easygen-4.1.0/tf-calc.go 0000664 0000000 0000000 00000000447 13502324010 0015002 0 ustar 00root root 0000000 0000000 package easygen
//==========================================================================
// template function for calculations
// By Caleb Spare @gmail.com
// https://groups.google.com/d/msg/golang-nuts/gzAyBLAeUbU/LwgomgxcjQ8J
// Get input less 1
func minus1(n int) int { return n - 1 }
easygen-4.1.0/tf-datetime.go 0000664 0000000 0000000 00000002507 13502324010 0015673 0 ustar 00root root 0000000 0000000 package easygen
import (
"fmt"
"strconv"
"time"
)
// now is function that represents the current time in UTC. This is here
// primarily for the tests to override times.
var now = func() time.Time { return time.Now() }
//==========================================================================
// template function for date & time
// https://godoc.org/time#pkg-constants
// date returns the date or year
func date(fmt string) string {
switch fmt {
case "Y4":
// returns the year string of length 4
return time.Now().Format("2006")
case "I":
// returns the output of `date -I`
return time.Now().Format("2006-01-02")
// for the output of `date -Iseconds`
// use `timestamp`
default:
return time.Now().Format("2006" + fmt + "01" + fmt + "02")
}
}
// https://github.com/hashicorp/consul-template/blob/de2ebf4/template_functions.go#L666-L682
// timestamp returns the current UNIX timestamp in UTC. If an argument is
// specified, it will be used to format the timestamp.
func timestamp(s ...string) (string, error) {
switch len(s) {
case 0:
return now().Format(time.RFC3339), nil
case 1:
if s[0] == "unix" {
return strconv.FormatInt(now().Unix(), 10), nil
}
return now().Format(s[0]), nil
default:
return "", fmt.Errorf("timestamp: wrong number of arguments, expected 0 or 1"+
", but got %d", len(s))
}
}
easygen-4.1.0/tf-strings.go 0000664 0000000 0000000 00000004724 13502324010 0015573 0 ustar 00root root 0000000 0000000 package easygen
import (
"regexp"
"strings"
)
var (
re *regexp.Regexp
rec *regexp.Regexp
)
////////////////////////////////////////////////////////////////////////////
// Regexp Function Definitions
func regexpFindAllString(s string, regExp string, n int) []string {
return regexp.MustCompile(regExp).FindAllString(s, n)
}
func regexpFindAllStringIndex(s string, regExp string, n int) [][]int {
return regexp.MustCompile(regExp).FindAllStringIndex(s, n)
}
func regexpFindAllStringSubmatch(s string, regExp string, n int) [][]string {
return regexp.MustCompile(regExp).FindAllStringSubmatch(s, n)
}
func regexpFindAllStringSubmatchIndex(s string, regExp string, n int) [][]int {
return regexp.MustCompile(regExp).FindAllStringSubmatchIndex(s, n)
}
func regexpFindString(s string, regExp string) string {
return regexp.MustCompile(regExp).FindString(s)
}
func regexpFindStringIndex(s string, regExp string) (loc []int) {
return regexp.MustCompile(regExp).FindStringIndex(s)
}
func regexpFindStringSubmatch(s string, regExp string) []string {
return regexp.MustCompile(regExp).FindStringSubmatch(s)
}
func regexpFindStringSubmatchIndex(s string, regExp string) []int {
return regexp.MustCompile(regExp).FindStringSubmatchIndex(s)
}
func regexpMatchString(s string, regExp string) bool {
return regexp.MustCompile(regExp).MatchString(s)
}
func regexpReplaceAllLiteralString(src, regExp string, repl string) string {
return regexp.MustCompile(regExp).ReplaceAllLiteralString(src, repl)
}
func regexpReplaceAllString(src, regExp string, repl string) string {
return regexp.MustCompile(regExp).ReplaceAllString(src, repl)
}
func regexpReplaceAllStringFunc(src string, regExp string, repl func(string) string) string {
return regexp.MustCompile(regExp).ReplaceAllStringFunc(src, repl)
}
func regexpSplit(s string, regExp string, n int) []string {
return regexp.MustCompile(regExp).Split(s, n)
}
////////////////////////////////////////////////////////////////////////////
// Misc
// coalesce function takes two or more string arguments and returns the first argument that is not empty.
// The result is empty only if all the arguments are empty.
func coalesce(s ...string) string {
for _, str := range s {
if len(str) != 0 && str != "" {
return str
}
}
return ""
}
// quote4shell -- quote file name for shell.
// So "%bob's file" will be quoted as '%bob'\''s file'
func quote4shell(s string) string {
return "'" + strings.Join(strings.Split(s, "'"), `'\''`) + "'"
}
easygen-4.1.0/using_easygen.md 0000664 0000000 0000000 00000004264 13502324010 0016325 0 ustar 00root root 0000000 0000000
## Testing the templates on the fly
echo 'Name: some-init-method' > /tmp/var.yaml
$ EASYGEN_TS='{{.Name}}' easygen /tmp/var
some-init-method
I.e., with the environment variable `EASYGEN_TS`, the `.tmpl` template file is not used.
$ EASYGEN_TS='{{.Name}}' easygen -ts '{{clk2uc .Name}}' /tmp/var
SomeInitMethod
I.e., command line value takes the highest priority, even overriding the environment variable `EASYGEN_TS`'s value.
As such, if you have a different naming convention than using `.tmpl` for template file and `.yaml` for data file, you can override them in environment variables, `EASYGEN_ET` and `EASYGEN_EY`, so that you don't need to use `-et` and/or `-ey` to override them from command line each time.
echo 'Name: myConstantVariable' > /tmp/var.yml
$ EASYGEN_EY=.yml easygen -ts '{{clc2ss .Name}}' /tmp/var
MY_CONSTANT_VARIABLE
## Tips
[ ](https://suntong.github.io/blogs/)
You can use `easygen` as an generic Go template testing tool with the `-ts` commandline option. For example,
```bash
echo "Age: 16" > /tmp/age.yaml
$ easygen -ts "{{.Age}}" /tmp/age
16
$ easygen -ts '{{printf "%x" .Age}}' /tmp/age
10
$ easygen -ts '{{date "Y4"}}' /tmp/age
2017
$
$ easygen -ts '{{date "I"}}' /tmp/age
2017-07-10
$ easygen -ts '{{date "."}}' /tmp/age
2017.07.10
$ easygen -ts '{{date ""}}' /tmp/age
20170710
$ easygen -ts '{{timestamp}}' /tmp/age
2017-07-10T08:53:25-04:00
$ easygen -ts '{{timestamp "unix"}}' /tmp/age
1499691221
echo '{FirstName: John, LastName: Doe}' > /tmp/name.yaml
$ easygen -ts '{{.FirstName}}'\''s full name is {{printf "%s%s" .FirstName .LastName | len}} letters long.' /tmp/name
John's full name is 7 letters long.
$ easygen -ts "{{.FirstName}} {{clk2ss .LastName}}'s full name is "'{{len (printf "%s%s" .FirstName .LastName)}} letters long.' /tmp/name
John DOE's full name is 7 letters long.
echo 'Name: some-init-method' > /tmp/var.yaml
$ easygen -ts '{{.Name}} {{6 | minus1}} {{minus1 6}} {{clk2lc .Name}} {{clk2uc .Name}}' /tmp/var
some-init-method 5 5 someInitMethod SomeInitMethod
$ echo 'Name: "%bob'"'"'s file"' | tee /tmp/var.yaml
Name: "%bob's file"
$ easygen -ts '{{quote4shell .Name}}' /tmp/var
'%bob'\''s file'
```