Fault tolerance and resilience patterns for Go.

Failsafe-go

Parallelized formatter with no external dependencies for gherkin (cucumber, behat...).

# [![Go Report Card](https://goreportcard.com/badge/github.com/antham/ghokin)](https://goreportcard.com/report/github.com/antham/ghokin) [![codecov](https://codecov.io/gh/antham/ghokin/branch/master/graph/badge.svg)](https://codecov.io/gh/antham/ghokin) [![GitHub tag](https://img.shields.io/github/tag/antham/ghokin.svg)]()

Ghokin format and apply transformation on gherkin files.

---

- [Install](#install)
- [Usage](#usage)
- [Documentation](#documentation)
- [Contribute](#contribute)

---

## Install

Download the latest binary for your achitecture [here](https://github.com/antham/ghokin/releases/latest).

If you can't find a binary for your architecture, install the go toolchain, clone the repository and run : `go install .`.

## Usage

```
Clean and/or apply transformation on gherkin files

Usage:
  ghokin [command]

Available Commands:
  check       Check a file/folder is well formatted
  fmt         Format a feature file/folder
  help        Help about any command

Flags:
      --config string   config file
  -h, --help            help for ghokin

Use "ghokin [command] --help" for more information about a command.
```

⚠️ Ghokin works only on `UTF-8` encoded files, it will detect and convert automatically files that are not encoded in this charset.

### fmt stdout

Dump stdin or a feature file formatted on stdout

```
ghokin fmt stdout features/test.feature
```

or

```
cat features/test.feature|ghokin fmt stdout
```

### fmt replace

Format and replace a file or all files in a directory

```
ghokin fmt replace features/test.feature
```

or

```
ghokin fmt replace features/
```

### check

Ensure a file or all files in a directory are well formatted, exit with an error code otherwise

```
ghokin check features/test.feature
```

or

```
ghokin check features/
```

## Documentation

### Shell commands

You can run shell commands from within your feature file to transform some datas with annotations, to do so you need first to define in the config an alias and afterwards you can simply "comment" the line before the line you want to transform with that alias.
For instance let say `@json` calls behind the curtain `jq`, we could validate and format some json in our feature like so :

```
Feature: A Feature
  Description

  Scenario: A scenario to test
    Given a thing
    # @json
    """
    {
      "test": "test"
    }
    """
```

### Config

Defaut config is to use 2 spaces for indentation.

It's possible to override configuration by defining a `.ghokin.yml` file in the home directory or in the current directory where we are running the binary from :

```
indent: 2
aliases:
  json: "jq ."
```

Aliases key defined [shell commands](#shell-commands) callable in comments as we discussed earlier.

It's possible to use environments variables instead of a static config file :

```
export GHOKIN_INDENT=2
export GHOKIN_ALIASES='{"json":"jq ."}'
```

## Contribute

If you want to add a new feature to ghokin project, the best way is to open a ticket first to know exactly how to implement your changes in code.

### Setup

After cloning the repository you need to install vendors with `go mod vendor`
To test your changes locally you can run go tests with : `make test-all`


ghokin

Simple, seamless, lightweight time tracking for Git.

<div align="center"><img src="https://cloud.githubusercontent.com/assets/630550/19619834/43c460dc-9835-11e6-8652-1c8fff91cf02.png" alt="GTM Logo" height="115" width="275"></div>
<div align="center"><font size=16><bold>Git Time Metric</bold></font></div>

### Seamless time tracking for all your Git projects

##### $ gtm report -last-month
<div><img src="https://cloud.githubusercontent.com/assets/630550/21582250/8a03f9dc-d015-11e6-8f77-548ef7314bf7.png"></div>

##### $ gtm report -last-month -format summary
<div><img src="https://cloud.githubusercontent.com/assets/630550/21582252/8f85b738-d015-11e6-8c70-beed7e7b3254.png"></div>

##### $ gtm report -last-month -format timeline-hours
<div><img src="https://cloud.githubusercontent.com/assets/630550/21582253/91f6226e-d015-11e6-897c-6042111e6a6a.png"></div> </br>

GTM is automatic, seamless and lightweight.  There is no need to remember to start and stop timers.  It runs on occasion to capture activity triggered by your editor.  The time metrics are stored locally with the git repository as [Git notes](https://git-scm.com/docs/git-notes) and can be pushed to the remote repository.

### <div align="center">Plugins</div>

Simply install a plugin for your favorite editor and the GTM command line utility to start tracking your time now.

<p><img src="https://cloud.githubusercontent.com/assets/630550/17458557/72247454-5bda-11e6-84ce-03364b8ac832.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458560/72397408-5bda-11e6-909c-c2dd2dad3b52.png" width="64" height="64">
<img src="https://user-images.githubusercontent.com/3669664/62366235-a39ef880-b526-11e9-9408-e549b5b12a46.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458562/7264e2be-5bda-11e6-8311-bbed672ffb8f.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458559/72302916-5bda-11e6-886e-2a41f423b06f.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458563/7264f06a-5bda-11e6-9fb6-d0469730c1cb.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458556/72030a62-5bda-11e6-89e4-6a3921034aed.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458564/727d43a4-5bda-11e6-8b3c-56d3fb7bf988.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458555/71e4352e-5bda-11e6-89d3-e8ff2c3a86e2.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458561/72417ac2-5bda-11e6-9769-04cffc64397e.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458591/82e06c98-5bdb-11e6-8ae0-c5b2bd2fe97f.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/17458558/72269342-5bda-11e6-8194-d9bf030bd037.png" width="64" height="64">
<img src="https://cloud.githubusercontent.com/assets/630550/19619987/f9f7523a-9838-11e6-99da-c3fda05ce0d6.png" width="64" height="64"></p>

# Getting Started

### Install the latest GTM release

**Mac OS X**

The simplest way to install is to use [Homebrew](http://brew.sh)

```
brew tap git-time-metric/gtm
brew install gtm
```

**Windows**

- Download and run the Windows installer from [here](https://github.com/git-time-metric/gtm/releases/latest)

**Linux**

The simplest way to install is to use [Linuxbrew](http://linuxbrew.sh/)

```
brew tap git-time-metric/gtm
brew install gtm
```

**Manually install for Linux, OSX or Windows**

- Download and install the executable from [here](https://github.com/git-time-metric/gtm/releases/latest)


### Install a plugin for your editor

- [Sublime 3](https://github.com/git-time-metric/gtm-sublime3-plugin)
- [Atom](https://github.com/git-time-metric/gtm-atom-plugin)
- [Vim](https://github.com/git-time-metric/gtm-vim-plugin)
- [IntelliJ IDEA, PyCharm, WebStorm, AppCode, RubyMine, PhpStorm, AndroidStudio ](https://github.com/git-time-metric/gtm-jetbrains-plugin)
- [VSCode](https://github.com/nexus-uw/vscode-gtm)
- [Visual Studio](https://github.com/jjonescz/gtm-visualstudio-plugin)
- [Terminal](https://github.com/git-time-metric/gtm-terminal-plugin)

### Initialize a project for time tracking

<pre>$ cd /my/project/dir
$ gtm init

Git Time Metric initialized for /my/project/dir

     post-commit: gtm commit --yes
  alias.fetchgtm: fetch origin refs/notes/gtm-data:refs/notes/gtm-data
   alias.pushgtm: push origin refs/notes/gtm-data
notes.rewriteref: refs/notes/gtm-data
        terminal: true
      .gitignore: /.gtm/
            tags: tag1, tag2 </pre>

### Edit some files in your project

Check your progress with `gtm status`.

<pre>$ gtm status

       20m 40s  53% [m] plugin/gtm.vim
       18m  5s  46% [r] Terminal
           15s   1% [m] .gitignore
       39m  0s          <b>gtm-vim-plugin</b> </pre>

### Commit your work

When you are ready, commit your work like you usually do.  GTM will automatically save the time spent associated with your commit. To check the time of the last commit type `gtm report`.
<pre>$ gtm report

7129f00 <b>Remove post processing of status</b>
Fri Sep 09 20:45:03 2016 -0500 <b>gtm-vim-plugin</b> Michael Schenk

       20m 40s  53% [m] plugin/gtm.vim
       18m  5s  46% [r] Terminal
           15s   1% [m] .gitignore
       39m  0s          <b>gtm-vim-plugin</b> </pre>

### Optionally save time in the remote Git repository

GTM provides [git aliases](https://git-scm.com/book/en/v2/Git-Basics-Git-Aliases) to make this easy.  It defaults to origin for the remote repository.

Time data can be saved to the remote repository by pushing.
<pre>$ git pushgtm </pre>

Time data can be retrieved from the remote repository by fetching.
<pre>$ git fetchgtm </pre>

### Getting Help

For help from the command line type `gtm --help` and `gtm <subcommand> --help`.

For additional help please consult the [Wiki](https://github.com/git-time-metric/gtm/wiki).

# Contributing
[![Build Status](https://travis-ci.org/git-time-metric/gtm.svg?branch=develop)](https://travis-ci.org/git-time-metric/gtm) [![Build status](https://ci.appveyor.com/api/projects/status/gj6tvm8njgwj0hqi?svg=true)](https://ci.appveyor.com/project/mschenk42/gtm) [![Coverage Status](https://coveralls.io/repos/github/git-time-metric/gtm/badge.svg)](https://coveralls.io/github/git-time-metric/gtm) [![Go Report Card](https://goreportcard.com/badge/github.com/git-time-metric/gtm)](https://goreportcard.com/report/github.com/git-time-metric/gtm)

If you find a bug or have an idea for a new feature please feel free to file new issues and submits PRs.  In particular if there isn't a plugin for your favorite editor, go ahead and create one!

For more detail on how to write plugins, check out the [Wiki](https://github.com/git-time-metric/gtm/wiki/Editor-Plugins).

# Support

To report a bug, please submit an issue on the [GitHub Page](https://github.com/git-time-metric/gtm/issues)

Consult the [Wiki](https://github.com/git-time-metric/gtm/wiki) for more information.


git-time-metric

Go library for encoding structs into Header fields.

# go-httpheader

go-httpheader is a Go library for encoding structs into Header fields.

[![Build Status](https://github.com/mozillazg/go-httpheader/workflows/CI/badge.svg?branch=master)](https://github.com/mozillazg/go-httpheader/actions)
[![Coverage Status](https://coveralls.io/repos/github/mozillazg/go-httpheader/badge.svg?branch=master)](https://coveralls.io/github/mozillazg/go-httpheader?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/mozillazg/go-httpheader)](https://goreportcard.com/report/github.com/mozillazg/go-httpheader)
[![GoDoc](https://godoc.org/github.com/mozillazg/go-httpheader?status.svg)](https://godoc.org/github.com/mozillazg/go-httpheader)

## install

```
go get github.com/mozillazg/go-httpheader
```


## usage

```go
package main

import (
	"fmt"
	"net/http"

	"github.com/mozillazg/go-httpheader"
)

type Options struct {
	hide         string
	ContentType  string `header:"Content-Type"`
	Length       int
	XArray       []string `header:"X-Array"`
	TestHide     string   `header:"-"`
	IgnoreEmpty  string   `header:"X-Empty,omitempty"`
	IgnoreEmptyN string   `header:"X-Empty-N,omitempty"`
	CustomHeader http.Header
}

func main() {
	opt := Options{
		hide:         "hide",
		ContentType:  "application/json",
		Length:       2,
		XArray:       []string{"test1", "test2"},
		TestHide:     "hide",
		IgnoreEmptyN: "n",
		CustomHeader: http.Header{
			"X-Test-1": []string{"233"},
			"X-Test-2": []string{"666"},
		},
	}
	h, _ := httpheader.Header(opt)
	fmt.Printf("%#v", h)
	// h:
	// http.Header{
	//	"X-Test-1":     []string{"233"},
	//	"X-Test-2":     []string{"666"},
	//	"Content-Type": []string{"application/json"},
	//	"Length":       []string{"2"},
	//	"X-Array":      []string{"test1", "test2"},
	//	"X-Empty-N":    []string{"n"},
	// }
	
	// decode
	var decode Options
	httpheader.Decode(h, &decode)
}
```


go-httpheader

A native, high-quality and minimalistic QR code generator.

# go-qr
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#utilities)
[![Go Report Card](https://goreportcard.com/badge/github.com/piglig/go-qr)](https://goreportcard.com/report/github.com/piglig/go-qr)
[![Build Status](https://github.com/piglig/go-qr/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/piglig/go-qr/actions/workflows/go.yml?query=branch%3Amain)
[![Codecov](https://img.shields.io/codecov/c/github/piglig/go-qr)](https://app.codecov.io/github/piglig/go-qr)
[![GoDoc](https://godoc.org/github.com/piglig/go-qr?status.svg)](https://pkg.go.dev/github.com/piglig/go-qr)
[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/piglig/go-qr/blob/main/LICENSE)

> 🎶 Go Community Minimalist QR Code Generator Library.

## Overview
This library is native, high quality and minimalistic. Generate QR code from string text
 
It is mostly a translation of [project Nayuki's Java version of the QR code generator](https://www.nayuki.io/page/qr-code-generator-library).

## Features
* Minimalist native code implementation
* Based on QR Code Model 2 standard, supports all 40 versions and all 4 error correction levels
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encoding space optimisation for numeric and special alphanumeric texts
* Japanese Unicode Text Encoding Optimisation
* For mixed numeric/alphanumeric/general/kanji text, computes optimal segment mode switching
* Good test coverage
* MIT's Open Source License

## Installation
```go
go get github.com/piglig/go-qr
```

## [Examples](https://github.com/piglig/go-qr/tree/master/example/main.go)
```go
package main

import (
	go_qr "github.com/piglig/go-qr"
	"image/color"
)

func main() {
	doBasicDemo()
}

func doBasicDemo() {
	text := "Hello, world!"
	errCorLvl := go_qr.Low
	qr, err := go_qr.EncodeText(text, errCorLvl)
	if err != nil {
		return
	}
	config := go_qr.NewQrCodeImgConfig(10, 4)
	err = qr.PNG(config, "hello-world-QR.png")
	if err != nil {
		return
	}

	err = qr.SVG(config, "hello-world-QR.svg", "#FFFFFF", "#000000")
	if err != nil {
		return
	}

	err = qr.SVG(go_qr.NewQrCodeImgConfig(10, 4, go_qr.WithSVGXMLHeader(true)), "hello-world-QR-xml-header.svg", "#FFFFFF", "#000000")
	if err != nil {
		return
	}
}
```

## Command Line Tool
**generator** command line tool to generate the QR Code.
### Installation
In order to use the tool, compile it using the following command
```shell
go install github.com/piglig/go-qr/tools/generator@latest
```

### Usage
```shell
generator [options] [arguments]
  -content string
        Content to encode in the QR code
  -png string
        Output PNG file name
  -svg string
        Output SVG file name
  -svg-optimized
        Output optimized SVG file name - regions with connected black pixels are merged into a single path
```

### Example
* **Text Art**
```shell
generator -content hello
```
![Gif](./docs/assets/text_art.gif)

* **Image Type**
```shell
generator -content hello -png hello.png -svg hello.svg
```
![Gif](./docs/assets/image_type.gif)

* **Optimized SVG Type**
```shell
generator -content hello -svg hello.svg -svg-optimized hello-optimized.svg 
```
The optimized svg output create paths around connected black regions. This reduces the file size and rendering artifacts.
![svg](./docs/assets/optimized_path.svg)

## License
See the [LICENSE](LICENSE) file for license rights and limitations (MIT).

go-qr

A scanner similar to bufio.Scanner, but it reads and returns lines in reverse order, starting at a given position and going backward.

# backscanner

![Build Status](https://github.com/icza/backscanner/actions/workflows/go.yml/badge.svg)
[![Go Reference](https://pkg.go.dev/badge/github.com/icza/backscanner.svg)](https://pkg.go.dev/github.com/icza/backscanner)
[![Go Report Card](https://goreportcard.com/badge/github.com/icza/backscanner)](https://goreportcard.com/report/github.com/icza/backscanner)
[![codecov](https://codecov.io/gh/icza/backscanner/branch/master/graph/badge.svg)](https://codecov.io/gh/icza/backscanner)

Ever needed or wondered how to efficiently search for something in a log file,
but starting at the end and going backward? Here's your solution.

Package `backscanner` provides a scanner similar to `bufio.Scanner`, but it reads
and returns lines in reverse order, starting at a given position (which may be
the end of the input) and going backward.

This library only uses the standard library, but the test uses an external package.
To install this library (along with the test dependency), simply run:

    go get -t github.com/icza/backscanner

Advancing and accessing lines of the input is done by calling `Scanner.Line()`,
which returns the next line (previous in the source) as a `string`.

For maximum efficiency there is `Scanner.LineBytes()`. It returns the next line
as a byte slice, which shares its backing array with the internal buffer of
`Scanner`. This is because no copy is made from the line data; but this also
means you can only inspect or search in the slice before calling `Line()` or
`LineBytes()` again, as the content of the internal buffer–and thus slices
returned by `LineBytes()`–may be overwritten. If you need to retain the line
data, make a copy of it or use `Line()`.


Example using it:

	input := "Line1\nLine2\nLine3"
	scanner := backscanner.New(strings.NewReader(input), len(input))
	for {
		line, pos, err := scanner.Line()
		if err != nil {
			fmt.Println("Error:", err)
			break
		}
		fmt.Printf("Line position: %2d, line: %q\n", pos, line)
	}

Output:

	Line position: 12, line: "Line3"
	Line position:  6, line: "Line2"
	Line position:  0, line: "Line1"
	Error: EOF

Using it to efficiently scan a file, finding last occurrence of a string (`"error"`):

	file, err := os.Open("mylog.txt")
	if err != nil {
		panic(err)
	}
	fileStatus, err := file.Stat()
	if err != nil {
		panic(err)
	}
	defer file.Close()

	scanner := backscanner.New(file, int(fileStatus.Size()))
	what := []byte("error")
	for {
		line, pos, err := scanner.LineBytes()
		if err != nil {
			if err == io.EOF {
				fmt.Printf("%q is not found in file.\n", what)
			} else {
				fmt.Println("Error:", err)
			}
			break
		}
		if bytes.Contains(line, what) {
			fmt.Printf("Found %q at line position: %d, line: %q\n", what, pos, line)
			break
		}
	}


backscanner

Package contextplus provide more easy to use functions for contexts.

[![Go Report Card](https://goreportcard.com/badge/github.com/contextplus/contextplus)](https://goreportcard.com/report/github.com/contextplus/contextplus)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/contextplus/contextplus)](https://pkg.go.dev/github.com/contextplus/contextplus)
[![Go package](https://github.com/contextplus/contextplus/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/contextplus/contextplus/actions/workflows/test.yaml)
[![codecov](https://codecov.io/gh/contextplus/contextplus/branch/main/graph/badge.svg?token=L8E15TDQFP)](https://codecov.io/gh/contextplus/contextplus)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

# contextplus

Package contextplus provide more easy to use functions for contexts.

# Use

```
go get -u github.com/contextplus/contextplus
```
# Example
This is how an http.Handler should run a goroutine that need values from the context. Pretend to use the middleware that timeout after one second.

```golang
func myMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()
		ctx, cancel := context.WithTimeout(time.Second)
		defer cancel()
		r = r.WithContext(ctx)
		next.ServeHTTP(w, r)
	})
}
```

```golang
func handle(w http.ResponseWriter, r *http.Request) {
	asyncCtx := contextplus.WithOnlyValue(r.Context())
	go func() {
		// will not cancel if timeout
		// will not cancel if call 'cancel'
		asyncTask(asyncCtx)
	}()
}
```

```golang
func handle(w http.ResponseWriter, r *http.Request) {
	asyncCtx := contextplus.WithoutCancel(r.Context())
	go func() {
		// will cancel if timeout
		// will not cancel if call 'cancel'
		asyncTask(asyncCtx)
	}()
}
```


contextplus

Cookie struct parsing and helper package.

cookie

Evaluate an expression dynamically based on s-expression. It's simple and easy to extend.

[![Build Status](https://travis-ci.org/nullne/evaluator.svg?branch=master)](https://travis-ci.org/nullne/evaluator.svg?branch=master)
[![Coverage Status](https://coveralls.io/repos/github/nullne/evaluator/badge.svg)](https://coveralls.io/github/nullne/evaluator)
[![GoDoc](https://godoc.org/github.com/nullne/evaluator?status.svg)](http://godoc.org/github.com/nullne/evaluator)
[![Go Report Card](https://goreportcard.com/badge/github.com/nullne/evaluator)](https://goreportcard.com/report/github.com/nullne/evaluator)

It's very common to evaluate an expression dynamicly, so that's why we are here.  
#### S-expression
We use s-epxression syntax to parse and evaluate.
> In computing, s-expressions, sexprs or sexps (for "symbolic expression") are a notation for nested list (tree-structured) data, invented for and popularized by the programming language Lisp, which uses them for source code as well as data. 

For example, for expression in common way:
​	
	(
			(gender = "female")
	 and  
	 		((age % 2) != 0)
	 )
it's coresponding format in s-expression is:
​	
	(and
		(= gender "female")
		(!= 
			(% age 2)
			0
		)
	)

#### Element types within expression
- number  
  For convenience, we treat float64, int64 and so on as type of number. For example, float `100.0` is equal to int `100`, but not euqal to string `"100"`

- string  
   character string quoted with `` ` ``, `'`, or `"` are treated as type of `string`. You can convert type `string` to any other defined type you like by type convert functions which are mentioned later

- function or variable  
    character string without quotes are regarded as type of `function` or `variable` which depends on whether this function exists. For example in expression `(age birthdate)`, both `age` and `birthdate` is unquoted. `age` is type of function because we have registered a function named `age`, while `birthdate` is type of variable for not found. The program will come to errors if there is neither parameter nor function named `birthdate` when evaluating


#### How to
You can evaluate directly:

    params := evaluator.MapParams{
        "gender": "female",
    }
    res, err := evaluator.EvalBool(`(in gender ("female" "male"))`, params)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(res)
    # true	

or you can reuse the `Expression` to evaluate multiple times:

    params := evaluator.MapParams{
        "gender": "female",
    }
    exp, err := evaluator.New(`(in gender ("female" "male"))`)
    if err != nil {
        log.Fatal(err)
    }
    res, err := exp.EvalBool(params)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(res)
    # true

##### And you can write expressions like this
- `(in gender ("male", "female"))`
- `(between now (td_time "2017-01-02 12:00:00") (td_time "2017-12-02 12:00:00"))`
- `(ne (mod (age birthdate) 7) 5)`
- or multiple-line for clarity

  ```
  (and
  	(ne os "ios")
  	(eq gender "male")
  	(beteen version (t_version "2.7.1") (t_version "2.9.1"))
  )
  ```


#### Functions
##### Implemented functions


| operand | function  | example | description 
| ------- | --------- | ---------- | ----
| -       | `in`      | `(in 1 (1 2))` | also suport array like `(in (1) ((1)))`
| -       | `between` | `(between age 18 20)` 
| -       | `overlap` | `(overlap region (3142 1860))` 
| `&`     | `and`     | `(and (eq gender "femal") (between age 18 20))`
| `|`     | `or`      |
| `!`     | `not`     |
| `=`     | `eq`      | | equal
| `!=`    | `ne`      | | not equal
| `>`     | `gt`      | | greater than
| `<`     | `lt`      | | less than
| `>=`    | `ge`      | | greater than or equal to
| `<=`    | `le`      | | less than or equal to
| `%`     | `mod`     |
| `+`     | -         | | plus 
| `-`     | -         | | minus
| `*`     | -         | | multiply
| `/`     | -         | | divide
| -       | `t_version` ||  convert type to version
| -       | `t_time`    |`(t_time "2006-01-02 15:04" "2017-09-09 12:00")`| convert type to time, first param must be the layout for the time
| -       | `td_time` |`(td_time "2017:09:09 12:00:00)`| convert type to time of default layout format `2006-01-02 15:04:05`
| _       | `td_date`    |`(in (td_date now) (td_date ("2017-01-02" "2017-02-01")) )`| convert type to time  of default layout format `2006-01-02`

p.s. either operand or function can be used in expression
##### How to use self-defined functions
Yes, you can write your own function by following thses steps:

1. implement your function
2. regist to functions
3. enjoy it

here is an example:

```go
package main


import (
	"errors"
	"log"
	"time"

	"github.com/nullne/evaluator"
	"github.com/nullne/evaluator/function"
)

// define your own function and don't forget to register
func age(params ...interface{}) (interface{}, error) {
	if len(params) != 1 {
		return nil, errors.New("only one params accepted")
	}
	birth, ok := params[0].(string)
	if !ok {
		return nil, errors.New("birth format need to be string")
	}
	r, err := time.Parse("2006-01-02", birth)
	if err != nil {
		return nil, err
	}
	now := time.Now()
	a := r.Year() - now.Year()
	if r.Month() < now.Month() {
		a--
	} else if r.Month() == now.Month() {
		if r.Day() < now.Day() {
			a--
		}
	}
	return a, nil
}

func main() {
	if err := function.Regist("age", age); err != nil {
		log.Print(err)
	}

	exp := `(not (between (age birthdate) 18 20))`
	vvf := evaluator.MapParams{
		"birthdate": "1980-02-01",
	}
	e, err := evaluator.New(exp)
	if err != nil {
		log.Print(err)
	}
	r, err := e.Eval(vvf)
	if err != nil {
		log.Print(err)
	}
	log.Printf("expression: `%s`, wanna: %+v, got: %+v\r", exp, true, r)
}
```


#### Params
- `Params` interface, which has a method named `Get` to get all params needed
- `MapParams` a simple implemented `Params` in `map`

#### Bench
    BenchmarkEqualString-8   	 3000000	       473 ns/op
    BenchmarkInString-8      	 2000000	       916 ns/op
    BenchmarkBetweenInt-8    	 3000000	       467 ns/op
    BenchmarkBetweenTime-8   	 1000000	      2089 ns/op
    BenchmarkOverlapInt-8    	  500000	      2966 ns/op
    BenchmarkTypeTime-8      	 2000000	       638 ns/op
    BenchmarkTypeVersion-8   	 3000000	       539 ns/op

p.s. on MacBook Pro (Retina, 15-inch, Mid 2015), Memory: 16 GB 1600 MHz DDR3, Processor: 2.2 GHz Intel Core i7


evaluator

go-rate
===============

[![Build Status](https://travis-ci.org/beefsack/go-rate.svg?branch=master)](https://travis-ci.org/beefsack/go-rate)
[![GoDoc](https://godoc.org/github.com/beefsack/go-rate?status.svg)](https://godoc.org/github.com/beefsack/go-rate)

**go-rate** is a rate limiter designed for a range of use cases,
including server side spam protection and preventing saturation of APIs you
consume.

It is used in production at
[LangTrend](http://langtrend.com/l/Java,PHP,JavaScript) to adhere to the GitHub
API rate limits.

Usage
-----

Import `github.com/beefsack/go-rate` and create a new rate limiter with
the `rate.New(limit int, interval time.Duration)` function.

The rate limiter provides a `Wait()` and a `Try() (bool, time.Duration)` method
for both blocking and non-blocking functionality respectively.

API documentation available at [godoc.org](http://godoc.org/github.com/beefsack/go-rate).

Examples
--------

### Blocking rate limiting

This example demonstrates limiting the output rate to 3 times per second.

```Go
package main

import (
	"fmt"
	"time"

	"github.com/beefsack/go-rate"
)

func main() {
	rl := rate.New(3, time.Second) // 3 times per second
	begin := time.Now()
	for i := 1; i <= 10; i++ {
		rl.Wait()
		fmt.Printf("%d started at %s\n", i, time.Now().Sub(begin))
	}
	// Output:
	// 1 started at 12.584us
	// 2 started at 40.13us
	// 3 started at 44.92us
	// 4 started at 1.000125362s
	// 5 started at 1.000143066s
	// 6 started at 1.000144707s
	// 7 started at 2.000224641s
	// 8 started at 2.000240751s
	// 9 started at 2.00024244s
	// 10 started at 3.000314332s
}
```

### Blocking rate limiting with multiple limiters

This example demonstrates combining rate limiters, one limiting at once per
second, the other limiting at 2 times per 3 seconds.

```Go
package main

import (
	"fmt"
	"time"

	"github.com/beefsack/go-rate"
)

func main() {
	begin := time.Now()
	rl1 := rate.New(1, time.Second)   // Once per second
	rl2 := rate.New(2, time.Second*3) // 2 times per 3 seconds
	for i := 1; i <= 10; i++ {
		rl1.Wait()
		rl2.Wait()
		fmt.Printf("%d started at %s\n", i, time.Now().Sub(begin))
	}
	// Output:
	// 1 started at 11.197us
	// 2 started at 1.00011941s
	// 3 started at 3.000105858s
	// 4 started at 4.000210639s
	// 5 started at 6.000189578s
	// 6 started at 7.000289992s
	// 7 started at 9.000289942s
	// 8 started at 10.00038286s
	// 9 started at 12.000386821s
	// 10 started at 13.000465465s
}
```

### Non-blocking rate limiting

This example demonstrates non-blocking rate limiting, such as would be used to
limit spam in a chat client.

```Go
package main

import (
	"fmt"
	"time"

	"github.com/beefsack/go-rate"
)

var rl = rate.New(3, time.Second) // 3 times per second

func say(message string) {
	if ok, remaining := rl.Try(); ok {
		fmt.Printf("You said: %s\n", message)
	} else {
		fmt.Printf("Spam filter triggered, please wait %s\n", remaining)
	}
}

func main() {
	for i := 1; i <= 5; i++ {
		say(fmt.Sprintf("Message %d", i))
	}
	time.Sleep(time.Second / 2)
	say("I waited half a second, is that enough?")
	time.Sleep(time.Second / 2)
	say("Okay, I waited a second.")
	// Output:
	// You said: Message 1
	// You said: Message 2
	// You said: Message 3
	// Spam filter triggered, please wait 999.980816ms
	// Spam filter triggered, please wait 999.976704ms
	// Spam filter triggered, please wait 499.844795ms
	// You said: Okay, I waited a second.
}
```

Authors
-------

* [Michael Alexander](https://github.com/beefsack)
* [Geert-Johan Riemer](https://github.com/GeertJohan)
* [Matt T. Proud](https://github.com/matttproud)


go-rate

Common libraries for writing Go services/applications from Dropbox.

# godropbox [![GoDoc](https://godoc.org/github.com/dropbox/godropbox?status.svg)](https://godoc.org/github.com/dropbox/godropbox) [![Actions Status](https://github.com/dropbox/godropbox/workflows/Test/badge.svg)](https://github.com/dropbox/godropbox/actions) [![Actions Status](https://github.com/dropbox/godropbox/workflows/Lint/badge.svg)](https://github.com/dropbox/godropbox/actions)

Common libraries for writing go services/applications on Linux servers.

### Requirements
 * Go 1.13+
 * Linux/x64

### Installation
``go get github.com/dropbox/godropbox``

### Documentation

See https://pkg.go.dev/github.com/dropbox/godropbox for modules documentation.


godropbox

High performance utility functions written using Generics for Go 1.18+.

gofn

Various tools/modules help for development.

# Gohper [![wercker status](https://app.wercker.com/status/7736d0f7ea77997f830cb7aee6b3ea5a/s "wercker status")](https://app.wercker.com/project/bykey/7736d0f7ea77997f830cb7aee6b3ea5a) [![GoDoc](https://godoc.org/github.com/cosiner/gohper?status.png)](http://godoc.org/github.com/cosiner/gohper)

Common libs.

### Contribution
Use, Test, Commit your libs.

### License
MIT.


gohper

wrap git commands with additional functionality to interact with github from the terminal.

Utility for generating random data based on an input template.

# Moldova [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/StabbyCutyou/moldova) [![Build Status](https://api.travis-ci.org/StabbyCutyou/moldova.svg)](https://travis-ci.org/StabbyCutyou/moldova)
Moldova is a lightweight template interpreter, used to generate random values that plug into the template, as defined by a series of custom tokens.

It understands the tokens as defined further down in the document.

Moldova comes both as a library you can import, as well as a binary executable that you can run, which will output results to STDOUT.

The intended use is via the binary executable.

## Works great with the Slammer

Moldova was originally designed as input to a database load testing tool, called the [Slammer](https://github.com/StabbyCutyou/slammer). It's primary purpose was to
generate INSERT and SELECT statements, which were then loaded into the Slammer. If you're looking for a good tool to
test the throughput and latency of database operations at scale, checkout the Slammer.

And if you're interested in using them together, checkout the [Moldovan Slammer](http://github.com/StabbyCutyou/moldovan_slammer), a quick helper repo to
demonstrate using them together

## Moldova command

To use the command, first install

```bash
go install github.com/StabbyCutyou/moldova/cmd/moldova
```

The command accepts 2 arguments:

* n - How many templates to render to STDOUT. The default is 1, and it cannot be less than 1.
* t - The template to render

## Example

```bash
moldova -t "INSERT INTO floof VALUES ('{guid}','{guid:ordinal:0}','{country}',{int:min:-2000|max:0},{int:min:100|max:1000},{float:min:-1000.0|max:-540.0},{int:min:1|max:40},'{now}','{now:ordinal:0}','{country:case:up}',NULL,-3)" -n 100
```

This would provide sample output like the following:

```sql
...
INSERT INTO floof VALUES ('791add99-43df-44c8-8251-6f7af7a014df','791add99-43df-44c8-8251-6f7af7a014df','MU',-1540,392,-624.529332,39,'2016-01-24 23:42:49','2016-01-24 23:42:49','UN',NULL,-3)
INSERT INTO floof VALUES ('0ab4cc33-6689-404f-a801-4fd431ca3f30','0ab4cc33-6689-404f-a801-4fd431ca3f30','PL',-1707,112,-550.333145,1,'2016-01-24 23:42:49','2016-01-24 23:42:49','SS',NULL,-3)
INSERT INTO floof VALUES ('a3f4151a-a304-4190-a3df-7fd97ce58588','a3f4151a-a304-4190-a3df-7fd97ce58588','CM',-1755,569,-961.122173,25,'2016-01-24 23:42:49','2016-01-24 23:42:49','NE',NULL,-3)
```

# Tokens

Tokens are represented by special values placed inside of { } characters.

Each token follows this pattern:

{command:argument_name:value|argument_name:value|...|...}

Each token defines it's own set of arguments, which are outlined below. If you're provided multiple arguments, the key-value pairs of argument names to values are delimited by a | pipe character. These can be provided in any order, so long as they are valid arguments.

It is only necessary to provide a | when you have further arguments to provide. For example:

* {int}
* {int:min:10}
* {int:min:10|max:50}
* {int:min:10|max:50|ordinal:0}


## {guid}

### Options
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {guid} with a GUID/UUID

If you provide the *ordinal:* option, for the current line of text being generated,
you can have Moldova insert an existing value, rather than a new one. For
example:

"{guid} - {guid:ordinal:0}"

In this example, both guids will be replaced with the same value. This is a way
to back-reference existing generated values, for when you need something repeated.

## {now}

### Options
* format : string, either "simple", "simpletz", or a golang date format string
* ordinal : integer >= 0
* zone: A timezone to represent the time in. You can use any value accepted [here](https://golang.org/pkg/time/#LoadLocation)

### Description

Moldova will replace any instance of {now} with a string representation of Golangs
time.Now() function, formatted per the provided date format. There are 2 built in formats, for convenience, that are compatible with many databases.

* simple - "2006-01-02 15:04:05"
* simpletz - "2006-01-02 15:04:05 -0700"

Additionally, you can provide your own format string.

{now} also supports the *ordinal:* option

## {time}

### Options
* min : integer < max, unix epoch value
* max : integer > min, unix epoch value
* format : string, either "simple", "simpletz", or a golang date format string
* ordinal : integer >= 0
* zone: A timezone to represent the time in. You can use any value accepted [here](https://golang.org/pkg/time/#LoadLocation)


### Description

Moldova will replace any instance of {time} with a string representation of a random time, between min and max in terms of Unix Epoch values. The defaults are between 0, and roughly Now (determined at runtime) There are 2 built in formats, for convenience, that are compatible with many databases.

* simple - "2006-01-02 15:04:05"
* simpletz - "2006-01-02 15:04:05 -0700"

Additionally, you can provide your own format string.

{time} also supports the *ordinal:* option

## {int}

### Options
* min : integer < max
* max : integer > min
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {int} with a random int value, optionally between the range provided. The defaults, if not provided, are 0 to 100.

{int} also supports *ordinal:* option

## {float}

### Options
* min : integer < max
* max : integer > min
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {float} with a random Float64, optionally between the range provided. The defaults, if not provided, are 0.0 to 100.0

{float} also supports *ordinal:* option

## {unicode}

### Options
* length : integer >= 1
* case : "up" or "down"
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {unicode} with a randomly generated set of unicode
characters, of a length specified by :number. The default value is 2.

{unicode} also takes the :case argument, which is either 'up' or 'down', like so

{unicode:case:up}
{unicode:case:down}

{unicode} also supports *ordinal:* option

Only a certain subset of unicode character ranges are supported by default, as defined
in the moldova/data/unicode.go file.

## {ascii}

### Options
* length : integer >= 1
* case : "up" or "down"
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {ascii} with a randomly generated set of ASCII
characters, of a length specified by :number. The default value is 2.

{ascii} also takes the :case argument, which is either 'up' or 'down', like so

{ascii:case:up}
{ascii:case:down}

{ascii} also supports *ordinal:* option

## {firstname}

### Options
* language : any string value
* case : "up" or "down"
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {firstname} with a randomly generated first
name, from the list defined in data/names.go

{firstname} takes a :langage argument, which can be any of the supported language
strings in data/names.go. If the chosen name does not have an entry for the selected
language, the configured default will be used in it's place. For exmaple:

{firstname:language:romanian}

{firstname} also takes the :case argument, which is either 'up' or 'down', like so

{firstname:case:up}
{firstname:case:down}

{firstname} also supports *:ordinal* option

Only a certain subset of unicode character ranges are supported by default, as defined
in the moldova/data/unicode.go file.

## {lastname}

### Options
* language : any string value
* case : "up" or "down"
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {firstname} with a randomly generated first
name, from the list defined in data/names.go

{lastname} takes a :langage argument, which can be any of the supported language
strings in data/names.go. If the chosen name does not have an entry for the selected
language, the configured default will be used in it's place. For example:

{lastname:language:romanian}

{lastname} also takes the :case argument, which is either 'up' or 'down', like so

{lastname:case:up}
{lastname:case:down}

{lastname} also supports *:ordinal* option

Only a certain subset of unicode character ranges are supported by default, as defined
in the moldova/data/unicode.go file.

## {country}

### Options
* case : "up" or "down"
* ordinal : integer >= 0

### Description

Moldova will replace any instance of {country} with an ISO 3166-1 alpha-2 country code.

{country} supports the same *case:* argument as {unicode}. The default value is "up"

{country} also supports the *ordinal:* argument.

# Roadmap

I'll continue to add support for more random value categories. There are also hooks to support ascii-only string generation, but as of yet it is not implemented.

Add proper support for escaping control characters, so they are not interpreted as part of a token. These characters are {, }, :, and |.

# License

Apache v2 - See LICENSE


moldova

mole

Database client library, proxy for any master slave, master master structures. Lightweight and auto balancing in mind.

# mssqlx

[![](https://github.com/linxGnu/mssqlx/workflows/CI/badge.svg)]()
[![Go Report Card](https://goreportcard.com/badge/github.com/linxGnu/mssqlx)](https://goreportcard.com/report/github.com/linxGnu/mssqlx)
[![Coverage Status](https://coveralls.io/repos/github/linxGnu/mssqlx/badge.svg?branch=master)](https://coveralls.io/github/linxGnu/mssqlx?branch=master)
[![godoc](https://img.shields.io/badge/docs-GoDoc-green.svg)](https://godoc.org/github.com/linxGnu/mssqlx)

Embeddable, high availability, performance and lightweight database client library. Support go 1.9 or newer.

Features and concepts are:

* Builtin layer/extension to [sqlx](http://jmoiron.github.io/sqlx).
* Auto proxy for any master-slave, master-master databases. Compatible with Wsrep, Galera Cluster and others.
* Auto and lightweight round-robin balancer for queries.
* Builtin error handling for Wsrep, Galera and some database drivers. Auto retry `select/get/query` queries when detected bad connection causing by DBMS's timeout policy which auto-closes non interactive/timeout connection.
* Auto health checking.

For more detail of api, please refer to [godoc](https://godoc.org/github.com/linxGnu/mssqlx)

## Install

    go get -u github.com/linxGnu/mssqlx

## Connecting to Databases

mssqlx is compatible to all kind of databases which `database/sql` supports. Below code is `mysql` usage:

```go
import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/linxGnu/mssqlx"
)

dsn := "root:123@(%s:3306)/test?charset=utf8&collation=utf8_general_ci&parseTime=true"
masterDSNs := []string{
    fmt.Sprintf(dsn, "172.31.25.233"), // address of master 1
    fmt.Sprintf(dsn, "172.31.24.233"), // address of master 2 if have
    fmt.Sprintf(dsn, "172.31.23.233"), // address of master 3 if have
}
slaveDSNs := []string{
    fmt.Sprintf(dsn, "172.31.25.234"), // address of slave 1
    fmt.Sprintf(dsn, "172.31.25.235"), // address of slave 2
    fmt.Sprintf(dsn, "172.31.25.236"), // address of slave 3
}

db, _ := mssqlx.ConnectMasterSlaves("mysql", masterDSNs, slaveDSNs)
```

## Connecting to Galera Cluster

Recommended to set flag as following: 

```go
db, _ := mssqlx.ConnectMasterSlaves("mysql", masterDSNs, slaveDSNs, mssqlx.WithWsrep())
```

## Connecting to Databases with custom read-query source

Read-queries will be distributed among both masters and slaves: 

```go
db, _ := mssqlx.ConnectMasterSlaves("mysql", masterDSNs, slaveDSNs, mssqlx.WithReadQuerySource(mssqlx.ReadQuerySourceAll))
```

## Configuration

It's highly recommended to setup configuration before querying.

```go
db.SetMaxIdleConns(20) // set max idle connections to all nodes
// db.SetMasterMaxIdleConns(20) // set max idle connections to master nodes
// db.SetSlaveMaxIdleConns(20) // set max idle connections to slave nodes

db.SetMaxOpenConns(50) // set max open connections to all nodes
// db.SetMasterMaxOpenConns(50) 
// db.SetSlaveMaxOpenConns(50)
    
// if nodes fail, checking healthy in a period (in milliseconds) for auto reconnect. Default is 500.
db.SetHealthCheckPeriod(1000) 
// db.SetMasterHealthCheckPeriod(1000)
// db.SetSlaveHealthCheckPeriod(1000)
```

## Select

```go
type Person struct {
    FirstName string `db:"first_name"`
    LastName  string `db:"last_name"`
    Email     string
    Data      []byte
}

var people []Person
db.Select(&people, "SELECT * FROM person WHERE id > ? and id < ? ORDER BY first_name ASC", 1, 1000)
```

## Get

```go
var person Person
db.Get(&person, "SELECT * FROM person WHERE id = ?", 1)
```

## Queryx

```go
// Loop through rows using only one struct
var person Person

rows, err := db.Queryx("SELECT * FROM person") // or db.QueryxOnMaster(...)
for rows.Next() {
    if err := rows.StructScan(&person); err != nil {
        log.Fatalln(err)
    } 
    fmt.Printf("%#v\n", person)
}
```

## Named query

```go
// Loop through rows using only one struct
var person Person

rows, err := db.NamedQuery(`SELECT * FROM person WHERE first_name = :fn`, map[string]interface{}{"fn": "Bin"}) // or db.NamedQueryOnMaster(...)
for rows.Next() {
    if err := rows.StructScan(&person); err != nil {
        log.Fatalln(err)
    } 
    fmt.Printf("%#v\n", person)
}
```

## Exec (insert/update/delete/etc...)

```go
result, err := db.Exec("DELETE FROM person WHERE id < ?", 100)
```

## Transaction

```go
// Recommended write transaction this way
tx, e := db.Begin()
if e != nil {
	return e
}
    
shouldAutoRollBack := true
defer func() {
	if e := recover(); e != nil {
		err = fmt.Errorf("%v", e)
		tx.Rollback()
	} else if err != nil && shouldAutoRollBack {
		tx.Rollback()
	}
}()
			
if _, err = tx.Exec("INSERT INTO person(first_name, last_name, email, data) VALUES (?,?,?,?)", "Jon", "Dow", "jon@gmail", []byte{1, 2}); err != nil {
        return
}
    
if _, err = tx.Exec("INSERT INTO person(first_name, last_name, email, data) VALUES (?,?,?,?)", "Jon", "Snow", "snow@gmail", []byte{1}); err != nil {
    return
}
			
if err = tx.Commit(); err != nil {
    shouldAutoRollBack = false
}
```

## Notices

* APIs supports executing query on master-only or slave-only (or boths). Function name for querying on master-only has suffix `OnMaster`, querying on slaves-only has suffix `OnSlave`.
* Default `select/show queries` are balanced on slaves.


mssqlx

multitick

Performant and flexible struct mapping and loose type conversion.

[![Go Reference](https://pkg.go.dev/badge/github.com/nofeaturesonlybugs/set.svg)](https://pkg.go.dev/github.com/nofeaturesonlybugs/set)
[![Go Report Card](https://goreportcard.com/badge/github.com/nofeaturesonlybugs/set)](https://goreportcard.com/report/github.com/nofeaturesonlybugs/set)
[![Build Status](https://app.travis-ci.com/nofeaturesonlybugs/set.svg?branch=master)](https://app.travis-ci.com/nofeaturesonlybugs/set)
[![codecov](https://codecov.io/gh/nofeaturesonlybugs/set/branch/master/graph/badge.svg)](https://codecov.io/gh/nofeaturesonlybugs/set)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Package `set` is a performant reflect wrapper supporting loose type conversion, struct mapping and population, and slice building.

The `godoc` documentation has detailed information and many examples but following is the high-level view.

## Type Coercion

Type coercion allows assignment from loosey-goosey sources -- for example incoming string data -- to strongly typed Go types.

```go
var t T           // T is a target data type, t is a variable of that type.
var s S           // S is a source data type, s is a variable of that type.
set.V(&t).To(s)   // Sets s into t with a "best effort" approach.
```

## Struct Population with Getter

`set.Value` has two methods, `Fill` and `FillByTag`, that use the `set.Getter` interface as the provider for data to populate a struct and its hierarchy.

For convenience:

-   `set.GetterFunc` allows plain functions to be used as a `set.Getter` similar to `http.HandlerFunc`.
-   `set.MapGetter` allows either `map[string]T` or `map[interface{}]T` to be used as a `set.Getter`.

## Struct Mapping

`set.Mapper` is a powerful and highly configurable struct mapping facility.

A mapper will traverse a struct hiearchy and create a `1:1` mapping of `friendly names` to `traversal information`. The friendly names can then be used to target associated fields within a struct value and its hierarchy.

Example usages of a mapper are to map CSV column headings to struct fields, database column names to struct fields,
or creating a generic struct copier to marshal structs across different domains or boundaries in your application architecture.

`set.Mapper` contains several configuration fields that can be used to fully customize the generated `friendly names`:

-   Choose how nested names are combined: `VendorName`, `Vendor_Name`, `Vendor.Name`, `vendor_name`, etc.
-   Specify multiple tags in order of preference: `db` tag values can have higher precedence than `json` tags
-   Elevate types into a higher namespace: see the Mapper example(s)
-   Specify types that are ignored and don't get mapped.
-   Specify types that are treated as scalars: useful for sql.Null\* types or similar

## BoundMapping and PreparedMapping

Once a `set.Mapper` (described above) is created it can return `BoundMapping` or `PreparedMapping` types that are bound to Go structs. In turn `BoundMapping` and `PreparedMapping` provide performant access to the bound data via the friendly names generated by the mapper.

A `BoundMapping` provides an adhoc access to struct fields; each method takes the mapped name of the field to access. An example use case for `BoundMapping` is populating data when some of the data may be missing and you may not set data for every possible mapped field.

A `PreparedMapping` is similar to a prepared SQL statement and the access plan must be set with a call to its `Plan` method. An example use case for `PreparedMapping` is populating CSV data or database rows where every row is guaranteed to access the same fields in the same order.

## Performance Notes

Package `reflect` is always slower than code not using `reflect`. A considerable effort has been spent designing and implementing this package to reduce reflect overhead.

-   `reflect` data is generally only gathered once (via reflect.TypeOf, reflect.ValueOf) when first encountering a type. This data is cached and retrieved from cache on further encounters with repeated types.
-   Value assigning is generally attempted first with type switches and then falls back to `reflect`. This strategy is heavily used during type coercion.
-   Appropriate types in this package have a `Rebind` method. `Rebind` will swap a "bound" Go type with a new incoming instance without making additional expensive calls into `reflect`. The outgoing and incoming types must be compatible but this is the expected usage in tight loops building slices of data.

Additionally this package attempts to be low allocation so as not to overwhelm the garbage collector.

-   Some of the methods on BoundMapping and PreparedMapping allow a dest slice to be pre-allocated.
-   BoundMapping, PreparedMapping, and Value are created and returned as structs instead of pointers.

## API Consistency and Breaking Changes

I am making a very concerted effort to break the API as little as possible while adding features or fixing bugs. However this software is currently in a pre-1.0.0 version and breaking changes _are_ allowed under standard semver. As the API approaches a stable 1.0.0 release I will list any such breaking changes here and they will always be signaled by a bump in _minor_ version.

-   0.4.0 ⭢ 0.5.0

    -   README-0.4.0-to-0.5.0.md outlines many of the package changes, reasoning, and benchmarks

    -   Remove erroneous documentation for `Value.To` method.  
        The documentation indicated that when Dst and Src are both pointers with same level of indirection that direct assignment was performed. This is not true. The Value type uses the values at the end of pointers and pointer chains and therefore does not perform direct assignment of pointer values.

-   0.3.0 ⭢ 0.4.0  
    set.Mapper has new field TaggedFieldsOnly. `TaggedFieldsOnly=false` means no change in behavior. `TaggedFieldsOnly=true` means set.Mapper only maps exported fields with struct tags.

-   0.2.3 ⭢ 0.3.0  
    set.BoundMapping.Assignables has a second argument allowing you to pre-allocate the slice that is returned; you can also set it to `nil` to keep current behavior.


App shutdown hooks for `os.Signal` handling.

shutdown

Slice, map, multimap, struct, function, data conversion utilities. Service router, macro evaluator, tokenizer.

# Toolbox - go utility library

[![GoReportCard](https://goreportcard.com/badge/github.com/viant/toolbox)](https://goreportcard.com/report/github.com/viant/toolbox)
[![GoDoc](https://godoc.org/github.com/viant/toolbox?status.svg)](https://godoc.org/github.com/viant/toolbox)

This library is compatible with Go 1.8+

Please refer to [`CHANGELOG.md`](CHANGELOG.md) if you encounter breaking changes.

- [Motivation](#Motivation)
- [Collection Utilities](#Collection-Utilities)
- [Converter && Conversion Utilities](#Conversion-Utilities)
- [Struct Utilities](#Struct-Utilities)
- [Function Utilities](#Function-Utilities)
- [Time Utilities](#TimeUtilities)
- [Storage API](#storage)
- [Data substitution](data/)
- [Text Utilities](text/)
- [ServiceRouter](#ServiceRouter)
- [Decoder and Encoder](#DecoderandEncoder)
- [Logger](#Logger)
- [BatchLimiter](#BatchLimiter)
- [AST Based FileSetInfo](#ast-based-filesetinfo)
- [License](#License)
- [Credits and Acknowledgements](#Credits-and-Acknowledgements)



## Motivation

This library was developed as part of [Datastore Connectivity](https://github.com/viant/dsc/) and Testibility libraries: ([Assertly](https://github.com/viant/assertly),  [Datastore testing](https://github.com/viant/dsunit/), [End to end testing](https://github.com/viant/endly/)) 
as a way to share utilities, and other abstractions that may be useful in other projects.


<a name="Collection-Utilities"></a>

### Collection Utilities


#### Iterator

Example
```go
	slice := []string{"a", "z", "c"}
	iterator := toolbox.NewSliceIterator(slice)
    value := ""
    for iterator.HasNext() {
        iterator.Next(&value)
        ...
    }
```

#### Slice utilities

The following methods work on **any slice type.**

**ProcessSlice**

Example
```go
	var aSlice interface{}
	
	toolbox.ProcessSlice(aSlice, func(item interface{}) bool {
    		...
    		return true //to continue to next element return true
    })
	
```


**ProcessSliceWithIndex**

Example:
```go
	var aSlice interface{}
	
	toolbox.ProcessSlice(aSlice, func(index int, item interface{}) bool {
    		...
    		return true //to continue to next element return true
    })
	
```


**IndexSlice**

Example:
```go
    type Foo struct{
		id int
		name string
	}

	var aSlice = []Foo{ Foo{1, "A"}, Foo{2, "B"} }
	var indexedMap = make(map[int]Foo)
	
	toolbox.IndexSlice(aSlice, indexedMap, func(foo Foo) int {
		return foo.id
	})
	
	
```


**CopySliceElements**

Example:
```go
   source := []interface{}{
   		"abc", "def", "cyz",
   	}
   	var target = make([]string, 0)
   	toolbox.CopySliceElements(source, &target)
	
	
```


**FilterSliceElements**

Example:
```go
	source := []interface{}{
		"abc", "def", "cyz","adc",
	}
	var target = make([]string, 0)
	
	toolbox.FilterSliceElements(source, func(item string) bool {
		return strings.HasPrefix(item, "a") //this matches any elements starting with a
	}, &target)
```


**HasSliceAnyElements**

Example:
```go
    source := []interface{}{
		"abc", "def", "cyz","adc",
	}
	toolbox.HasSliceAnyElements(source, "cyz")
```


**SliceToMap**

Example:
```go
    var source = []Foo{ Foo{1, "A"}, Foo{2, "B"} }
	var target = make(map[int]string)
	toolbox.SliceToMap(source, target, func(foo Foo) int {
		return foo.id
	},
	func(foo Foo) string {
		return foo.name
	})
	

```


**TransformSlice**

Example:
```go
type Product struct{ vendor, name string }
	products := []Product{
		Product{"Vendor1", "Product1"},
		Product{"Vendor2", "Product2"},
		Product{"Vendor1", "Product3"},
		Product{"Vendor1", "Product4"},
	}
	var vendors=make([]string, 0)
	toolbox.TransformSlice(products, &vendors, func(product Product) string {
		return product.vendor
	})
```


#### Map utilities

**ProcessMap**

The following methods work on **any map type.**

Example:
```go
    var aMap interface{}
	toolbox.ProcessMap(aMap, func(key, value interface{}) bool {
    		...
    		return true //to continue to next element return true
    })

```


**CopyMapEntries**

Example:
```go
    type Foo struct{id int;name string}
	
	source := map[interface{}]interface{} {
		1: Foo{1, "A"},
		2: Foo{2, "B"},
	}
	var target = make   (map[int]Foo)

	toolbox.CopyMapEntries(source, target)
```


**MapKeysToSlice**

Example:
```go
    aMap := map[string]int {
		"abc":1,
		"efg":2,
	}
	var keys = make([]string, 0)
	toolbox.MapKeysToSlice(aMap, &keys)
```
	

**GroupSliceElements**

Example:
```go
	type Product struct{vendor,name string}
    	products := []Product{
    		Product{"Vendor1", "Product1"},
    		Product{"Vendor2", "Product2"},
    		Product{"Vendor1", "Product3"},
    		Product{"Vendor1", "Product4"},
    	}
    
    	productsByVendor := make(map[string][]Product)
    	toolbox.GroupSliceElements(products, productsByVendor, func(product Product) string {
    		return product.vendor
    	})
```


**SliceToMultimap**

```go	
	type Product struct {
    		vendor, name string
    		productId    int
    	}
    
    	products := []Product{
    		Product{"Vendor1", "Product1", 1},
    		Product{"Vendor2", "Product2", 2},
    		Product{"Vendor1", "Product3", 3},
    		Product{"Vendor1", "Product4", 4},
    	}
    
    	productsByVendor := make(map[string][]int)
    	toolbox.SliceToMultimap(products, productsByVendor, func(product Product) string {
    		return product.vendor
    	},
    	func(product Product) int {
    		return product.productId
    	})
```

<a name="Conversion-Utilities"></a>
### Converter && Conversion Utilities

Converter transforms, data between any compatible or incompatible data type including struct/basicType/map/slice/interface{}
On top of that it supports custom tag to map field to target data type (i.e map)


```go
    myStruct :=  //some struct ...
    myMap := make(map[string]interface{})
    converter := NewConverter(dateLayout, keyTag) 	
    err = converter.AssignConverted(&myMap, myStruct)
    err = converter.AssignConverted(myStruct, myMap) 
```


<a name="Struct-Utilities"></a>
### Struct Utilities


**ScanStructMethods**

Scan struct methods

```go
    service := New()
    err = toolbox.ScanStructMethods(service, 1, func(method reflect.Method) error {
		fmt.Printf("%v\n", method.Name)
		return nil
	})

```

**ProcessStruct**

Scan struct fields

```go
   service := New()
    err = toolbox.ProcessStruct(service,
        func(field reflect.StructField, value reflect.Value) error {
            fmt.Print(field.Type.Name)
            return nil
    })

```


<a name="Function-Utilities"></a>
### Function Utilities




<a name="TimeUtilities"></a>
### Time Utilities	
	
**DateFormatToLayout**

Java date format style to go date layout conversion.


```go	
    dateLaout := toolbox.DateFormatToLayout("yyyy-MM-dd hh:mm:ss z")
    timeValue, err := time.Parse(dateLaout, "2016-02-22 12:32:01 UTC")
```

**TimeAt** 

Provide dynamic semantic for creating time object

```go
    
    tomorrow, err = TimeAt("tomorrow")//tomorrow in local timezone
    timeInUTC, err := TimeAt("2 days ago in UTC") //or 2DayAgoInUTC
    yesterdayUTC, err := TimeAt("yesterdayInUTC")//yesterday in UTC
    hoursAhead, err := TimeAt("50 hours ahead")

```

**TimeDiff**

Provide dynamic semantic for creating time object based on time dif

```go

    lastyear, _ := time.Parse(DateFormatToLayout("yyyy-MM-dd"), "2017-01-01")
    ts1, e := TimeDiff(lastyear, "50 hours earlier")
    ts2, e := TimeDiff(lastyear, "3 days before in Poland")
	
```

**DayElapsed** 
```go

    t0, _ := time.Parse(DateFormatToLayout("yyyy-MM-dd hh:mm:ss"), "2017-01-01 12:00:00")
    dayElapsedInT0, err := ElapsedDay(t0) //0.5
	
```

**ElapsedToday**
```go

    elapscedInLocalTz, err := ElapsedTodayInPct("")  
    elapscedInUTC, err := ElapsedToday("UTC")
	
```
 
**RemainingToday**
```go

    elapscedInLocalTz, err := RemainingTodayInPct("")
    elapscedInUTC, err := RemainingToday("UTC")
	
```

**AtTime**
```go
    atTime := &AtTime{
        WeekDay: "*",
        Hour:    "*",
        Minute:  "10,30",
	}
    
    //returns the nearest future time for xx:10 or xx:30  
    nextScheduleTime := atTime.Next(time.Now)
```
<a name="storage"></a>

## Storage


[Storage API](storage/README.md) provides unified way of accessing local or remote storage system.  

This API has been deprecated, please consider using [Abstract Storage](https://github.com/viant/afs)

**Example** 

```go
    import (
    	"github.com/viant/toolbox/storage"
    	_ "github.com/viant/toolbox/storage/gs"	
    )
    
    
    destinationURL := "gs://myBucket/set1/content.gz"
    destinationCredentialFile = "gs-secret.json"
    storageService, err := storage.NewServiceForURL(destinationURL, destinationCredentialFile)

```



<a name="tet"></a>
### Text utilities


**Text Case Format** 

You can format with [format.Case](format/case.go).Format(text, destCase)

```go
    formatted := format.CaseLowerUnderscore.Format(text, format.CaseLowerCamel)
```


<a name="Tokenizer"></a>
### Tokenizer

<a name="ServiceRouter"></a>
### ServiceRouter

This ServiceRouter provides simple WebService Endpoint abstractin and RESET Client utilities.


Take as example of a ReverseService defined as follow

```go

type ReverseService interface {
        Reverse(values []int) []int 
}

type reverseService struct{}

func (r *reverseService) Reverse(values []int) []int {
	var result = make([]int, 0)
	for i := len(values) - 1; i >= 0; i-- {
		result = append(result, values[i])
	}

	return result
}

```

In order to define Endpoint for this service,  define a server, a router with the service routes;



```qo


type Server struct {
    service ReverseService
    port string
}

func (s *Server) Start() {
    
    router := toolbox.NewServiceRouter(
		toolbox.ServiceRouting{
			HTTPMethod: "GET",
			URI:        "/v1/reverse/{ids}",
			Handler:    s.service.Reverse,
			Parameters: []string{"ids"}, 
		},
		toolbox.ServiceRouting{
			HTTPMethod: "POST",
			URI:        "/v1/reverse/",
			Handler:    s.service.Reverse,
			Parameters: []string{"ids"},
		})
		
        http.HandleFunc("/v1/", func(writer http.ResponseWriter, reader *http.Request) {
            err := router.Route(writer, reader)
            if err != nil {
                response.WriteHeader(http.StatusInternalServerError)
            }
        })
    
        fmt.Printf("Started test server on port %v\n", port)
        log.Fatal(http.ListenAndServe(":"+port, nil))
}

```
**ServiceRouting** parameters define handler parameters that can be extracted from URI, QueryString, or from Post Body (json payload)
In addition two special parameter names are supported: @httpRequest, @httpResponseWriter  to pass in request, and response object respectively.


The REST client utility invoking our reverse service may look as follow
 
 
```go

               var result = make([]int, 0)
               err := toolbox.RouteToService("get", "http://127.0.0.1:8082/v1/reverse/1,7,3", nil, &result)
               //...
               err := toolbox.RouteToService("post", "http://127.0.0.1:8082/v1/reverse/", []int{1, 7, 3}, &result)

``` 


By default a service router uses reflection to call the matched routes handler, it is possible to avoid reflection overhead by providing the custom handler invoker.

```go


var ReverseInvoker = func(serviceRouting *toolbox.ServiceRouting, request *http.Request, response http.ResponseWriter, uriParameters map[string]interface{}) error {
	var function = serviceRouting.Handler.(func(values []int) []int)
	idsParam := uriParameters["ids"]
	ids := idsParam.([]string)
	values := make([]int, 0)
	for _, item := range ids {
		values = append(values, toolbox.AsInt(item))
	}
	var result = function(values)
	err := toolbox.WriteServiceRoutingResponse(response, request, serviceRouting, result)
	if err != nil {
		return err
	}
	return nil
}

//...

 
        router := toolbox.NewServiceRouter(
		toolbox.ServiceRouting{
			HTTPMethod: "GET",
			URI:        "/v1/reverse/{ids}",
			Handler:    s.service.Reverse,
			Parameters: []string{"ids"},
			HandlerInvoker: ReverseInvoker,
		})
//...		
		

```




<a name="DecoderandEncoder"></a>
### Decoder and Encoder 

#### Decoder

This library defines DecoderFactory interface to delegate  decoder creation, 
This library comes with standard JSON and UnMarshaler (protobuf) factory implementation.

 Example
  
```go
    factory :=toolbox.NewJsonDecoderFactory()
    ....
    
    decoder := factory.Create(reader)
    foo := &Foo{}
    err = decoder.Decode(foo)



    marshalerFactory := toolbox.NewUnMarshalerDecoderFactory()
    decoder := marshalerFactory.Create(reader)
    foo := &Foo{}
    err = decoder.Decode(foo)
```


#### Encoder

This library defines EncoderFactory interface to delegate encoder creation, 
This library comes with standard JSON and Marshaler (protobuf) factory implementation.

 Example
  
```go
        factory :=toolbox.NewJsonEncoderFactory()
        ....
        buffer := new(bytes.Buffer)
        
        
        decoder := factory.Create(buffer)
        err = decoder.Encode(foo)
    
    
    
        marshalerFactory := toolbox.NewMarshalerEncoderFactory()
        decoder := marshalerFactory.Create(buffer)
        err = decoder.Encode(foo)
```



<a name="Logger"></a>
### Logger


This library provides a file logger implementation that optimizes writes.
Log messages are queues until max queue size or flush frequency are met.
On top of that Ctrl-C also forces immediate log messages flush to disk.

File template support java style time format to manage rotation on the file name level.

```go
    logger, err := toolbox.NewFileLogger(toolbox.FileLoggerConfig{
		LogType:           "test",
		FileTemplate:      "/tmp/test[yyyyMMdd-hhmm].log",
		QueueFlashCount:   250,
		MaxQueueSize:      500,
		FlushFrequencyInMs: 2000,
		MaxIddleTimeInSec: 1,
	}, toolbox.FileLoggerConfig{
       		LogType:           "transaction",
       		FileTemplate:      "/tmp/transaction[yyyyMMdd-hhmm].log",
       		QueueFlashCount:   250,
       		MaxQueueSize:      500,
       		FlushFrequencyInMs:2000,
       		MaxIddleTimeInSec: 1,
       	},
	)

    logger.Log(&toolbox.LogMessage{
        MessageType: "test",
        Message:     message
    })
    
    logger.Log(&toolbox.LogMessage{
            MessageType: "transaction",
            Message:     message
        })
```
		
<a name="BatchLimiter"></a>
### BatchLimiter


This library provides a batch limiter, that enables controling number of active go routines.


```go

     var tasks []*Task
     var batchSize = 4
	 limiter:= toolbox.NewBatchLimiter(batchSize, len(tasks))
   	 for i, _ :=  range tasks {
            go func(task *Task) {
                    limiter.Acquire()
                    defer limiter.Done()
                    task.Run();
        	}(tasks[i])
	}
	limiter.Wait()

```

### AST Based FileSetInfo 


```go
    pkgPath := ""
	source := path.Join(pkgPath)
	filesetInfo, err :=toolbox.NewFileSetInfo(source)
    myType := fileSetInfo.Type("MyType")
    fields := myType.Fields()
    method := myType.Receivers
``` 




## GoCover

[![GoCover](https://gocover.io/github.com/viant/toolbox)](https://gocover.io/github.com/viant/toolbox)

	
	
<a name="License"></a>
## License

The source code is made available under the terms of the Apache License, Version 2, as stated in the file `LICENSE`.

Individual files may be made available under their own specific license,
all compatible with Apache License, Version 2. Please see individual files for details.


<a name="Credits-and-Acknowledgements"></a>

##  Credits and Acknowledgements

**Library Author:** Adrian Witas

**Contributors:**


toolbox

ugo is slice toolbox with concise syntax for Go.

The Best Go Libraries For Utilities (22)