Bloat things up
* Use `minify` library instead of the CLI * Add file size on the right of each entry * Render clickable links for the heading breadcrumb * Pretty logging with charmlog * Use `echo` framework for the preview (why? just for fun and the logger middleware)
This commit is contained in:
parent
f3bb7cb7fc
commit
f77dd38704
GPG Key ID:
B0567C20730E9B11
|
|
@ -21,13 +21,12 @@ build:site:
|
|||
image: golang:1.21-alpine
|
||||
before_script:
|
||||
- echo "https://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories
|
||||
- apk add --no-cache minify templ
|
||||
- apk add --no-cache templ
|
||||
- mkdir "$SRC_DIR"
|
||||
- cp -r src/* "$SRC_DIR"/
|
||||
script:
|
||||
- templ generate
|
||||
- go run ./*.go -gen "$SRC_DIR"
|
||||
- minify -r "$SRC_DIR" -o .
|
||||
- go run . -gen "$SRC_DIR"
|
||||
artifacts:
|
||||
expire_in: 1 hour
|
||||
paths:
|
||||
|
|
|
|||
|
|
@ -25,6 +25,8 @@
|
|||
extra-rules = true
|
||||
[linters-settings.govet]
|
||||
check-shadowing = true
|
||||
[linters-settings.misspell]
|
||||
locale = "US"
|
||||
|
||||
[issues]
|
||||
fix = false
|
||||
|
|
|
|||
|
|
@ -10,6 +10,8 @@ The website is deployed to Cloudflare Pages and is available at <https://cdn.fol
|
|||
|
||||
I like being in control of my own stuff. Also, it's because my websites have a strict `Content-Security-Policy` header value (see [_headers](./src/_headers) file for an example).
|
||||
|
||||
**NOTE**: to generate the integrity checksum, run: `openssl dgst -sha256 -binary <file_path> | openssl base64 -A`
|
||||
|
||||
> Why not using Chrome or Nginx directory listing?
|
||||
|
||||
I like some theming and little directory/file icons. Also, CloudFlare Pages (where I deploy this project to) isn't a VM hosting platform but a [FaaS](https://en.wikipedia.org/wiki/Function_as_a_Service) provider.
|
||||
|
|
@ -36,9 +38,9 @@ Meh?
|
|||
|
||||
Also, `tree` injects its metadata, CSS and copyright notice into the `index.html` file. Yes, I can yank them out with something like [htmlq](https://github.com/mgdm/htmlq), but I also want to insert my own styling and stuff.
|
||||
|
||||
> Why not using [minify](https://github.com/tdewolff/minify)'s library but its CLI?
|
||||
> Nicer way to have directory listing?
|
||||
|
||||
Using the CLI is much easier. And, I don't want a dedicated Go module for this small project with external dependencies.
|
||||
Yes, there are many better alternatives that exist like [serve](https://github.com/vercel/serve).
|
||||
|
||||
## License
|
||||
|
||||
|
|
|
|||
12
flake.lock
12
flake.lock
|
|
@ -55,11 +55,11 @@
|
|||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1700204040,
|
||||
"narHash": "sha256-xSVcS5HBYnD3LTer7Y2K8ZQCDCXMa3QUD1MzRjHzuhI=",
|
||||
"lastModified": 1700612854,
|
||||
"narHash": "sha256-yrQ8osMD+vDLGFX7pcwsY/Qr5PUd6OmDMYJZzZi0+zc=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "c757e9bd77b16ca2e03c89bf8bc9ecb28e0c06ad",
|
||||
"rev": "19cbff58383a4ae384dea4d1d0c823d72b49d614",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
|
|
@ -103,11 +103,11 @@
|
|||
"xc": "xc"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1700298481,
|
||||
"narHash": "sha256-eFDvyf1EGfHpFQn7XLG9CRba4BleYRlTM64Oyty6rpA=",
|
||||
"lastModified": 1700556837,
|
||||
"narHash": "sha256-795qIrNeHC0Z0oD+FIAxJvUrKT94LTX8m4Ufoq93Y20=",
|
||||
"owner": "a-h",
|
||||
"repo": "templ",
|
||||
"rev": "6c411018048a7aa35a275caddc5c3c1222283293",
|
||||
"rev": "802881f56f69c01a8bf0bd75ec30c0c4b53b5567",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
|
|
|
|||
22
flake.nix
22
flake.nix
|
|
@ -5,16 +5,16 @@
|
|||
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
|
||||
flake-utils.url = "github:numtide/flake-utils";
|
||||
|
||||
gitignore = {
|
||||
url = "github:hercules-ci/gitignore.nix";
|
||||
inputs.nixpkgs.follows = "nixpkgs";
|
||||
};
|
||||
|
||||
templ-src = {
|
||||
url = "github:a-h/templ";
|
||||
inputs.nixpkgs.follows = "nixpkgs";
|
||||
inputs.gitignore.follows = "gitignore";
|
||||
};
|
||||
|
||||
gitignore = {
|
||||
url = "github:hercules-ci/gitignore.nix";
|
||||
inputs.nixpkgs.follows = "nixpkgs";
|
||||
};
|
||||
};
|
||||
|
||||
outputs = { nixpkgs, templ-src, flake-utils, gitignore, ... }:
|
||||
|
|
@ -29,7 +29,7 @@
|
|||
inherit (nixpkgs) lib;
|
||||
pkgs = nixpkgs.legacyPackages."${system}" // templ-src.packages."${system}";
|
||||
|
||||
buildInputs = with pkgs; [ go minify templ ];
|
||||
buildInputs = with pkgs; [ go templ ];
|
||||
shellHook = ''
|
||||
export GOTOOLCHAIN=local
|
||||
export CGO_ENABLED=0
|
||||
|
|
@ -41,8 +41,11 @@
|
|||
script = "templ generate";
|
||||
};
|
||||
preview = {
|
||||
runtimeInputs = [ go ];
|
||||
script = "go run ./*.go -preview result/";
|
||||
runtimeInputs = [ go templ ];
|
||||
script = ''
|
||||
templ generate
|
||||
go run . -preview result/
|
||||
'';
|
||||
};
|
||||
publish = {
|
||||
runtimeInputs = [ nodePackages.wrangler ];
|
||||
|
|
@ -84,8 +87,7 @@
|
|||
templ generate
|
||||
'';
|
||||
buildPhase = ''
|
||||
go run *.go -gen src
|
||||
minify -r ./src -o .
|
||||
go run . -gen src
|
||||
'';
|
||||
installPhase = ''
|
||||
mkdir -p "$out"
|
||||
|
|
|
|||
31
go.mod
31
go.mod
|
|
@ -1,8 +1,35 @@
|
|||
module cdn
|
||||
|
||||
go 1.21.3
|
||||
go 1.21.4
|
||||
|
||||
require (
|
||||
github.com/a-h/templ v0.2.476
|
||||
golang.org/x/sync v0.5.0
|
||||
github.com/charmbracelet/lipgloss v0.9.1
|
||||
github.com/charmbracelet/log v0.3.0
|
||||
github.com/dustin/go-humanize v1.0.1
|
||||
github.com/labstack/echo/v4 v4.11.3
|
||||
github.com/tdewolff/minify/v2 v2.20.7
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
|
||||
github.com/go-logfmt/logfmt v0.6.0 // indirect
|
||||
github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
|
||||
github.com/labstack/gommon v0.4.0 // indirect
|
||||
github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
|
||||
github.com/mattn/go-colorable v0.1.13 // indirect
|
||||
github.com/mattn/go-isatty v0.0.20 // indirect
|
||||
github.com/mattn/go-runewidth v0.0.15 // indirect
|
||||
github.com/muesli/reflow v0.3.0 // indirect
|
||||
github.com/muesli/termenv v0.15.2 // indirect
|
||||
github.com/rivo/uniseg v0.2.0 // indirect
|
||||
github.com/tdewolff/parse/v2 v2.7.5 // indirect
|
||||
github.com/valyala/bytebufferpool v1.0.0 // indirect
|
||||
github.com/valyala/fasttemplate v1.2.2 // indirect
|
||||
golang.org/x/crypto v0.14.0 // indirect
|
||||
golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
|
||||
golang.org/x/net v0.17.0 // indirect
|
||||
golang.org/x/sys v0.14.0 // indirect
|
||||
golang.org/x/text v0.13.0 // indirect
|
||||
golang.org/x/time v0.3.0 // indirect
|
||||
)
|
||||
|
|
|
|||
79
go.sum
79
go.sum
|
|
@ -1,6 +1,81 @@
|
|||
github.com/a-h/templ v0.2.476 h1:+H4hP4CwK4kfJwXsE6kHeFWMGtcVOVoOm/I64uzARBk=
|
||||
github.com/a-h/templ v0.2.476/go.mod h1:zQ95mSyadNTGHv6k5Fm+wQU8zkBMMbHCHg7eAvUZKNM=
|
||||
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
|
||||
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
|
||||
github.com/charmbracelet/lipgloss v0.9.1 h1:PNyd3jvaJbg4jRHKWXnCj1akQm4rh8dbEzN1p/u1KWg=
|
||||
github.com/charmbracelet/lipgloss v0.9.1/go.mod h1:1mPmG4cxScwUQALAAnacHaigiiHB9Pmr+v1VEawJl6I=
|
||||
github.com/charmbracelet/log v0.3.0 h1:u5aB2KJDgNZo4WOfOC8C+KvGIkJ2rCFNlPWDu6xhnqI=
|
||||
github.com/charmbracelet/log v0.3.0/go.mod h1:OR4E1hutLsax3ZKpXbgUqPtTjQfrh1pG3zwHGWuuq8g=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
|
||||
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
|
||||
github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
|
||||
github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
|
||||
github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
|
||||
github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
|
||||
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
|
||||
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
|
||||
golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=
|
||||
golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
github.com/labstack/echo/v4 v4.11.3 h1:Upyu3olaqSHkCjs1EJJwQ3WId8b8b1hxbogyommKktM=
|
||||
github.com/labstack/echo/v4 v4.11.3/go.mod h1:UcGuQ8V6ZNRmSweBIJkPvGfwCMIlFmiqrPqiEBfPYws=
|
||||
github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=
|
||||
github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
|
||||
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
|
||||
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
|
||||
github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
|
||||
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
|
||||
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
|
||||
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
|
||||
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
|
||||
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
|
||||
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
|
||||
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
|
||||
github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
|
||||
github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
|
||||
github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
|
||||
github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
|
||||
github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
|
||||
github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
|
||||
github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
|
||||
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
|
||||
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
|
||||
github.com/tdewolff/minify/v2 v2.20.7 h1:NUkuzJ9dvQUNJjSdmmrfELa/ZpnMdyMR/ZKU2bw7N/E=
|
||||
github.com/tdewolff/minify/v2 v2.20.7/go.mod h1:bj2NpP3zoUhsPzE4oM4JYwuUyVCU/uMaCYZ6/riEjIo=
|
||||
github.com/tdewolff/parse/v2 v2.7.5 h1:RdcN3Ja6zAMSvnxxO047xRoWexX3RrXKi3H6EQHzXto=
|
||||
github.com/tdewolff/parse/v2 v2.7.5/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
|
||||
github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52 h1:gAQliwn+zJrkjAHVcBEYW/RFvd2St4yYimisvozAYlA=
|
||||
github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
|
||||
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
|
||||
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
|
||||
github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
|
||||
github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
|
||||
github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
|
||||
golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
|
||||
golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
|
||||
golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
|
||||
golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
|
||||
golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
|
||||
golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
|
||||
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
|
||||
golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
|
||||
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
|
||||
golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
|
||||
golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
|
|
|
|||
208
main.go
208
main.go
|
|
@ -1,86 +1,135 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"golang.org/x/sync/errgroup"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/charmbracelet/log"
|
||||
"github.com/labstack/echo/v4"
|
||||
"github.com/labstack/echo/v4/middleware"
|
||||
"github.com/tdewolff/minify/v2"
|
||||
"github.com/tdewolff/minify/v2/css"
|
||||
"github.com/tdewolff/minify/v2/html"
|
||||
)
|
||||
|
||||
var (
|
||||
ctx = context.Background()
|
||||
previewPort = "8080"
|
||||
previewPort = ":8080"
|
||||
logger = log.New(os.Stderr)
|
||||
minifier = minify.New()
|
||||
)
|
||||
|
||||
// genListingPages generates listing pages recursively inside provided directory
|
||||
func genListingPages(path, prefix string) error {
|
||||
entries, err := os.ReadDir(path)
|
||||
func closeFile(file *os.File) {
|
||||
if err := file.Close(); err != nil {
|
||||
logger.Fatal("failed to close file", "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// minifyInPlace replaces the file content with the minified version
|
||||
func minifyInPlace(mediatype, path string) error {
|
||||
tempPath := path + ".bak"
|
||||
err := os.Rename(path, tempPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
indexFile, err := os.Create(filepath.Join(path, "index.html"))
|
||||
inputFile, err := os.Open(tempPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
trimedPath := strings.TrimPrefix(path, prefix)
|
||||
if err := listingPage(strings.TrimPrefix(trimedPath, "/"), entries).Render(ctx, indexFile); err != nil {
|
||||
// Open the file again for writing
|
||||
outputFile, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Goroutines are cheap, so just spawn them needlessly \^-^/
|
||||
errGroup := new(errgroup.Group)
|
||||
for _, entry := range entries {
|
||||
entry := entry
|
||||
if entry.IsDir() {
|
||||
errGroup.Go(func() error {
|
||||
return genListingPages(filepath.Join(path, entry.Name()), prefix)
|
||||
})
|
||||
defer func() {
|
||||
closeFile(inputFile)
|
||||
closeFile(outputFile)
|
||||
|
||||
if err := os.Remove(tempPath); err != nil {
|
||||
logger.Fatal("failed to delete temporary input file", "file", path)
|
||||
}
|
||||
}()
|
||||
|
||||
return minifier.Minify(mediatype, outputFile, inputFile)
|
||||
}
|
||||
|
||||
func traverse(prefix, path string, d fs.DirEntry) error {
|
||||
trimedPath := strings.TrimPrefix(path, prefix+"/")
|
||||
|
||||
// Generate index.html file if we hit a directory
|
||||
if d.IsDir() {
|
||||
logger.Info("create index.html", "dir", trimedPath)
|
||||
|
||||
entries, err := os.ReadDir(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
indexFile, err := os.Create(filepath.Join(path, "index.html"))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer closeFile(indexFile)
|
||||
|
||||
buf := new(bytes.Buffer)
|
||||
if err := listingPage(trimedPath, entries).Render(ctx, buf); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return minifier.Minify("text/html", indexFile, buf)
|
||||
}
|
||||
return errGroup.Wait()
|
||||
|
||||
// Otherwise minify it, if it is a CSS file
|
||||
if d.Type().IsRegular() && filepath.Ext(path) == ".css" {
|
||||
logger.Info("minify CSS", "file", trimedPath)
|
||||
return minifyInPlace("text/css", path)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// preview Previews the website at specified root directory on localhost:<port>
|
||||
func preview(root, port string) error {
|
||||
http.Handle("/", http.FileServer(http.Dir(root)))
|
||||
fmt.Println("Serving the preview webpage at http://localhost:" + port)
|
||||
srv := &http.Server{
|
||||
Addr: ":" + port,
|
||||
ReadTimeout: 5 * time.Second,
|
||||
WriteTimeout: 10 * time.Second,
|
||||
}
|
||||
return srv.ListenAndServe()
|
||||
}
|
||||
e := echo.New()
|
||||
e.Use(middleware.RequestLoggerWithConfig(middleware.RequestLoggerConfig{
|
||||
LogURI: true,
|
||||
LogError: true,
|
||||
LogStatus: true,
|
||||
LogMethod: true,
|
||||
LogLatency: true,
|
||||
LogValuesFunc: func(_ echo.Context, v middleware.RequestLoggerValues) error {
|
||||
logger.
|
||||
With("Method", v.Method).
|
||||
With("URI", v.URI).
|
||||
With("Status", v.Status).
|
||||
With("Latency", v.Latency).
|
||||
Info("request")
|
||||
|
||||
// generate generates index.html files for the root directory
|
||||
func generate(root string) error {
|
||||
// NOTE: it also generate one for the root directory. We'll override this file later
|
||||
if err := genListingPages(root, root); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Render the home page to override the written listing page at root
|
||||
homePage, err := os.Create(filepath.Join(root, "index.html"))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return indexPage().Render(ctx, homePage)
|
||||
if v.Error != nil {
|
||||
logger.Error("request", "err", v.Error)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}))
|
||||
e.Static("/", root)
|
||||
return e.Start(port)
|
||||
}
|
||||
|
||||
func main() {
|
||||
genFlag := flag.Bool("gen", false, "Generate index files")
|
||||
previewFlag := flag.Bool("preview", false, "Preview the built website")
|
||||
flag.Usage = func() {
|
||||
fmt.Printf(`Usage: go run *.go [OPTIONS] DIR
|
||||
fmt.Printf(`Usage: go run . [OPTIONS] DIR
|
||||
|
||||
Arguments:
|
||||
DIR
|
||||
|
|
@ -92,27 +141,84 @@ Options:
|
|||
}
|
||||
flag.Parse()
|
||||
|
||||
// Being fancy ^-^
|
||||
logger.SetStyles(&log.Styles{
|
||||
Separator: lipgloss.NewStyle().Foreground(lipgloss.Color("#7b88a1")).Bold(true),
|
||||
Message: lipgloss.NewStyle().Foreground(lipgloss.Color("#7b88a1")),
|
||||
Key: lipgloss.NewStyle().Foreground(lipgloss.Color("4")).Bold(true),
|
||||
Levels: map[log.Level]lipgloss.Style{
|
||||
log.FatalLevel: lipgloss.NewStyle().
|
||||
Bold(true).
|
||||
Background(lipgloss.Color("5")).
|
||||
Foreground(lipgloss.Color("0")).
|
||||
Padding(0, 1, 0, 1).
|
||||
SetString("FATAL"),
|
||||
log.ErrorLevel: lipgloss.NewStyle().
|
||||
Bold(true).
|
||||
Background(lipgloss.Color("1")).
|
||||
Foreground(lipgloss.Color("0")).
|
||||
Padding(0, 1, 0, 1).
|
||||
SetString("ERROR"),
|
||||
log.InfoLevel: lipgloss.NewStyle().
|
||||
Bold(true).
|
||||
Background(lipgloss.Color("6")).
|
||||
Foreground(lipgloss.Color("0")).
|
||||
Padding(0, 1, 0, 1).
|
||||
SetString("INFO"),
|
||||
},
|
||||
Keys: map[string]lipgloss.Style{
|
||||
"err": lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("1")),
|
||||
},
|
||||
})
|
||||
|
||||
// Load minifiers
|
||||
minifier.AddFunc("text/html", html.Minify)
|
||||
minifier.AddFunc("text/css", css.Minify)
|
||||
|
||||
// The root directory argument is required
|
||||
if len(flag.Args()) != 1 {
|
||||
log.Fatal("[ERROR] exactly 1 argument DIR is required")
|
||||
logger.Fatal("failed to parse arguments", "err", "exactly 1 argument DIR is required")
|
||||
}
|
||||
|
||||
// Specify the starting directory, for consistency
|
||||
rootDir, err := filepath.Abs(flag.Arg(0))
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
logger.Fatal("unable to get root directory", "err", err)
|
||||
}
|
||||
|
||||
if *genFlag {
|
||||
if err := generate(rootDir); err != nil {
|
||||
log.Fatalf("[ERROR] %v", err)
|
||||
err = filepath.WalkDir(rootDir, func(path string, d fs.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Generate the home page for the root directory.
|
||||
// NOTE: there isn't anything else in the root directory, so don't check each entry for minification
|
||||
if rootDir == path {
|
||||
logger.Info("create index.html for root directory")
|
||||
indexFile, err := os.Create(filepath.Join(path, "index.html"))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer closeFile(indexFile)
|
||||
|
||||
buf := new(bytes.Buffer)
|
||||
if err := indexPage().Render(ctx, buf); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return minifier.Minify("text/html", indexFile, buf)
|
||||
}
|
||||
|
||||
// Otherwise generate listing pages and minify CSS files
|
||||
return traverse(rootDir, path, d)
|
||||
})
|
||||
if err != nil {
|
||||
logger.Fatal("failed to traverse root directory", "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Only preview after things are generated
|
||||
if *previewFlag {
|
||||
if err := preview(rootDir, previewPort); err != nil {
|
||||
log.Fatalf("[ERROR] %v", err)
|
||||
}
|
||||
logger.Fatal("failed to preview website", "err", preview(rootDir, previewPort))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
67
pages.templ
67
pages.templ
|
|
@ -1,29 +1,27 @@
|
|||
package main
|
||||
|
||||
import "io/fs"
|
||||
import "strings"
|
||||
import "github.com/dustin/go-humanize"
|
||||
|
||||
var siteName = "FollieCDN"
|
||||
|
||||
templ pageTemplate(path string) {
|
||||
<!DOCTYPE html>
|
||||
<html lang="en-us">
|
||||
<head>
|
||||
<title>
|
||||
if path != "" {
|
||||
{ path + " | " }
|
||||
}
|
||||
{ siteName }
|
||||
</title>
|
||||
<title>{ siteName }</title>
|
||||
<meta charset="utf-8"/>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1"/>
|
||||
if path != "" {
|
||||
<meta name="description" content={ path + " | " + siteName }/>
|
||||
<meta name="description" content={ siteName + " | /" + path }/>
|
||||
} else {
|
||||
<meta name="description" content={ siteName }/>
|
||||
}
|
||||
<link rel="icon" type="image/x-icon" href="/favicon.ico"/>
|
||||
<link rel="canonical" href={ "https://cdn.folliehiyuki.com/" + path }/>
|
||||
<link rel="stylesheet" href="/styles/normalize.css" integrity="sha256-Atknw9eu6T9FV6v//wFp8skKdJ5JcAqANQ1bPykR4go=" crossorigin="anonymous"/>
|
||||
<link rel="stylesheet" href="/styles/self.css" integrity="sha256-KReR+W3bFJ+Eu2X+F0lR+bULlbmaLS8SXUhIQJ/p/p4=" crossorigin="anonymous"/>
|
||||
<link rel="stylesheet" href="/styles/self.css" integrity="sha256-c991ejabvQnXqaa6D9clbr+4rzY5fM7DmNHXvMBN4Dw=" crossorigin="anonymous"/>
|
||||
<link rel="stylesheet" href="/fonts/iosevka/iosevka-aile.css" integrity="sha256-20HRMpRlRW2+dk9R7asoOl5/z8Xyc2BbjeLZsButUww=" crossorigin="anonymous"/>
|
||||
<link rel="stylesheet" href="/fonts/font-awesome/solid.css" integrity="sha256-xuw8YIIudFiLKxnOSDufxt0N2CFAJQXsK2lnTUPbofE=" crossorigin="anonymous"/>
|
||||
<link rel="preload" href="/fonts/iosevka/iosevka-aile-bold.woff2" as="font" type="font/woff2" integrity="sha256-Hu4sqJ4m0rjWqqKYxhGKw1Lqz/VpftqKe0CeHACkSto=" crossorigin="anonymous"/>
|
||||
|
|
@ -60,24 +58,47 @@ templ indexPage() {
|
|||
|
||||
templ listingPage(path string, entries []fs.DirEntry) {
|
||||
@pageTemplate(path) {
|
||||
<h1>{ path }</h1>
|
||||
<p>
|
||||
<span class="fa-solid"></span> <a href="../">{ "../" }</a>
|
||||
<br/>
|
||||
<h1 style="font-size:1.25rem;">
|
||||
<a href="/" class="fa-solid"></a>
|
||||
@splitPathIntoLinks(strings.Split(path, "/"))
|
||||
</h1>
|
||||
<div>
|
||||
<!-- List everything except index.html files -->
|
||||
for _, entry := range entries {
|
||||
// Obviously we need to discard the index file from the UI
|
||||
if entry.Name() != "index.html" {
|
||||
<span class="fa-solid">
|
||||
if entry.IsDir() {
|
||||

|
||||
} else {
|
||||

|
||||
}
|
||||
</span>
|
||||
<a href={ templ.URL("./" + entry.Name()) }>{ entry.Name() }</a>
|
||||
<br/>
|
||||
<div class="entryRow">
|
||||
<div>
|
||||
<span class="fa-solid">
|
||||
if entry.IsDir() {
|
||||

|
||||
} else {
|
||||

|
||||
}
|
||||
</span>
|
||||
<a href={ templ.URL("./" + entry.Name()) }>
|
||||
if entry.IsDir() {
|
||||
{ entry.Name() + "/" }
|
||||
} else {
|
||||
{ entry.Name() }
|
||||
}
|
||||
</a>
|
||||
</div>
|
||||
<div>
|
||||
{ func(e fs.DirEntry) string {
|
||||
info, _ := e.Info()
|
||||
return humanize.Bytes(uint64(info.Size()))
|
||||
}(entry) }
|
||||
</div>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
</p>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
|
||||
templ splitPathIntoLinks(pathArr []string) {
|
||||
for index, elem := range pathArr {
|
||||
{ " " }<span class="fa-solid"></span>{ " " }
|
||||
<a href={ templ.URL("/" + strings.Join(pathArr[:(index+1)], "/")) }>{ elem }</a>
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,6 +47,15 @@ a:hover {
|
|||
border-bottom: 0.1rem solid var(--color-cyan);
|
||||
}
|
||||
|
||||
h1 > a {
|
||||
color: var(--color-fg);
|
||||
}
|
||||
|
||||
h1 > a:hover {
|
||||
color: var(--color-fg);
|
||||
border: none;
|
||||
}
|
||||
|
||||
h1 {
|
||||
font-size: 1.5rem;
|
||||
}
|
||||
|
|
@ -61,5 +70,14 @@ p {
|
|||
|
||||
.fa-solid {
|
||||
font-family: "Font Awesome 6 Free";
|
||||
font-size: 1rem;
|
||||
}
|
||||
|
||||
div.entryRow {
|
||||
display: flex;
|
||||
flex-direction: row;
|
||||
justify-content: space-between;
|
||||
}
|
||||
|
||||
div.entryRow > div {
|
||||
padding: 0.1rem;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) 2022 Ayman Bagabas
|
||||
|
||||
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.
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
|
||||
# go-osc52
|
||||
|
||||
<p>
|
||||
<a href="https://github.com/aymanbagabas/go-osc52/releases"><img src="https://img.shields.io/github/release/aymanbagabas/go-osc52.svg" alt="Latest Release"></a>
|
||||
<a href="https://pkg.go.dev/github.com/aymanbagabas/go-osc52/v2?tab=doc"><img src="https://godoc.org/github.com/golang/gddo?status.svg" alt="GoDoc"></a>
|
||||
</p>
|
||||
|
||||
A Go library to work with the [ANSI OSC52](https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands) terminal sequence.
|
||||
|
||||
## Usage
|
||||
|
||||
You can use this small library to construct an ANSI OSC52 sequence suitable for
|
||||
your terminal.
|
||||
|
||||
|
||||
### Example
|
||||
|
||||
```go
|
||||
import (
|
||||
"os"
|
||||
"fmt"
|
||||
|
||||
"github.com/aymanbagabas/go-osc52/v2"
|
||||
)
|
||||
|
||||
func main() {
|
||||
s := "Hello World!"
|
||||
|
||||
// Copy `s` to system clipboard
|
||||
osc52.New(s).WriteTo(os.Stderr)
|
||||
|
||||
// Copy `s` to primary clipboard (X11)
|
||||
osc52.New(s).Primary().WriteTo(os.Stderr)
|
||||
|
||||
// Query the clipboard
|
||||
osc52.Query().WriteTo(os.Stderr)
|
||||
|
||||
// Clear system clipboard
|
||||
osc52.Clear().WriteTo(os.Stderr)
|
||||
|
||||
// Use the fmt.Stringer interface to copy `s` to system clipboard
|
||||
fmt.Fprint(os.Stderr, osc52.New(s))
|
||||
|
||||
// Or to primary clipboard
|
||||
fmt.Fprint(os.Stderr, osc52.New(s).Primary())
|
||||
}
|
||||
```
|
||||
|
||||
## SSH Example
|
||||
|
||||
You can use this over SSH using [gliderlabs/ssh](https://github.com/gliderlabs/ssh) for instance:
|
||||
|
||||
```go
|
||||
var sshSession ssh.Session
|
||||
seq := osc52.New("Hello awesome!")
|
||||
// Check if term is screen or tmux
|
||||
pty, _, _ := s.Pty()
|
||||
if pty.Term == "screen" {
|
||||
seq = seq.Screen()
|
||||
} else if isTmux {
|
||||
seq = seq.Tmux()
|
||||
}
|
||||
seq.WriteTo(sshSession.Stderr())
|
||||
```
|
||||
|
||||
## Tmux
|
||||
|
||||
Make sure you have `set-clipboard on` in your config, otherwise, tmux won't
|
||||
allow your application to access the clipboard [^1].
|
||||
|
||||
Using the tmux option, `osc52.TmuxMode` or `osc52.New(...).Tmux()`, wraps the
|
||||
OSC52 sequence in a special tmux DCS sequence and pass it to the outer
|
||||
terminal. This requires `allow-passthrough on` in your config.
|
||||
`allow-passthrough` is no longer enabled by default
|
||||
[since tmux 3.3a](https://github.com/tmux/tmux/issues/3218#issuecomment-1153089282) [^2].
|
||||
|
||||
[^1]: See [tmux clipboard](https://github.com/tmux/tmux/wiki/Clipboard)
|
||||
[^2]: [What is allow-passthrough](https://github.com/tmux/tmux/wiki/FAQ#what-is-the-passthrough-escape-sequence-and-how-do-i-use-it)
|
||||
|
||||
## Credits
|
||||
|
||||
* [vim-oscyank](https://github.com/ojroques/vim-oscyank) this is heavily inspired by vim-oscyank.
|
||||
|
|
@ -0,0 +1,305 @@
|
|||
// OSC52 is a terminal escape sequence that allows copying text to the clipboard.
|
||||
//
|
||||
// The sequence consists of the following:
|
||||
//
|
||||
// OSC 52 ; Pc ; Pd BEL
|
||||
//
|
||||
// Pc is the clipboard choice:
|
||||
//
|
||||
// c: clipboard
|
||||
// p: primary
|
||||
// q: secondary (not supported)
|
||||
// s: select (not supported)
|
||||
// 0-7: cut-buffers (not supported)
|
||||
//
|
||||
// Pd is the data to copy to the clipboard. This string should be encoded in
|
||||
// base64 (RFC-4648).
|
||||
//
|
||||
// If Pd is "?", the terminal replies to the host with the current contents of
|
||||
// the clipboard.
|
||||
//
|
||||
// If Pd is neither a base64 string nor "?", the terminal clears the clipboard.
|
||||
//
|
||||
// See https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands
|
||||
// where Ps = 52 => Manipulate Selection Data.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// // copy "hello world" to the system clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.New("hello world"))
|
||||
//
|
||||
// // copy "hello world" to the primary Clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.New("hello world").Primary())
|
||||
//
|
||||
// // limit the size of the string to copy 10 bytes
|
||||
// fmt.Fprint(os.Stderr, osc52.New("0123456789").Limit(10))
|
||||
//
|
||||
// // escape the OSC52 sequence for screen using DCS sequences
|
||||
// fmt.Fprint(os.Stderr, osc52.New("hello world").Screen())
|
||||
//
|
||||
// // escape the OSC52 sequence for Tmux
|
||||
// fmt.Fprint(os.Stderr, osc52.New("hello world").Tmux())
|
||||
//
|
||||
// // query the system Clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.Query())
|
||||
//
|
||||
// // query the primary clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.Query().Primary())
|
||||
//
|
||||
// // clear the system Clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.Clear())
|
||||
//
|
||||
// // clear the primary Clipboard
|
||||
// fmt.Fprint(os.Stderr, osc52.Clear().Primary())
|
||||
package osc52
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Clipboard is the clipboard buffer to use.
|
||||
type Clipboard rune
|
||||
|
||||
const (
|
||||
// SystemClipboard is the system clipboard buffer.
|
||||
SystemClipboard Clipboard = 'c'
|
||||
// PrimaryClipboard is the primary clipboard buffer (X11).
|
||||
PrimaryClipboard = 'p'
|
||||
)
|
||||
|
||||
// Mode is the mode to use for the OSC52 sequence.
|
||||
type Mode uint
|
||||
|
||||
const (
|
||||
// DefaultMode is the default OSC52 sequence mode.
|
||||
DefaultMode Mode = iota
|
||||
// ScreenMode escapes the OSC52 sequence for screen using DCS sequences.
|
||||
ScreenMode
|
||||
// TmuxMode escapes the OSC52 sequence for tmux. Not needed if tmux
|
||||
// clipboard is set to `set-clipboard on`
|
||||
TmuxMode
|
||||
)
|
||||
|
||||
// Operation is the OSC52 operation.
|
||||
type Operation uint
|
||||
|
||||
const (
|
||||
// SetOperation is the copy operation.
|
||||
SetOperation Operation = iota
|
||||
// QueryOperation is the query operation.
|
||||
QueryOperation
|
||||
// ClearOperation is the clear operation.
|
||||
ClearOperation
|
||||
)
|
||||
|
||||
// Sequence is the OSC52 sequence.
|
||||
type Sequence struct {
|
||||
str string
|
||||
limit int
|
||||
op Operation
|
||||
mode Mode
|
||||
clipboard Clipboard
|
||||
}
|
||||
|
||||
var _ fmt.Stringer = Sequence{}
|
||||
|
||||
var _ io.WriterTo = Sequence{}
|
||||
|
||||
// String returns the OSC52 sequence.
|
||||
func (s Sequence) String() string {
|
||||
var seq strings.Builder
|
||||
// mode escape sequences start
|
||||
seq.WriteString(s.seqStart())
|
||||
// actual OSC52 sequence start
|
||||
seq.WriteString(fmt.Sprintf("\x1b]52;%c;", s.clipboard))
|
||||
switch s.op {
|
||||
case SetOperation:
|
||||
str := s.str
|
||||
if s.limit > 0 && len(str) > s.limit {
|
||||
return ""
|
||||
}
|
||||
b64 := base64.StdEncoding.EncodeToString([]byte(str))
|
||||
switch s.mode {
|
||||
case ScreenMode:
|
||||
// Screen doesn't support OSC52 but will pass the contents of a DCS
|
||||
// sequence to the outer terminal unchanged.
|
||||
//
|
||||
// Here, we split the encoded string into 76 bytes chunks and then
|
||||
// join the chunks with <end-dsc><start-dsc> sequences. Finally,
|
||||
// wrap the whole thing in
|
||||
// <start-dsc><start-osc52><joined-chunks><end-osc52><end-dsc>.
|
||||
// s := strings.SplitN(b64, "", 76)
|
||||
s := make([]string, 0, len(b64)/76+1)
|
||||
for i := 0; i < len(b64); i += 76 {
|
||||
end := i + 76
|
||||
if end > len(b64) {
|
||||
end = len(b64)
|
||||
}
|
||||
s = append(s, b64[i:end])
|
||||
}
|
||||
seq.WriteString(strings.Join(s, "\x1b\\\x1bP"))
|
||||
default:
|
||||
seq.WriteString(b64)
|
||||
}
|
||||
case QueryOperation:
|
||||
// OSC52 queries the clipboard using "?"
|
||||
seq.WriteString("?")
|
||||
case ClearOperation:
|
||||
// OSC52 clears the clipboard if the data is neither a base64 string nor "?"
|
||||
// we're using "!" as a default
|
||||
seq.WriteString("!")
|
||||
}
|
||||
// actual OSC52 sequence end
|
||||
seq.WriteString("\x07")
|
||||
// mode escape end
|
||||
seq.WriteString(s.seqEnd())
|
||||
return seq.String()
|
||||
}
|
||||
|
||||
// WriteTo writes the OSC52 sequence to the writer.
|
||||
func (s Sequence) WriteTo(out io.Writer) (int64, error) {
|
||||
n, err := out.Write([]byte(s.String()))
|
||||
return int64(n), err
|
||||
}
|
||||
|
||||
// Mode sets the mode for the OSC52 sequence.
|
||||
func (s Sequence) Mode(m Mode) Sequence {
|
||||
s.mode = m
|
||||
return s
|
||||
}
|
||||
|
||||
// Tmux sets the mode to TmuxMode.
|
||||
// Used to escape the OSC52 sequence for `tmux`.
|
||||
//
|
||||
// Note: this is not needed if tmux clipboard is set to `set-clipboard on`. If
|
||||
// TmuxMode is used, tmux must have `allow-passthrough on` set.
|
||||
//
|
||||
// This is a syntactic sugar for s.Mode(TmuxMode).
|
||||
func (s Sequence) Tmux() Sequence {
|
||||
return s.Mode(TmuxMode)
|
||||
}
|
||||
|
||||
// Screen sets the mode to ScreenMode.
|
||||
// Used to escape the OSC52 sequence for `screen`.
|
||||
//
|
||||
// This is a syntactic sugar for s.Mode(ScreenMode).
|
||||
func (s Sequence) Screen() Sequence {
|
||||
return s.Mode(ScreenMode)
|
||||
}
|
||||
|
||||
// Clipboard sets the clipboard buffer for the OSC52 sequence.
|
||||
func (s Sequence) Clipboard(c Clipboard) Sequence {
|
||||
s.clipboard = c
|
||||
return s
|
||||
}
|
||||
|
||||
// Primary sets the clipboard buffer to PrimaryClipboard.
|
||||
// This is the X11 primary clipboard.
|
||||
//
|
||||
// This is a syntactic sugar for s.Clipboard(PrimaryClipboard).
|
||||
func (s Sequence) Primary() Sequence {
|
||||
return s.Clipboard(PrimaryClipboard)
|
||||
}
|
||||
|
||||
// Limit sets the limit for the OSC52 sequence.
|
||||
// The default limit is 0 (no limit).
|
||||
//
|
||||
// Strings longer than the limit get ignored. Settting the limit to 0 or a
|
||||
// negative value disables the limit. Each terminal defines its own escapse
|
||||
// sequence limit.
|
||||
func (s Sequence) Limit(l int) Sequence {
|
||||
if l < 0 {
|
||||
s.limit = 0
|
||||
} else {
|
||||
s.limit = l
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// Operation sets the operation for the OSC52 sequence.
|
||||
// The default operation is SetOperation.
|
||||
func (s Sequence) Operation(o Operation) Sequence {
|
||||
s.op = o
|
||||
return s
|
||||
}
|
||||
|
||||
// Clear sets the operation to ClearOperation.
|
||||
// This clears the clipboard.
|
||||
//
|
||||
// This is a syntactic sugar for s.Operation(ClearOperation).
|
||||
func (s Sequence) Clear() Sequence {
|
||||
return s.Operation(ClearOperation)
|
||||
}
|
||||
|
||||
// Query sets the operation to QueryOperation.
|
||||
// This queries the clipboard contents.
|
||||
//
|
||||
// This is a syntactic sugar for s.Operation(QueryOperation).
|
||||
func (s Sequence) Query() Sequence {
|
||||
return s.Operation(QueryOperation)
|
||||
}
|
||||
|
||||
// SetString sets the string for the OSC52 sequence. Strings are joined with a
|
||||
// space character.
|
||||
func (s Sequence) SetString(strs ...string) Sequence {
|
||||
s.str = strings.Join(strs, " ")
|
||||
return s
|
||||
}
|
||||
|
||||
// New creates a new OSC52 sequence with the given string(s). Strings are
|
||||
// joined with a space character.
|
||||
func New(strs ...string) Sequence {
|
||||
s := Sequence{
|
||||
str: strings.Join(strs, " "),
|
||||
limit: 0,
|
||||
mode: DefaultMode,
|
||||
clipboard: SystemClipboard,
|
||||
op: SetOperation,
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// Query creates a new OSC52 sequence with the QueryOperation.
|
||||
// This returns a new OSC52 sequence to query the clipboard contents.
|
||||
//
|
||||
// This is a syntactic sugar for New().Query().
|
||||
func Query() Sequence {
|
||||
return New().Query()
|
||||
}
|
||||
|
||||
// Clear creates a new OSC52 sequence with the ClearOperation.
|
||||
// This returns a new OSC52 sequence to clear the clipboard.
|
||||
//
|
||||
// This is a syntactic sugar for New().Clear().
|
||||
func Clear() Sequence {
|
||||
return New().Clear()
|
||||
}
|
||||
|
||||
func (s Sequence) seqStart() string {
|
||||
switch s.mode {
|
||||
case TmuxMode:
|
||||
// Write the start of a tmux escape sequence.
|
||||
return "\x1bPtmux;\x1b"
|
||||
case ScreenMode:
|
||||
// Write the start of a DCS sequence.
|
||||
return "\x1bP"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func (s Sequence) seqEnd() string {
|
||||
switch s.mode {
|
||||
case TmuxMode:
|
||||
// Terminate the tmux escape sequence.
|
||||
return "\x1b\\"
|
||||
case ScreenMode:
|
||||
// Write the end of a DCS sequence.
|
||||
return "\x1b\x5c"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
ssh_example_ed25519*
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
run:
|
||||
tests: false
|
||||
|
||||
issues:
|
||||
include:
|
||||
- EXC0001
|
||||
- EXC0005
|
||||
- EXC0011
|
||||
- EXC0012
|
||||
- EXC0013
|
||||
|
||||
max-issues-per-linter: 0
|
||||
max-same-issues: 0
|
||||
|
||||
linters:
|
||||
enable:
|
||||
# - dupl
|
||||
- exhaustive
|
||||
# - exhaustivestruct
|
||||
- goconst
|
||||
- godot
|
||||
- godox
|
||||
- gomnd
|
||||
- gomoddirectives
|
||||
- goprintffuncname
|
||||
- ifshort
|
||||
# - lll
|
||||
- misspell
|
||||
- nakedret
|
||||
- nestif
|
||||
- noctx
|
||||
- nolintlint
|
||||
- prealloc
|
||||
- wrapcheck
|
||||
|
||||
# disable default linters, they are already enabled in .golangci.yml
|
||||
disable:
|
||||
- deadcode
|
||||
- errcheck
|
||||
- gosimple
|
||||
- govet
|
||||
- ineffassign
|
||||
- staticcheck
|
||||
- structcheck
|
||||
- typecheck
|
||||
- unused
|
||||
- varcheck
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
run:
|
||||
tests: false
|
||||
|
||||
issues:
|
||||
include:
|
||||
- EXC0001
|
||||
- EXC0005
|
||||
- EXC0011
|
||||
- EXC0012
|
||||
- EXC0013
|
||||
|
||||
max-issues-per-linter: 0
|
||||
max-same-issues: 0
|
||||
|
||||
linters:
|
||||
enable:
|
||||
- bodyclose
|
||||
- exportloopref
|
||||
- goimports
|
||||
- gosec
|
||||
- nilerr
|
||||
- predeclared
|
||||
- revive
|
||||
- rowserrcheck
|
||||
- sqlclosecheck
|
||||
- tparallel
|
||||
- unconvert
|
||||
- unparam
|
||||
- whitespace
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) 2021-2023 Charmbracelet, Inc
|
||||
|
||||
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.
|
||||
|
|
@ -0,0 +1,562 @@
|
|||
Lip Gloss
|
||||
=========
|
||||
|
||||
<p>
|
||||
<img src="https://stuff.charm.sh/lipgloss/lipgloss-header-github.png" width="340" alt="Lip Gloss Title Treatment"><br>
|
||||
<a href="https://github.com/charmbracelet/lipgloss/releases"><img src="https://img.shields.io/github/release/charmbracelet/lipgloss.svg" alt="Latest Release"></a>
|
||||
<a href="https://pkg.go.dev/github.com/charmbracelet/lipgloss?tab=doc"><img src="https://godoc.org/github.com/golang/gddo?status.svg" alt="GoDoc"></a>
|
||||
<a href="https://github.com/charmbracelet/lipgloss/actions"><img src="https://github.com/charmbracelet/lipgloss/workflows/build/badge.svg" alt="Build Status"></a>
|
||||
</p>
|
||||
|
||||
Style definitions for nice terminal layouts. Built with TUIs in mind.
|
||||
|
||||
|
||||
|
||||
Lip Gloss takes an expressive, declarative approach to terminal rendering.
|
||||
Users familiar with CSS will feel at home with Lip Gloss.
|
||||
|
||||
```go
|
||||
|
||||
import "github.com/charmbracelet/lipgloss"
|
||||
|
||||
var style = lipgloss.NewStyle().
|
||||
Bold(true).
|
||||
Foreground(lipgloss.Color("#FAFAFA")).
|
||||
Background(lipgloss.Color("#7D56F4")).
|
||||
PaddingTop(2).
|
||||
PaddingLeft(4).
|
||||
Width(22)
|
||||
|
||||
fmt.Println(style.Render("Hello, kitty"))
|
||||
```
|
||||
|
||||
## Colors
|
||||
|
||||
Lip Gloss supports the following color profiles:
|
||||
|
||||
### ANSI 16 colors (4-bit)
|
||||
|
||||
```go
|
||||
lipgloss.Color("5") // magenta
|
||||
lipgloss.Color("9") // red
|
||||
lipgloss.Color("12") // light blue
|
||||
```
|
||||
|
||||
### ANSI 256 Colors (8-bit)
|
||||
|
||||
```go
|
||||
lipgloss.Color("86") // aqua
|
||||
lipgloss.Color("201") // hot pink
|
||||
lipgloss.Color("202") // orange
|
||||
```
|
||||
|
||||
### True Color (16,777,216 colors; 24-bit)
|
||||
|
||||
```go
|
||||
lipgloss.Color("#0000FF") // good ol' 100% blue
|
||||
lipgloss.Color("#04B575") // a green
|
||||
lipgloss.Color("#3C3C3C") // a dark gray
|
||||
```
|
||||
|
||||
...as well as a 1-bit ASCII profile, which is black and white only.
|
||||
|
||||
The terminal's color profile will be automatically detected, and colors outside
|
||||
the gamut of the current palette will be automatically coerced to their closest
|
||||
available value.
|
||||
|
||||
|
||||
### Adaptive Colors
|
||||
|
||||
You can also specify color options for light and dark backgrounds:
|
||||
|
||||
```go
|
||||
lipgloss.AdaptiveColor{Light: "236", Dark: "248"}
|
||||
```
|
||||
|
||||
The terminal's background color will automatically be detected and the
|
||||
appropriate color will be chosen at runtime.
|
||||
|
||||
### Complete Colors
|
||||
|
||||
CompleteColor specifies exact values for truecolor, ANSI256, and ANSI color
|
||||
profiles.
|
||||
|
||||
```go
|
||||
lipgloss.CompleteColor{True: "#0000FF", ANSI256: "86", ANSI: "5"}
|
||||
```
|
||||
|
||||
Automatic color degradation will not be performed in this case and it will be
|
||||
based on the color specified.
|
||||
|
||||
### Complete Adaptive Colors
|
||||
|
||||
You can use CompleteColor with AdaptiveColor to specify the exact values for
|
||||
light and dark backgrounds without automatic color degradation.
|
||||
|
||||
```go
|
||||
lipgloss.CompleteAdaptiveColor{
|
||||
Light: CompleteColor{TrueColor: "#d7ffae", ANSI256: "193", ANSI: "11"},
|
||||
Dark: CompleteColor{TrueColor: "#d75fee", ANSI256: "163", ANSI: "5"},
|
||||
}
|
||||
```
|
||||
|
||||
## Inline Formatting
|
||||
|
||||
Lip Gloss supports the usual ANSI text formatting options:
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().
|
||||
Bold(true).
|
||||
Italic(true).
|
||||
Faint(true).
|
||||
Blink(true).
|
||||
Strikethrough(true).
|
||||
Underline(true).
|
||||
Reverse(true)
|
||||
```
|
||||
|
||||
|
||||
## Block-Level Formatting
|
||||
|
||||
Lip Gloss also supports rules for block-level formatting:
|
||||
|
||||
```go
|
||||
// Padding
|
||||
var style = lipgloss.NewStyle().
|
||||
PaddingTop(2).
|
||||
PaddingRight(4).
|
||||
PaddingBottom(2).
|
||||
PaddingLeft(4)
|
||||
|
||||
// Margins
|
||||
var style = lipgloss.NewStyle().
|
||||
MarginTop(2).
|
||||
MarginRight(4).
|
||||
MarginBottom(2).
|
||||
MarginLeft(4)
|
||||
```
|
||||
|
||||
There is also shorthand syntax for margins and padding, which follows the same
|
||||
format as CSS:
|
||||
|
||||
```go
|
||||
// 2 cells on all sides
|
||||
lipgloss.NewStyle().Padding(2)
|
||||
|
||||
// 2 cells on the top and bottom, 4 cells on the left and right
|
||||
lipgloss.NewStyle().Margin(2, 4)
|
||||
|
||||
// 1 cell on the top, 4 cells on the sides, 2 cells on the bottom
|
||||
lipgloss.NewStyle().Padding(1, 4, 2)
|
||||
|
||||
// Clockwise, starting from the top: 2 cells on the top, 4 on the right, 3 on
|
||||
// the bottom, and 1 on the left
|
||||
lipgloss.NewStyle().Margin(2, 4, 3, 1)
|
||||
```
|
||||
|
||||
|
||||
## Aligning Text
|
||||
|
||||
You can align paragraphs of text to the left, right, or center.
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().
|
||||
Width(24).
|
||||
Align(lipgloss.Left). // align it left
|
||||
Align(lipgloss.Right). // no wait, align it right
|
||||
Align(lipgloss.Center) // just kidding, align it in the center
|
||||
```
|
||||
|
||||
|
||||
## Width and Height
|
||||
|
||||
Setting a minimum width and height is simple and straightforward.
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().
|
||||
SetString("What’s for lunch?").
|
||||
Width(24).
|
||||
Height(32).
|
||||
Foreground(lipgloss.Color("63"))
|
||||
```
|
||||
|
||||
|
||||
## Borders
|
||||
|
||||
Adding borders is easy:
|
||||
|
||||
```go
|
||||
// Add a purple, rectangular border
|
||||
var style = lipgloss.NewStyle().
|
||||
BorderStyle(lipgloss.NormalBorder()).
|
||||
BorderForeground(lipgloss.Color("63"))
|
||||
|
||||
// Set a rounded, yellow-on-purple border to the top and left
|
||||
var anotherStyle = lipgloss.NewStyle().
|
||||
BorderStyle(lipgloss.RoundedBorder()).
|
||||
BorderForeground(lipgloss.Color("228")).
|
||||
BorderBackground(lipgloss.Color("63")).
|
||||
BorderTop(true).
|
||||
BorderLeft(true)
|
||||
|
||||
// Make your own border
|
||||
var myCuteBorder = lipgloss.Border{
|
||||
Top: "._.:*:",
|
||||
Bottom: "._.:*:",
|
||||
Left: "|*",
|
||||
Right: "|*",
|
||||
TopLeft: "*",
|
||||
TopRight: "*",
|
||||
BottomLeft: "*",
|
||||
BottomRight: "*",
|
||||
}
|
||||
```
|
||||
|
||||
There are also shorthand functions for defining borders, which follow a similar
|
||||
pattern to the margin and padding shorthand functions.
|
||||
|
||||
```go
|
||||
// Add a thick border to the top and bottom
|
||||
lipgloss.NewStyle().
|
||||
Border(lipgloss.ThickBorder(), true, false)
|
||||
|
||||
// Add a thick border to the right and bottom sides. Rules are set clockwise
|
||||
// from top.
|
||||
lipgloss.NewStyle().
|
||||
Border(lipgloss.DoubleBorder(), true, false, false, true)
|
||||
```
|
||||
|
||||
For more on borders see [the docs][docs].
|
||||
|
||||
|
||||
## Copying Styles
|
||||
|
||||
Just use `Copy()`:
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().Foreground(lipgloss.Color("219"))
|
||||
|
||||
var wildStyle = style.Copy().Blink(true)
|
||||
```
|
||||
|
||||
`Copy()` performs a copy on the underlying data structure ensuring that you get
|
||||
a true, dereferenced copy of a style. Without copying, it's possible to mutate
|
||||
styles.
|
||||
|
||||
|
||||
## Inheritance
|
||||
|
||||
Styles can inherit rules from other styles. When inheriting, only unset rules
|
||||
on the receiver are inherited.
|
||||
|
||||
```go
|
||||
var styleA = lipgloss.NewStyle().
|
||||
Foreground(lipgloss.Color("229")).
|
||||
Background(lipgloss.Color("63"))
|
||||
|
||||
// Only the background color will be inherited here, because the foreground
|
||||
// color will have been already set:
|
||||
var styleB = lipgloss.NewStyle().
|
||||
Foreground(lipgloss.Color("201")).
|
||||
Inherit(styleA)
|
||||
```
|
||||
|
||||
|
||||
## Unsetting Rules
|
||||
|
||||
All rules can be unset:
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().
|
||||
Bold(true). // make it bold
|
||||
UnsetBold(). // jk don't make it bold
|
||||
Background(lipgloss.Color("227")). // yellow background
|
||||
UnsetBackground() // never mind
|
||||
```
|
||||
|
||||
When a rule is unset, it won't be inherited or copied.
|
||||
|
||||
|
||||
## Enforcing Rules
|
||||
|
||||
Sometimes, such as when developing a component, you want to make sure style
|
||||
definitions respect their intended purpose in the UI. This is where `Inline`
|
||||
and `MaxWidth`, and `MaxHeight` come in:
|
||||
|
||||
```go
|
||||
// Force rendering onto a single line, ignoring margins, padding, and borders.
|
||||
someStyle.Inline(true).Render("yadda yadda")
|
||||
|
||||
// Also limit rendering to five cells
|
||||
someStyle.Inline(true).MaxWidth(5).Render("yadda yadda")
|
||||
|
||||
// Limit rendering to a 5x5 cell block
|
||||
someStyle.MaxWidth(5).MaxHeight(5).Render("yadda yadda")
|
||||
```
|
||||
|
||||
## Tabs
|
||||
|
||||
The tab character (`\t`) is rendered differently in different terminals (often
|
||||
as 8 spaces, sometimes 4). Because of this inconsistency, Lip Gloss converts
|
||||
tabs to 4 spaces at render time. This behavior can be changed on a per-style
|
||||
basis, however:
|
||||
|
||||
```go
|
||||
style := lipgloss.NewStyle() // tabs will render as 4 spaces, the default
|
||||
style = style.TabWidth(2) // render tabs as 2 spaces
|
||||
style = style.TabWidth(0) // remove tabs entirely
|
||||
style = style.TabWidth(lipgloss.NoTabConversion) // leave tabs intact
|
||||
```
|
||||
|
||||
## Rendering
|
||||
|
||||
Generally, you just call the `Render(string...)` method on a `lipgloss.Style`:
|
||||
|
||||
```go
|
||||
style := lipgloss.NewStyle().Bold(true).SetString("Hello,")
|
||||
fmt.Println(style.Render("kitty.")) // Hello, kitty.
|
||||
fmt.Println(style.Render("puppy.")) // Hello, puppy.
|
||||
```
|
||||
|
||||
But you could also use the Stringer interface:
|
||||
|
||||
```go
|
||||
var style = lipgloss.NewStyle().SetString("你好，猫咪。").Bold(true)
|
||||
fmt.Println(style) // 你好，猫咪。
|
||||
```
|
||||
|
||||
### Custom Renderers
|
||||
|
||||
Custom renderers allow you to render to a specific outputs. This is
|
||||
particularly important when you want to render to different outputs and
|
||||
correctly detect the color profile and dark background status for each, such as
|
||||
in a server-client situation.
|
||||
|
||||
```go
|
||||
func myLittleHandler(sess ssh.Session) {
|
||||
// Create a renderer for the client.
|
||||
renderer := lipgloss.NewRenderer(sess)
|
||||
|
||||
// Create a new style on the renderer.
|
||||
style := renderer.NewStyle().Background(lipgloss.AdaptiveColor{Light: "63", Dark: "228"})
|
||||
|
||||
// Render. The color profile and dark background state will be correctly detected.
|
||||
io.WriteString(sess, style.Render("Heyyyyyyy"))
|
||||
}
|
||||
```
|
||||
|
||||
For an example on using a custom renderer over SSH with [Wish][wish] see the
|
||||
[SSH example][ssh-example].
|
||||
|
||||
## Utilities
|
||||
|
||||
In addition to pure styling, Lip Gloss also ships with some utilities to help
|
||||
assemble your layouts.
|
||||
|
||||
|
||||
### Joining Paragraphs
|
||||
|
||||
Horizontally and vertically joining paragraphs is a cinch.
|
||||
|
||||
```go
|
||||
// Horizontally join three paragraphs along their bottom edges
|
||||
lipgloss.JoinHorizontal(lipgloss.Bottom, paragraphA, paragraphB, paragraphC)
|
||||
|
||||
// Vertically join two paragraphs along their center axes
|
||||
lipgloss.JoinVertical(lipgloss.Center, paragraphA, paragraphB)
|
||||
|
||||
// Horizontally join three paragraphs, with the shorter ones aligning 20%
|
||||
// from the top of the tallest
|
||||
lipgloss.JoinHorizontal(0.2, paragraphA, paragraphB, paragraphC)
|
||||
```
|
||||
|
||||
|
||||
### Measuring Width and Height
|
||||
|
||||
Sometimes you’ll want to know the width and height of text blocks when building
|
||||
your layouts.
|
||||
|
||||
```go
|
||||
// Render a block of text.
|
||||
var style = lipgloss.NewStyle().
|
||||
Width(40).
|
||||
Padding(2)
|
||||
var block string = style.Render(someLongString)
|
||||
|
||||
// Get the actual, physical dimensions of the text block.
|
||||
width := lipgloss.Width(block)
|
||||
height := lipgloss.Height(block)
|
||||
|
||||
// Here's a shorthand function.
|
||||
w, h := lipgloss.Size(block)
|
||||
```
|
||||
|
||||
### Placing Text in Whitespace
|
||||
|
||||
Sometimes you’ll simply want to place a block of text in whitespace.
|
||||
|
||||
```go
|
||||
// Center a paragraph horizontally in a space 80 cells wide. The height of
|
||||
// the block returned will be as tall as the input paragraph.
|
||||
block := lipgloss.PlaceHorizontal(80, lipgloss.Center, fancyStyledParagraph)
|
||||
|
||||
// Place a paragraph at the bottom of a space 30 cells tall. The width of
|
||||
// the text block returned will be as wide as the input paragraph.
|
||||
block := lipgloss.PlaceVertical(30, lipgloss.Bottom, fancyStyledParagraph)
|
||||
|
||||
// Place a paragraph in the bottom right corner of a 30x80 cell space.
|
||||
block := lipgloss.Place(30, 80, lipgloss.Right, lipgloss.Bottom, fancyStyledParagraph)
|
||||
```
|
||||
|
||||
You can also style the whitespace. For details, see [the docs][docs].
|
||||
|
||||
### Rendering Tables
|
||||
|
||||
Lip Gloss ships with a table rendering sub-package.
|
||||
|
||||
```go
|
||||
import "github.com/charmbracelet/lipgloss/table"
|
||||
```
|
||||
|
||||
Define some rows of data.
|
||||
|
||||
```go
|
||||
rows := [][]string{
|
||||
{"Chinese", "您好", "你好"},
|
||||
{"Japanese", "こんにちは", "やあ"},
|
||||
{"Arabic", "أهلين", "أهلا"},
|
||||
{"Russian", "Здравствуйте", "Привет"},
|
||||
{"Spanish", "Hola", "¿Qué tal?"},
|
||||
}
|
||||
```
|
||||
|
||||
Use the table package to style and render the table.
|
||||
|
||||
```go
|
||||
t := table.New().
|
||||
Border(lipgloss.NormalBorder()).
|
||||
BorderStyle(lipgloss.NewStyle().Foreground(lipgloss.Color("99"))).
|
||||
StyleFunc(func(row, col int) lipgloss.Style {
|
||||
switch {
|
||||
case row == 0:
|
||||
return HeaderStyle
|
||||
case row%2 == 0:
|
||||
return EvenRowStyle
|
||||
default:
|
||||
return OddRowStyle
|
||||
}
|
||||
}).
|
||||
Headers("LANGUAGE", "FORMAL", "INFORMAL").
|
||||
Rows(rows...)
|
||||
|
||||
// You can also add tables row-by-row
|
||||
t.Row("English", "You look absolutely fabulous.", "How's it going?")
|
||||
```
|
||||
|
||||
Print the table.
|
||||
|
||||
```go
|
||||
fmt.Println(t)
|
||||
```
|
||||
|
||||
|
||||
|
||||
For more on tables see [the docs](https://pkg.go.dev/github.com/charmbracelet/lipgloss?tab=doc).
|
||||
|
||||
***
|
||||
|
||||
## FAQ
|
||||
|
||||
<details>
|
||||
<summary>
|
||||
Why are things misaligning? Why are borders at the wrong widths?
|
||||
</summary>
|
||||
<p>This is most likely due to your locale and encoding, particularly with
|
||||
regard to Chinese, Japanese, and Korean (for example, <code>zh_CN.UTF-8</code>
|
||||
or <code>ja_JP.UTF-8</code>). The most direct way to fix this is to set
|
||||
<code>RUNEWIDTH_EASTASIAN=0</code> in your environment.</p>
|
||||
|
||||
<p>For details see <a href="https://github.com/charmbracelet/lipgloss/issues/40">https://github.com/charmbracelet/lipgloss/issues/40.</a></p>
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary>
|
||||
Why isn't Lip Gloss displaying colors?
|
||||
</summary>
|
||||
<p>Lip Gloss automatically degrades colors to the best available option in the
|
||||
given terminal, and if output's not a TTY it will remove color output entirely.
|
||||
This is common when running tests, CI, or when piping output elsewhere.</p>
|
||||
|
||||
<p>If necessary, you can force a color profile in your tests with
|
||||
<a href="https://pkg.go.dev/github.com/charmbracelet/lipgloss#SetColorProfile"><code>SetColorProfile</code></a>.</p>
|
||||
|
||||
```go
|
||||
import (
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
lipgloss.SetColorProfile(termenv.TrueColor)
|
||||
```
|
||||
|
||||
*Note:* this option limits the flexibility of your application and can cause
|
||||
ANSI escape codes to be output in cases where that might not be desired. Take
|
||||
careful note of your use case and environment before choosing to force a color
|
||||
profile.
|
||||
</details>
|
||||
|
||||
## What about [Bubble Tea][tea]?
|
||||
|
||||
Lip Gloss doesn’t replace Bubble Tea. Rather, it is an excellent Bubble Tea
|
||||
companion. It was designed to make assembling terminal user interface views as
|
||||
simple and fun as possible so that you can focus on building your application
|
||||
instead of concerning yourself with low-level layout details.
|
||||
|
||||
In simple terms, you can use Lip Gloss to help build your Bubble Tea views.
|
||||
|
||||
[tea]: https://github.com/charmbracelet/tea
|
||||
|
||||
|
||||
## Under the Hood
|
||||
|
||||
Lip Gloss is built on the excellent [Termenv][termenv] and [Reflow][reflow]
|
||||
libraries which deal with color and ANSI-aware text operations, respectively.
|
||||
For many use cases Termenv and Reflow will be sufficient for your needs.
|
||||
|
||||
[termenv]: https://github.com/muesli/termenv
|
||||
[reflow]: https://github.com/muesli/reflow
|
||||
|
||||
|
||||
## Rendering Markdown
|
||||
|
||||
For a more document-centric rendering solution with support for things like
|
||||
lists, tables, and syntax-highlighted code have a look at [Glamour][glamour],
|
||||
the stylesheet-based Markdown renderer.
|
||||
|
||||
[glamour]: https://github.com/charmbracelet/glamour
|
||||
|
||||
|
||||
## Feedback
|
||||
|
||||
We’d love to hear your thoughts on this project. Feel free to drop us a note!
|
||||
|
||||
* [Twitter](https://twitter.com/charmcli)
|
||||
* [The Fediverse](https://mastodon.social/@charmcli)
|
||||
* [Discord](https://charm.sh/chat)
|
||||
|
||||
## License
|
||||
|
||||
[MIT](https://github.com/charmbracelet/lipgloss/raw/master/LICENSE)
|
||||
|
||||
***
|
||||
|
||||
Part of [Charm](https://charm.sh).
|
||||
|
||||
<a href="https://charm.sh/"><img alt="The Charm logo" src="https://stuff.charm.sh/charm-badge.jpg" width="400"></a>
|
||||
|
||||
Charm热爱开源 • Charm loves open source
|
||||
|
||||
|
||||
[docs]: https://pkg.go.dev/github.com/charmbracelet/lipgloss?tab=doc
|
||||
[wish]: https://github.com/charmbracelet/wish
|
||||
[ssh-example]: examples/ssh
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
// Perform text alignment. If the string is multi-lined, we also make all lines
|
||||
// the same width by padding them with spaces. If a termenv style is passed,
|
||||
// use that to style the spaces added.
|
||||
func alignTextHorizontal(str string, pos Position, width int, style *termenv.Style) string {
|
||||
lines, widestLine := getLines(str)
|
||||
var b strings.Builder
|
||||
|
||||
for i, l := range lines {
|
||||
lineWidth := ansi.PrintableRuneWidth(l)
|
||||
|
||||
shortAmount := widestLine - lineWidth // difference from the widest line
|
||||
shortAmount += max(0, width-(shortAmount+lineWidth)) // difference from the total width, if set
|
||||
|
||||
if shortAmount > 0 {
|
||||
switch pos { //nolint:exhaustive
|
||||
case Right:
|
||||
s := strings.Repeat(" ", shortAmount)
|
||||
if style != nil {
|
||||
s = style.Styled(s)
|
||||
}
|
||||
l = s + l
|
||||
case Center:
|
||||
// Note: remainder goes on the right.
|
||||
left := shortAmount / 2 //nolint:gomnd
|
||||
right := left + shortAmount%2 //nolint:gomnd
|
||||
|
||||
leftSpaces := strings.Repeat(" ", left)
|
||||
rightSpaces := strings.Repeat(" ", right)
|
||||
|
||||
if style != nil {
|
||||
leftSpaces = style.Styled(leftSpaces)
|
||||
rightSpaces = style.Styled(rightSpaces)
|
||||
}
|
||||
l = leftSpaces + l + rightSpaces
|
||||
default: // Left
|
||||
s := strings.Repeat(" ", shortAmount)
|
||||
if style != nil {
|
||||
s = style.Styled(s)
|
||||
}
|
||||
l += s
|
||||
}
|
||||
}
|
||||
|
||||
b.WriteString(l)
|
||||
if i < len(lines)-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func alignTextVertical(str string, pos Position, height int, _ *termenv.Style) string {
|
||||
strHeight := strings.Count(str, "\n") + 1
|
||||
if height < strHeight {
|
||||
return str
|
||||
}
|
||||
|
||||
switch pos {
|
||||
case Top:
|
||||
return str + strings.Repeat("\n", height-strHeight)
|
||||
case Center:
|
||||
var topPadding, bottomPadding = (height - strHeight) / 2, (height - strHeight) / 2
|
||||
if strHeight+topPadding+bottomPadding > height {
|
||||
topPadding--
|
||||
} else if strHeight+topPadding+bottomPadding < height {
|
||||
bottomPadding++
|
||||
}
|
||||
return strings.Repeat("\n", topPadding) + str + strings.Repeat("\n", bottomPadding)
|
||||
case Bottom:
|
||||
return strings.Repeat("\n", height-strHeight) + str
|
||||
}
|
||||
return str
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
//go:build !windows
|
||||
// +build !windows
|
||||
|
||||
package lipgloss
|
||||
|
||||
// enableLegacyWindowsANSI is only needed on Windows.
|
||||
func enableLegacyWindowsANSI() {}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
//go:build windows
|
||||
// +build windows
|
||||
|
||||
package lipgloss
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
var enableANSI sync.Once
|
||||
|
||||
// enableANSIColors enables support for ANSI color sequences in the Windows
|
||||
// default console (cmd.exe and the PowerShell application). Note that this
|
||||
// only works with Windows 10. Also note that Windows Terminal supports colors
|
||||
// by default.
|
||||
func enableLegacyWindowsANSI() {
|
||||
enableANSI.Do(func() {
|
||||
_, _ = termenv.EnableWindowsANSIConsole()
|
||||
})
|
||||
}
|
||||
|
|
@ -0,0 +1,442 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/mattn/go-runewidth"
|
||||
"github.com/muesli/reflow/ansi"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
// Border contains a series of values which comprise the various parts of a
|
||||
// border.
|
||||
type Border struct {
|
||||
Top string
|
||||
Bottom string
|
||||
Left string
|
||||
Right string
|
||||
TopLeft string
|
||||
TopRight string
|
||||
BottomLeft string
|
||||
BottomRight string
|
||||
MiddleLeft string
|
||||
MiddleRight string
|
||||
Middle string
|
||||
MiddleTop string
|
||||
MiddleBottom string
|
||||
}
|
||||
|
||||
// GetTopSize returns the width of the top border. If borders contain runes of
|
||||
// varying widths, the widest rune is returned. If no border exists on the top
|
||||
// edge, 0 is returned.
|
||||
func (b Border) GetTopSize() int {
|
||||
return getBorderEdgeWidth(b.TopLeft, b.Top, b.TopRight)
|
||||
}
|
||||
|
||||
// GetRightSize returns the width of the right border. If borders contain
|
||||
// runes of varying widths, the widest rune is returned. If no border exists on
|
||||
// the right edge, 0 is returned.
|
||||
func (b Border) GetRightSize() int {
|
||||
return getBorderEdgeWidth(b.TopRight, b.Right, b.BottomRight)
|
||||
}
|
||||
|
||||
// GetBottomSize returns the width of the bottom border. If borders contain
|
||||
// runes of varying widths, the widest rune is returned. If no border exists on
|
||||
// the bottom edge, 0 is returned.
|
||||
func (b Border) GetBottomSize() int {
|
||||
return getBorderEdgeWidth(b.BottomLeft, b.Bottom, b.BottomRight)
|
||||
}
|
||||
|
||||
// GetLeftSize returns the width of the left border. If borders contain runes
|
||||
// of varying widths, the widest rune is returned. If no border exists on the
|
||||
// left edge, 0 is returned.
|
||||
func (b Border) GetLeftSize() int {
|
||||
return getBorderEdgeWidth(b.TopLeft, b.Left, b.BottomLeft)
|
||||
}
|
||||
|
||||
func getBorderEdgeWidth(borderParts ...string) (maxWidth int) {
|
||||
for _, piece := range borderParts {
|
||||
w := maxRuneWidth(piece)
|
||||
if w > maxWidth {
|
||||
maxWidth = w
|
||||
}
|
||||
}
|
||||
return maxWidth
|
||||
}
|
||||
|
||||
var (
|
||||
noBorder = Border{}
|
||||
|
||||
normalBorder = Border{
|
||||
Top: "─",
|
||||
Bottom: "─",
|
||||
Left: "│",
|
||||
Right: "│",
|
||||
TopLeft: "┌",
|
||||
TopRight: "┐",
|
||||
BottomLeft: "└",
|
||||
BottomRight: "┘",
|
||||
MiddleLeft: "├",
|
||||
MiddleRight: "┤",
|
||||
Middle: "┼",
|
||||
MiddleTop: "┬",
|
||||
MiddleBottom: "┴",
|
||||
}
|
||||
|
||||
roundedBorder = Border{
|
||||
Top: "─",
|
||||
Bottom: "─",
|
||||
Left: "│",
|
||||
Right: "│",
|
||||
TopLeft: "╭",
|
||||
TopRight: "╮",
|
||||
BottomLeft: "╰",
|
||||
BottomRight: "╯",
|
||||
MiddleLeft: "├",
|
||||
MiddleRight: "┤",
|
||||
Middle: "┼",
|
||||
MiddleTop: "┬",
|
||||
MiddleBottom: "┴",
|
||||
}
|
||||
|
||||
blockBorder = Border{
|
||||
Top: "█",
|
||||
Bottom: "█",
|
||||
Left: "█",
|
||||
Right: "█",
|
||||
TopLeft: "█",
|
||||
TopRight: "█",
|
||||
BottomLeft: "█",
|
||||
BottomRight: "█",
|
||||
}
|
||||
|
||||
outerHalfBlockBorder = Border{
|
||||
Top: "▀",
|
||||
Bottom: "▄",
|
||||
Left: "▌",
|
||||
Right: "▐",
|
||||
TopLeft: "▛",
|
||||
TopRight: "▜",
|
||||
BottomLeft: "▙",
|
||||
BottomRight: "▟",
|
||||
}
|
||||
|
||||
innerHalfBlockBorder = Border{
|
||||
Top: "▄",
|
||||
Bottom: "▀",
|
||||
Left: "▐",
|
||||
Right: "▌",
|
||||
TopLeft: "▗",
|
||||
TopRight: "▖",
|
||||
BottomLeft: "▝",
|
||||
BottomRight: "▘",
|
||||
}
|
||||
|
||||
thickBorder = Border{
|
||||
Top: "━",
|
||||
Bottom: "━",
|
||||
Left: "┃",
|
||||
Right: "┃",
|
||||
TopLeft: "┏",
|
||||
TopRight: "┓",
|
||||
BottomLeft: "┗",
|
||||
BottomRight: "┛",
|
||||
MiddleLeft: "┣",
|
||||
MiddleRight: "┫",
|
||||
Middle: "╋",
|
||||
MiddleTop: "┳",
|
||||
MiddleBottom: "┻",
|
||||
}
|
||||
|
||||
doubleBorder = Border{
|
||||
Top: "═",
|
||||
Bottom: "═",
|
||||
Left: "║",
|
||||
Right: "║",
|
||||
TopLeft: "╔",
|
||||
TopRight: "╗",
|
||||
BottomLeft: "╚",
|
||||
BottomRight: "╝",
|
||||
MiddleLeft: "╠",
|
||||
MiddleRight: "╣",
|
||||
Middle: "╬",
|
||||
MiddleTop: "╦",
|
||||
MiddleBottom: "╩",
|
||||
}
|
||||
|
||||
hiddenBorder = Border{
|
||||
Top: " ",
|
||||
Bottom: " ",
|
||||
Left: " ",
|
||||
Right: " ",
|
||||
TopLeft: " ",
|
||||
TopRight: " ",
|
||||
BottomLeft: " ",
|
||||
BottomRight: " ",
|
||||
MiddleLeft: " ",
|
||||
MiddleRight: " ",
|
||||
Middle: " ",
|
||||
MiddleTop: " ",
|
||||
MiddleBottom: " ",
|
||||
}
|
||||
)
|
||||
|
||||
// NormalBorder returns a standard-type border with a normal weight and 90
|
||||
// degree corners.
|
||||
func NormalBorder() Border {
|
||||
return normalBorder
|
||||
}
|
||||
|
||||
// RoundedBorder returns a border with rounded corners.
|
||||
func RoundedBorder() Border {
|
||||
return roundedBorder
|
||||
}
|
||||
|
||||
// BlockBorder returns a border that takes the whole block.
|
||||
func BlockBorder() Border {
|
||||
return blockBorder
|
||||
}
|
||||
|
||||
// OuterHalfBlockBorder returns a half-block border that sits outside the frame.
|
||||
func OuterHalfBlockBorder() Border {
|
||||
return outerHalfBlockBorder
|
||||
}
|
||||
|
||||
// InnerHalfBlockBorder returns a half-block border that sits inside the frame.
|
||||
func InnerHalfBlockBorder() Border {
|
||||
return innerHalfBlockBorder
|
||||
}
|
||||
|
||||
// ThickBorder returns a border that's thicker than the one returned by
|
||||
// NormalBorder.
|
||||
func ThickBorder() Border {
|
||||
return thickBorder
|
||||
}
|
||||
|
||||
// DoubleBorder returns a border comprised of two thin strokes.
|
||||
func DoubleBorder() Border {
|
||||
return doubleBorder
|
||||
}
|
||||
|
||||
// HiddenBorder returns a border that renders as a series of single-cell
|
||||
// spaces. It's useful for cases when you want to remove a standard border but
|
||||
// maintain layout positioning. This said, you can still apply a background
|
||||
// color to a hidden border.
|
||||
func HiddenBorder() Border {
|
||||
return hiddenBorder
|
||||
}
|
||||
|
||||
func (s Style) applyBorder(str string) string {
|
||||
var (
|
||||
topSet = s.isSet(borderTopKey)
|
||||
rightSet = s.isSet(borderRightKey)
|
||||
bottomSet = s.isSet(borderBottomKey)
|
||||
leftSet = s.isSet(borderLeftKey)
|
||||
|
||||
border = s.getBorderStyle()
|
||||
hasTop = s.getAsBool(borderTopKey, false)
|
||||
hasRight = s.getAsBool(borderRightKey, false)
|
||||
hasBottom = s.getAsBool(borderBottomKey, false)
|
||||
hasLeft = s.getAsBool(borderLeftKey, false)
|
||||
|
||||
topFG = s.getAsColor(borderTopForegroundKey)
|
||||
rightFG = s.getAsColor(borderRightForegroundKey)
|
||||
bottomFG = s.getAsColor(borderBottomForegroundKey)
|
||||
leftFG = s.getAsColor(borderLeftForegroundKey)
|
||||
|
||||
topBG = s.getAsColor(borderTopBackgroundKey)
|
||||
rightBG = s.getAsColor(borderRightBackgroundKey)
|
||||
bottomBG = s.getAsColor(borderBottomBackgroundKey)
|
||||
leftBG = s.getAsColor(borderLeftBackgroundKey)
|
||||
)
|
||||
|
||||
// If a border is set and no sides have been specifically turned on or off
|
||||
// render borders on all sides.
|
||||
if border != noBorder && !(topSet || rightSet || bottomSet || leftSet) {
|
||||
hasTop = true
|
||||
hasRight = true
|
||||
hasBottom = true
|
||||
hasLeft = true
|
||||
}
|
||||
|
||||
// If no border is set or all borders are been disabled, abort.
|
||||
if border == noBorder || (!hasTop && !hasRight && !hasBottom && !hasLeft) {
|
||||
return str
|
||||
}
|
||||
|
||||
lines, width := getLines(str)
|
||||
|
||||
if hasLeft {
|
||||
if border.Left == "" {
|
||||
border.Left = " "
|
||||
}
|
||||
width += maxRuneWidth(border.Left)
|
||||
}
|
||||
|
||||
if hasRight && border.Right == "" {
|
||||
border.Right = " "
|
||||
}
|
||||
|
||||
// If corners should be rendered but are set with the empty string, fill them
|
||||
// with a single space.
|
||||
if hasTop && hasLeft && border.TopLeft == "" {
|
||||
border.TopLeft = " "
|
||||
}
|
||||
if hasTop && hasRight && border.TopRight == "" {
|
||||
border.TopRight = " "
|
||||
}
|
||||
if hasBottom && hasLeft && border.BottomLeft == "" {
|
||||
border.BottomLeft = " "
|
||||
}
|
||||
if hasBottom && hasRight && border.BottomRight == "" {
|
||||
border.BottomRight = " "
|
||||
}
|
||||
|
||||
// Figure out which corners we should actually be using based on which
|
||||
// sides are set to show.
|
||||
if hasTop {
|
||||
switch {
|
||||
case !hasLeft && !hasRight:
|
||||
border.TopLeft = ""
|
||||
border.TopRight = ""
|
||||
case !hasLeft:
|
||||
border.TopLeft = ""
|
||||
case !hasRight:
|
||||
border.TopRight = ""
|
||||
}
|
||||
}
|
||||
if hasBottom {
|
||||
switch {
|
||||
case !hasLeft && !hasRight:
|
||||
border.BottomLeft = ""
|
||||
border.BottomRight = ""
|
||||
case !hasLeft:
|
||||
border.BottomLeft = ""
|
||||
case !hasRight:
|
||||
border.BottomRight = ""
|
||||
}
|
||||
}
|
||||
|
||||
// For now, limit corners to one rune.
|
||||
border.TopLeft = getFirstRuneAsString(border.TopLeft)
|
||||
border.TopRight = getFirstRuneAsString(border.TopRight)
|
||||
border.BottomRight = getFirstRuneAsString(border.BottomRight)
|
||||
border.BottomLeft = getFirstRuneAsString(border.BottomLeft)
|
||||
|
||||
var out strings.Builder
|
||||
|
||||
// Render top
|
||||
if hasTop {
|
||||
top := renderHorizontalEdge(border.TopLeft, border.Top, border.TopRight, width)
|
||||
top = s.styleBorder(top, topFG, topBG)
|
||||
out.WriteString(top)
|
||||
out.WriteRune('\n')
|
||||
}
|
||||
|
||||
leftRunes := []rune(border.Left)
|
||||
leftIndex := 0
|
||||
|
||||
rightRunes := []rune(border.Right)
|
||||
rightIndex := 0
|
||||
|
||||
// Render sides
|
||||
for i, l := range lines {
|
||||
if hasLeft {
|
||||
r := string(leftRunes[leftIndex])
|
||||
leftIndex++
|
||||
if leftIndex >= len(leftRunes) {
|
||||
leftIndex = 0
|
||||
}
|
||||
out.WriteString(s.styleBorder(r, leftFG, leftBG))
|
||||
}
|
||||
out.WriteString(l)
|
||||
if hasRight {
|
||||
r := string(rightRunes[rightIndex])
|
||||
rightIndex++
|
||||
if rightIndex >= len(rightRunes) {
|
||||
rightIndex = 0
|
||||
}
|
||||
out.WriteString(s.styleBorder(r, rightFG, rightBG))
|
||||
}
|
||||
if i < len(lines)-1 {
|
||||
out.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
// Render bottom
|
||||
if hasBottom {
|
||||
bottom := renderHorizontalEdge(border.BottomLeft, border.Bottom, border.BottomRight, width)
|
||||
bottom = s.styleBorder(bottom, bottomFG, bottomBG)
|
||||
out.WriteRune('\n')
|
||||
out.WriteString(bottom)
|
||||
}
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// Render the horizontal (top or bottom) portion of a border.
|
||||
func renderHorizontalEdge(left, middle, right string, width int) string {
|
||||
if width < 1 {
|
||||
return ""
|
||||
}
|
||||
|
||||
if middle == "" {
|
||||
middle = " "
|
||||
}
|
||||
|
||||
leftWidth := ansi.PrintableRuneWidth(left)
|
||||
rightWidth := ansi.PrintableRuneWidth(right)
|
||||
|
||||
runes := []rune(middle)
|
||||
j := 0
|
||||
|
||||
out := strings.Builder{}
|
||||
out.WriteString(left)
|
||||
for i := leftWidth + rightWidth; i < width+rightWidth; {
|
||||
out.WriteRune(runes[j])
|
||||
j++
|
||||
if j >= len(runes) {
|
||||
j = 0
|
||||
}
|
||||
i += ansi.PrintableRuneWidth(string(runes[j]))
|
||||
}
|
||||
out.WriteString(right)
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// Apply foreground and background styling to a border.
|
||||
func (s Style) styleBorder(border string, fg, bg TerminalColor) string {
|
||||
if fg == noColor && bg == noColor {
|
||||
return border
|
||||
}
|
||||
|
||||
var style = termenv.Style{}
|
||||
|
||||
if fg != noColor {
|
||||
style = style.Foreground(fg.color(s.r))
|
||||
}
|
||||
if bg != noColor {
|
||||
style = style.Background(bg.color(s.r))
|
||||
}
|
||||
|
||||
return style.Styled(border)
|
||||
}
|
||||
|
||||
func maxRuneWidth(str string) (width int) {
|
||||
for _, r := range str {
|
||||
w := runewidth.RuneWidth(r)
|
||||
if w > width {
|
||||
width = w
|
||||
}
|
||||
}
|
||||
return width
|
||||
}
|
||||
|
||||
func getFirstRuneAsString(str string) string {
|
||||
if str == "" {
|
||||
return str
|
||||
}
|
||||
r := []rune(str)
|
||||
return string(r[0])
|
||||
}
|
||||
|
|
@ -0,0 +1,172 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
// TerminalColor is a color intended to be rendered in the terminal.
|
||||
type TerminalColor interface {
|
||||
color(*Renderer) termenv.Color
|
||||
RGBA() (r, g, b, a uint32)
|
||||
}
|
||||
|
||||
var noColor = NoColor{}
|
||||
|
||||
// NoColor is used to specify the absence of color styling. When this is active
|
||||
// foreground colors will be rendered with the terminal's default text color,
|
||||
// and background colors will not be drawn at all.
|
||||
//
|
||||
// Example usage:
|
||||
//
|
||||
// var style = someStyle.Copy().Background(lipgloss.NoColor{})
|
||||
type NoColor struct{}
|
||||
|
||||
func (NoColor) color(*Renderer) termenv.Color {
|
||||
return termenv.NoColor{}
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. Because we have to return
|
||||
// something, despite this color being the absence of color, we're returning
|
||||
// black with 100% opacity.
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
//
|
||||
// Deprecated.
|
||||
func (n NoColor) RGBA() (r, g, b, a uint32) {
|
||||
return 0x0, 0x0, 0x0, 0xFFFF //nolint:gomnd
|
||||
}
|
||||
|
||||
// Color specifies a color by hex or ANSI value. For example:
|
||||
//
|
||||
// ansiColor := lipgloss.Color("21")
|
||||
// hexColor := lipgloss.Color("#0000ff")
|
||||
type Color string
|
||||
|
||||
func (c Color) color(r *Renderer) termenv.Color {
|
||||
return r.ColorProfile().Color(string(c))
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
||||
// interface. Note that on error we return black with 100% opacity, or:
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
//
|
||||
// Deprecated.
|
||||
func (c Color) RGBA() (r, g, b, a uint32) {
|
||||
return termenv.ConvertToRGB(c.color(renderer)).RGBA()
|
||||
}
|
||||
|
||||
// ANSIColor is a color specified by an ANSI color value. It's merely syntactic
|
||||
// sugar for the more general Color function. Invalid colors will render as
|
||||
// black.
|
||||
//
|
||||
// Example usage:
|
||||
//
|
||||
// // These two statements are equivalent.
|
||||
// colorA := lipgloss.ANSIColor(21)
|
||||
// colorB := lipgloss.Color("21")
|
||||
type ANSIColor uint
|
||||
|
||||
func (ac ANSIColor) color(r *Renderer) termenv.Color {
|
||||
return Color(strconv.FormatUint(uint64(ac), 10)).color(r)
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
||||
// interface. Note that on error we return black with 100% opacity, or:
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
//
|
||||
// Deprecated.
|
||||
func (ac ANSIColor) RGBA() (r, g, b, a uint32) {
|
||||
cf := Color(strconv.FormatUint(uint64(ac), 10))
|
||||
return cf.RGBA()
|
||||
}
|
||||
|
||||
// AdaptiveColor provides color options for light and dark backgrounds. The
|
||||
// appropriate color will be returned at runtime based on the darkness of the
|
||||
// terminal background color.
|
||||
//
|
||||
// Example usage:
|
||||
//
|
||||
// color := lipgloss.AdaptiveColor{Light: "#0000ff", Dark: "#000099"}
|
||||
type AdaptiveColor struct {
|
||||
Light string
|
||||
Dark string
|
||||
}
|
||||
|
||||
func (ac AdaptiveColor) color(r *Renderer) termenv.Color {
|
||||
if r.HasDarkBackground() {
|
||||
return Color(ac.Dark).color(r)
|
||||
}
|
||||
return Color(ac.Light).color(r)
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
||||
// interface. Note that on error we return black with 100% opacity, or:
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
//
|
||||
// Deprecated.
|
||||
func (ac AdaptiveColor) RGBA() (r, g, b, a uint32) {
|
||||
return termenv.ConvertToRGB(ac.color(renderer)).RGBA()
|
||||
}
|
||||
|
||||
// CompleteColor specifies exact values for truecolor, ANSI256, and ANSI color
|
||||
// profiles. Automatic color degradation will not be performed.
|
||||
type CompleteColor struct {
|
||||
TrueColor string
|
||||
ANSI256 string
|
||||
ANSI string
|
||||
}
|
||||
|
||||
func (c CompleteColor) color(r *Renderer) termenv.Color {
|
||||
p := r.ColorProfile()
|
||||
switch p { //nolint:exhaustive
|
||||
case termenv.TrueColor:
|
||||
return p.Color(c.TrueColor)
|
||||
case termenv.ANSI256:
|
||||
return p.Color(c.ANSI256)
|
||||
case termenv.ANSI:
|
||||
return p.Color(c.ANSI)
|
||||
default:
|
||||
return termenv.NoColor{}
|
||||
}
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
||||
// interface. Note that on error we return black with 100% opacity, or:
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
// CompleteAdaptiveColor specifies exact values for truecolor, ANSI256, and ANSI color
|
||||
//
|
||||
// Deprecated.
|
||||
func (c CompleteColor) RGBA() (r, g, b, a uint32) {
|
||||
return termenv.ConvertToRGB(c.color(renderer)).RGBA()
|
||||
}
|
||||
|
||||
// CompleteAdaptiveColor specifies exact values for truecolor, ANSI256, and ANSI color
|
||||
// profiles, with separate options for light and dark backgrounds. Automatic
|
||||
// color degradation will not be performed.
|
||||
type CompleteAdaptiveColor struct {
|
||||
Light CompleteColor
|
||||
Dark CompleteColor
|
||||
}
|
||||
|
||||
func (cac CompleteAdaptiveColor) color(r *Renderer) termenv.Color {
|
||||
if r.HasDarkBackground() {
|
||||
return cac.Dark.color(r)
|
||||
}
|
||||
return cac.Light.color(r)
|
||||
}
|
||||
|
||||
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
||||
// interface. Note that on error we return black with 100% opacity, or:
|
||||
//
|
||||
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
||||
//
|
||||
// Deprecated.
|
||||
func (cac CompleteAdaptiveColor) RGBA() (r, g, b, a uint32) {
|
||||
return termenv.ConvertToRGB(cac.color(renderer)).RGBA()
|
||||
}
|
||||
|
|
@ -0,0 +1,485 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
)
|
||||
|
||||
// GetBold returns the style's bold value. If no value is set false is returned.
|
||||
func (s Style) GetBold() bool {
|
||||
return s.getAsBool(boldKey, false)
|
||||
}
|
||||
|
||||
// GetItalic returns the style's italic value. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetItalic() bool {
|
||||
return s.getAsBool(italicKey, false)
|
||||
}
|
||||
|
||||
// GetUnderline returns the style's underline value. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetUnderline() bool {
|
||||
return s.getAsBool(underlineKey, false)
|
||||
}
|
||||
|
||||
// GetStrikethrough returns the style's strikethrough value. If no value is set false
|
||||
// is returned.
|
||||
func (s Style) GetStrikethrough() bool {
|
||||
return s.getAsBool(strikethroughKey, false)
|
||||
}
|
||||
|
||||
// GetReverse returns the style's reverse value. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetReverse() bool {
|
||||
return s.getAsBool(reverseKey, false)
|
||||
}
|
||||
|
||||
// GetBlink returns the style's blink value. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetBlink() bool {
|
||||
return s.getAsBool(blinkKey, false)
|
||||
}
|
||||
|
||||
// GetFaint returns the style's faint value. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetFaint() bool {
|
||||
return s.getAsBool(faintKey, false)
|
||||
}
|
||||
|
||||
// GetForeground returns the style's foreground color. If no value is set
|
||||
// NoColor{} is returned.
|
||||
func (s Style) GetForeground() TerminalColor {
|
||||
return s.getAsColor(foregroundKey)
|
||||
}
|
||||
|
||||
// GetBackground returns the style's background color. If no value is set
|
||||
// NoColor{} is returned.
|
||||
func (s Style) GetBackground() TerminalColor {
|
||||
return s.getAsColor(backgroundKey)
|
||||
}
|
||||
|
||||
// GetWidth returns the style's width setting. If no width is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetWidth() int {
|
||||
return s.getAsInt(widthKey)
|
||||
}
|
||||
|
||||
// GetHeight returns the style's height setting. If no height is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetHeight() int {
|
||||
return s.getAsInt(heightKey)
|
||||
}
|
||||
|
||||
// GetAlign returns the style's implicit horizontal alignment setting.
|
||||
// If no alignment is set Position.Left is returned.
|
||||
func (s Style) GetAlign() Position {
|
||||
v := s.getAsPosition(alignHorizontalKey)
|
||||
if v == Position(0) {
|
||||
return Left
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// GetAlignHorizontal returns the style's implicit horizontal alignment setting.
|
||||
// If no alignment is set Position.Left is returned.
|
||||
func (s Style) GetAlignHorizontal() Position {
|
||||
v := s.getAsPosition(alignHorizontalKey)
|
||||
if v == Position(0) {
|
||||
return Left
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// GetAlignVertical returns the style's implicit vertical alignment setting.
|
||||
// If no alignment is set Position.Top is returned.
|
||||
func (s Style) GetAlignVertical() Position {
|
||||
v := s.getAsPosition(alignVerticalKey)
|
||||
if v == Position(0) {
|
||||
return Top
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// GetPadding returns the style's top, right, bottom, and left padding values,
|
||||
// in that order. 0 is returned for unset values.
|
||||
func (s Style) GetPadding() (top, right, bottom, left int) {
|
||||
return s.getAsInt(paddingTopKey),
|
||||
s.getAsInt(paddingRightKey),
|
||||
s.getAsInt(paddingBottomKey),
|
||||
s.getAsInt(paddingLeftKey)
|
||||
}
|
||||
|
||||
// GetPaddingTop returns the style's top padding. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetPaddingTop() int {
|
||||
return s.getAsInt(paddingTopKey)
|
||||
}
|
||||
|
||||
// GetPaddingRight returns the style's right padding. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetPaddingRight() int {
|
||||
return s.getAsInt(paddingRightKey)
|
||||
}
|
||||
|
||||
// GetPaddingBottom returns the style's bottom padding. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetPaddingBottom() int {
|
||||
return s.getAsInt(paddingBottomKey)
|
||||
}
|
||||
|
||||
// GetPaddingLeft returns the style's left padding. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetPaddingLeft() int {
|
||||
return s.getAsInt(paddingLeftKey)
|
||||
}
|
||||
|
||||
// GetHorizontalPadding returns the style's left and right padding. Unset
|
||||
// values are measured as 0.
|
||||
func (s Style) GetHorizontalPadding() int {
|
||||
return s.getAsInt(paddingLeftKey) + s.getAsInt(paddingRightKey)
|
||||
}
|
||||
|
||||
// GetVerticalPadding returns the style's top and bottom padding. Unset values
|
||||
// are measured as 0.
|
||||
func (s Style) GetVerticalPadding() int {
|
||||
return s.getAsInt(paddingTopKey) + s.getAsInt(paddingBottomKey)
|
||||
}
|
||||
|
||||
// GetColorWhitespace returns the style's whitespace coloring setting. If no
|
||||
// value is set false is returned.
|
||||
func (s Style) GetColorWhitespace() bool {
|
||||
return s.getAsBool(colorWhitespaceKey, false)
|
||||
}
|
||||
|
||||
// GetMargin returns the style's top, right, bottom, and left margins, in that
|
||||
// order. 0 is returned for unset values.
|
||||
func (s Style) GetMargin() (top, right, bottom, left int) {
|
||||
return s.getAsInt(marginTopKey),
|
||||
s.getAsInt(marginRightKey),
|
||||
s.getAsInt(marginBottomKey),
|
||||
s.getAsInt(marginLeftKey)
|
||||
}
|
||||
|
||||
// GetMarginTop returns the style's top margin. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMarginTop() int {
|
||||
return s.getAsInt(marginTopKey)
|
||||
}
|
||||
|
||||
// GetMarginRight returns the style's right margin. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMarginRight() int {
|
||||
return s.getAsInt(marginRightKey)
|
||||
}
|
||||
|
||||
// GetMarginBottom returns the style's bottom margin. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMarginBottom() int {
|
||||
return s.getAsInt(marginBottomKey)
|
||||
}
|
||||
|
||||
// GetMarginLeft returns the style's left margin. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMarginLeft() int {
|
||||
return s.getAsInt(marginLeftKey)
|
||||
}
|
||||
|
||||
// GetHorizontalMargins returns the style's left and right margins. Unset
|
||||
// values are measured as 0.
|
||||
func (s Style) GetHorizontalMargins() int {
|
||||
return s.getAsInt(marginLeftKey) + s.getAsInt(marginRightKey)
|
||||
}
|
||||
|
||||
// GetVerticalMargins returns the style's top and bottom margins. Unset values
|
||||
// are measured as 0.
|
||||
func (s Style) GetVerticalMargins() int {
|
||||
return s.getAsInt(marginTopKey) + s.getAsInt(marginBottomKey)
|
||||
}
|
||||
|
||||
// GetBorder returns the style's border style (type Border) and value for the
|
||||
// top, right, bottom, and left in that order. If no value is set for the
|
||||
// border style, Border{} is returned. For all other unset values false is
|
||||
// returned.
|
||||
func (s Style) GetBorder() (b Border, top, right, bottom, left bool) {
|
||||
return s.getBorderStyle(),
|
||||
s.getAsBool(borderTopKey, false),
|
||||
s.getAsBool(borderRightKey, false),
|
||||
s.getAsBool(borderBottomKey, false),
|
||||
s.getAsBool(borderLeftKey, false)
|
||||
}
|
||||
|
||||
// GetBorderStyle returns the style's border style (type Border). If no value
|
||||
// is set Border{} is returned.
|
||||
func (s Style) GetBorderStyle() Border {
|
||||
return s.getBorderStyle()
|
||||
}
|
||||
|
||||
// GetBorderTop returns the style's top border setting. If no value is set
|
||||
// false is returned.
|
||||
func (s Style) GetBorderTop() bool {
|
||||
return s.getAsBool(borderTopKey, false)
|
||||
}
|
||||
|
||||
// GetBorderRight returns the style's right border setting. If no value is set
|
||||
// false is returned.
|
||||
func (s Style) GetBorderRight() bool {
|
||||
return s.getAsBool(borderRightKey, false)
|
||||
}
|
||||
|
||||
// GetBorderBottom returns the style's bottom border setting. If no value is
|
||||
// set false is returned.
|
||||
func (s Style) GetBorderBottom() bool {
|
||||
return s.getAsBool(borderBottomKey, false)
|
||||
}
|
||||
|
||||
// GetBorderLeft returns the style's left border setting. If no value is
|
||||
// set false is returned.
|
||||
func (s Style) GetBorderLeft() bool {
|
||||
return s.getAsBool(borderLeftKey, false)
|
||||
}
|
||||
|
||||
// GetBorderTopForeground returns the style's border top foreground color. If
|
||||
// no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderTopForeground() TerminalColor {
|
||||
return s.getAsColor(borderTopForegroundKey)
|
||||
}
|
||||
|
||||
// GetBorderRightForeground returns the style's border right foreground color.
|
||||
// If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderRightForeground() TerminalColor {
|
||||
return s.getAsColor(borderRightForegroundKey)
|
||||
}
|
||||
|
||||
// GetBorderBottomForeground returns the style's border bottom foreground
|
||||
// color. If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderBottomForeground() TerminalColor {
|
||||
return s.getAsColor(borderBottomForegroundKey)
|
||||
}
|
||||
|
||||
// GetBorderLeftForeground returns the style's border left foreground
|
||||
// color. If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderLeftForeground() TerminalColor {
|
||||
return s.getAsColor(borderLeftForegroundKey)
|
||||
}
|
||||
|
||||
// GetBorderTopBackground returns the style's border top background color. If
|
||||
// no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderTopBackground() TerminalColor {
|
||||
return s.getAsColor(borderTopBackgroundKey)
|
||||
}
|
||||
|
||||
// GetBorderRightBackground returns the style's border right background color.
|
||||
// If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderRightBackground() TerminalColor {
|
||||
return s.getAsColor(borderRightBackgroundKey)
|
||||
}
|
||||
|
||||
// GetBorderBottomBackground returns the style's border bottom background
|
||||
// color. If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderBottomBackground() TerminalColor {
|
||||
return s.getAsColor(borderBottomBackgroundKey)
|
||||
}
|
||||
|
||||
// GetBorderLeftBackground returns the style's border left background
|
||||
// color. If no value is set NoColor{} is returned.
|
||||
func (s Style) GetBorderLeftBackground() TerminalColor {
|
||||
return s.getAsColor(borderLeftBackgroundKey)
|
||||
}
|
||||
|
||||
// GetBorderTopWidth returns the width of the top border. If borders contain
|
||||
// runes of varying widths, the widest rune is returned. If no border exists on
|
||||
// the top edge, 0 is returned.
|
||||
//
|
||||
// Deprecated: This function simply calls Style.GetBorderTopSize.
|
||||
func (s Style) GetBorderTopWidth() int {
|
||||
return s.GetBorderTopSize()
|
||||
}
|
||||
|
||||
// GetBorderTopSize returns the width of the top border. If borders contain
|
||||
// runes of varying widths, the widest rune is returned. If no border exists on
|
||||
// the top edge, 0 is returned.
|
||||
func (s Style) GetBorderTopSize() int {
|
||||
if !s.getAsBool(borderTopKey, false) {
|
||||
return 0
|
||||
}
|
||||
return s.getBorderStyle().GetTopSize()
|
||||
}
|
||||
|
||||
// GetBorderLeftSize returns the width of the left border. If borders contain
|
||||
// runes of varying widths, the widest rune is returned. If no border exists on
|
||||
// the left edge, 0 is returned.
|
||||
func (s Style) GetBorderLeftSize() int {
|
||||
if !s.getAsBool(borderLeftKey, false) {
|
||||
return 0
|
||||
}
|
||||
return s.getBorderStyle().GetLeftSize()
|
||||
}
|
||||
|
||||
// GetBorderBottomSize returns the width of the bottom border. If borders
|
||||
// contain runes of varying widths, the widest rune is returned. If no border
|
||||
// exists on the left edge, 0 is returned.
|
||||
func (s Style) GetBorderBottomSize() int {
|
||||
if !s.getAsBool(borderBottomKey, false) {
|
||||
return 0
|
||||
}
|
||||
return s.getBorderStyle().GetBottomSize()
|
||||
}
|
||||
|
||||
// GetBorderRightSize returns the width of the right border. If borders
|
||||
// contain runes of varying widths, the widest rune is returned. If no border
|
||||
// exists on the right edge, 0 is returned.
|
||||
func (s Style) GetBorderRightSize() int {
|
||||
if !s.getAsBool(borderRightKey, false) {
|
||||
return 0
|
||||
}
|
||||
return s.getBorderStyle().GetRightSize()
|
||||
}
|
||||
|
||||
// GetHorizontalBorderSize returns the width of the horizontal borders. If
|
||||
// borders contain runes of varying widths, the widest rune is returned. If no
|
||||
// border exists on the horizontal edges, 0 is returned.
|
||||
func (s Style) GetHorizontalBorderSize() int {
|
||||
return s.GetBorderLeftSize() + s.GetBorderRightSize()
|
||||
}
|
||||
|
||||
// GetVerticalBorderSize returns the width of the vertical borders. If
|
||||
// borders contain runes of varying widths, the widest rune is returned. If no
|
||||
// border exists on the vertical edges, 0 is returned.
|
||||
func (s Style) GetVerticalBorderSize() int {
|
||||
return s.GetBorderTopSize() + s.GetBorderBottomSize()
|
||||
}
|
||||
|
||||
// GetInline returns the style's inline setting. If no value is set false is
|
||||
// returned.
|
||||
func (s Style) GetInline() bool {
|
||||
return s.getAsBool(inlineKey, false)
|
||||
}
|
||||
|
||||
// GetMaxWidth returns the style's max width setting. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMaxWidth() int {
|
||||
return s.getAsInt(maxWidthKey)
|
||||
}
|
||||
|
||||
// GetMaxHeight returns the style's max height setting. If no value is set 0 is
|
||||
// returned.
|
||||
func (s Style) GetMaxHeight() int {
|
||||
return s.getAsInt(maxHeightKey)
|
||||
}
|
||||
|
||||
// GetTabWidth returns the style's tab width setting. If no value is set 4 is
|
||||
// returned which is the implicit default.
|
||||
func (s Style) GetTabWidth() int {
|
||||
return s.getAsInt(tabWidthKey)
|
||||
}
|
||||
|
||||
// GetUnderlineSpaces returns whether or not the style is set to underline
|
||||
// spaces. If not value is set false is returned.
|
||||
func (s Style) GetUnderlineSpaces() bool {
|
||||
return s.getAsBool(underlineSpacesKey, false)
|
||||
}
|
||||
|
||||
// GetStrikethroughSpaces returns whether or not the style is set to strikethrough
|
||||
// spaces. If not value is set false is returned.
|
||||
func (s Style) GetStrikethroughSpaces() bool {
|
||||
return s.getAsBool(strikethroughSpacesKey, false)
|
||||
}
|
||||
|
||||
// GetHorizontalFrameSize returns the sum of the style's horizontal margins, padding
|
||||
// and border widths.
|
||||
//
|
||||
// Provisional: this method may be renamed.
|
||||
func (s Style) GetHorizontalFrameSize() int {
|
||||
return s.GetHorizontalMargins() + s.GetHorizontalPadding() + s.GetHorizontalBorderSize()
|
||||
}
|
||||
|
||||
// GetVerticalFrameSize returns the sum of the style's vertical margins, padding
|
||||
// and border widths.
|
||||
//
|
||||
// Provisional: this method may be renamed.
|
||||
func (s Style) GetVerticalFrameSize() int {
|
||||
return s.GetVerticalMargins() + s.GetVerticalPadding() + s.GetVerticalBorderSize()
|
||||
}
|
||||
|
||||
// GetFrameSize returns the sum of the margins, padding and border width for
|
||||
// both the horizontal and vertical margins.
|
||||
func (s Style) GetFrameSize() (x, y int) {
|
||||
return s.GetHorizontalFrameSize(), s.GetVerticalFrameSize()
|
||||
}
|
||||
|
||||
// Returns whether or not the given property is set.
|
||||
func (s Style) isSet(k propKey) bool {
|
||||
_, exists := s.rules[k]
|
||||
return exists
|
||||
}
|
||||
|
||||
func (s Style) getAsBool(k propKey, defaultVal bool) bool {
|
||||
v, ok := s.rules[k]
|
||||
if !ok {
|
||||
return defaultVal
|
||||
}
|
||||
if b, ok := v.(bool); ok {
|
||||
return b
|
||||
}
|
||||
return defaultVal
|
||||
}
|
||||
|
||||
func (s Style) getAsColor(k propKey) TerminalColor {
|
||||
v, ok := s.rules[k]
|
||||
if !ok {
|
||||
return noColor
|
||||
}
|
||||
if c, ok := v.(TerminalColor); ok {
|
||||
return c
|
||||
}
|
||||
return noColor
|
||||
}
|
||||
|
||||
func (s Style) getAsInt(k propKey) int {
|
||||
v, ok := s.rules[k]
|
||||
if !ok {
|
||||
return 0
|
||||
}
|
||||
if i, ok := v.(int); ok {
|
||||
return i
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (s Style) getAsPosition(k propKey) Position {
|
||||
v, ok := s.rules[k]
|
||||
if !ok {
|
||||
return Position(0)
|
||||
}
|
||||
if p, ok := v.(Position); ok {
|
||||
return p
|
||||
}
|
||||
return Position(0)
|
||||
}
|
||||
|
||||
func (s Style) getBorderStyle() Border {
|
||||
v, ok := s.rules[borderStyleKey]
|
||||
if !ok {
|
||||
return noBorder
|
||||
}
|
||||
if b, ok := v.(Border); ok {
|
||||
return b
|
||||
}
|
||||
return noBorder
|
||||
}
|
||||
|
||||
// Split a string into lines, additionally returning the size of the widest
|
||||
// line.
|
||||
func getLines(s string) (lines []string, widest int) {
|
||||
lines = strings.Split(s, "\n")
|
||||
|
||||
for _, l := range lines {
|
||||
w := ansi.PrintableRuneWidth(l)
|
||||
if widest < w {
|
||||
widest = w
|
||||
}
|
||||
}
|
||||
|
||||
return lines, widest
|
||||
}
|
||||
|
|
@ -0,0 +1,175 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
)
|
||||
|
||||
// JoinHorizontal is a utility function for horizontally joining two
|
||||
// potentially multi-lined strings along a vertical axis. The first argument is
|
||||
// the position, with 0 being all the way at the top and 1 being all the way
|
||||
// at the bottom.
|
||||
//
|
||||
// If you just want to align to the left, right or center you may as well just
|
||||
// use the helper constants Top, Center, and Bottom.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// blockB := "...\n...\n..."
|
||||
// blockA := "...\n...\n...\n...\n..."
|
||||
//
|
||||
// // Join 20% from the top
|
||||
// str := lipgloss.JoinHorizontal(0.2, blockA, blockB)
|
||||
//
|
||||
// // Join on the top edge
|
||||
// str := lipgloss.JoinHorizontal(lipgloss.Top, blockA, blockB)
|
||||
func JoinHorizontal(pos Position, strs ...string) string {
|
||||
if len(strs) == 0 {
|
||||
return ""
|
||||
}
|
||||
if len(strs) == 1 {
|
||||
return strs[0]
|
||||
}
|
||||
|
||||
var (
|
||||
// Groups of strings broken into multiple lines
|
||||
blocks = make([][]string, len(strs))
|
||||
|
||||
// Max line widths for the above text blocks
|
||||
maxWidths = make([]int, len(strs))
|
||||
|
||||
// Height of the tallest block
|
||||
maxHeight int
|
||||
)
|
||||
|
||||
// Break text blocks into lines and get max widths for each text block
|
||||
for i, str := range strs {
|
||||
blocks[i], maxWidths[i] = getLines(str)
|
||||
if len(blocks[i]) > maxHeight {
|
||||
maxHeight = len(blocks[i])
|
||||
}
|
||||
}
|
||||
|
||||
// Add extra lines to make each side the same height
|
||||
for i := range blocks {
|
||||
if len(blocks[i]) >= maxHeight {
|
||||
continue
|
||||
}
|
||||
|
||||
extraLines := make([]string, maxHeight-len(blocks[i]))
|
||||
|
||||
switch pos { //nolint:exhaustive
|
||||
case Top:
|
||||
blocks[i] = append(blocks[i], extraLines...)
|
||||
|
||||
case Bottom:
|
||||
blocks[i] = append(extraLines, blocks[i]...)
|
||||
|
||||
default: // Somewhere in the middle
|
||||
n := len(extraLines)
|
||||
split := int(math.Round(float64(n) * pos.value()))
|
||||
top := n - split
|
||||
bottom := n - top
|
||||
|
||||
blocks[i] = append(extraLines[top:], blocks[i]...)
|
||||
blocks[i] = append(blocks[i], extraLines[bottom:]...)
|
||||
}
|
||||
}
|
||||
|
||||
// Merge lines
|
||||
var b strings.Builder
|
||||
for i := range blocks[0] { // remember, all blocks have the same number of members now
|
||||
for j, block := range blocks {
|
||||
b.WriteString(block[i])
|
||||
|
||||
// Also make lines the same length
|
||||
b.WriteString(strings.Repeat(" ", maxWidths[j]-ansi.PrintableRuneWidth(block[i])))
|
||||
}
|
||||
if i < len(blocks[0])-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// JoinVertical is a utility function for vertically joining two potentially
|
||||
// multi-lined strings along a horizontal axis. The first argument is the
|
||||
// position, with 0 being all the way to the left and 1 being all the way to
|
||||
// the right.
|
||||
//
|
||||
// If you just want to align to the left, right or center you may as well just
|
||||
// use the helper constants Left, Center, and Right.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// blockB := "...\n...\n..."
|
||||
// blockA := "...\n...\n...\n...\n..."
|
||||
//
|
||||
// // Join 20% from the top
|
||||
// str := lipgloss.JoinVertical(0.2, blockA, blockB)
|
||||
//
|
||||
// // Join on the right edge
|
||||
// str := lipgloss.JoinVertical(lipgloss.Right, blockA, blockB)
|
||||
func JoinVertical(pos Position, strs ...string) string {
|
||||
if len(strs) == 0 {
|
||||
return ""
|
||||
}
|
||||
if len(strs) == 1 {
|
||||
return strs[0]
|
||||
}
|
||||
|
||||
var (
|
||||
blocks = make([][]string, len(strs))
|
||||
maxWidth int
|
||||
)
|
||||
|
||||
for i := range strs {
|
||||
var w int
|
||||
blocks[i], w = getLines(strs[i])
|
||||
if w > maxWidth {
|
||||
maxWidth = w
|
||||
}
|
||||
}
|
||||
|
||||
var b strings.Builder
|
||||
for i, block := range blocks {
|
||||
for j, line := range block {
|
||||
w := maxWidth - ansi.PrintableRuneWidth(line)
|
||||
|
||||
switch pos { //nolint:exhaustive
|
||||
case Left:
|
||||
b.WriteString(line)
|
||||
b.WriteString(strings.Repeat(" ", w))
|
||||
|
||||
case Right:
|
||||
b.WriteString(strings.Repeat(" ", w))
|
||||
b.WriteString(line)
|
||||
|
||||
default: // Somewhere in the middle
|
||||
if w < 1 {
|
||||
b.WriteString(line)
|
||||
break
|
||||
}
|
||||
|
||||
split := int(math.Round(float64(w) * pos.value()))
|
||||
right := w - split
|
||||
left := w - right
|
||||
|
||||
b.WriteString(strings.Repeat(" ", left))
|
||||
b.WriteString(line)
|
||||
b.WriteString(strings.Repeat(" ", right))
|
||||
}
|
||||
|
||||
// Write a newline as long as we're not on the last line of the
|
||||
// last block.
|
||||
if !(i == len(blocks)-1 && j == len(block)-1) {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
)
|
||||
|
||||
// Position represents a position along a horizontal or vertical axis. It's in
|
||||
// situations where an axis is involved, like alignment, joining, placement and
|
||||
// so on.
|
||||
//
|
||||
// A value of 0 represents the start (the left or top) and 1 represents the end
|
||||
// (the right or bottom). 0.5 represents the center.
|
||||
//
|
||||
// There are constants Top, Bottom, Center, Left and Right in this package that
|
||||
// can be used to aid readability.
|
||||
type Position float64
|
||||
|
||||
func (p Position) value() float64 {
|
||||
return math.Min(1, math.Max(0, float64(p)))
|
||||
}
|
||||
|
||||
// Position aliases.
|
||||
const (
|
||||
Top Position = 0.0
|
||||
Bottom Position = 1.0
|
||||
Center Position = 0.5
|
||||
Left Position = 0.0
|
||||
Right Position = 1.0
|
||||
)
|
||||
|
||||
// Place places a string or text block vertically in an unstyled box of a given
|
||||
// width or height.
|
||||
func Place(width, height int, hPos, vPos Position, str string, opts ...WhitespaceOption) string {
|
||||
return renderer.Place(width, height, hPos, vPos, str, opts...)
|
||||
}
|
||||
|
||||
// Place places a string or text block vertically in an unstyled box of a given
|
||||
// width or height.
|
||||
func (r *Renderer) Place(width, height int, hPos, vPos Position, str string, opts ...WhitespaceOption) string {
|
||||
return r.PlaceVertical(height, vPos, r.PlaceHorizontal(width, hPos, str, opts...), opts...)
|
||||
}
|
||||
|
||||
// PlaceHorizontal places a string or text block horizontally in an unstyled
|
||||
// block of a given width. If the given width is shorter than the max width of
|
||||
// the string (measured by its longest line) this will be a noop.
|
||||
func PlaceHorizontal(width int, pos Position, str string, opts ...WhitespaceOption) string {
|
||||
return renderer.PlaceHorizontal(width, pos, str, opts...)
|
||||
}
|
||||
|
||||
// PlaceHorizontal places a string or text block horizontally in an unstyled
|
||||
// block of a given width. If the given width is shorter than the max width of
|
||||
// the string (measured by its longest line) this will be a noöp.
|
||||
func (r *Renderer) PlaceHorizontal(width int, pos Position, str string, opts ...WhitespaceOption) string {
|
||||
lines, contentWidth := getLines(str)
|
||||
gap := width - contentWidth
|
||||
|
||||
if gap <= 0 {
|
||||
return str
|
||||
}
|
||||
|
||||
ws := newWhitespace(r, opts...)
|
||||
|
||||
var b strings.Builder
|
||||
for i, l := range lines {
|
||||
// Is this line shorter than the longest line?
|
||||
short := max(0, contentWidth-ansi.PrintableRuneWidth(l))
|
||||
|
||||
switch pos { //nolint:exhaustive
|
||||
case Left:
|
||||
b.WriteString(l)
|
||||
b.WriteString(ws.render(gap + short))
|
||||
|
||||
case Right:
|
||||
b.WriteString(ws.render(gap + short))
|
||||
b.WriteString(l)
|
||||
|
||||
default: // somewhere in the middle
|
||||
totalGap := gap + short
|
||||
|
||||
split := int(math.Round(float64(totalGap) * pos.value()))
|
||||
left := totalGap - split
|
||||
right := totalGap - left
|
||||
|
||||
b.WriteString(ws.render(left))
|
||||
b.WriteString(l)
|
||||
b.WriteString(ws.render(right))
|
||||
}
|
||||
|
||||
if i < len(lines)-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// PlaceVertical places a string or text block vertically in an unstyled block
|
||||
// of a given height. If the given height is shorter than the height of the
|
||||
// string (measured by its newlines) then this will be a noop.
|
||||
func PlaceVertical(height int, pos Position, str string, opts ...WhitespaceOption) string {
|
||||
return renderer.PlaceVertical(height, pos, str, opts...)
|
||||
}
|
||||
|
||||
// PlaceVertical places a string or text block vertically in an unstyled block
|
||||
// of a given height. If the given height is shorter than the height of the
|
||||
// string (measured by its newlines) then this will be a noöp.
|
||||
func (r *Renderer) PlaceVertical(height int, pos Position, str string, opts ...WhitespaceOption) string {
|
||||
contentHeight := strings.Count(str, "\n") + 1
|
||||
gap := height - contentHeight
|
||||
|
||||
if gap <= 0 {
|
||||
return str
|
||||
}
|
||||
|
||||
ws := newWhitespace(r, opts...)
|
||||
|
||||
_, width := getLines(str)
|
||||
emptyLine := ws.render(width)
|
||||
b := strings.Builder{}
|
||||
|
||||
switch pos { //nolint:exhaustive
|
||||
case Top:
|
||||
b.WriteString(str)
|
||||
b.WriteRune('\n')
|
||||
for i := 0; i < gap; i++ {
|
||||
b.WriteString(emptyLine)
|
||||
if i < gap-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
case Bottom:
|
||||
b.WriteString(strings.Repeat(emptyLine+"\n", gap))
|
||||
b.WriteString(str)
|
||||
|
||||
default: // Somewhere in the middle
|
||||
split := int(math.Round(float64(gap) * pos.value()))
|
||||
top := gap - split
|
||||
bottom := gap - top
|
||||
|
||||
b.WriteString(strings.Repeat(emptyLine+"\n", top))
|
||||
b.WriteString(str)
|
||||
|
||||
for i := 0; i < bottom; i++ {
|
||||
b.WriteRune('\n')
|
||||
b.WriteString(emptyLine)
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"io"
|
||||
"sync"
|
||||
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
// We're manually creating the struct here to avoid initializing the output and
|
||||
// query the terminal multiple times.
|
||||
var renderer = &Renderer{
|
||||
output: termenv.DefaultOutput(),
|
||||
}
|
||||
|
||||
// Renderer is a lipgloss terminal renderer.
|
||||
type Renderer struct {
|
||||
output *termenv.Output
|
||||
colorProfile termenv.Profile
|
||||
hasDarkBackground bool
|
||||
|
||||
getColorProfile sync.Once
|
||||
explicitColorProfile bool
|
||||
|
||||
getBackgroundColor sync.Once
|
||||
explicitBackgroundColor bool
|
||||
|
||||
mtx sync.RWMutex
|
||||
}
|
||||
|
||||
// RendererOption is a function that can be used to configure a [Renderer].
|
||||
type RendererOption func(r *Renderer)
|
||||
|
||||
// DefaultRenderer returns the default renderer.
|
||||
func DefaultRenderer() *Renderer {
|
||||
return renderer
|
||||
}
|
||||
|
||||
// SetDefaultRenderer sets the default global renderer.
|
||||
func SetDefaultRenderer(r *Renderer) {
|
||||
renderer = r
|
||||
}
|
||||
|
||||
// NewRenderer creates a new Renderer.
|
||||
//
|
||||
// w will be used to determine the terminal's color capabilities.
|
||||
func NewRenderer(w io.Writer, opts ...termenv.OutputOption) *Renderer {
|
||||
r := &Renderer{
|
||||
output: termenv.NewOutput(w, opts...),
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// Output returns the termenv output.
|
||||
func (r *Renderer) Output() *termenv.Output {
|
||||
r.mtx.RLock()
|
||||
defer r.mtx.RUnlock()
|
||||
return r.output
|
||||
}
|
||||
|
||||
// SetOutput sets the termenv output.
|
||||
func (r *Renderer) SetOutput(o *termenv.Output) {
|
||||
r.mtx.Lock()
|
||||
defer r.mtx.Unlock()
|
||||
r.output = o
|
||||
}
|
||||
|
||||
// ColorProfile returns the detected termenv color profile.
|
||||
func (r *Renderer) ColorProfile() termenv.Profile {
|
||||
r.mtx.RLock()
|
||||
defer r.mtx.RUnlock()
|
||||
|
||||
if !r.explicitColorProfile {
|
||||
r.getColorProfile.Do(func() {
|
||||
// NOTE: we don't need to lock here because sync.Once provides its
|
||||
// own locking mechanism.
|
||||
r.colorProfile = r.output.EnvColorProfile()
|
||||
})
|
||||
}
|
||||
|
||||
return r.colorProfile
|
||||
}
|
||||
|
||||
// ColorProfile returns the detected termenv color profile.
|
||||
func ColorProfile() termenv.Profile {
|
||||
return renderer.ColorProfile()
|
||||
}
|
||||
|
||||
// SetColorProfile sets the color profile on the renderer. This function exists
|
||||
// mostly for testing purposes so that you can assure you're testing against
|
||||
// a specific profile.
|
||||
//
|
||||
// Outside of testing you likely won't want to use this function as the color
|
||||
// profile will detect and cache the terminal's color capabilities and choose
|
||||
// the best available profile.
|
||||
//
|
||||
// Available color profiles are:
|
||||
//
|
||||
// termenv.Ascii // no color, 1-bit
|
||||
// termenv.ANSI //16 colors, 4-bit
|
||||
// termenv.ANSI256 // 256 colors, 8-bit
|
||||
// termenv.TrueColor // 16,777,216 colors, 24-bit
|
||||
//
|
||||
// This function is thread-safe.
|
||||
func (r *Renderer) SetColorProfile(p termenv.Profile) {
|
||||
r.mtx.Lock()
|
||||
defer r.mtx.Unlock()
|
||||
|
||||
r.colorProfile = p
|
||||
r.explicitColorProfile = true
|
||||
}
|
||||
|
||||
// SetColorProfile sets the color profile on the default renderer. This
|
||||
// function exists mostly for testing purposes so that you can assure you're
|
||||
// testing against a specific profile.
|
||||
//
|
||||
// Outside of testing you likely won't want to use this function as the color
|
||||
// profile will detect and cache the terminal's color capabilities and choose
|
||||
// the best available profile.
|
||||
//
|
||||
// Available color profiles are:
|
||||
//
|
||||
// termenv.Ascii // no color, 1-bit
|
||||
// termenv.ANSI //16 colors, 4-bit
|
||||
// termenv.ANSI256 // 256 colors, 8-bit
|
||||
// termenv.TrueColor // 16,777,216 colors, 24-bit
|
||||
//
|
||||
// This function is thread-safe.
|
||||
func SetColorProfile(p termenv.Profile) {
|
||||
renderer.SetColorProfile(p)
|
||||
}
|
||||
|
||||
// HasDarkBackground returns whether or not the terminal has a dark background.
|
||||
func HasDarkBackground() bool {
|
||||
return renderer.HasDarkBackground()
|
||||
}
|
||||
|
||||
// HasDarkBackground returns whether or not the renderer will render to a dark
|
||||
// background. A dark background can either be auto-detected, or set explicitly
|
||||
// on the renderer.
|
||||
func (r *Renderer) HasDarkBackground() bool {
|
||||
r.mtx.RLock()
|
||||
defer r.mtx.RUnlock()
|
||||
|
||||
if !r.explicitBackgroundColor {
|
||||
r.getBackgroundColor.Do(func() {
|
||||
// NOTE: we don't need to lock here because sync.Once provides its
|
||||
// own locking mechanism.
|
||||
r.hasDarkBackground = r.output.HasDarkBackground()
|
||||
})
|
||||
}
|
||||
|
||||
return r.hasDarkBackground
|
||||
}
|
||||
|
||||
// SetHasDarkBackground sets the background color detection value for the
|
||||
// default renderer. This function exists mostly for testing purposes so that
|
||||
// you can assure you're testing against a specific background color setting.
|
||||
//
|
||||
// Outside of testing you likely won't want to use this function as the
|
||||
// backgrounds value will be automatically detected and cached against the
|
||||
// terminal's current background color setting.
|
||||
//
|
||||
// This function is thread-safe.
|
||||
func SetHasDarkBackground(b bool) {
|
||||
renderer.SetHasDarkBackground(b)
|
||||
}
|
||||
|
||||
// SetHasDarkBackground sets the background color detection value on the
|
||||
// renderer. This function exists mostly for testing purposes so that you can
|
||||
// assure you're testing against a specific background color setting.
|
||||
//
|
||||
// Outside of testing you likely won't want to use this function as the
|
||||
// backgrounds value will be automatically detected and cached against the
|
||||
// terminal's current background color setting.
|
||||
//
|
||||
// This function is thread-safe.
|
||||
func (r *Renderer) SetHasDarkBackground(b bool) {
|
||||
r.mtx.Lock()
|
||||
defer r.mtx.Unlock()
|
||||
|
||||
r.hasDarkBackground = b
|
||||
r.explicitBackgroundColor = true
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// StyleRunes apply a given style to runes at the given indices in the string.
|
||||
// Note that you must provide styling options for both matched and unmatched
|
||||
// runes. Indices out of bounds will be ignored.
|
||||
func StyleRunes(str string, indices []int, matched, unmatched Style) string {
|
||||
// Convert slice of indices to a map for easier lookups
|
||||
m := make(map[int]struct{})
|
||||
for _, i := range indices {
|
||||
m[i] = struct{}{}
|
||||
}
|
||||
|
||||
var (
|
||||
out strings.Builder
|
||||
group strings.Builder
|
||||
style Style
|
||||
runes = []rune(str)
|
||||
)
|
||||
|
||||
for i, r := range runes {
|
||||
group.WriteRune(r)
|
||||
|
||||
_, matches := m[i]
|
||||
_, nextMatches := m[i+1]
|
||||
|
||||
if matches != nextMatches || i == len(runes)-1 {
|
||||
// Flush
|
||||
if matches {
|
||||
style = matched
|
||||
} else {
|
||||
style = unmatched
|
||||
}
|
||||
out.WriteString(style.Render(group.String()))
|
||||
group.Reset()
|
||||
}
|
||||
}
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
|
@ -0,0 +1,658 @@
|
|||
package lipgloss
|
||||
|
||||
// This could (should) probably just be moved into NewStyle(). We've broken it
|
||||
// out, so we can call it in a lazy way.
|
||||
func (s *Style) init() {
|
||||
if s.rules == nil {
|
||||
s.rules = make(rules)
|
||||
}
|
||||
}
|
||||
|
||||
// Set a value on the underlying rules map.
|
||||
func (s *Style) set(key propKey, value interface{}) {
|
||||
s.init()
|
||||
|
||||
switch v := value.(type) {
|
||||
case int:
|
||||
// TabWidth is the only property that may have a negative value (and
|
||||
// that negative value can be no less than -1).
|
||||
if key == tabWidthKey {
|
||||
s.rules[key] = v
|
||||
break
|
||||
}
|
||||
|
||||
// We don't allow negative integers on any of our other values, so just keep
|
||||
// them at zero or above. We could use uints instead, but the
|
||||
// conversions are a little tedious, so we're sticking with ints for
|
||||
// sake of usability.
|
||||
s.rules[key] = max(0, v)
|
||||
default:
|
||||
s.rules[key] = v
|
||||
}
|
||||
}
|
||||
|
||||
// Bold sets a bold formatting rule.
|
||||
func (s Style) Bold(v bool) Style {
|
||||
s.set(boldKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Italic sets an italic formatting rule. In some terminal emulators this will
|
||||
// render with "reverse" coloring if not italic font variant is available.
|
||||
func (s Style) Italic(v bool) Style {
|
||||
s.set(italicKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Underline sets an underline rule. By default, underlines will not be drawn on
|
||||
// whitespace like margins and padding. To change this behavior set
|
||||
// UnderlineSpaces.
|
||||
func (s Style) Underline(v bool) Style {
|
||||
s.set(underlineKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Strikethrough sets a strikethrough rule. By default, strikes will not be
|
||||
// drawn on whitespace like margins and padding. To change this behavior set
|
||||
// StrikethroughSpaces.
|
||||
func (s Style) Strikethrough(v bool) Style {
|
||||
s.set(strikethroughKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Reverse sets a rule for inverting foreground and background colors.
|
||||
func (s Style) Reverse(v bool) Style {
|
||||
s.set(reverseKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Blink sets a rule for blinking foreground text.
|
||||
func (s Style) Blink(v bool) Style {
|
||||
s.set(blinkKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Faint sets a rule for rendering the foreground color in a dimmer shade.
|
||||
func (s Style) Faint(v bool) Style {
|
||||
s.set(faintKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Foreground sets a foreground color.
|
||||
//
|
||||
// // Sets the foreground to blue
|
||||
// s := lipgloss.NewStyle().Foreground(lipgloss.Color("#0000ff"))
|
||||
//
|
||||
// // Removes the foreground color
|
||||
// s.Foreground(lipgloss.NoColor)
|
||||
func (s Style) Foreground(c TerminalColor) Style {
|
||||
s.set(foregroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// Background sets a background color.
|
||||
func (s Style) Background(c TerminalColor) Style {
|
||||
s.set(backgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// Width sets the width of the block before applying margins. The width, if
|
||||
// set, also determines where text will wrap.
|
||||
func (s Style) Width(i int) Style {
|
||||
s.set(widthKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// Height sets the height of the block before applying margins. If the height of
|
||||
// the text block is less than this value after applying padding (or not), the
|
||||
// block will be set to this height.
|
||||
func (s Style) Height(i int) Style {
|
||||
s.set(heightKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// Align is a shorthand method for setting horizontal and vertical alignment.
|
||||
//
|
||||
// With one argument, the position value is applied to the horizontal alignment.
|
||||
//
|
||||
// With two arguments, the value is applied to the vertical and horizontal
|
||||
// alignments, in that order.
|
||||
func (s Style) Align(p ...Position) Style {
|
||||
if len(p) > 0 {
|
||||
s.set(alignHorizontalKey, p[0])
|
||||
}
|
||||
if len(p) > 1 {
|
||||
s.set(alignVerticalKey, p[1])
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// AlignHorizontal sets a horizontal text alignment rule.
|
||||
func (s Style) AlignHorizontal(p Position) Style {
|
||||
s.set(alignHorizontalKey, p)
|
||||
return s
|
||||
}
|
||||
|
||||
// AlignVertical sets a vertical text alignment rule.
|
||||
func (s Style) AlignVertical(p Position) Style {
|
||||
s.set(alignVerticalKey, p)
|
||||
return s
|
||||
}
|
||||
|
||||
// Padding is a shorthand method for setting padding on all sides at once.
|
||||
//
|
||||
// With one argument, the value is applied to all sides.
|
||||
//
|
||||
// With two arguments, the value is applied to the vertical and horizontal
|
||||
// sides, in that order.
|
||||
//
|
||||
// With three arguments, the value is applied to the top side, the horizontal
|
||||
// sides, and the bottom side, in that order.
|
||||
//
|
||||
// With four arguments, the value is applied clockwise starting from the top
|
||||
// side, followed by the right side, then the bottom, and finally the left.
|
||||
//
|
||||
// With more than four arguments no padding will be added.
|
||||
func (s Style) Padding(i ...int) Style {
|
||||
top, right, bottom, left, ok := whichSidesInt(i...)
|
||||
if !ok {
|
||||
return s
|
||||
}
|
||||
|
||||
s.set(paddingTopKey, top)
|
||||
s.set(paddingRightKey, right)
|
||||
s.set(paddingBottomKey, bottom)
|
||||
s.set(paddingLeftKey, left)
|
||||
return s
|
||||
}
|
||||
|
||||
// PaddingLeft adds padding on the left.
|
||||
func (s Style) PaddingLeft(i int) Style {
|
||||
s.set(paddingLeftKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// PaddingRight adds padding on the right.
|
||||
func (s Style) PaddingRight(i int) Style {
|
||||
s.set(paddingRightKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// PaddingTop adds padding to the top of the block.
|
||||
func (s Style) PaddingTop(i int) Style {
|
||||
s.set(paddingTopKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// PaddingBottom adds padding to the bottom of the block.
|
||||
func (s Style) PaddingBottom(i int) Style {
|
||||
s.set(paddingBottomKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// ColorWhitespace determines whether or not the background color should be
|
||||
// applied to the padding. This is true by default as it's more than likely the
|
||||
// desired and expected behavior, but it can be disabled for certain graphic
|
||||
// effects.
|
||||
func (s Style) ColorWhitespace(v bool) Style {
|
||||
s.set(colorWhitespaceKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Margin is a shorthand method for setting margins on all sides at once.
|
||||
//
|
||||
// With one argument, the value is applied to all sides.
|
||||
//
|
||||
// With two arguments, the value is applied to the vertical and horizontal
|
||||
// sides, in that order.
|
||||
//
|
||||
// With three arguments, the value is applied to the top side, the horizontal
|
||||
// sides, and the bottom side, in that order.
|
||||
//
|
||||
// With four arguments, the value is applied clockwise starting from the top
|
||||
// side, followed by the right side, then the bottom, and finally the left.
|
||||
//
|
||||
// With more than four arguments no margin will be added.
|
||||
func (s Style) Margin(i ...int) Style {
|
||||
top, right, bottom, left, ok := whichSidesInt(i...)
|
||||
if !ok {
|
||||
return s
|
||||
}
|
||||
|
||||
s.set(marginTopKey, top)
|
||||
s.set(marginRightKey, right)
|
||||
s.set(marginBottomKey, bottom)
|
||||
s.set(marginLeftKey, left)
|
||||
return s
|
||||
}
|
||||
|
||||
// MarginLeft sets the value of the left margin.
|
||||
func (s Style) MarginLeft(i int) Style {
|
||||
s.set(marginLeftKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// MarginRight sets the value of the right margin.
|
||||
func (s Style) MarginRight(i int) Style {
|
||||
s.set(marginRightKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// MarginTop sets the value of the top margin.
|
||||
func (s Style) MarginTop(i int) Style {
|
||||
s.set(marginTopKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// MarginBottom sets the value of the bottom margin.
|
||||
func (s Style) MarginBottom(i int) Style {
|
||||
s.set(marginBottomKey, i)
|
||||
return s
|
||||
}
|
||||
|
||||
// MarginBackground sets the background color of the margin. Note that this is
|
||||
// also set when inheriting from a style with a background color. In that case
|
||||
// the background color on that style will set the margin color on this style.
|
||||
func (s Style) MarginBackground(c TerminalColor) Style {
|
||||
s.set(marginBackgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// Border is shorthand for setting the border style and which sides should
|
||||
// have a border at once. The variadic argument sides works as follows:
|
||||
//
|
||||
// With one value, the value is applied to all sides.
|
||||
//
|
||||
// With two values, the values are applied to the vertical and horizontal
|
||||
// sides, in that order.
|
||||
//
|
||||
// With three values, the values are applied to the top side, the horizontal
|
||||
// sides, and the bottom side, in that order.
|
||||
//
|
||||
// With four values, the values are applied clockwise starting from the top
|
||||
// side, followed by the right side, then the bottom, and finally the left.
|
||||
//
|
||||
// With more than four arguments the border will be applied to all sides.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// // Applies borders to the top and bottom only
|
||||
// lipgloss.NewStyle().Border(lipgloss.NormalBorder(), true, false)
|
||||
//
|
||||
// // Applies rounded borders to the right and bottom only
|
||||
// lipgloss.NewStyle().Border(lipgloss.RoundedBorder(), false, true, true, false)
|
||||
func (s Style) Border(b Border, sides ...bool) Style {
|
||||
s.set(borderStyleKey, b)
|
||||
|
||||
top, right, bottom, left, ok := whichSidesBool(sides...)
|
||||
if !ok {
|
||||
top = true
|
||||
right = true
|
||||
bottom = true
|
||||
left = true
|
||||
}
|
||||
|
||||
s.set(borderTopKey, top)
|
||||
s.set(borderRightKey, right)
|
||||
s.set(borderBottomKey, bottom)
|
||||
s.set(borderLeftKey, left)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderStyle defines the Border on a style. A Border contains a series of
|
||||
// definitions for the sides and corners of a border.
|
||||
//
|
||||
// Note that if border visibility has not been set for any sides when setting
|
||||
// the border style, the border will be enabled for all sides during rendering.
|
||||
//
|
||||
// You can define border characters as you'd like, though several default
|
||||
// styles are included: NormalBorder(), RoundedBorder(), BlockBorder(),
|
||||
// OuterHalfBlockBorder(), InnerHalfBlockBorder(), ThickBorder(),
|
||||
// and DoubleBorder().
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// lipgloss.NewStyle().BorderStyle(lipgloss.ThickBorder())
|
||||
func (s Style) BorderStyle(b Border) Style {
|
||||
s.set(borderStyleKey, b)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderTop determines whether or not to draw a top border.
|
||||
func (s Style) BorderTop(v bool) Style {
|
||||
s.set(borderTopKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderRight determines whether or not to draw a right border.
|
||||
func (s Style) BorderRight(v bool) Style {
|
||||
s.set(borderRightKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderBottom determines whether or not to draw a bottom border.
|
||||
func (s Style) BorderBottom(v bool) Style {
|
||||
s.set(borderBottomKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderLeft determines whether or not to draw a left border.
|
||||
func (s Style) BorderLeft(v bool) Style {
|
||||
s.set(borderLeftKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderForeground is a shorthand function for setting all of the
|
||||
// foreground colors of the borders at once. The arguments work as follows:
|
||||
//
|
||||
// With one argument, the argument is applied to all sides.
|
||||
//
|
||||
// With two arguments, the arguments are applied to the vertical and horizontal
|
||||
// sides, in that order.
|
||||
//
|
||||
// With three arguments, the arguments are applied to the top side, the
|
||||
// horizontal sides, and the bottom side, in that order.
|
||||
//
|
||||
// With four arguments, the arguments are applied clockwise starting from the
|
||||
// top side, followed by the right side, then the bottom, and finally the left.
|
||||
//
|
||||
// With more than four arguments nothing will be set.
|
||||
func (s Style) BorderForeground(c ...TerminalColor) Style {
|
||||
if len(c) == 0 {
|
||||
return s
|
||||
}
|
||||
|
||||
top, right, bottom, left, ok := whichSidesColor(c...)
|
||||
if !ok {
|
||||
return s
|
||||
}
|
||||
|
||||
s.set(borderTopForegroundKey, top)
|
||||
s.set(borderRightForegroundKey, right)
|
||||
s.set(borderBottomForegroundKey, bottom)
|
||||
s.set(borderLeftForegroundKey, left)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderTopForeground set the foreground color for the top of the border.
|
||||
func (s Style) BorderTopForeground(c TerminalColor) Style {
|
||||
s.set(borderTopForegroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderRightForeground sets the foreground color for the right side of the
|
||||
// border.
|
||||
func (s Style) BorderRightForeground(c TerminalColor) Style {
|
||||
s.set(borderRightForegroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderBottomForeground sets the foreground color for the bottom of the
|
||||
// border.
|
||||
func (s Style) BorderBottomForeground(c TerminalColor) Style {
|
||||
s.set(borderBottomForegroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderLeftForeground sets the foreground color for the left side of the
|
||||
// border.
|
||||
func (s Style) BorderLeftForeground(c TerminalColor) Style {
|
||||
s.set(borderLeftForegroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderBackground is a shorthand function for setting all of the
|
||||
// background colors of the borders at once. The arguments work as follows:
|
||||
//
|
||||
// With one argument, the argument is applied to all sides.
|
||||
//
|
||||
// With two arguments, the arguments are applied to the vertical and horizontal
|
||||
// sides, in that order.
|
||||
//
|
||||
// With three arguments, the arguments are applied to the top side, the
|
||||
// horizontal sides, and the bottom side, in that order.
|
||||
//
|
||||
// With four arguments, the arguments are applied clockwise starting from the
|
||||
// top side, followed by the right side, then the bottom, and finally the left.
|
||||
//
|
||||
// With more than four arguments nothing will be set.
|
||||
func (s Style) BorderBackground(c ...TerminalColor) Style {
|
||||
if len(c) == 0 {
|
||||
return s
|
||||
}
|
||||
|
||||
top, right, bottom, left, ok := whichSidesColor(c...)
|
||||
if !ok {
|
||||
return s
|
||||
}
|
||||
|
||||
s.set(borderTopBackgroundKey, top)
|
||||
s.set(borderRightBackgroundKey, right)
|
||||
s.set(borderBottomBackgroundKey, bottom)
|
||||
s.set(borderLeftBackgroundKey, left)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderTopBackground sets the background color of the top of the border.
|
||||
func (s Style) BorderTopBackground(c TerminalColor) Style {
|
||||
s.set(borderTopBackgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderRightBackground sets the background color of right side the border.
|
||||
func (s Style) BorderRightBackground(c TerminalColor) Style {
|
||||
s.set(borderRightBackgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderBottomBackground sets the background color of the bottom of the
|
||||
// border.
|
||||
func (s Style) BorderBottomBackground(c TerminalColor) Style {
|
||||
s.set(borderBottomBackgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// BorderLeftBackground set the background color of the left side of the
|
||||
// border.
|
||||
func (s Style) BorderLeftBackground(c TerminalColor) Style {
|
||||
s.set(borderLeftBackgroundKey, c)
|
||||
return s
|
||||
}
|
||||
|
||||
// Inline makes rendering output one line and disables the rendering of
|
||||
// margins, padding and borders. This is useful when you need a style to apply
|
||||
// only to font rendering and don't want it to change any physical dimensions.
|
||||
// It works well with Style.MaxWidth.
|
||||
//
|
||||
// Because this in intended to be used at the time of render, this method will
|
||||
// not mutate the style and instead return a copy.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// var userInput string = "..."
|
||||
// var userStyle = text.Style{ /* ... */ }
|
||||
// fmt.Println(userStyle.Inline(true).Render(userInput))
|
||||
func (s Style) Inline(v bool) Style {
|
||||
o := s.Copy()
|
||||
o.set(inlineKey, v)
|
||||
return o
|
||||
}
|
||||
|
||||
// MaxWidth applies a max width to a given style. This is useful in enforcing
|
||||
// a certain width at render time, particularly with arbitrary strings and
|
||||
// styles.
|
||||
//
|
||||
// Because this in intended to be used at the time of render, this method will
|
||||
// not mutate the style and instead return a copy.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// var userInput string = "..."
|
||||
// var userStyle = text.Style{ /* ... */ }
|
||||
// fmt.Println(userStyle.MaxWidth(16).Render(userInput))
|
||||
func (s Style) MaxWidth(n int) Style {
|
||||
o := s.Copy()
|
||||
o.set(maxWidthKey, n)
|
||||
return o
|
||||
}
|
||||
|
||||
// MaxHeight applies a max height to a given style. This is useful in enforcing
|
||||
// a certain height at render time, particularly with arbitrary strings and
|
||||
// styles.
|
||||
//
|
||||
// Because this in intended to be used at the time of render, this method will
|
||||
// not mutate the style and instead returns a copy.
|
||||
func (s Style) MaxHeight(n int) Style {
|
||||
o := s.Copy()
|
||||
o.set(maxHeightKey, n)
|
||||
return o
|
||||
}
|
||||
|
||||
// NoTabConversion can be passed to [Style.TabWidth] to disable the replacement
|
||||
// of tabs with spaces at render time.
|
||||
const NoTabConversion = -1
|
||||
|
||||
// TabWidth sets the number of spaces that a tab (/t) should be rendered as.
|
||||
// When set to 0, tabs will be removed. To disable the replacement of tabs with
|
||||
// spaces entirely, set this to [NoTabConversion].
|
||||
//
|
||||
// By default, tabs will be replaced with 4 spaces.
|
||||
func (s Style) TabWidth(n int) Style {
|
||||
if n <= -1 {
|
||||
n = -1
|
||||
}
|
||||
s.set(tabWidthKey, n)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnderlineSpaces determines whether to underline spaces between words. By
|
||||
// default, this is true. Spaces can also be underlined without underlining the
|
||||
// text itself.
|
||||
func (s Style) UnderlineSpaces(v bool) Style {
|
||||
s.set(underlineSpacesKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// StrikethroughSpaces determines whether to apply strikethroughs to spaces
|
||||
// between words. By default, this is true. Spaces can also be struck without
|
||||
// underlining the text itself.
|
||||
func (s Style) StrikethroughSpaces(v bool) Style {
|
||||
s.set(strikethroughSpacesKey, v)
|
||||
return s
|
||||
}
|
||||
|
||||
// Renderer sets the renderer for the style. This is useful for changing the
|
||||
// renderer for a style that is being used in a different context.
|
||||
func (s Style) Renderer(r *Renderer) Style {
|
||||
s.r = r
|
||||
return s
|
||||
}
|
||||
|
||||
// whichSidesInt is a helper method for setting values on sides of a block based
|
||||
// on the number of arguments. It follows the CSS shorthand rules for blocks
|
||||
// like margin, padding. and borders. Here are how the rules work:
|
||||
//
|
||||
// 0 args: do nothing
|
||||
// 1 arg: all sides
|
||||
// 2 args: top -> bottom
|
||||
// 3 args: top -> horizontal -> bottom
|
||||
// 4 args: top -> right -> bottom -> left
|
||||
// 5+ args: do nothing.
|
||||
func whichSidesInt(i ...int) (top, right, bottom, left int, ok bool) {
|
||||
switch len(i) {
|
||||
case 1:
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[0]
|
||||
right = i[0]
|
||||
ok = true
|
||||
case 2: //nolint:gomnd
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
ok = true
|
||||
case 3: //nolint:gomnd
|
||||
top = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
ok = true
|
||||
case 4: //nolint:gomnd
|
||||
top = i[0]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
left = i[3]
|
||||
ok = true
|
||||
}
|
||||
return top, right, bottom, left, ok
|
||||
}
|
||||
|
||||
// whichSidesBool is like whichSidesInt, except it operates on a series of
|
||||
// boolean values. See the comment on whichSidesInt for details on how this
|
||||
// works.
|
||||
func whichSidesBool(i ...bool) (top, right, bottom, left bool, ok bool) {
|
||||
switch len(i) {
|
||||
case 1:
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[0]
|
||||
right = i[0]
|
||||
ok = true
|
||||
case 2: //nolint:gomnd
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
ok = true
|
||||
case 3: //nolint:gomnd
|
||||
top = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
ok = true
|
||||
case 4: //nolint:gomnd
|
||||
top = i[0]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
left = i[3]
|
||||
ok = true
|
||||
}
|
||||
return top, right, bottom, left, ok
|
||||
}
|
||||
|
||||
// whichSidesColor is like whichSides, except it operates on a series of
|
||||
// boolean values. See the comment on whichSidesInt for details on how this
|
||||
// works.
|
||||
func whichSidesColor(i ...TerminalColor) (top, right, bottom, left TerminalColor, ok bool) {
|
||||
switch len(i) {
|
||||
case 1:
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[0]
|
||||
right = i[0]
|
||||
ok = true
|
||||
case 2: //nolint:gomnd
|
||||
top = i[0]
|
||||
bottom = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
ok = true
|
||||
case 3: //nolint:gomnd
|
||||
top = i[0]
|
||||
left = i[1]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
ok = true
|
||||
case 4: //nolint:gomnd
|
||||
top = i[0]
|
||||
right = i[1]
|
||||
bottom = i[2]
|
||||
left = i[3]
|
||||
ok = true
|
||||
}
|
||||
return top, right, bottom, left, ok
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
)
|
||||
|
||||
// Width returns the cell width of characters in the string. ANSI sequences are
|
||||
// ignored and characters wider than one cell (such as Chinese characters and
|
||||
// emojis) are appropriately measured.
|
||||
//
|
||||
// You should use this instead of len(string) len([]rune(string) as neither
|
||||
// will give you accurate results.
|
||||
func Width(str string) (width int) {
|
||||
for _, l := range strings.Split(str, "\n") {
|
||||
w := ansi.PrintableRuneWidth(l)
|
||||
if w > width {
|
||||
width = w
|
||||
}
|
||||
}
|
||||
|
||||
return width
|
||||
}
|
||||
|
||||
// Height returns height of a string in cells. This is done simply by
|
||||
// counting \n characters. If your strings use \r\n for newlines you should
|
||||
// convert them to \n first, or simply write a separate function for measuring
|
||||
// height.
|
||||
func Height(str string) int {
|
||||
return strings.Count(str, "\n") + 1
|
||||
}
|
||||
|
||||
// Size returns the width and height of the string in cells. ANSI sequences are
|
||||
// ignored and characters wider than one cell (such as Chinese characters and
|
||||
// emojis) are appropriately measured.
|
||||
func Size(str string) (width, height int) {
|
||||
width = Width(str)
|
||||
height = Height(str)
|
||||
return width, height
|
||||
}
|
||||
|
|
@ -0,0 +1,519 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"unicode"
|
||||
|
||||
"github.com/muesli/reflow/truncate"
|
||||
"github.com/muesli/reflow/wordwrap"
|
||||
"github.com/muesli/reflow/wrap"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
const tabWidthDefault = 4
|
||||
|
||||
// Property for a key.
|
||||
type propKey int
|
||||
|
||||
// Available properties.
|
||||
const (
|
||||
boldKey propKey = iota
|
||||
italicKey
|
||||
underlineKey
|
||||
strikethroughKey
|
||||
reverseKey
|
||||
blinkKey
|
||||
faintKey
|
||||
foregroundKey
|
||||
backgroundKey
|
||||
widthKey
|
||||
heightKey
|
||||
alignHorizontalKey
|
||||
alignVerticalKey
|
||||
|
||||
// Padding.
|
||||
paddingTopKey
|
||||
paddingRightKey
|
||||
paddingBottomKey
|
||||
paddingLeftKey
|
||||
|
||||
colorWhitespaceKey
|
||||
|
||||
// Margins.
|
||||
marginTopKey
|
||||
marginRightKey
|
||||
marginBottomKey
|
||||
marginLeftKey
|
||||
marginBackgroundKey
|
||||
|
||||
// Border runes.
|
||||
borderStyleKey
|
||||
|
||||
// Border edges.
|
||||
borderTopKey
|
||||
borderRightKey
|
||||
borderBottomKey
|
||||
borderLeftKey
|
||||
|
||||
// Border foreground colors.
|
||||
borderTopForegroundKey
|
||||
borderRightForegroundKey
|
||||
borderBottomForegroundKey
|
||||
borderLeftForegroundKey
|
||||
|
||||
// Border background colors.
|
||||
borderTopBackgroundKey
|
||||
borderRightBackgroundKey
|
||||
borderBottomBackgroundKey
|
||||
borderLeftBackgroundKey
|
||||
|
||||
inlineKey
|
||||
maxWidthKey
|
||||
maxHeightKey
|
||||
tabWidthKey
|
||||
underlineSpacesKey
|
||||
strikethroughSpacesKey
|
||||
)
|
||||
|
||||
// A set of properties.
|
||||
type rules map[propKey]interface{}
|
||||
|
||||
// NewStyle returns a new, empty Style. While it's syntactic sugar for the
|
||||
// Style{} primitive, it's recommended to use this function for creating styles
|
||||
// in case the underlying implementation changes. It takes an optional string
|
||||
// value to be set as the underlying string value for this style.
|
||||
func NewStyle() Style {
|
||||
return renderer.NewStyle()
|
||||
}
|
||||
|
||||
// NewStyle returns a new, empty Style. While it's syntactic sugar for the
|
||||
// Style{} primitive, it's recommended to use this function for creating styles
|
||||
// in case the underlying implementation changes. It takes an optional string
|
||||
// value to be set as the underlying string value for this style.
|
||||
func (r *Renderer) NewStyle() Style {
|
||||
s := Style{r: r}
|
||||
return s
|
||||
}
|
||||
|
||||
// Style contains a set of rules that comprise a style as a whole.
|
||||
type Style struct {
|
||||
r *Renderer
|
||||
rules map[propKey]interface{}
|
||||
value string
|
||||
}
|
||||
|
||||
// joinString joins a list of strings into a single string separated with a
|
||||
// space.
|
||||
func joinString(strs ...string) string {
|
||||
return strings.Join(strs, " ")
|
||||
}
|
||||
|
||||
// SetString sets the underlying string value for this style. To render once
|
||||
// the underlying string is set, use the Style.String. This method is
|
||||
// a convenience for cases when having a stringer implementation is handy, such
|
||||
// as when using fmt.Sprintf. You can also simply define a style and render out
|
||||
// strings directly with Style.Render.
|
||||
func (s Style) SetString(strs ...string) Style {
|
||||
s.value = joinString(strs...)
|
||||
return s
|
||||
}
|
||||
|
||||
// Value returns the raw, unformatted, underlying string value for this style.
|
||||
func (s Style) Value() string {
|
||||
return s.value
|
||||
}
|
||||
|
||||
// String implements stringer for a Style, returning the rendered result based
|
||||
// on the rules in this style. An underlying string value must be set with
|
||||
// Style.SetString prior to using this method.
|
||||
func (s Style) String() string {
|
||||
return s.Render()
|
||||
}
|
||||
|
||||
// Copy returns a copy of this style, including any underlying string values.
|
||||
func (s Style) Copy() Style {
|
||||
o := NewStyle()
|
||||
o.init()
|
||||
for k, v := range s.rules {
|
||||
o.rules[k] = v
|
||||
}
|
||||
o.r = s.r
|
||||
o.value = s.value
|
||||
return o
|
||||
}
|
||||
|
||||
// Inherit overlays the style in the argument onto this style by copying each explicitly
|
||||
// set value from the argument style onto this style if it is not already explicitly set.
|
||||
// Existing set values are kept intact and not overwritten.
|
||||
//
|
||||
// Margins, padding, and underlying string values are not inherited.
|
||||
func (s Style) Inherit(i Style) Style {
|
||||
s.init()
|
||||
|
||||
for k, v := range i.rules {
|
||||
switch k { //nolint:exhaustive
|
||||
case marginTopKey, marginRightKey, marginBottomKey, marginLeftKey:
|
||||
// Margins are not inherited
|
||||
continue
|
||||
case paddingTopKey, paddingRightKey, paddingBottomKey, paddingLeftKey:
|
||||
// Padding is not inherited
|
||||
continue
|
||||
case backgroundKey:
|
||||
// The margins also inherit the background color
|
||||
if !s.isSet(marginBackgroundKey) && !i.isSet(marginBackgroundKey) {
|
||||
s.rules[marginBackgroundKey] = v
|
||||
}
|
||||
}
|
||||
|
||||
if _, exists := s.rules[k]; exists {
|
||||
continue
|
||||
}
|
||||
s.rules[k] = v
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// Render applies the defined style formatting to a given string.
|
||||
func (s Style) Render(strs ...string) string {
|
||||
if s.r == nil {
|
||||
s.r = renderer
|
||||
}
|
||||
if s.value != "" {
|
||||
strs = append([]string{s.value}, strs...)
|
||||
}
|
||||
|
||||
var (
|
||||
str = joinString(strs...)
|
||||
|
||||
p = s.r.ColorProfile()
|
||||
te = p.String()
|
||||
teSpace = p.String()
|
||||
teWhitespace = p.String()
|
||||
|
||||
bold = s.getAsBool(boldKey, false)
|
||||
italic = s.getAsBool(italicKey, false)
|
||||
underline = s.getAsBool(underlineKey, false)
|
||||
strikethrough = s.getAsBool(strikethroughKey, false)
|
||||
reverse = s.getAsBool(reverseKey, false)
|
||||
blink = s.getAsBool(blinkKey, false)
|
||||
faint = s.getAsBool(faintKey, false)
|
||||
|
||||
fg = s.getAsColor(foregroundKey)
|
||||
bg = s.getAsColor(backgroundKey)
|
||||
|
||||
width = s.getAsInt(widthKey)
|
||||
height = s.getAsInt(heightKey)
|
||||
horizontalAlign = s.getAsPosition(alignHorizontalKey)
|
||||
verticalAlign = s.getAsPosition(alignVerticalKey)
|
||||
|
||||
topPadding = s.getAsInt(paddingTopKey)
|
||||
rightPadding = s.getAsInt(paddingRightKey)
|
||||
bottomPadding = s.getAsInt(paddingBottomKey)
|
||||
leftPadding = s.getAsInt(paddingLeftKey)
|
||||
|
||||
colorWhitespace = s.getAsBool(colorWhitespaceKey, true)
|
||||
inline = s.getAsBool(inlineKey, false)
|
||||
maxWidth = s.getAsInt(maxWidthKey)
|
||||
maxHeight = s.getAsInt(maxHeightKey)
|
||||
|
||||
underlineSpaces = underline && s.getAsBool(underlineSpacesKey, true)
|
||||
strikethroughSpaces = strikethrough && s.getAsBool(strikethroughSpacesKey, true)
|
||||
|
||||
// Do we need to style whitespace (padding and space outside
|
||||
// paragraphs) separately?
|
||||
styleWhitespace = reverse
|
||||
|
||||
// Do we need to style spaces separately?
|
||||
useSpaceStyler = underlineSpaces || strikethroughSpaces
|
||||
)
|
||||
|
||||
if len(s.rules) == 0 {
|
||||
return s.maybeConvertTabs(str)
|
||||
}
|
||||
|
||||
// Enable support for ANSI on the legacy Windows cmd.exe console. This is a
|
||||
// no-op on non-Windows systems and on Windows runs only once.
|
||||
enableLegacyWindowsANSI()
|
||||
|
||||
if bold {
|
||||
te = te.Bold()
|
||||
}
|
||||
if italic {
|
||||
te = te.Italic()
|
||||
}
|
||||
if underline {
|
||||
te = te.Underline()
|
||||
}
|
||||
if reverse {
|
||||
if reverse {
|
||||
teWhitespace = teWhitespace.Reverse()
|
||||
}
|
||||
te = te.Reverse()
|
||||
}
|
||||
if blink {
|
||||
te = te.Blink()
|
||||
}
|
||||
if faint {
|
||||
te = te.Faint()
|
||||
}
|
||||
|
||||
if fg != noColor {
|
||||
te = te.Foreground(fg.color(s.r))
|
||||
if styleWhitespace {
|
||||
teWhitespace = teWhitespace.Foreground(fg.color(s.r))
|
||||
}
|
||||
if useSpaceStyler {
|
||||
teSpace = teSpace.Foreground(fg.color(s.r))
|
||||
}
|
||||
}
|
||||
|
||||
if bg != noColor {
|
||||
te = te.Background(bg.color(s.r))
|
||||
if colorWhitespace {
|
||||
teWhitespace = teWhitespace.Background(bg.color(s.r))
|
||||
}
|
||||
if useSpaceStyler {
|
||||
teSpace = teSpace.Background(bg.color(s.r))
|
||||
}
|
||||
}
|
||||
|
||||
if underline {
|
||||
te = te.Underline()
|
||||
}
|
||||
if strikethrough {
|
||||
te = te.CrossOut()
|
||||
}
|
||||
|
||||
if underlineSpaces {
|
||||
teSpace = teSpace.Underline()
|
||||
}
|
||||
if strikethroughSpaces {
|
||||
teSpace = teSpace.CrossOut()
|
||||
}
|
||||
|
||||
// Potentially convert tabs to spaces
|
||||
str = s.maybeConvertTabs(str)
|
||||
|
||||
// Strip newlines in single line mode
|
||||
if inline {
|
||||
str = strings.ReplaceAll(str, "\n", "")
|
||||
}
|
||||
|
||||
// Word wrap
|
||||
if !inline && width > 0 {
|
||||
wrapAt := width - leftPadding - rightPadding
|
||||
str = wordwrap.String(str, wrapAt)
|
||||
str = wrap.String(str, wrapAt) // force-wrap long strings
|
||||
}
|
||||
|
||||
// Render core text
|
||||
{
|
||||
var b strings.Builder
|
||||
|
||||
l := strings.Split(str, "\n")
|
||||
for i := range l {
|
||||
if useSpaceStyler {
|
||||
// Look for spaces and apply a different styler
|
||||
for _, r := range l[i] {
|
||||
if unicode.IsSpace(r) {
|
||||
b.WriteString(teSpace.Styled(string(r)))
|
||||
continue
|
||||
}
|
||||
b.WriteString(te.Styled(string(r)))
|
||||
}
|
||||
} else {
|
||||
b.WriteString(te.Styled(l[i]))
|
||||
}
|
||||
if i != len(l)-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
str = b.String()
|
||||
}
|
||||
|
||||
// Padding
|
||||
if !inline {
|
||||
if leftPadding > 0 {
|
||||
var st *termenv.Style
|
||||
if colorWhitespace || styleWhitespace {
|
||||
st = &teWhitespace
|
||||
}
|
||||
str = padLeft(str, leftPadding, st)
|
||||
}
|
||||
|
||||
if rightPadding > 0 {
|
||||
var st *termenv.Style
|
||||
if colorWhitespace || styleWhitespace {
|
||||
st = &teWhitespace
|
||||
}
|
||||
str = padRight(str, rightPadding, st)
|
||||
}
|
||||
|
||||
if topPadding > 0 {
|
||||
str = strings.Repeat("\n", topPadding) + str
|
||||
}
|
||||
|
||||
if bottomPadding > 0 {
|
||||
str += strings.Repeat("\n", bottomPadding)
|
||||
}
|
||||
}
|
||||
|
||||
// Height
|
||||
if height > 0 {
|
||||
str = alignTextVertical(str, verticalAlign, height, nil)
|
||||
}
|
||||
|
||||
// Set alignment. This will also pad short lines with spaces so that all
|
||||
// lines are the same length, so we run it under a few different conditions
|
||||
// beyond alignment.
|
||||
{
|
||||
numLines := strings.Count(str, "\n")
|
||||
|
||||
if !(numLines == 0 && width == 0) {
|
||||
var st *termenv.Style
|
||||
if colorWhitespace || styleWhitespace {
|
||||
st = &teWhitespace
|
||||
}
|
||||
str = alignTextHorizontal(str, horizontalAlign, width, st)
|
||||
}
|
||||
}
|
||||
|
||||
if !inline {
|
||||
str = s.applyBorder(str)
|
||||
str = s.applyMargins(str, inline)
|
||||
}
|
||||
|
||||
// Truncate according to MaxWidth
|
||||
if maxWidth > 0 {
|
||||
lines := strings.Split(str, "\n")
|
||||
|
||||
for i := range lines {
|
||||
lines[i] = truncate.String(lines[i], uint(maxWidth))
|
||||
}
|
||||
|
||||
str = strings.Join(lines, "\n")
|
||||
}
|
||||
|
||||
// Truncate according to MaxHeight
|
||||
if maxHeight > 0 {
|
||||
lines := strings.Split(str, "\n")
|
||||
str = strings.Join(lines[:min(maxHeight, len(lines))], "\n")
|
||||
}
|
||||
|
||||
return str
|
||||
}
|
||||
|
||||
func (s Style) maybeConvertTabs(str string) string {
|
||||
tw := tabWidthDefault
|
||||
if s.isSet(tabWidthKey) {
|
||||
tw = s.getAsInt(tabWidthKey)
|
||||
}
|
||||
switch tw {
|
||||
case -1:
|
||||
return str
|
||||
case 0:
|
||||
return strings.ReplaceAll(str, "\t", "")
|
||||
default:
|
||||
return strings.ReplaceAll(str, "\t", strings.Repeat(" ", tw))
|
||||
}
|
||||
}
|
||||
|
||||
func (s Style) applyMargins(str string, inline bool) string {
|
||||
var (
|
||||
topMargin = s.getAsInt(marginTopKey)
|
||||
rightMargin = s.getAsInt(marginRightKey)
|
||||
bottomMargin = s.getAsInt(marginBottomKey)
|
||||
leftMargin = s.getAsInt(marginLeftKey)
|
||||
|
||||
styler termenv.Style
|
||||
)
|
||||
|
||||
bgc := s.getAsColor(marginBackgroundKey)
|
||||
if bgc != noColor {
|
||||
styler = styler.Background(bgc.color(s.r))
|
||||
}
|
||||
|
||||
// Add left and right margin
|
||||
str = padLeft(str, leftMargin, &styler)
|
||||
str = padRight(str, rightMargin, &styler)
|
||||
|
||||
// Top/bottom margin
|
||||
if !inline {
|
||||
_, width := getLines(str)
|
||||
spaces := strings.Repeat(" ", width)
|
||||
|
||||
if topMargin > 0 {
|
||||
str = styler.Styled(strings.Repeat(spaces+"\n", topMargin)) + str
|
||||
}
|
||||
if bottomMargin > 0 {
|
||||
str += styler.Styled(strings.Repeat("\n"+spaces, bottomMargin))
|
||||
}
|
||||
}
|
||||
|
||||
return str
|
||||
}
|
||||
|
||||
// Apply left padding.
|
||||
func padLeft(str string, n int, style *termenv.Style) string {
|
||||
if n == 0 {
|
||||
return str
|
||||
}
|
||||
|
||||
sp := strings.Repeat(" ", n)
|
||||
if style != nil {
|
||||
sp = style.Styled(sp)
|
||||
}
|
||||
|
||||
b := strings.Builder{}
|
||||
l := strings.Split(str, "\n")
|
||||
|
||||
for i := range l {
|
||||
b.WriteString(sp)
|
||||
b.WriteString(l[i])
|
||||
if i != len(l)-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Apply right padding.
|
||||
func padRight(str string, n int, style *termenv.Style) string {
|
||||
if n == 0 || str == "" {
|
||||
return str
|
||||
}
|
||||
|
||||
sp := strings.Repeat(" ", n)
|
||||
if style != nil {
|
||||
sp = style.Styled(sp)
|
||||
}
|
||||
|
||||
b := strings.Builder{}
|
||||
l := strings.Split(str, "\n")
|
||||
|
||||
for i := range l {
|
||||
b.WriteString(l[i])
|
||||
b.WriteString(sp)
|
||||
if i != len(l)-1 {
|
||||
b.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func max(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
|
@ -0,0 +1,312 @@
|
|||
package lipgloss
|
||||
|
||||
// UnsetBold removes the bold style rule, if set.
|
||||
func (s Style) UnsetBold() Style {
|
||||
delete(s.rules, boldKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetItalic removes the italic style rule, if set.
|
||||
func (s Style) UnsetItalic() Style {
|
||||
delete(s.rules, italicKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetUnderline removes the underline style rule, if set.
|
||||
func (s Style) UnsetUnderline() Style {
|
||||
delete(s.rules, underlineKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetStrikethrough removes the strikethrough style rule, if set.
|
||||
func (s Style) UnsetStrikethrough() Style {
|
||||
delete(s.rules, strikethroughKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetReverse removes the reverse style rule, if set.
|
||||
func (s Style) UnsetReverse() Style {
|
||||
delete(s.rules, reverseKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBlink removes the blink style rule, if set.
|
||||
func (s Style) UnsetBlink() Style {
|
||||
delete(s.rules, blinkKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetFaint removes the faint style rule, if set.
|
||||
func (s Style) UnsetFaint() Style {
|
||||
delete(s.rules, faintKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetForeground removes the foreground style rule, if set.
|
||||
func (s Style) UnsetForeground() Style {
|
||||
delete(s.rules, foregroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBackground removes the background style rule, if set.
|
||||
func (s Style) UnsetBackground() Style {
|
||||
delete(s.rules, backgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetWidth removes the width style rule, if set.
|
||||
func (s Style) UnsetWidth() Style {
|
||||
delete(s.rules, widthKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetHeight removes the height style rule, if set.
|
||||
func (s Style) UnsetHeight() Style {
|
||||
delete(s.rules, heightKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetAlign removes the horizontal and vertical text alignment style rule, if set.
|
||||
func (s Style) UnsetAlign() Style {
|
||||
delete(s.rules, alignHorizontalKey)
|
||||
delete(s.rules, alignVerticalKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetAlignHorizontal removes the horizontal text alignment style rule, if set.
|
||||
func (s Style) UnsetAlignHorizontal() Style {
|
||||
delete(s.rules, alignHorizontalKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetAlignVertical removes the vertical text alignment style rule, if set.
|
||||
func (s Style) UnsetAlignVertical() Style {
|
||||
delete(s.rules, alignVerticalKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetPadding removes all padding style rules.
|
||||
func (s Style) UnsetPadding() Style {
|
||||
delete(s.rules, paddingLeftKey)
|
||||
delete(s.rules, paddingRightKey)
|
||||
delete(s.rules, paddingTopKey)
|
||||
delete(s.rules, paddingBottomKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetPaddingLeft removes the left padding style rule, if set.
|
||||
func (s Style) UnsetPaddingLeft() Style {
|
||||
delete(s.rules, paddingLeftKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetPaddingRight removes the right padding style rule, if set.
|
||||
func (s Style) UnsetPaddingRight() Style {
|
||||
delete(s.rules, paddingRightKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetPaddingTop removes the top padding style rule, if set.
|
||||
func (s Style) UnsetPaddingTop() Style {
|
||||
delete(s.rules, paddingTopKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetPaddingBottom removes the bottom padding style rule, if set.
|
||||
func (s Style) UnsetPaddingBottom() Style {
|
||||
delete(s.rules, paddingBottomKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetColorWhitespace removes the rule for coloring padding, if set.
|
||||
func (s Style) UnsetColorWhitespace() Style {
|
||||
delete(s.rules, colorWhitespaceKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMargins removes all margin style rules.
|
||||
func (s Style) UnsetMargins() Style {
|
||||
delete(s.rules, marginLeftKey)
|
||||
delete(s.rules, marginRightKey)
|
||||
delete(s.rules, marginTopKey)
|
||||
delete(s.rules, marginBottomKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMarginLeft removes the left margin style rule, if set.
|
||||
func (s Style) UnsetMarginLeft() Style {
|
||||
delete(s.rules, marginLeftKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMarginRight removes the right margin style rule, if set.
|
||||
func (s Style) UnsetMarginRight() Style {
|
||||
delete(s.rules, marginRightKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMarginTop removes the top margin style rule, if set.
|
||||
func (s Style) UnsetMarginTop() Style {
|
||||
delete(s.rules, marginTopKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMarginBottom removes the bottom margin style rule, if set.
|
||||
func (s Style) UnsetMarginBottom() Style {
|
||||
delete(s.rules, marginBottomKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMarginBackground removes the margin's background color. Note that the
|
||||
// margin's background color can be set from the background color of another
|
||||
// style during inheritance.
|
||||
func (s Style) UnsetMarginBackground() Style {
|
||||
delete(s.rules, marginBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderStyle removes the border style rule, if set.
|
||||
func (s Style) UnsetBorderStyle() Style {
|
||||
delete(s.rules, borderStyleKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderTop removes the border top style rule, if set.
|
||||
func (s Style) UnsetBorderTop() Style {
|
||||
delete(s.rules, borderTopKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderRight removes the border right style rule, if set.
|
||||
func (s Style) UnsetBorderRight() Style {
|
||||
delete(s.rules, borderRightKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderBottom removes the border bottom style rule, if set.
|
||||
func (s Style) UnsetBorderBottom() Style {
|
||||
delete(s.rules, borderBottomKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderLeft removes the border left style rule, if set.
|
||||
func (s Style) UnsetBorderLeft() Style {
|
||||
delete(s.rules, borderLeftKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderForeground removes all border foreground color styles, if set.
|
||||
func (s Style) UnsetBorderForeground() Style {
|
||||
delete(s.rules, borderTopForegroundKey)
|
||||
delete(s.rules, borderRightForegroundKey)
|
||||
delete(s.rules, borderBottomForegroundKey)
|
||||
delete(s.rules, borderLeftForegroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderTopForeground removes the top border foreground color rule,
|
||||
// if set.
|
||||
func (s Style) UnsetBorderTopForeground() Style {
|
||||
delete(s.rules, borderTopForegroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderRightForeground removes the right border foreground color rule,
|
||||
// if set.
|
||||
func (s Style) UnsetBorderRightForeground() Style {
|
||||
delete(s.rules, borderRightForegroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderBottomForeground removes the bottom border foreground color
|
||||
// rule, if set.
|
||||
func (s Style) UnsetBorderBottomForeground() Style {
|
||||
delete(s.rules, borderBottomForegroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderLeftForeground removes the left border foreground color rule,
|
||||
// if set.
|
||||
func (s Style) UnsetBorderLeftForeground() Style {
|
||||
delete(s.rules, borderLeftForegroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderBackground removes all border background color styles, if
|
||||
// set.
|
||||
func (s Style) UnsetBorderBackground() Style {
|
||||
delete(s.rules, borderTopBackgroundKey)
|
||||
delete(s.rules, borderRightBackgroundKey)
|
||||
delete(s.rules, borderBottomBackgroundKey)
|
||||
delete(s.rules, borderLeftBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderTopBackgroundColor removes the top border background color rule,
|
||||
// if set.
|
||||
func (s Style) UnsetBorderTopBackgroundColor() Style {
|
||||
delete(s.rules, borderTopBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderRightBackground removes the right border background color
|
||||
// rule, if set.
|
||||
func (s Style) UnsetBorderRightBackground() Style {
|
||||
delete(s.rules, borderRightBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderBottomBackground removes the bottom border background color
|
||||
// rule, if set.
|
||||
func (s Style) UnsetBorderBottomBackground() Style {
|
||||
delete(s.rules, borderBottomBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetBorderLeftBackground removes the left border color rule, if set.
|
||||
func (s Style) UnsetBorderLeftBackground() Style {
|
||||
delete(s.rules, borderLeftBackgroundKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetInline removes the inline style rule, if set.
|
||||
func (s Style) UnsetInline() Style {
|
||||
delete(s.rules, inlineKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMaxWidth removes the max width style rule, if set.
|
||||
func (s Style) UnsetMaxWidth() Style {
|
||||
delete(s.rules, maxWidthKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetMaxHeight removes the max height style rule, if set.
|
||||
func (s Style) UnsetMaxHeight() Style {
|
||||
delete(s.rules, maxHeightKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetTabWidth removes the tab width style rule, if set.
|
||||
func (s Style) UnsetTabWidth() Style {
|
||||
delete(s.rules, tabWidthKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetUnderlineSpaces removes the value set by UnderlineSpaces.
|
||||
func (s Style) UnsetUnderlineSpaces() Style {
|
||||
delete(s.rules, underlineSpacesKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetStrikethroughSpaces removes the value set by StrikethroughSpaces.
|
||||
func (s Style) UnsetStrikethroughSpaces() Style {
|
||||
delete(s.rules, strikethroughSpacesKey)
|
||||
return s
|
||||
}
|
||||
|
||||
// UnsetString sets the underlying string value to the empty string.
|
||||
func (s Style) UnsetString() Style {
|
||||
s.value = ""
|
||||
return s
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
package lipgloss
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/muesli/reflow/ansi"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
// whitespace is a whitespace renderer.
|
||||
type whitespace struct {
|
||||
re *Renderer
|
||||
style termenv.Style
|
||||
chars string
|
||||
}
|
||||
|
||||
// newWhitespace creates a new whitespace renderer. The order of the options
|
||||
// matters, if you're using WithWhitespaceRenderer, make sure it comes first as
|
||||
// other options might depend on it.
|
||||
func newWhitespace(r *Renderer, opts ...WhitespaceOption) *whitespace {
|
||||
w := &whitespace{
|
||||
re: r,
|
||||
style: r.ColorProfile().String(),
|
||||
}
|
||||
for _, opt := range opts {
|
||||
opt(w)
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
// Render whitespaces.
|
||||
func (w whitespace) render(width int) string {
|
||||
if w.chars == "" {
|
||||
w.chars = " "
|
||||
}
|
||||
|
||||
r := []rune(w.chars)
|
||||
j := 0
|
||||
b := strings.Builder{}
|
||||
|
||||
// Cycle through runes and print them into the whitespace.
|
||||
for i := 0; i < width; {
|
||||
b.WriteRune(r[j])
|
||||
j++
|
||||
if j >= len(r) {
|
||||
j = 0
|
||||
}
|
||||
i += ansi.PrintableRuneWidth(string(r[j]))
|
||||
}
|
||||
|
||||
// Fill any extra gaps white spaces. This might be necessary if any runes
|
||||
// are more than one cell wide, which could leave a one-rune gap.
|
||||
short := width - ansi.PrintableRuneWidth(b.String())
|
||||
if short > 0 {
|
||||
b.WriteString(strings.Repeat(" ", short))
|
||||
}
|
||||
|
||||
return w.style.Styled(b.String())
|
||||
}
|
||||
|
||||
// WhitespaceOption sets a styling rule for rendering whitespace.
|
||||
type WhitespaceOption func(*whitespace)
|
||||
|
||||
// WithWhitespaceForeground sets the color of the characters in the whitespace.
|
||||
func WithWhitespaceForeground(c TerminalColor) WhitespaceOption {
|
||||
return func(w *whitespace) {
|
||||
w.style = w.style.Foreground(c.color(w.re))
|
||||
}
|
||||
}
|
||||
|
||||
// WithWhitespaceBackground sets the background color of the whitespace.
|
||||
func WithWhitespaceBackground(c TerminalColor) WhitespaceOption {
|
||||
return func(w *whitespace) {
|
||||
w.style = w.style.Background(c.color(w.re))
|
||||
}
|
||||
}
|
||||
|
||||
// WithWhitespaceChars sets the characters to be rendered in the whitespace.
|
||||
func WithWhitespaceChars(s string) WhitespaceOption {
|
||||
return func(w *whitespace) {
|
||||
w.chars = s
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
*.txt
|
||||
*.gif
|
||||
|
||||
examples/batch2/batch2
|
||||
examples/chocolate-chips/chocolate-chips
|
||||
examples/cookie/cookie
|
||||
examples/error/error
|
||||
examples/format/format
|
||||
examples/log/log
|
||||
examples/new/new
|
||||
examples/options/options
|
||||
examples/oven/oven
|
||||
examples/temperature/temperature
|
||||
|
||||
.vscode
|
||||
.history
|
||||
go.work
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
run:
|
||||
tests: false
|
||||
|
||||
issues:
|
||||
include:
|
||||
- EXC0001
|
||||
- EXC0005
|
||||
- EXC0011
|
||||
- EXC0012
|
||||
- EXC0013
|
||||
|
||||
max-issues-per-linter: 0
|
||||
max-same-issues: 0
|
||||
|
||||
linters:
|
||||
enable:
|
||||
- bodyclose
|
||||
- dupl
|
||||
- exportloopref
|
||||
- goconst
|
||||
- godot
|
||||
- godox
|
||||
- goimports
|
||||
- goprintffuncname
|
||||
- gosec
|
||||
- misspell
|
||||
- nolintlint
|
||||
- prealloc
|
||||
- revive
|
||||
- rowserrcheck
|
||||
- sqlclosecheck
|
||||
- unconvert
|
||||
- unparam
|
||||
- whitespace
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
includes:
|
||||
- from_url:
|
||||
url: charmbracelet/meta/main/goreleaser-lib.yaml
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) 2022-2023 Charmbracelet, Inc
|
||||
|
||||
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.
|
||||
|
|
@ -0,0 +1,357 @@
|
|||
# Log
|
||||
|
||||
<p>
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/25087/219742757-c8afe0d9-608a-4845-a555-ef59c0af9ebc.png" width="359">
|
||||
<source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/25087/219743408-3d7bef51-1409-40c0-8159-acc6e52f078e.png" width="359">
|
||||
<img src="https://user-images.githubusercontent.com/25087/219742757-c8afe0d9-608a-4845-a555-ef59c0af9ebc.png" width="359" />
|
||||
</picture>
|
||||
<br>
|
||||
<a href="https://github.com/charmbracelet/log/releases"><img src="https://img.shields.io/github/release/charmbracelet/log.svg" alt="Latest Release"></a>
|
||||
<a href="https://pkg.go.dev/github.com/charmbracelet/log?tab=doc"><img src="https://godoc.org/github.com/golang/gddo?status.svg" alt="Go Docs"></a>
|
||||
<a href="https://github.com/charmbracelet/log/actions"><img src="https://github.com/charmbracelet/log/workflows/build/badge.svg" alt="Build Status"></a>
|
||||
<a href="https://codecov.io/gh/charmbracelet/log"><img alt="Codecov branch" src="https://img.shields.io/codecov/c/github/charmbracelet/log/main.svg"></a>
|
||||
<a href="https://goreportcard.com/report/github.com/charmbracelet/log"><img alt="Go Report Card" src="https://goreportcard.com/badge/github.com/charmbracelet/log"></a>
|
||||
</p>
|
||||
|
||||
A minimal and colorful Go logging library. 🪵
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" srcset="https://vhs.charm.sh/vhs-1wBImk2iSIuiiD7Ib9rufi.gif">
|
||||
<source media="(prefers-color-scheme: light)" srcset="https://vhs.charm.sh/vhs-1wBImk2iSIuiiD7Ib9rufi.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" srcset="https://vhs.charm.sh/vhs-2NvOYS29AauVRgRRPmquXx.gif"> -->
|
||||
<img src="https://vhs.charm.sh/vhs-1wBImk2iSIuiiD7Ib9rufi.gif" alt="Made with VHS" />
|
||||
</picture>
|
||||
|
||||
It provides a leveled structured human readable logger with a small API. Unlike
|
||||
[standard `log`][stdlog], the Charm logger provides customizable colorful human
|
||||
readable logging with batteries included.
|
||||
|
||||
- Uses [Lip Gloss][lipgloss] to style and colorize the output.
|
||||
- Colorful, human readable format.
|
||||
- Ability to customize the time stamp format.
|
||||
- Skips caller frames and marks function as helpers.
|
||||
- Leveled logging.
|
||||
- Text, JSON, and Logfmt formatters.
|
||||
- Store and retrieve logger in and from context.
|
||||
- Slog handler.
|
||||
- Standard log adapter.
|
||||
|
||||
## Usage
|
||||
|
||||
Use `go get` to download the dependency.
|
||||
|
||||
```bash
|
||||
go get github.com/charmbracelet/log@latest
|
||||
```
|
||||
|
||||
Then, `import` it in your Go files:
|
||||
|
||||
```go
|
||||
import "github.com/charmbracelet/log"
|
||||
```
|
||||
|
||||
The Charm logger comes with a global package-wise logger with timestamps turned
|
||||
on, and the logging level set to `info`.
|
||||
|
||||
```go
|
||||
log.Debug("Cookie 🍪") // won't print anything
|
||||
log.Info("Hello World!")
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="400" srcset="https://vhs.charm.sh/vhs-cKiS8OuRrF1VVVpscM9e3.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="400" srcset="https://vhs.charm.sh/vhs-cKiS8OuRrF1VVVpscM9e3.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="400" srcset="https://vhs.charm.sh/vhs-4AeLaEuO3tDbECR1qe9Jvp.gif"> -->
|
||||
<img width="400" src="https://vhs.charm.sh/vhs-4AeLaEuO3tDbECR1qe9Jvp.gif" alt="Made with VHS" />
|
||||
</picture>
|
||||
|
||||
All logging levels accept optional key/value pairs to be printed along with a
|
||||
message.
|
||||
|
||||
```go
|
||||
err := fmt.Errorf("too much sugar")
|
||||
log.Error("failed to bake cookies", "err", err)
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="600" srcset="https://vhs.charm.sh/vhs-65KIpGw4FTESK0IzkDB9VQ.gif" >
|
||||
<source media="(prefers-color-scheme: light)" width="600" srcset="https://vhs.charm.sh/vhs-65KIpGw4FTESK0IzkDB9VQ.gif" >
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="600" srcset="https://vhs.charm.sh/vhs-7rk8wALXRDoFw8SLFwn9rW.gif"> -->
|
||||
<img width="600" src="https://vhs.charm.sh/vhs-65KIpGw4FTESK0IzkDB9VQ.gif" alt="Made with VHS">
|
||||
</picture>
|
||||
|
||||
You can use `log.Print()` to print messages without a level prefix.
|
||||
|
||||
```go
|
||||
log.Print("Baking 101")
|
||||
// 2023/01/04 10:04:06 Baking 101
|
||||
```
|
||||
|
||||
### New loggers
|
||||
|
||||
Use `New()` to create new loggers.
|
||||
|
||||
```go
|
||||
logger := log.New(os.Stderr)
|
||||
if butter {
|
||||
logger.Warn("chewy!", "butter", true)
|
||||
}
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="300" srcset="https://vhs.charm.sh/vhs-3QQdzOW4Zc0bN2tOhAest9.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="300" srcset="https://vhs.charm.sh/vhs-3QQdzOW4Zc0bN2tOhAest9.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="300" srcset="https://vhs.charm.sh/vhs-1nrhNSuFnQkxWD4RoMlE4O.gif"> -->
|
||||
<img width="300" src="https://vhs.charm.sh/vhs-3QQdzOW4Zc0bN2tOhAest9.gif">
|
||||
</picture>
|
||||
|
||||
### Levels
|
||||
|
||||
Log offers multiple levels to filter your logs on. Available levels are:
|
||||
|
||||
```go
|
||||
log.DebugLevel
|
||||
log.InfoLevel
|
||||
log.WarnLevel
|
||||
log.ErrorLevel
|
||||
log.FatalLevel
|
||||
```
|
||||
|
||||
Use `log.SetLevel()` to set the log level. You can also create a new logger with
|
||||
a specific log level using `log.Options{Level: }`.
|
||||
|
||||
Use the corresponding function to log a message:
|
||||
|
||||
```go
|
||||
err := errors.New("Baking error 101")
|
||||
log.Debug(err)
|
||||
log.Info(err)
|
||||
log.Warn(err)
|
||||
log.Error(err)
|
||||
log.Fatal(err) // this calls os.Exit(1)
|
||||
log.Print(err) // prints regardless of log level
|
||||
```
|
||||
|
||||
Or use the formatter variant:
|
||||
|
||||
```go
|
||||
format := "%s %d"
|
||||
log.Debugf(format, "chocolate", 10)
|
||||
log.Warnf(format, "adding more", 5)
|
||||
log.Errorf(format, "increasing temp", 420)
|
||||
log.Fatalf(format, "too hot!", 500) // this calls os.Exit(1)
|
||||
log.Printf(format, "baking cookies") // prints regardless of log level
|
||||
|
||||
// Use these in conjunction with `With(...)` to add more context
|
||||
log.With("err", err).Errorf("unable to start %s", "oven")
|
||||
```
|
||||
|
||||
### Structured
|
||||
|
||||
All the functions above take a message and key-value pairs of anything. The
|
||||
message can also be of type any.
|
||||
|
||||
```go
|
||||
ingredients := []string{"flour", "butter", "sugar", "chocolate"}
|
||||
log.Debug("Available ingredients", "ingredients", ingredients)
|
||||
// DEBUG Available ingredients ingredients="[flour butter sugar chocolate]"
|
||||
```
|
||||
|
||||
### Options
|
||||
|
||||
You can customize the logger with options. Use `log.NewWithOptions()` and
|
||||
`log.Options{}` to customize your new logger.
|
||||
|
||||
```go
|
||||
logger := log.NewWithOptions(os.Stderr, log.Options{
|
||||
ReportCaller: true,
|
||||
ReportTimestamp: true,
|
||||
TimeFormat: time.Kitchen,
|
||||
Prefix: "Baking 🍪 "
|
||||
})
|
||||
logger.Info("Starting oven!", "degree", 375)
|
||||
time.Sleep(10 * time.Minute)
|
||||
logger.Info("Finished baking")
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="700" srcset="https://vhs.charm.sh/vhs-6oSCJcQ5EmFKKELcskJhLo.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-6oSCJcQ5EmFKKELcskJhLo.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-2X8Esd8ZsHo4DVPVgR36yx.gif"> -->
|
||||
<img width="700" src="https://vhs.charm.sh/vhs-6oSCJcQ5EmFKKELcskJhLo.gif">
|
||||
</picture>
|
||||
|
||||
You can also use logger setters to customize the logger.
|
||||
|
||||
```go
|
||||
logger := log.New(os.Stderr)
|
||||
logger.SetReportTimestamp(false)
|
||||
logger.SetReportCaller(false)
|
||||
logger.SetLevel(log.DebugLevel)
|
||||
```
|
||||
|
||||
Use `log.SetFormatter()` or `log.Options{Formatter: }` to change the output
|
||||
format. Available options are:
|
||||
|
||||
- `log.TextFormatter` (_default_)
|
||||
- `log.JSONFormatter`
|
||||
- `log.LogfmtFormatter`
|
||||
|
||||
> **Note** styling only affects the `TextFormatter`. Styling is disabled if the
|
||||
> output is not a TTY.
|
||||
|
||||
For a list of available options, refer to [options.go](./options.go).
|
||||
|
||||
### Styles
|
||||
|
||||
You can customize the logger styles using [Lipgloss][lipgloss]. The styles are
|
||||
defined at a global level in [styles.go](./styles.go).
|
||||
|
||||
```go
|
||||
// Override the default error level style.
|
||||
log.ErrorLevelStyle = lipgloss.NewStyle().
|
||||
SetString("ERROR!!").
|
||||
Padding(0, 1, 0, 1).
|
||||
Background(lipgloss.AdaptiveColor{
|
||||
Light: "203",
|
||||
Dark: "204",
|
||||
}).
|
||||
Foreground(lipgloss.Color("0"))
|
||||
// Add a custom style for key `err`
|
||||
log.KeyStyles["err"] = lipgloss.NewStyle().Foreground(lipgloss.Color("204"))
|
||||
log.ValueStyles["err"] = lipgloss.NewStyle().Bold(true)
|
||||
log.Error("Whoops!", "err", "kitchen on fire")
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="400" srcset="https://vhs.charm.sh/vhs-4LXsGvzyH4RdjJaTF4a9MG.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="400" srcset="https://vhs.charm.sh/vhs-4LXsGvzyH4RdjJaTF4a9MG.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="400" srcset="https://vhs.charm.sh/vhs-4f6qLnIfudMMLDD9sxXUrv.gif"> -->
|
||||
<img width="400" src="https://vhs.charm.sh/vhs-4LXsGvzyH4RdjJaTF4a9MG.gif">
|
||||
</picture>
|
||||
|
||||
### Sub-logger
|
||||
|
||||
Create sub-loggers with their specific fields.
|
||||
|
||||
```go
|
||||
logger := log.NewWithOptions(os.Stderr, log.Options{
|
||||
Prefix: "Baking 🍪 "
|
||||
})
|
||||
batch2 := logger.With("batch", 2, "chocolateChips", true)
|
||||
batch2.Debug("Preparing batch 2...")
|
||||
batch2.Debug("Adding chocolate chips")
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="700" srcset="https://vhs.charm.sh/vhs-1JgP5ZRL0oXVspeg50CczR.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-1JgP5ZRL0oXVspeg50CczR.gif">
|
||||
<img width="700" src="https://vhs.charm.sh/vhs-1JgP5ZRL0oXVspeg50CczR.gif">
|
||||
</picture>
|
||||
|
||||
### Format Messages
|
||||
|
||||
You can use `fmt.Sprintf()` to format messages.
|
||||
|
||||
```go
|
||||
for item := 1; i <= 100; i++ {
|
||||
log.Info(fmt.Sprintf("Baking %d/100...", item))
|
||||
}
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="500" srcset="https://vhs.charm.sh/vhs-4nX5I7qHT09aJ2gU7OaGV5.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="500" srcset="https://vhs.charm.sh/vhs-4nX5I7qHT09aJ2gU7OaGV5.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="500" srcset="https://vhs.charm.sh/vhs-4RHXd4JSucomcPqJGZTpKh.gif"> -->
|
||||
<img width="500" src="https://vhs.charm.sh/vhs-4nX5I7qHT09aJ2gU7OaGV5.gif">
|
||||
</picture>
|
||||
|
||||
Or arguments:
|
||||
|
||||
```go
|
||||
for temp := 375; temp <= 400; temp++ {
|
||||
log.Info("Increasing temperature", "degree", fmt.Sprintf("%d°F", temp))
|
||||
}
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="700" srcset="https://vhs.charm.sh/vhs-79YvXcDOsqgHte3bv42UTr.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-79YvXcDOsqgHte3bv42UTr.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-4AvAnoA2S53QTOteX8krp4.gif"> -->
|
||||
<img width="700" src="https://vhs.charm.sh/vhs-79YvXcDOsqgHte3bv42UTr.gif">
|
||||
</picture>
|
||||
|
||||
### Helper Functions
|
||||
|
||||
Skip caller frames in helper functions. Similar to what you can do with
|
||||
`testing.TB().Helper()`.
|
||||
|
||||
```go
|
||||
function startOven(degree int) {
|
||||
log.Helper()
|
||||
log.Info("Starting oven", "degree", degree)
|
||||
}
|
||||
|
||||
log.SetReportCaller(true)
|
||||
startOven(400) // INFO <cookies/oven.go:123> Starting oven degree=400
|
||||
```
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" width="700" srcset="https://vhs.charm.sh/vhs-6CeQGIV8Ovgr8GD0N6NgTq.gif">
|
||||
<source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-6CeQGIV8Ovgr8GD0N6NgTq.gif">
|
||||
<!-- <source media="(prefers-color-scheme: light)" width="700" srcset="https://vhs.charm.sh/vhs-6DPg0bVL4K4TkfoHkAn2ap.gif"> -->
|
||||
<img width="700" src="https://vhs.charm.sh/vhs-6CeQGIV8Ovgr8GD0N6NgTq.gif">
|
||||
</picture>
|
||||
|
||||
This will use the _caller_ function (`startOven`) line number instead of the
|
||||
logging function (`log.Info`) to report the source location.
|
||||
|
||||
### Slog Handler
|
||||
|
||||
You can use Log as an [`log/slog`](https://pkg.go.dev/log/slog) handler. Just
|
||||
pass a logger instance to Slog and you're good to go.
|
||||
|
||||
```go
|
||||
handler := log.New(os.Stderr)
|
||||
logger := slog.New(handler)
|
||||
logger.Error("meow?")
|
||||
```
|
||||
|
||||
### Standard Log Adapter
|
||||
|
||||
Some Go libraries, especially the ones in the standard library, will only accept
|
||||
the [standard logger][stdlog] interface. For instance, the HTTP Server from
|
||||
`net/http` will only take a `*log.Logger` for its `ErrorLog` field.
|
||||
|
||||
For this, you can use the standard log adapter, which simply wraps the logger in
|
||||
a `*log.Logger` interface.
|
||||
|
||||
```go
|
||||
logger := log.NewWithOptions(os.Stderr, log.Options{Prefix: "http"})
|
||||
stdlog := logger.StandardLog(log.StandardLogOptions{
|
||||
ForceLevel: log.ErrorLevel,
|
||||
})
|
||||
s := &http.Server{
|
||||
Addr: ":8080",
|
||||
Handler: handler,
|
||||
ErrorLog: stdlog,
|
||||
}
|
||||
stdlog.Printf("Failed to make bake request, %s", fmt.Errorf("temperature is too low"))
|
||||
// ERROR http: Failed to make bake request, temperature is too low
|
||||
```
|
||||
|
||||
[lipgloss]: https://github.com/charmbracelet/lipgloss
|
||||
[stdlog]: https://pkg.go.dev/log
|
||||
|
||||
## License
|
||||
|
||||
[MIT](https://github.com/charmbracelet/log/raw/master/LICENSE)
|
||||
|
||||
---
|
||||
|
||||
Part of [Charm](https://charm.sh).
|
||||
|
||||
<a href="https://charm.sh/"><img alt="the Charm logo" src="https://stuff.charm.sh/charm-badge.jpg" width="400"></a>
|
||||
|
||||
Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
package log
|
||||
|
||||
import "context"
|
||||
|
||||
// WithContext wraps the given logger in context.
|
||||
func WithContext(ctx context.Context, logger *Logger) context.Context {
|
||||
return context.WithValue(ctx, ContextKey, logger)
|
||||
}
|
||||
|
||||
// FromContext returns the logger from the given context.
|
||||
// This will return the default package logger if no logger
|
||||
// found in context.
|
||||
func FromContext(ctx context.Context) *Logger {
|
||||
if logger, ok := ctx.Value(ContextKey).(*Logger); ok {
|
||||
return logger
|
||||
}
|
||||
return defaultLogger
|
||||
}
|
||||
|
||||
type contextKey struct{ string }
|
||||
|
||||
// ContextKey is the key used to store the logger in context.
|
||||
var ContextKey = contextKey{"log"}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
package log
|
||||
|
||||
// Formatter is a formatter for log messages.
|
||||
type Formatter uint8
|
||||
|
||||
const (
|
||||
// TextFormatter is a formatter that formats log messages as text. Suitable for
|
||||
// console output and log files.
|
||||
TextFormatter Formatter = iota
|
||||
// JSONFormatter is a formatter that formats log messages as JSON.
|
||||
JSONFormatter
|
||||
// LogfmtFormatter is a formatter that formats log messages as logfmt.
|
||||
LogfmtFormatter
|
||||
)
|
||||
|
||||
var (
|
||||
// TimestampKey is the key for the timestamp.
|
||||
TimestampKey = "time"
|
||||
// MessageKey is the key for the message.
|
||||
MessageKey = "msg"
|
||||
// LevelKey is the key for the level.
|
||||
LevelKey = "level"
|
||||
// CallerKey is the key for the caller.
|
||||
CallerKey = "caller"
|
||||
// PrefixKey is the key for the prefix.
|
||||
PrefixKey = "prefix"
|
||||
)
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func (l *Logger) jsonFormatter(keyvals ...interface{}) {
|
||||
m := make(map[string]interface{}, len(keyvals)/2)
|
||||
for i := 0; i < len(keyvals); i += 2 {
|
||||
switch keyvals[i] {
|
||||
case TimestampKey:
|
||||
if t, ok := keyvals[i+1].(time.Time); ok {
|
||||
m[TimestampKey] = t.Format(l.timeFormat)
|
||||
}
|
||||
case LevelKey:
|
||||
if level, ok := keyvals[i+1].(Level); ok {
|
||||
m[LevelKey] = level.String()
|
||||
}
|
||||
case CallerKey:
|
||||
if caller, ok := keyvals[i+1].(string); ok {
|
||||
m[CallerKey] = caller
|
||||
}
|
||||
case PrefixKey:
|
||||
if prefix, ok := keyvals[i+1].(string); ok {
|
||||
m[PrefixKey] = prefix
|
||||
}
|
||||
case MessageKey:
|
||||
if msg := keyvals[i+1]; msg != nil {
|
||||
m[MessageKey] = fmt.Sprint(msg)
|
||||
}
|
||||
default:
|
||||
var (
|
||||
key string
|
||||
val interface{}
|
||||
)
|
||||
switch k := keyvals[i].(type) {
|
||||
case fmt.Stringer:
|
||||
key = k.String()
|
||||
case error:
|
||||
key = k.Error()
|
||||
default:
|
||||
key = fmt.Sprint(k)
|
||||
}
|
||||
switch v := keyvals[i+1].(type) {
|
||||
case error:
|
||||
val = v.Error()
|
||||
case fmt.Stringer:
|
||||
val = v.String()
|
||||
default:
|
||||
val = v
|
||||
}
|
||||
m[key] = val
|
||||
}
|
||||
}
|
||||
|
||||
e := json.NewEncoder(&l.b)
|
||||
e.SetEscapeHTML(false)
|
||||
_ = e.Encode(m)
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Level is a logging level.
|
||||
type Level int32
|
||||
|
||||
const (
|
||||
// DebugLevel is the debug level.
|
||||
DebugLevel Level = -4
|
||||
// InfoLevel is the info level.
|
||||
InfoLevel Level = 0
|
||||
// WarnLevel is the warn level.
|
||||
WarnLevel Level = 4
|
||||
// ErrorLevel is the error level.
|
||||
ErrorLevel Level = 8
|
||||
// FatalLevel is the fatal level.
|
||||
FatalLevel Level = 12
|
||||
// noLevel is used with log.Print.
|
||||
noLevel Level = math.MaxInt32
|
||||
)
|
||||
|
||||
// String returns the string representation of the level.
|
||||
func (l Level) String() string {
|
||||
switch l {
|
||||
case DebugLevel:
|
||||
return "debug"
|
||||
case InfoLevel:
|
||||
return "info"
|
||||
case WarnLevel:
|
||||
return "warn"
|
||||
case ErrorLevel:
|
||||
return "error"
|
||||
case FatalLevel:
|
||||
return "fatal"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
// ErrInvalidLevel is an error returned when parsing an invalid level string.
|
||||
var ErrInvalidLevel = errors.New("invalid level")
|
||||
|
||||
// ParseLevel converts level in string to Level type. Default level is InfoLevel.
|
||||
func ParseLevel(level string) (Level, error) {
|
||||
switch strings.ToLower(level) {
|
||||
case DebugLevel.String():
|
||||
return DebugLevel, nil
|
||||
case InfoLevel.String():
|
||||
return InfoLevel, nil
|
||||
case WarnLevel.String():
|
||||
return WarnLevel, nil
|
||||
case ErrorLevel.String():
|
||||
return ErrorLevel, nil
|
||||
case FatalLevel.String():
|
||||
return FatalLevel, nil
|
||||
default:
|
||||
return 0, fmt.Errorf("%w: %q", ErrInvalidLevel, level)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
//go:build go1.21
|
||||
// +build go1.21
|
||||
|
||||
package log
|
||||
|
||||
import "log/slog"
|
||||
|
||||
// fromSlogLevel converts slog.Level to log.Level.
|
||||
var fromSlogLevel = map[slog.Level]Level{
|
||||
slog.LevelDebug: DebugLevel,
|
||||
slog.LevelInfo: InfoLevel,
|
||||
slog.LevelWarn: WarnLevel,
|
||||
slog.LevelError: ErrorLevel,
|
||||
slog.Level(12): FatalLevel,
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
//go:build !go1.21
|
||||
// +build !go1.21
|
||||
|
||||
package log
|
||||
|
||||
import "golang.org/x/exp/slog"
|
||||
|
||||
// fromSlogLevel converts slog.Level to log.Level.
|
||||
var fromSlogLevel = map[slog.Level]Level{
|
||||
slog.LevelDebug: DebugLevel,
|
||||
slog.LevelInfo: InfoLevel,
|
||||
slog.LevelWarn: WarnLevel,
|
||||
slog.LevelError: ErrorLevel,
|
||||
slog.Level(12): FatalLevel,
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/go-logfmt/logfmt"
|
||||
)
|
||||
|
||||
func (l *Logger) logfmtFormatter(keyvals ...interface{}) {
|
||||
e := logfmt.NewEncoder(&l.b)
|
||||
|
||||
for i := 0; i < len(keyvals); i += 2 {
|
||||
switch keyvals[i] {
|
||||
case TimestampKey:
|
||||
if t, ok := keyvals[i+1].(time.Time); ok {
|
||||
keyvals[i+1] = t.Format(l.timeFormat)
|
||||
}
|
||||
default:
|
||||
if key := fmt.Sprint(keyvals[i]); key != "" {
|
||||
keyvals[i] = key
|
||||
}
|
||||
}
|
||||
err := e.EncodeKeyval(keyvals[i], keyvals[i+1])
|
||||
if err != nil && errors.Is(err, logfmt.ErrUnsupportedValueType) {
|
||||
// If the value is not supported by logfmt, we try to convert it to a string.
|
||||
_ = e.EncodeKeyval(keyvals[i], fmt.Sprintf("%+v", keyvals[i+1]))
|
||||
}
|
||||
}
|
||||
_ = e.EndRecord()
|
||||
}
|
||||
|
|
@ -0,0 +1,404 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrMissingValue is returned when a key is missing a value.
|
||||
ErrMissingValue = fmt.Errorf("missing value")
|
||||
)
|
||||
|
||||
// LoggerOption is an option for a logger.
|
||||
type LoggerOption = func(*Logger)
|
||||
|
||||
// Logger is a Logger that implements Logger.
|
||||
type Logger struct {
|
||||
w io.Writer
|
||||
b bytes.Buffer
|
||||
mu *sync.RWMutex
|
||||
re *lipgloss.Renderer
|
||||
|
||||
isDiscard uint32
|
||||
|
||||
level int32
|
||||
prefix string
|
||||
timeFunc TimeFunction
|
||||
timeFormat string
|
||||
callerOffset int
|
||||
callerFormatter CallerFormatter
|
||||
formatter Formatter
|
||||
|
||||
reportCaller bool
|
||||
reportTimestamp bool
|
||||
|
||||
fields []interface{}
|
||||
|
||||
helpers *sync.Map
|
||||
styles *Styles
|
||||
}
|
||||
|
||||
func (l *Logger) log(level Level, msg interface{}, keyvals ...interface{}) {
|
||||
if atomic.LoadUint32(&l.isDiscard) != 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// check if the level is allowed
|
||||
if atomic.LoadInt32(&l.level) > int32(level) {
|
||||
return
|
||||
}
|
||||
|
||||
var frame runtime.Frame
|
||||
if l.reportCaller {
|
||||
// Skip log.log, the caller, and any offset added.
|
||||
frames := l.frames(l.callerOffset + 2)
|
||||
for {
|
||||
f, more := frames.Next()
|
||||
_, helper := l.helpers.Load(f.Function)
|
||||
if !helper || !more {
|
||||
// Found a frame that wasn't a helper function.
|
||||
// Or we ran out of frames to check.
|
||||
frame = f
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
l.handle(level, l.timeFunc(), []runtime.Frame{frame}, msg, keyvals...)
|
||||
}
|
||||
|
||||
func (l *Logger) handle(level Level, ts time.Time, frames []runtime.Frame, msg interface{}, keyvals ...interface{}) {
|
||||
var kvs []interface{}
|
||||
if l.reportTimestamp && !ts.IsZero() {
|
||||
kvs = append(kvs, TimestampKey, ts)
|
||||
}
|
||||
|
||||
if level != noLevel {
|
||||
kvs = append(kvs, LevelKey, level)
|
||||
}
|
||||
|
||||
if l.reportCaller && len(frames) > 0 && frames[0].PC != 0 {
|
||||
file, line, fn := l.location(frames)
|
||||
if file != "" {
|
||||
caller := l.callerFormatter(file, line, fn)
|
||||
kvs = append(kvs, CallerKey, caller)
|
||||
}
|
||||
}
|
||||
|
||||
if l.prefix != "" {
|
||||
kvs = append(kvs, PrefixKey, l.prefix)
|
||||
}
|
||||
|
||||
if msg != nil {
|
||||
if m := fmt.Sprint(msg); m != "" {
|
||||
kvs = append(kvs, MessageKey, m)
|
||||
}
|
||||
}
|
||||
|
||||
// append logger fields
|
||||
kvs = append(kvs, l.fields...)
|
||||
if len(l.fields)%2 != 0 {
|
||||
kvs = append(kvs, ErrMissingValue)
|
||||
}
|
||||
|
||||
// append the rest
|
||||
kvs = append(kvs, keyvals...)
|
||||
if len(keyvals)%2 != 0 {
|
||||
kvs = append(kvs, ErrMissingValue)
|
||||
}
|
||||
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
switch l.formatter {
|
||||
case LogfmtFormatter:
|
||||
l.logfmtFormatter(kvs...)
|
||||
case JSONFormatter:
|
||||
l.jsonFormatter(kvs...)
|
||||
default:
|
||||
l.textFormatter(kvs...)
|
||||
}
|
||||
|
||||
// WriteTo will reset the buffer
|
||||
l.b.WriteTo(l.w) //nolint: errcheck
|
||||
}
|
||||
|
||||
// Helper marks the calling function as a helper
|
||||
// and skips it for source location information.
|
||||
// It's the equivalent of testing.TB.Helper().
|
||||
func (l *Logger) Helper() {
|
||||
l.helper(1)
|
||||
}
|
||||
|
||||
func (l *Logger) helper(skip int) {
|
||||
var pcs [1]uintptr
|
||||
// Skip runtime.Callers, and l.helper
|
||||
n := runtime.Callers(skip+2, pcs[:])
|
||||
frames := runtime.CallersFrames(pcs[:n])
|
||||
frame, _ := frames.Next()
|
||||
l.helpers.LoadOrStore(frame.Function, struct{}{})
|
||||
}
|
||||
|
||||
// frames returns the runtime.Frames for the caller.
|
||||
func (l *Logger) frames(skip int) *runtime.Frames {
|
||||
// Copied from testing.T
|
||||
const maxStackLen = 50
|
||||
var pc [maxStackLen]uintptr
|
||||
|
||||
// Skip runtime.Callers, and l.frame
|
||||
n := runtime.Callers(skip+2, pc[:])
|
||||
frames := runtime.CallersFrames(pc[:n])
|
||||
return frames
|
||||
}
|
||||
|
||||
func (l *Logger) location(frames []runtime.Frame) (file string, line int, fn string) {
|
||||
if len(frames) == 0 {
|
||||
return "", 0, ""
|
||||
}
|
||||
f := frames[0]
|
||||
return f.File, f.Line, f.Function
|
||||
}
|
||||
|
||||
// Cleanup a path by returning the last n segments of the path only.
|
||||
func trimCallerPath(path string, n int) string {
|
||||
// lovely borrowed from zap
|
||||
// nb. To make sure we trim the path correctly on Windows too, we
|
||||
// counter-intuitively need to use '/' and *not* os.PathSeparator here,
|
||||
// because the path given originates from Go stdlib, specifically
|
||||
// runtime.Caller() which (as of Mar/17) returns forward slashes even on
|
||||
// Windows.
|
||||
//
|
||||
// See https://github.com/golang/go/issues/3335
|
||||
// and https://github.com/golang/go/issues/18151
|
||||
//
|
||||
// for discussion on the issue on Go side.
|
||||
|
||||
// Return the full path if n is 0.
|
||||
if n <= 0 {
|
||||
return path
|
||||
}
|
||||
|
||||
// Find the last separator.
|
||||
idx := strings.LastIndexByte(path, '/')
|
||||
if idx == -1 {
|
||||
return path
|
||||
}
|
||||
|
||||
for i := 0; i < n-1; i++ {
|
||||
// Find the penultimate separator.
|
||||
idx = strings.LastIndexByte(path[:idx], '/')
|
||||
if idx == -1 {
|
||||
return path
|
||||
}
|
||||
}
|
||||
|
||||
return path[idx+1:]
|
||||
}
|
||||
|
||||
// SetReportTimestamp sets whether the timestamp should be reported.
|
||||
func (l *Logger) SetReportTimestamp(report bool) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.reportTimestamp = report
|
||||
}
|
||||
|
||||
// SetReportCaller sets whether the caller location should be reported.
|
||||
func (l *Logger) SetReportCaller(report bool) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.reportCaller = report
|
||||
}
|
||||
|
||||
// GetLevel returns the current level.
|
||||
func (l *Logger) GetLevel() Level {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
return Level(l.level)
|
||||
}
|
||||
|
||||
// SetLevel sets the current level.
|
||||
func (l *Logger) SetLevel(level Level) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
atomic.StoreInt32(&l.level, int32(level))
|
||||
}
|
||||
|
||||
// GetPrefix returns the current prefix.
|
||||
func (l *Logger) GetPrefix() string {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
return l.prefix
|
||||
}
|
||||
|
||||
// SetPrefix sets the current prefix.
|
||||
func (l *Logger) SetPrefix(prefix string) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.prefix = prefix
|
||||
}
|
||||
|
||||
// SetTimeFormat sets the time format.
|
||||
func (l *Logger) SetTimeFormat(format string) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.timeFormat = format
|
||||
}
|
||||
|
||||
// SetTimeFunction sets the time function.
|
||||
func (l *Logger) SetTimeFunction(f TimeFunction) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.timeFunc = f
|
||||
}
|
||||
|
||||
// SetOutput sets the output destination.
|
||||
func (l *Logger) SetOutput(w io.Writer) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if w == nil {
|
||||
w = os.Stderr
|
||||
}
|
||||
l.w = w
|
||||
var isDiscard uint32
|
||||
if w == io.Discard {
|
||||
isDiscard = 1
|
||||
}
|
||||
atomic.StoreUint32(&l.isDiscard, isDiscard)
|
||||
// Reuse cached renderers
|
||||
if v, ok := registry.Load(w); ok {
|
||||
l.re = v.(*lipgloss.Renderer)
|
||||
} else {
|
||||
l.re = lipgloss.NewRenderer(w, termenv.WithColorCache(true))
|
||||
registry.Store(w, l.re)
|
||||
}
|
||||
}
|
||||
|
||||
// SetFormatter sets the formatter.
|
||||
func (l *Logger) SetFormatter(f Formatter) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.formatter = f
|
||||
}
|
||||
|
||||
// SetCallerFormatter sets the caller formatter.
|
||||
func (l *Logger) SetCallerFormatter(f CallerFormatter) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.callerFormatter = f
|
||||
}
|
||||
|
||||
// SetCallerOffset sets the caller offset.
|
||||
func (l *Logger) SetCallerOffset(offset int) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.callerOffset = offset
|
||||
}
|
||||
|
||||
// SetColorProfile force sets the underlying Lip Gloss renderer color profile
|
||||
// for the TextFormatter.
|
||||
func (l *Logger) SetColorProfile(profile termenv.Profile) {
|
||||
l.re.SetColorProfile(profile)
|
||||
}
|
||||
|
||||
// SetStyles sets the logger styles for the TextFormatter.
|
||||
func (l *Logger) SetStyles(s *Styles) {
|
||||
if s == nil {
|
||||
s = DefaultStyles()
|
||||
}
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.styles = s
|
||||
}
|
||||
|
||||
// With returns a new logger with the given keyvals added.
|
||||
func (l *Logger) With(keyvals ...interface{}) *Logger {
|
||||
var st Styles
|
||||
l.mu.Lock()
|
||||
sl := *l
|
||||
st = *l.styles
|
||||
l.mu.Unlock()
|
||||
sl.b = bytes.Buffer{}
|
||||
sl.mu = &sync.RWMutex{}
|
||||
sl.helpers = &sync.Map{}
|
||||
sl.fields = append(l.fields, keyvals...)
|
||||
sl.styles = &st
|
||||
return &sl
|
||||
}
|
||||
|
||||
// WithPrefix returns a new logger with the given prefix.
|
||||
func (l *Logger) WithPrefix(prefix string) *Logger {
|
||||
sl := l.With()
|
||||
sl.SetPrefix(prefix)
|
||||
return sl
|
||||
}
|
||||
|
||||
// Debug prints a debug message.
|
||||
func (l *Logger) Debug(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(DebugLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Info prints an info message.
|
||||
func (l *Logger) Info(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(InfoLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Warn prints a warning message.
|
||||
func (l *Logger) Warn(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(WarnLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Error prints an error message.
|
||||
func (l *Logger) Error(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(ErrorLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Fatal prints a fatal message and exits.
|
||||
func (l *Logger) Fatal(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(FatalLevel, msg, keyvals...)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Print prints a message with no level.
|
||||
func (l *Logger) Print(msg interface{}, keyvals ...interface{}) {
|
||||
l.log(noLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Debugf prints a debug message with formatting.
|
||||
func (l *Logger) Debugf(format string, args ...interface{}) {
|
||||
l.log(DebugLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Infof prints an info message with formatting.
|
||||
func (l *Logger) Infof(format string, args ...interface{}) {
|
||||
l.log(InfoLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Warnf prints a warning message with formatting.
|
||||
func (l *Logger) Warnf(format string, args ...interface{}) {
|
||||
l.log(WarnLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Errorf prints an error message with formatting.
|
||||
func (l *Logger) Errorf(format string, args ...interface{}) {
|
||||
l.log(ErrorLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Fatalf prints a fatal message with formatting and exits.
|
||||
func (l *Logger) Fatalf(format string, args ...interface{}) {
|
||||
l.log(FatalLevel, fmt.Sprintf(format, args...))
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Printf prints a message with no level and formatting.
|
||||
func (l *Logger) Printf(format string, args ...interface{}) {
|
||||
l.log(noLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
//go:build go1.21
|
||||
// +build go1.21
|
||||
|
||||
package log
|
||||
|
||||
import (
|
||||
"context"
|
||||
"runtime"
|
||||
"sync/atomic"
|
||||
|
||||
"log/slog"
|
||||
)
|
||||
|
||||
// Enabled reports whether the logger is enabled for the given level.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) Enabled(_ context.Context, level slog.Level) bool {
|
||||
return atomic.LoadInt32(&l.level) <= int32(fromSlogLevel[level])
|
||||
}
|
||||
|
||||
// Handle handles the Record. It will only be called if Enabled returns true.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) Handle(_ context.Context, record slog.Record) error {
|
||||
fields := make([]interface{}, 0, record.NumAttrs()*2)
|
||||
record.Attrs(func(a slog.Attr) bool {
|
||||
fields = append(fields, a.Key, a.Value.String())
|
||||
return true
|
||||
})
|
||||
// Get the caller frame using the record's PC.
|
||||
frames := runtime.CallersFrames([]uintptr{record.PC})
|
||||
frame, _ := frames.Next()
|
||||
l.handle(fromSlogLevel[record.Level], record.Time, []runtime.Frame{frame}, record.Message, fields...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// WithAttrs returns a new Handler with the given attributes added.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) WithAttrs(attrs []slog.Attr) slog.Handler {
|
||||
fields := make([]interface{}, 0, len(attrs)*2)
|
||||
for _, attr := range attrs {
|
||||
fields = append(fields, attr.Key, attr.Value)
|
||||
}
|
||||
return l.With(fields...)
|
||||
}
|
||||
|
||||
// WithGroup returns a new Handler with the given group name prepended to the
|
||||
// current group name or prefix.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) WithGroup(name string) slog.Handler {
|
||||
if l.prefix != "" {
|
||||
name = l.prefix + "." + name
|
||||
}
|
||||
return l.WithPrefix(name)
|
||||
}
|
||||
|
||||
var _ slog.Handler = (*Logger)(nil)
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
//go:build !go1.21
|
||||
// +build !go1.21
|
||||
|
||||
package log
|
||||
|
||||
import (
|
||||
"context"
|
||||
"runtime"
|
||||
"sync/atomic"
|
||||
|
||||
"golang.org/x/exp/slog"
|
||||
)
|
||||
|
||||
// Enabled reports whether the logger is enabled for the given level.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) Enabled(_ context.Context, level slog.Level) bool {
|
||||
return atomic.LoadInt32(&l.level) <= int32(fromSlogLevel[level])
|
||||
}
|
||||
|
||||
// Handle handles the Record. It will only be called if Enabled returns true.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) Handle(_ context.Context, record slog.Record) error {
|
||||
fields := make([]interface{}, 0, record.NumAttrs()*2)
|
||||
record.Attrs(func(a slog.Attr) bool {
|
||||
fields = append(fields, a.Key, a.Value.String())
|
||||
return true
|
||||
})
|
||||
// Get the caller frame using the record's PC.
|
||||
frames := runtime.CallersFrames([]uintptr{record.PC})
|
||||
frame, _ := frames.Next()
|
||||
l.handle(fromSlogLevel[record.Level], record.Time, []runtime.Frame{frame}, record.Message, fields...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// WithAttrs returns a new Handler with the given attributes added.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) WithAttrs(attrs []slog.Attr) slog.Handler {
|
||||
fields := make([]interface{}, 0, len(attrs)*2)
|
||||
for _, attr := range attrs {
|
||||
fields = append(fields, attr.Key, attr.Value)
|
||||
}
|
||||
return l.With(fields...)
|
||||
}
|
||||
|
||||
// WithGroup returns a new Handler with the given group name prepended to the
|
||||
// current group name or prefix.
|
||||
//
|
||||
// Implements slog.Handler.
|
||||
func (l *Logger) WithGroup(name string) slog.Handler {
|
||||
if l.prefix != "" {
|
||||
name = l.prefix + "." + name
|
||||
}
|
||||
return l.WithPrefix(name)
|
||||
}
|
||||
|
||||
var _ slog.Handler = (*Logger)(nil)
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// DefaultTimeFormat is the default time format.
|
||||
const DefaultTimeFormat = "2006/01/02 15:04:05"
|
||||
|
||||
// TimeFunction is a function that returns a time.Time.
|
||||
type TimeFunction = func() time.Time
|
||||
|
||||
// NowUTC is a convenient function that returns the
|
||||
// current time in UTC timezone.
|
||||
//
|
||||
// This is to be used as a time function.
|
||||
// For example:
|
||||
//
|
||||
// log.SetTimeFunction(log.NowUTC)
|
||||
func NowUTC() time.Time {
|
||||
return time.Now().UTC()
|
||||
}
|
||||
|
||||
// CallerFormatter is the caller formatter.
|
||||
type CallerFormatter func(string, int, string) string
|
||||
|
||||
// ShortCallerFormatter is a caller formatter that returns the last 2 levels of the path
|
||||
// and line number.
|
||||
func ShortCallerFormatter(file string, line int, _ string) string {
|
||||
return fmt.Sprintf("%s:%d", trimCallerPath(file, 2), line)
|
||||
}
|
||||
|
||||
// LongCallerFormatter is a caller formatter that returns the full path and line number.
|
||||
func LongCallerFormatter(file string, line int, _ string) string {
|
||||
return fmt.Sprintf("%s:%d", file, line)
|
||||
}
|
||||
|
||||
// Options is the options for the logger.
|
||||
type Options struct {
|
||||
// TimeFunction is the time function for the logger. The default is time.Now.
|
||||
TimeFunction TimeFunction
|
||||
// TimeFormat is the time format for the logger. The default is "2006/01/02 15:04:05".
|
||||
TimeFormat string
|
||||
// Level is the level for the logger. The default is InfoLevel.
|
||||
Level Level
|
||||
// Prefix is the prefix for the logger. The default is no prefix.
|
||||
Prefix string
|
||||
// ReportTimestamp is whether the logger should report the timestamp. The default is false.
|
||||
ReportTimestamp bool
|
||||
// ReportCaller is whether the logger should report the caller location. The default is false.
|
||||
ReportCaller bool
|
||||
// CallerFormatter is the caller format for the logger. The default is CallerShort.
|
||||
CallerFormatter CallerFormatter
|
||||
// CallerOffset is the caller format for the logger. The default is 0.
|
||||
CallerOffset int
|
||||
// Fields is the fields for the logger. The default is no fields.
|
||||
Fields []interface{}
|
||||
// Formatter is the formatter for the logger. The default is TextFormatter.
|
||||
Formatter Formatter
|
||||
}
|
||||
|
|
@ -0,0 +1,228 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/muesli/termenv"
|
||||
)
|
||||
|
||||
var (
|
||||
// registry is a map of all registered lipgloss renderers.
|
||||
registry = sync.Map{}
|
||||
|
||||
// defaultLogger is the default global logger instance.
|
||||
defaultLogger = NewWithOptions(os.Stderr, Options{ReportTimestamp: true})
|
||||
)
|
||||
|
||||
// Default returns the default logger. The default logger comes with timestamp enabled.
|
||||
func Default() *Logger {
|
||||
return defaultLogger
|
||||
}
|
||||
|
||||
// SetDefault sets the default global logger.
|
||||
func SetDefault(logger *Logger) {
|
||||
defaultLogger = logger
|
||||
}
|
||||
|
||||
// New returns a new logger with the default options.
|
||||
func New(w io.Writer) *Logger {
|
||||
return NewWithOptions(w, Options{})
|
||||
}
|
||||
|
||||
// NewWithOptions returns a new logger using the provided options.
|
||||
func NewWithOptions(w io.Writer, o Options) *Logger {
|
||||
l := &Logger{
|
||||
b: bytes.Buffer{},
|
||||
mu: &sync.RWMutex{},
|
||||
helpers: &sync.Map{},
|
||||
level: int32(o.Level),
|
||||
reportTimestamp: o.ReportTimestamp,
|
||||
reportCaller: o.ReportCaller,
|
||||
prefix: o.Prefix,
|
||||
timeFunc: o.TimeFunction,
|
||||
timeFormat: o.TimeFormat,
|
||||
formatter: o.Formatter,
|
||||
fields: o.Fields,
|
||||
callerFormatter: o.CallerFormatter,
|
||||
callerOffset: o.CallerOffset,
|
||||
}
|
||||
|
||||
l.SetOutput(w)
|
||||
l.SetLevel(Level(l.level))
|
||||
l.SetStyles(DefaultStyles())
|
||||
|
||||
if l.callerFormatter == nil {
|
||||
l.callerFormatter = ShortCallerFormatter
|
||||
}
|
||||
|
||||
if l.timeFunc == nil {
|
||||
l.timeFunc = time.Now
|
||||
}
|
||||
|
||||
if l.timeFormat == "" {
|
||||
l.timeFormat = DefaultTimeFormat
|
||||
}
|
||||
|
||||
return l
|
||||
}
|
||||
|
||||
// SetReportTimestamp sets whether to report timestamp for the default logger.
|
||||
func SetReportTimestamp(report bool) {
|
||||
defaultLogger.SetReportTimestamp(report)
|
||||
}
|
||||
|
||||
// SetReportCaller sets whether to report caller location for the default logger.
|
||||
func SetReportCaller(report bool) {
|
||||
defaultLogger.SetReportCaller(report)
|
||||
}
|
||||
|
||||
// SetLevel sets the level for the default logger.
|
||||
func SetLevel(level Level) {
|
||||
defaultLogger.SetLevel(level)
|
||||
}
|
||||
|
||||
// GetLevel returns the level for the default logger.
|
||||
func GetLevel() Level {
|
||||
return defaultLogger.GetLevel()
|
||||
}
|
||||
|
||||
// SetTimeFormat sets the time format for the default logger.
|
||||
func SetTimeFormat(format string) {
|
||||
defaultLogger.SetTimeFormat(format)
|
||||
}
|
||||
|
||||
// SetTimeFunction sets the time function for the default logger.
|
||||
func SetTimeFunction(f TimeFunction) {
|
||||
defaultLogger.SetTimeFunction(f)
|
||||
}
|
||||
|
||||
// SetOutput sets the output for the default logger.
|
||||
func SetOutput(w io.Writer) {
|
||||
defaultLogger.SetOutput(w)
|
||||
}
|
||||
|
||||
// SetFormatter sets the formatter for the default logger.
|
||||
func SetFormatter(f Formatter) {
|
||||
defaultLogger.SetFormatter(f)
|
||||
}
|
||||
|
||||
// SetCallerFormatter sets the caller formatter for the default logger.
|
||||
func SetCallerFormatter(f CallerFormatter) {
|
||||
defaultLogger.SetCallerFormatter(f)
|
||||
}
|
||||
|
||||
// SetCallerOffset sets the caller offset for the default logger.
|
||||
func SetCallerOffset(offset int) {
|
||||
defaultLogger.SetCallerOffset(offset)
|
||||
}
|
||||
|
||||
// SetPrefix sets the prefix for the default logger.
|
||||
func SetPrefix(prefix string) {
|
||||
defaultLogger.SetPrefix(prefix)
|
||||
}
|
||||
|
||||
// SetColorProfile force sets the underlying Lip Gloss renderer color profile
|
||||
// for the TextFormatter.
|
||||
func SetColorProfile(profile termenv.Profile) {
|
||||
defaultLogger.SetColorProfile(profile)
|
||||
}
|
||||
|
||||
// SetStyles sets the logger styles for the TextFormatter.
|
||||
func SetStyles(s *Styles) {
|
||||
defaultLogger.SetStyles(s)
|
||||
}
|
||||
|
||||
// GetPrefix returns the prefix for the default logger.
|
||||
func GetPrefix() string {
|
||||
return defaultLogger.GetPrefix()
|
||||
}
|
||||
|
||||
// With returns a new logger with the given keyvals.
|
||||
func With(keyvals ...interface{}) *Logger {
|
||||
return defaultLogger.With(keyvals...)
|
||||
}
|
||||
|
||||
// WithPrefix returns a new logger with the given prefix.
|
||||
func WithPrefix(prefix string) *Logger {
|
||||
return defaultLogger.WithPrefix(prefix)
|
||||
}
|
||||
|
||||
// Helper marks the calling function as a helper
|
||||
// and skips it for source location information.
|
||||
// It's the equivalent of testing.TB.Helper().
|
||||
func Helper() {
|
||||
defaultLogger.helper(1)
|
||||
}
|
||||
|
||||
// Debug logs a debug message.
|
||||
func Debug(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(DebugLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Info logs an info message.
|
||||
func Info(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(InfoLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Warn logs a warning message.
|
||||
func Warn(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(WarnLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Error logs an error message.
|
||||
func Error(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(ErrorLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Fatal logs a fatal message and exit.
|
||||
func Fatal(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(FatalLevel, msg, keyvals...)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Print logs a message with no level.
|
||||
func Print(msg interface{}, keyvals ...interface{}) {
|
||||
defaultLogger.log(noLevel, msg, keyvals...)
|
||||
}
|
||||
|
||||
// Debugf logs a debug message with formatting.
|
||||
func Debugf(format string, args ...interface{}) {
|
||||
defaultLogger.log(DebugLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Infof logs an info message with formatting.
|
||||
func Infof(format string, args ...interface{}) {
|
||||
defaultLogger.log(InfoLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Warnf logs a warning message with formatting.
|
||||
func Warnf(format string, args ...interface{}) {
|
||||
defaultLogger.log(WarnLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Errorf logs an error message with formatting.
|
||||
func Errorf(format string, args ...interface{}) {
|
||||
defaultLogger.log(ErrorLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// Fatalf logs a fatal message with formatting and exit.
|
||||
func Fatalf(format string, args ...interface{}) {
|
||||
defaultLogger.log(FatalLevel, fmt.Sprintf(format, args...))
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Printf logs a message with formatting and no level.
|
||||
func Printf(format string, args ...interface{}) {
|
||||
defaultLogger.log(noLevel, fmt.Sprintf(format, args...))
|
||||
}
|
||||
|
||||
// StandardLog returns a standard logger from the default logger.
|
||||
func StandardLog(opts ...StandardLogOptions) *log.Logger {
|
||||
return defaultLogger.StandardLog(opts...)
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"log"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type stdLogWriter struct {
|
||||
l *Logger
|
||||
opt *StandardLogOptions
|
||||
}
|
||||
|
||||
func (l *stdLogWriter) Write(p []byte) (n int, err error) {
|
||||
str := strings.TrimSuffix(string(p), "\n")
|
||||
|
||||
if l.opt != nil {
|
||||
switch l.opt.ForceLevel {
|
||||
case DebugLevel:
|
||||
l.l.Debug(str)
|
||||
case InfoLevel:
|
||||
l.l.Info(str)
|
||||
case WarnLevel:
|
||||
l.l.Warn(str)
|
||||
case ErrorLevel:
|
||||
l.l.Error(str)
|
||||
}
|
||||
} else {
|
||||
switch {
|
||||
case strings.HasPrefix(str, "DEBUG"):
|
||||
l.l.Debug(strings.TrimSpace(str[5:]))
|
||||
case strings.HasPrefix(str, "INFO"):
|
||||
l.l.Info(strings.TrimSpace(str[4:]))
|
||||
case strings.HasPrefix(str, "WARN"):
|
||||
l.l.Warn(strings.TrimSpace(str[4:]))
|
||||
case strings.HasPrefix(str, "ERROR"):
|
||||
l.l.Error(strings.TrimSpace(str[5:]))
|
||||
case strings.HasPrefix(str, "ERR"):
|
||||
l.l.Error(strings.TrimSpace(str[3:]))
|
||||
default:
|
||||
l.l.Info(str)
|
||||
}
|
||||
}
|
||||
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
// StandardLogOptions can be used to configure the standard log adapter.
|
||||
type StandardLogOptions struct {
|
||||
ForceLevel Level
|
||||
}
|
||||
|
||||
// StandardLog returns a standard logger from Logger. The returned logger
|
||||
// can infer log levels from message prefix. Expected prefixes are DEBUG, INFO,
|
||||
// WARN, ERROR, and ERR.
|
||||
func (l *Logger) StandardLog(opts ...StandardLogOptions) *log.Logger {
|
||||
nl := l.With()
|
||||
// The caller stack is
|
||||
// log.Printf() -> l.Output() -> l.out.Write(stdLogger.Write)
|
||||
nl.callerOffset += 3
|
||||
sl := &stdLogWriter{
|
||||
l: nl,
|
||||
}
|
||||
if len(opts) > 0 {
|
||||
sl.opt = &opts[0]
|
||||
}
|
||||
return log.New(sl, "", 0)
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
)
|
||||
|
||||
// Styles defines the styles for the text logger.
|
||||
type Styles struct {
|
||||
// Timestamp is the style for timestamps.
|
||||
Timestamp lipgloss.Style
|
||||
|
||||
// Caller is the style for source caller.
|
||||
Caller lipgloss.Style
|
||||
|
||||
// Prefix is the style for prefix.
|
||||
Prefix lipgloss.Style
|
||||
|
||||
// Message is the style for messages.
|
||||
Message lipgloss.Style
|
||||
|
||||
// Key is the style for keys.
|
||||
Key lipgloss.Style
|
||||
|
||||
// Value is the style for values.
|
||||
Value lipgloss.Style
|
||||
|
||||
// Separator is the style for separators.
|
||||
Separator lipgloss.Style
|
||||
|
||||
// Levels are the styles for each level.
|
||||
Levels map[Level]lipgloss.Style
|
||||
|
||||
// Keys overrides styles for specific keys.
|
||||
Keys map[string]lipgloss.Style
|
||||
|
||||
// Values overrides value styles for specific keys.
|
||||
Values map[string]lipgloss.Style
|
||||
}
|
||||
|
||||
// DefaultStyles returns the default styles.
|
||||
func DefaultStyles() *Styles {
|
||||
return &Styles{
|
||||
Timestamp: lipgloss.NewStyle(),
|
||||
Caller: lipgloss.NewStyle().Faint(true),
|
||||
Prefix: lipgloss.NewStyle().Bold(true).Faint(true),
|
||||
Message: lipgloss.NewStyle(),
|
||||
Key: lipgloss.NewStyle().Faint(true),
|
||||
Value: lipgloss.NewStyle(),
|
||||
Separator: lipgloss.NewStyle().Faint(true),
|
||||
Levels: map[Level]lipgloss.Style{
|
||||
DebugLevel: lipgloss.NewStyle().
|
||||
SetString(strings.ToUpper(DebugLevel.String())).
|
||||
Bold(true).
|
||||
MaxWidth(4).
|
||||
Foreground(lipgloss.AdaptiveColor{
|
||||
Light: "63",
|
||||
Dark: "63",
|
||||
}),
|
||||
InfoLevel: lipgloss.NewStyle().
|
||||
SetString(strings.ToUpper(InfoLevel.String())).
|
||||
Bold(true).
|
||||
MaxWidth(4).
|
||||
Foreground(lipgloss.AdaptiveColor{
|
||||
Light: "39",
|
||||
Dark: "86",
|
||||
}),
|
||||
WarnLevel: lipgloss.NewStyle().
|
||||
SetString(strings.ToUpper(WarnLevel.String())).
|
||||
Bold(true).
|
||||
MaxWidth(4).
|
||||
Foreground(lipgloss.AdaptiveColor{
|
||||
Light: "208",
|
||||
Dark: "192",
|
||||
}),
|
||||
ErrorLevel: lipgloss.NewStyle().
|
||||
SetString(strings.ToUpper(ErrorLevel.String())).
|
||||
Bold(true).
|
||||
MaxWidth(4).
|
||||
Foreground(lipgloss.AdaptiveColor{
|
||||
Light: "203",
|
||||
Dark: "204",
|
||||
}),
|
||||
FatalLevel: lipgloss.NewStyle().
|
||||
SetString(strings.ToUpper(FatalLevel.String())).
|
||||
Bold(true).
|
||||
MaxWidth(4).
|
||||
Foreground(lipgloss.AdaptiveColor{
|
||||
Light: "133",
|
||||
Dark: "134",
|
||||
}),
|
||||
},
|
||||
Keys: map[string]lipgloss.Style{},
|
||||
Values: map[string]lipgloss.Style{},
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,269 @@
|
|||
package log
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
const (
|
||||
separator = "="
|
||||
indentSeparator = " │ "
|
||||
)
|
||||
|
||||
func (l *Logger) writeIndent(w io.Writer, str string, indent string, newline bool, key string) {
|
||||
st := l.styles
|
||||
|
||||
// kindly borrowed from hclog
|
||||
for {
|
||||
nl := strings.IndexByte(str, '\n')
|
||||
if nl == -1 {
|
||||
if str != "" {
|
||||
_, _ = w.Write([]byte(indent))
|
||||
val := escapeStringForOutput(str, false)
|
||||
if valueStyle, ok := st.Values[key]; ok {
|
||||
val = valueStyle.Renderer(l.re).Render(val)
|
||||
} else {
|
||||
val = st.Value.Renderer(l.re).Render(val)
|
||||
}
|
||||
_, _ = w.Write([]byte(val))
|
||||
if newline {
|
||||
_, _ = w.Write([]byte{'\n'})
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
_, _ = w.Write([]byte(indent))
|
||||
val := escapeStringForOutput(str[:nl], false)
|
||||
val = st.Value.Renderer(l.re).Render(val)
|
||||
_, _ = w.Write([]byte(val))
|
||||
_, _ = w.Write([]byte{'\n'})
|
||||
str = str[nl+1:]
|
||||
}
|
||||
}
|
||||
|
||||
func needsEscaping(str string) bool {
|
||||
for _, b := range str {
|
||||
if !unicode.IsPrint(b) || b == '"' {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
const (
|
||||
lowerhex = "0123456789abcdef"
|
||||
)
|
||||
|
||||
var bufPool = sync.Pool{
|
||||
New: func() interface{} {
|
||||
return new(strings.Builder)
|
||||
},
|
||||
}
|
||||
|
||||
func escapeStringForOutput(str string, escapeQuotes bool) string {
|
||||
// kindly borrowed from hclog
|
||||
if !needsEscaping(str) {
|
||||
return str
|
||||
}
|
||||
|
||||
bb := bufPool.Get().(*strings.Builder)
|
||||
bb.Reset()
|
||||
|
||||
defer bufPool.Put(bb)
|
||||
for _, r := range str {
|
||||
if escapeQuotes && r == '"' {
|
||||
bb.WriteString(`\"`)
|
||||
} else if unicode.IsPrint(r) {
|
||||
bb.WriteRune(r)
|
||||
} else {
|
||||
switch r {
|
||||
case '\a':
|
||||
bb.WriteString(`\a`)
|
||||
case '\b':
|
||||
bb.WriteString(`\b`)
|
||||
case '\f':
|
||||
bb.WriteString(`\f`)
|
||||
case '\n':
|
||||
bb.WriteString(`\n`)
|
||||
case '\r':
|
||||
bb.WriteString(`\r`)
|
||||
case '\t':
|
||||
bb.WriteString(`\t`)
|
||||
case '\v':
|
||||
bb.WriteString(`\v`)
|
||||
default:
|
||||
switch {
|
||||
case r < ' ':
|
||||
bb.WriteString(`\x`)
|
||||
bb.WriteByte(lowerhex[byte(r)>>4])
|
||||
bb.WriteByte(lowerhex[byte(r)&0xF])
|
||||
case !utf8.ValidRune(r):
|
||||
r = 0xFFFD
|
||||
fallthrough
|
||||
case r < 0x10000:
|
||||
bb.WriteString(`\u`)
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
bb.WriteByte(lowerhex[r>>uint(s)&0xF])
|
||||
}
|
||||
default:
|
||||
bb.WriteString(`\U`)
|
||||
for s := 28; s >= 0; s -= 4 {
|
||||
bb.WriteByte(lowerhex[r>>uint(s)&0xF])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return bb.String()
|
||||
}
|
||||
|
||||
func needsQuoting(s string) bool {
|
||||
for i := 0; i < len(s); {
|
||||
b := s[i]
|
||||
if b < utf8.RuneSelf {
|
||||
if needsQuotingSet[b] {
|
||||
return true
|
||||
}
|
||||
i++
|
||||
continue
|
||||
}
|
||||
r, size := utf8.DecodeRuneInString(s[i:])
|
||||
if r == utf8.RuneError || unicode.IsSpace(r) || !unicode.IsPrint(r) {
|
||||
return true
|
||||
}
|
||||
i += size
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
var needsQuotingSet = [utf8.RuneSelf]bool{
|
||||
'"': true,
|
||||
'=': true,
|
||||
}
|
||||
|
||||
func init() {
|
||||
for i := 0; i < utf8.RuneSelf; i++ {
|
||||
r := rune(i)
|
||||
if unicode.IsSpace(r) || !unicode.IsPrint(r) {
|
||||
needsQuotingSet[i] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func writeSpace(w io.Writer, first bool) {
|
||||
if !first {
|
||||
w.Write([]byte{' '}) //nolint: errcheck
|
||||
}
|
||||
}
|
||||
|
||||
func (l *Logger) textFormatter(keyvals ...interface{}) {
|
||||
st := l.styles
|
||||
lenKeyvals := len(keyvals)
|
||||
|
||||
for i := 0; i < lenKeyvals; i += 2 {
|
||||
firstKey := i == 0
|
||||
moreKeys := i < lenKeyvals-2
|
||||
|
||||
switch keyvals[i] {
|
||||
case TimestampKey:
|
||||
if t, ok := keyvals[i+1].(time.Time); ok {
|
||||
ts := t.Format(l.timeFormat)
|
||||
ts = st.Timestamp.Renderer(l.re).Render(ts)
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(ts)
|
||||
}
|
||||
case LevelKey:
|
||||
if level, ok := keyvals[i+1].(Level); ok {
|
||||
var lvl string
|
||||
if lvlStyle, ok := st.Levels[level]; ok {
|
||||
lvl = lvlStyle.Renderer(l.re).String()
|
||||
}
|
||||
if lvl != "" {
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(lvl)
|
||||
}
|
||||
}
|
||||
case CallerKey:
|
||||
if caller, ok := keyvals[i+1].(string); ok {
|
||||
caller = fmt.Sprintf("<%s>", caller)
|
||||
caller = st.Caller.Renderer(l.re).Render(caller)
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(caller)
|
||||
}
|
||||
case PrefixKey:
|
||||
if prefix, ok := keyvals[i+1].(string); ok {
|
||||
prefix = st.Prefix.Renderer(l.re).Render(prefix + ":")
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(prefix)
|
||||
}
|
||||
case MessageKey:
|
||||
if msg := keyvals[i+1]; msg != nil {
|
||||
m := fmt.Sprint(msg)
|
||||
m = st.Message.Renderer(l.re).Render(m)
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(m)
|
||||
}
|
||||
default:
|
||||
sep := separator
|
||||
indentSep := indentSeparator
|
||||
sep = st.Separator.Renderer(l.re).Render(sep)
|
||||
indentSep = st.Separator.Renderer(l.re).Render(indentSep)
|
||||
key := fmt.Sprint(keyvals[i])
|
||||
val := fmt.Sprintf("%+v", keyvals[i+1])
|
||||
raw := val == ""
|
||||
if raw {
|
||||
val = `""`
|
||||
}
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
actualKey := key
|
||||
valueStyle := st.Value
|
||||
if vs, ok := st.Values[actualKey]; ok {
|
||||
valueStyle = vs
|
||||
}
|
||||
if keyStyle, ok := st.Keys[key]; ok {
|
||||
key = keyStyle.Renderer(l.re).Render(key)
|
||||
} else {
|
||||
key = st.Key.Renderer(l.re).Render(key)
|
||||
}
|
||||
|
||||
// Values may contain multiple lines, and that format
|
||||
// is preserved, with each line prefixed with a " | "
|
||||
// to show it's part of a collection of lines.
|
||||
//
|
||||
// Values may also need quoting, if not all the runes
|
||||
// in the value string are "normal", like if they
|
||||
// contain ANSI escape sequences.
|
||||
if strings.Contains(val, "\n") {
|
||||
l.b.WriteString("\n ")
|
||||
l.b.WriteString(key)
|
||||
l.b.WriteString(sep + "\n")
|
||||
l.writeIndent(&l.b, val, indentSep, moreKeys, actualKey)
|
||||
} else if !raw && needsQuoting(val) {
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(key)
|
||||
l.b.WriteString(sep)
|
||||
l.b.WriteString(valueStyle.Renderer(l.re).Render(fmt.Sprintf(`"%s"`,
|
||||
escapeStringForOutput(val, true))))
|
||||
} else {
|
||||
val = valueStyle.Renderer(l.re).Render(val)
|
||||
writeSpace(&l.b, firstKey)
|
||||
l.b.WriteString(key)
|
||||
l.b.WriteString(sep)
|
||||
l.b.WriteString(val)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add a newline to the end of the log message.
|
||||
l.b.WriteByte('\n')
|
||||
}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
sudo: false
|
||||
language: go
|
||||
go_import_path: github.com/dustin/go-humanize
|
||||
go:
|
||||
- 1.13.x
|
||||
- 1.14.x
|
||||
- 1.15.x
|
||||
- 1.16.x
|
||||
- stable
|
||||
- master
|
||||
matrix:
|
||||
allow_failures:
|
||||
- go: master
|
||||
fast_finish: true
|
||||
install:
|
||||
- # Do nothing. This is needed to prevent default install action "go get -t -v ./..." from happening here (we want it to happen inside script step).
|
||||
script:
|
||||
- diff -u <(echo -n) <(gofmt -d -s .)
|
||||
- go vet .
|
||||
- go install -v -race ./...
|
||||
- go test -v -race ./...
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
Copyright (c) 2005-2008 Dustin Sallings <dustin@spy.net>
|
||||
|
||||
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.
|
||||
|
||||
<http://www.opensource.org/licenses/mit-license.php>
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
# Humane Units [](https://travis-ci.org/dustin/go-humanize) [](https://godoc.org/github.com/dustin/go-humanize)
|
||||
|
||||
Just a few functions for helping humanize times and sizes.
|
||||
|
||||
`go get` it as `github.com/dustin/go-humanize`, import it as
|
||||
`"github.com/dustin/go-humanize"`, use it as `humanize`.
|
||||
|
||||
See [godoc](https://pkg.go.dev/github.com/dustin/go-humanize) for
|
||||
complete documentation.
|
||||
|
||||
## Sizes
|
||||
|
||||
This lets you take numbers like `82854982` and convert them to useful
|
||||
strings like, `83 MB` or `79 MiB` (whichever you prefer).
|
||||
|
||||
Example:
|
||||
|
||||
```go
|
||||
fmt.Printf("That file is %s.", humanize.Bytes(82854982)) // That file is 83 MB.
|
||||
```
|
||||
|
||||
## Times
|
||||
|
||||
This lets you take a `time.Time` and spit it out in relative terms.
|
||||
For example, `12 seconds ago` or `3 days from now`.
|
||||
|
||||
Example:
|
||||
|
||||
```go
|
||||
fmt.Printf("This was touched %s.", humanize.Time(someTimeInstance)) // This was touched 7 hours ago.
|
||||
```
|
||||
|
||||
Thanks to Kyle Lemons for the time implementation from an IRC
|
||||
conversation one day. It's pretty neat.
|
||||
|
||||
## Ordinals
|
||||
|
||||
From a [mailing list discussion][odisc] where a user wanted to be able
|
||||
to label ordinals.
|
||||
|
||||
0 -> 0th
|
||||
1 -> 1st
|
||||
2 -> 2nd
|
||||
3 -> 3rd
|
||||
4 -> 4th
|
||||
[...]
|
||||
|
||||
Example:
|
||||
|
||||
```go
|
||||
fmt.Printf("You're my %s best friend.", humanize.Ordinal(193)) // You are my 193rd best friend.
|
||||
```
|
||||
|
||||
## Commas
|
||||
|
||||
Want to shove commas into numbers? Be my guest.
|
||||
|
||||
0 -> 0
|
||||
100 -> 100
|
||||
1000 -> 1,000
|
||||
1000000000 -> 1,000,000,000
|
||||
-100000 -> -100,000
|
||||
|
||||
Example:
|
||||
|
||||
```go
|
||||
fmt.Printf("You owe $%s.\n", humanize.Comma(6582491)) // You owe $6,582,491.
|
||||
```
|
||||
|
||||
## Ftoa
|
||||
|
||||
Nicer float64 formatter that removes trailing zeros.
|
||||
|
||||
```go
|
||||
fmt.Printf("%f", 2.24) // 2.240000
|
||||
fmt.Printf("%s", humanize.Ftoa(2.24)) // 2.24
|
||||
fmt.Printf("%f", 2.0) // 2.000000
|
||||
fmt.Printf("%s", humanize.Ftoa(2.0)) // 2
|
||||
```
|
||||
|
||||
## SI notation
|
||||
|
||||
Format numbers with [SI notation][sinotation].
|
||||
|
||||
Example:
|
||||
|
||||
```go
|
||||
humanize.SI(0.00000000223, "M") // 2.23 nM
|
||||
```
|
||||
|
||||
## English-specific functions
|
||||
|
||||
The following functions are in the `humanize/english` subpackage.
|
||||
|
||||
### Plurals
|
||||
|
||||
Simple English pluralization
|
||||
|
||||
```go
|
||||
english.PluralWord(1, "object", "") // object
|
||||
english.PluralWord(42, "object", "") // objects
|
||||
english.PluralWord(2, "bus", "") // buses
|
||||
english.PluralWord(99, "locus", "loci") // loci
|
||||
|
||||
english.Plural(1, "object", "") // 1 object
|
||||
english.Plural(42, "object", "") // 42 objects
|
||||
english.Plural(2, "bus", "") // 2 buses
|
||||
english.Plural(99, "locus", "loci") // 99 loci
|
||||
```
|
||||
|
||||
### Word series
|
||||
|
||||
Format comma-separated words lists with conjuctions:
|
||||
|
||||
```go
|
||||
english.WordSeries([]string{"foo"}, "and") // foo
|
||||
english.WordSeries([]string{"foo", "bar"}, "and") // foo and bar
|
||||
english.WordSeries([]string{"foo", "bar", "baz"}, "and") // foo, bar and baz
|
||||
|
||||
english.OxfordWordSeries([]string{"foo", "bar", "baz"}, "and") // foo, bar, and baz
|
||||
```
|
||||
|
||||
[odisc]: https://groups.google.com/d/topic/golang-nuts/l8NhI74jl-4/discussion
|
||||
[sinotation]: http://en.wikipedia.org/wiki/Metric_prefix
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"math/big"
|
||||
)
|
||||
|
||||
// order of magnitude (to a max order)
|
||||
func oomm(n, b *big.Int, maxmag int) (float64, int) {
|
||||
mag := 0
|
||||
m := &big.Int{}
|
||||
for n.Cmp(b) >= 0 {
|
||||
n.DivMod(n, b, m)
|
||||
mag++
|
||||
if mag == maxmag && maxmag >= 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
|
||||
}
|
||||
|
||||
// total order of magnitude
|
||||
// (same as above, but with no upper limit)
|
||||
func oom(n, b *big.Int) (float64, int) {
|
||||
mag := 0
|
||||
m := &big.Int{}
|
||||
for n.Cmp(b) >= 0 {
|
||||
n.DivMod(n, b, m)
|
||||
mag++
|
||||
}
|
||||
return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
|
||||
}
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/big"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
var (
|
||||
bigIECExp = big.NewInt(1024)
|
||||
|
||||
// BigByte is one byte in bit.Ints
|
||||
BigByte = big.NewInt(1)
|
||||
// BigKiByte is 1,024 bytes in bit.Ints
|
||||
BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)
|
||||
// BigMiByte is 1,024 k bytes in bit.Ints
|
||||
BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)
|
||||
// BigGiByte is 1,024 m bytes in bit.Ints
|
||||
BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)
|
||||
// BigTiByte is 1,024 g bytes in bit.Ints
|
||||
BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)
|
||||
// BigPiByte is 1,024 t bytes in bit.Ints
|
||||
BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)
|
||||
// BigEiByte is 1,024 p bytes in bit.Ints
|
||||
BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)
|
||||
// BigZiByte is 1,024 e bytes in bit.Ints
|
||||
BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)
|
||||
// BigYiByte is 1,024 z bytes in bit.Ints
|
||||
BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)
|
||||
// BigRiByte is 1,024 y bytes in bit.Ints
|
||||
BigRiByte = (&big.Int{}).Mul(BigYiByte, bigIECExp)
|
||||
// BigQiByte is 1,024 r bytes in bit.Ints
|
||||
BigQiByte = (&big.Int{}).Mul(BigRiByte, bigIECExp)
|
||||
)
|
||||
|
||||
var (
|
||||
bigSIExp = big.NewInt(1000)
|
||||
|
||||
// BigSIByte is one SI byte in big.Ints
|
||||
BigSIByte = big.NewInt(1)
|
||||
// BigKByte is 1,000 SI bytes in big.Ints
|
||||
BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)
|
||||
// BigMByte is 1,000 SI k bytes in big.Ints
|
||||
BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)
|
||||
// BigGByte is 1,000 SI m bytes in big.Ints
|
||||
BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)
|
||||
// BigTByte is 1,000 SI g bytes in big.Ints
|
||||
BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)
|
||||
// BigPByte is 1,000 SI t bytes in big.Ints
|
||||
BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)
|
||||
// BigEByte is 1,000 SI p bytes in big.Ints
|
||||
BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)
|
||||
// BigZByte is 1,000 SI e bytes in big.Ints
|
||||
BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)
|
||||
// BigYByte is 1,000 SI z bytes in big.Ints
|
||||
BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)
|
||||
// BigRByte is 1,000 SI y bytes in big.Ints
|
||||
BigRByte = (&big.Int{}).Mul(BigYByte, bigSIExp)
|
||||
// BigQByte is 1,000 SI r bytes in big.Ints
|
||||
BigQByte = (&big.Int{}).Mul(BigRByte, bigSIExp)
|
||||
)
|
||||
|
||||
var bigBytesSizeTable = map[string]*big.Int{
|
||||
"b": BigByte,
|
||||
"kib": BigKiByte,
|
||||
"kb": BigKByte,
|
||||
"mib": BigMiByte,
|
||||
"mb": BigMByte,
|
||||
"gib": BigGiByte,
|
||||
"gb": BigGByte,
|
||||
"tib": BigTiByte,
|
||||
"tb": BigTByte,
|
||||
"pib": BigPiByte,
|
||||
"pb": BigPByte,
|
||||
"eib": BigEiByte,
|
||||
"eb": BigEByte,
|
||||
"zib": BigZiByte,
|
||||
"zb": BigZByte,
|
||||
"yib": BigYiByte,
|
||||
"yb": BigYByte,
|
||||
"rib": BigRiByte,
|
||||
"rb": BigRByte,
|
||||
"qib": BigQiByte,
|
||||
"qb": BigQByte,
|
||||
// Without suffix
|
||||
"": BigByte,
|
||||
"ki": BigKiByte,
|
||||
"k": BigKByte,
|
||||
"mi": BigMiByte,
|
||||
"m": BigMByte,
|
||||
"gi": BigGiByte,
|
||||
"g": BigGByte,
|
||||
"ti": BigTiByte,
|
||||
"t": BigTByte,
|
||||
"pi": BigPiByte,
|
||||
"p": BigPByte,
|
||||
"ei": BigEiByte,
|
||||
"e": BigEByte,
|
||||
"z": BigZByte,
|
||||
"zi": BigZiByte,
|
||||
"y": BigYByte,
|
||||
"yi": BigYiByte,
|
||||
"r": BigRByte,
|
||||
"ri": BigRiByte,
|
||||
"q": BigQByte,
|
||||
"qi": BigQiByte,
|
||||
}
|
||||
|
||||
var ten = big.NewInt(10)
|
||||
|
||||
func humanateBigBytes(s, base *big.Int, sizes []string) string {
|
||||
if s.Cmp(ten) < 0 {
|
||||
return fmt.Sprintf("%d B", s)
|
||||
}
|
||||
c := (&big.Int{}).Set(s)
|
||||
val, mag := oomm(c, base, len(sizes)-1)
|
||||
suffix := sizes[mag]
|
||||
f := "%.0f %s"
|
||||
if val < 10 {
|
||||
f = "%.1f %s"
|
||||
}
|
||||
|
||||
return fmt.Sprintf(f, val, suffix)
|
||||
|
||||
}
|
||||
|
||||
// BigBytes produces a human readable representation of an SI size.
|
||||
//
|
||||
// See also: ParseBigBytes.
|
||||
//
|
||||
// BigBytes(82854982) -> 83 MB
|
||||
func BigBytes(s *big.Int) string {
|
||||
sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "RB", "QB"}
|
||||
return humanateBigBytes(s, bigSIExp, sizes)
|
||||
}
|
||||
|
||||
// BigIBytes produces a human readable representation of an IEC size.
|
||||
//
|
||||
// See also: ParseBigBytes.
|
||||
//
|
||||
// BigIBytes(82854982) -> 79 MiB
|
||||
func BigIBytes(s *big.Int) string {
|
||||
sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", "RiB", "QiB"}
|
||||
return humanateBigBytes(s, bigIECExp, sizes)
|
||||
}
|
||||
|
||||
// ParseBigBytes parses a string representation of bytes into the number
|
||||
// of bytes it represents.
|
||||
//
|
||||
// See also: BigBytes, BigIBytes.
|
||||
//
|
||||
// ParseBigBytes("42 MB") -> 42000000, nil
|
||||
// ParseBigBytes("42 mib") -> 44040192, nil
|
||||
func ParseBigBytes(s string) (*big.Int, error) {
|
||||
lastDigit := 0
|
||||
hasComma := false
|
||||
for _, r := range s {
|
||||
if !(unicode.IsDigit(r) || r == '.' || r == ',') {
|
||||
break
|
||||
}
|
||||
if r == ',' {
|
||||
hasComma = true
|
||||
}
|
||||
lastDigit++
|
||||
}
|
||||
|
||||
num := s[:lastDigit]
|
||||
if hasComma {
|
||||
num = strings.Replace(num, ",", "", -1)
|
||||
}
|
||||
|
||||
val := &big.Rat{}
|
||||
_, err := fmt.Sscanf(num, "%f", val)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
|
||||
if m, ok := bigBytesSizeTable[extra]; ok {
|
||||
mv := (&big.Rat{}).SetInt(m)
|
||||
val.Mul(val, mv)
|
||||
rv := &big.Int{}
|
||||
rv.Div(val.Num(), val.Denom())
|
||||
return rv, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("unhandled size name: %v", extra)
|
||||
}
|
||||
|
|
@ -0,0 +1,143 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
// IEC Sizes.
|
||||
// kibis of bits
|
||||
const (
|
||||
Byte = 1 << (iota * 10)
|
||||
KiByte
|
||||
MiByte
|
||||
GiByte
|
||||
TiByte
|
||||
PiByte
|
||||
EiByte
|
||||
)
|
||||
|
||||
// SI Sizes.
|
||||
const (
|
||||
IByte = 1
|
||||
KByte = IByte * 1000
|
||||
MByte = KByte * 1000
|
||||
GByte = MByte * 1000
|
||||
TByte = GByte * 1000
|
||||
PByte = TByte * 1000
|
||||
EByte = PByte * 1000
|
||||
)
|
||||
|
||||
var bytesSizeTable = map[string]uint64{
|
||||
"b": Byte,
|
||||
"kib": KiByte,
|
||||
"kb": KByte,
|
||||
"mib": MiByte,
|
||||
"mb": MByte,
|
||||
"gib": GiByte,
|
||||
"gb": GByte,
|
||||
"tib": TiByte,
|
||||
"tb": TByte,
|
||||
"pib": PiByte,
|
||||
"pb": PByte,
|
||||
"eib": EiByte,
|
||||
"eb": EByte,
|
||||
// Without suffix
|
||||
"": Byte,
|
||||
"ki": KiByte,
|
||||
"k": KByte,
|
||||
"mi": MiByte,
|
||||
"m": MByte,
|
||||
"gi": GiByte,
|
||||
"g": GByte,
|
||||
"ti": TiByte,
|
||||
"t": TByte,
|
||||
"pi": PiByte,
|
||||
"p": PByte,
|
||||
"ei": EiByte,
|
||||
"e": EByte,
|
||||
}
|
||||
|
||||
func logn(n, b float64) float64 {
|
||||
return math.Log(n) / math.Log(b)
|
||||
}
|
||||
|
||||
func humanateBytes(s uint64, base float64, sizes []string) string {
|
||||
if s < 10 {
|
||||
return fmt.Sprintf("%d B", s)
|
||||
}
|
||||
e := math.Floor(logn(float64(s), base))
|
||||
suffix := sizes[int(e)]
|
||||
val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
|
||||
f := "%.0f %s"
|
||||
if val < 10 {
|
||||
f = "%.1f %s"
|
||||
}
|
||||
|
||||
return fmt.Sprintf(f, val, suffix)
|
||||
}
|
||||
|
||||
// Bytes produces a human readable representation of an SI size.
|
||||
//
|
||||
// See also: ParseBytes.
|
||||
//
|
||||
// Bytes(82854982) -> 83 MB
|
||||
func Bytes(s uint64) string {
|
||||
sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"}
|
||||
return humanateBytes(s, 1000, sizes)
|
||||
}
|
||||
|
||||
// IBytes produces a human readable representation of an IEC size.
|
||||
//
|
||||
// See also: ParseBytes.
|
||||
//
|
||||
// IBytes(82854982) -> 79 MiB
|
||||
func IBytes(s uint64) string {
|
||||
sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}
|
||||
return humanateBytes(s, 1024, sizes)
|
||||
}
|
||||
|
||||
// ParseBytes parses a string representation of bytes into the number
|
||||
// of bytes it represents.
|
||||
//
|
||||
// See Also: Bytes, IBytes.
|
||||
//
|
||||
// ParseBytes("42 MB") -> 42000000, nil
|
||||
// ParseBytes("42 mib") -> 44040192, nil
|
||||
func ParseBytes(s string) (uint64, error) {
|
||||
lastDigit := 0
|
||||
hasComma := false
|
||||
for _, r := range s {
|
||||
if !(unicode.IsDigit(r) || r == '.' || r == ',') {
|
||||
break
|
||||
}
|
||||
if r == ',' {
|
||||
hasComma = true
|
||||
}
|
||||
lastDigit++
|
||||
}
|
||||
|
||||
num := s[:lastDigit]
|
||||
if hasComma {
|
||||
num = strings.Replace(num, ",", "", -1)
|
||||
}
|
||||
|
||||
f, err := strconv.ParseFloat(num, 64)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
|
||||
if m, ok := bytesSizeTable[extra]; ok {
|
||||
f *= float64(m)
|
||||
if f >= math.MaxUint64 {
|
||||
return 0, fmt.Errorf("too large: %v", s)
|
||||
}
|
||||
return uint64(f), nil
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("unhandled size name: %v", extra)
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"math"
|
||||
"math/big"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Comma produces a string form of the given number in base 10 with
|
||||
// commas after every three orders of magnitude.
|
||||
//
|
||||
// e.g. Comma(834142) -> 834,142
|
||||
func Comma(v int64) string {
|
||||
sign := ""
|
||||
|
||||
// Min int64 can't be negated to a usable value, so it has to be special cased.
|
||||
if v == math.MinInt64 {
|
||||
return "-9,223,372,036,854,775,808"
|
||||
}
|
||||
|
||||
if v < 0 {
|
||||
sign = "-"
|
||||
v = 0 - v
|
||||
}
|
||||
|
||||
parts := []string{"", "", "", "", "", "", ""}
|
||||
j := len(parts) - 1
|
||||
|
||||
for v > 999 {
|
||||
parts[j] = strconv.FormatInt(v%1000, 10)
|
||||
switch len(parts[j]) {
|
||||
case 2:
|
||||
parts[j] = "0" + parts[j]
|
||||
case 1:
|
||||
parts[j] = "00" + parts[j]
|
||||
}
|
||||
v = v / 1000
|
||||
j--
|
||||
}
|
||||
parts[j] = strconv.Itoa(int(v))
|
||||
return sign + strings.Join(parts[j:], ",")
|
||||
}
|
||||
|
||||
// Commaf produces a string form of the given number in base 10 with
|
||||
// commas after every three orders of magnitude.
|
||||
//
|
||||
// e.g. Commaf(834142.32) -> 834,142.32
|
||||
func Commaf(v float64) string {
|
||||
buf := &bytes.Buffer{}
|
||||
if v < 0 {
|
||||
buf.Write([]byte{'-'})
|
||||
v = 0 - v
|
||||
}
|
||||
|
||||
comma := []byte{','}
|
||||
|
||||
parts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), ".")
|
||||
pos := 0
|
||||
if len(parts[0])%3 != 0 {
|
||||
pos += len(parts[0]) % 3
|
||||
buf.WriteString(parts[0][:pos])
|
||||
buf.Write(comma)
|
||||
}
|
||||
for ; pos < len(parts[0]); pos += 3 {
|
||||
buf.WriteString(parts[0][pos : pos+3])
|
||||
buf.Write(comma)
|
||||
}
|
||||
buf.Truncate(buf.Len() - 1)
|
||||
|
||||
if len(parts) > 1 {
|
||||
buf.Write([]byte{'.'})
|
||||
buf.WriteString(parts[1])
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// CommafWithDigits works like the Commaf but limits the resulting
|
||||
// string to the given number of decimal places.
|
||||
//
|
||||
// e.g. CommafWithDigits(834142.32, 1) -> 834,142.3
|
||||
func CommafWithDigits(f float64, decimals int) string {
|
||||
return stripTrailingDigits(Commaf(f), decimals)
|
||||
}
|
||||
|
||||
// BigComma produces a string form of the given big.Int in base 10
|
||||
// with commas after every three orders of magnitude.
|
||||
func BigComma(b *big.Int) string {
|
||||
sign := ""
|
||||
if b.Sign() < 0 {
|
||||
sign = "-"
|
||||
b.Abs(b)
|
||||
}
|
||||
|
||||
athousand := big.NewInt(1000)
|
||||
c := (&big.Int{}).Set(b)
|
||||
_, m := oom(c, athousand)
|
||||
parts := make([]string, m+1)
|
||||
j := len(parts) - 1
|
||||
|
||||
mod := &big.Int{}
|
||||
for b.Cmp(athousand) >= 0 {
|
||||
b.DivMod(b, athousand, mod)
|
||||
parts[j] = strconv.FormatInt(mod.Int64(), 10)
|
||||
switch len(parts[j]) {
|
||||
case 2:
|
||||
parts[j] = "0" + parts[j]
|
||||
case 1:
|
||||
parts[j] = "00" + parts[j]
|
||||
}
|
||||
j--
|
||||
}
|
||||
parts[j] = strconv.Itoa(int(b.Int64()))
|
||||
return sign + strings.Join(parts[j:], ",")
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
//go:build go1.6
|
||||
// +build go1.6
|
||||
|
||||
package humanize
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"math/big"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// BigCommaf produces a string form of the given big.Float in base 10
|
||||
// with commas after every three orders of magnitude.
|
||||
func BigCommaf(v *big.Float) string {
|
||||
buf := &bytes.Buffer{}
|
||||
if v.Sign() < 0 {
|
||||
buf.Write([]byte{'-'})
|
||||
v.Abs(v)
|
||||
}
|
||||
|
||||
comma := []byte{','}
|
||||
|
||||
parts := strings.Split(v.Text('f', -1), ".")
|
||||
pos := 0
|
||||
if len(parts[0])%3 != 0 {
|
||||
pos += len(parts[0]) % 3
|
||||
buf.WriteString(parts[0][:pos])
|
||||
buf.Write(comma)
|
||||
}
|
||||
for ; pos < len(parts[0]); pos += 3 {
|
||||
buf.WriteString(parts[0][pos : pos+3])
|
||||
buf.Write(comma)
|
||||
}
|
||||
buf.Truncate(buf.Len() - 1)
|
||||
|
||||
if len(parts) > 1 {
|
||||
buf.Write([]byte{'.'})
|
||||
buf.WriteString(parts[1])
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func stripTrailingZeros(s string) string {
|
||||
if !strings.ContainsRune(s, '.') {
|
||||
return s
|
||||
}
|
||||
offset := len(s) - 1
|
||||
for offset > 0 {
|
||||
if s[offset] == '.' {
|
||||
offset--
|
||||
break
|
||||
}
|
||||
if s[offset] != '0' {
|
||||
break
|
||||
}
|
||||
offset--
|
||||
}
|
||||
return s[:offset+1]
|
||||
}
|
||||
|
||||
func stripTrailingDigits(s string, digits int) string {
|
||||
if i := strings.Index(s, "."); i >= 0 {
|
||||
if digits <= 0 {
|
||||
return s[:i]
|
||||
}
|
||||
i++
|
||||
if i+digits >= len(s) {
|
||||
return s
|
||||
}
|
||||
return s[:i+digits]
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// Ftoa converts a float to a string with no trailing zeros.
|
||||
func Ftoa(num float64) string {
|
||||
return stripTrailingZeros(strconv.FormatFloat(num, 'f', 6, 64))
|
||||
}
|
||||
|
||||
// FtoaWithDigits converts a float to a string but limits the resulting string
|
||||
// to the given number of decimal places, and no trailing zeros.
|
||||
func FtoaWithDigits(num float64, digits int) string {
|
||||
return stripTrailingZeros(stripTrailingDigits(strconv.FormatFloat(num, 'f', 6, 64), digits))
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
/*
|
||||
Package humanize converts boring ugly numbers to human-friendly strings and back.
|
||||
|
||||
Durations can be turned into strings such as "3 days ago", numbers
|
||||
representing sizes like 82854982 into useful strings like, "83 MB" or
|
||||
"79 MiB" (whichever you prefer).
|
||||
*/
|
||||
package humanize
|
||||
|
|
@ -0,0 +1,192 @@
|
|||
package humanize
|
||||
|
||||
/*
|
||||
Slightly adapted from the source to fit go-humanize.
|
||||
|
||||
Author: https://github.com/gorhill
|
||||
Source: https://gist.github.com/gorhill/5285193
|
||||
|
||||
*/
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
var (
|
||||
renderFloatPrecisionMultipliers = [...]float64{
|
||||
1,
|
||||
10,
|
||||
100,
|
||||
1000,
|
||||
10000,
|
||||
100000,
|
||||
1000000,
|
||||
10000000,
|
||||
100000000,
|
||||
1000000000,
|
||||
}
|
||||
|
||||
renderFloatPrecisionRounders = [...]float64{
|
||||
0.5,
|
||||
0.05,
|
||||
0.005,
|
||||
0.0005,
|
||||
0.00005,
|
||||
0.000005,
|
||||
0.0000005,
|
||||
0.00000005,
|
||||
0.000000005,
|
||||
0.0000000005,
|
||||
}
|
||||
)
|
||||
|
||||
// FormatFloat produces a formatted number as string based on the following user-specified criteria:
|
||||
// * thousands separator
|
||||
// * decimal separator
|
||||
// * decimal precision
|
||||
//
|
||||
// Usage: s := RenderFloat(format, n)
|
||||
// The format parameter tells how to render the number n.
|
||||
//
|
||||
// See examples: http://play.golang.org/p/LXc1Ddm1lJ
|
||||
//
|
||||
// Examples of format strings, given n = 12345.6789:
|
||||
// "#,###.##" => "12,345.67"
|
||||
// "#,###." => "12,345"
|
||||
// "#,###" => "12345,678"
|
||||
// "#\u202F###,##" => "12 345,68"
|
||||
// "#.###,###### => 12.345,678900
|
||||
// "" (aka default format) => 12,345.67
|
||||
//
|
||||
// The highest precision allowed is 9 digits after the decimal symbol.
|
||||
// There is also a version for integer number, FormatInteger(),
|
||||
// which is convenient for calls within template.
|
||||
func FormatFloat(format string, n float64) string {
|
||||
// Special cases:
|
||||
// NaN = "NaN"
|
||||
// +Inf = "+Infinity"
|
||||
// -Inf = "-Infinity"
|
||||
if math.IsNaN(n) {
|
||||
return "NaN"
|
||||
}
|
||||
if n > math.MaxFloat64 {
|
||||
return "Infinity"
|
||||
}
|
||||
if n < (0.0 - math.MaxFloat64) {
|
||||
return "-Infinity"
|
||||
}
|
||||
|
||||
// default format
|
||||
precision := 2
|
||||
decimalStr := "."
|
||||
thousandStr := ","
|
||||
positiveStr := ""
|
||||
negativeStr := "-"
|
||||
|
||||
if len(format) > 0 {
|
||||
format := []rune(format)
|
||||
|
||||
// If there is an explicit format directive,
|
||||
// then default values are these:
|
||||
precision = 9
|
||||
thousandStr = ""
|
||||
|
||||
// collect indices of meaningful formatting directives
|
||||
formatIndx := []int{}
|
||||
for i, char := range format {
|
||||
if char != '#' && char != '0' {
|
||||
formatIndx = append(formatIndx, i)
|
||||
}
|
||||
}
|
||||
|
||||
if len(formatIndx) > 0 {
|
||||
// Directive at index 0:
|
||||
// Must be a '+'
|
||||
// Raise an error if not the case
|
||||
// index: 0123456789
|
||||
// +0.000,000
|
||||
// +000,000.0
|
||||
// +0000.00
|
||||
// +0000
|
||||
if formatIndx[0] == 0 {
|
||||
if format[formatIndx[0]] != '+' {
|
||||
panic("RenderFloat(): invalid positive sign directive")
|
||||
}
|
||||
positiveStr = "+"
|
||||
formatIndx = formatIndx[1:]
|
||||
}
|
||||
|
||||
// Two directives:
|
||||
// First is thousands separator
|
||||
// Raise an error if not followed by 3-digit
|
||||
// 0123456789
|
||||
// 0.000,000
|
||||
// 000,000.00
|
||||
if len(formatIndx) == 2 {
|
||||
if (formatIndx[1] - formatIndx[0]) != 4 {
|
||||
panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
|
||||
}
|
||||
thousandStr = string(format[formatIndx[0]])
|
||||
formatIndx = formatIndx[1:]
|
||||
}
|
||||
|
||||
// One directive:
|
||||
// Directive is decimal separator
|
||||
// The number of digit-specifier following the separator indicates wanted precision
|
||||
// 0123456789
|
||||
// 0.00
|
||||
// 000,0000
|
||||
if len(formatIndx) == 1 {
|
||||
decimalStr = string(format[formatIndx[0]])
|
||||
precision = len(format) - formatIndx[0] - 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// generate sign part
|
||||
var signStr string
|
||||
if n >= 0.000000001 {
|
||||
signStr = positiveStr
|
||||
} else if n <= -0.000000001 {
|
||||
signStr = negativeStr
|
||||
n = -n
|
||||
} else {
|
||||
signStr = ""
|
||||
n = 0.0
|
||||
}
|
||||
|
||||
// split number into integer and fractional parts
|
||||
intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
|
||||
|
||||
// generate integer part string
|
||||
intStr := strconv.FormatInt(int64(intf), 10)
|
||||
|
||||
// add thousand separator if required
|
||||
if len(thousandStr) > 0 {
|
||||
for i := len(intStr); i > 3; {
|
||||
i -= 3
|
||||
intStr = intStr[:i] + thousandStr + intStr[i:]
|
||||
}
|
||||
}
|
||||
|
||||
// no fractional part, we can leave now
|
||||
if precision == 0 {
|
||||
return signStr + intStr
|
||||
}
|
||||
|
||||
// generate fractional part
|
||||
fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
|
||||
// may need padding
|
||||
if len(fracStr) < precision {
|
||||
fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
|
||||
}
|
||||
|
||||
return signStr + intStr + decimalStr + fracStr
|
||||
}
|
||||
|
||||
// FormatInteger produces a formatted number as string.
|
||||
// See FormatFloat.
|
||||
func FormatInteger(format string, n int) string {
|
||||
return FormatFloat(format, float64(n))
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package humanize
|
||||
|
||||
import "strconv"
|
||||
|
||||
// Ordinal gives you the input number in a rank/ordinal format.
|
||||
//
|
||||
// Ordinal(3) -> 3rd
|
||||
func Ordinal(x int) string {
|
||||
suffix := "th"
|
||||
switch x % 10 {
|
||||
case 1:
|
||||
if x%100 != 11 {
|
||||
suffix = "st"
|
||||
}
|
||||
case 2:
|
||||
if x%100 != 12 {
|
||||
suffix = "nd"
|
||||
}
|
||||
case 3:
|
||||
if x%100 != 13 {
|
||||
suffix = "rd"
|
||||
}
|
||||
}
|
||||
return strconv.Itoa(x) + suffix
|
||||
}
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"math"
|
||||
"regexp"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
var siPrefixTable = map[float64]string{
|
||||
-30: "q", // quecto
|
||||
-27: "r", // ronto
|
||||
-24: "y", // yocto
|
||||
-21: "z", // zepto
|
||||
-18: "a", // atto
|
||||
-15: "f", // femto
|
||||
-12: "p", // pico
|
||||
-9: "n", // nano
|
||||
-6: "µ", // micro
|
||||
-3: "m", // milli
|
||||
0: "",
|
||||
3: "k", // kilo
|
||||
6: "M", // mega
|
||||
9: "G", // giga
|
||||
12: "T", // tera
|
||||
15: "P", // peta
|
||||
18: "E", // exa
|
||||
21: "Z", // zetta
|
||||
24: "Y", // yotta
|
||||
27: "R", // ronna
|
||||
30: "Q", // quetta
|
||||
}
|
||||
|
||||
var revSIPrefixTable = revfmap(siPrefixTable)
|
||||
|
||||
// revfmap reverses the map and precomputes the power multiplier
|
||||
func revfmap(in map[float64]string) map[string]float64 {
|
||||
rv := map[string]float64{}
|
||||
for k, v := range in {
|
||||
rv[v] = math.Pow(10, k)
|
||||
}
|
||||
return rv
|
||||
}
|
||||
|
||||
var riParseRegex *regexp.Regexp
|
||||
|
||||
func init() {
|
||||
ri := `^([\-0-9.]+)\s?([`
|
||||
for _, v := range siPrefixTable {
|
||||
ri += v
|
||||
}
|
||||
ri += `]?)(.*)`
|
||||
|
||||
riParseRegex = regexp.MustCompile(ri)
|
||||
}
|
||||
|
||||
// ComputeSI finds the most appropriate SI prefix for the given number
|
||||
// and returns the prefix along with the value adjusted to be within
|
||||
// that prefix.
|
||||
//
|
||||
// See also: SI, ParseSI.
|
||||
//
|
||||
// e.g. ComputeSI(2.2345e-12) -> (2.2345, "p")
|
||||
func ComputeSI(input float64) (float64, string) {
|
||||
if input == 0 {
|
||||
return 0, ""
|
||||
}
|
||||
mag := math.Abs(input)
|
||||
exponent := math.Floor(logn(mag, 10))
|
||||
exponent = math.Floor(exponent/3) * 3
|
||||
|
||||
value := mag / math.Pow(10, exponent)
|
||||
|
||||
// Handle special case where value is exactly 1000.0
|
||||
// Should return 1 M instead of 1000 k
|
||||
if value == 1000.0 {
|
||||
exponent += 3
|
||||
value = mag / math.Pow(10, exponent)
|
||||
}
|
||||
|
||||
value = math.Copysign(value, input)
|
||||
|
||||
prefix := siPrefixTable[exponent]
|
||||
return value, prefix
|
||||
}
|
||||
|
||||
// SI returns a string with default formatting.
|
||||
//
|
||||
// SI uses Ftoa to format float value, removing trailing zeros.
|
||||
//
|
||||
// See also: ComputeSI, ParseSI.
|
||||
//
|
||||
// e.g. SI(1000000, "B") -> 1 MB
|
||||
// e.g. SI(2.2345e-12, "F") -> 2.2345 pF
|
||||
func SI(input float64, unit string) string {
|
||||
value, prefix := ComputeSI(input)
|
||||
return Ftoa(value) + " " + prefix + unit
|
||||
}
|
||||
|
||||
// SIWithDigits works like SI but limits the resulting string to the
|
||||
// given number of decimal places.
|
||||
//
|
||||
// e.g. SIWithDigits(1000000, 0, "B") -> 1 MB
|
||||
// e.g. SIWithDigits(2.2345e-12, 2, "F") -> 2.23 pF
|
||||
func SIWithDigits(input float64, decimals int, unit string) string {
|
||||
value, prefix := ComputeSI(input)
|
||||
return FtoaWithDigits(value, decimals) + " " + prefix + unit
|
||||
}
|
||||
|
||||
var errInvalid = errors.New("invalid input")
|
||||
|
||||
// ParseSI parses an SI string back into the number and unit.
|
||||
//
|
||||
// See also: SI, ComputeSI.
|
||||
//
|
||||
// e.g. ParseSI("2.2345 pF") -> (2.2345e-12, "F", nil)
|
||||
func ParseSI(input string) (float64, string, error) {
|
||||
found := riParseRegex.FindStringSubmatch(input)
|
||||
if len(found) != 4 {
|
||||
return 0, "", errInvalid
|
||||
}
|
||||
mag := revSIPrefixTable[found[2]]
|
||||
unit := found[3]
|
||||
|
||||
base, err := strconv.ParseFloat(found[1], 64)
|
||||
return base * mag, unit, err
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
package humanize
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"sort"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Seconds-based time units
|
||||
const (
|
||||
Day = 24 * time.Hour
|
||||
Week = 7 * Day
|
||||
Month = 30 * Day
|
||||
Year = 12 * Month
|
||||
LongTime = 37 * Year
|
||||
)
|
||||
|
||||
// Time formats a time into a relative string.
|
||||
//
|
||||
// Time(someT) -> "3 weeks ago"
|
||||
func Time(then time.Time) string {
|
||||
return RelTime(then, time.Now(), "ago", "from now")
|
||||
}
|
||||
|
||||
// A RelTimeMagnitude struct contains a relative time point at which
|
||||
// the relative format of time will switch to a new format string. A
|
||||
// slice of these in ascending order by their "D" field is passed to
|
||||
// CustomRelTime to format durations.
|
||||
//
|
||||
// The Format field is a string that may contain a "%s" which will be
|
||||
// replaced with the appropriate signed label (e.g. "ago" or "from
|
||||
// now") and a "%d" that will be replaced by the quantity.
|
||||
//
|
||||
// The DivBy field is the amount of time the time difference must be
|
||||
// divided by in order to display correctly.
|
||||
//
|
||||
// e.g. if D is 2*time.Minute and you want to display "%d minutes %s"
|
||||
// DivBy should be time.Minute so whatever the duration is will be
|
||||
// expressed in minutes.
|
||||
type RelTimeMagnitude struct {
|
||||
D time.Duration
|
||||
Format string
|
||||
DivBy time.Duration
|
||||
}
|
||||
|
||||
var defaultMagnitudes = []RelTimeMagnitude{
|
||||
{time.Second, "now", time.Second},
|
||||
{2 * time.Second, "1 second %s", 1},
|
||||
{time.Minute, "%d seconds %s", time.Second},
|
||||
{2 * time.Minute, "1 minute %s", 1},
|
||||
{time.Hour, "%d minutes %s", time.Minute},
|
||||
{2 * time.Hour, "1 hour %s", 1},
|
||||
{Day, "%d hours %s", time.Hour},
|
||||
{2 * Day, "1 day %s", 1},
|
||||
{Week, "%d days %s", Day},
|
||||
{2 * Week, "1 week %s", 1},
|
||||
{Month, "%d weeks %s", Week},
|
||||
{2 * Month, "1 month %s", 1},
|
||||
{Year, "%d months %s", Month},
|
||||
{18 * Month, "1 year %s", 1},
|
||||
{2 * Year, "2 years %s", 1},
|
||||
{LongTime, "%d years %s", Year},
|
||||
{math.MaxInt64, "a long while %s", 1},
|
||||
}
|
||||
|
||||
// RelTime formats a time into a relative string.
|
||||
//
|
||||
// It takes two times and two labels. In addition to the generic time
|
||||
// delta string (e.g. 5 minutes), the labels are used applied so that
|
||||
// the label corresponding to the smaller time is applied.
|
||||
//
|
||||
// RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier"
|
||||
func RelTime(a, b time.Time, albl, blbl string) string {
|
||||
return CustomRelTime(a, b, albl, blbl, defaultMagnitudes)
|
||||
}
|
||||
|
||||
// CustomRelTime formats a time into a relative string.
|
||||
//
|
||||
// It takes two times two labels and a table of relative time formats.
|
||||
// In addition to the generic time delta string (e.g. 5 minutes), the
|
||||
// labels are used applied so that the label corresponding to the
|
||||
// smaller time is applied.
|
||||
func CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string {
|
||||
lbl := albl
|
||||
diff := b.Sub(a)
|
||||
|
||||
if a.After(b) {
|
||||
lbl = blbl
|
||||
diff = a.Sub(b)
|
||||
}
|
||||
|
||||
n := sort.Search(len(magnitudes), func(i int) bool {
|
||||
return magnitudes[i].D > diff
|
||||
})
|
||||
|
||||
if n >= len(magnitudes) {
|
||||
n = len(magnitudes) - 1
|
||||
}
|
||||
mag := magnitudes[n]
|
||||
args := []interface{}{}
|
||||
escaped := false
|
||||
for _, ch := range mag.Format {
|
||||
if escaped {
|
||||
switch ch {
|
||||
case 's':
|
||||
args = append(args, lbl)
|
||||
case 'd':
|
||||
args = append(args, diff/mag.DivBy)
|
||||
}
|
||||
escaped = false
|
||||
} else {
|
||||
escaped = ch == '%'
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf(mag.Format, args...)
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
.vscode/
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [0.6.0] - 2023-01-30
|
||||
|
||||
[0.6.0]: https://github.com/go-logfmt/logfmt/compare/v0.5.1...v0.6.0
|
||||
|
||||
### Added
|
||||
|
||||
- NewDecoderSize by [@alexanderjophus]
|
||||
|
||||
## [0.5.1] - 2021-08-18
|
||||
|
||||
[0.5.1]: https://github.com/go-logfmt/logfmt/compare/v0.5.0...v0.5.1
|
||||
|
||||
### Changed
|
||||
|
||||
- Update the `go.mod` file for Go 1.17 as described in the [Go 1.17 release
|
||||
notes](https://golang.org/doc/go1.17#go-command)
|
||||
|
||||
## [0.5.0] - 2020-01-03
|
||||
|
||||
[0.5.0]: https://github.com/go-logfmt/logfmt/compare/v0.4.0...v0.5.0
|
||||
|
||||
### Changed
|
||||
|
||||
- Remove the dependency on github.com/kr/logfmt by [@ChrisHines]
|
||||
- Move fuzz code to github.com/go-logfmt/fuzzlogfmt by [@ChrisHines]
|
||||
|
||||
## [0.4.0] - 2018-11-21
|
||||
|
||||
[0.4.0]: https://github.com/go-logfmt/logfmt/compare/v0.3.0...v0.4.0
|
||||
|
||||
### Added
|
||||
|
||||
- Go module support by [@ChrisHines]
|
||||
- CHANGELOG by [@ChrisHines]
|
||||
|
||||
### Changed
|
||||
|
||||
- Drop invalid runes from keys instead of returning ErrInvalidKey by [@ChrisHines]
|
||||
- On panic while printing, attempt to print panic value by [@bboreham]
|
||||
|
||||
## [0.3.0] - 2016-11-15
|
||||
|
||||
[0.3.0]: https://github.com/go-logfmt/logfmt/compare/v0.2.0...v0.3.0
|
||||
|
||||
### Added
|
||||
|
||||
- Pool buffers for quoted strings and byte slices by [@nussjustin]
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fuzz fix, quote invalid UTF-8 values by [@judwhite]
|
||||
|
||||
## [0.2.0] - 2016-05-08
|
||||
|
||||
[0.2.0]: https://github.com/go-logfmt/logfmt/compare/v0.1.0...v0.2.0
|
||||
|
||||
### Added
|
||||
|
||||
- Encoder.EncodeKeyvals by [@ChrisHines]
|
||||
|
||||
## [0.1.0] - 2016-03-28
|
||||
|
||||
[0.1.0]: https://github.com/go-logfmt/logfmt/commits/v0.1.0
|
||||
|
||||
### Added
|
||||
|
||||
- Encoder by [@ChrisHines]
|
||||
- Decoder by [@ChrisHines]
|
||||
- MarshalKeyvals by [@ChrisHines]
|
||||
|
||||
[@ChrisHines]: https://github.com/ChrisHines
|
||||
[@bboreham]: https://github.com/bboreham
|
||||
[@judwhite]: https://github.com/judwhite
|
||||
[@nussjustin]: https://github.com/nussjustin
|
||||
[@alexanderjophus]: https://github.com/alexanderjophus
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2015 go-logfmt
|
||||
|
||||
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.
|
||||
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# logfmt
|
||||
|
||||
[](https://pkg.go.dev/github.com/go-logfmt/logfmt)
|
||||
[](https://goreportcard.com/report/go-logfmt/logfmt)
|
||||
[](https://github.com/go-logfmt/logfmt/actions/workflows/test.yml)
|
||||
[](https://coveralls.io/github/go-logfmt/logfmt?branch=main)
|
||||
|
||||
Package logfmt implements utilities to marshal and unmarshal data in the [logfmt
|
||||
format][fmt]. It provides an API similar to [encoding/json][json] and
|
||||
[encoding/xml][xml].
|
||||
|
||||
[fmt]: https://brandur.org/logfmt
|
||||
[json]: https://pkg.go.dev/encoding/json
|
||||
[xml]: https://pkg.go.dev/encoding/xml
|
||||
|
||||
The logfmt format was first documented by Brandur Leach in [this
|
||||
article][origin]. The format has not been formally standardized. The most
|
||||
authoritative public specification to date has been the documentation of a Go
|
||||
Language [package][parser] written by Blake Mizerany and Keith Rarick.
|
||||
|
||||
[origin]: https://brandur.org/logfmt
|
||||
[parser]: https://pkg.go.dev/github.com/kr/logfmt
|
||||
|
||||
## Goals
|
||||
|
||||
This project attempts to conform as closely as possible to the prior art, while
|
||||
also removing ambiguity where necessary to provide well behaved encoder and
|
||||
decoder implementations.
|
||||
|
||||
## Non-goals
|
||||
|
||||
This project does not attempt to formally standardize the logfmt format. In the
|
||||
event that logfmt is standardized this project would take conforming to the
|
||||
standard as a goal.
|
||||
|
||||
## Versioning
|
||||
|
||||
This project publishes releases according to the Go language guidelines for
|
||||
[developing and publishing modules][pub].
|
||||
|
||||
[pub]: https://go.dev/doc/modules/developing
|
||||
|
|
@ -0,0 +1,254 @@
|
|||
package logfmt
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// A Decoder reads and decodes logfmt records from an input stream.
|
||||
type Decoder struct {
|
||||
pos int
|
||||
key []byte
|
||||
value []byte
|
||||
lineNum int
|
||||
s *bufio.Scanner
|
||||
err error
|
||||
}
|
||||
|
||||
// NewDecoder returns a new decoder that reads from r.
|
||||
//
|
||||
// The decoder introduces its own buffering and may read data from r beyond
|
||||
// the logfmt records requested.
|
||||
func NewDecoder(r io.Reader) *Decoder {
|
||||
dec := &Decoder{
|
||||
s: bufio.NewScanner(r),
|
||||
}
|
||||
return dec
|
||||
}
|
||||
|
||||
// NewDecoderSize returns a new decoder that reads from r.
|
||||
//
|
||||
// The decoder introduces its own buffering and may read data from r beyond
|
||||
// the logfmt records requested.
|
||||
// The size argument specifies the size of the initial buffer that the
|
||||
// Decoder will use to read records from r.
|
||||
// If a log line is longer than the size argument, the Decoder will return
|
||||
// a bufio.ErrTooLong error.
|
||||
func NewDecoderSize(r io.Reader, size int) *Decoder {
|
||||
scanner := bufio.NewScanner(r)
|
||||
scanner.Buffer(make([]byte, 0, size), size)
|
||||
dec := &Decoder{
|
||||
s: scanner,
|
||||
}
|
||||
return dec
|
||||
}
|
||||
|
||||
// ScanRecord advances the Decoder to the next record, which can then be
|
||||
// parsed with the ScanKeyval method. It returns false when decoding stops,
|
||||
// either by reaching the end of the input or an error. After ScanRecord
|
||||
// returns false, the Err method will return any error that occurred during
|
||||
// decoding, except that if it was io.EOF, Err will return nil.
|
||||
func (dec *Decoder) ScanRecord() bool {
|
||||
if dec.err != nil {
|
||||
return false
|
||||
}
|
||||
if !dec.s.Scan() {
|
||||
dec.err = dec.s.Err()
|
||||
return false
|
||||
}
|
||||
dec.lineNum++
|
||||
dec.pos = 0
|
||||
return true
|
||||
}
|
||||
|
||||
// ScanKeyval advances the Decoder to the next key/value pair of the current
|
||||
// record, which can then be retrieved with the Key and Value methods. It
|
||||
// returns false when decoding stops, either by reaching the end of the
|
||||
// current record or an error.
|
||||
func (dec *Decoder) ScanKeyval() bool {
|
||||
dec.key, dec.value = nil, nil
|
||||
if dec.err != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
line := dec.s.Bytes()
|
||||
|
||||
// garbage
|
||||
for p, c := range line[dec.pos:] {
|
||||
if c > ' ' {
|
||||
dec.pos += p
|
||||
goto key
|
||||
}
|
||||
}
|
||||
dec.pos = len(line)
|
||||
return false
|
||||
|
||||
key:
|
||||
const invalidKeyError = "invalid key"
|
||||
|
||||
start, multibyte := dec.pos, false
|
||||
for p, c := range line[dec.pos:] {
|
||||
switch {
|
||||
case c == '=':
|
||||
dec.pos += p
|
||||
if dec.pos > start {
|
||||
dec.key = line[start:dec.pos]
|
||||
if multibyte && bytes.ContainsRune(dec.key, utf8.RuneError) {
|
||||
dec.syntaxError(invalidKeyError)
|
||||
return false
|
||||
}
|
||||
}
|
||||
if dec.key == nil {
|
||||
dec.unexpectedByte(c)
|
||||
return false
|
||||
}
|
||||
goto equal
|
||||
case c == '"':
|
||||
dec.pos += p
|
||||
dec.unexpectedByte(c)
|
||||
return false
|
||||
case c <= ' ':
|
||||
dec.pos += p
|
||||
if dec.pos > start {
|
||||
dec.key = line[start:dec.pos]
|
||||
if multibyte && bytes.ContainsRune(dec.key, utf8.RuneError) {
|
||||
dec.syntaxError(invalidKeyError)
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
case c >= utf8.RuneSelf:
|
||||
multibyte = true
|
||||
}
|
||||
}
|
||||
dec.pos = len(line)
|
||||
if dec.pos > start {
|
||||
dec.key = line[start:dec.pos]
|
||||
if multibyte && bytes.ContainsRune(dec.key, utf8.RuneError) {
|
||||
dec.syntaxError(invalidKeyError)
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
|
||||
equal:
|
||||
dec.pos++
|
||||
if dec.pos >= len(line) {
|
||||
return true
|
||||
}
|
||||
switch c := line[dec.pos]; {
|
||||
case c <= ' ':
|
||||
return true
|
||||
case c == '"':
|
||||
goto qvalue
|
||||
}
|
||||
|
||||
// value
|
||||
start = dec.pos
|
||||
for p, c := range line[dec.pos:] {
|
||||
switch {
|
||||
case c == '=' || c == '"':
|
||||
dec.pos += p
|
||||
dec.unexpectedByte(c)
|
||||
return false
|
||||
case c <= ' ':
|
||||
dec.pos += p
|
||||
if dec.pos > start {
|
||||
dec.value = line[start:dec.pos]
|
||||
}
|
||||
return true
|
||||
}
|
||||
}
|
||||
dec.pos = len(line)
|
||||
if dec.pos > start {
|
||||
dec.value = line[start:dec.pos]
|
||||
}
|
||||
return true
|
||||
|
||||
qvalue:
|
||||
const (
|
||||
untermQuote = "unterminated quoted value"
|
||||
invalidQuote = "invalid quoted value"
|
||||
)
|
||||
|
||||
hasEsc, esc := false, false
|
||||
start = dec.pos
|
||||
for p, c := range line[dec.pos+1:] {
|
||||
switch {
|
||||
case esc:
|
||||
esc = false
|
||||
case c == '\\':
|
||||
hasEsc, esc = true, true
|
||||
case c == '"':
|
||||
dec.pos += p + 2
|
||||
if hasEsc {
|
||||
v, ok := unquoteBytes(line[start:dec.pos])
|
||||
if !ok {
|
||||
dec.syntaxError(invalidQuote)
|
||||
return false
|
||||
}
|
||||
dec.value = v
|
||||
} else {
|
||||
start++
|
||||
end := dec.pos - 1
|
||||
if end > start {
|
||||
dec.value = line[start:end]
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
}
|
||||
dec.pos = len(line)
|
||||
dec.syntaxError(untermQuote)
|
||||
return false
|
||||
}
|
||||
|
||||
// Key returns the most recent key found by a call to ScanKeyval. The returned
|
||||
// slice may point to internal buffers and is only valid until the next call
|
||||
// to ScanRecord. It does no allocation.
|
||||
func (dec *Decoder) Key() []byte {
|
||||
return dec.key
|
||||
}
|
||||
|
||||
// Value returns the most recent value found by a call to ScanKeyval. The
|
||||
// returned slice may point to internal buffers and is only valid until the
|
||||
// next call to ScanRecord. It does no allocation when the value has no
|
||||
// escape sequences.
|
||||
func (dec *Decoder) Value() []byte {
|
||||
return dec.value
|
||||
}
|
||||
|
||||
// Err returns the first non-EOF error that was encountered by the Scanner.
|
||||
func (dec *Decoder) Err() error {
|
||||
return dec.err
|
||||
}
|
||||
|
||||
func (dec *Decoder) syntaxError(msg string) {
|
||||
dec.err = &SyntaxError{
|
||||
Msg: msg,
|
||||
Line: dec.lineNum,
|
||||
Pos: dec.pos + 1,
|
||||
}
|
||||
}
|
||||
|
||||
func (dec *Decoder) unexpectedByte(c byte) {
|
||||
dec.err = &SyntaxError{
|
||||
Msg: fmt.Sprintf("unexpected %q", c),
|
||||
Line: dec.lineNum,
|
||||
Pos: dec.pos + 1,
|
||||
}
|
||||
}
|
||||
|
||||
// A SyntaxError represents a syntax error in the logfmt input stream.
|
||||
type SyntaxError struct {
|
||||
Msg string
|
||||
Line int
|
||||
Pos int
|
||||
}
|
||||
|
||||
func (e *SyntaxError) Error() string {
|
||||
return fmt.Sprintf("logfmt syntax error at pos %d on line %d: %s", e.Pos, e.Line, e.Msg)
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
// Package logfmt implements utilities to marshal and unmarshal data in the
|
||||
// logfmt format. The logfmt format records key/value pairs in a way that
|
||||
// balances readability for humans and simplicity of computer parsing. It is
|
||||
// most commonly used as a more human friendly alternative to JSON for
|
||||
// structured logging.
|
||||
package logfmt
|
||||
|
|
@ -0,0 +1,322 @@
|
|||
package logfmt
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// MarshalKeyvals returns the logfmt encoding of keyvals, a variadic sequence
|
||||
// of alternating keys and values.
|
||||
func MarshalKeyvals(keyvals ...interface{}) ([]byte, error) {
|
||||
buf := &bytes.Buffer{}
|
||||
if err := NewEncoder(buf).EncodeKeyvals(keyvals...); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return buf.Bytes(), nil
|
||||
}
|
||||
|
||||
// An Encoder writes logfmt data to an output stream.
|
||||
type Encoder struct {
|
||||
w io.Writer
|
||||
scratch bytes.Buffer
|
||||
needSep bool
|
||||
}
|
||||
|
||||
// NewEncoder returns a new encoder that writes to w.
|
||||
func NewEncoder(w io.Writer) *Encoder {
|
||||
return &Encoder{
|
||||
w: w,
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
space = []byte(" ")
|
||||
equals = []byte("=")
|
||||
newline = []byte("\n")
|
||||
null = []byte("null")
|
||||
)
|
||||
|
||||
// EncodeKeyval writes the logfmt encoding of key and value to the stream. A
|
||||
// single space is written before the second and subsequent keys in a record.
|
||||
// Nothing is written if a non-nil error is returned.
|
||||
func (enc *Encoder) EncodeKeyval(key, value interface{}) error {
|
||||
enc.scratch.Reset()
|
||||
if enc.needSep {
|
||||
if _, err := enc.scratch.Write(space); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := writeKey(&enc.scratch, key); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := enc.scratch.Write(equals); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := writeValue(&enc.scratch, value); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := enc.w.Write(enc.scratch.Bytes())
|
||||
enc.needSep = true
|
||||
return err
|
||||
}
|
||||
|
||||
// EncodeKeyvals writes the logfmt encoding of keyvals to the stream. Keyvals
|
||||
// is a variadic sequence of alternating keys and values. Keys of unsupported
|
||||
// type are skipped along with their corresponding value. Values of
|
||||
// unsupported type or that cause a MarshalerError are replaced by their error
|
||||
// but do not cause EncodeKeyvals to return an error. If a non-nil error is
|
||||
// returned some key/value pairs may not have be written.
|
||||
func (enc *Encoder) EncodeKeyvals(keyvals ...interface{}) error {
|
||||
if len(keyvals) == 0 {
|
||||
return nil
|
||||
}
|
||||
if len(keyvals)%2 == 1 {
|
||||
keyvals = append(keyvals, nil)
|
||||
}
|
||||
for i := 0; i < len(keyvals); i += 2 {
|
||||
k, v := keyvals[i], keyvals[i+1]
|
||||
err := enc.EncodeKeyval(k, v)
|
||||
if err == ErrUnsupportedKeyType {
|
||||
continue
|
||||
}
|
||||
if _, ok := err.(*MarshalerError); ok || err == ErrUnsupportedValueType {
|
||||
v = err
|
||||
err = enc.EncodeKeyval(k, v)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarshalerError represents an error encountered while marshaling a value.
|
||||
type MarshalerError struct {
|
||||
Type reflect.Type
|
||||
Err error
|
||||
}
|
||||
|
||||
func (e *MarshalerError) Error() string {
|
||||
return "error marshaling value of type " + e.Type.String() + ": " + e.Err.Error()
|
||||
}
|
||||
|
||||
// ErrNilKey is returned by Marshal functions and Encoder methods if a key is
|
||||
// a nil interface or pointer value.
|
||||
var ErrNilKey = errors.New("nil key")
|
||||
|
||||
// ErrInvalidKey is returned by Marshal functions and Encoder methods if, after
|
||||
// dropping invalid runes, a key is empty.
|
||||
var ErrInvalidKey = errors.New("invalid key")
|
||||
|
||||
// ErrUnsupportedKeyType is returned by Encoder methods if a key has an
|
||||
// unsupported type.
|
||||
var ErrUnsupportedKeyType = errors.New("unsupported key type")
|
||||
|
||||
// ErrUnsupportedValueType is returned by Encoder methods if a value has an
|
||||
// unsupported type.
|
||||
var ErrUnsupportedValueType = errors.New("unsupported value type")
|
||||
|
||||
func writeKey(w io.Writer, key interface{}) error {
|
||||
if key == nil {
|
||||
return ErrNilKey
|
||||
}
|
||||
|
||||
switch k := key.(type) {
|
||||
case string:
|
||||
return writeStringKey(w, k)
|
||||
case []byte:
|
||||
if k == nil {
|
||||
return ErrNilKey
|
||||
}
|
||||
return writeBytesKey(w, k)
|
||||
case encoding.TextMarshaler:
|
||||
kb, err := safeMarshal(k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if kb == nil {
|
||||
return ErrNilKey
|
||||
}
|
||||
return writeBytesKey(w, kb)
|
||||
case fmt.Stringer:
|
||||
ks, ok := safeString(k)
|
||||
if !ok {
|
||||
return ErrNilKey
|
||||
}
|
||||
return writeStringKey(w, ks)
|
||||
default:
|
||||
rkey := reflect.ValueOf(key)
|
||||
switch rkey.Kind() {
|
||||
case reflect.Array, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Struct:
|
||||
return ErrUnsupportedKeyType
|
||||
case reflect.Ptr:
|
||||
if rkey.IsNil() {
|
||||
return ErrNilKey
|
||||
}
|
||||
return writeKey(w, rkey.Elem().Interface())
|
||||
}
|
||||
return writeStringKey(w, fmt.Sprint(k))
|
||||
}
|
||||
}
|
||||
|
||||
// keyRuneFilter returns r for all valid key runes, and -1 for all invalid key
|
||||
// runes. When used as the mapping function for strings.Map and bytes.Map
|
||||
// functions it causes them to remove invalid key runes from strings or byte
|
||||
// slices respectively.
|
||||
func keyRuneFilter(r rune) rune {
|
||||
if r <= ' ' || r == '=' || r == '"' || r == utf8.RuneError {
|
||||
return -1
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func writeStringKey(w io.Writer, key string) error {
|
||||
k := strings.Map(keyRuneFilter, key)
|
||||
if k == "" {
|
||||
return ErrInvalidKey
|
||||
}
|
||||
_, err := io.WriteString(w, k)
|
||||
return err
|
||||
}
|
||||
|
||||
func writeBytesKey(w io.Writer, key []byte) error {
|
||||
k := bytes.Map(keyRuneFilter, key)
|
||||
if len(k) == 0 {
|
||||
return ErrInvalidKey
|
||||
}
|
||||
_, err := w.Write(k)
|
||||
return err
|
||||
}
|
||||
|
||||
func writeValue(w io.Writer, value interface{}) error {
|
||||
switch v := value.(type) {
|
||||
case nil:
|
||||
return writeBytesValue(w, null)
|
||||
case string:
|
||||
return writeStringValue(w, v, true)
|
||||
case []byte:
|
||||
return writeBytesValue(w, v)
|
||||
case encoding.TextMarshaler:
|
||||
vb, err := safeMarshal(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if vb == nil {
|
||||
vb = null
|
||||
}
|
||||
return writeBytesValue(w, vb)
|
||||
case error:
|
||||
se, ok := safeError(v)
|
||||
return writeStringValue(w, se, ok)
|
||||
case fmt.Stringer:
|
||||
ss, ok := safeString(v)
|
||||
return writeStringValue(w, ss, ok)
|
||||
default:
|
||||
rvalue := reflect.ValueOf(value)
|
||||
switch rvalue.Kind() {
|
||||
case reflect.Array, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Struct:
|
||||
return ErrUnsupportedValueType
|
||||
case reflect.Ptr:
|
||||
if rvalue.IsNil() {
|
||||
return writeBytesValue(w, null)
|
||||
}
|
||||
return writeValue(w, rvalue.Elem().Interface())
|
||||
}
|
||||
return writeStringValue(w, fmt.Sprint(v), true)
|
||||
}
|
||||
}
|
||||
|
||||
func needsQuotedValueRune(r rune) bool {
|
||||
return r <= ' ' || r == '=' || r == '"' || r == utf8.RuneError
|
||||
}
|
||||
|
||||
func writeStringValue(w io.Writer, value string, ok bool) error {
|
||||
var err error
|
||||
if ok && value == "null" {
|
||||
_, err = io.WriteString(w, `"null"`)
|
||||
} else if strings.IndexFunc(value, needsQuotedValueRune) != -1 {
|
||||
_, err = writeQuotedString(w, value)
|
||||
} else {
|
||||
_, err = io.WriteString(w, value)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func writeBytesValue(w io.Writer, value []byte) error {
|
||||
var err error
|
||||
if bytes.IndexFunc(value, needsQuotedValueRune) != -1 {
|
||||
_, err = writeQuotedBytes(w, value)
|
||||
} else {
|
||||
_, err = w.Write(value)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// EndRecord writes a newline character to the stream and resets the encoder
|
||||
// to the beginning of a new record.
|
||||
func (enc *Encoder) EndRecord() error {
|
||||
_, err := enc.w.Write(newline)
|
||||
if err == nil {
|
||||
enc.needSep = false
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// Reset resets the encoder to the beginning of a new record.
|
||||
func (enc *Encoder) Reset() {
|
||||
enc.needSep = false
|
||||
}
|
||||
|
||||
func safeError(err error) (s string, ok bool) {
|
||||
defer func() {
|
||||
if panicVal := recover(); panicVal != nil {
|
||||
if v := reflect.ValueOf(err); v.Kind() == reflect.Ptr && v.IsNil() {
|
||||
s, ok = "null", false
|
||||
} else {
|
||||
s, ok = fmt.Sprintf("PANIC:%v", panicVal), false
|
||||
}
|
||||
}
|
||||
}()
|
||||
s, ok = err.Error(), true
|
||||
return
|
||||
}
|
||||
|
||||
func safeString(str fmt.Stringer) (s string, ok bool) {
|
||||
defer func() {
|
||||
if panicVal := recover(); panicVal != nil {
|
||||
if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() {
|
||||
s, ok = "null", false
|
||||
} else {
|
||||
s, ok = fmt.Sprintf("PANIC:%v", panicVal), true
|
||||
}
|
||||
}
|
||||
}()
|
||||
s, ok = str.String(), true
|
||||
return
|
||||
}
|
||||
|
||||
func safeMarshal(tm encoding.TextMarshaler) (b []byte, err error) {
|
||||
defer func() {
|
||||
if panicVal := recover(); panicVal != nil {
|
||||
if v := reflect.ValueOf(tm); v.Kind() == reflect.Ptr && v.IsNil() {
|
||||
b, err = nil, nil
|
||||
} else {
|
||||
b, err = nil, fmt.Errorf("panic when marshalling: %s", panicVal)
|
||||
}
|
||||
}
|
||||
}()
|
||||
b, err = tm.MarshalText()
|
||||
if err != nil {
|
||||
return nil, &MarshalerError{
|
||||
Type: reflect.TypeOf(tm),
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
package logfmt
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"strconv"
|
||||
"sync"
|
||||
"unicode"
|
||||
"unicode/utf16"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// Taken from Go's encoding/json and modified for use here.
|
||||
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
var hex = "0123456789abcdef"
|
||||
|
||||
var bufferPool = sync.Pool{
|
||||
New: func() interface{} {
|
||||
return &bytes.Buffer{}
|
||||
},
|
||||
}
|
||||
|
||||
func getBuffer() *bytes.Buffer {
|
||||
return bufferPool.Get().(*bytes.Buffer)
|
||||
}
|
||||
|
||||
func poolBuffer(buf *bytes.Buffer) {
|
||||
buf.Reset()
|
||||
bufferPool.Put(buf)
|
||||
}
|
||||
|
||||
// NOTE: keep in sync with writeQuotedBytes below.
|
||||
func writeQuotedString(w io.Writer, s string) (int, error) {
|
||||
buf := getBuffer()
|
||||
buf.WriteByte('"')
|
||||
start := 0
|
||||
for i := 0; i < len(s); {
|
||||
if b := s[i]; b < utf8.RuneSelf {
|
||||
if 0x20 <= b && b != '\\' && b != '"' {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
if start < i {
|
||||
buf.WriteString(s[start:i])
|
||||
}
|
||||
switch b {
|
||||
case '\\', '"':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte(b)
|
||||
case '\n':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('n')
|
||||
case '\r':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('r')
|
||||
case '\t':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('t')
|
||||
default:
|
||||
// This encodes bytes < 0x20 except for \n, \r, and \t.
|
||||
buf.WriteString(`\u00`)
|
||||
buf.WriteByte(hex[b>>4])
|
||||
buf.WriteByte(hex[b&0xF])
|
||||
}
|
||||
i++
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
c, size := utf8.DecodeRuneInString(s[i:])
|
||||
if c == utf8.RuneError {
|
||||
if start < i {
|
||||
buf.WriteString(s[start:i])
|
||||
}
|
||||
buf.WriteString(`\ufffd`)
|
||||
i += size
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
i += size
|
||||
}
|
||||
if start < len(s) {
|
||||
buf.WriteString(s[start:])
|
||||
}
|
||||
buf.WriteByte('"')
|
||||
n, err := w.Write(buf.Bytes())
|
||||
poolBuffer(buf)
|
||||
return n, err
|
||||
}
|
||||
|
||||
// NOTE: keep in sync with writeQuoteString above.
|
||||
func writeQuotedBytes(w io.Writer, s []byte) (int, error) {
|
||||
buf := getBuffer()
|
||||
buf.WriteByte('"')
|
||||
start := 0
|
||||
for i := 0; i < len(s); {
|
||||
if b := s[i]; b < utf8.RuneSelf {
|
||||
if 0x20 <= b && b != '\\' && b != '"' {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
if start < i {
|
||||
buf.Write(s[start:i])
|
||||
}
|
||||
switch b {
|
||||
case '\\', '"':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte(b)
|
||||
case '\n':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('n')
|
||||
case '\r':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('r')
|
||||
case '\t':
|
||||
buf.WriteByte('\\')
|
||||
buf.WriteByte('t')
|
||||
default:
|
||||
// This encodes bytes < 0x20 except for \n, \r, and \t.
|
||||
buf.WriteString(`\u00`)
|
||||
buf.WriteByte(hex[b>>4])
|
||||
buf.WriteByte(hex[b&0xF])
|
||||
}
|
||||
i++
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
c, size := utf8.DecodeRune(s[i:])
|
||||
if c == utf8.RuneError {
|
||||
if start < i {
|
||||
buf.Write(s[start:i])
|
||||
}
|
||||
buf.WriteString(`\ufffd`)
|
||||
i += size
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
i += size
|
||||
}
|
||||
if start < len(s) {
|
||||
buf.Write(s[start:])
|
||||
}
|
||||
buf.WriteByte('"')
|
||||
n, err := w.Write(buf.Bytes())
|
||||
poolBuffer(buf)
|
||||
return n, err
|
||||
}
|
||||
|
||||
// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
|
||||
// or it returns -1.
|
||||
func getu4(s []byte) rune {
|
||||
if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
|
||||
return -1
|
||||
}
|
||||
r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
|
||||
if err != nil {
|
||||
return -1
|
||||
}
|
||||
return rune(r)
|
||||
}
|
||||
|
||||
func unquoteBytes(s []byte) (t []byte, ok bool) {
|
||||
if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
|
||||
return
|
||||
}
|
||||
s = s[1 : len(s)-1]
|
||||
|
||||
// Check for unusual characters. If there are none,
|
||||
// then no unquoting is needed, so return a slice of the
|
||||
// original bytes.
|
||||
r := 0
|
||||
for r < len(s) {
|
||||
c := s[r]
|
||||
if c == '\\' || c == '"' || c < ' ' {
|
||||
break
|
||||
}
|
||||
if c < utf8.RuneSelf {
|
||||
r++
|
||||
continue
|
||||
}
|
||||
rr, size := utf8.DecodeRune(s[r:])
|
||||
if rr == utf8.RuneError {
|
||||
break
|
||||
}
|
||||
r += size
|
||||
}
|
||||
if r == len(s) {
|
||||
return s, true
|
||||
}
|
||||
|
||||
b := make([]byte, len(s)+2*utf8.UTFMax)
|
||||
w := copy(b, s[0:r])
|
||||
for r < len(s) {
|
||||
// Out of room? Can only happen if s is full of
|
||||
// malformed UTF-8 and we're replacing each
|
||||
// byte with RuneError.
|
||||
if w >= len(b)-2*utf8.UTFMax {
|
||||
nb := make([]byte, (len(b)+utf8.UTFMax)*2)
|
||||
copy(nb, b[0:w])
|
||||
b = nb
|
||||
}
|
||||
switch c := s[r]; {
|
||||
case c == '\\':
|
||||
r++
|
||||
if r >= len(s) {
|
||||
return
|
||||
}
|
||||
switch s[r] {
|
||||
default:
|
||||
return
|
||||
case '"', '\\', '/', '\'':
|
||||
b[w] = s[r]
|
||||
r++
|
||||
w++
|
||||
case 'b':
|
||||
b[w] = '\b'
|
||||
r++
|
||||
w++
|
||||
case 'f':
|
||||
b[w] = '\f'
|
||||
r++
|
||||
w++
|
||||
case 'n':
|
||||
b[w] = '\n'
|
||||
r++
|
||||
w++
|
||||
case 'r':
|
||||
b[w] = '\r'
|
||||
r++
|
||||
w++
|
||||
case 't':
|
||||
b[w] = '\t'
|
||||
r++
|
||||
w++
|
||||
case 'u':
|
||||
r--
|
||||
rr := getu4(s[r:])
|
||||
if rr < 0 {
|
||||
return
|
||||
}
|
||||
r += 6
|
||||
if utf16.IsSurrogate(rr) {
|
||||
rr1 := getu4(s[r:])
|
||||
if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
|
||||
// A valid pair; consume.
|
||||
r += 6
|
||||
w += utf8.EncodeRune(b[w:], dec)
|
||||
break
|
||||
}
|
||||
// Invalid surrogate; fall back to replacement rune.
|
||||
rr = unicode.ReplacementChar
|
||||
}
|
||||
w += utf8.EncodeRune(b[w:], rr)
|
||||
}
|
||||
|
||||
// Quote, control characters are invalid.
|
||||
case c == '"', c < ' ':
|
||||
return
|
||||
|
||||
// ASCII
|
||||
case c < utf8.RuneSelf:
|
||||
b[w] = c
|
||||
r++
|
||||
w++
|
||||
|
||||
// Coerce to well-formed UTF-8.
|
||||
default:
|
||||
rr, size := utf8.DecodeRune(s[r:])
|
||||
r += size
|
||||
w += utf8.EncodeRune(b[w:], rr)
|
||||
}
|
||||
}
|
||||
return b[0:w], true
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
.DS_Store
|
||||
bin
|
||||
.idea/
|
||||
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
Copyright (c) 2012 Dave Grijalva
|
||||
Copyright (c) 2021 golang-jwt maintainers
|
||||
|
||||
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.
|
||||
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
## Migration Guide (v3.2.1)
|
||||
|
||||
Starting from [v3.2.1](https://github.com/golang-jwt/jwt/releases/tag/v3.2.1]), the import path has changed from `github.com/dgrijalva/jwt-go` to `github.com/golang-jwt/jwt`. Future releases will be using the `github.com/golang-jwt/jwt` import path and continue the existing versioning scheme of `v3.x.x+incompatible`. Backwards-compatible patches and fixes will be done on the `v3` release branch, where as new build-breaking features will be developed in a `v4` release, possibly including a SIV-style import path.
|
||||
|
||||
### go.mod replacement
|
||||
|
||||
In a first step, the easiest way is to use `go mod edit` to issue a replacement.
|
||||
|
||||
```
|
||||
go mod edit -replace github.com/dgrijalva/jwt-go=github.com/golang-jwt/jwt@v3.2.1+incompatible
|
||||
go mod tidy
|
||||
```
|
||||
|
||||
This will still keep the old import path in your code but replace it with the new package and also introduce a new indirect dependency to `github.com/golang-jwt/jwt`. Try to compile your project; it should still work.
|
||||
|
||||
### Cleanup
|
||||
|
||||
If your code still consistently builds, you can replace all occurences of `github.com/dgrijalva/jwt-go` with `github.com/golang-jwt/jwt`, either manually or by using tools such as `sed`. Finally, the `replace` directive in the `go.mod` file can be removed.
|
||||
|
||||
## Older releases (before v3.2.0)
|
||||
|
||||
The original migration guide for older releases can be found at https://github.com/dgrijalva/jwt-go/blob/master/MIGRATION_GUIDE.md.
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
# jwt-go
|
||||
|
||||
[](https://github.com/golang-jwt/jwt/actions/workflows/build.yml)
|
||||
[](https://pkg.go.dev/github.com/golang-jwt/jwt)
|
||||
|
||||
A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](https://datatracker.ietf.org/doc/html/rfc7519).
|
||||
|
||||
**IMPORT PATH CHANGE:** Starting from [v3.2.1](https://github.com/golang-jwt/jwt/releases/tag/v3.2.1), the import path has changed from `github.com/dgrijalva/jwt-go` to `github.com/golang-jwt/jwt`. After the original author of the library suggested migrating the maintenance of `jwt-go`, a dedicated team of open source maintainers decided to clone the existing library into this repository. See [dgrijalva/jwt-go#462](https://github.com/dgrijalva/jwt-go/issues/462) for a detailed discussion on this topic.
|
||||
|
||||
Future releases will be using the `github.com/golang-jwt/jwt` import path and continue the existing versioning scheme of `v3.x.x+incompatible`. Backwards-compatible patches and fixes will be done on the `v3` release branch, where as new build-breaking features will be developed in a `v4` release, possibly including a SIV-style import path.
|
||||
|
||||
**SECURITY NOTICE:** Some older versions of Go have a security issue in the crypto/elliptic. Recommendation is to upgrade to at least 1.15 See issue [dgrijalva/jwt-go#216](https://github.com/dgrijalva/jwt-go/issues/216) for more detail.
|
||||
|
||||
**SECURITY NOTICE:** It's important that you [validate the `alg` presented is what you expect](https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/). This library attempts to make it easy to do the right thing by requiring key types match the expected alg, but you should take the extra step to verify it in your usage. See the examples provided.
|
||||
|
||||
### Supported Go versions
|
||||
|
||||
Our support of Go versions is aligned with Go's [version release policy](https://golang.org/doc/devel/release#policy).
|
||||
So we will support a major version of Go until there are two newer major releases.
|
||||
We no longer support building jwt-go with unsupported Go versions, as these contain security vulnerabilities
|
||||
which will not be fixed.
|
||||
|
||||
## What the heck is a JWT?
|
||||
|
||||
JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens.
|
||||
|
||||
In short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used for `Bearer` tokens in Oauth 2. A token is made of three parts, separated by `.`'s. The first two parts are JSON objects, that have been [base64url](https://datatracker.ietf.org/doc/html/rfc4648) encoded. The last part is the signature, encoded the same way.
|
||||
|
||||
The first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used.
|
||||
|
||||
The part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer to [RFC 7519](https://datatracker.ietf.org/doc/html/rfc7519) for information about reserved keys and the proper way to add your own.
|
||||
|
||||
## What's in the box?
|
||||
|
||||
This library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.
|
||||
|
||||
## Examples
|
||||
|
||||
See [the project documentation](https://pkg.go.dev/github.com/golang-jwt/jwt) for examples of usage:
|
||||
|
||||
* [Simple example of parsing and validating a token](https://pkg.go.dev/github.com/golang-jwt/jwt#example-Parse-Hmac)
|
||||
* [Simple example of building and signing a token](https://pkg.go.dev/github.com/golang-jwt/jwt#example-New-Hmac)
|
||||
* [Directory of Examples](https://pkg.go.dev/github.com/golang-jwt/jwt#pkg-examples)
|
||||
|
||||
## Extensions
|
||||
|
||||
This library publishes all the necessary components for adding your own signing methods. Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`.
|
||||
|
||||
Here's an example of an extension that integrates with multiple Google Cloud Platform signing tools (AppEngine, IAM API, Cloud KMS): https://github.com/someone1/gcp-jwt-go
|
||||
|
||||
## Compliance
|
||||
|
||||
This library was last reviewed to comply with [RTF 7519](https://datatracker.ietf.org/doc/html/rfc7519) dated May 2015 with a few notable differences:
|
||||
|
||||
* In order to protect against accidental use of [Unsecured JWTs](https://datatracker.ietf.org/doc/html/rfc7519#section-6), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key.
|
||||
|
||||
## Project Status & Versioning
|
||||
|
||||
This library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).
|
||||
|
||||
This project uses [Semantic Versioning 2.0.0](http://semver.org). Accepted pull requests will land on `main`. Periodically, versions will be tagged from `main`. You can find all the releases on [the project releases page](https://github.com/golang-jwt/jwt/releases).
|
||||
|
||||
While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users. You may want to use this alternative package include: `gopkg.in/golang-jwt/jwt.v3`. It will do the right thing WRT semantic versioning.
|
||||
|
||||
**BREAKING CHANGES:***
|
||||
* Version 3.0.0 includes _a lot_ of changes from the 2.x line, including a few that break the API. We've tried to break as few things as possible, so there should just be a few type signature changes. A full list of breaking changes is available in `VERSION_HISTORY.md`. See `MIGRATION_GUIDE.md` for more information on updating your code.
|
||||
|
||||
## Usage Tips
|
||||
|
||||
### Signing vs Encryption
|
||||
|
||||
A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:
|
||||
|
||||
* The author of the token was in the possession of the signing secret
|
||||
* The data has not been modified since it was signed
|
||||
|
||||
It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library.
|
||||
|
||||
### Choosing a Signing Method
|
||||
|
||||
There are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric.
|
||||
|
||||
Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.
|
||||
|
||||
Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.
|
||||
|
||||
### Signing Methods and Key Types
|
||||
|
||||
Each signing method expects a different object type for its signing keys. See the package documentation for details. Here are the most common ones:
|
||||
|
||||
* The [HMAC signing method](https://pkg.go.dev/github.com/golang-jwt/jwt#SigningMethodHMAC) (`HS256`,`HS384`,`HS512`) expect `[]byte` values for signing and validation
|
||||
* The [RSA signing method](https://pkg.go.dev/github.com/golang-jwt/jwt#SigningMethodRSA) (`RS256`,`RS384`,`RS512`) expect `*rsa.PrivateKey` for signing and `*rsa.PublicKey` for validation
|
||||
* The [ECDSA signing method](https://pkg.go.dev/github.com/golang-jwt/jwt#SigningMethodECDSA) (`ES256`,`ES384`,`ES512`) expect `*ecdsa.PrivateKey` for signing and `*ecdsa.PublicKey` for validation
|
||||
|
||||
### JWT and OAuth
|
||||
|
||||
It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.
|
||||
|
||||
Without going too far down the rabbit hole, here's a description of the interaction of these technologies:
|
||||
|
||||
* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.
|
||||
* OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.
|
||||
* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.
|
||||
|
||||
### Troubleshooting
|
||||
|
||||
This library uses descriptive error messages whenever possible. If you are not getting the expected result, have a look at the errors. The most common place people get stuck is providing the correct type of key to the parser. See the above section on signing methods and key types.
|
||||
|
||||
## More
|
||||
|
||||
Documentation can be found [on pkg.go.dev](https://pkg.go.dev/github.com/golang-jwt/jwt).
|
||||
|
||||
The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in the documentation.
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
## `jwt-go` Version History
|
||||
|
||||
#### 3.2.2
|
||||
|
||||
* Starting from this release, we are adopting the policy to support the most 2 recent versions of Go currently available. By the time of this release, this is Go 1.15 and 1.16 ([#28](https://github.com/golang-jwt/jwt/pull/28)).
|
||||
* Fixed a potential issue that could occur when the verification of `exp`, `iat` or `nbf` was not required and contained invalid contents, i.e. non-numeric/date. Thanks for @thaJeztah for making us aware of that and @giorgos-f3 for originally reporting it to the formtech fork ([#40](https://github.com/golang-jwt/jwt/pull/40)).
|
||||
* Added support for EdDSA / ED25519 ([#36](https://github.com/golang-jwt/jwt/pull/36)).
|
||||
* Optimized allocations ([#33](https://github.com/golang-jwt/jwt/pull/33)).
|
||||
|
||||
#### 3.2.1
|
||||
|
||||
* **Import Path Change**: See MIGRATION_GUIDE.md for tips on updating your code
|
||||
* Changed the import path from `github.com/dgrijalva/jwt-go` to `github.com/golang-jwt/jwt`
|
||||
* Fixed type confusing issue between `string` and `[]string` in `VerifyAudience` ([#12](https://github.com/golang-jwt/jwt/pull/12)). This fixes CVE-2020-26160
|
||||
|
||||
#### 3.2.0
|
||||
|
||||
* Added method `ParseUnverified` to allow users to split up the tasks of parsing and validation
|
||||
* HMAC signing method returns `ErrInvalidKeyType` instead of `ErrInvalidKey` where appropriate
|
||||
* Added options to `request.ParseFromRequest`, which allows for an arbitrary list of modifiers to parsing behavior. Initial set include `WithClaims` and `WithParser`. Existing usage of this function will continue to work as before.
|
||||
* Deprecated `ParseFromRequestWithClaims` to simplify API in the future.
|
||||
|
||||
#### 3.1.0
|
||||
|
||||
* Improvements to `jwt` command line tool
|
||||
* Added `SkipClaimsValidation` option to `Parser`
|
||||
* Documentation updates
|
||||
|
||||
#### 3.0.0
|
||||
|
||||
* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code
|
||||
* Dropped support for `[]byte` keys when using RSA signing methods. This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods.
|
||||
* `ParseFromRequest` has been moved to `request` subpackage and usage has changed
|
||||
* The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`. The default value is type `MapClaims`, which is an alias to `map[string]interface{}`. This makes it possible to use a custom type when decoding claims.
|
||||
* Other Additions and Changes
|
||||
* Added `Claims` interface type to allow users to decode the claims into a custom type
|
||||
* Added `ParseWithClaims`, which takes a third argument of type `Claims`. Use this function instead of `Parse` if you have a custom type you'd like to decode into.
|
||||
* Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage
|
||||
* Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims`
|
||||
* Added new interface type `Extractor`, which is used for extracting JWT strings from http requests. Used with `ParseFromRequest` and `ParseFromRequestWithClaims`.
|
||||
* Added several new, more specific, validation errors to error type bitmask
|
||||
* Moved examples from README to executable example files
|
||||
* Signing method registry is now thread safe
|
||||
* Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser)
|
||||
|
||||
#### 2.7.0
|
||||
|
||||
This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes.
|
||||
|
||||
* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying
|
||||
* Error text for expired tokens includes how long it's been expired
|
||||
* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM`
|
||||
* Documentation updates
|
||||
|
||||
#### 2.6.0
|
||||
|
||||
* Exposed inner error within ValidationError
|
||||
* Fixed validation errors when using UseJSONNumber flag
|
||||
* Added several unit tests
|
||||
|
||||
#### 2.5.0
|
||||
|
||||
* Added support for signing method none. You shouldn't use this. The API tries to make this clear.
|
||||
* Updated/fixed some documentation
|
||||
* Added more helpful error message when trying to parse tokens that begin with `BEARER `
|
||||
|
||||
#### 2.4.0
|
||||
|
||||
* Added new type, Parser, to allow for configuration of various parsing parameters
|
||||
* You can now specify a list of valid signing methods. Anything outside this set will be rejected.
|
||||
* You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON
|
||||
* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go)
|
||||
* Fixed some bugs with ECDSA parsing
|
||||
|
||||
#### 2.3.0
|
||||
|
||||
* Added support for ECDSA signing methods
|
||||
* Added support for RSA PSS signing methods (requires go v1.4)
|
||||
|
||||
#### 2.2.0
|
||||
|
||||
* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`. Result will now be the parsed token and an error, instead of a panic.
|
||||
|
||||
#### 2.1.0
|
||||
|
||||
Backwards compatible API change that was missed in 2.0.0.
|
||||
|
||||
* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte`
|
||||
|
||||
#### 2.0.0
|
||||
|
||||
There were two major reasons for breaking backwards compatibility with this update. The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations. There will likely be no required code changes to support this change.
|
||||
|
||||
The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods. Not all keys used for all signing methods have a single standard on-disk representation. Requiring `[]byte` as the type for all keys proved too limiting. Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys. Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`.
|
||||
|
||||
It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`.
|
||||
|
||||
* **Compatibility Breaking Changes**
|
||||
* `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct`
|
||||
* `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct`
|
||||
* `KeyFunc` now returns `interface{}` instead of `[]byte`
|
||||
* `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key
|
||||
* `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key
|
||||
* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`. Specific sizes are now just instances of this type.
|
||||
* Added public package global `SigningMethodHS256`
|
||||
* Added public package global `SigningMethodHS384`
|
||||
* Added public package global `SigningMethodHS512`
|
||||
* Renamed type `SigningMethodRS256` to `SigningMethodRSA`. Specific sizes are now just instances of this type.
|
||||
* Added public package global `SigningMethodRS256`
|
||||
* Added public package global `SigningMethodRS384`
|
||||
* Added public package global `SigningMethodRS512`
|
||||
* Moved sample private key for HMAC tests from an inline value to a file on disk. Value is unchanged.
|
||||
* Refactored the RSA implementation to be easier to read
|
||||
* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM`
|
||||
|
||||
#### 1.0.2
|
||||
|
||||
* Fixed bug in parsing public keys from certificates
|
||||
* Added more tests around the parsing of keys for RS256
|
||||
* Code refactoring in RS256 implementation. No functional changes
|
||||
|
||||
#### 1.0.1
|
||||
|
||||
* Fixed panic if RS256 signing method was passed an invalid key
|
||||
|
||||
#### 1.0.0
|
||||
|
||||
* First versioned release
|
||||
* API stabilized
|
||||
* Supports creating, signing, parsing, and validating JWT tokens
|
||||
* Supports RS256 and HS256 signing methods
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto/subtle"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// For a type to be a Claims object, it must just have a Valid method that determines
|
||||
// if the token is invalid for any supported reason
|
||||
type Claims interface {
|
||||
Valid() error
|
||||
}
|
||||
|
||||
// Structured version of Claims Section, as referenced at
|
||||
// https://tools.ietf.org/html/rfc7519#section-4.1
|
||||
// See examples for how to use this with your own claim types
|
||||
type StandardClaims struct {
|
||||
Audience string `json:"aud,omitempty"`
|
||||
ExpiresAt int64 `json:"exp,omitempty"`
|
||||
Id string `json:"jti,omitempty"`
|
||||
IssuedAt int64 `json:"iat,omitempty"`
|
||||
Issuer string `json:"iss,omitempty"`
|
||||
NotBefore int64 `json:"nbf,omitempty"`
|
||||
Subject string `json:"sub,omitempty"`
|
||||
}
|
||||
|
||||
// Validates time based claims "exp, iat, nbf".
|
||||
// There is no accounting for clock skew.
|
||||
// As well, if any of the above claims are not in the token, it will still
|
||||
// be considered a valid claim.
|
||||
func (c StandardClaims) Valid() error {
|
||||
vErr := new(ValidationError)
|
||||
now := TimeFunc().Unix()
|
||||
|
||||
// The claims below are optional, by default, so if they are set to the
|
||||
// default value in Go, let's not fail the verification for them.
|
||||
if !c.VerifyExpiresAt(now, false) {
|
||||
delta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0))
|
||||
vErr.Inner = fmt.Errorf("token is expired by %v", delta)
|
||||
vErr.Errors |= ValidationErrorExpired
|
||||
}
|
||||
|
||||
if !c.VerifyIssuedAt(now, false) {
|
||||
vErr.Inner = fmt.Errorf("Token used before issued")
|
||||
vErr.Errors |= ValidationErrorIssuedAt
|
||||
}
|
||||
|
||||
if !c.VerifyNotBefore(now, false) {
|
||||
vErr.Inner = fmt.Errorf("token is not valid yet")
|
||||
vErr.Errors |= ValidationErrorNotValidYet
|
||||
}
|
||||
|
||||
if vErr.valid() {
|
||||
return nil
|
||||
}
|
||||
|
||||
return vErr
|
||||
}
|
||||
|
||||
// Compares the aud claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyAudience(cmp string, req bool) bool {
|
||||
return verifyAud([]string{c.Audience}, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the exp claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool {
|
||||
return verifyExp(c.ExpiresAt, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the iat claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool {
|
||||
return verifyIat(c.IssuedAt, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the iss claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool {
|
||||
return verifyIss(c.Issuer, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the nbf claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool {
|
||||
return verifyNbf(c.NotBefore, cmp, req)
|
||||
}
|
||||
|
||||
// ----- helpers
|
||||
|
||||
func verifyAud(aud []string, cmp string, required bool) bool {
|
||||
if len(aud) == 0 {
|
||||
return !required
|
||||
}
|
||||
// use a var here to keep constant time compare when looping over a number of claims
|
||||
result := false
|
||||
|
||||
var stringClaims string
|
||||
for _, a := range aud {
|
||||
if subtle.ConstantTimeCompare([]byte(a), []byte(cmp)) != 0 {
|
||||
result = true
|
||||
}
|
||||
stringClaims = stringClaims + a
|
||||
}
|
||||
|
||||
// case where "" is sent in one or many aud claims
|
||||
if len(stringClaims) == 0 {
|
||||
return !required
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
func verifyExp(exp int64, now int64, required bool) bool {
|
||||
if exp == 0 {
|
||||
return !required
|
||||
}
|
||||
return now <= exp
|
||||
}
|
||||
|
||||
func verifyIat(iat int64, now int64, required bool) bool {
|
||||
if iat == 0 {
|
||||
return !required
|
||||
}
|
||||
return now >= iat
|
||||
}
|
||||
|
||||
func verifyIss(iss string, cmp string, required bool) bool {
|
||||
if iss == "" {
|
||||
return !required
|
||||
}
|
||||
if subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0 {
|
||||
return true
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func verifyNbf(nbf int64, now int64, required bool) bool {
|
||||
if nbf == 0 {
|
||||
return !required
|
||||
}
|
||||
return now >= nbf
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html
|
||||
//
|
||||
// See README.md for more info.
|
||||
package jwt
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/ecdsa"
|
||||
"crypto/rand"
|
||||
"errors"
|
||||
"math/big"
|
||||
)
|
||||
|
||||
var (
|
||||
// Sadly this is missing from crypto/ecdsa compared to crypto/rsa
|
||||
ErrECDSAVerification = errors.New("crypto/ecdsa: verification error")
|
||||
)
|
||||
|
||||
// Implements the ECDSA family of signing methods signing methods
|
||||
// Expects *ecdsa.PrivateKey for signing and *ecdsa.PublicKey for verification
|
||||
type SigningMethodECDSA struct {
|
||||
Name string
|
||||
Hash crypto.Hash
|
||||
KeySize int
|
||||
CurveBits int
|
||||
}
|
||||
|
||||
// Specific instances for EC256 and company
|
||||
var (
|
||||
SigningMethodES256 *SigningMethodECDSA
|
||||
SigningMethodES384 *SigningMethodECDSA
|
||||
SigningMethodES512 *SigningMethodECDSA
|
||||
)
|
||||
|
||||
func init() {
|
||||
// ES256
|
||||
SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256}
|
||||
RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod {
|
||||
return SigningMethodES256
|
||||
})
|
||||
|
||||
// ES384
|
||||
SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384}
|
||||
RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod {
|
||||
return SigningMethodES384
|
||||
})
|
||||
|
||||
// ES512
|
||||
SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521}
|
||||
RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod {
|
||||
return SigningMethodES512
|
||||
})
|
||||
}
|
||||
|
||||
func (m *SigningMethodECDSA) Alg() string {
|
||||
return m.Name
|
||||
}
|
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this verify method, key must be an ecdsa.PublicKey struct
|
||||
func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error {
|
||||
var err error
|
||||
|
||||
// Decode the signature
|
||||
var sig []byte
|
||||
if sig, err = DecodeSegment(signature); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Get the key
|
||||
var ecdsaKey *ecdsa.PublicKey
|
||||
switch k := key.(type) {
|
||||
case *ecdsa.PublicKey:
|
||||
ecdsaKey = k
|
||||
default:
|
||||
return ErrInvalidKeyType
|
||||
}
|
||||
|
||||
if len(sig) != 2*m.KeySize {
|
||||
return ErrECDSAVerification
|
||||
}
|
||||
|
||||
r := big.NewInt(0).SetBytes(sig[:m.KeySize])
|
||||
s := big.NewInt(0).SetBytes(sig[m.KeySize:])
|
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() {
|
||||
return ErrHashUnavailable
|
||||
}
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
// Verify the signature
|
||||
if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus {
|
||||
return nil
|
||||
}
|
||||
|
||||
return ErrECDSAVerification
|
||||
}
|
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, key must be an ecdsa.PrivateKey struct
|
||||
func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {
|
||||
// Get the key
|
||||
var ecdsaKey *ecdsa.PrivateKey
|
||||
switch k := key.(type) {
|
||||
case *ecdsa.PrivateKey:
|
||||
ecdsaKey = k
|
||||
default:
|
||||
return "", ErrInvalidKeyType
|
||||
}
|
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() {
|
||||
return "", ErrHashUnavailable
|
||||
}
|
||||
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
// Sign the string and return r, s
|
||||
if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {
|
||||
curveBits := ecdsaKey.Curve.Params().BitSize
|
||||
|
||||
if m.CurveBits != curveBits {
|
||||
return "", ErrInvalidKey
|
||||
}
|
||||
|
||||
keyBytes := curveBits / 8
|
||||
if curveBits%8 > 0 {
|
||||
keyBytes += 1
|
||||
}
|
||||
|
||||
// We serialize the outputs (r and s) into big-endian byte arrays
|
||||
// padded with zeros on the left to make sure the sizes work out.
|
||||
// Output must be 2*keyBytes long.
|
||||
out := make([]byte, 2*keyBytes)
|
||||
r.FillBytes(out[0:keyBytes]) // r is assigned to the first half of output.
|
||||
s.FillBytes(out[keyBytes:]) // s is assigned to the second half of output.
|
||||
|
||||
return EncodeSegment(out), nil
|
||||
} else {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto/ecdsa"
|
||||
"crypto/x509"
|
||||
"encoding/pem"
|
||||
"errors"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNotECPublicKey = errors.New("Key is not a valid ECDSA public key")
|
||||
ErrNotECPrivateKey = errors.New("Key is not a valid ECDSA private key")
|
||||
)
|
||||
|
||||
// Parse PEM encoded Elliptic Curve Private Key Structure
|
||||
func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil {
|
||||
if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var pkey *ecdsa.PrivateKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok {
|
||||
return nil, ErrNotECPrivateKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 public key
|
||||
func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
|
||||
if cert, err := x509.ParseCertificate(block.Bytes); err == nil {
|
||||
parsedKey = cert.PublicKey
|
||||
} else {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var pkey *ecdsa.PublicKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok {
|
||||
return nil, ErrNotECPublicKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"crypto/ed25519"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrEd25519Verification = errors.New("ed25519: verification error")
|
||||
)
|
||||
|
||||
// Implements the EdDSA family
|
||||
// Expects ed25519.PrivateKey for signing and ed25519.PublicKey for verification
|
||||
type SigningMethodEd25519 struct{}
|
||||
|
||||
// Specific instance for EdDSA
|
||||
var (
|
||||
SigningMethodEdDSA *SigningMethodEd25519
|
||||
)
|
||||
|
||||
func init() {
|
||||
SigningMethodEdDSA = &SigningMethodEd25519{}
|
||||
RegisterSigningMethod(SigningMethodEdDSA.Alg(), func() SigningMethod {
|
||||
return SigningMethodEdDSA
|
||||
})
|
||||
}
|
||||
|
||||
func (m *SigningMethodEd25519) Alg() string {
|
||||
return "EdDSA"
|
||||
}
|
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this verify method, key must be an ed25519.PublicKey
|
||||
func (m *SigningMethodEd25519) Verify(signingString, signature string, key interface{}) error {
|
||||
var err error
|
||||
var ed25519Key ed25519.PublicKey
|
||||
var ok bool
|
||||
|
||||
if ed25519Key, ok = key.(ed25519.PublicKey); !ok {
|
||||
return ErrInvalidKeyType
|
||||
}
|
||||
|
||||
if len(ed25519Key) != ed25519.PublicKeySize {
|
||||
return ErrInvalidKey
|
||||
}
|
||||
|
||||
// Decode the signature
|
||||
var sig []byte
|
||||
if sig, err = DecodeSegment(signature); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Verify the signature
|
||||
if !ed25519.Verify(ed25519Key, []byte(signingString), sig) {
|
||||
return ErrEd25519Verification
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, key must be an ed25519.PrivateKey
|
||||
func (m *SigningMethodEd25519) Sign(signingString string, key interface{}) (string, error) {
|
||||
var ed25519Key ed25519.PrivateKey
|
||||
var ok bool
|
||||
|
||||
if ed25519Key, ok = key.(ed25519.PrivateKey); !ok {
|
||||
return "", ErrInvalidKeyType
|
||||
}
|
||||
|
||||
// ed25519.Sign panics if private key not equal to ed25519.PrivateKeySize
|
||||
// this allows to avoid recover usage
|
||||
if len(ed25519Key) != ed25519.PrivateKeySize {
|
||||
return "", ErrInvalidKey
|
||||
}
|
||||
|
||||
// Sign the string and return the encoded result
|
||||
sig := ed25519.Sign(ed25519Key, []byte(signingString))
|
||||
return EncodeSegment(sig), nil
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/ed25519"
|
||||
"crypto/x509"
|
||||
"encoding/pem"
|
||||
"errors"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNotEdPrivateKey = errors.New("Key is not a valid Ed25519 private key")
|
||||
ErrNotEdPublicKey = errors.New("Key is not a valid Ed25519 public key")
|
||||
)
|
||||
|
||||
// Parse PEM-encoded Edwards curve private key
|
||||
func ParseEdPrivateKeyFromPEM(key []byte) (crypto.PrivateKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var pkey ed25519.PrivateKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(ed25519.PrivateKey); !ok {
|
||||
return nil, ErrNotEdPrivateKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
||||
// Parse PEM-encoded Edwards curve public key
|
||||
func ParseEdPublicKeyFromPEM(key []byte) (crypto.PublicKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var pkey ed25519.PublicKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(ed25519.PublicKey); !ok {
|
||||
return nil, ErrNotEdPublicKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"errors"
|
||||
)
|
||||
|
||||
// Error constants
|
||||
var (
|
||||
ErrInvalidKey = errors.New("key is invalid")
|
||||
ErrInvalidKeyType = errors.New("key is of invalid type")
|
||||
ErrHashUnavailable = errors.New("the requested hash function is unavailable")
|
||||
)
|
||||
|
||||
// The errors that might occur when parsing and validating a token
|
||||
const (
|
||||
ValidationErrorMalformed uint32 = 1 << iota // Token is malformed
|
||||
ValidationErrorUnverifiable // Token could not be verified because of signing problems
|
||||
ValidationErrorSignatureInvalid // Signature validation failed
|
||||
|
||||
// Standard Claim validation errors
|
||||
ValidationErrorAudience // AUD validation failed
|
||||
ValidationErrorExpired // EXP validation failed
|
||||
ValidationErrorIssuedAt // IAT validation failed
|
||||
ValidationErrorIssuer // ISS validation failed
|
||||
ValidationErrorNotValidYet // NBF validation failed
|
||||
ValidationErrorId // JTI validation failed
|
||||
ValidationErrorClaimsInvalid // Generic claims validation error
|
||||
)
|
||||
|
||||
// Helper for constructing a ValidationError with a string error message
|
||||
func NewValidationError(errorText string, errorFlags uint32) *ValidationError {
|
||||
return &ValidationError{
|
||||
text: errorText,
|
||||
Errors: errorFlags,
|
||||
}
|
||||
}
|
||||
|
||||
// The error from Parse if token is not valid
|
||||
type ValidationError struct {
|
||||
Inner error // stores the error returned by external dependencies, i.e.: KeyFunc
|
||||
Errors uint32 // bitfield. see ValidationError... constants
|
||||
text string // errors that do not have a valid error just have text
|
||||
}
|
||||
|
||||
// Validation error is an error type
|
||||
func (e ValidationError) Error() string {
|
||||
if e.Inner != nil {
|
||||
return e.Inner.Error()
|
||||
} else if e.text != "" {
|
||||
return e.text
|
||||
} else {
|
||||
return "token is invalid"
|
||||
}
|
||||
}
|
||||
|
||||
// No errors
|
||||
func (e *ValidationError) valid() bool {
|
||||
return e.Errors == 0
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/hmac"
|
||||
"errors"
|
||||
)
|
||||
|
||||
// Implements the HMAC-SHA family of signing methods signing methods
|
||||
// Expects key type of []byte for both signing and validation
|
||||
type SigningMethodHMAC struct {
|
||||
Name string
|
||||
Hash crypto.Hash
|
||||
}
|
||||
|
||||
// Specific instances for HS256 and company
|
||||
var (
|
||||
SigningMethodHS256 *SigningMethodHMAC
|
||||
SigningMethodHS384 *SigningMethodHMAC
|
||||
SigningMethodHS512 *SigningMethodHMAC
|
||||
ErrSignatureInvalid = errors.New("signature is invalid")
|
||||
)
|
||||
|
||||
func init() {
|
||||
// HS256
|
||||
SigningMethodHS256 = &SigningMethodHMAC{"HS256", crypto.SHA256}
|
||||
RegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod {
|
||||
return SigningMethodHS256
|
||||
})
|
||||
|
||||
// HS384
|
||||
SigningMethodHS384 = &SigningMethodHMAC{"HS384", crypto.SHA384}
|
||||
RegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod {
|
||||
return SigningMethodHS384
|
||||
})
|
||||
|
||||
// HS512
|
||||
SigningMethodHS512 = &SigningMethodHMAC{"HS512", crypto.SHA512}
|
||||
RegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod {
|
||||
return SigningMethodHS512
|
||||
})
|
||||
}
|
||||
|
||||
func (m *SigningMethodHMAC) Alg() string {
|
||||
return m.Name
|
||||
}
|
||||
|
||||
// Verify the signature of HSXXX tokens. Returns nil if the signature is valid.
|
||||
func (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error {
|
||||
// Verify the key is the right type
|
||||
keyBytes, ok := key.([]byte)
|
||||
if !ok {
|
||||
return ErrInvalidKeyType
|
||||
}
|
||||
|
||||
// Decode signature, for comparison
|
||||
sig, err := DecodeSegment(signature)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Can we use the specified hashing method?
|
||||
if !m.Hash.Available() {
|
||||
return ErrHashUnavailable
|
||||
}
|
||||
|
||||
// This signing method is symmetric, so we validate the signature
|
||||
// by reproducing the signature from the signing string and key, then
|
||||
// comparing that against the provided signature.
|
||||
hasher := hmac.New(m.Hash.New, keyBytes)
|
||||
hasher.Write([]byte(signingString))
|
||||
if !hmac.Equal(sig, hasher.Sum(nil)) {
|
||||
return ErrSignatureInvalid
|
||||
}
|
||||
|
||||
// No validation errors. Signature is good.
|
||||
return nil
|
||||
}
|
||||
|
||||
// Implements the Sign method from SigningMethod for this signing method.
|
||||
// Key must be []byte
|
||||
func (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) {
|
||||
if keyBytes, ok := key.([]byte); ok {
|
||||
if !m.Hash.Available() {
|
||||
return "", ErrHashUnavailable
|
||||
}
|
||||
|
||||
hasher := hmac.New(m.Hash.New, keyBytes)
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
return EncodeSegment(hasher.Sum(nil)), nil
|
||||
}
|
||||
|
||||
return "", ErrInvalidKeyType
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
// "fmt"
|
||||
)
|
||||
|
||||
// Claims type that uses the map[string]interface{} for JSON decoding
|
||||
// This is the default claims type if you don't supply one
|
||||
type MapClaims map[string]interface{}
|
||||
|
||||
// VerifyAudience Compares the aud claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyAudience(cmp string, req bool) bool {
|
||||
var aud []string
|
||||
switch v := m["aud"].(type) {
|
||||
case string:
|
||||
aud = append(aud, v)
|
||||
case []string:
|
||||
aud = v
|
||||
case []interface{}:
|
||||
for _, a := range v {
|
||||
vs, ok := a.(string)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
aud = append(aud, vs)
|
||||
}
|
||||
}
|
||||
return verifyAud(aud, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the exp claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyExpiresAt(cmp int64, req bool) bool {
|
||||
exp, ok := m["exp"]
|
||||
if !ok {
|
||||
return !req
|
||||
}
|
||||
switch expType := exp.(type) {
|
||||
case float64:
|
||||
return verifyExp(int64(expType), cmp, req)
|
||||
case json.Number:
|
||||
v, _ := expType.Int64()
|
||||
return verifyExp(v, cmp, req)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Compares the iat claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyIssuedAt(cmp int64, req bool) bool {
|
||||
iat, ok := m["iat"]
|
||||
if !ok {
|
||||
return !req
|
||||
}
|
||||
switch iatType := iat.(type) {
|
||||
case float64:
|
||||
return verifyIat(int64(iatType), cmp, req)
|
||||
case json.Number:
|
||||
v, _ := iatType.Int64()
|
||||
return verifyIat(v, cmp, req)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Compares the iss claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyIssuer(cmp string, req bool) bool {
|
||||
iss, _ := m["iss"].(string)
|
||||
return verifyIss(iss, cmp, req)
|
||||
}
|
||||
|
||||
// Compares the nbf claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyNotBefore(cmp int64, req bool) bool {
|
||||
nbf, ok := m["nbf"]
|
||||
if !ok {
|
||||
return !req
|
||||
}
|
||||
switch nbfType := nbf.(type) {
|
||||
case float64:
|
||||
return verifyNbf(int64(nbfType), cmp, req)
|
||||
case json.Number:
|
||||
v, _ := nbfType.Int64()
|
||||
return verifyNbf(v, cmp, req)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Validates time based claims "exp, iat, nbf".
|
||||
// There is no accounting for clock skew.
|
||||
// As well, if any of the above claims are not in the token, it will still
|
||||
// be considered a valid claim.
|
||||
func (m MapClaims) Valid() error {
|
||||
vErr := new(ValidationError)
|
||||
now := TimeFunc().Unix()
|
||||
|
||||
if !m.VerifyExpiresAt(now, false) {
|
||||
vErr.Inner = errors.New("Token is expired")
|
||||
vErr.Errors |= ValidationErrorExpired
|
||||
}
|
||||
|
||||
if !m.VerifyIssuedAt(now, false) {
|
||||
vErr.Inner = errors.New("Token used before issued")
|
||||
vErr.Errors |= ValidationErrorIssuedAt
|
||||
}
|
||||
|
||||
if !m.VerifyNotBefore(now, false) {
|
||||
vErr.Inner = errors.New("Token is not valid yet")
|
||||
vErr.Errors |= ValidationErrorNotValidYet
|
||||
}
|
||||
|
||||
if vErr.valid() {
|
||||
return nil
|
||||
}
|
||||
|
||||
return vErr
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
package jwt
|
||||
|
||||
// Implements the none signing method. This is required by the spec
|
||||
// but you probably should never use it.
|
||||
var SigningMethodNone *signingMethodNone
|
||||
|
||||
const UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = "none signing method allowed"
|
||||
|
||||
var NoneSignatureTypeDisallowedError error
|
||||
|
||||
type signingMethodNone struct{}
|
||||
type unsafeNoneMagicConstant string
|
||||
|
||||
func init() {
|
||||
SigningMethodNone = &signingMethodNone{}
|
||||
NoneSignatureTypeDisallowedError = NewValidationError("'none' signature type is not allowed", ValidationErrorSignatureInvalid)
|
||||
|
||||
RegisterSigningMethod(SigningMethodNone.Alg(), func() SigningMethod {
|
||||
return SigningMethodNone
|
||||
})
|
||||
}
|
||||
|
||||
func (m *signingMethodNone) Alg() string {
|
||||
return "none"
|
||||
}
|
||||
|
||||
// Only allow 'none' alg type if UnsafeAllowNoneSignatureType is specified as the key
|
||||
func (m *signingMethodNone) Verify(signingString, signature string, key interface{}) (err error) {
|
||||
// Key must be UnsafeAllowNoneSignatureType to prevent accidentally
|
||||
// accepting 'none' signing method
|
||||
if _, ok := key.(unsafeNoneMagicConstant); !ok {
|
||||
return NoneSignatureTypeDisallowedError
|
||||
}
|
||||
// If signing method is none, signature must be an empty string
|
||||
if signature != "" {
|
||||
return NewValidationError(
|
||||
"'none' signing method with non-empty signature",
|
||||
ValidationErrorSignatureInvalid,
|
||||
)
|
||||
}
|
||||
|
||||
// Accept 'none' signing method.
|
||||
return nil
|
||||
}
|
||||
|
||||
// Only allow 'none' signing if UnsafeAllowNoneSignatureType is specified as the key
|
||||
func (m *signingMethodNone) Sign(signingString string, key interface{}) (string, error) {
|
||||
if _, ok := key.(unsafeNoneMagicConstant); ok {
|
||||
return "", nil
|
||||
}
|
||||
return "", NoneSignatureTypeDisallowedError
|
||||
}
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type Parser struct {
|
||||
ValidMethods []string // If populated, only these methods will be considered valid
|
||||
UseJSONNumber bool // Use JSON Number format in JSON decoder
|
||||
SkipClaimsValidation bool // Skip claims validation during token parsing
|
||||
}
|
||||
|
||||
// Parse, validate, and return a token.
|
||||
// keyFunc will receive the parsed token and should return the key for validating.
|
||||
// If everything is kosher, err will be nil
|
||||
func (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {
|
||||
return p.ParseWithClaims(tokenString, MapClaims{}, keyFunc)
|
||||
}
|
||||
|
||||
func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
|
||||
token, parts, err := p.ParseUnverified(tokenString, claims)
|
||||
if err != nil {
|
||||
return token, err
|
||||
}
|
||||
|
||||
// Verify signing method is in the required set
|
||||
if p.ValidMethods != nil {
|
||||
var signingMethodValid = false
|
||||
var alg = token.Method.Alg()
|
||||
for _, m := range p.ValidMethods {
|
||||
if m == alg {
|
||||
signingMethodValid = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !signingMethodValid {
|
||||
// signing method is not in the listed set
|
||||
return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid)
|
||||
}
|
||||
}
|
||||
|
||||
// Lookup key
|
||||
var key interface{}
|
||||
if keyFunc == nil {
|
||||
// keyFunc was not provided. short circuiting validation
|
||||
return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable)
|
||||
}
|
||||
if key, err = keyFunc(token); err != nil {
|
||||
// keyFunc returned an error
|
||||
if ve, ok := err.(*ValidationError); ok {
|
||||
return token, ve
|
||||
}
|
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable}
|
||||
}
|
||||
|
||||
vErr := &ValidationError{}
|
||||
|
||||
// Validate Claims
|
||||
if !p.SkipClaimsValidation {
|
||||
if err := token.Claims.Valid(); err != nil {
|
||||
|
||||
// If the Claims Valid returned an error, check if it is a validation error,
|
||||
// If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set
|
||||
if e, ok := err.(*ValidationError); !ok {
|
||||
vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid}
|
||||
} else {
|
||||
vErr = e
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Perform validation
|
||||
token.Signature = parts[2]
|
||||
if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil {
|
||||
vErr.Inner = err
|
||||
vErr.Errors |= ValidationErrorSignatureInvalid
|
||||
}
|
||||
|
||||
if vErr.valid() {
|
||||
token.Valid = true
|
||||
return token, nil
|
||||
}
|
||||
|
||||
return token, vErr
|
||||
}
|
||||
|
||||
// WARNING: Don't use this method unless you know what you're doing
|
||||
//
|
||||
// This method parses the token but doesn't validate the signature. It's only
|
||||
// ever useful in cases where you know the signature is valid (because it has
|
||||
// been checked previously in the stack) and you want to extract values from
|
||||
// it.
|
||||
func (p *Parser) ParseUnverified(tokenString string, claims Claims) (token *Token, parts []string, err error) {
|
||||
parts = strings.Split(tokenString, ".")
|
||||
if len(parts) != 3 {
|
||||
return nil, parts, NewValidationError("token contains an invalid number of segments", ValidationErrorMalformed)
|
||||
}
|
||||
|
||||
token = &Token{Raw: tokenString}
|
||||
|
||||
// parse Header
|
||||
var headerBytes []byte
|
||||
if headerBytes, err = DecodeSegment(parts[0]); err != nil {
|
||||
if strings.HasPrefix(strings.ToLower(tokenString), "bearer ") {
|
||||
return token, parts, NewValidationError("tokenstring should not contain 'bearer '", ValidationErrorMalformed)
|
||||
}
|
||||
return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
|
||||
}
|
||||
if err = json.Unmarshal(headerBytes, &token.Header); err != nil {
|
||||
return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
|
||||
}
|
||||
|
||||
// parse Claims
|
||||
var claimBytes []byte
|
||||
token.Claims = claims
|
||||
|
||||
if claimBytes, err = DecodeSegment(parts[1]); err != nil {
|
||||
return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewBuffer(claimBytes))
|
||||
if p.UseJSONNumber {
|
||||
dec.UseNumber()
|
||||
}
|
||||
// JSON Decode. Special case for map type to avoid weird pointer behavior
|
||||
if c, ok := token.Claims.(MapClaims); ok {
|
||||
err = dec.Decode(&c)
|
||||
} else {
|
||||
err = dec.Decode(&claims)
|
||||
}
|
||||
// Handle decode error
|
||||
if err != nil {
|
||||
return token, parts, &ValidationError{Inner: err, Errors: ValidationErrorMalformed}
|
||||
}
|
||||
|
||||
// Lookup signature method
|
||||
if method, ok := token.Header["alg"].(string); ok {
|
||||
if token.Method = GetSigningMethod(method); token.Method == nil {
|
||||
return token, parts, NewValidationError("signing method (alg) is unavailable.", ValidationErrorUnverifiable)
|
||||
}
|
||||
} else {
|
||||
return token, parts, NewValidationError("signing method (alg) is unspecified.", ValidationErrorUnverifiable)
|
||||
}
|
||||
|
||||
return token, parts, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
)
|
||||
|
||||
// Implements the RSA family of signing methods signing methods
|
||||
// Expects *rsa.PrivateKey for signing and *rsa.PublicKey for validation
|
||||
type SigningMethodRSA struct {
|
||||
Name string
|
||||
Hash crypto.Hash
|
||||
}
|
||||
|
||||
// Specific instances for RS256 and company
|
||||
var (
|
||||
SigningMethodRS256 *SigningMethodRSA
|
||||
SigningMethodRS384 *SigningMethodRSA
|
||||
SigningMethodRS512 *SigningMethodRSA
|
||||
)
|
||||
|
||||
func init() {
|
||||
// RS256
|
||||
SigningMethodRS256 = &SigningMethodRSA{"RS256", crypto.SHA256}
|
||||
RegisterSigningMethod(SigningMethodRS256.Alg(), func() SigningMethod {
|
||||
return SigningMethodRS256
|
||||
})
|
||||
|
||||
// RS384
|
||||
SigningMethodRS384 = &SigningMethodRSA{"RS384", crypto.SHA384}
|
||||
RegisterSigningMethod(SigningMethodRS384.Alg(), func() SigningMethod {
|
||||
return SigningMethodRS384
|
||||
})
|
||||
|
||||
// RS512
|
||||
SigningMethodRS512 = &SigningMethodRSA{"RS512", crypto.SHA512}
|
||||
RegisterSigningMethod(SigningMethodRS512.Alg(), func() SigningMethod {
|
||||
return SigningMethodRS512
|
||||
})
|
||||
}
|
||||
|
||||
func (m *SigningMethodRSA) Alg() string {
|
||||
return m.Name
|
||||
}
|
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this signing method, must be an *rsa.PublicKey structure.
|
||||
func (m *SigningMethodRSA) Verify(signingString, signature string, key interface{}) error {
|
||||
var err error
|
||||
|
||||
// Decode the signature
|
||||
var sig []byte
|
||||
if sig, err = DecodeSegment(signature); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var rsaKey *rsa.PublicKey
|
||||
var ok bool
|
||||
|
||||
if rsaKey, ok = key.(*rsa.PublicKey); !ok {
|
||||
return ErrInvalidKeyType
|
||||
}
|
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() {
|
||||
return ErrHashUnavailable
|
||||
}
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
// Verify the signature
|
||||
return rsa.VerifyPKCS1v15(rsaKey, m.Hash, hasher.Sum(nil), sig)
|
||||
}
|
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, must be an *rsa.PrivateKey structure.
|
||||
func (m *SigningMethodRSA) Sign(signingString string, key interface{}) (string, error) {
|
||||
var rsaKey *rsa.PrivateKey
|
||||
var ok bool
|
||||
|
||||
// Validate type of key
|
||||
if rsaKey, ok = key.(*rsa.PrivateKey); !ok {
|
||||
return "", ErrInvalidKey
|
||||
}
|
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() {
|
||||
return "", ErrHashUnavailable
|
||||
}
|
||||
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
// Sign the string and return the encoded bytes
|
||||
if sigBytes, err := rsa.SignPKCS1v15(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil)); err == nil {
|
||||
return EncodeSegment(sigBytes), nil
|
||||
} else {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
// +build go1.4
|
||||
|
||||
package jwt
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
)
|
||||
|
||||
// Implements the RSAPSS family of signing methods signing methods
|
||||
type SigningMethodRSAPSS struct {
|
||||
*SigningMethodRSA
|
||||
Options *rsa.PSSOptions
|
||||
// VerifyOptions is optional. If set overrides Options for rsa.VerifyPPS.
|
||||
// Used to accept tokens signed with rsa.PSSSaltLengthAuto, what doesn't follow
|
||||
// https://tools.ietf.org/html/rfc7518#section-3.5 but was used previously.
|
||||
// See https://github.com/dgrijalva/jwt-go/issues/285#issuecomment-437451244 for details.
|
||||
VerifyOptions *rsa.PSSOptions
|
||||
}
|
||||
|
||||
// Specific instances for RS/PS and company.
|
||||
var (
|
||||
SigningMethodPS256 *SigningMethodRSAPSS
|
||||
SigningMethodPS384 *SigningMethodRSAPSS
|
||||
SigningMethodPS512 *SigningMethodRSAPSS
|
||||
)
|
||||
|
||||
func init() {
|
||||
// PS256
|
||||
SigningMethodPS256 = &SigningMethodRSAPSS{
|
||||
SigningMethodRSA: &SigningMethodRSA{
|
||||
Name: "PS256",
|
||||
Hash: crypto.SHA256,
|
||||
},
|
||||
Options: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthEqualsHash,
|
||||
},
|
||||
VerifyOptions: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthAuto,
|
||||
},
|
||||
}
|
||||
RegisterSigningMethod(SigningMethodPS256.Alg(), func() SigningMethod {
|
||||
return SigningMethodPS256
|
||||
})
|
||||
|
||||
// PS384
|
||||
SigningMethodPS384 = &SigningMethodRSAPSS{
|
||||
SigningMethodRSA: &SigningMethodRSA{
|
||||
Name: "PS384",
|
||||
Hash: crypto.SHA384,
|
||||
},
|
||||
Options: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthEqualsHash,
|
||||
},
|
||||
VerifyOptions: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthAuto,
|
||||
},
|
||||
}
|
||||
RegisterSigningMethod(SigningMethodPS384.Alg(), func() SigningMethod {
|
||||
return SigningMethodPS384
|
||||
})
|
||||
|
||||
// PS512
|
||||
SigningMethodPS512 = &SigningMethodRSAPSS{
|
||||
SigningMethodRSA: &SigningMethodRSA{
|
||||
Name: "PS512",
|
||||
Hash: crypto.SHA512,
|
||||
},
|
||||
Options: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthEqualsHash,
|
||||
},
|
||||
VerifyOptions: &rsa.PSSOptions{
|
||||
SaltLength: rsa.PSSSaltLengthAuto,
|
||||
},
|
||||
}
|
||||
RegisterSigningMethod(SigningMethodPS512.Alg(), func() SigningMethod {
|
||||
return SigningMethodPS512
|
||||
})
|
||||
}
|
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this verify method, key must be an rsa.PublicKey struct
|
||||
func (m *SigningMethodRSAPSS) Verify(signingString, signature string, key interface{}) error {
|
||||
var err error
|
||||
|
||||
// Decode the signature
|
||||
var sig []byte
|
||||
if sig, err = DecodeSegment(signature); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var rsaKey *rsa.PublicKey
|
||||
switch k := key.(type) {
|
||||
case *rsa.PublicKey:
|
||||
rsaKey = k
|
||||
default:
|
||||
return ErrInvalidKey
|
||||
}
|
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() {
|
||||
return ErrHashUnavailable
|
||||
}
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
opts := m.Options
|
||||
if m.VerifyOptions != nil {
|
||||
opts = m.VerifyOptions
|
||||
}
|
||||
|
||||
return rsa.VerifyPSS(rsaKey, m.Hash, hasher.Sum(nil), sig, opts)
|
||||
}
|
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, key must be an rsa.PrivateKey struct
|
||||
func (m *SigningMethodRSAPSS) Sign(signingString string, key interface{}) (string, error) {
|
||||
var rsaKey *rsa.PrivateKey
|
||||
|
||||
switch k := key.(type) {
|
||||
case *rsa.PrivateKey:
|
||||
rsaKey = k
|
||||
default:
|
||||
return "", ErrInvalidKeyType
|
||||
}
|
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() {
|
||||
return "", ErrHashUnavailable
|
||||
}
|
||||
|
||||
hasher := m.Hash.New()
|
||||
hasher.Write([]byte(signingString))
|
||||
|
||||
// Sign the string and return the encoded bytes
|
||||
if sigBytes, err := rsa.SignPSS(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil), m.Options); err == nil {
|
||||
return EncodeSegment(sigBytes), nil
|
||||
} else {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"crypto/rsa"
|
||||
"crypto/x509"
|
||||
"encoding/pem"
|
||||
"errors"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrKeyMustBePEMEncoded = errors.New("Invalid Key: Key must be a PEM encoded PKCS1 or PKCS8 key")
|
||||
ErrNotRSAPrivateKey = errors.New("Key is not a valid RSA private key")
|
||||
ErrNotRSAPublicKey = errors.New("Key is not a valid RSA public key")
|
||||
)
|
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 private key
|
||||
func ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {
|
||||
if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var pkey *rsa.PrivateKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {
|
||||
return nil, ErrNotRSAPrivateKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 private key protected with password
|
||||
func ParseRSAPrivateKeyFromPEMWithPassword(key []byte, password string) (*rsa.PrivateKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
var parsedKey interface{}
|
||||
|
||||
var blockDecrypted []byte
|
||||
if blockDecrypted, err = x509.DecryptPEMBlock(block, []byte(password)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if parsedKey, err = x509.ParsePKCS1PrivateKey(blockDecrypted); err != nil {
|
||||
if parsedKey, err = x509.ParsePKCS8PrivateKey(blockDecrypted); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var pkey *rsa.PrivateKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok {
|
||||
return nil, ErrNotRSAPrivateKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 public key
|
||||
func ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error) {
|
||||
var err error
|
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block
|
||||
if block, _ = pem.Decode(key); block == nil {
|
||||
return nil, ErrKeyMustBePEMEncoded
|
||||
}
|
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{}
|
||||
if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
|
||||
if cert, err := x509.ParseCertificate(block.Bytes); err == nil {
|
||||
parsedKey = cert.PublicKey
|
||||
} else {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var pkey *rsa.PublicKey
|
||||
var ok bool
|
||||
if pkey, ok = parsedKey.(*rsa.PublicKey); !ok {
|
||||
return nil, ErrNotRSAPublicKey
|
||||
}
|
||||
|
||||
return pkey, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"sync"
|
||||
)
|
||||
|
||||
var signingMethods = map[string]func() SigningMethod{}
|
||||
var signingMethodLock = new(sync.RWMutex)
|
||||
|
||||
// Implement SigningMethod to add new methods for signing or verifying tokens.
|
||||
type SigningMethod interface {
|
||||
Verify(signingString, signature string, key interface{}) error // Returns nil if signature is valid
|
||||
Sign(signingString string, key interface{}) (string, error) // Returns encoded signature or error
|
||||
Alg() string // returns the alg identifier for this method (example: 'HS256')
|
||||
}
|
||||
|
||||
// Register the "alg" name and a factory function for signing method.
|
||||
// This is typically done during init() in the method's implementation
|
||||
func RegisterSigningMethod(alg string, f func() SigningMethod) {
|
||||
signingMethodLock.Lock()
|
||||
defer signingMethodLock.Unlock()
|
||||
|
||||
signingMethods[alg] = f
|
||||
}
|
||||
|
||||
// Get a signing method from an "alg" string
|
||||
func GetSigningMethod(alg string) (method SigningMethod) {
|
||||
signingMethodLock.RLock()
|
||||
defer signingMethodLock.RUnlock()
|
||||
|
||||
if methodF, ok := signingMethods[alg]; ok {
|
||||
method = methodF()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
package jwt
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TimeFunc provides the current time when parsing token to validate "exp" claim (expiration time).
|
||||
// You can override it to use another time value. This is useful for testing or if your
|
||||
// server uses a different time zone than your tokens.
|
||||
var TimeFunc = time.Now
|
||||
|
||||
// Parse methods use this callback function to supply
|
||||
// the key for verification. The function receives the parsed,
|
||||
// but unverified Token. This allows you to use properties in the
|
||||
// Header of the token (such as `kid`) to identify which key to use.
|
||||
type Keyfunc func(*Token) (interface{}, error)
|
||||
|
||||
// A JWT Token. Different fields will be used depending on whether you're
|
||||
// creating or parsing/verifying a token.
|
||||
type Token struct {
|
||||
Raw string // The raw token. Populated when you Parse a token
|
||||
Method SigningMethod // The signing method used or to be used
|
||||
Header map[string]interface{} // The first segment of the token
|
||||
Claims Claims // The second segment of the token
|
||||
Signature string // The third segment of the token. Populated when you Parse a token
|
||||
Valid bool // Is the token valid? Populated when you Parse/Verify a token
|
||||
}
|
||||
|
||||
// Create a new Token. Takes a signing method
|
||||
func New(method SigningMethod) *Token {
|
||||
return NewWithClaims(method, MapClaims{})
|
||||
}
|
||||
|
||||
func NewWithClaims(method SigningMethod, claims Claims) *Token {
|
||||
return &Token{
|
||||
Header: map[string]interface{}{
|
||||
"typ": "JWT",
|
||||
"alg": method.Alg(),
|
||||
},
|
||||
Claims: claims,
|
||||
Method: method,
|
||||
}
|
||||
}
|
||||
|
||||
// Get the complete, signed token
|
||||
func (t *Token) SignedString(key interface{}) (string, error) {
|
||||
var sig, sstr string
|
||||
var err error
|
||||
if sstr, err = t.SigningString(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if sig, err = t.Method.Sign(sstr, key); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return strings.Join([]string{sstr, sig}, "."), nil
|
||||
}
|
||||
|
||||
// Generate the signing string. This is the
|
||||
// most expensive part of the whole deal. Unless you
|
||||
// need this for something special, just go straight for
|
||||
// the SignedString.
|
||||
func (t *Token) SigningString() (string, error) {
|
||||
var err error
|
||||
parts := make([]string, 2)
|
||||
for i := range parts {
|
||||
var jsonValue []byte
|
||||
if i == 0 {
|
||||
if jsonValue, err = json.Marshal(t.Header); err != nil {
|
||||
return "", err
|
||||
}
|
||||
} else {
|
||||
if jsonValue, err = json.Marshal(t.Claims); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
|
||||
parts[i] = EncodeSegment(jsonValue)
|
||||
}
|
||||
return strings.Join(parts, "."), nil
|
||||
}
|
||||
|
||||
// Parse, validate, and return a token.
|
||||
// keyFunc will receive the parsed token and should return the key for validating.
|
||||
// If everything is kosher, err will be nil
|
||||
func Parse(tokenString string, keyFunc Keyfunc) (*Token, error) {
|
||||
return new(Parser).Parse(tokenString, keyFunc)
|
||||
}
|
||||
|
||||
func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
|
||||
return new(Parser).ParseWithClaims(tokenString, claims, keyFunc)
|
||||
}
|
||||
|
||||
// Encode JWT specific base64url encoding with padding stripped
|
||||
func EncodeSegment(seg []byte) string {
|
||||
return base64.RawURLEncoding.EncodeToString(seg)
|
||||
}
|
||||
|
||||
// Decode JWT specific base64url encoding with padding stripped
|
||||
func DecodeSegment(seg string) ([]byte, error) {
|
||||
return base64.RawURLEncoding.DecodeString(seg)
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# EditorConfig coding styles definitions. For more information about the
|
||||
# properties used in this file, please see the EditorConfig documentation:
|
||||
# http://editorconfig.org/
|
||||
|
||||
# indicate this is the root of the project
|
||||
root = true
|
||||
|
||||
[*]
|
||||
charset = utf-8
|
||||
|
||||
end_of_line = LF
|
||||
insert_final_newline = true
|
||||
trim_trailing_whitespace = true
|
||||
|
||||
indent_style = space
|
||||
indent_size = 2
|
||||
|
||||
[Makefile]
|
||||
indent_style = tab
|
||||
|
||||
[*.md]
|
||||
trim_trailing_whitespace = false
|
||||
|
||||
[*.go]
|
||||
indent_style = tab
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
# Automatically normalize line endings for all text-based files
|
||||
# http://git-scm.com/docs/gitattributes#_end_of_line_conversion
|
||||
* text=auto
|
||||
|
||||
# For the following file types, normalize line endings to LF on checking and
|
||||
# prevent conversion to CRLF when they are checked out (this is required in
|
||||
# order to prevent newline related issues)
|
||||
.* text eol=lf
|
||||
*.go text eol=lf
|
||||
*.yml text eol=lf
|
||||
*.html text eol=lf
|
||||
*.css text eol=lf
|
||||
*.js text eol=lf
|
||||
*.json text eol=lf
|
||||
LICENSE text eol=lf
|
||||
|
||||
# Exclude `website` and `cookbook` from GitHub's language statistics
|
||||
# https://github.com/github/linguist#using-gitattributes
|
||||
cookbook/* linguist-documentation
|
||||
website/* linguist-documentation
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
.DS_Store
|
||||
coverage.txt
|
||||
_test
|
||||
vendor
|
||||
.idea
|
||||
*.iml
|
||||
*.out
|
||||
.vscode
|
||||
|
|
@ -0,0 +1,441 @@
|
|||
# Changelog
|
||||
|
||||
## v4.11.3 - 2023-11-07
|
||||
|
||||
**Security**
|
||||
|
||||
* 'c.Attachment' and 'c.Inline' should escape filename in 'Content-Disposition' header to avoid 'Reflect File Download' vulnerability. [#2541](https://github.com/labstack/echo/pull/2541)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Tests: refactor context tests to be separate functions [#2540](https://github.com/labstack/echo/pull/2540)
|
||||
* Proxy middleware: reuse echo request context [#2537](https://github.com/labstack/echo/pull/2537)
|
||||
* Mark unmarshallable yaml struct tags as ignored [#2536](https://github.com/labstack/echo/pull/2536)
|
||||
|
||||
|
||||
## v4.11.2 - 2023-10-11
|
||||
|
||||
**Security**
|
||||
|
||||
* Bump golang.org/x/net to prevent CVE-2023-39325 / CVE-2023-44487 HTTP/2 Rapid Reset Attack [#2527](https://github.com/labstack/echo/pull/2527)
|
||||
* fix(sec): randomString bias introduced by #2490 [#2492](https://github.com/labstack/echo/pull/2492)
|
||||
* CSRF/RequestID mw: switch math/random usage to crypto/random [#2490](https://github.com/labstack/echo/pull/2490)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Delete unused context in body_limit.go [#2483](https://github.com/labstack/echo/pull/2483)
|
||||
* Use Go 1.21 in CI [#2505](https://github.com/labstack/echo/pull/2505)
|
||||
* Fix some typos [#2511](https://github.com/labstack/echo/pull/2511)
|
||||
* Allow CORS middleware to send Access-Control-Max-Age: 0 [#2518](https://github.com/labstack/echo/pull/2518)
|
||||
* Bump dependancies [#2522](https://github.com/labstack/echo/pull/2522)
|
||||
|
||||
## v4.11.1 - 2023-07-16
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix `Gzip` middleware not sending response code for no content responses (404, 301/302 redirects etc) [#2481](https://github.com/labstack/echo/pull/2481)
|
||||
|
||||
|
||||
## v4.11.0 - 2023-07-14
|
||||
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fixes the proxy middleware concurrency issue of calling the Next() proxy target on Round Robin Balancer [#2409](https://github.com/labstack/echo/pull/2409)
|
||||
* Fix `group.RouteNotFound` not working when group has attached middlewares [#2411](https://github.com/labstack/echo/pull/2411)
|
||||
* Fix global error handler return error message when message is an error [#2456](https://github.com/labstack/echo/pull/2456)
|
||||
* Do not use global timeNow variables [#2477](https://github.com/labstack/echo/pull/2477)
|
||||
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Added a optional config variable to disable centralized error handler in recovery middleware [#2410](https://github.com/labstack/echo/pull/2410)
|
||||
* refactor: use `strings.ReplaceAll` directly [#2424](https://github.com/labstack/echo/pull/2424)
|
||||
* Add support for Go1.20 `http.rwUnwrapper` to Response struct [#2425](https://github.com/labstack/echo/pull/2425)
|
||||
* Check whether is nil before invoking centralized error handling [#2429](https://github.com/labstack/echo/pull/2429)
|
||||
* Proper colon support in `echo.Reverse` method [#2416](https://github.com/labstack/echo/pull/2416)
|
||||
* Fix misuses of a vs an in documentation comments [#2436](https://github.com/labstack/echo/pull/2436)
|
||||
* Add link to slog.Handler library for Echo logging into README.md [#2444](https://github.com/labstack/echo/pull/2444)
|
||||
* In proxy middleware Support retries of failed proxy requests [#2414](https://github.com/labstack/echo/pull/2414)
|
||||
* gofmt fixes to comments [#2452](https://github.com/labstack/echo/pull/2452)
|
||||
* gzip response only if it exceeds a minimal length [#2267](https://github.com/labstack/echo/pull/2267)
|
||||
* Upgrade packages [#2475](https://github.com/labstack/echo/pull/2475)
|
||||
|
||||
|
||||
## v4.10.2 - 2023-02-22
|
||||
|
||||
**Security**
|
||||
|
||||
* `filepath.Clean` behaviour has changed in Go 1.20 - adapt to it [#2406](https://github.com/labstack/echo/pull/2406)
|
||||
* Add `middleware.CORSConfig.UnsafeWildcardOriginWithAllowCredentials` to make UNSAFE usages of wildcard origin + allow cretentials less likely [#2405](https://github.com/labstack/echo/pull/2405)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add more HTTP error values [#2277](https://github.com/labstack/echo/pull/2277)
|
||||
|
||||
|
||||
## v4.10.1 - 2023-02-19
|
||||
|
||||
**Security**
|
||||
|
||||
* Upgrade deps due to the latest golang.org/x/net vulnerability [#2402](https://github.com/labstack/echo/pull/2402)
|
||||
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add new JWT repository to the README [#2377](https://github.com/labstack/echo/pull/2377)
|
||||
* Return an empty string for ctx.path if there is no registered path [#2385](https://github.com/labstack/echo/pull/2385)
|
||||
* Add context timeout middleware [#2380](https://github.com/labstack/echo/pull/2380)
|
||||
* Update link to jaegertracing [#2394](https://github.com/labstack/echo/pull/2394)
|
||||
|
||||
|
||||
## v4.10.0 - 2022-12-27
|
||||
|
||||
**Security**
|
||||
|
||||
* We are deprecating JWT middleware in this repository. Please use https://github.com/labstack/echo-jwt instead.
|
||||
|
||||
JWT middleware is moved to separate repository to allow us to bump/upgrade version of JWT implementation (`github.com/golang-jwt/jwt`) we are using
|
||||
which we can not do in Echo core because this would break backwards compatibility guarantees we try to maintain.
|
||||
|
||||
* This minor version bumps minimum Go version to 1.17 (from 1.16) due `golang.org/x/` packages we depend on. There are
|
||||
several vulnerabilities fixed in these libraries.
|
||||
|
||||
Echo still tries to support last 4 Go versions but there are occasions we can not guarantee this promise.
|
||||
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Bump x/text to 0.3.8 [#2305](https://github.com/labstack/echo/pull/2305)
|
||||
* Bump dependencies and add notes about Go releases we support [#2336](https://github.com/labstack/echo/pull/2336)
|
||||
* Add helper interface for ProxyBalancer interface [#2316](https://github.com/labstack/echo/pull/2316)
|
||||
* Expose `middleware.CreateExtractors` function so we can use it from echo-contrib repository [#2338](https://github.com/labstack/echo/pull/2338)
|
||||
* Refactor func(Context) error to HandlerFunc [#2315](https://github.com/labstack/echo/pull/2315)
|
||||
* Improve function comments [#2329](https://github.com/labstack/echo/pull/2329)
|
||||
* Add new method HTTPError.WithInternal [#2340](https://github.com/labstack/echo/pull/2340)
|
||||
* Replace io/ioutil package usages [#2342](https://github.com/labstack/echo/pull/2342)
|
||||
* Add staticcheck to CI flow [#2343](https://github.com/labstack/echo/pull/2343)
|
||||
* Replace relative path determination from proprietary to std [#2345](https://github.com/labstack/echo/pull/2345)
|
||||
* Remove square brackets from ipv6 addresses in XFF (X-Forwarded-For header) [#2182](https://github.com/labstack/echo/pull/2182)
|
||||
* Add testcases for some BodyLimit middleware configuration options [#2350](https://github.com/labstack/echo/pull/2350)
|
||||
* Additional configuration options for RequestLogger and Logger middleware [#2341](https://github.com/labstack/echo/pull/2341)
|
||||
* Add route to request log [#2162](https://github.com/labstack/echo/pull/2162)
|
||||
* GitHub Workflows security hardening [#2358](https://github.com/labstack/echo/pull/2358)
|
||||
* Add govulncheck to CI and bump dependencies [#2362](https://github.com/labstack/echo/pull/2362)
|
||||
* Fix rate limiter docs [#2366](https://github.com/labstack/echo/pull/2366)
|
||||
* Refactor how `e.Routes()` work and introduce `e.OnAddRouteHandler` callback [#2337](https://github.com/labstack/echo/pull/2337)
|
||||
|
||||
|
||||
## v4.9.1 - 2022-10-12
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix logger panicing (when template is set to empty) by bumping dependency version [#2295](https://github.com/labstack/echo/issues/2295)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Improve CORS documentation [#2272](https://github.com/labstack/echo/pull/2272)
|
||||
* Update readme about supported Go versions [#2291](https://github.com/labstack/echo/pull/2291)
|
||||
* Tests: improve error handling on closing body [#2254](https://github.com/labstack/echo/pull/2254)
|
||||
* Tests: refactor some of the assertions in tests [#2275](https://github.com/labstack/echo/pull/2275)
|
||||
* Tests: refactor assertions [#2301](https://github.com/labstack/echo/pull/2301)
|
||||
|
||||
## v4.9.0 - 2022-09-04
|
||||
|
||||
**Security**
|
||||
|
||||
* Fix open redirect vulnerability in handlers serving static directories (e.Static, e.StaticFs, echo.StaticDirectoryHandler) [#2260](https://github.com/labstack/echo/pull/2260)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Allow configuring ErrorHandler in CSRF middleware [#2257](https://github.com/labstack/echo/pull/2257)
|
||||
* Replace HTTP method constants in tests with stdlib constants [#2247](https://github.com/labstack/echo/pull/2247)
|
||||
|
||||
|
||||
## v4.8.0 - 2022-08-10
|
||||
|
||||
**Most notable things**
|
||||
|
||||
You can now add any arbitrary HTTP method type as a route [#2237](https://github.com/labstack/echo/pull/2237)
|
||||
```go
|
||||
e.Add("COPY", "/*", func(c echo.Context) error
|
||||
return c.String(http.StatusOK, "OK COPY")
|
||||
})
|
||||
```
|
||||
|
||||
You can add custom 404 handler for specific paths [#2217](https://github.com/labstack/echo/pull/2217)
|
||||
```go
|
||||
e.RouteNotFound("/*", func(c echo.Context) error { return c.NoContent(http.StatusNotFound) })
|
||||
|
||||
g := e.Group("/images")
|
||||
g.RouteNotFound("/*", func(c echo.Context) error { return c.NoContent(http.StatusNotFound) })
|
||||
```
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add new value binding methods (UnixTimeMilli,TextUnmarshaler,JSONUnmarshaler) to Valuebinder [#2127](https://github.com/labstack/echo/pull/2127)
|
||||
* Refactor: body_limit middleware unit test [#2145](https://github.com/labstack/echo/pull/2145)
|
||||
* Refactor: Timeout mw: rework how test waits for timeout. [#2187](https://github.com/labstack/echo/pull/2187)
|
||||
* BasicAuth middleware returns 500 InternalServerError on invalid base64 strings but should return 400 [#2191](https://github.com/labstack/echo/pull/2191)
|
||||
* Refactor: duplicated findStaticChild process at findChildWithLabel [#2176](https://github.com/labstack/echo/pull/2176)
|
||||
* Allow different param names in different methods with same path scheme [#2209](https://github.com/labstack/echo/pull/2209)
|
||||
* Add support for registering handlers for different 404 routes [#2217](https://github.com/labstack/echo/pull/2217)
|
||||
* Middlewares should use errors.As() instead of type assertion on HTTPError [#2227](https://github.com/labstack/echo/pull/2227)
|
||||
* Allow arbitrary HTTP method types to be added as routes [#2237](https://github.com/labstack/echo/pull/2237)
|
||||
|
||||
## v4.7.2 - 2022-03-16
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix nil pointer exception when calling Start again after address binding error [#2131](https://github.com/labstack/echo/pull/2131)
|
||||
* Fix CSRF middleware not being able to extract token from multipart/form-data form [#2136](https://github.com/labstack/echo/pull/2136)
|
||||
* Fix Timeout middleware write race [#2126](https://github.com/labstack/echo/pull/2126)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Recover middleware should not log panic for aborted handler [#2134](https://github.com/labstack/echo/pull/2134)
|
||||
|
||||
|
||||
## v4.7.1 - 2022-03-13
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix `e.Static`, `.File()`, `c.Attachment()` being picky with paths starting with `./`, `../` and `/` after 4.7.0 introduced echo.Filesystem support (Go1.16+) [#2123](https://github.com/labstack/echo/pull/2123)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Remove some unused code [#2116](https://github.com/labstack/echo/pull/2116)
|
||||
|
||||
|
||||
## v4.7.0 - 2022-03-01
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add JWT, KeyAuth, CSRF multivalue extractors [#2060](https://github.com/labstack/echo/pull/2060)
|
||||
* Add LogErrorFunc to recover middleware [#2072](https://github.com/labstack/echo/pull/2072)
|
||||
* Add support for HEAD method query params binding [#2027](https://github.com/labstack/echo/pull/2027)
|
||||
* Improve filesystem support with echo.FileFS, echo.StaticFS, group.FileFS, group.StaticFS [#2064](https://github.com/labstack/echo/pull/2064)
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix X-Real-IP bug, improve tests [#2007](https://github.com/labstack/echo/pull/2007)
|
||||
* Minor syntax fixes [#1994](https://github.com/labstack/echo/pull/1994), [#2102](https://github.com/labstack/echo/pull/2102), [#2102](https://github.com/labstack/echo/pull/2102)
|
||||
|
||||
**General**
|
||||
|
||||
* Add cache-control and connection headers [#2103](https://github.com/labstack/echo/pull/2103)
|
||||
* Add Retry-After header constant [#2078](https://github.com/labstack/echo/pull/2078)
|
||||
* Upgrade `go` directive in `go.mod` to 1.17 [#2049](https://github.com/labstack/echo/pull/2049)
|
||||
* Add Pagoda [#2077](https://github.com/labstack/echo/pull/2077) and Souin [#2069](https://github.com/labstack/echo/pull/2069) to 3rd-party middlewares in README
|
||||
|
||||
## v4.6.3 - 2022-01-10
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fixed Echo version number in greeting message which was not incremented to `4.6.2` [#2066](https://github.com/labstack/echo/issues/2066)
|
||||
|
||||
|
||||
## v4.6.2 - 2022-01-08
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fixed route containing escaped colon should be matchable but is not matched to request path [#2047](https://github.com/labstack/echo/pull/2047)
|
||||
* Fixed a problem that returned wrong content-encoding when the gzip compressed content was empty. [#1921](https://github.com/labstack/echo/pull/1921)
|
||||
* Update (test) dependencies [#2021](https://github.com/labstack/echo/pull/2021)
|
||||
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add support for configurable target header for the request_id middleware [#2040](https://github.com/labstack/echo/pull/2040)
|
||||
* Change decompress middleware to use stream decompression instead of buffering [#2018](https://github.com/labstack/echo/pull/2018)
|
||||
* Documentation updates
|
||||
|
||||
|
||||
## v4.6.1 - 2021-09-26
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add start time to request logger middleware values [#1991](https://github.com/labstack/echo/pull/1991)
|
||||
|
||||
## v4.6.0 - 2021-09-20
|
||||
|
||||
Introduced a new [request logger](https://github.com/labstack/echo/blob/master/middleware/request_logger.go) middleware
|
||||
to help with cases when you want to use some other logging library in your application.
|
||||
|
||||
**Fixes**
|
||||
|
||||
* fix timeout middleware warning: superfluous response.WriteHeader [#1905](https://github.com/labstack/echo/issues/1905)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add Cookie to KeyAuth middleware's KeyLookup [#1929](https://github.com/labstack/echo/pull/1929)
|
||||
* JWT middleware should ignore case of auth scheme in request header [#1951](https://github.com/labstack/echo/pull/1951)
|
||||
* Refactor default error handler to return first if response is already committed [#1956](https://github.com/labstack/echo/pull/1956)
|
||||
* Added request logger middleware which helps to use custom logger library for logging requests. [#1980](https://github.com/labstack/echo/pull/1980)
|
||||
* Allow escaping of colon in route path so Google Cloud API "custom methods" could be implemented [#1988](https://github.com/labstack/echo/pull/1988)
|
||||
|
||||
## v4.5.0 - 2021-08-01
|
||||
|
||||
**Important notes**
|
||||
|
||||
A **BREAKING CHANGE** is introduced for JWT middleware users.
|
||||
The JWT library used for the JWT middleware had to be changed from [github.com/dgrijalva/jwt-go](https://github.com/dgrijalva/jwt-go) to
|
||||
[github.com/golang-jwt/jwt](https://github.com/golang-jwt/jwt) due former library being unmaintained and affected by security
|
||||
issues.
|
||||
The [github.com/golang-jwt/jwt](https://github.com/golang-jwt/jwt) project is a drop-in replacement, but supports only the latest 2 Go versions.
|
||||
So for JWT middleware users Go 1.15+ is required. For detailed information please read [#1940](https://github.com/labstack/echo/discussions/)
|
||||
|
||||
To change the library imports in all .go files in your project replace all occurrences of `dgrijalva/jwt-go` with `golang-jwt/jwt`.
|
||||
|
||||
For Linux CLI you can use:
|
||||
```bash
|
||||
find -type f -name "*.go" -exec sed -i "s/dgrijalva\/jwt-go/golang-jwt\/jwt/g" {} \;
|
||||
go mod tidy
|
||||
```
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Change JWT library to `github.com/golang-jwt/jwt` [#1946](https://github.com/labstack/echo/pull/1946)
|
||||
|
||||
## v4.4.0 - 2021-07-12
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Split HeaderXForwardedFor header only by comma [#1878](https://github.com/labstack/echo/pull/1878)
|
||||
* Fix Timeout middleware Context propagation [#1910](https://github.com/labstack/echo/pull/1910)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Bind data using headers as source [#1866](https://github.com/labstack/echo/pull/1866)
|
||||
* Adds JWTConfig.ParseTokenFunc to JWT middleware to allow different libraries implementing JWT parsing. [#1887](https://github.com/labstack/echo/pull/1887)
|
||||
* Adding tests for Echo#Host [#1895](https://github.com/labstack/echo/pull/1895)
|
||||
* Adds RequestIDHandler function to RequestID middleware [#1898](https://github.com/labstack/echo/pull/1898)
|
||||
* Allow for custom JSON encoding implementations [#1880](https://github.com/labstack/echo/pull/1880)
|
||||
|
||||
## v4.3.0 - 2021-05-08
|
||||
|
||||
**Important notes**
|
||||
|
||||
* Route matching has improvements for following cases:
|
||||
1. Correctly match routes with parameter part as last part of route (with trailing backslash)
|
||||
2. Considering handlers when resolving routes and search for matching http method handler
|
||||
* Echo minimal Go version is now 1.13.
|
||||
|
||||
**Fixes**
|
||||
|
||||
* When url ends with slash first param route is the match [#1804](https://github.com/labstack/echo/pull/1812)
|
||||
* Router should check if node is suitable as matching route by path+method and if not then continue search in tree [#1808](https://github.com/labstack/echo/issues/1808)
|
||||
* Fix timeout middleware not writing response correctly when handler panics [#1864](https://github.com/labstack/echo/pull/1864)
|
||||
* Fix binder not working with embedded pointer structs [#1861](https://github.com/labstack/echo/pull/1861)
|
||||
* Add Go 1.16 to CI and drop 1.12 specific code [#1850](https://github.com/labstack/echo/pull/1850)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Make KeyFunc public in JWT middleware [#1756](https://github.com/labstack/echo/pull/1756)
|
||||
* Add support for optional filesystem to the static middleware [#1797](https://github.com/labstack/echo/pull/1797)
|
||||
* Add a custom error handler to key-auth middleware [#1847](https://github.com/labstack/echo/pull/1847)
|
||||
* Allow JWT token to be looked up from multiple sources [#1845](https://github.com/labstack/echo/pull/1845)
|
||||
|
||||
## v4.2.2 - 2021-04-07
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Allow proxy middleware to use query part in rewrite (#1802)
|
||||
* Fix timeout middleware not sending status code when handler returns an error (#1805)
|
||||
* Fix Bind() when target is array/slice and path/query params complains bind target not being struct (#1835)
|
||||
* Fix panic in redirect middleware on short host name (#1813)
|
||||
* Fix timeout middleware docs (#1836)
|
||||
|
||||
## v4.2.1 - 2021-03-08
|
||||
|
||||
**Important notes**
|
||||
|
||||
Due to a datarace the config parameters for the newly added timeout middleware required a change.
|
||||
See the [docs](https://echo.labstack.com/middleware/timeout).
|
||||
A performance regression has been fixed, even bringing better performance than before for some routing scenarios.
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix performance regression caused by path escaping (#1777, #1798, #1799, aldas)
|
||||
* Avoid context canceled errors (#1789, clwluvw)
|
||||
* Improve router to use on stack backtracking (#1791, aldas, stffabi)
|
||||
* Fix panic in timeout middleware not being not recovered and cause application crash (#1794, aldas)
|
||||
* Fix Echo.Serve() not serving on HTTP port correctly when TLSListener is used (#1785, #1793, aldas)
|
||||
* Apply go fmt (#1788, Le0tk0k)
|
||||
* Uses strings.Equalfold (#1790, rkilingr)
|
||||
* Improve code quality (#1792, withshubh)
|
||||
|
||||
This release was made possible by our **contributors**:
|
||||
aldas, clwluvw, lammel, Le0tk0k, maciej-jezierski, rkilingr, stffabi, withshubh
|
||||
|
||||
## v4.2.0 - 2021-02-11
|
||||
|
||||
**Important notes**
|
||||
|
||||
The behaviour for binding data has been reworked for compatibility with echo before v4.1.11 by
|
||||
enforcing `explicit tagging` for processing parameters. This **may break** your code if you
|
||||
expect combined handling of query/path/form params.
|
||||
Please see the updated documentation for [request](https://echo.labstack.com/guide/request) and [binding](https://echo.labstack.com/guide/request)
|
||||
|
||||
The handling for rewrite rules has been slightly adjusted to expand `*` to a non-greedy `(.*?)` capture group. This is only relevant if multiple asterisks are used in your rules.
|
||||
Please see [rewrite](https://echo.labstack.com/middleware/rewrite) and [proxy](https://echo.labstack.com/middleware/proxy) for details.
|
||||
|
||||
**Security**
|
||||
|
||||
* Fix directory traversal vulnerability for Windows (#1718, little-cui)
|
||||
* Fix open redirect vulnerability with trailing slash (#1771,#1775 aldas,GeoffreyFrogeye)
|
||||
|
||||
**Enhancements**
|
||||
|
||||
* Add Echo#ListenerNetwork as configuration (#1667, pafuent)
|
||||
* Add ability to change the status code using response beforeFuncs (#1706, RashadAnsari)
|
||||
* Echo server startup to allow data race free access to listener address
|
||||
* Binder: Restore pre v4.1.11 behaviour for c.Bind() to use query params only for GET or DELETE methods (#1727, aldas)
|
||||
* Binder: Add separate methods to bind only query params, path params or request body (#1681, aldas)
|
||||
* Binder: New fluent binder for query/path/form parameter binding (#1717, #1736, aldas)
|
||||
* Router: Performance improvements for missed routes (#1689, pafuent)
|
||||
* Router: Improve performance for Real-IP detection using IndexByte instead of Split (#1640, imxyb)
|
||||
* Middleware: Support real regex rules for rewrite and proxy middleware (#1767)
|
||||
* Middleware: New rate limiting middleware (#1724, iambenkay)
|
||||
* Middleware: New timeout middleware implementation for go1.13+ (#1743, )
|
||||
* Middleware: Allow regex pattern for CORS middleware (#1623, KlotzAndrew)
|
||||
* Middleware: Add IgnoreBase parameter to static middleware (#1701, lnenad, iambenkay)
|
||||
* Middleware: Add an optional custom function to CORS middleware to validate origin (#1651, curvegrid)
|
||||
* Middleware: Support form fields in JWT middleware (#1704, rkfg)
|
||||
* Middleware: Use sync.Pool for (de)compress middleware to improve performance (#1699, #1672, pafuent)
|
||||
* Middleware: Add decompress middleware to support gzip compressed requests (#1687, arun0009)
|
||||
* Middleware: Add ErrJWTInvalid for JWT middleware (#1627, juanbelieni)
|
||||
* Middleware: Add SameSite mode for CSRF cookies to support iframes (#1524, pr0head)
|
||||
|
||||
**Fixes**
|
||||
|
||||
* Fix handling of special trailing slash case for partial prefix (#1741, stffabi)
|
||||
* Fix handling of static routes with trailing slash (#1747)
|
||||
* Fix Static files route not working (#1671, pwli0755, lammel)
|
||||
* Fix use of caret(^) in regex for rewrite middleware (#1588, chotow)
|
||||
* Fix Echo#Reverse for Any type routes (#1695, pafuent)
|
||||
* Fix Router#Find panic with infinite loop (#1661, pafuent)
|
||||
* Fix Router#Find panic fails on Param paths (#1659, pafuent)
|
||||
* Fix DefaultHTTPErrorHandler with Debug=true (#1477, lammel)
|
||||
* Fix incorrect CORS headers (#1669, ulasakdeniz)
|
||||
* Fix proxy middleware rewritePath to use url with updated tests (#1630, arun0009)
|
||||
* Fix rewritePath for proxy middleware to use escaped path in (#1628, arun0009)
|
||||
* Remove unless defer (#1656, imxyb)
|
||||
|
||||
**General**
|
||||
|
||||
* New maintainers for Echo: Roland Lammel (@lammel) and Pablo Andres Fuente (@pafuent)
|
||||
* Add GitHub action to compare benchmarks (#1702, pafuent)
|
||||
* Binding query/path params and form fields to struct only works for explicit tags (#1729,#1734, aldas)
|
||||
* Add support for Go 1.15 in CI (#1683, asahasrabuddhe)
|
||||
* Add test for request id to remain unchanged if provided (#1719, iambenkay)
|
||||
* Refactor echo instance listener access and startup to speed up testing (#1735, aldas)
|
||||
* Refactor and improve various tests for binding and routing
|
||||
* Run test workflow only for relevant changes (#1637, #1636, pofl)
|
||||
* Update .travis.yml (#1662, santosh653)
|
||||
* Update README.md with an recents framework benchmark (#1679, pafuent)
|
||||
|
||||
This release was made possible by **over 100 commits** from more than **20 contributors**:
|
||||
asahasrabuddhe, aldas, AndrewKlotz, arun0009, chotow, curvegrid, iambenkay, imxyb,
|
||||
juanbelieni, lammel, little-cui, lnenad, pafuent, pofl, pr0head, pwli, RashadAnsari,
|
||||
rkfg, santosh653, segfiner, stffabi, ulasakdeniz
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue