rework: reflection-based Marshal/Unmarshal API

Replace the Parse/Builder API with a struct tag-based encoding/decoding
API similar to encoding/json. This is a breaking change from v0.1.x.

- Add Marshal/Unmarshal with struct tag support (hex 0x and decimal formats)
- Add Encoder/Decoder types for streaming usage
- Add Marshaler/Unmarshaler interfaces for custom types
- Add Options with DisallowUnknownFields
- Remove all external dependencies
- Replace Travis CI with GitHub Actions
- Add Nix flake with devshell and treefmt (gofumpt + golangci-lint)
- Add example tests for all public functions
- Update README, LICENSE, go.mod

Author: skythen

.envrc

@@ -0,0 +1,5 @@
+if ! has nix_direnv_version || ! nix_direnv_version 3.0.6; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.0.6/direnvrc" "sha256-RYcUJaRMf8oF5LznDrlCXbkOQrywm0HDv1VjYGaJGdM="
+fi
+
+use flake

.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: ['1.18', '1.26']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+
+      - name: Test
+        run: go test -race -coverprofile=coverage.txt ./...
+
+      - name: Upload coverage
+        if: matrix.go-version == '1.26'
+        uses: codecov/codecov-action@v4
+        with:
+          files: coverage.txt

.gitignore

@@ -13,3 +13,9 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# IDE
+.idea/
+
+# direnv
+.direnv/

.travis.yml

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 skythen
+Copyright (c) 2021-2026 skythen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

LICENSE

@@ -1,56 +1,132 @@
 # BER-TLV
 
-[![Build Status](https://travis-ci.org/skythen/bertlv.svg?branch=master)](https://travis-ci.org/skythen/bertlv)
-[![Coverage Status](https://coveralls.io/repos/github/skythen/bertlv/badge.svg?branch=master)](https://coveralls.io/github/skythen/bertlv?branch=master)
-[![GoDoc](https://godoc.org/github.com/skythen/bertlv?status.svg)](http://godoc.org/github.com/skythen/bertlv)
+[![Go Reference](https://pkg.go.dev/badge/github.com/skythen/bertlv.svg)](https://pkg.go.dev/github.com/skythen/bertlv)
 [![Go Report Card](https://goreportcard.com/badge/github.com/skythen/bertlv)](https://goreportcard.com/report/github.com/skythen/bertlv)
 
-Package bertlv implements parsing and building of BER-TLV structures.
-
-Please note that this is not a complete implementation of the X.690 standard as it is agnostic about classes (Universal, Application, Context-specific, Private) and therefore does not check for correct encoding of tags/values.
+Package bertlv implements encoding and decoding of BER-TLV structures using struct tags, similar to `encoding/json`.
 
 `go get github.com/skythen/bertlv`
 
-## Parse
+## Struct Tags
+
+Use the `bertlv` struct tag to map struct fields to BER-TLV tags.
+
+### Hex Format
+
+Use the `0x` prefix to specify tags as hex bytes. Class and construction are derived from the encoded tag bytes:
+
+```go
+type FCI struct {
+    AID       []byte   `bertlv:"0x4F"`
+    Label     []byte   `bertlv:"0x50"`
+    Track2    []byte   `bertlv:"0x57"`
+    ExpDate   []byte   `bertlv:"0x5F24"`  // multi-byte tags
+    Records   []Record `bertlv:"0x70"`    // constructed tags decode recursively
+}
+```
+
+### Decimal Format
+
+Specify tag number and class explicitly:
+
+`"<number>,<class>[,options...]"`
+
+- **number**: Decimal tag number (0-16383)
+- **class**: One of `universal`, `application`, `context`, `private`
+
+```go
+type Data struct {
+    Field1 []byte `bertlv:"1,universal"`
+    Field2 []byte `bertlv:"2,application"`
+    Field3 []byte `bertlv:"3,context"`
+}
+```
+
+### Options
+
+- `omitempty` - skip field during encoding if empty/zero
+- `required` - return error during decoding if tag is not present
+
+```go
+type Data struct {
+    Required []byte `bertlv:"0x4F,required"`
+    Optional []byte `bertlv:"0x50,omitempty"`
+    Both     []byte `bertlv:"1,universal,required,omitempty"`
+}
+```
+
+## Unmarshal
 
-You can parse BER-TLV encoded data from bytes:
+Decode BER-TLV data into a struct:
 
 ```go
-b := []byte{0x71, 0x10, 0xB0, 0x0E, 0x0F, 0x05, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0E, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01}
-bertlvs, err := Parse(b)
+var result struct {
+    AID   []byte `bertlv:"0x4F"`
+    Label []byte `bertlv:"0x50"`
+}
+
+err := bertlv.Unmarshal(data, &result)
 ```
-### Constructed objects
-You can check if a BerTLV is constructed and get first or all children or filter child objects by tag:
+
+### Options
+
 ```go
-if bertlvs[0].Tag.IsConstructed() {
-    child := bertlvs[0].FirstChild(NewOneByteTag(0x0F))
+opts := bertlv.Options{
+    DisallowUnknownFields: true,
 }
+
+err := bertlv.UnmarshalWithOptions(data, &result, opts)
 ```
 
-## Create
-You can create single BER-TLVs with NewBerTLV:
+### Custom Unmarshaler
+
+Implement the `Unmarshaler` interface for custom decoding:
+
 ```go
-val := []byte{0xB0, 0x0E, 0x0F, 0x05, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0E, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01}
-bertlv, err := NewBerTLV(NewOneByteTag(0x71), val)
+type MyType struct {
+    Value string
+}
+
+func (m *MyType) UnmarshalBERTLV(value []byte) error {
+    m.Value = string(value)
+    return nil
+}
 ```
 
-If you want to create complex constructed objects you use the Builder:
+## Marshal
+
+Encode a struct into BER-TLV format:
+
 ```go
-builder := Builder{}
-nestedBuilder := Builder{}
-anotherNestedBuilder := Builder{}
+data := struct {
+    AID   []byte `bertlv:"0x4F"`
+    Label []byte `bertlv:"0x50"`
+}{
+    AID:   []byte{0xA0, 0x00, 0x00, 0x00, 0x04, 0x10, 0x10},
+    Label: "GoCard",
+}
 
-berTlvs, err := builder.AddBytes(NewOneByteTag(0x71), 			     // first level, constructed object
-    nestedBuilder.AddBytes(NewOneByteTag(0xB0), 		             // second level, constructed object
-        anotherNestedBuilder.
-            AddBytes(NewOneByteTag(0x0F), []byte{0x01, 0x02, 0x03, 0x04, 0x05}). // third level primitive object
-            AddBytes(NewOneByteTag(0x0E), []byte{0x05, 0x04, 0x03, 0x02, 0x01}). // third level primitive object
-        Bytes()).
-    Bytes()).
-BuildBerTLVs()
+encoded, err := bertlv.Marshal(data)
 ```
 
-You can also use
-- builder.AddEmpty() to add objects without value
-- builder.AddByte() to add objects with a value that consists of a single byte
-- builder.AddRaw() to add raw bytes
+### Custom Marshaler
+
+Implement the `Marshaler` interface for custom encoding:
+
+```go
+func (m MyType) MarshalBERTLV() ([]byte, error) {
+    return []byte(m.Value), nil
+}
+```
+
+## Supported Types
+
+The following Go types can be used as struct fields:
+
+- `[]byte` - raw TLV value
+- `string` - UTF-8 encoded value
+- `int`, `int8`, `int16`, `int32`, `int64` - big-endian signed integers
+- `uint`, `uint8`, `uint16`, `uint32`, `uint64` - big-endian unsigned integers
+- `bool` - single byte (0x00 = false, non-zero = true)
+- `struct` - nested constructed TLV
+- `[]T` (slice of structs) - repeated TLV elements