Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/oriser/regroup
Match regex group into go struct using struct tags and automatic parsing
https://github.com/oriser/regroup
Last synced: about 2 months ago
JSON representation
Match regex group into go struct using struct tags and automatic parsing
- Host: GitHub
- URL: https://github.com/oriser/regroup
- Owner: oriser
- License: apache-2.0
- Created: 2020-09-08T19:04:42.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2024-06-10T20:05:00.000Z (6 months ago)
- Last Synced: 2024-07-31T20:53:14.448Z (5 months ago)
- Language: Go
- Homepage:
- Size: 37.1 KB
- Stars: 143
- Watchers: 2
- Forks: 13
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- awesome-go - regroup - Match regex expression named groups into go struct using struct tags and automatic parsing. (Text Processing / Regular Expressions)
- awesome-go-extra - regroup - 09-08T19:04:42Z|2021-07-30T15:53:28Z| (Bot Building / Regular Expressions)
README
# regroup
Simple library to match regex expression named groups into go struct using struct tags and automatic parsing
[](https://codecov.io/gh/oriser/regroup)
[](https://opensource.org/licenses/Apache-2.0)
[](https://pkg.go.dev/github.com/oriser/regroup)
[](https://goreportcard.com/report/github.com/oriser/regroup)
[](https://goreportcard.com/report/github.com/oriser/regroup)
### Installing
`go get github.com/oriser/regroup`
## Example
#### Named groups map
```go
package main
import (
"fmt"
"github.com/oriser/regroup"
)
var re = regroup.MustCompile(`(?P.*?)\s+(?P\d+)\s+(?P.*)`)
func main() {
matches, err := re.Groups("5s 123 bar")
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", matches)
}
```
Will output:
`map[duration:5s foo:bar num:123]`
#### Single match
```go
package main
import (
"fmt"
"github.com/oriser/regroup"
"time"
)
var re = regroup.MustCompile(`(?P.*?)\s+(?P\d+)\s+(?P.*)`)
type B struct {
Str string `regroup:"foo"`
}
type A struct {
Number int `regroup:"num"`
Dur time.Duration `regroup:"duration"`
AnotherStruct B
}
func main() {
a := &A{}
if err := re.MatchToTarget("5s 123 bar", a); err != nil {
panic(err)
}
fmt.Printf("%+v\n", a)
}
```
Will output:
`&{Number:123 Dur:5s AnotherStruct:{Str:bar}}`
#### Multiple matches
You can also get all matches parsed as given target struct. The return value in this
case will be an array of interfaces, you should cast it to the target type in order to access its fields.
```go
package main
import (
"fmt"
"github.com/oriser/regroup"
"time"
)
var re = regroup.MustCompile(`\s*(?P.*?)\s+(?P\d+)\s+(?P.*)`)
type B struct {
Str string `regroup:"foo"`
}
type A struct {
Number int `regroup:"num"`
Dur time.Duration `regroup:"duration"`
AnotherStruct B
}
func main() {
a := &A{}
s := `5s 123 bar1
1m 456 bar2
10h 789 bar3`
rets, err := re.MatchAllToTarget(s, -1, a)
if err != nil {
panic(err)
}
for _, elem := range rets {
fmt.Printf("%+v\n", elem.(*A))
}
}
```
Will output:
```
&{Number:123 Dur:5s AnotherStruct:{Str:bar1}}
&{Number:456 Dur:1m0s AnotherStruct:{Str:bar2}}
&{Number:789 Dur:10h0m0s AnotherStruct:{Str:bar3}}
```
#### Required groups
You can specify that a specific group is required, means that it can't be empty.
If a required group is empty, an error (`*regroup.RequiredGroupIsEmpty`) will be returned .
```go
package main
import (
"fmt"
"github.com/oriser/regroup"
"time"
)
var re = regroup.MustCompile(`(?P.*?)\s+(?P\d+)\s+(?P.*)`)
type B struct {
Str string `regroup:"foo,required"`
}
type A struct {
Number int `regroup:"num"`
Dur time.Duration `regroup:"duration"`
AnotherStruct B
}
func main() {
a := &A{}
if err := re.MatchToTarget("5s 123 ", a); err != nil {
panic(err)
}
fmt.Printf("%+v\n", a)
}
```
Will return an error: `required regroup "foo" is empty for field "Str"`
### Existence Match Groups
You can check for the presence of an optional group using a `bool` with the `exists` tag.
```go
package main
type Exist struct {
IsAdmin bool `regroup:"is_admin,exists"`
}
func main() {
r := MustCompile(`^(?P\w*)(?:,(?Padmin))?$`)
parsed := &Exist{}
if err := r.MatchToTarget("bob_smith", parsed); err != nil {
panic(err)
}
fmt.Printf("%t\n", parsed.IsAdmin)
}
```
This example would print `false`. However if the input were `bob_smith,admin` it would print `true`. When using the `exists` tag, make ure that you regular expression has an optional group and matches all the expected input patterns.
## Supported struct field types
- `time.Duration`
- `bool`
- `string`
- `int`
- `int8`
- `int16`
- `int32`
- `int64`
- `uint`
- `uint8`
- `uint16`
- `uint32`
- `uint64`
- `float32`
- `float64`
Pointers and nested structs are also supported, both on single match and multiple matches