diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0effcf58..73e3db9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html),
and is generated by [Changie](https://github.com/miniscruff/changie).
+## v1.0.2 - 2024-01-18
+
+### ⬆️ Dependencies
+
+- Bump dependencies.
+ Migrate to public maintained jwt repo since original was deleted from github.
+
## v1.0.1 - 2023-08-09
### 📘 Docs
diff --git a/charts/dsv-k8s-controller/Chart.yaml b/charts/dsv-k8s-controller/Chart.yaml
index 4641a880..8f0c6425 100644
--- a/charts/dsv-k8s-controller/Chart.yaml
+++ b/charts/dsv-k8s-controller/Chart.yaml
@@ -30,7 +30,7 @@ keywords:
- vault
type: application
# WARNING: Version should be bumped by changie, not manually.
-version: v1.0.1
+version: v1.0.2
appVersion: latest
maintainers:
- name: Delinea DSV Team
diff --git a/charts/dsv-k8s-sidecar/Chart.yaml b/charts/dsv-k8s-sidecar/Chart.yaml
index 05e628fd..7a5e0dfe 100644
--- a/charts/dsv-k8s-sidecar/Chart.yaml
+++ b/charts/dsv-k8s-sidecar/Chart.yaml
@@ -29,7 +29,7 @@ keywords:
- vault
type: application
# WARNING: Version should be bumped by changie, not manually.
-version: v1.0.1
+version: v1.0.2
appVersion: latest
maintainers:
- name: Delinea DSV Team
diff --git a/go.mod b/go.mod
index fc3fc6f1..48d3e78a 100644
--- a/go.mod
+++ b/go.mod
@@ -1,47 +1,46 @@
module github.com/DelineaXPM/dsv-k8s-sidecar
-go 1.18
+go 1.21
require (
- github.com/bitfield/script v0.21.4
- github.com/dgrijalva/jwt-go/v4 v4.0.0-preview1
+ github.com/bitfield/script v0.22.0
github.com/ericchiang/k8s v1.2.0
+ github.com/golang-jwt/jwt/v5 v5.2.0
github.com/golang/mock v1.6.0
github.com/golang/protobuf v1.2.0
- github.com/gorilla/mux v1.8.0
- github.com/magefile/mage v1.14.0
- github.com/pterm/pterm v0.12.58
- github.com/sheldonhull/magetools v1.0.0
- github.com/sirupsen/logrus v1.2.0
- github.com/stretchr/testify v1.8.2
+ github.com/gorilla/mux v1.8.1
+ github.com/magefile/mage v1.15.0
+ github.com/pterm/pterm v0.12.75
+ github.com/sheldonhull/magetools v1.0.1
+ github.com/sirupsen/logrus v1.9.3
+ github.com/stretchr/testify v1.8.4
google.golang.org/grpc v1.16.0
)
require (
- atomicgo.dev/cursor v0.1.1 // indirect
+ atomicgo.dev/schedule v0.1.0 // indirect
+ mvdan.cc/sh/v3 v3.7.0 // indirect
+)
+
+require (
+ atomicgo.dev/cursor v0.2.0 // indirect
atomicgo.dev/keyboard v0.2.9 // indirect
- bitbucket.org/creachadair/shell v0.0.7 // indirect
github.com/containerd/console v1.0.3 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/dustin/go-humanize v1.0.0 // indirect
- github.com/gookit/color v1.5.3 // indirect
- github.com/itchyny/gojq v0.12.7 // indirect
- github.com/itchyny/timefmt-go v0.1.3 // indirect
- github.com/konsorten/go-windows-terminal-sequences v1.0.1 // indirect
- github.com/kr/pretty v0.2.1 // indirect
- github.com/lithammer/fuzzysearch v1.1.5 // indirect
- github.com/logrusorgru/aurora v2.0.3+incompatible // indirect
- github.com/mattn/go-runewidth v0.0.14 // indirect
+ github.com/dustin/go-humanize v1.0.1 // indirect
+ github.com/gookit/color v1.5.4 // indirect
+ github.com/itchyny/gojq v0.12.14 // indirect
+ github.com/itchyny/timefmt-go v0.1.5 // indirect
+ github.com/lithammer/fuzzysearch v1.1.8 // indirect
+ github.com/mattn/go-runewidth v0.0.15 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rivo/uniseg v0.4.4 // indirect
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
- github.com/ztrue/tracerr v0.3.0 // indirect
- golang.org/x/crypto v0.17.0 // indirect
- golang.org/x/mod v0.8.0 // indirect
- golang.org/x/net v0.17.0 // indirect; indirect // indirect
- golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 // indirect
- golang.org/x/sys v0.15.0 // indirect
- golang.org/x/term v0.15.0 // indirect
+ github.com/ztrue/tracerr v0.4.0 // indirect
+ golang.org/x/mod v0.14.0 // indirect
+ golang.org/x/net v0.20.0 // indirect; indirect // indirect
+ golang.org/x/sys v0.16.0 // indirect
+ golang.org/x/term v0.16.0 // indirect
golang.org/x/text v0.14.0 // indirect
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index a32ad8dd..60af5dc6 100644
--- a/go.sum
+++ b/go.sum
@@ -1,10 +1,11 @@
atomicgo.dev/assert v0.0.2 h1:FiKeMiZSgRrZsPo9qn/7vmr7mCsh5SZyXY4YGYiYwrg=
-atomicgo.dev/cursor v0.1.1 h1:0t9sxQomCTRh5ug+hAMCs59x/UmC9QL6Ci5uosINKD4=
-atomicgo.dev/cursor v0.1.1/go.mod h1:Lr4ZJB3U7DfPPOkbH7/6TOtJ4vFGHlgj1nc+n900IpU=
+atomicgo.dev/assert v0.0.2/go.mod h1:ut4NcI3QDdJtlmAxQULOmA13Gz6e2DWbSAS8RUOmNYQ=
+atomicgo.dev/cursor v0.2.0 h1:H6XN5alUJ52FZZUkI7AlJbUc1aW38GWZalpYRPpoPOw=
+atomicgo.dev/cursor v0.2.0/go.mod h1:Lr4ZJB3U7DfPPOkbH7/6TOtJ4vFGHlgj1nc+n900IpU=
atomicgo.dev/keyboard v0.2.9 h1:tOsIid3nlPLZ3lwgG8KZMp/SFmr7P0ssEN5JUsm78K8=
atomicgo.dev/keyboard v0.2.9/go.mod h1:BC4w9g00XkxH/f1HXhW2sXmJFOCWbKn9xrOunSFtExQ=
-bitbucket.org/creachadair/shell v0.0.7 h1:Z96pB6DkSb7F3Y3BBnJeOZH2gazyMTWlvecSD4vDqfk=
-bitbucket.org/creachadair/shell v0.0.7/go.mod h1:oqtXSSvSYr4624lnnabXHaBsYW6RD80caLi2b3hJk0U=
+atomicgo.dev/schedule v0.1.0 h1:nTthAbhZS5YZmgYbb2+DH8uQIZcTlIrd4eYr3UQxEjs=
+atomicgo.dev/schedule v0.1.0/go.mod h1:xeUa3oAkiuHYh8bKiQBRojqAMq3PXXbJujjb0hw8pEU=
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
github.com/MarvinJWendt/testza v0.1.0/go.mod h1:7AxNvlfeHP7Z/hDQ5JtE3OKYT3XFUeLCDE2DQninSqs=
github.com/MarvinJWendt/testza v0.2.1/go.mod h1:God7bhG8n6uQxwdScay+gjm9/LnO4D3kkcZX4hv9Rp8=
@@ -14,21 +15,27 @@ github.com/MarvinJWendt/testza v0.2.12/go.mod h1:JOIegYyV7rX+7VZ9r77L/eH6CfJHHzX
github.com/MarvinJWendt/testza v0.3.0/go.mod h1:eFcL4I0idjtIx8P9C6KkAuLgATNKpX4/2oUqKc6bF2c=
github.com/MarvinJWendt/testza v0.4.2/go.mod h1:mSdhXiKH8sg/gQehJ63bINcCKp7RtYewEjXsvsVUPbE=
github.com/MarvinJWendt/testza v0.5.2 h1:53KDo64C1z/h/d/stCYCPY69bt/OSwjq5KpFNwi+zB4=
+github.com/MarvinJWendt/testza v0.5.2/go.mod h1:xu53QFE5sCdjtMCKk8YMQ2MnymimEctc4n3EjyIYvEY=
github.com/atomicgo/cursor v0.0.1/go.mod h1:cBON2QmmrysudxNBFthvMtN32r3jxVRIvzkUiF/RuIk=
-github.com/bitfield/script v0.21.4 h1:XPMD/ti7pa9KW1aPMq7Hfh+mVznQdlqxkbiZSM2lnbE=
-github.com/bitfield/script v0.21.4/go.mod h1:l3AZPVAtKQrL03bwh7nlNTUtgrgSWurpJSbtqspYrOA=
+github.com/bitfield/script v0.22.0 h1:LA7QHuEsXMPD52YLtxWrlqCCy+9FOpzNYfsRHC5Gsrc=
+github.com/bitfield/script v0.22.0/go.mod h1:ms4w+9B8f2/W0mbsgWDVTtl7K94bYuZc3AunnJC4Ebs=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/containerd/console v1.0.3 h1:lIr7SlA5PxZyMV30bDW0MGbiOPXwc63yRuCP0ARubLw=
github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
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/dgrijalva/jwt-go/v4 v4.0.0-preview1 h1:CaO/zOnF8VvUfEbhRatPcwKVWamvbYd8tQGRWacE9kU=
-github.com/dgrijalva/jwt-go/v4 v4.0.0-preview1/go.mod h1:+hnT3ywWDTAFrW5aE+u2Sa/wT555ZqwoCS+pk3p6ry4=
-github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
-github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+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/ericchiang/k8s v1.2.0 h1:vxrMwEzY43oxu8aZyD/7b1s8tsBM+xoUoxjWECWFbPI=
github.com/ericchiang/k8s v1.2.0/go.mod h1:/OmBgSq2cd9IANnsGHGlEz27nwMZV2YxlpXuQtU3Bz4=
+github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/frankban/quicktest v1.14.5 h1:dfYrrRyLtiqT9GyKXgdh+k4inNeTvmGbuSgZ3lx3GhA=
+github.com/frankban/quicktest v1.14.5/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw=
+github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
@@ -38,45 +45,45 @@ github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+Licev
github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
-github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/renameio/v2 v2.0.0/go.mod h1:BtmJXm5YlszgC+TD4HOEEUFgkJP3nLxehU6hfe7jRt4=
github.com/gookit/color v1.4.2/go.mod h1:fqRyamkC1W8uxl+lxCQxOT09l/vYfZ+QeiX3rKQHCoQ=
github.com/gookit/color v1.5.0/go.mod h1:43aQb+Zerm/BWh2GnrgOQm7ffz7tvQXEKV6BFMl7wAo=
-github.com/gookit/color v1.5.3 h1:twfIhZs4QLCtimkP7MOxlF3A0U/5cDPseRT9M/+2SCE=
-github.com/gookit/color v1.5.3/go.mod h1:NUzwzeehUfl7GIb36pqId+UGmRfQcU/WiiyTTeNjHtE=
-github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
-github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
-github.com/itchyny/gojq v0.12.7 h1:hYPTpeWfrJ1OT+2j6cvBScbhl0TkdwGM4bc66onUSOQ=
-github.com/itchyny/gojq v0.12.7/go.mod h1:ZdvNHVlzPgUf8pgjnuDTmGfHA/21KoutQUJ3An/xNuw=
-github.com/itchyny/timefmt-go v0.1.3 h1:7M3LGVDsqcd0VZH2U+x393obrzZisp7C0uEe921iRkU=
-github.com/itchyny/timefmt-go v0.1.3/go.mod h1:0osSSCQSASBJMsIZnhAaF1C2fCBTJZXrnj37mG8/c+A=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/itchyny/gojq v0.12.12/go.mod h1:j+3sVkjxwd7A7Z5jrbKibgOLn0ZfLWkV+Awxr/pyzJE=
+github.com/itchyny/gojq v0.12.14 h1:6k8vVtsrhQSYgSGg827AD+PVVaB1NLXEdX+dda2oZCc=
+github.com/itchyny/gojq v0.12.14/go.mod h1:y1G7oO7XkcR1LPZO59KyoCRy08T3j9vDYRV0GgYSS+s=
+github.com/itchyny/timefmt-go v0.1.5 h1:G0INE2la8S6ru/ZI5JecgyzbbJNs5lG1RcBqa7Jm6GE=
+github.com/itchyny/timefmt-go v0.1.5/go.mod h1:nEP7L+2YmAbT2kZ2HfSs1d8Xtw9LY8D2stDBckWakZ8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.0.10/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
github.com/klauspost/cpuid/v2 v2.0.12/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lithammer/fuzzysearch v1.1.5 h1:Ag7aKU08wp0R9QCfF4GoGST9HbmAIeLP7xwMrOBEp1c=
-github.com/lithammer/fuzzysearch v1.1.5/go.mod h1:1R1LRNk7yKid1BaQkmuLQaHruxcC4HmAH30Dh61Ih1Q=
-github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
-github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8=
-github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
-github.com/magefile/mage v1.14.0 h1:6QDX3g6z1YvJ4olPhT1wksUcSa/V0a1B+pJb73fBjyo=
-github.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
-github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
+github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
+github.com/magefile/mage v1.15.0 h1:BvGheCMAsG3bWUDbZ8AyXXpCNwU9u5CB6sM+HNb9HYg=
+github.com/magefile/mage v1.15.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
+github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
+github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+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/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
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/pterm/pterm v0.12.27/go.mod h1:PhQ89w4i95rhgE+xedAoqous6K9X+r6aSOI2eFF7DZI=
@@ -86,59 +93,63 @@ github.com/pterm/pterm v0.12.31/go.mod h1:32ZAWZVXD7ZfG0s8qqHXePte42kdz8ECtRyEej
github.com/pterm/pterm v0.12.33/go.mod h1:x+h2uL+n7CP/rel9+bImHD5lF3nM9vJj80k9ybiiTTE=
github.com/pterm/pterm v0.12.36/go.mod h1:NjiL09hFhT/vWjQHSj1athJpx6H8cjpHXNAK5bUw8T8=
github.com/pterm/pterm v0.12.40/go.mod h1:ffwPLwlbXxP+rxT0GsgDTzS3y3rmpAO1NMjUkGTYf8s=
-github.com/pterm/pterm v0.12.58 h1:MEImvkbvty8JvoJH64bJ+CvoCkcuRw2iBIJvRwAEgHI=
-github.com/pterm/pterm v0.12.58/go.mod h1:Ro9CV954hiaxt3mcpDx4a8XF5EmRDlIIpPdlfCKF9fE=
+github.com/pterm/pterm v0.12.75 h1:sRoDOqowp0lOr2SBREsxLRzLOUmwBWfyOflsGnVIIbo=
+github.com/pterm/pterm v0.12.75/go.mod h1:1v/gzOF1N0FsjbgTHZ1wVycRkKiatFvJSJC4IGaQAAo=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/rogpeppe/go-internal v1.10.1-0.20230524175051-ec119421bb97 h1:3RPlVWzZ/PDqmVuf/FKHARG5EMid/tl7cv54Sw/QRVY=
+github.com/rogpeppe/go-internal v1.10.1-0.20230524175051-ec119421bb97/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
-github.com/sheldonhull/magetools v1.0.0 h1:IkGv46ZShJvVMfzkgdFWW6VXigoKkzlVSN3Ir1OU8ZU=
-github.com/sheldonhull/magetools v1.0.0/go.mod h1:2NgMhFb1nyBhCiP4lljJ54osHHChyxyi4FBO/dWGA28=
-github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sheldonhull/magetools v1.0.1 h1:EzTRk0JUNl2MijssyrA2Cx+J/7SyjcTgXQmsMccDpaI=
+github.com/sheldonhull/magetools v1.0.1/go.mod h1:K5W5pCBkaBlDqnheO2mSWZ8s9t8IOsKehxvj70g8kpg=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+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/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/ztrue/tracerr v0.3.0 h1:lDi6EgEYhPYPnKcjsYzmWw4EkFEoA/gfe+I9Y5f+h6Y=
-github.com/ztrue/tracerr v0.3.0/go.mod h1:qEalzze4VN9O8tnhBXScfCrmoJo10o8TN5ciKjm6Mww=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/ztrue/tracerr v0.4.0 h1:vT5PFxwIGs7rCg9ZgJ/y0NmOpJkPCPFK8x0vVIYzd04=
+github.com/ztrue/tracerr v0.4.0/go.mod h1:PaFfYlas0DfmXNpo7Eay4MFhZUONqvXM+T2HyGPpngk=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
-golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=
+golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
+golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -146,31 +157,42 @@ golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211013075003-97ac67df715c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4=
-golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
@@ -187,3 +209,7 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+mvdan.cc/editorconfig v0.2.0/go.mod h1:lvnnD3BNdBYkhq+B4uBuFFKatfp02eB6HixDvEz91C0=
+mvdan.cc/sh/v3 v3.6.0/go.mod h1:U4mhtBLZ32iWhif5/lD+ygy1zrgaQhUu+XFy7C8+TTA=
+mvdan.cc/sh/v3 v3.7.0 h1:lSTjdP/1xsddtaKfGg7Myu7DnlHItd3/M2tomOcNNBg=
+mvdan.cc/sh/v3 v3.7.0/go.mod h1:K2gwkaesF/D7av7Kxl0HbF5kGOd2ArupNTX3X44+8l8=
diff --git a/pkg/auth/service.go b/pkg/auth/service.go
index 25df5bca..336af93f 100644
--- a/pkg/auth/service.go
+++ b/pkg/auth/service.go
@@ -7,7 +7,7 @@ import (
"github.com/DelineaXPM/dsv-k8s-sidecar/pkg/pods"
- "github.com/dgrijalva/jwt-go/v4"
+ "github.com/golang-jwt/jwt/v5"
"github.com/sirupsen/logrus"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
diff --git a/vendor/atomicgo.dev/cursor/.golangci.yml b/vendor/atomicgo.dev/cursor/.golangci.yml
index d18a485d..796ca35c 100644
--- a/vendor/atomicgo.dev/cursor/.golangci.yml
+++ b/vendor/atomicgo.dev/cursor/.golangci.yml
@@ -17,55 +17,83 @@ linters-settings:
- ptrToRefParam
- paramTypeCombine
- unnamedResult
- misspell:
- locale: US
linters:
disable-all: true
enable:
+ # default linters
- errcheck
- gosimple
- govet
- ineffassign
- staticcheck
+ - typecheck
+ - unused
+ # additional linters
+ - asasalint
- asciicheck
+ - bidichk
- bodyclose
+ - containedctx
+ - contextcheck
+ - decorder
- dupl
- durationcheck
+ - errchkjson
+ - errname
- errorlint
- exhaustive
- - gci
- - gocognit
+ - exhaustruct
+ - exportloopref
+ - forcetypeassert
+ - gocheckcompilerdirectives
- gocritic
- godot
- godox
- goerr113
- gofmt
- - goimports
- goprintffuncname
- - misspell
+ - gosec
+ - gosmopolitan
+ - importas
+ - ireturn
+ - nakedret
+ - nestif
- nilerr
- - nlreturn
- - noctx
+ - nilnil
- prealloc
- predeclared
+ - revive
+ - rowserrcheck
+ - tagalign
+ - tenv
- thelper
+ - tparallel
- unconvert
- unparam
+ - usestdlibvars
- wastedassign
+ - whitespace
- wrapcheck
+ - wsl
+ - gocyclo
+ - misspell
issues:
- # Excluding configuration per-path, per-linter, per-text and per-source
+ include:
+ - EXC0012
+ - EXC0014
exclude-rules:
- path: _test\.go
linters:
+ - gocyclo
- errcheck
- dupl
+ - gosec
- gocritic
- - wrapcheck
- - goerr113
- # https://github.com/go-critic/go-critic/issues/926
- linters:
- gocritic
text: "unnecessaryDefer:"
+ - linters:
+ - gocritic
+ text: "preferDecodeRune:"
service:
- golangci-lint-version: 1.39.x # use the fixed version to not introduce new linters unexpectedly
+ golangci-lint-version: 1.53.x
diff --git a/vendor/atomicgo.dev/cursor/README.md b/vendor/atomicgo.dev/cursor/README.md
index c9d6d60d..0f799745 100644
--- a/vendor/atomicgo.dev/cursor/README.md
+++ b/vendor/atomicgo.dev/cursor/README.md
@@ -1,13 +1,14 @@
AtomicGo | cursor
+
-
+
@@ -18,21 +19,19 @@
-
-
-
-
+
+
+
+
---
-Get The Module
-|
Documentation
|
Contributing
@@ -49,11 +48,6 @@
-
-![]()
- -----------------------------------------------------------------------------------------------------
-![]()
- |
@@ -61,214 +55,542 @@
-
-![]()
- -----------------------------------------------------------------------------------------------------
-![]()
- |
-## Description
+
-Package cursor contains cross-platform methods to move the terminal cursor in
-different directions. This package can be used to create interactive CLI tools
-and games, live charts, algorithm visualizations and other updatable output of
-any kind.
+
-Works niceley with https://github.com/atomicgo/keyboard
+# cursor
-Special thanks to github.com/k0kubun/go-ansi which this project is based on.
+```go
+import "atomicgo.dev/cursor"
+```
+Package cursor contains cross\-platform methods to move the terminal cursor in different directions. This package can be used to create interactive CLI tools and games, live charts, algorithm visualizations and other updatable output of any kind.
-## Usage
+Works niceley with https://github.com/atomicgo/keyboard
-#### func Bottom
+Special thanks to github.com/k0kubun/go\-ansi which this project is based on.
+
+## Index
+
+- [func Bottom\(\)](<#Bottom>)
+- [func Clear\(\)](<#Clear>)
+- [func ClearLine\(\)](<#ClearLine>)
+- [func ClearLinesDown\(n int\)](<#ClearLinesDown>)
+- [func ClearLinesUp\(n int\)](<#ClearLinesUp>)
+- [func Down\(n int\)](<#Down>)
+- [func DownAndClear\(n int\)](<#DownAndClear>)
+- [func Hide\(\)](<#Hide>)
+- [func HorizontalAbsolute\(n int\)](<#HorizontalAbsolute>)
+- [func Left\(n int\)](<#Left>)
+- [func Move\(x, y int\)](<#Move>)
+- [func Right\(n int\)](<#Right>)
+- [func SetTarget\(w Writer\)](<#SetTarget>)
+- [func Show\(\)](<#Show>)
+- [func StartOfLine\(\)](<#StartOfLine>)
+- [func StartOfLineDown\(n int\)](<#StartOfLineDown>)
+- [func StartOfLineUp\(n int\)](<#StartOfLineUp>)
+- [func TestCustomIOWriter\(t \*testing.T\)](<#TestCustomIOWriter>)
+- [func Up\(n int\)](<#Up>)
+- [func UpAndClear\(n int\)](<#UpAndClear>)
+- [type Area](<#Area>)
+ - [func NewArea\(\) Area](<#NewArea>)
+ - [func \(area \*Area\) Bottom\(\)](<#Area.Bottom>)
+ - [func \(area \*Area\) Clear\(\)](<#Area.Clear>)
+ - [func \(area \*Area\) ClearLinesDown\(n int\)](<#Area.ClearLinesDown>)
+ - [func \(area \*Area\) ClearLinesUp\(n int\)](<#Area.ClearLinesUp>)
+ - [func \(area \*Area\) Down\(n int\)](<#Area.Down>)
+ - [func \(area \*Area\) DownAndClear\(n int\)](<#Area.DownAndClear>)
+ - [func \(area \*Area\) Move\(x, y int\)](<#Area.Move>)
+ - [func \(area \*Area\) StartOfLine\(\)](<#Area.StartOfLine>)
+ - [func \(area \*Area\) StartOfLineDown\(n int\)](<#Area.StartOfLineDown>)
+ - [func \(area \*Area\) StartOfLineUp\(n int\)](<#Area.StartOfLineUp>)
+ - [func \(area \*Area\) Top\(\)](<#Area.Top>)
+ - [func \(area \*Area\) Up\(n int\)](<#Area.Up>)
+ - [func \(area \*Area\) UpAndClear\(n int\)](<#Area.UpAndClear>)
+ - [func \(area \*Area\) Update\(content string\)](<#Area.Update>)
+ - [func \(area Area\) WithWriter\(writer Writer\) Area](<#Area.WithWriter>)
+- [type Cursor](<#Cursor>)
+ - [func NewCursor\(\) \*Cursor](<#NewCursor>)
+ - [func \(c \*Cursor\) Clear\(\)](<#Cursor.Clear>)
+ - [func \(c \*Cursor\) ClearLine\(\)](<#Cursor.ClearLine>)
+ - [func \(c \*Cursor\) Down\(n int\)](<#Cursor.Down>)
+ - [func \(c \*Cursor\) Hide\(\)](<#Cursor.Hide>)
+ - [func \(c \*Cursor\) HorizontalAbsolute\(n int\)](<#Cursor.HorizontalAbsolute>)
+ - [func \(c \*Cursor\) Left\(n int\)](<#Cursor.Left>)
+ - [func \(c \*Cursor\) Right\(n int\)](<#Cursor.Right>)
+ - [func \(c \*Cursor\) Show\(\)](<#Cursor.Show>)
+ - [func \(c \*Cursor\) Up\(n int\)](<#Cursor.Up>)
+ - [func \(c \*Cursor\) WithWriter\(w Writer\) \*Cursor](<#Cursor.WithWriter>)
+- [type Writer](<#Writer>)
+
+
+
+## func [Bottom]()
```go
func Bottom()
```
-Bottom moves the cursor to the bottom of the terminal. This is done by
-calculating how many lines were moved by Up and Down.
-#### func ClearLine
+Bottom moves the cursor to the bottom of the terminal. This is done by calculating how many lines were moved by Up and Down.
+
+
+## func [Clear]()
+
+```go
+func Clear()
+```
+
+Clear clears the current position and moves the cursor to the left.
+
+
+## func [ClearLine]()
```go
func ClearLine()
```
+
ClearLine clears the current line and moves the cursor to it's start position.
-#### func ClearLinesDown
+
+## func [ClearLinesDown]()
```go
func ClearLinesDown(n int)
```
-ClearLinesDown clears n lines downwards from the current position and moves the
-cursor.
-#### func ClearLinesUp
+ClearLinesDown clears n lines downwards from the current position and moves the cursor.
+
+
+## func [ClearLinesUp]()
```go
func ClearLinesUp(n int)
```
-ClearLinesUp clears n lines upwards from the current position and moves the
-cursor.
-#### func Down
+ClearLinesUp clears n lines upwards from the current position and moves the cursor.
+
+
+## func [Down]()
```go
func Down(n int)
```
+
Down moves the cursor n lines down relative to the current position.
-#### func DownAndClear
+
+## func [DownAndClear]()
```go
func DownAndClear(n int)
```
+
DownAndClear moves the cursor down by n lines, then clears the line.
-#### func Hide
+
+## func [Hide]()
```go
func Hide()
```
-Hide the cursor. Don't forget to show the cursor at least at the end of your
-application with Show. Otherwise the user might have a terminal with a
-permanently hidden cursor, until he reopens the terminal.
-#### func HorizontalAbsolute
+Hide the cursor. Don't forget to show the cursor at least at the end of your application with Show. Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+
+
+## func [HorizontalAbsolute]()
```go
func HorizontalAbsolute(n int)
```
-HorizontalAbsolute moves the cursor to n horizontally. The position n is
-absolute to the start of the line.
-#### func Left
+HorizontalAbsolute moves the cursor to n horizontally. The position n is absolute to the start of the line.
+
+
+## func [Left]()
```go
func Left(n int)
```
+
Left moves the cursor n characters to the left relative to the current position.
-#### func Move
+
+## func [Move]()
```go
func Move(x, y int)
```
+
Move moves the cursor relative by x and y.
-#### func Right
+
+## func [Right]()
```go
func Right(n int)
```
-Right moves the cursor n characters to the right relative to the current
-position.
-#### func SetTarget
+Right moves the cursor n characters to the right relative to the current position.
+
+
+## func [SetTarget]()
```go
func SetTarget(w Writer)
```
-SetTarget allows for any arbitrary Writer to be used
-#### func Show
+SetTarget sets to output target of the default curser to the provided cursor.Writer \(wrapping io.Writer\).
+
+
+## func [Show]()
```go
func Show()
```
-Show the cursor if it was hidden previously. Don't forget to show the cursor at
-least at the end of your application. Otherwise the user might have a terminal
-with a permanently hidden cursor, until he reopens the terminal.
-#### func StartOfLine
+Show the cursor if it was hidden previously. Don't forget to show the cursor at least at the end of your application. Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+
+
+## func [StartOfLine]()
```go
func StartOfLine()
```
+
StartOfLine moves the cursor to the start of the current line.
-#### func StartOfLineDown
+
+## func [StartOfLineDown]()
```go
func StartOfLineDown(n int)
```
-StartOfLineDown moves the cursor down by n lines, then moves to cursor to the
-start of the line.
-#### func StartOfLineUp
+StartOfLineDown moves the cursor down by n lines, then moves to cursor to the start of the line.
+
+
+## func [StartOfLineUp]()
```go
func StartOfLineUp(n int)
```
-StartOfLineUp moves the cursor up by n lines, then moves to cursor to the start
-of the line.
-#### func TestCustomIOWriter
+StartOfLineUp moves the cursor up by n lines, then moves to cursor to the start of the line.
+
+
+## func [TestCustomIOWriter]()
```go
func TestCustomIOWriter(t *testing.T)
```
-#### func Up
+TestCustomIOWriter tests the cursor functions with a custom Writer.
+
+
+## func [Up]()
```go
func Up(n int)
```
+
Up moves the cursor n lines up relative to the current position.
-#### func UpAndClear
+
+## func [UpAndClear]()
```go
func UpAndClear(n int)
```
+
UpAndClear moves the cursor up by n lines, then clears the line.
-#### type Area
+
+## type [Area]()
+
+Area displays content which can be updated on the fly. You can use this to create live output, charts, dropdowns, etc.
```go
type Area struct {
+ // contains filtered or unexported fields
}
```
-Area displays content which can be updated on the fly. You can use this to
-create live output, charts, dropdowns, etc.
-
-#### func NewArea
+
+### func [NewArea]()
```go
func NewArea() Area
```
+
NewArea returns a new Area.
-#### func (*Area) Clear
+
+### func \(\*Area\) [Bottom]()
+
+```go
+func (area *Area) Bottom()
+```
+
+Bottom moves the cursor to the bottom of the terminal. This is done by calculating how many lines were moved by Up and Down.
+
+
+### func \(\*Area\) [Clear]()
```go
func (area *Area) Clear()
```
+
Clear clears the content of the Area.
-#### func (*Area) Update
+
+### func \(\*Area\) [ClearLinesDown]()
+
+```go
+func (area *Area) ClearLinesDown(n int)
+```
+
+ClearLinesDown clears n lines downwards from the current position and moves the cursor.
+
+
+### func \(\*Area\) [ClearLinesUp]()
+
+```go
+func (area *Area) ClearLinesUp(n int)
+```
+
+ClearLinesUp clears n lines upwards from the current position and moves the cursor.
+
+
+### func \(\*Area\) [Down]()
+
+```go
+func (area *Area) Down(n int)
+```
+
+Down moves the cursor of the area down one line.
+
+
+### func \(\*Area\) [DownAndClear]()
+
+```go
+func (area *Area) DownAndClear(n int)
+```
+
+DownAndClear moves the cursor down by n lines, then clears the line.
+
+
+### func \(\*Area\) [Move]()
+
+```go
+func (area *Area) Move(x, y int)
+```
+
+Move moves the cursor relative by x and y.
+
+
+### func \(\*Area\) [StartOfLine]()
+
+```go
+func (area *Area) StartOfLine()
+```
+
+StartOfLine moves the cursor to the start of the current line.
+
+
+### func \(\*Area\) [StartOfLineDown]()
+
+```go
+func (area *Area) StartOfLineDown(n int)
+```
+
+StartOfLineDown moves the cursor down by n lines, then moves to cursor to the start of the line.
+
+
+### func \(\*Area\) [StartOfLineUp]()
+
+```go
+func (area *Area) StartOfLineUp(n int)
+```
+
+StartOfLineUp moves the cursor up by n lines, then moves to cursor to the start of the line.
+
+
+### func \(\*Area\) [Top]()
+
+```go
+func (area *Area) Top()
+```
+
+Top moves the cursor to the top of the area. This is done by calculating how many lines were moved by Up and Down.
+
+
+### func \(\*Area\) [Up]()
+
+```go
+func (area *Area) Up(n int)
+```
+
+Up moves the cursor of the area up one line.
+
+
+### func \(\*Area\) [UpAndClear]()
+
+```go
+func (area *Area) UpAndClear(n int)
+```
+
+UpAndClear moves the cursor up by n lines, then clears the line.
+
+
+### func \(\*Area\) [Update]()
```go
func (area *Area) Update(content string)
```
-Update overwrites the content of the Area.
-#### type Writer
+Update overwrites the content of the Area and adjusts its height based on content.
+
+
+### func \(Area\) [WithWriter]()
```go
-type Writer interface {
- io.Writer
- Fd() uintptr
+func (area Area) WithWriter(writer Writer) Area
+```
+
+WithWriter sets the custom writer.
+
+
+## type [Cursor]()
+
+Cursor displays content which can be updated on the fly. You can use this to create live output, charts, dropdowns, etc.
+
+```go
+type Cursor struct {
+ // contains filtered or unexported fields
}
```
+
+### func [NewCursor]()
+
+```go
+func NewCursor() *Cursor
+```
+
+NewCursor creates a new Cursor instance writing to os.Stdout.
+
+
+### func \(\*Cursor\) [Clear]()
+
+```go
+func (c *Cursor) Clear()
+```
+
+Clear clears the current position and moves the cursor to the left.
+
+
+### func \(\*Cursor\) [ClearLine]()
+
+```go
+func (c *Cursor) ClearLine()
+```
+
+ClearLine clears the current line and moves the cursor to it's start position.
+
+
+### func \(\*Cursor\) [Down]()
+
+```go
+func (c *Cursor) Down(n int)
+```
+
+Down moves the cursor n lines down relative to the current position.
+
+
+### func \(\*Cursor\) [Hide]()
+
+```go
+func (c *Cursor) Hide()
+```
+
+Hide the cursor. Don't forget to show the cursor at least at the end of your application with Show. Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+
+
+### func \(\*Cursor\) [HorizontalAbsolute]()
+
+```go
+func (c *Cursor) HorizontalAbsolute(n int)
+```
+
+HorizontalAbsolute moves the cursor to n horizontally. The position n is absolute to the start of the line.
+
+
+### func \(\*Cursor\) [Left]()
+
+```go
+func (c *Cursor) Left(n int)
+```
+
+Left moves the cursor n characters to the left relative to the current position.
+
+
+### func \(\*Cursor\) [Right]()
+
+```go
+func (c *Cursor) Right(n int)
+```
+
+Right moves the cursor n characters to the right relative to the current position.
+
+
+### func \(\*Cursor\) [Show]()
+
+```go
+func (c *Cursor) Show()
+```
+
+Show the cursor if it was hidden previously. Don't forget to show the cursor at least at the end of your application. Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+
+
+### func \(\*Cursor\) [Up]()
+
+```go
+func (c *Cursor) Up(n int)
+```
+
+Up moves the cursor n lines up relative to the current position.
+
+
+### func \(\*Cursor\) [WithWriter]()
+
+```go
+func (c *Cursor) WithWriter(w Writer) *Cursor
+```
+
+WithWriter allows for any arbitrary Writer to be used for cursor movement abstracted.
+
+
+## type [Writer]()
+
Writer is an expanded io.Writer interface with a file descriptor.
+```go
+type Writer interface {
+ io.Writer
+ Fd() uintptr
+}
+```
+
+Generated by [gomarkdoc]()
+
+
+
+
---
> [AtomicGo.dev](https://atomicgo.dev) ·
diff --git a/vendor/atomicgo.dev/cursor/area.go b/vendor/atomicgo.dev/cursor/area.go
index e8cd72d5..5b26b5db 100644
--- a/vendor/atomicgo.dev/cursor/area.go
+++ b/vendor/atomicgo.dev/cursor/area.go
@@ -1,49 +1,164 @@
package cursor
import (
- "fmt"
- "runtime"
+ "os"
"strings"
)
// Area displays content which can be updated on the fly.
// You can use this to create live output, charts, dropdowns, etc.
type Area struct {
- height int
+ height int
+ writer Writer
+ cursor *Cursor
+ cursorPosY int
}
// NewArea returns a new Area.
func NewArea() Area {
- return Area{}
+ return Area{
+ height: 0,
+ writer: os.Stdout,
+ cursor: cursor,
+ cursorPosY: 0,
+ }
+}
+
+// WithWriter sets the custom writer.
+func (area Area) WithWriter(writer Writer) Area {
+ area.writer = writer
+ area.cursor = area.cursor.WithWriter(writer)
+
+ return area
}
// Clear clears the content of the Area.
func (area *Area) Clear() {
- Bottom()
+ // Initialize writer if not done yet
+ if area.writer == nil {
+ area.writer = os.Stdout
+ }
+
if area.height > 0 {
- ClearLinesUp(area.height)
+ area.Bottom()
+ area.ClearLinesUp(area.height)
+ area.StartOfLine()
+ } else {
+ area.StartOfLine()
+ area.cursor.ClearLine()
}
}
-// Update overwrites the content of the Area.
+// Update overwrites the content of the Area and adjusts its height based on content.
func (area *Area) Update(content string) {
area.Clear()
- lines := strings.Split(content, "\n")
-
- fmt.Println(strings.Repeat("\n", len(lines)-1)) // This appends space if the terminal is at the bottom
- Up(len(lines))
+ area.writeArea(content)
+ area.cursorPosY = 0
+ area.height = strings.Count(content, "\n")
+}
- if runtime.GOOS == "windows" {
- for _, line := range lines {
- fmt.Print(line)
- StartOfLineDown(1)
+// Up moves the cursor of the area up one line.
+func (area *Area) Up(n int) {
+ if n > 0 {
+ if area.cursorPosY+n > area.height {
+ n = area.height - area.cursorPosY
}
- } else {
- for _, line := range lines {
- fmt.Println(line)
+
+ area.cursor.Up(n)
+ area.cursorPosY += n
+ }
+}
+
+// Down moves the cursor of the area down one line.
+func (area *Area) Down(n int) {
+ if n > 0 {
+ if area.cursorPosY-n < 0 {
+ n = area.height - area.cursorPosY
}
+
+ area.cursor.Down(n)
+ area.cursorPosY -= n
}
- height = 0
+}
+
+// Bottom moves the cursor to the bottom of the terminal.
+// This is done by calculating how many lines were moved by Up and Down.
+func (area *Area) Bottom() {
+ if area.cursorPosY > 0 {
+ area.Down(area.cursorPosY)
+ area.cursorPosY = 0
+ }
+}
+
+// Top moves the cursor to the top of the area.
+// This is done by calculating how many lines were moved by Up and Down.
+func (area *Area) Top() {
+ if area.cursorPosY < area.height {
+ area.Up(area.height - area.cursorPosY)
+ area.cursorPosY = area.height
+ }
+}
- area.height = len(lines)
+// StartOfLine moves the cursor to the start of the current line.
+func (area *Area) StartOfLine() {
+ area.cursor.HorizontalAbsolute(0)
+}
+
+// StartOfLineDown moves the cursor down by n lines, then moves to cursor to the start of the line.
+func (area *Area) StartOfLineDown(n int) {
+ area.Down(n)
+ area.StartOfLine()
+}
+
+// StartOfLineUp moves the cursor up by n lines, then moves to cursor to the start of the line.
+func (area *Area) StartOfLineUp(n int) {
+ area.Up(n)
+ area.StartOfLine()
+}
+
+// UpAndClear moves the cursor up by n lines, then clears the line.
+func (area *Area) UpAndClear(n int) {
+ area.Up(n)
+ area.cursor.ClearLine()
+}
+
+// DownAndClear moves the cursor down by n lines, then clears the line.
+func (area *Area) DownAndClear(n int) {
+ area.Down(n)
+ area.cursor.ClearLine()
+}
+
+// Move moves the cursor relative by x and y.
+func (area *Area) Move(x, y int) {
+ if x > 0 {
+ area.cursor.Right(x)
+ } else if x < 0 {
+ area.cursor.Left(-x)
+ }
+
+ if y > 0 {
+ area.Up(y)
+ } else if y < 0 {
+ area.Down(-y)
+ }
+}
+
+// ClearLinesUp clears n lines upwards from the current position and moves the cursor.
+func (area *Area) ClearLinesUp(n int) {
+ area.StartOfLine()
+ area.cursor.ClearLine()
+
+ for i := 0; i < n; i++ {
+ area.UpAndClear(1)
+ }
+}
+
+// ClearLinesDown clears n lines downwards from the current position and moves the cursor.
+func (area *Area) ClearLinesDown(n int) {
+ area.StartOfLine()
+ area.cursor.ClearLine()
+
+ for i := 0; i < n; i++ {
+ area.DownAndClear(1)
+ }
}
diff --git a/vendor/atomicgo.dev/cursor/area_other.go b/vendor/atomicgo.dev/cursor/area_other.go
new file mode 100644
index 00000000..b92390de
--- /dev/null
+++ b/vendor/atomicgo.dev/cursor/area_other.go
@@ -0,0 +1,13 @@
+//go:build !windows
+// +build !windows
+
+package cursor
+
+import (
+ "fmt"
+)
+
+// Update overwrites the content of the Area and adjusts its height based on content.
+func (area *Area) writeArea(content string) {
+ fmt.Fprint(area.writer, content)
+}
diff --git a/vendor/atomicgo.dev/cursor/area_windows.go b/vendor/atomicgo.dev/cursor/area_windows.go
new file mode 100644
index 00000000..de7dd292
--- /dev/null
+++ b/vendor/atomicgo.dev/cursor/area_windows.go
@@ -0,0 +1,21 @@
+//go:build windows
+// +build windows
+
+package cursor
+
+import (
+ "fmt"
+)
+
+// writeArea is a helper for platform dependant output.
+// For Windows newlines '\n' in the content are replaced by '\r\n'
+func (area *Area) writeArea(content string) {
+ last := ' '
+ for _, r := range content {
+ if r == '\n' && last != '\r' {
+ fmt.Fprint(area.writer, "\r\n")
+ continue
+ }
+ fmt.Fprint(area.writer, string(r))
+ }
+}
diff --git a/vendor/atomicgo.dev/cursor/cursor.go b/vendor/atomicgo.dev/cursor/cursor.go
index fb4c010b..89a3efcf 100644
--- a/vendor/atomicgo.dev/cursor/cursor.go
+++ b/vendor/atomicgo.dev/cursor/cursor.go
@@ -1,69 +1,26 @@
-//go:build !windows
-// +build !windows
-
package cursor
import (
- "fmt"
"os"
)
-var target Writer = os.Stdout
-
-// SetTarget allows for any arbitrary io.Writer to be used
-// for cursor movement (will not work on Windows).
-func SetTarget(w Writer) {
- target = w
+// Cursor displays content which can be updated on the fly.
+// You can use this to create live output, charts, dropdowns, etc.
+type Cursor struct {
+ writer Writer
}
-// Up moves the cursor n lines up relative to the current position.
-func Up(n int) {
- fmt.Fprintf(target, "\x1b[%dA", n)
- height += n
+// NewCursor creates a new Cursor instance writing to os.Stdout.
+func NewCursor() *Cursor {
+ return &Cursor{writer: os.Stdout}
}
-// Down moves the cursor n lines down relative to the current position.
-func Down(n int) {
- fmt.Fprintf(target, "\x1b[%dB", n)
- if height-n <= 0 {
- height = 0
- } else {
- height -= n
+// WithWriter allows for any arbitrary Writer to be used
+// for cursor movement abstracted.
+func (c *Cursor) WithWriter(w Writer) *Cursor {
+ if w != nil {
+ c.writer = w
}
-}
-
-// Right moves the cursor n characters to the right relative to the current position.
-func Right(n int) {
- fmt.Fprintf(target, "\x1b[%dC", n)
-}
-
-// Left moves the cursor n characters to the left relative to the current position.
-func Left(n int) {
- fmt.Fprintf(target, "\x1b[%dD", n)
-}
-
-// HorizontalAbsolute moves the cursor to n horizontally.
-// The position n is absolute to the start of the line.
-func HorizontalAbsolute(n int) {
- n += 1 // Moves the line to the character after n
- fmt.Fprintf(target, "\x1b[%dG", n)
-}
-
-// Show the cursor if it was hidden previously.
-// Don't forget to show the cursor at least at the end of your application.
-// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
-func Show() {
- fmt.Fprint(target, "\x1b[?25h")
-}
-
-// Hide the cursor.
-// Don't forget to show the cursor at least at the end of your application with Show.
-// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
-func Hide() {
- fmt.Fprintf(target, "\x1b[?25l")
-}
-// ClearLine clears the current line and moves the cursor to it's start position.
-func ClearLine() {
- fmt.Fprintf(target, "\x1b[2K")
+ return c
}
diff --git a/vendor/atomicgo.dev/cursor/cursor_other.go b/vendor/atomicgo.dev/cursor/cursor_other.go
new file mode 100644
index 00000000..7c185578
--- /dev/null
+++ b/vendor/atomicgo.dev/cursor/cursor_other.go
@@ -0,0 +1,67 @@
+//go:build !windows
+// +build !windows
+
+package cursor
+
+import (
+ "fmt"
+)
+
+// Up moves the cursor n lines up relative to the current position.
+func (c *Cursor) Up(n int) {
+ if n > 0 {
+ fmt.Fprintf(c.writer, "\x1b[%dA", n)
+ }
+}
+
+// Down moves the cursor n lines down relative to the current position.
+func (c *Cursor) Down(n int) {
+ if n > 0 {
+ fmt.Fprintf(c.writer, "\x1b[%dB", n)
+ }
+}
+
+// Right moves the cursor n characters to the right relative to the current position.
+func (c *Cursor) Right(n int) {
+ if n > 0 {
+ fmt.Fprintf(c.writer, "\x1b[%dC", n)
+ }
+}
+
+// Left moves the cursor n characters to the left relative to the current position.
+func (c *Cursor) Left(n int) {
+ if n > 0 {
+ fmt.Fprintf(c.writer, "\x1b[%dD", n)
+ }
+}
+
+// HorizontalAbsolute moves the cursor to n horizontally.
+// The position n is absolute to the start of the line.
+func (c *Cursor) HorizontalAbsolute(n int) {
+ n++ // Moves the line to the character after n
+ fmt.Fprintf(c.writer, "\x1b[%dG", n)
+}
+
+// Show the cursor if it was hidden previously.
+// Don't forget to show the cursor at least at the end of your application.
+// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+func (c *Cursor) Show() {
+ fmt.Fprint(c.writer, "\x1b[?25h")
+}
+
+// Hide the cursor.
+// Don't forget to show the cursor at least at the end of your application with Show.
+// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+func (c *Cursor) Hide() {
+ fmt.Fprintf(c.writer, "\x1b[?25l")
+}
+
+// ClearLine clears the current line and moves the cursor to it's start position.
+func (c *Cursor) ClearLine() {
+ fmt.Fprintf(c.writer, "\x1b[2K")
+}
+
+// Clear clears the current position and moves the cursor to the left.
+func (c *Cursor) Clear() {
+ fmt.Fprintf(c.writer, "\x1b[K")
+}
diff --git a/vendor/atomicgo.dev/cursor/cursor_test_linux.go b/vendor/atomicgo.dev/cursor/cursor_test_linux.go
index 25179b23..6a37f406 100644
--- a/vendor/atomicgo.dev/cursor/cursor_test_linux.go
+++ b/vendor/atomicgo.dev/cursor/cursor_test_linux.go
@@ -6,75 +6,93 @@ import (
"testing"
)
+// TestCustomIOWriter tests the cursor functions with a custom Writer.
func TestCustomIOWriter(t *testing.T) {
tmpFile, err := os.CreateTemp("", "testingTmpFile-")
+ defer os.Remove(tmpFile.Name())
+
if err != nil {
log.Fatal(err)
}
- defer os.Remove(tmpFile.Name())
w := tmpFile
SetTarget(w)
Up(2)
+
expected := "\x1b[2A"
actual := getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
Down(2)
+
expected = "\x1b[2B"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
Right(2)
+
expected = "\x1b[2C"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
Left(2)
+
expected = "\x1b[2D"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
Hide()
+
expected = "\x1b[?25l"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
Show()
+
expected = "\x1b[?25h"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
ClearLine()
+
expected = "\x1b[2K"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
clearFile(t, w)
HorizontalAbsolute(3)
+
expected = "\x1b[4G"
actual = getFileContent(t, w.Name())
+
if expected != actual {
t.Errorf("wanted: %v, got %v", expected, actual)
}
@@ -82,6 +100,7 @@ func TestCustomIOWriter(t *testing.T) {
func getFileContent(t *testing.T, fileName string) string {
t.Helper()
+
content, err := os.ReadFile(fileName)
if err != nil {
t.Errorf("failed to read file contents: %s", err)
@@ -94,12 +113,14 @@ func getFileContent(t *testing.T, fileName string) string {
func clearFile(t *testing.T, file *os.File) {
t.Helper()
+
err := file.Truncate(0)
if err != nil {
t.Errorf("failed to clear file")
return
}
+
_, err = file.Seek(0, 0)
if err != nil {
t.Errorf("failed to clear file")
diff --git a/vendor/atomicgo.dev/cursor/cursor_windows.go b/vendor/atomicgo.dev/cursor/cursor_windows.go
index 0a3be0af..ebe2bc59 100644
--- a/vendor/atomicgo.dev/cursor/cursor_windows.go
+++ b/vendor/atomicgo.dev/cursor/cursor_windows.go
@@ -1,46 +1,35 @@
+//go:build windows
+// +build windows
+
package cursor
import (
- "os"
"syscall"
"unsafe"
)
-var target Writer = os.Stdout
-
-// SetTarget allows for any arbitrary Writer to be used
-func SetTarget(w Writer) {
- target = w
-}
-
// Up moves the cursor n lines up relative to the current position.
-func Up(n int) {
- move(0, -n)
- height += n
+func (c *Cursor) Up(n int) {
+ c.move(0, -n)
}
// Down moves the cursor n lines down relative to the current position.
-func Down(n int) {
- move(0, n)
- if height-n <= 0 {
- height = 0
- } else {
- height -= n
- }
+func (c *Cursor) Down(n int) {
+ c.move(0, n)
}
// Right moves the cursor n characters to the right relative to the current position.
-func Right(n int) {
- move(n, 0)
+func (c *Cursor) Right(n int) {
+ c.move(n, 0)
}
// Left moves the cursor n characters to the left relative to the current position.
-func Left(n int) {
- move(-n, 0)
+func (c *Cursor) Left(n int) {
+ c.move(-n, 0)
}
-func move(x int, y int) {
- handle := syscall.Handle(target.Fd())
+func (c *Cursor) move(x int, y int) {
+ handle := syscall.Handle(c.writer.Fd())
var csbi consoleScreenBufferInfo
_, _, _ = procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
@@ -54,8 +43,8 @@ func move(x int, y int) {
// HorizontalAbsolute moves the cursor to n horizontally.
// The position n is absolute to the start of the line.
-func HorizontalAbsolute(n int) {
- handle := syscall.Handle(target.Fd())
+func (c *Cursor) HorizontalAbsolute(n int) {
+ handle := syscall.Handle(c.writer.Fd())
var csbi consoleScreenBufferInfo
_, _, _ = procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
@@ -74,8 +63,8 @@ func HorizontalAbsolute(n int) {
// Show the cursor if it was hidden previously.
// Don't forget to show the cursor at least at the end of your application.
// Otherwise the user might have a terminal with a permanently hidden cursor, until he reopens the terminal.
-func Show() {
- handle := syscall.Handle(target.Fd())
+func (c *Cursor) Show() {
+ handle := syscall.Handle(c.writer.Fd())
var cci consoleCursorInfo
_, _, _ = procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
@@ -87,8 +76,8 @@ func Show() {
// Hide the cursor.
// Don't forget to show the cursor at least at the end of your application with Show.
// Otherwise the user might have a terminal with a permanently hidden cursor, until he reopens the terminal.
-func Hide() {
- handle := syscall.Handle(target.Fd())
+func (c *Cursor) Hide() {
+ handle := syscall.Handle(c.writer.Fd())
var cci consoleCursorInfo
_, _, _ = procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
@@ -97,9 +86,9 @@ func Hide() {
_, _, _ = procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&cci)))
}
-// ClearLine clears the current line and moves the cursor to it's start position.
-func ClearLine() {
- handle := syscall.Handle(target.Fd())
+// ClearLine clears the current line and moves the cursor to its start position.
+func (c *Cursor) ClearLine() {
+ handle := syscall.Handle(c.writer.Fd())
var csbi consoleScreenBufferInfo
_, _, _ = procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
@@ -110,3 +99,20 @@ func ClearLine() {
x = csbi.size.x
_, _, _ = procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(x), uintptr(*(*int32)(unsafe.Pointer(&cursor))), uintptr(unsafe.Pointer(&w)))
}
+
+// Clear clears the current position and moves the cursor to the left.
+func (c *Cursor) Clear() {
+ handle := syscall.Handle(c.writer.Fd())
+
+ var csbi consoleScreenBufferInfo
+ _, _, _ = procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+ var w uint32
+ cursor := csbi.cursorPosition
+ _, _, _ = procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(1), uintptr(*(*int32)(unsafe.Pointer(&cursor))), uintptr(unsafe.Pointer(&w)))
+
+ if cursor.x > 0 {
+ cursor.x--
+ }
+ _, _, _ = procSetConsoleCursorPosition.Call(uintptr(handle), uintptr(*(*int32)(unsafe.Pointer(&cursor))))
+}
diff --git a/vendor/atomicgo.dev/cursor/go.work b/vendor/atomicgo.dev/cursor/go.work
new file mode 100644
index 00000000..c71ff3ba
--- /dev/null
+++ b/vendor/atomicgo.dev/cursor/go.work
@@ -0,0 +1,10 @@
+go 1.18
+
+use .
+
+// replace git.neotel.at/go/c5rest => /home/rl/work/c5rest
+// replace git.neotel.at/go/c5db => /home/rl/work/c5db
+
+// replace github.com/pterm/pterm => H:/work/github.com/pterm/pterm
+
+// replace atomicgo.dev/cursor => H:/github.com/atomicgo.dev/cursor
diff --git a/vendor/atomicgo.dev/cursor/utils.go b/vendor/atomicgo.dev/cursor/utils.go
index cde36686..4b75f09e 100644
--- a/vendor/atomicgo.dev/cursor/utils.go
+++ b/vendor/atomicgo.dev/cursor/utils.go
@@ -1,16 +1,92 @@
package cursor
-import "io"
+import (
+ "io"
+ "os"
+)
-var height int
+//
+// Helpers for global cursor handling on os.Stdout
+//
+
+var autoheight int
+var cursor = &Cursor{writer: os.Stdout}
+
+// Writer is an expanded io.Writer interface with a file descriptor.
+type Writer interface {
+ io.Writer
+ Fd() uintptr
+}
+
+// SetTarget sets to output target of the default curser to the
+// provided cursor.Writer (wrapping io.Writer).
+func SetTarget(w Writer) {
+ cursor = cursor.WithWriter(w)
+}
+
+// Up moves the cursor n lines up relative to the current position.
+func Up(n int) {
+ cursor.Up(n)
+ autoheight += n
+}
+
+// Down moves the cursor n lines down relative to the current position.
+func Down(n int) {
+ cursor.Down(n)
+
+ if autoheight > 0 {
+ autoheight -= n
+ }
+}
+
+// Right moves the cursor n characters to the right relative to the current position.
+func Right(n int) {
+ cursor.Right(n)
+}
+
+// Left moves the cursor n characters to the left relative to the current position.
+func Left(n int) {
+ cursor.Left(n)
+}
+
+// HorizontalAbsolute moves the cursor to n horizontally.
+// The position n is absolute to the start of the line.
+func HorizontalAbsolute(n int) {
+ cursor.HorizontalAbsolute(n)
+}
+
+// Show the cursor if it was hidden previously.
+// Don't forget to show the cursor at least at the end of your application.
+// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+func Show() {
+ cursor.Show()
+}
+
+// Hide the cursor.
+// Don't forget to show the cursor at least at the end of your application with Show.
+// Otherwise the user might have a terminal with a permanently hidden cursor, until they reopen the terminal.
+func Hide() {
+ cursor.Hide()
+}
+
+// ClearLine clears the current line and moves the cursor to it's start position.
+func ClearLine() {
+ cursor.ClearLine()
+}
+
+// Clear clears the current position and moves the cursor to the left.
+func Clear() {
+ cursor.Clear()
+}
// Bottom moves the cursor to the bottom of the terminal.
// This is done by calculating how many lines were moved by Up and Down.
func Bottom() {
- if height > 0 {
- Down(height)
+ if autoheight > 0 {
+ Down(autoheight)
StartOfLine()
- height = 0
+
+ autoheight = 0
}
}
@@ -73,9 +149,3 @@ func ClearLinesDown(n int) {
DownAndClear(1)
}
}
-
-// Writer is an expanded io.Writer interface with a file descriptor.
-type Writer interface {
- io.Writer
- Fd() uintptr
-}
diff --git a/vendor/atomicgo.dev/schedule/.gitignore b/vendor/atomicgo.dev/schedule/.gitignore
new file mode 100644
index 00000000..7e5f3f45
--- /dev/null
+++ b/vendor/atomicgo.dev/schedule/.gitignore
@@ -0,0 +1,40 @@
+# Go template
+
+## Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+## Test binary, built with `go test -c`
+*.test
+
+## Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+## Dependency directories (remove the comment below to include it)
+vendor/
+
+# IDEs
+
+## IntelliJ
+.idea
+*.iml
+out
+gen
+
+## Visual Studio Code
+.vscode
+*.code-workspace
+
+# Operating System Files
+
+## macOS
+### General
+.DS_Store
+
+# Other
+
+## Experimenting folder
+experimenting
diff --git a/vendor/atomicgo.dev/schedule/.golangci.yml b/vendor/atomicgo.dev/schedule/.golangci.yml
new file mode 100644
index 00000000..796ca35c
--- /dev/null
+++ b/vendor/atomicgo.dev/schedule/.golangci.yml
@@ -0,0 +1,99 @@
+linters-settings:
+ gocritic:
+ enabled-tags:
+ - diagnostic
+ - experimental
+ - opinionated
+ - performance
+ - style
+ disabled-checks:
+ - dupImport
+ - ifElseChain
+ - octalLiteral
+ - whyNoLint
+ - wrapperFunc
+ - exitAfterDefer
+ - hugeParam
+ - ptrToRefParam
+ - paramTypeCombine
+ - unnamedResult
+linters:
+ disable-all: true
+ enable:
+ # default linters
+ - errcheck
+ - gosimple
+ - govet
+ - ineffassign
+ - staticcheck
+ - typecheck
+ - unused
+ # additional linters
+ - asasalint
+ - asciicheck
+ - bidichk
+ - bodyclose
+ - containedctx
+ - contextcheck
+ - decorder
+ - dupl
+ - durationcheck
+ - errchkjson
+ - errname
+ - errorlint
+ - exhaustive
+ - exhaustruct
+ - exportloopref
+ - forcetypeassert
+ - gocheckcompilerdirectives
+ - gocritic
+ - godot
+ - godox
+ - goerr113
+ - gofmt
+ - goprintffuncname
+ - gosec
+ - gosmopolitan
+ - importas
+ - ireturn
+ - nakedret
+ - nestif
+ - nilerr
+ - nilnil
+ - prealloc
+ - predeclared
+ - revive
+ - rowserrcheck
+ - tagalign
+ - tenv
+ - thelper
+ - tparallel
+ - unconvert
+ - unparam
+ - usestdlibvars
+ - wastedassign
+ - whitespace
+ - wrapcheck
+ - wsl
+ - gocyclo
+ - misspell
+issues:
+ include:
+ - EXC0012
+ - EXC0014
+ exclude-rules:
+ - path: _test\.go
+ linters:
+ - gocyclo
+ - errcheck
+ - dupl
+ - gosec
+ - gocritic
+ - linters:
+ - gocritic
+ text: "unnecessaryDefer:"
+ - linters:
+ - gocritic
+ text: "preferDecodeRune:"
+service:
+ golangci-lint-version: 1.53.x
diff --git a/vendor/atomicgo.dev/schedule/LICENSE b/vendor/atomicgo.dev/schedule/LICENSE
new file mode 100644
index 00000000..b42989ef
--- /dev/null
+++ b/vendor/atomicgo.dev/schedule/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Marvin Wendt (MarvinJWendt)
+
+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.
diff --git a/vendor/atomicgo.dev/schedule/README.md b/vendor/atomicgo.dev/schedule/README.md
new file mode 100644
index 00000000..3f7f9a84
--- /dev/null
+++ b/vendor/atomicgo.dev/schedule/README.md
@@ -0,0 +1,281 @@
+AtomicGo | schedule
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+
+Documentation
+|
+Contributing
+|
+Code of Conduct
+
+
+---
+
+
+ 
+
+
+
+
+
+go get atomicgo.dev/schedule
+
+
+
+
+
+
+
+
+# schedule
+
+```go
+import "atomicgo.dev/schedule"
+```
+
+Package schedule provides a simple scheduler for Go.
+
+It can run a function at a given time, in a given duration, or repeatedly at a given interval.
+
+## Index
+
+- [type Task](<#Task>)
+ - [func After\(d time.Duration, task func\(\)\) \*Task](<#After>)
+ - [func At\(t time.Time, task func\(\)\) \*Task](<#At>)
+ - [func Every\(interval time.Duration, task func\(\) bool\) \*Task](<#Every>)
+ - [func \(s \*Task\) ExecutesIn\(\) time.Duration](<#Task.ExecutesIn>)
+ - [func \(s \*Task\) IsActive\(\) bool](<#Task.IsActive>)
+ - [func \(s \*Task\) NextExecutionTime\(\) time.Time](<#Task.NextExecutionTime>)
+ - [func \(s \*Task\) StartedAt\(\) time.Time](<#Task.StartedAt>)
+ - [func \(s \*Task\) Stop\(\)](<#Task.Stop>)
+ - [func \(s \*Task\) Wait\(\)](<#Task.Wait>)
+
+
+
+## type [Task]()
+
+Task holds information about the running task and can be used to stop running tasks.
+
+```go
+type Task struct {
+ // contains filtered or unexported fields
+}
+```
+
+
+### func [After]()
+
+```go
+func After(d time.Duration, task func()) *Task
+```
+
+After executes the task after the given duration. The function is non\-blocking. If you want to wait for the task to be executed, use the Task.Wait method.
+
+Example
+
+
+
+
+```go
+package main
+
+import (
+ "fmt"
+ "time"
+
+ "atomicgo.dev/schedule"
+)
+
+func main() {
+ task := schedule.After(5*time.Second, func() {
+ fmt.Println("5 seconds are over!")
+ })
+
+ fmt.Println("Some stuff happening...")
+
+ task.Wait()
+}
+```
+
+
+Example
+
+
+
+
+```go
+package main
+
+import (
+ "fmt"
+ "time"
+
+ "atomicgo.dev/schedule"
+)
+
+func main() {
+ task := schedule.At(time.Now().Add(5*time.Second), func() {
+ fmt.Println("5 seconds are over!")
+ })
+
+ fmt.Println("Some stuff happening...")
+
+ task.Wait()
+}
+```
+
+
+Example
+
+
+
+
+```go
+package main
+
+import (
+ "fmt"
+ "time"
+
+ "atomicgo.dev/schedule"
+)
+
+func main() {
+ task := schedule.Every(time.Second, func() bool {
+ fmt.Println("1 second is over!")
+ return true // return false to stop the task
+ })
+
+ fmt.Println("Some stuff happening...")
+
+ time.Sleep(10 * time.Second)
+
+ task.Stop()
+}
+```
+
+
+
+
+ 
+
+
-Show Demo Code
+Show Demo Code
@@ -88,25 +92,30 @@ go get github.com/pterm/pterm
### Printers (Components)
+
+
| Feature | Feature | Feature | Feature | Feature |
| :-------: | :-------: | :-------: | :-------: | :-------: |
| Area
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/area) |Barchart
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/barchart) |Basictext
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/basictext) |Bigtext
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/bigtext) |Box
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/box) |
-| Bulletlist
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/bulletlist) |Center
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/center) |Coloring
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/coloring) |Demo
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/demo) |Header
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/header) |
+| Bulletlist
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/bulletlist) |Center
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/center) |Coloring
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/coloring) |Header
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/header) |Heatmap
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/heatmap) |
| Interactive confirm
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/interactive_confirm) |Interactive continue
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/interactive_continue) |Interactive multiselect
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/interactive_multiselect) |Interactive select
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/interactive_select) |Interactive textinput
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/interactive_textinput) |
-| Logger
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/logger) |Panel
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/panel) |Paragraph
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/paragraph) |Prefix
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/prefix) |Progressbar
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/progressbar) |
-| Section
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/section) |Spinner
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/spinner) |Style
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/style) |Table
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/table) |Theme
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/theme) |
-| Tree
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/tree) | | | | |
+| Logger
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/logger) |Multiple-live-printers
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/multiple-live-printers) |Panel
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/panel) |Paragraph
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/paragraph) |Prefix
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/prefix) |
+| Progressbar
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/progressbar) |Section
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/section) |Slog
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/slog) |Spinner
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/spinner) |Style
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/style) |
+| Table
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/table) |Theme
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/theme) |Tree
[(Examples)](https://github.com/pterm/pterm/tree/master/_examples/tree) | | |
+
+
+---
-### 🦸♂️ Supporters
+### 🦸♂️ Sponsors
-|-|User|💸|
-|---|---|---|
-||[@jenslauterbach](https://github.com/jenslauterbach)|25$|
+
+
+---
@@ -141,16 +150,37 @@ import (
"time"
"github.com/pterm/pterm"
+ "github.com/pterm/pterm/putils"
)
func main() {
+ // Print an informational message using PTerm's Info printer.
+ // This message will stay in place while the area updates.
+ pterm.Info.Println("The previous text will stay in place, while the area updates.")
+
+ // Print two new lines as spacer.
+ pterm.Print("\n\n")
+
+ // Start the Area printer from PTerm's DefaultArea, with the Center option.
+ // The Area printer allows us to update a specific area of the console output.
+ // The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
- for i := 0; i < 5; i++ {
- area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
+ // Loop 10 times to update the area with the current time.
+ for i := 0; i < 10; i++ {
+ // Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
+ // Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
+ // The Srender() function is used to save the BigText as a string.
+ str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
+
+ // Update the Area contents with the current time string.
+ area.Update(str)
+
+ // Sleep for a second before the next update.
time.Sleep(time.Second)
}
+ // Stop the Area printer after all updates are done.
area.Stop()
}
@@ -158,9 +188,9 @@ func main() {
-### area/default
+### area/center
-
+
@@ -176,13 +206,21 @@ import (
)
func main() {
- area, _ := pterm.DefaultArea.Start()
+ // Start a new default area in the center of the terminal.
+ // The Start() function returns the created area and an error.
+ area, _ := pterm.DefaultArea.WithCenter().Start()
+ // Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
+ // Update the content of the area with the current count.
+ // The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
+
+ // Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
+ // Stop the area after all updates are done.
area.Stop()
}
@@ -190,9 +228,9 @@ func main() {
-### area/demo
+### area/default
-
+
@@ -208,15 +246,22 @@ import (
)
func main() {
- pterm.Info.Println("The previous text will stay in place, while the area updates.")
- pterm.Print("\n\n") // Add two new lines as spacer.
+ // Start a new default area and get a reference to it.
+ // The second return value is an error which is ignored here.
+ area, _ := pterm.DefaultArea.Start()
- area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
- for i := 0; i < 10; i++ {
- str, _ := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
- area.Update(str) // Update Area contents.
+ // Loop 5 times
+ for i := 0; i < 5; i++ {
+ // Update the content of the area dynamically.
+ // Here we're just displaying the current count.
+ area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
+
+ // Pause for a second before the next update.
time.Sleep(time.Second)
}
+
+ // Stop the area after all updates are done.
+ // This will clean up and free resources used by the area.
area.Stop()
}
@@ -242,23 +287,35 @@ import (
)
func main() {
+ // Start a new fullscreen centered area.
+ // This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
+ // Ensure the area stops updating when we're done.
defer area.Stop()
+ // Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
+ // Create a new bar chart with dynamic bars.
+ // The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
+ // Render the bar chart to a string.
+ // This string will be used to update the area.
content, _ := barchart.Srender()
+ // Update the area with the new bar chart.
area.Update(content)
+ // Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
+// dynamicBars generates a set of bars for the bar chart.
+// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
- {Label: "A", Value: 10},
- {Label: "B", Value: 20 * i},
- {Label: "C", Value: 30},
- {Label: "D", Value: 40 + i},
+ {Label: "A", Value: 10}, // A static bar.
+ {Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
+ {Label: "C", Value: 30}, // Another static bar.
+ {Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
@@ -284,13 +341,21 @@ import (
)
func main() {
+ // Start a new fullscreen area. This will return an area instance and an error.
+ // The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
+ // Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
+ // Update the content of the area with the current count.
+ // The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
+
+ // Pause for a second before the next update.
time.Sleep(time.Second)
}
+ // Stop the area after all updates are done.
area.Stop()
}
@@ -316,13 +381,22 @@ import (
)
func main() {
+ // Initialize a new PTerm area with fullscreen and center options
+ // The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
+ // Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
+ // Update the content of the area with the current count
+ // The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
+
+ // Pause for a second
time.Sleep(time.Second)
}
+ // Stop the area after all updates are done
+ // This will clear the area and return the terminal to its normal state
area.Stop()
}
@@ -330,9 +404,9 @@ func main() {
-### barchart/custom-height
+### barchart/demo
-
+
@@ -341,29 +415,39 @@ func main() {
```go
package main
-import "github.com/pterm/pterm"
+import (
+ "github.com/pterm/pterm"
+)
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
- {Label: "A", Value: 10},
- {Label: "B", Value: 20},
- {Label: "C", Value: 30},
- {Label: "D", Value: 40},
- {Label: "E", Value: 50},
- {Label: "F", Value: 40},
- {Label: "G", Value: 30},
- {Label: "H", Value: 20},
- {Label: "I", Value: 10},
- }).WithHeight(5).Render()
+ // Define the bars for the chart
+ bars := []pterm.Bar{
+ {Label: "Bar 1", Value: 5},
+ {Label: "Bar 2", Value: 3},
+ {Label: "Longer Label", Value: 7},
+ }
+
+ // Print an informational message
+ pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
+
+ // Create a bar chart with the defined bars and render it
+ // The DefaultBarChart is used as a base, and the bars are added with the WithBars option
+ // The Render function is then called to display the chart
+ pterm.DefaultBarChart.WithBars(bars).Render()
+
+ // Create a horizontal bar chart with the defined bars and render it
+ // The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
+ // The Render function is then called to display the chart
+ pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
```
-### barchart/custom-width
+### barchart/custom-height
-
+
@@ -375,7 +459,9 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
+ // Define a slice of Bar structs. Each struct represents a bar in the chart.
+ // The Label field is the name of the bar and the Value field is the height of the bar.
+ bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
@@ -385,16 +471,22 @@ func main() {
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
- }).WithHorizontal().WithWidth(5).Render()
+ }
+
+ // Create and render a bar chart with the defined bars and a height of 5.
+ // The WithBars method is used to set the bars of the chart.
+ // The WithHeight method is used to set the height of the chart.
+ // The Render method is used to display the chart in the terminal.
+ pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
```
-### barchart/default
+### barchart/custom-width
-
+
@@ -406,7 +498,8 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
+ // Define the data for the bar chart
+ barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
@@ -416,16 +509,21 @@ func main() {
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
- }).Render()
+ }
+
+ // Create a bar chart with the defined data
+ // The chart is horizontal and has a width of 5
+ // The Render() function is called to display the chart
+ pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
```
-### barchart/demo
+### barchart/default
-
+
@@ -434,29 +532,27 @@ func main() {
```go
package main
-import (
- "github.com/pterm/pterm"
-)
+import "github.com/pterm/pterm"
func main() {
- positiveBars := pterm.Bars{
- pterm.Bar{
- Label: "Bar 1",
- Value: 5,
- },
- pterm.Bar{
- Label: "Bar 2",
- Value: 3,
- },
- pterm.Bar{
- Label: "Longer Label",
- Value: 7,
- },
+ // Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
+ // The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
+ bars := []pterm.Bar{
+ {Label: "A", Value: 10},
+ {Label: "B", Value: 20},
+ {Label: "C", Value: 30},
+ {Label: "D", Value: 40},
+ {Label: "E", Value: 50},
+ {Label: "F", Value: 40},
+ {Label: "G", Value: 30},
+ {Label: "H", Value: 20},
+ {Label: "I", Value: 10},
}
- pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
- _ = pterm.DefaultBarChart.WithBars(positiveBars).Render()
- _ = pterm.DefaultBarChart.WithHorizontal().WithBars(positiveBars).Render()
+ // Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
+ // The `WithBars` method is used to set the bars of the chart.
+ // The `Render` method is used to display the chart.
+ pterm.DefaultBarChart.WithBars(bars).Render()
}
```
@@ -477,7 +573,8 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
+ // Define the data for the bar chart
+ bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
@@ -487,7 +584,12 @@ func main() {
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
- }).WithHorizontal().Render()
+ }
+
+ // Create a bar chart with the defined data
+ // The chart is displayed horizontally
+ // The Render() function is called to display the chart
+ pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
```
@@ -508,7 +610,8 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
+ // Define the data for the bar chart
+ barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
@@ -518,7 +621,12 @@ func main() {
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
- }).WithHorizontal().WithShowValue().Render()
+ }
+
+ // Create a bar chart with the defined data
+ // The chart is horizontal and displays the value of each bar
+ // The Render() function is called to display the chart
+ pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
```
@@ -541,32 +649,29 @@ import (
)
func main() {
- mixedBars := pterm.Bars{
- pterm.Bar{
- Label: "Bar 1",
- Value: 2,
- },
- pterm.Bar{
- Label: "Bar 2",
- Value: -3,
- },
- pterm.Bar{
- Label: "Bar 3",
- Value: -2,
- },
- pterm.Bar{
- Label: "Bar 4",
- Value: 5,
- },
- pterm.Bar{
- Label: "Longer Label",
- Value: 7,
- },
+ // Define a set of bars for the chart.
+ // Each bar has a label and a value.
+ bars := []pterm.Bar{
+ {Label: "Bar 1", Value: 2},
+ {Label: "Bar 2", Value: -3},
+ {Label: "Bar 3", Value: -2},
+ {Label: "Bar 4", Value: 5},
+ {Label: "Longer Label", Value: 7},
}
+ // Print a section header.
+ // This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
- _ = pterm.DefaultBarChart.WithBars(mixedBars).WithShowValue().Render()
- _ = pterm.DefaultBarChart.WithHorizontal().WithBars(mixedBars).WithShowValue().Render()
+
+ // Create a bar chart with the defined bars.
+ // The chart will display the value of each bar.
+ // The Render() function is called to display the chart.
+ pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
+
+ // Create a horizontal bar chart with the same bars.
+ // The chart will display the value of each bar.
+ // The Render() function is called to display the chart.
+ pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
```
@@ -589,23 +694,25 @@ import (
)
func main() {
+ // Define a set of bars with negative values.
+ // Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
- pterm.Bar{
- Label: "Bar 1",
- Value: -5,
- },
- pterm.Bar{
- Label: "Bar 2",
- Value: -3,
- },
- pterm.Bar{
- Label: "Longer Label",
- Value: -7,
- },
+ {Label: "Bar 1", Value: -5},
+ {Label: "Bar 2", Value: -3},
+ {Label: "Longer Label", Value: -7},
}
+ // Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
+
+ // Create a vertical bar chart with the defined bars.
+ // The WithShowValue() option is used to display the value of each bar in the chart.
+ // The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
+
+ // Create a horizontal bar chart with the same bars.
+ // The WithHorizontal() option is used to orient the chart horizontally.
+ // The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
@@ -627,7 +734,10 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBarChart.WithBars([]pterm.Bar{
+ // Define a slice of bars for the bar chart. Each bar is represented by a struct
+ // with a Label and a Value. The Label is a string that represents the name of the bar,
+ // and the Value is an integer that represents the height of the bar.
+ bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
@@ -637,7 +747,13 @@ func main() {
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
- }).WithShowValue().Render()
+ }
+
+ // Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
+ // Chain the WithBars method to set the bars of the chart.
+ // Chain the WithShowValue method to display the value of each bar on the chart.
+ // Finally, call the Render method to display the chart.
+ pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
```
@@ -658,22 +774,24 @@ package main
import "github.com/pterm/pterm"
func main() {
- // A BasicText printer is used to print text, without special formatting.
- // As it implements the TextPrinter interface, you can use it in combination with other printers.
+ // The DefaultBasicText is a basic text printer provided by PTerm.
+ // It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
+
+ // The DefaultBasicText can be used in any context that requires a TextPrinter.
+ // Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
- pterm.DefaultBasicText.Println("For example to resolve progressbars and spinners.")
- // If you just want to print text, you should use this instead:
- // pterm.Println("Hello, World!")
+
+ // The DefaultBasicText is also useful for resolving progress bars and spinners.
}
```
-### bigtext/colored
+### bigtext/demo
-
+
@@ -688,19 +806,33 @@ import (
)
func main() {
+ // Create a large text with the LetterStyle from the standard theme.
+ // This is useful for creating title screens.
+ pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
+
+ // Create a large text with differently colored letters.
+ // Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
+ // This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
- putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
- Render()
+ putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
+ ).Render()
+
+ // Create a large text with a specific RGB color.
+ // This can be used when you need a specific color that is not available in the standard colors.
+ // Here, the color is gold (RGB: 255, 215, 0).
+ pterm.DefaultBigText.WithLetters(
+ putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
+ ).Render()
}
```
-### bigtext/default
+### bigtext/colored
-
+
@@ -715,16 +847,21 @@ import (
)
func main() {
- pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
+ // Initialize a big text display with the letters "P" and "Term"
+ // "P" is displayed in cyan and "Term" is displayed in light magenta
+ pterm.DefaultBigText.WithLetters(
+ putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
+ putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
+ Render() // Render the big text to the terminal
}
```
-### bigtext/demo
+### bigtext/default
-
+
@@ -739,29 +876,23 @@ import (
)
func main() {
- // Print a large text with the LetterStyle from the standard theme.
- // Useful for title screens.
- pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
+ // Define the text to be rendered
+ var text = "PTerm"
- // Print a large text with differently colored letters.
- pterm.DefaultBigText.WithLetters(
- putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
- putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
- Render()
+ // Convert the text into a format suitable for PTerm
+ var letters = putils.LettersFromString(text)
- // LettersFromStringWithRGB can be used to create a large text with a specific RGB color.
- pterm.DefaultBigText.WithLetters(
- putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0))).
- Render()
+ // Render the text using PTerm's default big text style
+ pterm.DefaultBigText.WithLetters(letters).Render()
}
```
-### box/custom-padding
+### box/demo
-
+
@@ -773,21 +904,35 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBox.
- WithRightPadding(10).
- WithLeftPadding(10).
- WithTopPadding(2).
- WithBottomPadding(2).
- Println("Hello, World!")
+ // Print an informational message.
+ pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
+
+ // Create three panels with text, some of them with titles.
+ // The panels are created using the DefaultBox style.
+ panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
+ panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
+ panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
+
+ // Combine the panels into a layout using the DefaultPanel style.
+ // The layout is a 2D grid, with each row being an array of panels.
+ // In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
+ panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
+ {{Data: panel1}, {Data: panel2}},
+ {{Data: panel3}},
+ }).Srender()
+
+ // Print the panels layout inside a box with a title.
+ // The box is created using the DefaultBox style, with the title positioned at the bottom right.
+ pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
```
-### box/default
+### box/custom-padding
-
+
@@ -799,16 +944,17 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.DefaultBox.Println("Hello, World!")
+ // Create a default box with custom padding options and print "Hello, World!" inside it.
+ pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
```
-### box/demo
+### box/default
-
+
@@ -820,18 +966,9 @@ package main
import "github.com/pterm/pterm"
func main() {
- pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
-
- panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
- panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
- panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
-
- panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
- {{Data: panel1}, {Data: panel2}},
- {{Data: panel3}},
- }).Srender()
-
- pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
+ // Create a default box with PTerm and print a message in it.
+ // The DefaultBox.Println method automatically starts, prints the message, and stops the box.
+ pterm.DefaultBox.Println("Hello, World!")
}
```
@@ -852,19 +989,22 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Default titled bpx
+ // Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
+ // Define a title for the box
title := pterm.LightRed("I'm a box!")
- box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1")
- box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2")
- box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3")
- box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4")
- box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5")
- box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6")
- box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7")
+ // Create boxes with the title positioned differently and containing different content
+ box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
+ box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
+ box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
+ box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
+ box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
+ box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
+ box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
+ // Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
@@ -876,9 +1016,9 @@ func main() {
-### bulletlist/customized
+### bulletlist/demo
-
+
@@ -889,24 +1029,37 @@ package main
import (
"github.com/pterm/pterm"
+ "github.com/pterm/pterm/putils"
)
func main() {
- // Print a customized list with different styles and levels.
- pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
- {Level: 0, Text: "Blue", TextStyle: pterm.NewStyle(pterm.FgBlue), BulletStyle: pterm.NewStyle(pterm.FgRed)},
- {Level: 1, Text: "Green", TextStyle: pterm.NewStyle(pterm.FgGreen), Bullet: "-", BulletStyle: pterm.NewStyle(pterm.FgLightWhite)},
- {Level: 2, Text: "Cyan", TextStyle: pterm.NewStyle(pterm.FgCyan), Bullet: ">", BulletStyle: pterm.NewStyle(pterm.FgYellow)},
- }).Render()
+ // Define a list of bullet list items with different levels.
+ bulletListItems := []pterm.BulletListItem{
+ {Level: 0, Text: "Level 0"}, // Level 0 item
+ {Level: 1, Text: "Level 1"}, // Level 1 item
+ {Level: 2, Text: "Level 2"}, // Level 2 item
+ }
+
+ // Use the default bullet list style to render the list items.
+ pterm.DefaultBulletList.WithItems(bulletListItems).Render()
+
+ // Define a string with different levels of indentation.
+ text := `0
+ 1
+ 2
+ 3`
+
+ // Convert the indented string to a bullet list and render it.
+ putils.BulletListFromString(text, " ").Render()
}
```
-### bulletlist/demo
+### bulletlist/customized
-
+
@@ -917,23 +1070,35 @@ package main
import (
"github.com/pterm/pterm"
- "github.com/pterm/pterm/putils"
)
func main() {
- // Print a list with different levels.
- // Useful to generate lists automatically from data.
- pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
- {Level: 0, Text: "Level 0"},
- {Level: 1, Text: "Level 1"},
- {Level: 2, Text: "Level 2"},
- }).Render()
+ // Define a list of bullet list items with different styles and levels.
+ bulletListItems := []pterm.BulletListItem{
+ {
+ Level: 0, // Level 0 (top level)
+ Text: "Blue", // Text to display
+ TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
+ BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
+ },
+ {
+ Level: 1, // Level 1 (sub-item)
+ Text: "Green", // Text to display
+ TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
+ Bullet: "-", // Custom bullet symbol
+ BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
+ },
+ {
+ Level: 2, // Level 2 (sub-sub-item)
+ Text: "Cyan", // Text to display
+ TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
+ Bullet: ">", // Custom bullet symbol
+ BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
+ },
+ }
- // Convert a text to a list and print it.
- putils.BulletListFromString(`0
- 1
- 2
- 3`, " ").Render()
+ // Create a bullet list with the defined items and render it.
+ pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
```
@@ -951,15 +1116,22 @@ func main() {
```go
package main
-import "github.com/pterm/pterm"
+import (
+ "github.com/pterm/pterm"
+ "github.com/pterm/pterm/putils"
+)
func main() {
- pterm.DefaultCenter.Println("This text is centered!\nIt centeres the whole block by default.\nIn that way you can do stuff like this:")
+ // Print a block of text centered in the terminal
+ pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
+
+ // Generate BigLetters and store in 's'
+ s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
- // Generate BigLetters
- s, _ := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString("PTerm")).Srender()
- pterm.DefaultCenter.Println(s) // Print BigLetters with the default CenterPrinter
+ // Print the BigLetters 's' centered in the terminal
+ pterm.DefaultCenter.Println(s)
+ // Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
@@ -981,8 +1153,7 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print all colors
-
+ // Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
@@ -992,18 +1163,19 @@ func main() {
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
- }).Render()
+ }).Render() // Render the table.
pterm.Println()
- // Print different colored words.
+ // Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
- // Or print colors as a style
+ // Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
+ // Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
@@ -1025,16 +1197,20 @@ package main
import "github.com/pterm/pterm"
func main() {
+ // Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
+ // At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
+ // At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
+ // Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
@@ -1059,16 +1235,26 @@ import (
)
func main() {
- // Print info.
+ // Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
- from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
- to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients end point.
+ // Define the start and end points for the color gradient.
+ startColor := pterm.NewRGB(0, 255, 255) // Cyan
+ endColor := pterm.NewRGB(255, 0, 255) // Magenta
+
+ // Get the terminal height to determine the gradient range.
+ terminalHeight := pterm.GetTerminalHeight()
+
+ // Loop over the range of the terminal height to create a color gradient.
+ for i := 0; i < terminalHeight-2; i++ {
+ // Calculate the fade factor for the current step in the gradient.
+ fadeFactor := float32(i) / float32(terminalHeight-2)
- // For loop over the range of the terminal height.
- for i := 0; i < pterm.GetTerminalHeight()-2; i++ {
- // Print string which is colored with the faded RGB value.
- from.Fade(0, float32(pterm.GetTerminalHeight()-2), float32(i), to).Println("Hello, World!")
+ // Create a color that represents the current step in the gradient.
+ currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
+
+ // Print a string with the current color.
+ currentColor.Println("Hello, World!")
}
}
@@ -1076,9 +1262,9 @@ func main() {
-### coloring/fade-multiple-colors
+### coloring/fade-colors-rgb-style
-
+
@@ -1094,38 +1280,73 @@ import (
)
func main() {
- from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
- to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
- to2 := pterm.NewRGB(255, 0, 0) // This RGB value is used as the gradients second point.
- to3 := pterm.NewRGB(0, 255, 0) // This RGB value is used as the gradients third point.
- to4 := pterm.NewRGB(255, 255, 255) // This RGB value is used as the gradients end point.
+ // Define RGB colors
+ white := pterm.NewRGB(255, 255, 255)
+ grey := pterm.NewRGB(128, 128, 128)
+ black := pterm.NewRGB(0, 0, 0)
+ red := pterm.NewRGB(255, 0, 0)
+ purple := pterm.NewRGB(255, 0, 255)
+ green := pterm.NewRGB(0, 255, 0)
- str := "RGB colors only work in Terminals which support TrueColor."
+ // Define strings to be printed
+ str1 := "RGB colors only work in Terminals which support TrueColor."
+ str2 := "The background and foreground colors can be customized individually."
+ str3 := "Styles can also be applied. For example: Bold or Italic."
+
+ // Print first string with color fading from white to purple
+ printFadedString(str1, white, purple, grey, black)
+
+ // Print second string with color fading from purple to red
+ printFadedString(str2, black, purple, red, red)
+
+ // Print third string with color fading from white to green and style changes
+ printStyledString(str3, white, green, red, black)
+}
+
+// printFadedString prints a string with color fading effect
+func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
- var fadeInfo string // String which will be used to print info.
- // For loop over the range of the string length.
+ var result string
for i := 0; i < len(str); i++ {
- // Append faded letter to info string.
- fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
+ // Create a style with color fading effect
+ style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
+ // Append styled letter to result string
+ result += style.Sprint(strs[i])
}
+ pterm.Println(result)
+}
- // Print info.
- pterm.Info.Println(fadeInfo)
-
- // For loop over the range of the terminal height.
- for i := 0; i < pterm.GetTerminalHeight()-2; i++ {
- // Print string which is colored with the faded RGB value.
- from.Fade(0, float32(pterm.GetTerminalHeight()-2), float32(i), to, to2, to3, to4).Println("Hello, World!")
+// printStyledString prints a string with color fading and style changes
+func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
+ strs := strings.Split(str, "")
+ var result string
+ boldStr := strings.Split("Bold", "")
+ italicStr := strings.Split("Italic", "")
+ bold, italic := 0, 0
+ for i := 0; i < len(str); i++ {
+ // Create a style with color fading effect
+ style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
+ // Check if the next letters are "Bold" or "Italic" and add the corresponding style
+ if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
+ style = style.AddOptions(pterm.Bold)
+ bold++
+ } else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
+ style = style.AddOptions(pterm.Italic)
+ italic++
+ }
+ // Append styled letter to result string
+ result += style.Sprint(strs[i])
}
+ pterm.Println(result)
}
```
-### coloring/override-default-printers
+### coloring/fade-multiple-colors
-
+
@@ -1134,27 +1355,79 @@ func main() {
```go
package main
-import "github.com/pterm/pterm"
+import (
+ "strings"
+
+ "github.com/pterm/pterm"
+)
func main() {
- // Print default error.
- pterm.Error.Println("This is the default Error")
+ // Define RGB values for gradient points.
+ startColor := pterm.NewRGB(0, 255, 255)
+ firstPoint := pterm.NewRGB(255, 0, 255)
+ secondPoint := pterm.NewRGB(255, 0, 0)
+ thirdPoint := pterm.NewRGB(0, 255, 0)
+ endColor := pterm.NewRGB(255, 255, 255)
+
+ // Define the string to be printed.
+ str := "RGB colors only work in Terminals which support TrueColor."
+ strs := strings.Split(str, "")
- // Customize default error.
- pterm.Error.Prefix = pterm.Prefix{
- Text: "OVERRIDE",
- Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed),
+ // Initialize an empty string for the faded info.
+ var fadeInfo string
+
+ // Loop over the string length to create a gradient effect.
+ for i := 0; i < len(str); i++ {
+ // Append each character of the string with a faded color to the info string.
+ fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
- // Print new default error.
- pterm.Error.Println("This is the default Error after the prefix was overridden")
+ // Print the info string with gradient effect.
+ pterm.Info.Println(fadeInfo)
+
+ // Get the terminal height.
+ terminalHeight := pterm.GetTerminalHeight()
+
+ // Loop over the terminal height to print "Hello, World!" with a gradient effect.
+ for i := 0; i < terminalHeight-2; i++ {
+ // Print the string with a color that fades from startColor to endColor.
+ startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
+ }
}
```
-### coloring/print-color-rgb
+### coloring/override-default-printers
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import "github.com/pterm/pterm"
+
+func main() {
+ // Print a default error message with PTerm's built-in Error style.
+ pterm.Error.Println("This is the default Error")
+
+ // Override the default error prefix with a new text and style.
+ pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
+
+ // Print the error message again, this time with the overridden prefix.
+ pterm.Error.Println("This is the default Error after the prefix was overridden")
+}
+
+```
+
+
+
+### coloring/print-color-rgb
@@ -1168,10 +1441,17 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print strings with a custom RGB color.
- // NOTICE: This only works with terminals which support TrueColor.
+ // Create a new RGB color with values 178, 44, 199.
+ // This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
+
+ // Create a new RGB color with values 15, 199, 209.
+ // This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
+
+ // Create a new RGB color with values 201, 144, 30.
+ // This color will be used for the background.
+ // The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
@@ -1179,6 +1459,43 @@ func main() {
+### coloring/print-color-rgb-style
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Define RGB colors for foreground and background.
+ foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
+ backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
+
+ // Create a new RGB style with the defined foreground and background colors.
+ rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
+
+ // Print a string with the custom RGB style.
+ rgbStyle.Println("This text is not styled.")
+
+ // Add the 'Bold' option to the RGB style and print a string with this style.
+ rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
+
+ // Add the 'Italic' option to the RGB style and print a string with this style.
+ rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
+}
+
+```
+
+
+
### demo/demo
@@ -1321,7 +1638,7 @@ func main() {
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
- showcase("Fully Customizale", 2, func() {
+ showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
@@ -1461,9 +1778,9 @@ func randomInt(min, max int) int {
-### header/custom
+### header/demo
-
+
@@ -1475,35 +1792,25 @@ package main
import "github.com/pterm/pterm"
func main() {
- // All available options: https://pkg.go.dev/github.com/pterm/pterm#HeaderPrinter
-
- // Build on top of DefaultHeader
- pterm.DefaultHeader. // Use DefaultHeader as base
- WithMargin(15).
- WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).
- WithTextStyle(pterm.NewStyle(pterm.FgBlack)).
- Println("This is a custom header!")
- // Instead of printing the header you can set it to a variable.
- // You can then reuse your custom header.
+ // Print a default header.
+ // This uses the default settings of PTerm to print a header.
+ pterm.DefaultHeader.Println("This is the default header!")
- // Making a completely new HeaderPrinter
- newHeader := pterm.HeaderPrinter{
- TextStyle: pterm.NewStyle(pterm.FgBlack),
- BackgroundStyle: pterm.NewStyle(pterm.BgRed),
- Margin: 20,
- }
+ // Print a spacer line for better readability.
+ pterm.Println()
- // Print header.
- newHeader.Println("This is a custom header!")
+ // Print a full-width header.
+ // This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
+ pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
```
-### header/demo
+### header/custom
-
+
@@ -1515,19 +1822,27 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print a default header.
- pterm.DefaultHeader.Println("This is the default header!")
- pterm.Println() // spacer
- pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
+ // Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
+ pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
+
+ // Define a new HeaderPrinter with a red background, black text, and a margin of 20.
+ newHeader := pterm.HeaderPrinter{
+ TextStyle: pterm.NewStyle(pterm.FgBlack),
+ BackgroundStyle: pterm.NewStyle(pterm.BgRed),
+ Margin: 20,
+ }
+
+ // Print the custom header using the new HeaderPrinter.
+ newHeader.Println("This is a custom header!")
}
```
-### interactive_confirm/demo
+### heatmap/demo
-
+
@@ -1541,25 +1856,33 @@ import (
)
func main() {
- result, _ := pterm.DefaultInteractiveConfirm.Show()
- pterm.Println() // Blank line
- pterm.Info.Printfln("You answered: %s", boolToText(result))
-}
+ // Define the data for the heatmap. Each sub-array represents a row in the heatmap.
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
+ }
-func boolToText(b bool) string {
- if b {
- return pterm.Green("Yes")
+ // Define the labels for the X and Y axes of the heatmap.
+ headerData := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
}
- return pterm.Red("No")
+
+ // Create a heatmap with the defined data and axis labels, and enable RGB colors.
+ // Then render the heatmap.
+ pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
```
-### interactive_continue/demo
+### heatmap/custom_colors
-
+
@@ -1573,18 +1896,43 @@ import (
)
func main() {
- result, _ := pterm.DefaultInteractiveContinue.Show()
- pterm.Println() // Blank line
- pterm.Info.Printfln("You answered: %s", result)
+ // Define the data for the heatmap
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
+ }
+
+ // Define the axis labels for the heatmap
+ headerData := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
+ }
+
+ // Print an informational message
+ pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
+ pterm.Println()
+
+ // Create the heatmap with the defined data and options, and render it
+ pterm.DefaultHeatmap.
+ WithData(data).
+ WithBoxed(false).
+ WithAxisData(headerData).
+ WithLegend(false).
+ WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
+ WithLegend().
+ Render()
}
```
-### interactive_multiselect/custom-checkmarks
+### heatmap/custom_legend
-
+
@@ -1594,36 +1942,48 @@ func main() {
package main
import (
- "fmt"
-
- "atomicgo.dev/keyboard/keys"
-
"github.com/pterm/pterm"
)
func main() {
- var options []string
+ // Define the data for the heatmap
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
+ }
- for i := 0; i < 5; i++ {
- options = append(options, fmt.Sprintf("Option %d", i))
+ // Define the header data for the heatmap
+ headerData := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
}
- printer := pterm.DefaultInteractiveMultiselect.WithOptions(options)
- printer.Filter = false
- printer.KeyConfirm = keys.Enter
- printer.KeySelect = keys.Space
- printer.Checkmark = &pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")}
- selectedOptions, _ := printer.Show()
- pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
+ // Print an informational message
+ pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
+ pterm.Println()
+
+ // Create the heatmap with the defined data and options
+ // Options are chained in a single line for simplicity
+ pterm.DefaultHeatmap.
+ WithData(data).
+ WithBoxed(false).
+ WithAxisData(headerData).
+ WithEnableRGB().
+ WithLegendLabel("custom").
+ WithLegendOnlyColoredCells().
+ Render() // Render the heatmap
}
```
-### interactive_multiselect/custom-keys
+### heatmap/custom_rgb
-
+
@@ -1633,34 +1993,54 @@ func main() {
package main
import (
- "fmt"
-
- "atomicgo.dev/keyboard/keys"
"github.com/pterm/pterm"
)
func main() {
- var options []string
+ // Define the data for the heatmap.
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
+ }
- for i := 0; i < 5; i++ {
- options = append(options, fmt.Sprintf("Option %d", i))
+ // Define the axis labels for the heatmap.
+ axisLabels := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
}
- printer := pterm.DefaultInteractiveMultiselect.WithOptions(options)
- printer.Filter = false
- printer.KeyConfirm = keys.Enter
- printer.KeySelect = keys.Space
- selectedOptions, _ := printer.Show()
- pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
+ // Print an informational message.
+ pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
+ pterm.Println()
+
+ // Define the color range for the heatmap.
+ rgbRange := []pterm.RGB{
+ pterm.NewRGB(0, 0, 255),
+ pterm.NewRGB(255, 0, 0),
+ pterm.NewRGB(0, 255, 0),
+ pterm.NewRGB(255, 255, 0),
+ }
+
+ // Create and render the heatmap.
+ pterm.DefaultHeatmap.
+ WithData(data).
+ WithBoxed(false).
+ WithAxisData(axisLabels).
+ WithEnableRGB().
+ WithRGBRange(rgbRange...).
+ Render()
}
```
-### interactive_multiselect/demo
+### heatmap/no_grid
-
+
@@ -1670,33 +2050,40 @@ func main() {
package main
import (
- "fmt"
-
"github.com/pterm/pterm"
)
func main() {
- var options []string
-
- for i := 0; i < 100; i++ {
- options = append(options, fmt.Sprintf("Option %d", i))
+ // Define the data for the heatmap.
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
- for i := 0; i < 5; i++ {
- options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
+ // Define the axis data for the heatmap.
+ axisData := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
}
- selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
- pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
+ // Print an informational message.
+ pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
+ pterm.Println()
+
+ // Create the heatmap with the defined data and options, then render it.
+ pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
```
-### interactive_select/demo
+### heatmap/separated
-
+
@@ -1705,34 +2092,39 @@ func main() {
```go
package main
-import (
- "fmt"
-
- "github.com/pterm/pterm"
-)
+import "github.com/pterm/pterm"
func main() {
- var options []string
-
- for i := 0; i < 100; i++ {
- options = append(options, fmt.Sprintf("Option %d", i))
+ // Define the data for the heatmap.
+ data := [][]float32{
+ {0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
+ {0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
+ {0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
+ {0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
+ {0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
- for i := 0; i < 5; i++ {
- options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
+ // Define the axis labels for the heatmap.
+ headerData := pterm.HeatmapAxis{
+ XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
+ YAxis: []string{"1", "2", "3", "4", "5"},
}
- selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
- pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
+ // Print an informational message.
+ pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
+ pterm.Println()
+
+ // Create the heatmap with the specified data and options, and render it.
+ pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
```
-### interactive_textinput/demo
+### interactive_confirm/demo
-
+
@@ -1746,18 +2138,33 @@ import (
)
func main() {
- result, _ := pterm.DefaultInteractiveTextInput.WithMultiLine(false).Show()
- pterm.Println() // Blank line
- pterm.Info.Printfln("You answered: %s", result)
+ // Show an interactive confirmation dialog and get the result.
+ result, _ := pterm.DefaultInteractiveConfirm.Show()
+
+ // Print a blank line for better readability.
+ pterm.Println()
+
+ // Print the user's answer in a formatted way.
+ pterm.Info.Printfln("You answered: %s", boolToText(result))
+}
+
+// boolToText converts a boolean value to a colored text.
+// If the value is true, it returns a green "Yes".
+// If the value is false, it returns a red "No".
+func boolToText(b bool) string {
+ if b {
+ return pterm.Green("Yes")
+ }
+ return pterm.Red("No")
}
```
-### interactive_textinput/multi-line
+### interactive_continue/demo
-
+
@@ -1771,8 +2178,21 @@ import (
)
func main() {
- result, _ := pterm.DefaultInteractiveTextInput.WithMultiLine().Show() // Text input with multi line enabled
- pterm.Println() // Blank line
+ // Create an interactive continue prompt with default settings
+ // This will pause the program execution until the user presses enter
+ // The message displayed is "Press 'Enter' to continue..."
+ prompt := pterm.DefaultInteractiveContinue
+
+ // Show the prompt and wait for user input
+ // The returned result is the user's input (should be empty as it's a continue prompt)
+ // The second return value is an error which is ignored here
+ result, _ := prompt.Show()
+
+ // Print a blank line for better readability
+ pterm.Println()
+
+ // Print the user's input with an info prefix
+ // As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
@@ -1780,9 +2200,9 @@ func main() {
-### logger/custom-key-styles
+### interactive_multiselect/demo
-
+
@@ -1791,33 +2211,40 @@ func main() {
```go
package main
-import "github.com/pterm/pterm"
+import (
+ "fmt"
+ "github.com/pterm/pterm"
+)
func main() {
- logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace) // Only show logs with a level of Trace or higher.
+ // Initialize an empty slice to hold the options.
+ var options []string
- // Overwrite all key styles with a new map
- logger = logger.WithKeyStyles(map[string]pterm.Style{
- "priority": *pterm.NewStyle(pterm.FgRed),
- })
+ // Populate the options slice with 100 options.
+ for i := 0; i < 100; i++ {
+ options = append(options, fmt.Sprintf("Option %d", i))
+ }
- // The priority key should now be red
- logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
+ // Add 5 more options to the slice, indicating the availability of fuzzy searching.
+ for i := 0; i < 5; i++ {
+ options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
+ }
- // Append a key style to the exisiting ones
- logger.AppendKeyStyle("foo", *pterm.NewStyle(pterm.FgBlue))
+ // Use PTerm's interactive multiselect to present the options to the user and capture their selections.
+ // The Show() method displays the options and waits for user input.
+ selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
- // The foo key should now be blue
- logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
+ // Print the selected options, highlighted in green.
+ pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
-### logger/default
+### interactive_multiselect/custom-checkmarks
-
+
@@ -1827,38 +2254,40 @@ func main() {
package main
import (
+ "fmt"
"github.com/pterm/pterm"
- "time"
)
func main() {
- logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace) // Only show logs with a level of Trace or higher.
-
- logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
+ // Initialize an empty slice to hold the options
+ var options []string
- // You can also use the `ArgsFromMap` function to create a `Args` object from a map.
- interstingStuff := map[string]any{
- "when were crayons invented": "1903",
- "what is the meaning of life": 42,
- "is this interesting": true,
+ // Populate the options slice with 5 options
+ for i := 0; i < 5; i++ {
+ options = append(options, fmt.Sprintf("Option %d", i))
}
- logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
- logger.Info("That was actually interesting", logger.Args("such", "wow"))
- logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
- logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
- logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
- time.Sleep(time.Second * 2)
- logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
+ // Create a new interactive multiselect printer with the options
+ // Disable the filter and define the checkmark symbols
+ printer := pterm.DefaultInteractiveMultiselect.
+ WithOptions(options).
+ WithFilter(false).
+ WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
+
+ // Show the interactive multiselect and get the selected options
+ selectedOptions, _ := printer.Show()
+
+ // Print the selected options
+ pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
-### logger/demo
+### interactive_multiselect/custom-keys
-
+
@@ -1868,37 +2297,250 @@ func main() {
package main
import (
+ "atomicgo.dev/keyboard/keys"
+ "fmt"
"github.com/pterm/pterm"
- "time"
)
func main() {
- logger := pterm.DefaultLogger.
- WithLevel(pterm.LogLevelTrace)
+ // Initialize an empty slice to hold the options
+ var options []string
- logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
+ // Populate the options slice with 5 options
+ for i := 0; i < 5; i++ {
+ options = append(options, fmt.Sprintf("Option %d", i))
+ }
- sleep()
+ // Create a new interactive multiselect printer with the options
+ // Disable the filter and set the keys for confirming and selecting options
+ printer := pterm.DefaultInteractiveMultiselect.
+ WithOptions(options).
+ WithFilter(false).
+ WithKeyConfirm(keys.Enter).
+ WithKeySelect(keys.Space)
- interstingStuff := map[string]any{
- "when were crayons invented": "1903",
- "what is the meaning of life": 42,
+ // Show the interactive multiselect and get the selected options
+ selectedOptions, _ := printer.Show()
+
+ // Print the selected options
+ pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
+}
+
+```
+
+
+
+### interactive_select/demo
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "fmt"
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Initialize an empty slice to hold the options
+ var options []string
+
+ // Generate 100 options and add them to the options slice
+ for i := 0; i < 100; i++ {
+ options = append(options, fmt.Sprintf("Option %d", i))
+ }
+
+ // Generate 5 additional options with a specific message and add them to the options slice
+ for i := 0; i < 5; i++ {
+ options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
+ }
+
+ // Use PTerm's interactive select feature to present the options to the user and capture their selection
+ // The Show() method displays the options and waits for the user's input
+ selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
+
+ // Display the selected option to the user with a green color for emphasis
+ pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
+}
+
+```
+
+
+
+### interactive_textinput/demo
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create an interactive text input with single line input mode
+ textInput := pterm.DefaultInteractiveTextInput.WithMultiLine(false)
+
+ // Show the text input and get the result
+ result, _ := textInput.Show()
+
+ // Print a blank line for better readability
+ pterm.Println()
+
+ // Print the user's answer with an info prefix
+ pterm.Info.Printfln("You answered: %s", result)
+}
+
+```
+
+
+
+### interactive_textinput/multi-line
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create a default interactive text input with multi-line enabled.
+ // This allows the user to input multiple lines of text.
+ textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
+
+ // Show the text input to the user and store the result.
+ // The second return value (an error) is ignored with '_'.
+ result, _ := textInput.Show()
+
+ // Print a blank line for better readability in the output.
+ pterm.Println()
+
+ // Print the user's input prefixed with an informational message.
+ // The '%s' placeholder is replaced with the user's input.
+ pterm.Info.Printfln("You answered: %s", result)
+}
+
+```
+
+
+
+### interactive_textinput/password
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import "github.com/pterm/pterm"
+
+func main() {
+ // Create an interactive text input with a mask for password input
+ passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
+
+ // Show the password input prompt and store the result
+ result, _ := passwordInput.Show("Enter your password")
+
+ // Get the default logger from PTerm
+ logger := pterm.DefaultLogger
+
+ // Log the received password (masked)
+ // Note: In a real-world application, you should never log passwords
+ logger.Info("Password received", logger.Args("password", result))
+}
+
+```
+
+
+
+### logger/demo
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "github.com/pterm/pterm"
+ "time"
+)
+
+func main() {
+ // Create a logger with trace level
+ logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
+
+ // Log a trace level message
+ logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
+
+ // Pause for 3 seconds
+ sleep()
+
+ // Define a map with interesting stuff
+ interstingStuff := map[string]any{
+ "when were crayons invented": "1903",
+ "what is the meaning of life": 42,
"is this interesting": true,
}
+
+ // Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
+
+ // Pause for 3 seconds
sleep()
+ // Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
+
+ // Pause for 3 seconds
sleep()
+
+ // Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
+
+ // Pause for 3 seconds
sleep()
+
+ // Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
+
+ // Pause for 3 seconds
sleep()
+
+ // Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
+
+ // Pause for 3 seconds
sleep()
+
+ // Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
+// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
@@ -1907,9 +2549,9 @@ func sleep() {
-### logger/json
+### logger/custom-key-styles
-
+
@@ -1921,20 +2563,121 @@ package main
import "github.com/pterm/pterm"
func main() {
- logger := pterm.DefaultLogger.
- WithLevel(pterm.LogLevelTrace). // Only show logs with a level of Trace or higher.
- WithFormatter(pterm.LogFormatterJSON) // ! Make the logger print JSON logs.
+ // Create a logger with a level of Trace or higher.
+ logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
+
+ // Define a new style for the "priority" key.
+ priorityStyle := map[string]pterm.Style{
+ "priority": *pterm.NewStyle(pterm.FgRed),
+ }
+
+ // Overwrite all key styles with the new map.
+ logger = logger.WithKeyStyles(priorityStyle)
+
+ // Log an info message. The "priority" key will be displayed in red.
+ logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
+
+ // Define a new style for the "foo" key.
+ fooStyle := *pterm.NewStyle(pterm.FgBlue)
+
+ // Append the new style to the existing ones.
+ logger.AppendKeyStyle("foo", fooStyle)
+ // Log another info message. The "foo" key will be displayed in blue.
+ logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
+}
+
+```
+
+
+
+### logger/default
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "github.com/pterm/pterm"
+ "time"
+)
+
+func main() {
+ // Create a logger with a level of Trace or higher.
+ logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
+
+ // Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
- // You can also use the `ArgsFromMap` function to create a `Args` object from a map.
+ // Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
+
+ // Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
+ // Log an info message with additional arguments.
+ logger.Info("That was actually interesting", logger.Args("such", "wow"))
+
+ // Log a warning message with additional arguments.
+ logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
+
+ // Log an error message with additional arguments.
+ logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
+
+ // Log an info message with additional arguments. PTerm will automatically wrap long logs.
+ logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
+
+ // Pause for 2 seconds.
+ time.Sleep(time.Second * 2)
+
+ // Log a fatal message with additional arguments. This will terminate the process.
+ logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
+}
+
+```
+
+
+
+### logger/json
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import "github.com/pterm/pterm"
+
+func main() {
+ // Create a logger with Trace level and JSON formatter
+ logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
+
+ // Log a Trace level message with additional arguments
+ logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
+
+ // Create a map of interesting stuff
+ interestingStuff := map[string]any{
+ "when were crayons invented": "1903",
+ "what is the meaning of life": 42,
+ "is this interesting": true,
+ }
+
+ // Log a Debug level message with arguments from the map
+ logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
+
+ // Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
@@ -1960,24 +2703,35 @@ package main
import "github.com/pterm/pterm"
func main() {
- logger := pterm.DefaultLogger.
- WithLevel(pterm.LogLevelTrace). // Only show logs with a level of Trace or higher.
- WithCaller() // ! Show the caller of the log function.
+ // Create a logger with Trace level and caller information
+ logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
+ // Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
- // You can also use the `ArgsFromMap` function to create a `Args` object from a map.
- interstingStuff := map[string]any{
+ // Create a map of interesting stuff
+ interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
- logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
+ // Log a debug message with arguments from a map
+ logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
+
+ // Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
+
+ // Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
+
+ // Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
+
+ // Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
+
+ // Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
@@ -1985,6 +2739,80 @@ func main() {
+### multiple-live-printers/demo
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "time"
+
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create a multi printer for managing multiple printers
+ multi := pterm.DefaultMultiPrinter
+
+ // Create two spinners with their own writers
+ spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
+ spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
+
+ // Create five progress bars with their own writers and a total of 100
+ pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
+ pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
+ pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
+ pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
+ pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
+
+ // Start the multi printer
+ multi.Start()
+
+ // Increment progress bars and spinners based on certain conditions
+ for i := 1; i <= 100; i++ {
+ pb1.Increment() // Increment progress bar 1 every iteration
+
+ if i%2 == 0 {
+ pb2.Add(3) // Add 3 to progress bar 2 every even iteration
+ }
+
+ if i%5 == 0 {
+ pb3.Increment() // Increment progress bar 3 every 5th iteration
+ }
+
+ if i%10 == 0 {
+ pb4.Increment() // Increment progress bar 4 every 10th iteration
+ }
+
+ if i%3 == 0 {
+ pb5.Increment() // Increment progress bar 5 every 3rd iteration
+ }
+
+ if i%50 == 0 {
+ spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
+ }
+
+ if i%60 == 0 {
+ spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
+ }
+
+ time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
+ }
+
+ // Stop the multi printer
+ multi.Stop()
+}
+
+```
+
+
+
### panel/demo
@@ -1999,13 +2827,20 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Declare panels in a two dimensional grid system.
+ // Define panels in a 2D grid system
panels := pterm.Panels{
- {{Data: "This is the first panel"}, {Data: pterm.DefaultHeader.Sprint("Hello, World!")}, {Data: "This\npanel\ncontains\nmultiple\nlines"}},
- {{Data: pterm.Red("This is another\npanel line")}, {Data: "This is the second panel\nwith a new line"}},
+ {
+ {Data: "This is the first panel"},
+ {Data: pterm.DefaultHeader.Sprint("Hello, World!")},
+ {Data: "This\npanel\ncontains\nmultiple\nlines"},
+ },
+ {
+ {Data: pterm.Red("This is another\npanel line")},
+ {Data: "This is the second panel\nwith a new line"},
+ },
}
- // Print panels.
+ // Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
@@ -2013,9 +2848,9 @@ func main() {
-### paragraph/customized
+### paragraph/demo
-
+
@@ -2027,15 +2862,18 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print a paragraph with a custom maximal width.
- pterm.DefaultParagraph.WithMaxWidth(60).Println("This is a custom paragraph printer. As you can see, no words are separated, " +
+ // Using the default paragraph printer to print a long text.
+ // The text is split at the spaces, which is useful for continuous text of all kinds.
+ // The line width can be manually adjusted if needed.
+ pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
- // Print one line space.
+ // Printing a line space for separation.
pterm.Println()
- // Print text without a paragraph printer.
+ // Printing a long text without using the paragraph printer.
+ // The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
@@ -2044,9 +2882,9 @@ func main() {
-### paragraph/demo
+### paragraph/customized
-
+
@@ -2058,17 +2896,23 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print long text with default paragraph printer.
- pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
+ // Define a long text to be printed as a paragraph.
+ longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
+ "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
- // Print one line space.
+ // Print the long text as a paragraph with a custom maximal width of 60 characters.
+ pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
+
+ // Print a line space to separate the paragraph from the following text.
pterm.Println()
- // Print long text without paragraph printer.
- pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
+ // Define another long text to be printed without a paragraph printer.
+ longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
+ "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
+
+ // Print the long text without using a paragraph printer.
+ pterm.Println(longTextWithoutParagraph)
}
```
@@ -2089,17 +2933,31 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Enable debug messages.
+ // Enable debug messages in PTerm.
pterm.EnableDebugMessages()
- pterm.Debug.Println("Hello, World!") // Print Debug.
- pterm.Info.Println("Hello, World!") // Print Info.
- pterm.Success.Println("Hello, World!") // Print Success.
- pterm.Warning.Println("Hello, World!") // Print Warning.
- pterm.Error.Println("Errors show the filename and linenumber inside the terminal!") // Print Error.
- pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!") // Print Error.
+ // Print a debug message with PTerm.
+ pterm.Debug.Println("Hello, World!")
+
+ // Print an informational message with PTerm.
+ pterm.Info.Println("Hello, World!")
+
+ // Print a success message with PTerm.
+ pterm.Success.Println("Hello, World!")
+
+ // Print a warning message with PTerm.
+ pterm.Warning.Println("Hello, World!")
+
+ // Print an error message with PTerm. This will also display the filename and line number in the terminal.
+ pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
+
+ // Print an informational message with PTerm, with line number.
+ // This demonstrates that other PrefixPrinters can also display line numbers.
+ pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
+
// Temporarily set Fatal to false, so that the CI won't crash.
- pterm.Fatal.WithFatal(false).Println("Hello, World!") // Print Fatal.
+ // This will print a fatal message with PTerm, but won't terminate the program.
+ pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
```
@@ -2124,20 +2982,96 @@ import (
"github.com/pterm/pterm"
)
-// Slice of strings with placeholder text.
+// Slice of strings representing names of pseudo applications to be downloaded.
var fakeInstallList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
- // Create progressbar as fork from the default progressbar.
+ // Create a progressbar with the total steps equal to the number of items in fakeInstallList.
+ // Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
+ // Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
- p.UpdateTitle("Downloading " + fakeInstallList[i]) // Update the title of the progressbar.
- pterm.Success.Println("Downloading " + fakeInstallList[i]) // If a progressbar is running, each print will be printed above the progressbar.
- p.Increment() // Increment the progressbar by one. Use Add(x int) to increment by a custom amount.
- time.Sleep(time.Millisecond * 350) // Sleep 350 milliseconds.
+ // Simulate a slow download for the 7th item.
+ if i == 6 {
+ time.Sleep(time.Second * 3)
+ }
+
+ // Update the title of the progressbar with the current item being downloaded.
+ p.UpdateTitle("Downloading " + fakeInstallList[i])
+
+ // Print a success message for the current download. This will be printed above the progressbar.
+ pterm.Success.Println("Downloading " + fakeInstallList[i])
+
+ // Increment the progressbar by one to indicate progress.
+ p.Increment()
+
+ // Pause for 350 milliseconds to simulate the time taken for each download.
+ time.Sleep(time.Millisecond * 350)
+ }
+}
+
+```
+
+
+
+### progressbar/multiple
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "time"
+
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create a multi printer instance from the default one
+ multi := pterm.DefaultMultiPrinter
+
+ // Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
+ pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
+ pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
+ pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
+ pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
+ pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
+
+ // Start the multi printer
+ multi.Start()
+
+ // Loop to increment progress bars based on certain conditions
+ for i := 1; i <= 100; i++ {
+ pb1.Increment() // Increment the first progress bar at each iteration
+
+ if i%2 == 0 {
+ pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
+ }
+
+ if i%5 == 0 {
+ pb3.Increment() // Increment the third progress bar at every fifth iteration
+ }
+
+ if i%10 == 0 {
+ pb4.Increment() // Increment the fourth progress bar at every tenth iteration
+ }
+
+ if i%3 == 0 {
+ pb5.Increment() // Increment the fifth progress bar at every third iteration
+ }
+
+ time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
+
+ // Stop the multi printer
+ multi.Stop()
}
```
@@ -2158,14 +3092,16 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Print a section with level one.
+ // Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
- // Print placeholder.
+
+ // Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
- // Print a section with level two.
+ // Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
- // Print placeholder.
+
+ // Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
@@ -2173,6 +3109,53 @@ func main() {
+### slog/demo
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "log/slog"
+
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create a new slog handler with the default PTerm logger
+ handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
+
+ // Create a new slog logger with the handler
+ logger := slog.New(handler)
+
+ // Log a debug message (won't show by default)
+ logger.Debug("This is a debug message that won't show")
+
+ // Change the log level to debug to enable debug messages
+ pterm.DefaultLogger.Level = pterm.LogLevelDebug
+
+ // Log a debug message (will show because debug level is enabled)
+ logger.Debug("This is a debug message", "changedLevel", true)
+
+ // Log an info message
+ logger.Info("This is an info message")
+
+ // Log a warning message
+ logger.Warn("This is a warning message")
+
+ // Log an error message
+ logger.Error("This is an error message")
+}
+
+```
+
+
+
### spinner/demo
@@ -2238,6 +3221,68 @@ func main() {
+### spinner/multiple
+
+
+
+
+
+SHOW SOURCE
+
+```go
+package main
+
+import (
+ "time"
+
+ "github.com/pterm/pterm"
+)
+
+func main() {
+ // Create a multi printer. This allows multiple spinners to print simultaneously.
+ multi := pterm.DefaultMultiPrinter
+
+ // Create and start spinner 1 with a new writer from the multi printer.
+ // The spinner will display the message "Spinner 1".
+ spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
+
+ // Create and start spinner 2 with a new writer from the multi printer.
+ // The spinner will display the message "Spinner 2".
+ spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
+
+ // Create and start spinner 3 with a new writer from the multi printer.
+ // The spinner will display the message "Spinner 3".
+ spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
+
+ // Start the multi printer. This will start printing all the spinners.
+ multi.Start()
+
+ // Wait for 1 second.
+ time.Sleep(time.Millisecond * 1000)
+
+ // Stop spinner 1 with a success message.
+ spinner1.Success("Spinner 1 is done!")
+
+ // Wait for 750 milliseconds.
+ time.Sleep(time.Millisecond * 750)
+
+ // Stop spinner 2 with a failure message.
+ spinner2.Fail("Spinner 2 failed!")
+
+ // Wait for 500 milliseconds.
+ time.Sleep(time.Millisecond * 500)
+
+ // Stop spinner 3 with a warning message.
+ spinner3.Warning("Spinner 3 has a warning!")
+
+ // Stop the multi printer. This will stop printing all the spinners.
+ multi.Stop()
+}
+
+```
+
+
+
### style/demo
@@ -2252,12 +3297,16 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Create styles as new variables
+ // Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
+
+ // Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
- // Use created styles
+ // Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
+
+ // Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
@@ -2265,9 +3314,9 @@ func main() {
-### table/boxed
+### table/demo
-
+
@@ -2279,23 +3328,40 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Create a fork of the default table, fill it with data and print it.
- // Data can also be generated and inserted later.
- pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(pterm.TableData{
+ // Define the data for the first table
+ tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
- {"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk", ""},
- {"Callie", "Mckay", "egestas.nunc.sed@est.com", "这是一个测试, haha!"},
- {"Libby", "Camacho", "aliquet.lobortis@semper.com", "just a test, hey!"},
- }).Render()
+ {"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
+ {"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
+ {"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
+ {"张", "小宝", "zhang@example.com", ""},
+ }
+
+ // Create a table with a header and the defined data, then render it
+ pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
+
+ pterm.Println() // Blank line
+
+ // Define the data for the second table
+ tableData2 := pterm.TableData{
+ {"Firstname", "Lastname", "Email"},
+ {"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
+ {"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
+ {"Libby", "Camacho", "lobortis@semper.com"},
+ {"张", "小宝", "zhang@example.com"},
+ }
+
+ // Create another table with a header and the defined data, then render it
+ pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
```
-### table/demo
+### table/boxed
-
+
@@ -2307,25 +3373,21 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Create a fork of the default table, fill it with data and print it.
- // Data can also be generated and inserted later.
- pterm.DefaultTable.WithHasHeader().WithData(pterm.TableData{
+ // Define the data for the table.
+ // Each inner slice represents a row in the table.
+ // The first row is considered as the header of the table.
+ tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
- {"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk", ""},
- {"Callie", "Mckay", "egestas.nunc.sed@est.com", "这是一个测试, haha!"},
- {"Libby", "Camacho", "aliquet.lobortis@semper.com", "just a test, hey!"},
- }).Render()
-
- pterm.Println() // Blank line
+ {"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
+ {"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
+ {"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
+ {"张", "小宝", "zhang@example.com", ""},
+ }
- // Create a table with multiple lines in a row.
- pterm.DefaultTable.WithHasHeader().WithData(pterm.TableData{
- {"Firstname", "Lastname", "Email"},
- {"Paul\n\nNewline", "Dean", "nisi.dictum.augue@velitAliquam.co.uk"},
- {"Callie", "Mckay", "egestas.nunc.sed@est.com\nNewline"},
- {"Libby", "Camacho", "aliquet.lobortis@semper.com"},
- {"张", "小宝", "zhang@example.com"},
- }).Render()
+ // Create a table with the defined data.
+ // The table has a header and is boxed.
+ // Finally, render the table to print it.
+ pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
```
@@ -2346,14 +3408,19 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Create a table with multiple lines in a row and set a row separator.
- pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(pterm.TableData{
+ // Define the data for the table.
+ data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
- {"Paul\n\nNewline", "Dean", "nisi.dictum.augue@velitAliquam.co.uk"},
- {"Callie", "Mckay", "egestas.nunc.sed@est.com\nNewline"},
- {"Libby", "Camacho", "aliquet.lobortis@semper.com"},
+ {"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
+ {"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
+ {"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
- }).Render()
+ }
+
+ // Create and render the table.
+ // The options are chained in a single line for simplicity.
+ // The table has a header, a row separator, and a header row separator.
+ pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
```
@@ -2374,14 +3441,21 @@ package main
import "github.com/pterm/pterm"
func main() {
- // Create a fork of the default table, fill it with data and print it.
- // Data can also be generated and inserted later.
- pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(pterm.TableData{
+ // Define the data for the table.
+ // Each inner slice represents a row in the table.
+ // The first row is considered as the header.
+ tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
- {"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk", ""},
- {"Callie", "Mckay", "egestas.nunc.sed@est.com", "这是一个测试, haha!"},
- {"Libby", "Camacho", "aliquet.lobortis@semper.com", "just a test, hey!"},
- }).Render()
+ {"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
+ {"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
+ {"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
+ {"张", "小宝", "zhang@example.com", ""},
+ }
+
+ // Create a table with the defined data.
+ // The table has a header and the text in the cells is right-aligned.
+ // The Render() method is used to print the table to the console.
+ pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
```
@@ -2406,23 +3480,27 @@ import (
)
func main() {
- // Print info.
- pterm.Info.Println("These are the default theme styles.\n" +
- "You can modify them easily to your personal preference,\n" +
- "or create new themes from scratch :)")
+ // Print an informational message about the default theme styles.
+ pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
- pterm.Println() // Print one line space.
+ // Print a blank line for better readability.
+ pterm.Println()
- // Print every value of the default theme with its own style.
+ // Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
+ // Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
+ // Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
+ // Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
+ // Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
+ // Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
@@ -2448,11 +3526,17 @@ import (
)
func main() {
+ // Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
+ // The top node of the tree
Text: "Top node",
+ // The children of the top node
Children: []pterm.TreeNode{{
+ // A child node
Text: "Child node",
+ // The children of the child node
Children: []pterm.TreeNode{
+ // Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
@@ -2460,6 +3544,7 @@ func main() {
}},
}
+ // Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
@@ -2484,37 +3569,37 @@ import (
)
func main() {
- // You can use a LeveledList here, for easy generation.
+ // Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
- pterm.LeveledListItem{Level: 0, Text: "C:"},
- pterm.LeveledListItem{Level: 1, Text: "Users"},
- pterm.LeveledListItem{Level: 1, Text: "Windows"},
- pterm.LeveledListItem{Level: 1, Text: "Programs"},
- pterm.LeveledListItem{Level: 1, Text: "Programs(x86)"},
- pterm.LeveledListItem{Level: 1, Text: "dev"},
- pterm.LeveledListItem{Level: 0, Text: "D:"},
- pterm.LeveledListItem{Level: 0, Text: "E:"},
- pterm.LeveledListItem{Level: 1, Text: "Movies"},
- pterm.LeveledListItem{Level: 1, Text: "Music"},
- pterm.LeveledListItem{Level: 2, Text: "LinkinPark"},
- pterm.LeveledListItem{Level: 1, Text: "Games"},
- pterm.LeveledListItem{Level: 2, Text: "Shooter"},
- pterm.LeveledListItem{Level: 3, Text: "CallOfDuty"},
- pterm.LeveledListItem{Level: 3, Text: "CS:GO"},
- pterm.LeveledListItem{Level: 3, Text: "Battlefield"},
- pterm.LeveledListItem{Level: 4, Text: "Battlefield 1"},
- pterm.LeveledListItem{Level: 4, Text: "Battlefield 2"},
- pterm.LeveledListItem{Level: 0, Text: "F:"},
- pterm.LeveledListItem{Level: 1, Text: "dev"},
- pterm.LeveledListItem{Level: 2, Text: "dops"},
- pterm.LeveledListItem{Level: 2, Text: "PTerm"},
- }
-
- // Generate tree from LeveledList.
+ {Level: 0, Text: "C:"},
+ {Level: 1, Text: "Users"},
+ {Level: 1, Text: "Windows"},
+ {Level: 1, Text: "Programs"},
+ {Level: 1, Text: "Programs(x86)"},
+ {Level: 1, Text: "dev"},
+ {Level: 0, Text: "D:"},
+ {Level: 0, Text: "E:"},
+ {Level: 1, Text: "Movies"},
+ {Level: 1, Text: "Music"},
+ {Level: 2, Text: "LinkinPark"},
+ {Level: 1, Text: "Games"},
+ {Level: 2, Text: "Shooter"},
+ {Level: 3, Text: "CallOfDuty"},
+ {Level: 3, Text: "CS:GO"},
+ {Level: 3, Text: "Battlefield"},
+ {Level: 4, Text: "Battlefield 1"},
+ {Level: 4, Text: "Battlefield 2"},
+ {Level: 0, Text: "F:"},
+ {Level: 1, Text: "dev"},
+ {Level: 2, Text: "dops"},
+ {Level: 2, Text: "PTerm"},
+ }
+
+ // Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
- root.Text = "Computer"
+ root.Text = "Computer" // Set the root node text.
- // Render TreePrinter
+ // Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
diff --git a/vendor/github.com/pterm/pterm/SECURITY.md b/vendor/github.com/pterm/pterm/SECURITY.md
new file mode 100644
index 00000000..3e4653f8
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/SECURITY.md
@@ -0,0 +1,24 @@
+# PTerm Security Policy
+This security policy applies to the PTerm GitHub repository and outlines the process for reporting security issues and handling security incidents. The primary goal of this policy is to ensure the safety and integrity of the PTerm codebase and to minimize the impact of security incidents on our users.
+
+## 1. Overview
+PTerm is a command-line interface (CLI) tool library, and we believe the security risks associated with it are minimal. However, we recognize that vulnerabilities can still arise, and we are committed to addressing them promptly and transparently.
+
+## 2. Reporting Security Issues
+If you discover a security issue in PTerm, please follow these steps:
+
+Open a new issue in the PTerm GitHub repository, describing the security problem in detail.
+
+## 3. Vulnerable Dependencies
+If a dependency of PTerm is found to be vulnerable or infected and requires immediate updates, please follow these steps:
+
+1. Open a new issue in the PTerm GitHub repository, describing the vulnerable dependency and the need for an update.
+2. *Optional: Contact @MarvinJWendt directly via Twitter or Discord to alert them to the issue.*
+
+## 4. Incident Response
+Upon receiving a security report, the PTerm team will:
+
+1. Acknowledge receipt of the report and review the issue.
+2. Investigate the issue and determine the severity and impact.
+3. Develop and implement a fix or mitigation plan, as necessary.
+4. Update the PTerm repository and notify users, if applicable.
diff --git a/vendor/github.com/pterm/pterm/area_printer.go b/vendor/github.com/pterm/pterm/area_printer.go
index 5f3e5b04..ed4b0c22 100644
--- a/vendor/github.com/pterm/pterm/area_printer.go
+++ b/vendor/github.com/pterm/pterm/area_printer.go
@@ -1,6 +1,7 @@
package pterm
import (
+ "io"
"strings"
"atomicgo.dev/cursor"
@@ -47,6 +48,11 @@ func (p AreaPrinter) WithCenter(b ...bool) *AreaPrinter {
return &p
}
+// SetWriter sets the writer for the AreaPrinter.
+func (p *AreaPrinter) SetWriter(writer io.Writer) {
+
+}
+
// Update overwrites the content of the AreaPrinter.
// Can be used live.
func (p *AreaPrinter) Update(text ...interface{}) {
diff --git a/vendor/github.com/pterm/pterm/box_printer.go b/vendor/github.com/pterm/pterm/box_printer.go
index 8bff4671..3185e024 100644
--- a/vendor/github.com/pterm/pterm/box_printer.go
+++ b/vendor/github.com/pterm/pterm/box_printer.go
@@ -240,8 +240,8 @@ func (p BoxPrinter) Sprint(a ...interface{}) string {
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else {
p.Title = strings.ReplaceAll(p.Title, "\n", " ")
- if (maxWidth + p.RightPadding + p.LeftPadding - 4) < len(RemoveColorFromString(p.Title)) {
- p.RightPadding = len(RemoveColorFromString(p.Title)) - (maxWidth + p.RightPadding + p.LeftPadding - 5)
+ if (maxWidth + p.RightPadding + p.LeftPadding - 4) < internal.GetStringMaxWidth(p.Title) {
+ p.RightPadding = internal.GetStringMaxWidth(p.Title) - (maxWidth + p.RightPadding + p.LeftPadding - 5)
}
if p.TitleTopLeft {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + internal.AddTitleToLine(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding, true) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
diff --git a/vendor/github.com/pterm/pterm/bulletlist_printer.go b/vendor/github.com/pterm/pterm/bulletlist_printer.go
index ed997aa5..8e6afcb0 100644
--- a/vendor/github.com/pterm/pterm/bulletlist_printer.go
+++ b/vendor/github.com/pterm/pterm/bulletlist_printer.go
@@ -116,10 +116,18 @@ func (l BulletListPrinter) Srender() (string, error) {
item.BulletStyle = l.BulletStyle
}
}
- if item.Bullet == "" {
- ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(l.Bullet) + " " + item.TextStyle.Sprint(item.Text) + "\n"
- } else {
- ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(item.Bullet) + " " + item.TextStyle.Sprint(item.Text) + "\n"
+
+ split := strings.Split(item.Text, "\n")
+ for i, line := range split {
+ if i == 0 {
+ if item.Bullet == "" {
+ ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(l.Bullet) + " " + item.TextStyle.Sprint(line) + "\n"
+ } else {
+ ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(item.Bullet) + " " + item.TextStyle.Sprint(line) + "\n"
+ }
+ } else {
+ ret += strings.Repeat(" ", item.Level) + strings.Repeat(" ", len(item.Bullet)) + " " + item.TextStyle.Sprint(line) + "\n"
+ }
}
}
return ret, nil
diff --git a/vendor/github.com/pterm/pterm/heatmap_printer.go b/vendor/github.com/pterm/pterm/heatmap_printer.go
new file mode 100644
index 00000000..4fac71e3
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/heatmap_printer.go
@@ -0,0 +1,744 @@
+package pterm
+
+import (
+ "bytes"
+ "errors"
+ "io"
+ "math"
+ "strings"
+
+ "github.com/pterm/pterm/internal"
+)
+
+// DefaultHeatmap contains standards, which can be used to print a HeatmapPrinter.
+var DefaultHeatmap = HeatmapPrinter{
+ AxisStyle: &ThemeDefault.HeatmapHeaderStyle,
+ SeparatorStyle: &ThemeDefault.HeatmapSeparatorStyle,
+ VerticalSeparator: "│",
+ TopRightCornerSeparator: "└",
+ TopLeftCornerSeparator: "┘",
+ BottomLeftCornerSeparator: "┐",
+ BottomRightCornerSeparator: "┌",
+ HorizontalSeparator: "─",
+ TSeparator: "┬",
+ TReverseSeparator: "┴",
+ LSeparator: "├",
+ LReverseSeparator: "┤",
+ TCrossSeparator: "┼",
+ LegendLabel: "Legend",
+ Boxed: true,
+ Grid: true,
+ Legend: true,
+ TextRGB: RGB{0, 0, 0, false},
+ RGBRange: []RGB{{R: 255, G: 0, B: 0, Background: true}, {R: 255, G: 165, B: 0, Background: true}, {R: 0, G: 255, B: 0, Background: true}},
+ TextColor: FgBlack,
+ Colors: []Color{BgRed, BgLightRed, BgYellow, BgLightYellow, BgLightGreen, BgGreen},
+
+ EnableRGB: false,
+}
+
+// HeatmapData is the type that contains the data of a HeatmapPrinter.
+type HeatmapData [][]float32
+
+type HeatmapAxis struct {
+ XAxis []string
+ YAxis []string
+}
+
+// HeatmapPrinter is able to render tables.
+type HeatmapPrinter struct {
+ HasHeader bool
+ AxisStyle *Style
+ VerticalSeparator string
+ TopRightCornerSeparator string
+ TopLeftCornerSeparator string
+ BottomLeftCornerSeparator string
+ BottomRightCornerSeparator string
+ HorizontalSeparator string
+ TSeparator string
+ TReverseSeparator string
+ LSeparator string
+ LReverseSeparator string
+ TCrossSeparator string
+ LegendLabel string
+ SeparatorStyle *Style
+ Data HeatmapData
+ Axis HeatmapAxis
+ Boxed bool
+ Grid bool
+ OnlyColoredCells bool
+ LegendOnlyColoredCells bool
+ EnableComplementaryColor bool
+ Legend bool
+ CellSize int
+ Colors []Color
+ TextColor Color
+ EnableRGB bool
+ RGBRange []RGB
+ TextRGB RGB
+ Writer io.Writer
+
+ minValue float32
+ maxValue float32
+
+ rgbLegendValue int
+}
+
+var complementaryColors = map[Color]Color{
+ BgBlack: FgLightWhite,
+ BgRed: FgCyan,
+ BgGreen: FgMagenta,
+ BgYellow: FgBlue,
+ BgBlue: FgYellow,
+ BgMagenta: FgGreen,
+ BgCyan: FgRed,
+ BgWhite: FgBlack,
+ BgDefault: FgBlack,
+ BgDarkGray: FgLightWhite,
+ BgLightRed: FgLightCyan,
+ BgLightGreen: FgLightMagenta,
+ BgLightYellow: FgLightBlue,
+ BgLightBlue: FgLightYellow,
+ BgLightMagenta: FgLightGreen,
+ BgLightCyan: FgLightRed,
+ BgLightWhite: FgBlack,
+}
+
+// WithAxisData returns a new HeatmapPrinter, where the first line and row are headers.
+func (p HeatmapPrinter) WithAxisData(hd HeatmapAxis) *HeatmapPrinter {
+ p.HasHeader = true
+ p.Axis = hd
+ return &p
+}
+
+// WithAxisStyle returns a new HeatmapPrinter with a specific AxisStyle.
+func (p HeatmapPrinter) WithAxisStyle(style *Style) *HeatmapPrinter {
+ p.AxisStyle = style
+ return &p
+}
+
+// WithSeparatorStyle returns a new HeatmapPrinter with a specific SeparatorStyle.
+func (p HeatmapPrinter) WithSeparatorStyle(style *Style) *HeatmapPrinter {
+ p.SeparatorStyle = style
+ return &p
+}
+
+// WithData returns a new HeatmapPrinter with specific Data.
+func (p HeatmapPrinter) WithData(data [][]float32) *HeatmapPrinter {
+ p.Data = data
+ return &p
+}
+
+// WithTextColor returns a new HeatmapPrinter with a specific TextColor.
+// This sets EnableComplementaryColor to false.
+func (p HeatmapPrinter) WithTextColor(color Color) *HeatmapPrinter {
+ p.TextColor = color
+ p.EnableComplementaryColor = false
+ return &p
+}
+
+// WithTextRGB returns a new HeatmapPrinter with a specific TextRGB.
+// This sets EnableComplementaryColor to false.
+func (p HeatmapPrinter) WithTextRGB(rgb RGB) *HeatmapPrinter {
+ p.TextRGB = rgb
+ p.EnableComplementaryColor = false
+ return &p
+}
+
+// WithBoxed returns a new HeatmapPrinter with a box around the table.
+// If set to true, Grid will be set to true too.
+func (p HeatmapPrinter) WithBoxed(b ...bool) *HeatmapPrinter {
+ p.Boxed = internal.WithBoolean(b)
+ if p.Boxed && !p.Grid {
+ p.Grid = true
+ }
+ return &p
+}
+
+// WithGrid returns a new HeatmapPrinter with a grid.
+// If set to false, Boxed will be set to false too.
+func (p HeatmapPrinter) WithGrid(b ...bool) *HeatmapPrinter {
+ b2 := internal.WithBoolean(b)
+ p.Grid = b2
+ if !b2 && p.Boxed {
+ p.Boxed = false
+ }
+ return &p
+}
+
+// WithEnableRGB returns a new HeatmapPrinter with RGB colors.
+func (p HeatmapPrinter) WithEnableRGB(b ...bool) *HeatmapPrinter {
+ p.EnableRGB = internal.WithBoolean(b)
+ return &p
+}
+
+// WithOnlyColoredCells returns a new HeatmapPrinter with only colored cells.
+func (p HeatmapPrinter) WithOnlyColoredCells(b ...bool) *HeatmapPrinter {
+ b2 := internal.WithBoolean(b)
+ p.OnlyColoredCells = b2
+ return &p
+}
+
+// WithLegendOnlyColoredCells returns a new HeatmapPrinter with legend with only colored cells.
+// This sets the Legend to true.
+func (p HeatmapPrinter) WithLegendOnlyColoredCells(b ...bool) *HeatmapPrinter {
+ b2 := internal.WithBoolean(b)
+ p.LegendOnlyColoredCells = b2
+ if b2 {
+ p.Legend = true
+ }
+ return &p
+}
+
+// WithEnableComplementaryColor returns a new HeatmapPrinter with complement color.
+func (p HeatmapPrinter) WithEnableComplementaryColor(b ...bool) *HeatmapPrinter {
+ p.EnableComplementaryColor = internal.WithBoolean(b)
+ return &p
+}
+
+// WithLegend returns a new HeatmapPrinter with a legend.
+func (p HeatmapPrinter) WithLegend(b ...bool) *HeatmapPrinter {
+ p.Legend = internal.WithBoolean(b)
+ return &p
+}
+
+// WithCellSize returns a new HeatmapPrinter with a specific cell size.
+// This only works if there is no header and OnlyColoredCells == true!
+func (p HeatmapPrinter) WithCellSize(i int) *HeatmapPrinter {
+ p.CellSize = i
+ return &p
+}
+
+// WithLegendLabel returns a new HeatmapPrinter with a specific legend tag.
+// This sets the Legend to true.
+func (p HeatmapPrinter) WithLegendLabel(s string) *HeatmapPrinter {
+ p.LegendLabel = s
+ p.Legend = true
+ return &p
+}
+
+// WithRGBRange returns a new HeatmapPrinter with a specific RGBRange.
+func (p HeatmapPrinter) WithRGBRange(rgb ...RGB) *HeatmapPrinter {
+ p.RGBRange = rgb
+ return &p
+}
+
+// WithColors returns a new HeatmapPrinter with a specific Colors.
+func (p HeatmapPrinter) WithColors(colors ...Color) *HeatmapPrinter {
+ p.Colors = colors
+ return &p
+}
+
+// WithWriter sets the Writer.
+func (p HeatmapPrinter) WithWriter(writer io.Writer) *HeatmapPrinter {
+ p.Writer = writer
+ return &p
+}
+
+// Srender renders the HeatmapPrinter as a string.
+func (p HeatmapPrinter) Srender() (string, error) {
+ if err := p.errCheck(); err != nil {
+ return "", err
+ }
+
+ if p.SeparatorStyle == nil {
+ p.SeparatorStyle = DefaultHeatmap.SeparatorStyle
+ }
+ if p.AxisStyle == nil {
+ p.AxisStyle = DefaultHeatmap.AxisStyle
+ }
+
+ if RawOutput {
+ p.Legend = false
+ }
+
+ buffer := bytes.NewBufferString("")
+ xAmount := len(p.Data[0]) - 1
+ yAmount := len(p.Data) - 1
+ p.minValue, p.maxValue = minMaxFloat32(p.Data)
+
+ var data string
+ for _, datum := range p.Data {
+ for _, f := range datum {
+ data += Sprintf("%v\n", f)
+ }
+ }
+
+ if p.HasHeader {
+ data, xAmount, yAmount = p.computeAxisData(data, xAmount, yAmount)
+ }
+
+ colWidth := internal.GetStringMaxWidth(data)
+ legendColWidth := colWidth + 2
+
+ if p.OnlyColoredCells && (p.CellSize > colWidth || !p.HasHeader) {
+ colWidth = p.CellSize
+ }
+
+ if p.Boxed {
+ p.renderSeparatorRow(buffer, colWidth, xAmount, true)
+ }
+
+ p.renderData(buffer, colWidth, xAmount, yAmount)
+
+ if p.HasHeader {
+ p.renderHeader(buffer, colWidth, xAmount)
+ }
+
+ if p.Boxed {
+ p.renderSeparatorRow(buffer, colWidth, xAmount, false)
+ }
+
+ if p.Legend {
+ p.renderLegend(buffer, legendColWidth)
+ }
+
+ buffer.WriteString("\n")
+
+ return buffer.String(), nil
+}
+
+func (p HeatmapPrinter) computeAxisData(data string, xAmount, yAmount int) (string, int, int) {
+ var header string
+ for _, h := range p.Axis.XAxis {
+ header += h + "\n"
+ }
+ for _, h := range p.Axis.YAxis {
+ header += h + "\n"
+ }
+
+ if p.OnlyColoredCells {
+ data = header
+ } else {
+ data += header
+ }
+ xAmount++
+ yAmount++
+
+ p.Axis.YAxis = append(p.Axis.YAxis, "")
+
+ return data, xAmount, yAmount
+}
+
+func (p HeatmapPrinter) renderSeparatorRow(buffer *bytes.Buffer, colWidth, xAmount int, top bool) {
+ tSep := p.TReverseSeparator
+ rightSep := p.TopRightCornerSeparator
+ leftSep := p.TopLeftCornerSeparator
+
+ if top {
+ tSep = p.TSeparator
+ rightSep = p.BottomRightCornerSeparator
+ leftSep = p.BottomLeftCornerSeparator
+ } else {
+ buffer.WriteString("\n")
+ }
+ buffer.WriteString(p.SeparatorStyle.Sprint(rightSep))
+ for i := 0; i < xAmount+1; i++ {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), colWidth))
+ if i < xAmount {
+ buffer.WriteString(p.SeparatorStyle.Sprint(tSep))
+ }
+ }
+ buffer.WriteString(p.SeparatorStyle.Sprint(leftSep))
+
+ if top {
+ buffer.WriteString("\n")
+ }
+}
+
+func (p HeatmapPrinter) renderLegend(buffer *bytes.Buffer, legendColWidth int) {
+ buffer.WriteString("\n")
+ buffer.WriteString("\n")
+ if p.Boxed {
+ p.boxLegend(buffer, p.LegendLabel, legendColWidth)
+ } else {
+ p.generateLegend(buffer, p.LegendLabel, legendColWidth)
+ }
+}
+
+func (p HeatmapPrinter) renderHeader(buffer *bytes.Buffer, colWidth int, xAmount int) {
+ buffer.WriteString("\n")
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.LSeparator))
+ }
+ if p.Grid {
+ for i := 0; i < xAmount+1; i++ {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), colWidth))
+ if i < xAmount {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TCrossSeparator))
+ }
+ }
+ }
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.LReverseSeparator))
+ }
+ if p.Grid {
+ buffer.WriteString("\n")
+ }
+ for j, f := range p.Axis.XAxis {
+ if j == 0 {
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ ct := internal.CenterText(" ", colWidth)
+ if len(ct) < colWidth {
+ ct += strings.Repeat(" ", colWidth-len(ct))
+ }
+ buffer.WriteString(p.AxisStyle.Sprint(ct))
+ if p.Grid {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ }
+ var ct string
+ ct = internal.CenterText(Sprintf("%v", f), colWidth)
+ if len(ct) < colWidth {
+ ct += strings.Repeat(" ", colWidth-len(ct))
+ }
+ buffer.WriteString(p.AxisStyle.Sprint(ct))
+
+ if j < xAmount {
+ if !p.Boxed && j == xAmount-1 {
+ continue
+ }
+ if p.Grid {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ }
+ }
+}
+
+func (p HeatmapPrinter) renderData(buffer *bytes.Buffer, colWidth int, xAmount int, yAmount int) {
+ for i, datum := range p.Data {
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ for j, f := range datum {
+ if j == 0 && p.HasHeader {
+ ct := internal.CenterText(p.Axis.YAxis[i], colWidth)
+ if len(ct) < colWidth {
+ ct += strings.Repeat(" ", colWidth-len(ct))
+ }
+ buffer.WriteString(p.AxisStyle.Sprint(ct))
+ if p.Grid {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ }
+ var ct string
+ if p.OnlyColoredCells {
+ ct = internal.CenterText(" ", colWidth)
+ } else {
+ ct = internal.CenterText(Sprintf("%v", f), colWidth)
+ }
+ if len(ct) < colWidth {
+ if len(Sprintf("%v", f)) == 1 {
+ ct += strings.Repeat(" ", colWidth-len(ct))
+ } else {
+ ct = strings.Repeat(" ", colWidth-len(ct)) + ct
+ }
+ }
+ if p.EnableRGB {
+ rgb := p.RGBRange[0].Fade(p.minValue, p.maxValue, f, p.RGBRange[1:]...)
+ rgbStyle := NewRGBStyle(p.TextRGB, rgb)
+ if p.EnableComplementaryColor {
+ complimentary := NewRGB(internal.Complementary(rgb.R, rgb.G, rgb.B))
+ rgbStyle = NewRGBStyle(complimentary, rgb)
+ }
+ buffer.WriteString(rgbStyle.Sprint(ct))
+ } else {
+ color := getColor(p.minValue, p.maxValue, f, p.Colors...)
+ fgColor := p.TextColor
+ if p.EnableComplementaryColor {
+ fgColor = complementaryColors[color]
+ }
+ buffer.WriteString(fgColor.Sprint(color.Sprintf(ct)))
+ }
+ if j < xAmount {
+ if !p.Boxed && p.HasHeader && j == xAmount-1 {
+ continue
+ }
+ if p.Grid {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ }
+ if p.Boxed && !p.HasHeader && j == xAmount {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.VerticalSeparator))
+ }
+ }
+
+ if i < yAmount {
+ if p.HasHeader && i == yAmount-1 {
+ continue
+ }
+ buffer.WriteString("\n")
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.LSeparator))
+ }
+ if p.Grid {
+ for i := 0; i < xAmount+1; i++ {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), colWidth))
+ if i < xAmount {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TCrossSeparator))
+ }
+ }
+ }
+ if p.Boxed {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.LReverseSeparator))
+ }
+ if p.Grid {
+ buffer.WriteString("\n")
+ }
+ }
+ }
+}
+
+func (p HeatmapPrinter) generateLegend(buffer *bytes.Buffer, legend string, legendColWidth int) {
+ buffer.WriteString(p.AxisStyle.Sprint(legend))
+ if p.Grid {
+ buffer.WriteString(p.SeparatorStyle.Sprintf("%s", p.VerticalSeparator))
+ } else {
+ buffer.WriteString(" ")
+ }
+ if p.EnableRGB {
+ p.generateRGBLegend(buffer, legendColWidth)
+ } else {
+ p.generateColorLegend(buffer, legendColWidth)
+ }
+}
+
+func (p HeatmapPrinter) generateColorLegend(buffer *bytes.Buffer, legendColWidth int) {
+ for i, color := range p.Colors {
+ // the first color is the min value and the last color is the max value
+ var f float32
+ if i == 0 {
+ f = p.minValue
+ } else if i == len(p.Colors)-1 {
+ f = p.maxValue
+ } else {
+ f = p.minValue + (p.maxValue-p.minValue)*float32(i)/float32(len(p.Colors)-1)
+ }
+ fgColor := p.TextColor
+ if p.EnableComplementaryColor {
+ fgColor = complementaryColors[color]
+ }
+ buffer.WriteString(fgColor.Sprint(color.Sprint(centerAndShorten(f, legendColWidth, p.LegendOnlyColoredCells))))
+ if p.Grid && i < len(p.Colors)-1 && !p.LegendOnlyColoredCells {
+ buffer.WriteString(p.SeparatorStyle.Sprintf("%s", p.VerticalSeparator))
+ }
+ }
+}
+
+func (p HeatmapPrinter) generateRGBLegend(buffer *bytes.Buffer, legendColWidth int) {
+ p.rgbLegendValue = 10
+ steps := len(p.RGBRange)
+ if steps < p.rgbLegendValue {
+ steps = p.rgbLegendValue
+ }
+ if p.LegendOnlyColoredCells {
+ steps *= 3
+ }
+ for i := 0; i < steps; i++ {
+ // the first color is the min value and the last color is the max value
+ var f float32
+ if i == 0 {
+ f = p.minValue
+ } else if i == steps-1 {
+ f = p.maxValue
+ } else {
+ f = p.minValue + (p.maxValue-p.minValue)*float32(i)/float32(steps-1)
+ }
+ rgb := p.RGBRange[0].Fade(p.minValue, p.maxValue, f, p.RGBRange[1:]...)
+ rgbStyle := NewRGBStyle(p.TextRGB, rgb)
+ if p.EnableComplementaryColor {
+ complimentary := NewRGB(internal.Complementary(rgb.R, rgb.G, rgb.B))
+ rgbStyle = NewRGBStyle(complimentary, rgb)
+ }
+ if p.LegendOnlyColoredCells {
+ buffer.WriteString(rgbStyle.Sprint(centerAndShorten(f, 1, p.LegendOnlyColoredCells)))
+ } else {
+ buffer.WriteString(rgbStyle.Sprint(centerAndShorten(f, legendColWidth, p.LegendOnlyColoredCells)))
+ }
+ if p.Grid && i < steps-1 && !p.LegendOnlyColoredCells {
+ buffer.WriteString(p.SeparatorStyle.Sprintf("%s", p.VerticalSeparator))
+ }
+ }
+}
+
+func (p HeatmapPrinter) boxLegend(buffer *bytes.Buffer, legend string, legendColWidth int) {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.BottomRightCornerSeparator))
+
+ p.generateSeparatorRow(buffer, legend, legendColWidth, true)
+
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.BottomLeftCornerSeparator))
+ buffer.WriteString("\n")
+ buffer.WriteString(p.SeparatorStyle.Sprintf("%s", p.VerticalSeparator))
+
+ p.generateLegend(buffer, legend, legendColWidth)
+
+ buffer.WriteString(p.SeparatorStyle.Sprintf("%s", p.VerticalSeparator))
+ buffer.WriteString("\n")
+
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TopRightCornerSeparator))
+
+ p.generateSeparatorRow(buffer, legend, legendColWidth, false)
+
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TopLeftCornerSeparator))
+}
+
+func (p HeatmapPrinter) generateSeparatorRow(buffer *bytes.Buffer, legend string, legendColWidth int, top bool) {
+ p.rgbLegendValue = 10
+ steps := len(p.RGBRange)
+ if steps < p.rgbLegendValue {
+ steps = p.rgbLegendValue
+ }
+ if p.LegendOnlyColoredCells {
+ steps *= 3
+ }
+
+ var xValue int
+ if p.EnableRGB {
+ xValue = len(p.RGBRange)
+ if xValue < p.rgbLegendValue {
+ xValue = p.rgbLegendValue
+ }
+ } else {
+ xValue = len(p.Colors)
+ }
+
+ for i := 0; i < xValue+1; i++ {
+ if i == 0 {
+ firstLength := len(legend)
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), firstLength))
+ } else {
+ if p.LegendOnlyColoredCells {
+ if p.EnableRGB {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), steps/(xValue)))
+ } else {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), legendColWidth))
+ }
+ } else {
+ buffer.WriteString(strings.Repeat(p.SeparatorStyle.Sprint(p.HorizontalSeparator), legendColWidth))
+ }
+ }
+ if i < xValue && !p.LegendOnlyColoredCells || i == 0 {
+ if top {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TSeparator))
+ } else {
+ buffer.WriteString(p.SeparatorStyle.Sprint(p.TReverseSeparator))
+ }
+ }
+ }
+}
+
+func centerAndShorten(f float32, lineLength int, onlyColor bool) string {
+ value := ""
+ if !onlyColor {
+ value = Sprintf("%.2v", f)
+ }
+ if len(value) > lineLength {
+ value = value[:lineLength]
+ if strings.HasSuffix(value, ".") {
+ value = Sprintf("%.1v", f)
+ lineLength = len(value)
+ }
+ }
+ ct := internal.CenterText(value, lineLength)
+ if len(ct) < lineLength {
+ if len(Sprintf("%v", f)) == 1 {
+ ct += strings.Repeat(" ", lineLength-len(ct))
+ } else {
+ ct = strings.Repeat(" ", lineLength-len(ct)) + ct
+ }
+ }
+
+ return ct
+}
+
+func getColor(min float32, max float32, current float32, colors ...Color) Color {
+ // split the range into equal parts
+ // and assign a color to each part
+ // the last color is assigned to the max value
+ // and the first color to the min value
+ // the rest of the colors are assigned to the
+ // middle values
+ step := (max - min) / float32(len(colors))
+ for i := range colors {
+ if current >= min+float32(i)*step && current < min+float32(i+1)*step {
+ return colors[i]
+ }
+ }
+ return colors[len(colors)-1]
+}
+
+// Render prints the HeatmapPrinter to the terminal.
+func (p HeatmapPrinter) Render() error {
+ s, err := p.Srender()
+ if err != nil {
+ return err
+ }
+ Fprintln(p.Writer, s)
+
+ return nil
+}
+
+func (p HeatmapPrinter) errCheck() error {
+ if p.HasHeader {
+ if p.Axis.XAxis == nil {
+ return errors.New("x axis is nil")
+ }
+ if p.Axis.YAxis == nil {
+ return errors.New("y axis is nil")
+ }
+
+ if len(p.Axis.XAxis) == 0 {
+ return errors.New("x axis is empty")
+ }
+ if len(p.Axis.YAxis) == 0 {
+ return errors.New("y axis is empty")
+ }
+
+ for i := 1; i < len(p.Data); i++ {
+ if len(p.Data[i]) != len(p.Axis.XAxis) {
+ return errors.New("x axis length does not match data")
+ }
+ }
+ if len(p.Axis.YAxis) != len(p.Data) {
+ return errors.New("y axis length does not match data")
+ }
+ }
+
+ if p.Data == nil {
+ return errors.New("data is nil")
+ }
+
+ if len(p.Data) == 0 {
+ return errors.New("data is empty")
+ }
+
+ // check if p.Data[n] has the same length
+ for i := 1; i < len(p.Data); i++ {
+ if len(p.Data[i]) != len(p.Data[0]) {
+ return errors.New("data is not rectangular")
+ }
+ }
+
+ return nil
+}
+
+// return min and max value of a slice
+func minMaxFloat32(s [][]float32) (float32, float32) {
+ var min, max float32
+ min = math.MaxFloat32
+ max = -math.MaxFloat32
+
+ for _, r := range s {
+ for _, c := range r {
+ if c < min {
+ min = c
+ }
+ if c > max {
+ max = c
+ }
+ }
+ }
+ return min, max
+}
diff --git a/vendor/github.com/pterm/pterm/interactive_confirm_printer.go b/vendor/github.com/pterm/pterm/interactive_confirm_printer.go
index 6760ce69..a94cc5dc 100644
--- a/vendor/github.com/pterm/pterm/interactive_confirm_printer.go
+++ b/vendor/github.com/pterm/pterm/interactive_confirm_printer.go
@@ -7,35 +7,37 @@ import (
"atomicgo.dev/cursor"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
+
"github.com/pterm/pterm/internal"
)
-var (
- // DefaultInteractiveConfirm is the default InteractiveConfirm printer.
- // Pressing "y" will return true, "n" will return false.
- // Pressing enter without typing "y" or "n" will return the configured default value (by default set to "no").
- DefaultInteractiveConfirm = InteractiveConfirmPrinter{
- DefaultValue: false,
- DefaultText: "Please confirm",
- TextStyle: &ThemeDefault.PrimaryStyle,
- ConfirmText: "Yes",
- ConfirmStyle: &ThemeDefault.SuccessMessageStyle,
- RejectText: "No",
- RejectStyle: &ThemeDefault.ErrorMessageStyle,
- SuffixStyle: &ThemeDefault.SecondaryStyle,
- }
-)
+// DefaultInteractiveConfirm is the default InteractiveConfirm printer.
+// Pressing "y" will return true, "n" will return false.
+// Pressing enter without typing "y" or "n" will return the configured default value (by default set to "no").
+var DefaultInteractiveConfirm = InteractiveConfirmPrinter{
+ DefaultValue: false,
+ DefaultText: "Please confirm",
+ TextStyle: &ThemeDefault.PrimaryStyle,
+ ConfirmText: "Yes",
+ ConfirmStyle: &ThemeDefault.SuccessMessageStyle,
+ RejectText: "No",
+ RejectStyle: &ThemeDefault.ErrorMessageStyle,
+ SuffixStyle: &ThemeDefault.SecondaryStyle,
+ Delimiter: ": ",
+}
// InteractiveConfirmPrinter is a printer for interactive confirm prompts.
type InteractiveConfirmPrinter struct {
- DefaultValue bool
- DefaultText string
- TextStyle *Style
- ConfirmText string
- ConfirmStyle *Style
- RejectText string
- RejectStyle *Style
- SuffixStyle *Style
+ DefaultValue bool
+ DefaultText string
+ Delimiter string
+ TextStyle *Style
+ ConfirmText string
+ ConfirmStyle *Style
+ RejectText string
+ RejectStyle *Style
+ SuffixStyle *Style
+ OnInterruptFunc func()
}
// WithDefaultText sets the default text.
@@ -86,6 +88,18 @@ func (p InteractiveConfirmPrinter) WithSuffixStyle(style *Style) *InteractiveCon
return &p
}
+// OnInterrupt sets the function to execute on exit of the input reader
+func (p InteractiveConfirmPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveConfirmPrinter {
+ p.OnInterruptFunc = exitFunc
+ return &p
+}
+
+// WithDelimiter sets the delimiter between the message and the input.
+func (p InteractiveConfirmPrinter) WithDelimiter(delimiter string) *InteractiveConfirmPrinter {
+ p.Delimiter = delimiter
+ return &p
+}
+
// Show shows the confirm prompt.
//
// Example:
@@ -95,7 +109,7 @@ func (p InteractiveConfirmPrinter) WithSuffixStyle(style *Style) *InteractiveCon
func (p InteractiveConfirmPrinter) Show(text ...string) (bool, error) {
// should be the first defer statement to make sure it is executed last
// and all the needed cleanup can be done before
- cancel, exit := internal.NewCancelationSignal()
+ cancel, exit := internal.NewCancelationSignal(p.OnInterruptFunc)
defer exit()
var result bool
@@ -104,7 +118,7 @@ func (p InteractiveConfirmPrinter) Show(text ...string) (bool, error) {
text = []string{p.DefaultText}
}
- p.TextStyle.Print(text[0] + " " + p.getSuffix() + ": ")
+ p.TextStyle.Print(text[0] + " " + p.getSuffix() + p.Delimiter)
y, n := p.getShortHandles()
var interrupted bool
diff --git a/vendor/github.com/pterm/pterm/interactive_continue_printer.go b/vendor/github.com/pterm/pterm/interactive_continue_printer.go
index d0f91f13..4049cde9 100644
--- a/vendor/github.com/pterm/pterm/interactive_continue_printer.go
+++ b/vendor/github.com/pterm/pterm/interactive_continue_printer.go
@@ -2,7 +2,6 @@ package pterm
import (
"fmt"
- "os"
"strings"
"atomicgo.dev/cursor"
@@ -14,24 +13,24 @@ import (
"github.com/pterm/pterm/internal"
)
-var (
- // DefaultInteractiveContinue is the default InteractiveContinue printer.
- // Pressing "y" will return yes, "n" will return no, "a" returns all and "s" returns stop.
- // Pressing enter without typing any letter will return the configured default value (by default set to "yes", the fisrt option).
- DefaultInteractiveContinue = InteractiveContinuePrinter{
- DefaultValueIndex: 0,
- DefaultText: "Do you want to continue",
- TextStyle: &ThemeDefault.PrimaryStyle,
- Options: []string{"yes", "no", "all", "cancel"},
- OptionsStyle: &ThemeDefault.SuccessMessageStyle,
- SuffixStyle: &ThemeDefault.SecondaryStyle,
- }
-)
+// DefaultInteractiveContinue is the default InteractiveContinue printer.
+// Pressing "y" will return yes, "n" will return no, "a" returns all and "s" returns stop.
+// Pressing enter without typing any letter will return the configured default value (by default set to "yes", the fisrt option).
+var DefaultInteractiveContinue = InteractiveContinuePrinter{
+ DefaultValueIndex: 0,
+ DefaultText: "Do you want to continue",
+ TextStyle: &ThemeDefault.PrimaryStyle,
+ Options: []string{"yes", "no", "all", "cancel"},
+ OptionsStyle: &ThemeDefault.SuccessMessageStyle,
+ SuffixStyle: &ThemeDefault.SecondaryStyle,
+ Delimiter: ": ",
+}
// InteractiveContinuePrinter is a printer for interactive continue prompts.
type InteractiveContinuePrinter struct {
DefaultValueIndex int
DefaultText string
+ Delimiter string
TextStyle *Style
Options []string
OptionsStyle *Style
@@ -108,6 +107,12 @@ func (p InteractiveContinuePrinter) WithSuffixStyle(style *Style) *InteractiveCo
return &p
}
+// WithDelimiter sets the delimiter between the message and the input.
+func (p InteractiveContinuePrinter) WithDelimiter(delimiter string) *InteractiveContinuePrinter {
+ p.Delimiter = delimiter
+ return &p
+}
+
// Show shows the continue prompt.
//
// Example:
@@ -121,7 +126,7 @@ func (p InteractiveContinuePrinter) Show(text ...string) (string, error) {
text = []string{p.DefaultText}
}
- p.TextStyle.Print(text[0] + " " + p.getSuffix() + ": ")
+ p.TextStyle.Print(text[0] + " " + p.getSuffix() + p.Delimiter)
err := keyboard.Listen(func(keyInfo keys.Key) (stop bool, err error) {
if err != nil {
@@ -149,7 +154,7 @@ func (p InteractiveContinuePrinter) Show(text ...string) (string, error) {
result = p.Options[p.DefaultValueIndex]
return true, nil
case keys.CtrlC:
- os.Exit(1)
+ internal.Exit(1)
return true, nil
}
return false, nil
diff --git a/vendor/github.com/pterm/pterm/interactive_multiselect_printer.go b/vendor/github.com/pterm/pterm/interactive_multiselect_printer.go
index c80f9355..754ba98a 100644
--- a/vendor/github.com/pterm/pterm/interactive_multiselect_printer.go
+++ b/vendor/github.com/pterm/pterm/interactive_multiselect_printer.go
@@ -32,16 +32,17 @@ var (
// InteractiveMultiselectPrinter is a printer for interactive multiselect menus.
type InteractiveMultiselectPrinter struct {
- DefaultText string
- TextStyle *Style
- Options []string
- OptionStyle *Style
- DefaultOptions []string
- MaxHeight int
- Selector string
- SelectorStyle *Style
- Filter bool
- Checkmark *Checkmark
+ DefaultText string
+ TextStyle *Style
+ Options []string
+ OptionStyle *Style
+ DefaultOptions []string
+ MaxHeight int
+ Selector string
+ SelectorStyle *Style
+ Filter bool
+ Checkmark *Checkmark
+ OnInterruptFunc func()
selectedOption int
selectedOptions []int
@@ -52,7 +53,10 @@ type InteractiveMultiselectPrinter struct {
displayedOptionsStart int
displayedOptionsEnd int
- KeySelect keys.KeyCode
+ // KeySelect is the select key. It cannot be keys.Space when Filter is enabled.
+ KeySelect keys.KeyCode
+
+ // KeyConfirm is the confirm key. It cannot be keys.Space when Filter is enabled.
KeyConfirm keys.KeyCode
}
@@ -81,18 +85,20 @@ func (p InteractiveMultiselectPrinter) WithMaxHeight(maxHeight int) *Interactive
}
// WithFilter sets the Filter option
-func (p InteractiveMultiselectPrinter) WithFilter(filter bool) *InteractiveMultiselectPrinter {
- p.Filter = filter
+func (p InteractiveMultiselectPrinter) WithFilter(b ...bool) *InteractiveMultiselectPrinter {
+ p.Filter = internal.WithBoolean(b)
return &p
}
// WithKeySelect sets the confirm key
+// It cannot be keys.Space when Filter is enabled.
func (p InteractiveMultiselectPrinter) WithKeySelect(keySelect keys.KeyCode) *InteractiveMultiselectPrinter {
p.KeySelect = keySelect
return &p
}
// WithKeyConfirm sets the confirm key
+// It cannot be keys.Space when Filter is enabled.
func (p InteractiveMultiselectPrinter) WithKeyConfirm(keyConfirm keys.KeyCode) *InteractiveMultiselectPrinter {
p.KeyConfirm = keyConfirm
return &p
@@ -104,11 +110,17 @@ func (p InteractiveMultiselectPrinter) WithCheckmark(checkmark *Checkmark) *Inte
return &p
}
+// OnInterrupt sets the function to execute on exit of the input reader
+func (p InteractiveMultiselectPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveMultiselectPrinter {
+ p.OnInterruptFunc = exitFunc
+ return &p
+}
+
// Show shows the interactive multiselect menu and returns the selected entry.
func (p *InteractiveMultiselectPrinter) Show(text ...string) ([]string, error) {
// should be the first defer statement to make sure it is executed last
// and all the needed cleanup can be done before
- cancel, exit := internal.NewCancelationSignal()
+ cancel, exit := internal.NewCancelationSignal(p.OnInterruptFunc)
defer exit()
if len(text) == 0 || Sprint(text[0]) == "" {
@@ -228,7 +240,7 @@ func (p *InteractiveMultiselectPrinter) Show(text ...string) ([]string, error) {
p.selectedOptions = append(p.selectedOptions, i)
}
area.Update(p.renderSelectMenu())
- case keys.Up:
+ case keys.Up, keys.CtrlP:
if len(p.fuzzySearchMatches) == 0 {
return false, nil
}
@@ -251,7 +263,7 @@ func (p *InteractiveMultiselectPrinter) Show(text ...string) ([]string, error) {
}
area.Update(p.renderSelectMenu())
- case keys.Down:
+ case keys.Down, keys.CtrlN:
if len(p.fuzzySearchMatches) == 0 {
return false, nil
}
diff --git a/vendor/github.com/pterm/pterm/interactive_select_printer.go b/vendor/github.com/pterm/pterm/interactive_select_printer.go
index 0af1a0d6..0c4bc995 100644
--- a/vendor/github.com/pterm/pterm/interactive_select_printer.go
+++ b/vendor/github.com/pterm/pterm/interactive_select_printer.go
@@ -23,19 +23,22 @@ var (
MaxHeight: 5,
Selector: ">",
SelectorStyle: &ThemeDefault.SecondaryStyle,
+ Filter: true,
}
)
// InteractiveSelectPrinter is a printer for interactive select menus.
type InteractiveSelectPrinter struct {
- TextStyle *Style
- DefaultText string
- Options []string
- OptionStyle *Style
- DefaultOption string
- MaxHeight int
- Selector string
- SelectorStyle *Style
+ TextStyle *Style
+ DefaultText string
+ Options []string
+ OptionStyle *Style
+ DefaultOption string
+ MaxHeight int
+ Selector string
+ SelectorStyle *Style
+ OnInterruptFunc func()
+ Filter bool
selectedOption int
result string
@@ -71,11 +74,23 @@ func (p InteractiveSelectPrinter) WithMaxHeight(maxHeight int) *InteractiveSelec
return &p
}
+// OnInterrupt sets the function to execute on exit of the input reader
+func (p InteractiveSelectPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveSelectPrinter {
+ p.OnInterruptFunc = exitFunc
+ return &p
+}
+
+// WithFilter sets the Filter option
+func (p InteractiveSelectPrinter) WithFilter(b ...bool) *InteractiveSelectPrinter {
+ p.Filter = internal.WithBoolean(b)
+ return &p
+}
+
// Show shows the interactive select menu and returns the selected entry.
func (p *InteractiveSelectPrinter) Show(text ...string) (string, error) {
// should be the first defer statement to make sure it is executed last
// and all the needed cleanup can be done before
- cancel, exit := internal.NewCancelationSignal()
+ cancel, exit := internal.NewCancelationSignal(p.OnInterruptFunc)
defer exit()
if len(text) == 0 || Sprint(text[0]) == "" {
@@ -142,14 +157,16 @@ func (p *InteractiveSelectPrinter) Show(text ...string) (string, error) {
switch key {
case keys.RuneKey:
- // Fuzzy search for options
- // append to fuzzy search string
- p.fuzzySearchString += keyInfo.String()
- p.selectedOption = 0
- p.displayedOptionsStart = 0
- p.displayedOptionsEnd = maxHeight
- p.displayedOptions = append([]string{}, p.fuzzySearchMatches[:maxHeight]...)
- area.Update(p.renderSelectMenu())
+ if p.Filter {
+ // Fuzzy search for options
+ // append to fuzzy search string
+ p.fuzzySearchString += keyInfo.String()
+ p.selectedOption = 0
+ p.displayedOptionsStart = 0
+ p.displayedOptionsEnd = maxHeight
+ p.displayedOptions = append([]string{}, p.fuzzySearchMatches[:maxHeight]...)
+ area.Update(p.renderSelectMenu())
+ }
case keys.Space:
p.fuzzySearchString += " "
p.selectedOption = 0
@@ -179,7 +196,7 @@ func (p *InteractiveSelectPrinter) Show(text ...string) (string, error) {
p.displayedOptions = append([]string{}, p.fuzzySearchMatches[p.displayedOptionsStart:p.displayedOptionsEnd]...)
area.Update(p.renderSelectMenu())
- case keys.Up:
+ case keys.Up, keys.CtrlP:
if len(p.fuzzySearchMatches) == 0 {
return false, nil
}
@@ -202,7 +219,7 @@ func (p *InteractiveSelectPrinter) Show(text ...string) (string, error) {
}
area.Update(p.renderSelectMenu())
- case keys.Down:
+ case keys.Down, keys.CtrlN:
if len(p.fuzzySearchMatches) == 0 {
return false, nil
}
@@ -245,7 +262,11 @@ func (p *InteractiveSelectPrinter) Show(text ...string) (string, error) {
func (p *InteractiveSelectPrinter) renderSelectMenu() string {
var content string
- content += Sprintf("%s %s: %s\n", p.text, p.SelectorStyle.Sprint("[type to search]"), p.fuzzySearchString)
+ if p.Filter {
+ content += Sprintf("%s %s: %s\n", p.text, p.SelectorStyle.Sprint("[type to search]"), p.fuzzySearchString)
+ } else {
+ content += Sprintf("%s:\n", p.text)
+ }
// find options that match fuzzy search string
rankedResults := fuzzy.RankFindFold(p.fuzzySearchString, p.Options)
diff --git a/vendor/github.com/pterm/pterm/interactive_textinput_printer.go b/vendor/github.com/pterm/pterm/interactive_textinput_printer.go
index e7174555..88535c51 100644
--- a/vendor/github.com/pterm/pterm/interactive_textinput_printer.go
+++ b/vendor/github.com/pterm/pterm/interactive_textinput_printer.go
@@ -10,19 +10,23 @@ import (
"github.com/pterm/pterm/internal"
)
-var (
- // DefaultInteractiveTextInput is the default InteractiveTextInput printer.
- DefaultInteractiveTextInput = InteractiveTextInputPrinter{
- DefaultText: "Input text",
- TextStyle: &ThemeDefault.PrimaryStyle,
- }
-)
+// DefaultInteractiveTextInput is the default InteractiveTextInput printer.
+var DefaultInteractiveTextInput = InteractiveTextInputPrinter{
+ DefaultText: "Input text",
+ Delimiter: ": ",
+ TextStyle: &ThemeDefault.PrimaryStyle,
+ Mask: "",
+}
// InteractiveTextInputPrinter is a printer for interactive select menus.
type InteractiveTextInputPrinter struct {
- TextStyle *Style
- DefaultText string
- MultiLine bool
+ TextStyle *Style
+ DefaultText string
+ DefaultValue string
+ Delimiter string
+ MultiLine bool
+ Mask string
+ OnInterruptFunc func()
input []string
cursorXPos int
@@ -36,6 +40,12 @@ func (p InteractiveTextInputPrinter) WithDefaultText(text string) *InteractiveTe
return &p
}
+// WithDefaultValue sets the default value.
+func (p InteractiveTextInputPrinter) WithDefaultValue(value string) *InteractiveTextInputPrinter {
+ p.DefaultValue = value
+ return &p
+}
+
// WithTextStyle sets the text style.
func (p InteractiveTextInputPrinter) WithTextStyle(style *Style) *InteractiveTextInputPrinter {
p.TextStyle = style
@@ -48,11 +58,29 @@ func (p InteractiveTextInputPrinter) WithMultiLine(multiLine ...bool) *Interacti
return &p
}
+// WithMask sets the mask.
+func (p InteractiveTextInputPrinter) WithMask(mask string) *InteractiveTextInputPrinter {
+ p.Mask = mask
+ return &p
+}
+
+// WithOnInterruptFunc sets the function to execute on exit of the input reader
+func (p InteractiveTextInputPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveTextInputPrinter {
+ p.OnInterruptFunc = exitFunc
+ return &p
+}
+
+// WithDelimiter sets the delimiter between the message and the input.
+func (p InteractiveTextInputPrinter) WithDelimiter(delimiter string) *InteractiveTextInputPrinter {
+ p.Delimiter = delimiter
+ return &p
+}
+
// Show shows the interactive select menu and returns the selected entry.
func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
// should be the first defer statement to make sure it is executed last
// and all the needed cleanup can be done before
- cancel, exit := internal.NewCancelationSignal()
+ cancel, exit := internal.NewCancelationSignal(p.OnInterruptFunc)
defer exit()
var areaText string
@@ -62,24 +90,26 @@ func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
}
if p.MultiLine {
- areaText = p.TextStyle.Sprintfln("%s %s :", text[0], ThemeDefault.SecondaryStyle.Sprint("[Press tab to submit]"))
+ areaText = p.TextStyle.Sprintfln("%s %s %s", text[0], ThemeDefault.SecondaryStyle.Sprint("[Press tab to submit]"), p.Delimiter)
} else {
- areaText = p.TextStyle.Sprintf("%s: ", text[0])
+ areaText = p.TextStyle.Sprintf("%s%s", text[0], p.Delimiter)
}
+
p.text = areaText
- area, err := DefaultArea.Start(areaText)
- defer area.Stop()
- if err != nil {
- return "", err
- }
+ area := cursor.NewArea()
+ area.Update(areaText)
+ area.StartOfLine()
- cursor.Up(1)
- cursor.StartOfLine()
if !p.MultiLine {
cursor.Right(len(RemoveColorFromString(areaText)))
}
- err = keyboard.Listen(func(key keys.Key) (stop bool, err error) {
+ if p.DefaultValue != "" {
+ p.input = append(p.input, p.DefaultValue)
+ p.updateArea(&area)
+ }
+
+ err := keyboard.Listen(func(key keys.Key) (stop bool, err error) {
if !p.MultiLine {
p.cursorYPos = 0
}
@@ -90,6 +120,7 @@ func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
switch key.Code {
case keys.Tab:
if p.MultiLine {
+ area.Bottom()
return true, nil
}
case keys.Enter:
@@ -104,7 +135,6 @@ func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
p.input = append(p.input, appendAfterY...)
p.cursorYPos++
p.cursorXPos = -internal.GetStringMaxWidth(p.input[p.cursorYPos])
- cursor.Down(1)
cursor.StartOfLine()
} else {
return true, nil
@@ -173,7 +203,7 @@ func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
}
}
- p.updateArea(area)
+ p.updateArea(&area)
return false, nil
})
@@ -195,11 +225,12 @@ func (p InteractiveTextInputPrinter) Show(text ...string) (string, error) {
return strings.ReplaceAll(areaText, p.text, ""), nil
}
-func (p InteractiveTextInputPrinter) updateArea(area *AreaPrinter) string {
+func (p InteractiveTextInputPrinter) updateArea(area *cursor.Area) string {
if !p.MultiLine {
p.cursorYPos = 0
}
areaText := p.text
+
for i, s := range p.input {
if i < len(p.input)-1 {
areaText += s + "\n"
@@ -207,14 +238,19 @@ func (p InteractiveTextInputPrinter) updateArea(area *AreaPrinter) string {
areaText += s
}
}
+
+ if p.Mask != "" {
+ areaText = p.text + strings.Repeat(p.Mask, internal.GetStringMaxWidth(areaText)-internal.GetStringMaxWidth(p.text))
+ }
+
if p.cursorXPos+internal.GetStringMaxWidth(p.input[p.cursorYPos]) < 1 {
p.cursorXPos = -internal.GetStringMaxWidth(p.input[p.cursorYPos])
}
- cursor.StartOfLine()
area.Update(areaText)
- cursor.Up(len(p.input) - p.cursorYPos)
- cursor.StartOfLine()
+ area.Top()
+ area.Down(p.cursorYPos + 1)
+ area.StartOfLine()
if p.MultiLine {
cursor.Right(internal.GetStringMaxWidth(p.input[p.cursorYPos]) + p.cursorXPos)
} else {
diff --git a/vendor/github.com/pterm/pterm/interface_live_printer.go b/vendor/github.com/pterm/pterm/interface_live_printer.go
index b8d3dbe3..69dce345 100644
--- a/vendor/github.com/pterm/pterm/interface_live_printer.go
+++ b/vendor/github.com/pterm/pterm/interface_live_printer.go
@@ -1,5 +1,7 @@
package pterm
+import "io"
+
// LivePrinter is a printer which can update it's output live.
type LivePrinter interface {
// GenericStart runs Start, but returns a LivePrinter.
@@ -11,4 +13,6 @@ type LivePrinter interface {
// This is used for the interface LivePrinter.
// You most likely want to use Stop instead of this in your program.
GenericStop() (*LivePrinter, error)
+
+ SetWriter(writer io.Writer)
}
diff --git a/vendor/github.com/pterm/pterm/internal/cancelation_signal.go b/vendor/github.com/pterm/pterm/internal/cancelation_signal.go
index d6f79b0a..33f17cc1 100644
--- a/vendor/github.com/pterm/pterm/internal/cancelation_signal.go
+++ b/vendor/github.com/pterm/pterm/internal/cancelation_signal.go
@@ -1,19 +1,20 @@
package internal
-import (
- "os"
-)
-
// NewCancelationSignal for keeping track of a cancelation
-func NewCancelationSignal() (func(), func()) {
+func NewCancelationSignal(interruptFunc func()) (func(), func()) {
canceled := false
cancel := func() {
canceled = true
}
+
exit := func() {
if canceled {
- os.Exit(1)
+ if interruptFunc != nil {
+ interruptFunc()
+ } else {
+ Exit(1)
+ }
}
}
diff --git a/vendor/github.com/pterm/pterm/internal/exit.go b/vendor/github.com/pterm/pterm/internal/exit.go
new file mode 100644
index 00000000..f07a0045
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/internal/exit.go
@@ -0,0 +1,14 @@
+package internal
+
+import "os"
+
+// ExitFuncType is the type of function used to exit the program.
+type ExitFuncType func(int)
+
+// DefaultExitFunc is the default function used to exit the program.
+var DefaultExitFunc ExitFuncType = os.Exit
+
+// Exit calls the current exit function.
+func Exit(code int) {
+ DefaultExitFunc(code)
+}
diff --git a/vendor/github.com/pterm/pterm/internal/rgb_complementary.go b/vendor/github.com/pterm/pterm/internal/rgb_complementary.go
new file mode 100644
index 00000000..71520b33
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/internal/rgb_complementary.go
@@ -0,0 +1,5 @@
+package internal
+
+func Complementary(r, g, b uint8) (uint8, uint8, uint8) {
+ return 255 - r, 255 - g, 255 - b
+}
diff --git a/vendor/github.com/pterm/pterm/internal/title_in_line.go b/vendor/github.com/pterm/pterm/internal/title_in_line.go
index 3aae546b..68e28ec6 100644
--- a/vendor/github.com/pterm/pterm/internal/title_in_line.go
+++ b/vendor/github.com/pterm/pterm/internal/title_in_line.go
@@ -2,17 +2,15 @@ package internal
import (
"strings"
-
- "github.com/gookit/color"
)
// AddTitleToLine adds a title to a site of a line ex: "─ This is the title ──────"
func AddTitleToLine(title, line string, length int, left bool) string {
var ret string
if left {
- ret += line + " " + title + " " + line + strings.Repeat(line, length-(4+len(color.ClearCode(title))))
+ ret += line + " " + title + " " + line + strings.Repeat(line, length-(4+GetStringMaxWidth(title)))
} else {
- ret += strings.Repeat(line, length-(4+len(color.ClearCode(title)))) + line + " " + title + " " + line
+ ret += strings.Repeat(line, length-(4+GetStringMaxWidth(title))) + line + " " + title + " " + line
}
return ret
@@ -21,7 +19,7 @@ func AddTitleToLine(title, line string, length int, left bool) string {
// AddTitleToLineCenter adds a title to the center of a line ex: "─ This is the title ──────"
func AddTitleToLineCenter(title, line string, length int) string {
var ret string
- repeatString := length - (4 + len(color.ClearCode(title)))
+ repeatString := length - (4 + GetStringMaxWidth(title))
unevenRepeatString := repeatString % 2
ret += strings.Repeat(line, repeatString/2) + line + " " + title + " " + line + strings.Repeat(line, repeatString/2+unevenRepeatString)
diff --git a/vendor/github.com/pterm/pterm/logger.go b/vendor/github.com/pterm/pterm/logger.go
index 4fed9283..26eea5b0 100644
--- a/vendor/github.com/pterm/pterm/logger.go
+++ b/vendor/github.com/pterm/pterm/logger.go
@@ -200,6 +200,9 @@ func (l Logger) AppendKeyStyle(key string, style Style) *Logger {
// CanPrint checks if the logger can print a specific log level.
func (l Logger) CanPrint(level LogLevel) bool {
+ if l.Level == LogLevelDisabled {
+ return false
+ }
return l.Level <= level
}
@@ -261,7 +264,7 @@ func (l Logger) combineArgs(args ...[]LoggerArgument) []LoggerArgument {
}
func (l Logger) print(level LogLevel, msg string, args []LoggerArgument) {
- if l.Level > level {
+ if !l.CanPrint(level) {
return
}
diff --git a/vendor/github.com/pterm/pterm/multi_live_printer.go b/vendor/github.com/pterm/pterm/multi_live_printer.go
new file mode 100644
index 00000000..b9e0d0e8
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/multi_live_printer.go
@@ -0,0 +1,124 @@
+package pterm
+
+import (
+ "atomicgo.dev/schedule"
+ "bytes"
+ "io"
+ "os"
+ "strings"
+ "time"
+)
+
+var DefaultMultiPrinter = MultiPrinter{
+ printers: []LivePrinter{},
+ Writer: os.Stdout,
+ UpdateDelay: time.Millisecond * 200,
+
+ buffers: []*bytes.Buffer{},
+ area: DefaultArea,
+}
+
+type MultiPrinter struct {
+ IsActive bool
+ Writer io.Writer
+ UpdateDelay time.Duration
+
+ printers []LivePrinter
+ buffers []*bytes.Buffer
+ area AreaPrinter
+}
+
+// SetWriter sets the writer for the AreaPrinter.
+func (p *MultiPrinter) SetWriter(writer io.Writer) {
+ p.Writer = writer
+}
+
+// WithWriter returns a fork of the MultiPrinter with a new writer.
+func (p MultiPrinter) WithWriter(writer io.Writer) *MultiPrinter {
+ p.Writer = writer
+ return &p
+}
+
+// WithUpdateDelay returns a fork of the MultiPrinter with a new update delay.
+func (p MultiPrinter) WithUpdateDelay(delay time.Duration) *MultiPrinter {
+ p.UpdateDelay = delay
+ return &p
+}
+
+func (p *MultiPrinter) NewWriter() io.Writer {
+ buf := bytes.NewBufferString("")
+ p.buffers = append(p.buffers, buf)
+ return buf
+}
+
+// getString returns all buffers appended and separated by a newline.
+func (p *MultiPrinter) getString() string {
+ var buffer bytes.Buffer
+ for _, b := range p.buffers {
+ s := b.String()
+ s = strings.Trim(s, "\n")
+
+ parts := strings.Split(s, "\r") // only get the last override
+ s = parts[len(parts)-1]
+
+ // check if s is empty, if so get one part before, repeat until not empty
+ for s == "" {
+ parts = parts[:len(parts)-1]
+ s = parts[len(parts)-1]
+ }
+
+ s = strings.Trim(s, "\n\r")
+ buffer.WriteString(s)
+ buffer.WriteString("\n")
+ }
+ return buffer.String()
+}
+
+func (p *MultiPrinter) Start() (*MultiPrinter, error) {
+ p.IsActive = true
+ for _, printer := range p.printers {
+ printer.GenericStart()
+ }
+
+ schedule.Every(p.UpdateDelay, func() bool {
+ if !p.IsActive {
+ return false
+ }
+
+ p.area.Update(p.getString())
+
+ return true
+ })
+
+ return p, nil
+}
+
+func (p *MultiPrinter) Stop() (*MultiPrinter, error) {
+ p.IsActive = false
+ for _, printer := range p.printers {
+ printer.GenericStop()
+ }
+ time.Sleep(time.Millisecond * 20)
+ p.area.Update(p.getString())
+ p.area.Stop()
+
+ return p, nil
+}
+
+// GenericStart runs Start, but returns a LivePrinter.
+// This is used for the interface LivePrinter.
+// You most likely want to use Start instead of this in your program.
+func (p MultiPrinter) GenericStart() (*LivePrinter, error) {
+ p2, _ := p.Start()
+ lp := LivePrinter(p2)
+ return &lp, nil
+}
+
+// GenericStop runs Stop, but returns a LivePrinter.
+// This is used for the interface LivePrinter.
+// You most likely want to use Stop instead of this in your program.
+func (p MultiPrinter) GenericStop() (*LivePrinter, error) {
+ p2, _ := p.Stop()
+ lp := LivePrinter(p2)
+ return &lp, nil
+}
diff --git a/vendor/github.com/pterm/pterm/panel_printer.go b/vendor/github.com/pterm/pterm/panel_printer.go
index 709f7c80..090498e7 100644
--- a/vendor/github.com/pterm/pterm/panel_printer.go
+++ b/vendor/github.com/pterm/pterm/panel_printer.go
@@ -183,7 +183,7 @@ func (p PanelPrinter) Srender() (string, error) {
// Render prints the Template to the terminal.
func (p PanelPrinter) Render() error {
s, _ := p.Srender()
- Println(s)
+ Fprintln(p.Writer, s)
return nil
}
diff --git a/vendor/github.com/pterm/pterm/progressbar_printer.go b/vendor/github.com/pterm/pterm/progressbar_printer.go
index 2fb3f910..1cf4a0c2 100644
--- a/vendor/github.com/pterm/pterm/progressbar_printer.go
+++ b/vendor/github.com/pterm/pterm/progressbar_printer.go
@@ -1,8 +1,11 @@
package pterm
import (
+ "atomicgo.dev/cursor"
+ "atomicgo.dev/schedule"
+ "fmt"
"io"
- "strconv"
+ "math"
"strings"
"time"
@@ -15,23 +18,21 @@ import (
// Generally, there should only be one active ProgressbarPrinter at a time.
var ActiveProgressBarPrinters []*ProgressbarPrinter
-var (
- // DefaultProgressbar is the default ProgressbarPrinter.
- DefaultProgressbar = ProgressbarPrinter{
- Total: 100,
- BarCharacter: "█",
- LastCharacter: "█",
- ElapsedTimeRoundingFactor: time.Second,
- BarStyle: &ThemeDefault.ProgressbarBarStyle,
- TitleStyle: &ThemeDefault.ProgressbarTitleStyle,
- ShowTitle: true,
- ShowCount: true,
- ShowPercentage: true,
- ShowElapsedTime: true,
- BarFiller: " ",
- MaxWidth: 80,
- }
-)
+// DefaultProgressbar is the default ProgressbarPrinter.
+var DefaultProgressbar = ProgressbarPrinter{
+ Total: 100,
+ BarCharacter: "█",
+ LastCharacter: "█",
+ ElapsedTimeRoundingFactor: time.Second,
+ BarStyle: &ThemeDefault.ProgressbarBarStyle,
+ TitleStyle: &ThemeDefault.ProgressbarTitleStyle,
+ ShowTitle: true,
+ ShowCount: true,
+ ShowPercentage: true,
+ ShowElapsedTime: true,
+ BarFiller: Gray("█"),
+ MaxWidth: 80,
+}
// ProgressbarPrinter shows a progress animation in the terminal.
type ProgressbarPrinter struct {
@@ -55,7 +56,8 @@ type ProgressbarPrinter struct {
IsActive bool
- startedAt time.Time
+ startedAt time.Time
+ rerenderTask *schedule.Task
Writer io.Writer
}
@@ -158,6 +160,11 @@ func (p ProgressbarPrinter) WithWriter(writer io.Writer) *ProgressbarPrinter {
return &p
}
+// SetWriter sets the custom Writer.
+func (p *ProgressbarPrinter) SetWriter(writer io.Writer) {
+ p.Writer = writer
+}
+
// Increment current value by one.
func (p *ProgressbarPrinter) Increment() *ProgressbarPrinter {
p.Add(1)
@@ -173,6 +180,14 @@ func (p *ProgressbarPrinter) UpdateTitle(title string) *ProgressbarPrinter {
// This is the update logic, renders the progressbar
func (p *ProgressbarPrinter) updateProgress() *ProgressbarPrinter {
+ Fprinto(p.Writer, p.getString())
+ return p
+}
+
+func (p *ProgressbarPrinter) getString() string {
+ if !p.IsActive {
+ return ""
+ }
if p.TitleStyle == nil {
p.TitleStyle = NewStyle()
}
@@ -180,7 +195,7 @@ func (p *ProgressbarPrinter) updateProgress() *ProgressbarPrinter {
p.BarStyle = NewStyle()
}
if p.Total == 0 {
- return nil
+ return ""
}
var before string
@@ -195,25 +210,20 @@ func (p *ProgressbarPrinter) updateProgress() *ProgressbarPrinter {
width = p.MaxWidth
}
- currentPercentage := int(internal.PercentageRound(float64(int64(p.Total)), float64(int64(p.Current))))
-
- decoratorCount := Gray("[") + LightWhite(p.Current) + Gray("/") + LightWhite(p.Total) + Gray("]")
-
- decoratorCurrentPercentage := color.RGB(NewRGB(255, 0, 0).Fade(0, float32(p.Total), float32(p.Current), NewRGB(0, 255, 0)).GetValues()).
- Sprint(strconv.Itoa(currentPercentage) + "%")
-
- decoratorTitle := p.TitleStyle.Sprint(p.Title)
-
if p.ShowTitle {
- before += decoratorTitle + " "
+ before += p.TitleStyle.Sprint(p.Title) + " "
}
if p.ShowCount {
- before += decoratorCount + " "
+ padding := 1 + int(math.Log10(float64(p.Total)))
+ before += Gray("[") + LightWhite(fmt.Sprintf("%0*d", padding, p.Current)) + Gray("/") + LightWhite(p.Total) + Gray("]") + " "
}
after += " "
if p.ShowPercentage {
+ currentPercentage := int(internal.PercentageRound(float64(int64(p.Total)), float64(int64(p.Current))))
+ decoratorCurrentPercentage := color.RGB(NewRGB(255, 0, 0).Fade(0, float32(p.Total), float32(p.Current), NewRGB(0, 255, 0)).GetValues()).
+ Sprintf("%3d%%", currentPercentage)
after += decoratorCurrentPercentage + " "
}
if p.ShowElapsedTime {
@@ -228,17 +238,12 @@ func (p *ProgressbarPrinter) updateProgress() *ProgressbarPrinter {
barFiller = strings.Repeat(p.BarFiller, barMaxLength-barCurrentLength)
}
- var bar string
+ bar := barFiller
if barCurrentLength > 0 {
- bar = p.BarStyle.Sprint(strings.Repeat(p.BarCharacter, barCurrentLength)+p.LastCharacter) + barFiller
- } else {
- bar = ""
+ bar = p.BarStyle.Sprint(strings.Repeat(p.BarCharacter, barCurrentLength)+p.LastCharacter) + bar
}
- if !RawOutput {
- Fprinto(p.Writer, before+bar+after)
- }
- return p
+ return before + bar + after
}
// Add to current value.
@@ -251,6 +256,8 @@ func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter {
p.updateProgress()
if p.Current >= p.Total {
+ p.Total = p.Current
+ p.updateProgress()
p.Stop()
}
return p
@@ -258,6 +265,7 @@ func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter {
// Start the ProgressbarPrinter.
func (p ProgressbarPrinter) Start(title ...interface{}) (*ProgressbarPrinter, error) {
+ cursor.Hide()
if RawOutput && p.ShowTitle {
Fprintln(p.Writer, p.Title)
}
@@ -270,11 +278,23 @@ func (p ProgressbarPrinter) Start(title ...interface{}) (*ProgressbarPrinter, er
p.updateProgress()
+ if p.ShowElapsedTime {
+ p.rerenderTask = schedule.Every(time.Second, func() bool {
+ p.updateProgress()
+ return true
+ })
+ }
+
return &p, nil
}
// Stop the ProgressbarPrinter.
func (p *ProgressbarPrinter) Stop() (*ProgressbarPrinter, error) {
+ if p.rerenderTask != nil && p.rerenderTask.IsActive() {
+ p.rerenderTask.Stop()
+ }
+ cursor.Show()
+
if !p.IsActive {
return p, nil
}
@@ -291,7 +311,7 @@ func (p *ProgressbarPrinter) Stop() (*ProgressbarPrinter, error) {
// GenericStart runs Start, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Start instead of this in your program.
-func (p ProgressbarPrinter) GenericStart() (*LivePrinter, error) {
+func (p *ProgressbarPrinter) GenericStart() (*LivePrinter, error) {
p2, _ := p.Start()
lp := LivePrinter(p2)
return &lp, nil
@@ -300,7 +320,7 @@ func (p ProgressbarPrinter) GenericStart() (*LivePrinter, error) {
// GenericStop runs Stop, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Stop instead of this in your program.
-func (p ProgressbarPrinter) GenericStop() (*LivePrinter, error) {
+func (p *ProgressbarPrinter) GenericStop() (*LivePrinter, error) {
p2, _ := p.Stop()
lp := LivePrinter(p2)
return &lp, nil
diff --git a/vendor/github.com/pterm/pterm/pterm.go b/vendor/github.com/pterm/pterm/pterm.go
index b42a1140..f9d76ca3 100644
--- a/vendor/github.com/pterm/pterm/pterm.go
+++ b/vendor/github.com/pterm/pterm/pterm.go
@@ -63,7 +63,7 @@ func DisableStyling() {
DisableColor()
}
-// RecalculateTerminalSize updates already initialized terminal dimensions. Has to be called after a termina resize to guarantee proper rendering. Applies only to new instances.
+// RecalculateTerminalSize updates already initialized terminal dimensions. Has to be called after a terminal resize to guarantee proper rendering. Applies only to new instances.
func RecalculateTerminalSize() {
// keep in sync with DefaultBarChart
DefaultBarChart.Width = GetTerminalWidth() * 2 / 3
diff --git a/vendor/github.com/pterm/pterm/rgb.go b/vendor/github.com/pterm/pterm/rgb.go
index 23b2fa48..a35dd1a0 100644
--- a/vendor/github.com/pterm/pterm/rgb.go
+++ b/vendor/github.com/pterm/pterm/rgb.go
@@ -18,6 +18,133 @@ type RGB struct {
Background bool
}
+type RGBStyle struct {
+ Options []Color
+ Foreground, Background RGB
+
+ hasBg bool
+}
+
+// NewRGBStyle returns a new RGBStyle.
+// The foreground color is required, the background color is optional.
+// The colors will be set as is, ignoring the RGB.Background property.
+func NewRGBStyle(foreground RGB, background ...RGB) RGBStyle {
+ var s RGBStyle
+ s.Foreground = foreground
+ if len(background) > 0 {
+ s.Background = background[0]
+ s.hasBg = true
+ }
+ return s
+}
+
+// AddOptions adds options to the RGBStyle.
+func (p RGBStyle) AddOptions(opts ...Color) RGBStyle {
+ p.Options = append(p.Options, opts...)
+ return p
+}
+
+// Print formats using the default formats for its operands and writes to standard output.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+func (p RGBStyle) Print(a ...interface{}) *TextPrinter {
+ Print(p.Sprint(a...))
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// Println formats using the default formats for its operands and writes to standard output.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func (p RGBStyle) Println(a ...interface{}) *TextPrinter {
+ Println(p.Sprint(a...))
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// Printf formats according to a format specifier and writes to standard output.
+// It returns the number of bytes written and any write error encountered.
+func (p RGBStyle) Printf(format string, a ...interface{}) *TextPrinter {
+ Printf(format, p.Sprint(a...))
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// Printfln formats according to a format specifier and writes to standard output.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func (p RGBStyle) Printfln(format string, a ...interface{}) *TextPrinter {
+ Printf(format, p.Sprint(a...))
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// PrintOnError prints every error which is not nil.
+// If every error is nil, nothing will be printed.
+// This can be used for simple error checking.
+func (p RGBStyle) PrintOnError(a ...interface{}) *TextPrinter {
+ for _, arg := range a {
+ if err, ok := arg.(error); ok {
+ if err != nil {
+ p.Println(err)
+ }
+ }
+ }
+
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// PrintOnErrorf wraps every error which is not nil and prints it.
+// If every error is nil, nothing will be printed.
+// This can be used for simple error checking.
+func (p RGBStyle) PrintOnErrorf(format string, a ...interface{}) *TextPrinter {
+ for _, arg := range a {
+ if err, ok := arg.(error); ok {
+ if err != nil {
+ p.Println(fmt.Errorf(format, err))
+ }
+ }
+ }
+
+ tp := TextPrinter(p)
+ return &tp
+}
+
+// Sprint formats using the default formats for its operands and returns the resulting string.
+// Spaces are added between operands when neither is a string.
+func (p RGBStyle) Sprint(a ...interface{}) string {
+ var rgbStyle *color.RGBStyle
+ if !p.hasBg {
+ rgbStyle = color.NewRGBStyle(color.RGB(p.Foreground.R, p.Foreground.G, p.Foreground.B))
+ } else {
+ rgbStyle = color.NewRGBStyle(color.RGB(p.Foreground.R, p.Foreground.G, p.Foreground.B), color.RGB(p.Background.R, p.Background.G, p.Background.B))
+ }
+ if len(p.Options) > 0 {
+ for _, opt := range p.Options {
+ rgbStyle.AddOpts(color.Color(opt))
+ }
+ }
+ return rgbStyle.Sprint(a...)
+}
+
+// Sprintln formats using the default formats for its operands and returns the resulting string.
+// Spaces are always added between operands and a newline is appended.
+func (p RGBStyle) Sprintln(a ...interface{}) string {
+ return p.Sprint(a...) + "\n"
+}
+
+// Sprintf formats according to a format specifier and returns the resulting string.
+func (p RGBStyle) Sprintf(format string, a ...interface{}) string {
+ return fmt.Sprintf(format, p.Sprint(a...))
+}
+
+// Sprintfln formats according to a format specifier and returns the resulting string.
+// Spaces are always added between operands and a newline is appended.
+func (p RGBStyle) Sprintfln(format string, a ...interface{}) string {
+ return fmt.Sprintf(format, p.Sprint(a...)) + "\n"
+}
+
// GetValues returns the RGB values separately.
func (p RGB) GetValues() (r, g, b uint8) {
return p.R, p.G, p.B
@@ -160,3 +287,11 @@ func (p RGB) PrintOnErrorf(format string, a ...interface{}) *TextPrinter {
tp := TextPrinter(p)
return &tp
}
+
+func (p RGB) ToRGBStyle() RGBStyle {
+ if p.Background {
+ return RGBStyle{Background: p}
+ }
+
+ return RGBStyle{Foreground: p}
+}
diff --git a/vendor/github.com/pterm/pterm/slog_handler.go b/vendor/github.com/pterm/pterm/slog_handler.go
new file mode 100644
index 00000000..a2b2acfe
--- /dev/null
+++ b/vendor/github.com/pterm/pterm/slog_handler.go
@@ -0,0 +1,90 @@
+package pterm
+
+import (
+ "context"
+
+ "log/slog"
+)
+
+type SlogHandler struct {
+ logger *Logger
+ attrs []slog.Attr
+}
+
+// Enabled returns true if the given level is enabled.
+func (s *SlogHandler) Enabled(ctx context.Context, level slog.Level) bool {
+ switch level {
+ case slog.LevelDebug:
+ return s.logger.CanPrint(LogLevelDebug)
+ case slog.LevelInfo:
+ return s.logger.CanPrint(LogLevelInfo)
+ case slog.LevelWarn:
+ return s.logger.CanPrint(LogLevelWarn)
+ case slog.LevelError:
+ return s.logger.CanPrint(LogLevelError)
+ }
+ return false
+}
+
+// Handle handles the given record.
+func (s *SlogHandler) Handle(ctx context.Context, record slog.Record) error {
+ level := record.Level
+ message := record.Message
+
+ // Convert slog Attrs to a map.
+ keyValsMap := make(map[string]interface{})
+
+ record.Attrs(func(attr slog.Attr) bool {
+ keyValsMap[attr.Key] = attr.Value
+ return true
+ })
+
+ for _, attr := range s.attrs {
+ keyValsMap[attr.Key] = attr.Value
+ }
+
+ args := s.logger.ArgsFromMap(keyValsMap)
+
+ // Wrapping args inside another slice to match [][]LoggerArgument
+ argsWrapped := [][]LoggerArgument{args}
+
+ logger := s.logger
+
+ // Must be done here, see https://github.com/pterm/pterm/issues/608#issuecomment-1876001650
+ if logger.CallerOffset == 0 {
+ logger = logger.WithCallerOffset(3)
+ }
+
+ switch level {
+ case slog.LevelDebug:
+ logger.Debug(message, argsWrapped...)
+ case slog.LevelInfo:
+ logger.Info(message, argsWrapped...)
+ case slog.LevelWarn:
+ logger.Warn(message, argsWrapped...)
+ case slog.LevelError:
+ logger.Error(message, argsWrapped...)
+ default:
+ logger.Print(message, argsWrapped...)
+ }
+
+ return nil
+}
+
+// WithAttrs returns a new handler with the given attributes.
+func (s *SlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+ newS := *s
+ newS.attrs = attrs
+ return &newS
+}
+
+// WithGroup is not yet supported.
+func (s *SlogHandler) WithGroup(name string) slog.Handler {
+ // Grouping is not yet supported by pterm.
+ return s
+}
+
+// NewSlogHandler returns a new logging handler that can be intrgrated with log/slog.
+func NewSlogHandler(logger *Logger) *SlogHandler {
+ return &SlogHandler{logger: logger}
+}
diff --git a/vendor/github.com/pterm/pterm/spinner_printer.go b/vendor/github.com/pterm/pterm/spinner_printer.go
index 82b84af7..044b6976 100644
--- a/vendor/github.com/pterm/pterm/spinner_printer.go
+++ b/vendor/github.com/pterm/pterm/spinner_printer.go
@@ -110,15 +110,18 @@ func (p SpinnerPrinter) WithWriter(writer io.Writer) *SpinnerPrinter {
return &p
}
+// SetWriter sets the custom Writer.
+func (p *SpinnerPrinter) SetWriter(writer io.Writer) {
+ p.Writer = writer
+}
+
// UpdateText updates the message of the active SpinnerPrinter.
// Can be used live.
func (s *SpinnerPrinter) UpdateText(text string) {
s.Text = text
if !RawOutput {
- fClearLine(s.Writer)
Fprinto(s.Writer, s.Style.Sprint(s.currentSequence)+" "+s.MessageStyle.Sprint(s.Text))
- }
- if RawOutput {
+ } else {
Fprintln(s.Writer, s.Text)
}
}
@@ -152,7 +155,6 @@ func (s SpinnerPrinter) Start(text ...interface{}) (*SpinnerPrinter, error) {
if s.ShowTimer {
timer = " (" + time.Since(s.startedAt).Round(s.TimerRoundingFactor).String() + ")"
}
- fClearLine(s.Writer)
Fprinto(s.Writer, s.Style.Sprint(seq)+" "+s.MessageStyle.Sprint(s.Text)+s.TimerStyle.Sprint(timer))
s.currentSequence = seq
time.Sleep(s.Delay)
@@ -182,8 +184,8 @@ func (s *SpinnerPrinter) Stop() error {
// This is used for the interface LivePrinter.
// You most likely want to use Start instead of this in your program.
func (s *SpinnerPrinter) GenericStart() (*LivePrinter, error) {
- _, _ = s.Start()
- lp := LivePrinter(s)
+ p2, _ := s.Start()
+ lp := LivePrinter(p2)
return &lp, nil
}
diff --git a/vendor/github.com/pterm/pterm/table_printer.go b/vendor/github.com/pterm/pterm/table_printer.go
index cbef5019..54e8965a 100644
--- a/vendor/github.com/pterm/pterm/table_printer.go
+++ b/vendor/github.com/pterm/pterm/table_printer.go
@@ -2,9 +2,10 @@ package pterm
import (
"encoding/csv"
- "github.com/pterm/pterm/internal"
"io"
"strings"
+
+ "github.com/pterm/pterm/internal"
)
// DefaultTable contains standards, which can be used to print a TablePrinter.
@@ -183,8 +184,8 @@ func (p TablePrinter) Srender() (string, error) {
c.lines = strings.Split(cRaw, "\n")
c.height = len(c.lines)
for _, l := range c.lines {
- if internal.GetStringMaxWidth(l) > c.width {
- c.width = internal.GetStringMaxWidth(l)
+ if maxWidth := internal.GetStringMaxWidth(l); maxWidth > c.width {
+ c.width = maxWidth
}
}
r.cells = append(r.cells, c)
@@ -262,7 +263,7 @@ func (p TablePrinter) renderRow(t table, r row) string {
}
if i < len(c.lines) {
- s += strings.TrimSpace(c.lines[i])
+ s += c.lines[i]
}
if j < len(r.cells)-1 {
diff --git a/vendor/github.com/pterm/pterm/theme.go b/vendor/github.com/pterm/pterm/theme.go
index 22466ea7..91594c8c 100644
--- a/vendor/github.com/pterm/pterm/theme.go
+++ b/vendor/github.com/pterm/pterm/theme.go
@@ -30,6 +30,9 @@ var (
TableStyle: Style{FgDefault},
TableHeaderStyle: Style{FgLightCyan},
TableSeparatorStyle: Style{FgGray},
+ HeatmapStyle: Style{FgDefault},
+ HeatmapHeaderStyle: Style{FgLightCyan},
+ HeatmapSeparatorStyle: Style{FgDefault},
SectionStyle: Style{Bold, FgYellow},
BulletListTextStyle: Style{FgDefault},
BulletListBulletStyle: Style{FgGray},
@@ -81,6 +84,9 @@ type Theme struct {
TableStyle Style
TableHeaderStyle Style
TableSeparatorStyle Style
+ HeatmapStyle Style
+ HeatmapHeaderStyle Style
+ HeatmapSeparatorStyle Style
SectionStyle Style
BulletListTextStyle Style
BulletListBulletStyle Style
diff --git a/vendor/github.com/pterm/pterm/tree_printer.go b/vendor/github.com/pterm/pterm/tree_printer.go
index fe10c133..113f9202 100644
--- a/vendor/github.com/pterm/pterm/tree_printer.go
+++ b/vendor/github.com/pterm/pterm/tree_printer.go
@@ -124,7 +124,7 @@ func (p TreePrinter) Srender() (string, error) {
var result string
if p.Root.Text != "" {
- result += p.Root.Text + "\n"
+ result += p.TextStyle.Sprint(p.Root.Text) + "\n"
}
result += walkOverTree(p.Root.Children, p, "")
return result, nil
diff --git a/vendor/github.com/sheldonhull/magetools/ci/ci.go b/vendor/github.com/sheldonhull/magetools/ci/ci.go
index 670dadcb..162c3f79 100644
--- a/vendor/github.com/sheldonhull/magetools/ci/ci.go
+++ b/vendor/github.com/sheldonhull/magetools/ci/ci.go
@@ -16,19 +16,35 @@ import (
// IsCI will set the global variable for IsCI based on lookup of the environment variable.
func IsCI() bool {
magetoolsutils.CheckPtermDebug()
+
_, exists := os.LookupEnv("AGENT_ID")
if exists {
pterm.Info.Println("Azure DevOps match based on AGENT_ID. Setting IS_CI = 1")
return true
}
+ _, exists = os.LookupEnv("GITLAB_CI")
+ if exists {
+ pterm.Info.Println("Gitlab Runner match based on [GITLAB_CI] env variable. Setting IS_CI = 1")
+
+ return true
+ }
+
_, exists = os.LookupEnv("NETLIFY")
if exists {
pterm.Info.Println("Netlify match based on [NETLIFY] environment. Setting IS_CI = 1")
return true
}
+ _, exists = os.LookupEnv("GITHUB_ACTIONS")
+ if exists {
+ pterm.Info.Println("GitHub Actions match based on [GITHUB_ACTIONS] environment. Setting IS_CI = 1")
+
+ return true
+ }
+
// CI is also set for Netlify, so it's important to run the NETFLIFY check before the CI check.
+ // It might be used by others since it's so common so let's leave this check to the very end.
_, exists = os.LookupEnv("CI")
if exists {
pterm.Info.Println("GitHub actions match based on [CI] env variable. Setting IS_CI = 1")
diff --git a/vendor/github.com/sheldonhull/magetools/gotools/gotools.go b/vendor/github.com/sheldonhull/magetools/gotools/gotools.go
index f952722b..3bf5cc17 100644
--- a/vendor/github.com/sheldonhull/magetools/gotools/gotools.go
+++ b/vendor/github.com/sheldonhull/magetools/gotools/gotools.go
@@ -270,7 +270,7 @@ func (Go) Lint() error {
Printfln("unable to find %s: %v", appgolangcilint, err)
return err
}
- pterm.Info.Printfln("gotestsum found: %s", golangcilint)
+ pterm.Info.Printfln("golangci-lint found: %s", golangcilint)
if err := sh.RunV(golangcilint, "run"); err != nil {
pterm.Error.WithShowLineNumber(true).WithLineNumberOffset(1).Println("golangci-lint failure")
diff --git a/vendor/github.com/sheldonhull/magetools/pkg/magetoolsutils/magetoolsutils.go b/vendor/github.com/sheldonhull/magetools/pkg/magetoolsutils/magetoolsutils.go
index 20b6762b..ca60bfe7 100644
--- a/vendor/github.com/sheldonhull/magetools/pkg/magetoolsutils/magetoolsutils.go
+++ b/vendor/github.com/sheldonhull/magetools/pkg/magetoolsutils/magetoolsutils.go
@@ -32,7 +32,7 @@ func CheckPtermDebug() { //nolint:cyclop,funlen // cyclop,funlen: i'm sure there
}
if debug {
pterm.Debug.Println("strconv.ParseBool(\"DEBUG\") true, enabling debug output and exiting")
- pterm.Info.Println("DEBUG env var detected, setting tasks to debug level output")
+ pterm.Debug.Println("DEBUG env var detected, setting tasks to debug level output")
pterm.EnableDebugMessages()
return
}
@@ -50,7 +50,7 @@ func CheckPtermDebug() { //nolint:cyclop,funlen // cyclop,funlen: i'm sure there
if debug {
pterm.Debug.Println("strconv.ParseBool(\"SYSTEM_DEBUG\") true, enabling debug output and exiting")
- pterm.Info.Println("SYSTEM_DEBUG env var detected, setting tasks to debug level output")
+ pterm.Debug.Println("SYSTEM_DEBUG env var detected, setting tasks to debug level output")
pterm.EnableDebugMessages()
return
}
@@ -74,7 +74,7 @@ func CheckPtermDebug() { //nolint:cyclop,funlen // cyclop,funlen: i'm sure there
}
if mg.Verbose() {
pterm.Debug.Printfln("mg.Verbose() true, setting pterm.EnableDebugMessages()")
- pterm.Info.Println("mg.Verbose() true (-v or MAGEFILE_VERBOSE env var), setting tasks to debug level output")
+ pterm.Debug.Println("mg.Verbose() true (-v or MAGEFILE_VERBOSE env var), setting tasks to debug level output")
pterm.EnableDebugMessages()
return
}
diff --git a/vendor/github.com/sirupsen/logrus/.gitignore b/vendor/github.com/sirupsen/logrus/.gitignore
index 6b7d7d1e..1fb13abe 100644
--- a/vendor/github.com/sirupsen/logrus/.gitignore
+++ b/vendor/github.com/sirupsen/logrus/.gitignore
@@ -1,2 +1,4 @@
logrus
vendor
+
+.idea/
diff --git a/vendor/github.com/sirupsen/logrus/.golangci.yml b/vendor/github.com/sirupsen/logrus/.golangci.yml
new file mode 100644
index 00000000..65dc2850
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/.golangci.yml
@@ -0,0 +1,40 @@
+run:
+ # do not run on test files yet
+ tests: false
+
+# all available settings of specific linters
+linters-settings:
+ errcheck:
+ # report about not checking of errors in type assetions: `a := b.(MyStruct)`;
+ # default is false: such cases aren't reported by default.
+ check-type-assertions: false
+
+ # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`;
+ # default is false: such cases aren't reported by default.
+ check-blank: false
+
+ lll:
+ line-length: 100
+ tab-width: 4
+
+ prealloc:
+ simple: false
+ range-loops: false
+ for-loops: false
+
+ whitespace:
+ multi-if: false # Enforces newlines (or comments) after every multi-line if statement
+ multi-func: false # Enforces newlines (or comments) after every multi-line function signature
+
+linters:
+ enable:
+ - megacheck
+ - govet
+ disable:
+ - maligned
+ - prealloc
+ disable-all: false
+ presets:
+ - bugs
+ - unused
+ fast: false
diff --git a/vendor/github.com/sirupsen/logrus/.travis.yml b/vendor/github.com/sirupsen/logrus/.travis.yml
index 1f953beb..c1dbd5a3 100644
--- a/vendor/github.com/sirupsen/logrus/.travis.yml
+++ b/vendor/github.com/sirupsen/logrus/.travis.yml
@@ -1,51 +1,15 @@
language: go
+go_import_path: github.com/sirupsen/logrus
+git:
+ depth: 1
env:
- - GOMAXPROCS=4 GORACE=halt_on_error=1
-matrix:
- include:
- - go: 1.10.x
- install:
- - go get github.com/stretchr/testify/assert
- - go get golang.org/x/crypto/ssh/terminal
- - go get golang.org/x/sys/unix
- - go get golang.org/x/sys/windows
- script:
- - go test -race -v ./...
- - go: 1.11.x
- env: GO111MODULE=on
- install:
- - go mod download
- script:
- - go test -race -v ./...
- - go: 1.11.x
- env: GO111MODULE=off
- install:
- - go get github.com/stretchr/testify/assert
- - go get golang.org/x/crypto/ssh/terminal
- - go get golang.org/x/sys/unix
- - go get golang.org/x/sys/windows
- script:
- - go test -race -v ./...
- - go: 1.10.x
- install:
- - go get github.com/stretchr/testify/assert
- - go get golang.org/x/crypto/ssh/terminal
- - go get golang.org/x/sys/unix
- - go get golang.org/x/sys/windows
- script:
- - go test -race -v -tags appengine ./...
- - go: 1.11.x
- env: GO111MODULE=on
- install:
- - go mod download
- script:
- - go test -race -v -tags appengine ./...
- - go: 1.11.x
- env: GO111MODULE=off
- install:
- - go get github.com/stretchr/testify/assert
- - go get golang.org/x/crypto/ssh/terminal
- - go get golang.org/x/sys/unix
- - go get golang.org/x/sys/windows
- script:
- - go test -race -v -tags appengine ./...
+ - GO111MODULE=on
+go: 1.15.x
+os: linux
+install:
+ - ./travis/install.sh
+script:
+ - cd ci
+ - go run mage.go -v -w ../ crossBuild
+ - go run mage.go -v -w ../ lint
+ - go run mage.go -v -w ../ test
diff --git a/vendor/github.com/sirupsen/logrus/CHANGELOG.md b/vendor/github.com/sirupsen/logrus/CHANGELOG.md
index cb85d9f9..7567f612 100644
--- a/vendor/github.com/sirupsen/logrus/CHANGELOG.md
+++ b/vendor/github.com/sirupsen/logrus/CHANGELOG.md
@@ -1,3 +1,97 @@
+# 1.8.1
+Code quality:
+ * move magefile in its own subdir/submodule to remove magefile dependency on logrus consumer
+ * improve timestamp format documentation
+
+Fixes:
+ * fix race condition on logger hooks
+
+
+# 1.8.0
+
+Correct versioning number replacing v1.7.1.
+
+# 1.7.1
+
+Beware this release has introduced a new public API and its semver is therefore incorrect.
+
+Code quality:
+ * use go 1.15 in travis
+ * use magefile as task runner
+
+Fixes:
+ * small fixes about new go 1.13 error formatting system
+ * Fix for long time race condiction with mutating data hooks
+
+Features:
+ * build support for zos
+
+# 1.7.0
+Fixes:
+ * the dependency toward a windows terminal library has been removed
+
+Features:
+ * a new buffer pool management API has been added
+ * a set of `Fn()` functions have been added
+
+# 1.6.0
+Fixes:
+ * end of line cleanup
+ * revert the entry concurrency bug fix whic leads to deadlock under some circumstances
+ * update dependency on go-windows-terminal-sequences to fix a crash with go 1.14
+
+Features:
+ * add an option to the `TextFormatter` to completely disable fields quoting
+
+# 1.5.0
+Code quality:
+ * add golangci linter run on travis
+
+Fixes:
+ * add mutex for hooks concurrent access on `Entry` data
+ * caller function field for go1.14
+ * fix build issue for gopherjs target
+
+Feature:
+ * add an hooks/writer sub-package whose goal is to split output on different stream depending on the trace level
+ * add a `DisableHTMLEscape` option in the `JSONFormatter`
+ * add `ForceQuote` and `PadLevelText` options in the `TextFormatter`
+
+# 1.4.2
+ * Fixes build break for plan9, nacl, solaris
+# 1.4.1
+This new release introduces:
+ * Enhance TextFormatter to not print caller information when they are empty (#944)
+ * Remove dependency on golang.org/x/crypto (#932, #943)
+
+Fixes:
+ * Fix Entry.WithContext method to return a copy of the initial entry (#941)
+
+# 1.4.0
+This new release introduces:
+ * Add `DeferExitHandler`, similar to `RegisterExitHandler` but prepending the handler to the list of handlers (semantically like `defer`) (#848).
+ * Add `CallerPrettyfier` to `JSONFormatter` and `TextFormatter` (#909, #911)
+ * Add `Entry.WithContext()` and `Entry.Context`, to set a context on entries to be used e.g. in hooks (#919).
+
+Fixes:
+ * Fix wrong method calls `Logger.Print` and `Logger.Warningln` (#893).
+ * Update `Entry.Logf` to not do string formatting unless the log level is enabled (#903)
+ * Fix infinite recursion on unknown `Level.String()` (#907)
+ * Fix race condition in `getCaller` (#916).
+
+
+# 1.3.0
+This new release introduces:
+ * Log, Logf, Logln functions for Logger and Entry that take a Level
+
+Fixes:
+ * Building prometheus node_exporter on AIX (#840)
+ * Race condition in TextFormatter (#468)
+ * Travis CI import path (#868)
+ * Remove coloured output on Windows (#862)
+ * Pointer to func as field in JSONFormatter (#870)
+ * Properly marshal Levels (#873)
+
# 1.2.0
This new release introduces:
* A new method `SetReportCaller` in the `Logger` to enable the file, line and calling function from which the trace has been issued
diff --git a/vendor/github.com/sirupsen/logrus/README.md b/vendor/github.com/sirupsen/logrus/README.md
index 093bb13f..d1d4a85f 100644
--- a/vendor/github.com/sirupsen/logrus/README.md
+++ b/vendor/github.com/sirupsen/logrus/README.md
@@ -1,8 +1,28 @@
-# Logrus 
[](https://travis-ci.org/sirupsen/logrus) [](https://godoc.org/github.com/sirupsen/logrus)
+# Logrus [](https://github.com/sirupsen/logrus/actions?query=workflow%3ACI) [](https://travis-ci.org/sirupsen/logrus) [](https://pkg.go.dev/github.com/sirupsen/logrus)
Logrus is a structured logger for Go (golang), completely API compatible with
the standard library logger.
+**Logrus is in maintenance-mode.** We will not be introducing new features. It's
+simply too hard to do in a way that won't break many people's projects, which is
+the last thing you want from your Logging library (again...).
+
+This does not mean Logrus is dead. Logrus will continue to be maintained for
+security, (backwards compatible) bug fixes, and performance (where we are
+limited by the interface).
+
+I believe Logrus' biggest contribution is to have played a part in today's
+widespread use of structured logging in Golang. There doesn't seem to be a
+reason to do a major, breaking iteration into Logrus V2, since the fantastic Go
+community has built those independently. Many fantastic alternatives have sprung
+up. Logrus would look like those, had it been re-designed with what we know
+about structured logging in Go today. Check out, for example,
+[Zerolog][zerolog], [Zap][zap], and [Apex][apex].
+
+[zerolog]: https://github.com/rs/zerolog
+[zap]: https://github.com/uber-go/zap
+[apex]: https://github.com/apex/log
+
**Seeing weird case-sensitive problems?** It's in the past been possible to
import Logrus as both upper- and lower-case. Due to the Go package environment,
this caused issues in the community and we needed a standard. Some environments
@@ -15,11 +35,6 @@ comments](https://github.com/sirupsen/logrus/issues/553#issuecomment-306591437).
For an in-depth explanation of the casing issue, see [this
comment](https://github.com/sirupsen/logrus/issues/570#issuecomment-313933276).
-**Are you interested in assisting in maintaining Logrus?** Currently I have a
-lot of obligations, and I am unable to provide Logrus with the maintainership it
-needs. If you'd like to help, please reach out to me at `simon at author's
-username dot com`.
-
Nicely color-coded in development (when a TTY is attached, otherwise just
plain text):
@@ -28,7 +43,7 @@ plain text):
With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
or Splunk:
-```json
+```text
{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
@@ -84,7 +99,7 @@ time="2015-03-26T01:27:38-04:00" level=fatal method=github.com/sirupsen/arcticcr
```
Note that this does add measurable overhead - the cost will depend on the version of Go, but is
between 20 and 40% in recent tests with 1.6 and 1.7. You can validate this in your
-environment via benchmarks:
+environment via benchmarks:
```
go test -bench=.*CallerTracing
```
@@ -187,7 +202,7 @@ func main() {
log.Out = os.Stdout
// You could set this to any `io.Writer` such as a file
- // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
+ // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
// if err == nil {
// log.Out = file
// } else {
@@ -272,7 +287,7 @@ func init() {
```
Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
-A list of currently known of service hook can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks)
+A list of currently known service hooks can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks)
#### Level logging
@@ -302,6 +317,8 @@ log.SetLevel(log.InfoLevel)
It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
environment if your application has that.
+Note: If you want different log levels for global (`log.SetLevel(...)`) and syslog logging, please check the [syslog hook README](hooks/syslog/README.md#different-log-levels-for-local-and-remote-logging).
+
#### Entries
Besides the fields added with `WithField` or `WithFields` some fields are
@@ -326,7 +343,7 @@ import (
log "github.com/sirupsen/logrus"
)
-init() {
+func init() {
// do something here to set environment depending on an environment variable
// or command-line flag
if Environment == "production" {
@@ -354,6 +371,7 @@ The built-in logging formatters are:
[github.com/mattn/go-colorable](https://github.com/mattn/go-colorable).
* When colors are enabled, levels are truncated to 4 characters by default. To disable
truncation set the `DisableLevelTruncation` field to `true`.
+ * When outputting to a TTY, it's often helpful to visually scan down a column where all the levels are the same width. Setting the `PadLevelText` field to `true` enables this behavior, by adding padding to the level text.
* All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter).
* `logrus.JSONFormatter`. Logs fields as JSON.
* All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter).
@@ -361,9 +379,13 @@ The built-in logging formatters are:
Third party logging formatters:
* [`FluentdFormatter`](https://github.com/joonix/log). Formats entries that can be parsed by Kubernetes and Google Container Engine.
+* [`GELF`](https://github.com/fabienm/go-logrus-formatters). Formats entries so they comply to Graylog's [GELF 1.1 specification](http://docs.graylog.org/en/2.4/pages/gelf.html).
* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.
* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
-* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
+* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the Power of Zalgo.
+* [`nested-logrus-formatter`](https://github.com/antonfisher/nested-logrus-formatter). Converts logrus fields to a nested structure.
+* [`powerful-logrus-formatter`](https://github.com/zput/zxcTool). get fileName, log's line number and the latest function's name when print log; Sava log to files.
+* [`caption-json-formatter`](https://github.com/nolleh/caption_json_formatter). logrus's message json formatter with human-readable caption added.
You can define your formatter by implementing the `Formatter` interface,
requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
@@ -382,7 +404,7 @@ func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
// source of the official loggers.
serialized, err := json.Marshal(entry.Data)
if err != nil {
- return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %w", err)
}
return append(serialized, '\n'), nil
}
@@ -428,14 +450,14 @@ entries. It should not be a feature of the application-level logger.
| Tool | Description |
| ---- | ----------- |
-|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
+|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will be generated with different configs in different environments.|
|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper around Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) |
#### Testing
Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
-* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
+* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just adds the `test` hook
* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
```go
@@ -463,7 +485,7 @@ func TestSomething(t*testing.T){
Logrus can register one or more functions that will be called when any `fatal`
level message is logged. The registered handlers will be executed before
-logrus performs a `os.Exit(1)`. This behavior may be helpful if callers need
+logrus performs an `os.Exit(1)`. This behavior may be helpful if callers need
to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted.
```
@@ -488,6 +510,6 @@ Situation when locking is not needed includes:
1) logger.Out is protected by locks.
- 2) logger.Out is a os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allow multi-thread/multi-process writing)
+ 2) logger.Out is an os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allows multi-thread/multi-process writing)
(Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/)
diff --git a/vendor/github.com/sirupsen/logrus/alt_exit.go b/vendor/github.com/sirupsen/logrus/alt_exit.go
index 8af90637..8fd189e1 100644
--- a/vendor/github.com/sirupsen/logrus/alt_exit.go
+++ b/vendor/github.com/sirupsen/logrus/alt_exit.go
@@ -51,9 +51,9 @@ func Exit(code int) {
os.Exit(code)
}
-// RegisterExitHandler adds a Logrus Exit handler, call logrus.Exit to invoke
-// all handlers. The handlers will also be invoked when any Fatal log entry is
-// made.
+// RegisterExitHandler appends a Logrus Exit handler to the list of handlers,
+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
+// any Fatal log entry is made.
//
// This method is useful when a caller wishes to use logrus to log a fatal
// message but also needs to gracefully shutdown. An example usecase could be
@@ -62,3 +62,15 @@ func Exit(code int) {
func RegisterExitHandler(handler func()) {
handlers = append(handlers, handler)
}
+
+// DeferExitHandler prepends a Logrus Exit handler to the list of handlers,
+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
+// any Fatal log entry is made.
+//
+// This method is useful when a caller wishes to use logrus to log a fatal
+// message but also needs to gracefully shutdown. An example usecase could be
+// closing database connections, or sending a alert that the application is
+// closing.
+func DeferExitHandler(handler func()) {
+ handlers = append([]func(){handler}, handlers...)
+}
diff --git a/vendor/github.com/sirupsen/logrus/appveyor.yml b/vendor/github.com/sirupsen/logrus/appveyor.yml
index b4ffca27..df9d65c3 100644
--- a/vendor/github.com/sirupsen/logrus/appveyor.yml
+++ b/vendor/github.com/sirupsen/logrus/appveyor.yml
@@ -1,14 +1,14 @@
version: "{build}"
platform: x64
clone_folder: c:\gopath\src\github.com\sirupsen\logrus
-environment:
+environment:
GOPATH: c:\gopath
-branches:
+branches:
only:
- master
-install:
+install:
- set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
- go version
-build_script:
+build_script:
- go get -t
- go test
diff --git a/vendor/github.com/sirupsen/logrus/buffer_pool.go b/vendor/github.com/sirupsen/logrus/buffer_pool.go
new file mode 100644
index 00000000..c7787f77
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/buffer_pool.go
@@ -0,0 +1,43 @@
+package logrus
+
+import (
+ "bytes"
+ "sync"
+)
+
+var (
+ bufferPool BufferPool
+)
+
+type BufferPool interface {
+ Put(*bytes.Buffer)
+ Get() *bytes.Buffer
+}
+
+type defaultPool struct {
+ pool *sync.Pool
+}
+
+func (p *defaultPool) Put(buf *bytes.Buffer) {
+ p.pool.Put(buf)
+}
+
+func (p *defaultPool) Get() *bytes.Buffer {
+ return p.pool.Get().(*bytes.Buffer)
+}
+
+// SetBufferPool allows to replace the default logrus buffer pool
+// to better meets the specific needs of an application.
+func SetBufferPool(bp BufferPool) {
+ bufferPool = bp
+}
+
+func init() {
+ SetBufferPool(&defaultPool{
+ pool: &sync.Pool{
+ New: func() interface{} {
+ return new(bytes.Buffer)
+ },
+ },
+ })
+}
diff --git a/vendor/github.com/sirupsen/logrus/entry.go b/vendor/github.com/sirupsen/logrus/entry.go
index cc85d3aa..71cdbbc3 100644
--- a/vendor/github.com/sirupsen/logrus/entry.go
+++ b/vendor/github.com/sirupsen/logrus/entry.go
@@ -2,6 +2,7 @@ package logrus
import (
"bytes"
+ "context"
"fmt"
"os"
"reflect"
@@ -12,7 +13,6 @@ import (
)
var (
- bufferPool *sync.Pool
// qualified package name, cached at first use
logrusPackage string
@@ -30,12 +30,6 @@ const (
)
func init() {
- bufferPool = &sync.Pool{
- New: func() interface{} {
- return new(bytes.Buffer)
- },
- }
-
// start at the bottom of the stack before the package-name cache is primed
minimumCallerDepth = 1
}
@@ -69,6 +63,9 @@ type Entry struct {
// When formatter is called in entry.log(), a Buffer may be set to entry
Buffer *bytes.Buffer
+ // Contains the context set by the user. Useful for hook processing etc.
+ Context context.Context
+
// err may contain a field formatting error
err string
}
@@ -81,10 +78,23 @@ func NewEntry(logger *Logger) *Entry {
}
}
+func (entry *Entry) Dup() *Entry {
+ data := make(Fields, len(entry.Data))
+ for k, v := range entry.Data {
+ data[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, Context: entry.Context, err: entry.err}
+}
+
+// Returns the bytes representation of this entry from the formatter.
+func (entry *Entry) Bytes() ([]byte, error) {
+ return entry.Logger.Formatter.Format(entry)
+}
+
// Returns the string representation from the reader and ultimately the
// formatter.
func (entry *Entry) String() (string, error) {
- serialized, err := entry.Logger.Formatter.Format(entry)
+ serialized, err := entry.Bytes()
if err != nil {
return "", err
}
@@ -97,6 +107,15 @@ func (entry *Entry) WithError(err error) *Entry {
return entry.WithField(ErrorKey, err)
}
+// Add a context to the Entry.
+func (entry *Entry) WithContext(ctx context.Context) *Entry {
+ dataCopy := make(Fields, len(entry.Data))
+ for k, v := range entry.Data {
+ dataCopy[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: ctx}
+}
+
// Add a single field to the Entry.
func (entry *Entry) WithField(key string, value interface{}) *Entry {
return entry.WithFields(Fields{key: value})
@@ -108,23 +127,36 @@ func (entry *Entry) WithFields(fields Fields) *Entry {
for k, v := range entry.Data {
data[k] = v
}
- var field_err string
+ fieldErr := entry.err
for k, v := range fields {
- if t := reflect.TypeOf(v); t != nil && t.Kind() == reflect.Func {
- field_err = fmt.Sprintf("can not add field %q", k)
- if entry.err != "" {
- field_err = entry.err + ", " + field_err
+ isErrField := false
+ if t := reflect.TypeOf(v); t != nil {
+ switch {
+ case t.Kind() == reflect.Func, t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Func:
+ isErrField = true
+ }
+ }
+ if isErrField {
+ tmp := fmt.Sprintf("can not add field %q", k)
+ if fieldErr != "" {
+ fieldErr = entry.err + ", " + tmp
+ } else {
+ fieldErr = tmp
}
} else {
data[k] = v
}
}
- return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: field_err}
+ return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context}
}
// Overrides the time of the Entry.
func (entry *Entry) WithTime(t time.Time) *Entry {
- return &Entry{Logger: entry.Logger, Data: entry.Data, Time: t}
+ dataCopy := make(Fields, len(entry.Data))
+ for k, v := range entry.Data {
+ dataCopy[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: dataCopy, Time: t, err: entry.err, Context: entry.Context}
}
// getPackageName reduces a fully qualified function name to the package name
@@ -145,26 +177,34 @@ func getPackageName(f string) string {
// getCaller retrieves the name of the first non-logrus calling function
func getCaller() *runtime.Frame {
- // Restrict the lookback frames to avoid runaway lookups
- pcs := make([]uintptr, maximumCallerDepth)
- depth := runtime.Callers(minimumCallerDepth, pcs)
- frames := runtime.CallersFrames(pcs[:depth])
-
// cache this package's fully-qualified name
callerInitOnce.Do(func() {
- logrusPackage = getPackageName(runtime.FuncForPC(pcs[0]).Name())
+ pcs := make([]uintptr, maximumCallerDepth)
+ _ = runtime.Callers(0, pcs)
+
+ // dynamic get the package name and the minimum caller depth
+ for i := 0; i < maximumCallerDepth; i++ {
+ funcName := runtime.FuncForPC(pcs[i]).Name()
+ if strings.Contains(funcName, "getCaller") {
+ logrusPackage = getPackageName(funcName)
+ break
+ }
+ }
- // now that we have the cache, we can skip a minimum count of known-logrus functions
- // XXX this is dubious, the number of frames may vary store an entry in a logger interface
minimumCallerDepth = knownLogrusFrames
})
+ // Restrict the lookback frames to avoid runaway lookups
+ pcs := make([]uintptr, maximumCallerDepth)
+ depth := runtime.Callers(minimumCallerDepth, pcs)
+ frames := runtime.CallersFrames(pcs[:depth])
+
for f, again := frames.Next(); again; f, again = frames.Next() {
pkg := getPackageName(f.Function)
// If the caller isn't part of this package, we're done
if pkg != logrusPackage {
- return &f
+ return &f //nolint:scopelint
}
}
@@ -178,49 +218,66 @@ func (entry Entry) HasCaller() (has bool) {
entry.Caller != nil
}
-// This function is not declared with a pointer value because otherwise
-// race conditions will occur when using multiple goroutines
-func (entry Entry) log(level Level, msg string) {
+func (entry *Entry) log(level Level, msg string) {
var buffer *bytes.Buffer
- // Default to now, but allow users to override if they want.
- //
- // We don't have to worry about polluting future calls to Entry#log()
- // with this assignment because this function is declared with a
- // non-pointer receiver.
- if entry.Time.IsZero() {
- entry.Time = time.Now()
- }
+ newEntry := entry.Dup()
- entry.Level = level
- entry.Message = msg
- if entry.Logger.ReportCaller {
- entry.Caller = getCaller()
+ if newEntry.Time.IsZero() {
+ newEntry.Time = time.Now()
}
- entry.fireHooks()
+ newEntry.Level = level
+ newEntry.Message = msg
+
+ newEntry.Logger.mu.Lock()
+ reportCaller := newEntry.Logger.ReportCaller
+ bufPool := newEntry.getBufferPool()
+ newEntry.Logger.mu.Unlock()
- buffer = bufferPool.Get().(*bytes.Buffer)
+ if reportCaller {
+ newEntry.Caller = getCaller()
+ }
+
+ newEntry.fireHooks()
+ buffer = bufPool.Get()
+ defer func() {
+ newEntry.Buffer = nil
+ buffer.Reset()
+ bufPool.Put(buffer)
+ }()
buffer.Reset()
- defer bufferPool.Put(buffer)
- entry.Buffer = buffer
+ newEntry.Buffer = buffer
- entry.write()
+ newEntry.write()
- entry.Buffer = nil
+ newEntry.Buffer = nil
// To avoid Entry#log() returning a value that only would make sense for
// panic() to use in Entry#Panic(), we avoid the allocation by checking
// directly here.
if level <= PanicLevel {
- panic(&entry)
+ panic(newEntry)
}
}
+func (entry *Entry) getBufferPool() (pool BufferPool) {
+ if entry.Logger.BufferPool != nil {
+ return entry.Logger.BufferPool
+ }
+ return bufferPool
+}
+
func (entry *Entry) fireHooks() {
+ var tmpHooks LevelHooks
entry.Logger.mu.Lock()
- defer entry.Logger.mu.Unlock()
- err := entry.Logger.Hooks.Fire(entry.Level, entry)
+ tmpHooks = make(LevelHooks, len(entry.Logger.Hooks))
+ for k, v := range entry.Logger.Hooks {
+ tmpHooks[k] = v
+ }
+ entry.Logger.mu.Unlock()
+
+ err := tmpHooks.Fire(entry.Level, entry)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
}
@@ -232,24 +289,28 @@ func (entry *Entry) write() {
serialized, err := entry.Logger.Formatter.Format(entry)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
- } else {
- _, err = entry.Logger.Out.Write(serialized)
- if err != nil {
- fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
- }
+ return
+ }
+ if _, err := entry.Logger.Out.Write(serialized); err != nil {
+ fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
}
}
-func (entry *Entry) Trace(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(TraceLevel) {
- entry.log(TraceLevel, fmt.Sprint(args...))
+// Log will log a message at the level given as parameter.
+// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
+// For this behaviour Entry.Panic or Entry.Fatal should be used instead.
+func (entry *Entry) Log(level Level, args ...interface{}) {
+ if entry.Logger.IsLevelEnabled(level) {
+ entry.log(level, fmt.Sprint(args...))
}
}
+func (entry *Entry) Trace(args ...interface{}) {
+ entry.Log(TraceLevel, args...)
+}
+
func (entry *Entry) Debug(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(DebugLevel) {
- entry.log(DebugLevel, fmt.Sprint(args...))
- }
+ entry.Log(DebugLevel, args...)
}
func (entry *Entry) Print(args ...interface{}) {
@@ -257,15 +318,11 @@ func (entry *Entry) Print(args ...interface{}) {
}
func (entry *Entry) Info(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(InfoLevel) {
- entry.log(InfoLevel, fmt.Sprint(args...))
- }
+ entry.Log(InfoLevel, args...)
}
func (entry *Entry) Warn(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(WarnLevel) {
- entry.log(WarnLevel, fmt.Sprint(args...))
- }
+ entry.Log(WarnLevel, args...)
}
func (entry *Entry) Warning(args ...interface{}) {
@@ -273,43 +330,36 @@ func (entry *Entry) Warning(args ...interface{}) {
}
func (entry *Entry) Error(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(ErrorLevel) {
- entry.log(ErrorLevel, fmt.Sprint(args...))
- }
+ entry.Log(ErrorLevel, args...)
}
func (entry *Entry) Fatal(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(FatalLevel) {
- entry.log(FatalLevel, fmt.Sprint(args...))
- }
+ entry.Log(FatalLevel, args...)
entry.Logger.Exit(1)
}
func (entry *Entry) Panic(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(PanicLevel) {
- entry.log(PanicLevel, fmt.Sprint(args...))
- }
- panic(fmt.Sprint(args...))
+ entry.Log(PanicLevel, args...)
}
// Entry Printf family functions
-func (entry *Entry) Tracef(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(TraceLevel) {
- entry.Trace(fmt.Sprintf(format, args...))
+func (entry *Entry) Logf(level Level, format string, args ...interface{}) {
+ if entry.Logger.IsLevelEnabled(level) {
+ entry.Log(level, fmt.Sprintf(format, args...))
}
}
+func (entry *Entry) Tracef(format string, args ...interface{}) {
+ entry.Logf(TraceLevel, format, args...)
+}
+
func (entry *Entry) Debugf(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(DebugLevel) {
- entry.Debug(fmt.Sprintf(format, args...))
- }
+ entry.Logf(DebugLevel, format, args...)
}
func (entry *Entry) Infof(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(InfoLevel) {
- entry.Info(fmt.Sprintf(format, args...))
- }
+ entry.Logf(InfoLevel, format, args...)
}
func (entry *Entry) Printf(format string, args ...interface{}) {
@@ -317,9 +367,7 @@ func (entry *Entry) Printf(format string, args ...interface{}) {
}
func (entry *Entry) Warnf(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(WarnLevel) {
- entry.Warn(fmt.Sprintf(format, args...))
- }
+ entry.Logf(WarnLevel, format, args...)
}
func (entry *Entry) Warningf(format string, args ...interface{}) {
@@ -327,42 +375,36 @@ func (entry *Entry) Warningf(format string, args ...interface{}) {
}
func (entry *Entry) Errorf(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(ErrorLevel) {
- entry.Error(fmt.Sprintf(format, args...))
- }
+ entry.Logf(ErrorLevel, format, args...)
}
func (entry *Entry) Fatalf(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(FatalLevel) {
- entry.Fatal(fmt.Sprintf(format, args...))
- }
+ entry.Logf(FatalLevel, format, args...)
entry.Logger.Exit(1)
}
func (entry *Entry) Panicf(format string, args ...interface{}) {
- if entry.Logger.IsLevelEnabled(PanicLevel) {
- entry.Panic(fmt.Sprintf(format, args...))
- }
+ entry.Logf(PanicLevel, format, args...)
}
// Entry Println family functions
-func (entry *Entry) Traceln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(TraceLevel) {
- entry.Trace(entry.sprintlnn(args...))
+func (entry *Entry) Logln(level Level, args ...interface{}) {
+ if entry.Logger.IsLevelEnabled(level) {
+ entry.Log(level, entry.sprintlnn(args...))
}
}
+func (entry *Entry) Traceln(args ...interface{}) {
+ entry.Logln(TraceLevel, args...)
+}
+
func (entry *Entry) Debugln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(DebugLevel) {
- entry.Debug(entry.sprintlnn(args...))
- }
+ entry.Logln(DebugLevel, args...)
}
func (entry *Entry) Infoln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(InfoLevel) {
- entry.Info(entry.sprintlnn(args...))
- }
+ entry.Logln(InfoLevel, args...)
}
func (entry *Entry) Println(args ...interface{}) {
@@ -370,9 +412,7 @@ func (entry *Entry) Println(args ...interface{}) {
}
func (entry *Entry) Warnln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(WarnLevel) {
- entry.Warn(entry.sprintlnn(args...))
- }
+ entry.Logln(WarnLevel, args...)
}
func (entry *Entry) Warningln(args ...interface{}) {
@@ -380,22 +420,16 @@ func (entry *Entry) Warningln(args ...interface{}) {
}
func (entry *Entry) Errorln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(ErrorLevel) {
- entry.Error(entry.sprintlnn(args...))
- }
+ entry.Logln(ErrorLevel, args...)
}
func (entry *Entry) Fatalln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(FatalLevel) {
- entry.Fatal(entry.sprintlnn(args...))
- }
+ entry.Logln(FatalLevel, args...)
entry.Logger.Exit(1)
}
func (entry *Entry) Panicln(args ...interface{}) {
- if entry.Logger.IsLevelEnabled(PanicLevel) {
- entry.Panic(entry.sprintlnn(args...))
- }
+ entry.Logln(PanicLevel, args...)
}
// Sprintlnn => Sprint no newline. This is to get the behavior of how
diff --git a/vendor/github.com/sirupsen/logrus/exported.go b/vendor/github.com/sirupsen/logrus/exported.go
index 7342613c..017c30ce 100644
--- a/vendor/github.com/sirupsen/logrus/exported.go
+++ b/vendor/github.com/sirupsen/logrus/exported.go
@@ -1,6 +1,7 @@
package logrus
import (
+ "context"
"io"
"time"
)
@@ -55,6 +56,11 @@ func WithError(err error) *Entry {
return std.WithField(ErrorKey, err)
}
+// WithContext creates an entry from the standard logger and adds a context to it.
+func WithContext(ctx context.Context) *Entry {
+ return std.WithContext(ctx)
+}
+
// WithField creates an entry from the standard logger and adds a field to
// it. If you want multiple fields, use `WithFields`.
//
@@ -74,7 +80,7 @@ func WithFields(fields Fields) *Entry {
return std.WithFields(fields)
}
-// WithTime creats an entry from the standard logger and overrides the time of
+// WithTime creates an entry from the standard logger and overrides the time of
// logs generated with it.
//
// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
@@ -128,6 +134,51 @@ func Fatal(args ...interface{}) {
std.Fatal(args...)
}
+// TraceFn logs a message from a func at level Trace on the standard logger.
+func TraceFn(fn LogFunction) {
+ std.TraceFn(fn)
+}
+
+// DebugFn logs a message from a func at level Debug on the standard logger.
+func DebugFn(fn LogFunction) {
+ std.DebugFn(fn)
+}
+
+// PrintFn logs a message from a func at level Info on the standard logger.
+func PrintFn(fn LogFunction) {
+ std.PrintFn(fn)
+}
+
+// InfoFn logs a message from a func at level Info on the standard logger.
+func InfoFn(fn LogFunction) {
+ std.InfoFn(fn)
+}
+
+// WarnFn logs a message from a func at level Warn on the standard logger.
+func WarnFn(fn LogFunction) {
+ std.WarnFn(fn)
+}
+
+// WarningFn logs a message from a func at level Warn on the standard logger.
+func WarningFn(fn LogFunction) {
+ std.WarningFn(fn)
+}
+
+// ErrorFn logs a message from a func at level Error on the standard logger.
+func ErrorFn(fn LogFunction) {
+ std.ErrorFn(fn)
+}
+
+// PanicFn logs a message from a func at level Panic on the standard logger.
+func PanicFn(fn LogFunction) {
+ std.PanicFn(fn)
+}
+
+// FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1.
+func FatalFn(fn LogFunction) {
+ std.FatalFn(fn)
+}
+
// Tracef logs a message at level Trace on the standard logger.
func Tracef(format string, args ...interface{}) {
std.Tracef(format, args...)
diff --git a/vendor/github.com/sirupsen/logrus/json_formatter.go b/vendor/github.com/sirupsen/logrus/json_formatter.go
index 26057535..c96dc563 100644
--- a/vendor/github.com/sirupsen/logrus/json_formatter.go
+++ b/vendor/github.com/sirupsen/logrus/json_formatter.go
@@ -4,6 +4,7 @@ import (
"bytes"
"encoding/json"
"fmt"
+ "runtime"
)
type fieldKey string
@@ -22,11 +23,17 @@ func (f FieldMap) resolve(key fieldKey) string {
// JSONFormatter formats logs into parsable json
type JSONFormatter struct {
// TimestampFormat sets the format used for marshaling timestamps.
+ // The format to use is the same than for time.Format or time.Parse from the standard
+ // library.
+ // The standard Library already provides a set of predefined format.
TimestampFormat string
// DisableTimestamp allows disabling automatic timestamps in output
DisableTimestamp bool
+ // DisableHTMLEscape allows disabling html escaping in output
+ DisableHTMLEscape bool
+
// DataKey allows users to put all the log entry parameters into a nested dictionary at a given key.
DataKey string
@@ -42,6 +49,12 @@ type JSONFormatter struct {
// }
FieldMap FieldMap
+ // CallerPrettyfier can be set by the user to modify the content
+ // of the function and file keys in the json data when ReportCaller is
+ // activated. If any of the returned value is the empty string the
+ // corresponding key will be removed from json fields.
+ CallerPrettyfier func(*runtime.Frame) (function string, file string)
+
// PrettyPrint will indent all json logs
PrettyPrint bool
}
@@ -82,8 +95,17 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
if entry.HasCaller() {
- data[f.FieldMap.resolve(FieldKeyFunc)] = entry.Caller.Function
- data[f.FieldMap.resolve(FieldKeyFile)] = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+ funcVal := entry.Caller.Function
+ fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+ if f.CallerPrettyfier != nil {
+ funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+ }
+ if funcVal != "" {
+ data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal
+ }
+ if fileVal != "" {
+ data[f.FieldMap.resolve(FieldKeyFile)] = fileVal
+ }
}
var b *bytes.Buffer
@@ -94,11 +116,12 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
}
encoder := json.NewEncoder(b)
+ encoder.SetEscapeHTML(!f.DisableHTMLEscape)
if f.PrettyPrint {
encoder.SetIndent("", " ")
}
if err := encoder.Encode(data); err != nil {
- return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ return nil, fmt.Errorf("failed to marshal fields to JSON, %w", err)
}
return b.Bytes(), nil
diff --git a/vendor/github.com/sirupsen/logrus/logger.go b/vendor/github.com/sirupsen/logrus/logger.go
index 5ceca0ea..5ff0aef6 100644
--- a/vendor/github.com/sirupsen/logrus/logger.go
+++ b/vendor/github.com/sirupsen/logrus/logger.go
@@ -1,6 +1,7 @@
package logrus
import (
+ "context"
"io"
"os"
"sync"
@@ -8,6 +9,11 @@ import (
"time"
)
+// LogFunction For big messages, it can be more efficient to pass a function
+// and only call it if the log level is actually enables rather than
+// generating the log message and then checking if the level is enabled
+type LogFunction func() []interface{}
+
type Logger struct {
// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
// file, or leave it default which is `os.Stderr`. You can also set this to
@@ -38,6 +44,9 @@ type Logger struct {
entryPool sync.Pool
// Function to exit the application, defaults to `os.Exit()`
ExitFunc exitFunc
+ // The buffer pool used to format the log. If it is nil, the default global
+ // buffer pool will be used.
+ BufferPool BufferPool
}
type exitFunc func(int)
@@ -67,10 +76,10 @@ func (mw *MutexWrap) Disable() {
// `Out` and `Hooks` directly on the default logger instance. You can also just
// instantiate your own:
//
-// var log = &Logger{
+// var log = &logrus.Logger{
// Out: os.Stderr,
-// Formatter: new(JSONFormatter),
-// Hooks: make(LevelHooks),
+// Formatter: new(logrus.TextFormatter),
+// Hooks: make(logrus.LevelHooks),
// Level: logrus.DebugLevel,
// }
//
@@ -99,8 +108,9 @@ func (logger *Logger) releaseEntry(entry *Entry) {
logger.entryPool.Put(entry)
}
-// Adds a field to the log entry, note that it doesn't log until you call
-// Debug, Print, Info, Warn, Error, Fatal or Panic. It only creates a log entry.
+// WithField allocates a new entry and adds a field to it.
+// Debug, Print, Info, Warn, Error, Fatal or Panic must be then applied to
+// this new returned entry.
// If you want multiple fields, use `WithFields`.
func (logger *Logger) WithField(key string, value interface{}) *Entry {
entry := logger.newEntry()
@@ -124,6 +134,13 @@ func (logger *Logger) WithError(err error) *Entry {
return entry.WithError(err)
}
+// Add a context to the log entry.
+func (logger *Logger) WithContext(ctx context.Context) *Entry {
+ entry := logger.newEntry()
+ defer logger.releaseEntry(entry)
+ return entry.WithContext(ctx)
+}
+
// Overrides the time of the log entry.
func (logger *Logger) WithTime(t time.Time) *Entry {
entry := logger.newEntry()
@@ -131,28 +148,24 @@ func (logger *Logger) WithTime(t time.Time) *Entry {
return entry.WithTime(t)
}
-func (logger *Logger) Tracef(format string, args ...interface{}) {
- if logger.IsLevelEnabled(TraceLevel) {
+func (logger *Logger) Logf(level Level, format string, args ...interface{}) {
+ if logger.IsLevelEnabled(level) {
entry := logger.newEntry()
- entry.Tracef(format, args...)
+ entry.Logf(level, format, args...)
logger.releaseEntry(entry)
}
}
+func (logger *Logger) Tracef(format string, args ...interface{}) {
+ logger.Logf(TraceLevel, format, args...)
+}
+
func (logger *Logger) Debugf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(DebugLevel) {
- entry := logger.newEntry()
- entry.Debugf(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Logf(DebugLevel, format, args...)
}
func (logger *Logger) Infof(format string, args ...interface{}) {
- if logger.IsLevelEnabled(InfoLevel) {
- entry := logger.newEntry()
- entry.Infof(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Logf(InfoLevel, format, args...)
}
func (logger *Logger) Printf(format string, args ...interface{}) {
@@ -162,139 +175,141 @@ func (logger *Logger) Printf(format string, args ...interface{}) {
}
func (logger *Logger) Warnf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warnf(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Logf(WarnLevel, format, args...)
}
func (logger *Logger) Warningf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warnf(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Warnf(format, args...)
}
func (logger *Logger) Errorf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(ErrorLevel) {
- entry := logger.newEntry()
- entry.Errorf(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Logf(ErrorLevel, format, args...)
}
func (logger *Logger) Fatalf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(FatalLevel) {
- entry := logger.newEntry()
- entry.Fatalf(format, args...)
- logger.releaseEntry(entry)
- }
+ logger.Logf(FatalLevel, format, args...)
logger.Exit(1)
}
func (logger *Logger) Panicf(format string, args ...interface{}) {
- if logger.IsLevelEnabled(PanicLevel) {
+ logger.Logf(PanicLevel, format, args...)
+}
+
+// Log will log a message at the level given as parameter.
+// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
+// For this behaviour Logger.Panic or Logger.Fatal should be used instead.
+func (logger *Logger) Log(level Level, args ...interface{}) {
+ if logger.IsLevelEnabled(level) {
entry := logger.newEntry()
- entry.Panicf(format, args...)
+ entry.Log(level, args...)
logger.releaseEntry(entry)
}
}
-func (logger *Logger) Trace(args ...interface{}) {
- if logger.IsLevelEnabled(TraceLevel) {
+func (logger *Logger) LogFn(level Level, fn LogFunction) {
+ if logger.IsLevelEnabled(level) {
entry := logger.newEntry()
- entry.Trace(args...)
+ entry.Log(level, fn()...)
logger.releaseEntry(entry)
}
}
+func (logger *Logger) Trace(args ...interface{}) {
+ logger.Log(TraceLevel, args...)
+}
+
func (logger *Logger) Debug(args ...interface{}) {
- if logger.IsLevelEnabled(DebugLevel) {
- entry := logger.newEntry()
- entry.Debug(args...)
- logger.releaseEntry(entry)
- }
+ logger.Log(DebugLevel, args...)
}
func (logger *Logger) Info(args ...interface{}) {
- if logger.IsLevelEnabled(InfoLevel) {
- entry := logger.newEntry()
- entry.Info(args...)
- logger.releaseEntry(entry)
- }
+ logger.Log(InfoLevel, args...)
}
func (logger *Logger) Print(args ...interface{}) {
entry := logger.newEntry()
- entry.Info(args...)
+ entry.Print(args...)
logger.releaseEntry(entry)
}
func (logger *Logger) Warn(args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warn(args...)
- logger.releaseEntry(entry)
- }
+ logger.Log(WarnLevel, args...)
}
func (logger *Logger) Warning(args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warn(args...)
- logger.releaseEntry(entry)
- }
+ logger.Warn(args...)
}
func (logger *Logger) Error(args ...interface{}) {
- if logger.IsLevelEnabled(ErrorLevel) {
- entry := logger.newEntry()
- entry.Error(args...)
- logger.releaseEntry(entry)
- }
+ logger.Log(ErrorLevel, args...)
}
func (logger *Logger) Fatal(args ...interface{}) {
- if logger.IsLevelEnabled(FatalLevel) {
- entry := logger.newEntry()
- entry.Fatal(args...)
- logger.releaseEntry(entry)
- }
+ logger.Log(FatalLevel, args...)
logger.Exit(1)
}
func (logger *Logger) Panic(args ...interface{}) {
- if logger.IsLevelEnabled(PanicLevel) {
+ logger.Log(PanicLevel, args...)
+}
+
+func (logger *Logger) TraceFn(fn LogFunction) {
+ logger.LogFn(TraceLevel, fn)
+}
+
+func (logger *Logger) DebugFn(fn LogFunction) {
+ logger.LogFn(DebugLevel, fn)
+}
+
+func (logger *Logger) InfoFn(fn LogFunction) {
+ logger.LogFn(InfoLevel, fn)
+}
+
+func (logger *Logger) PrintFn(fn LogFunction) {
+ entry := logger.newEntry()
+ entry.Print(fn()...)
+ logger.releaseEntry(entry)
+}
+
+func (logger *Logger) WarnFn(fn LogFunction) {
+ logger.LogFn(WarnLevel, fn)
+}
+
+func (logger *Logger) WarningFn(fn LogFunction) {
+ logger.WarnFn(fn)
+}
+
+func (logger *Logger) ErrorFn(fn LogFunction) {
+ logger.LogFn(ErrorLevel, fn)
+}
+
+func (logger *Logger) FatalFn(fn LogFunction) {
+ logger.LogFn(FatalLevel, fn)
+ logger.Exit(1)
+}
+
+func (logger *Logger) PanicFn(fn LogFunction) {
+ logger.LogFn(PanicLevel, fn)
+}
+
+func (logger *Logger) Logln(level Level, args ...interface{}) {
+ if logger.IsLevelEnabled(level) {
entry := logger.newEntry()
- entry.Panic(args...)
+ entry.Logln(level, args...)
logger.releaseEntry(entry)
}
}
func (logger *Logger) Traceln(args ...interface{}) {
- if logger.IsLevelEnabled(TraceLevel) {
- entry := logger.newEntry()
- entry.Traceln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(TraceLevel, args...)
}
func (logger *Logger) Debugln(args ...interface{}) {
- if logger.IsLevelEnabled(DebugLevel) {
- entry := logger.newEntry()
- entry.Debugln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(DebugLevel, args...)
}
func (logger *Logger) Infoln(args ...interface{}) {
- if logger.IsLevelEnabled(InfoLevel) {
- entry := logger.newEntry()
- entry.Infoln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(InfoLevel, args...)
}
func (logger *Logger) Println(args ...interface{}) {
@@ -304,44 +319,24 @@ func (logger *Logger) Println(args ...interface{}) {
}
func (logger *Logger) Warnln(args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warnln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(WarnLevel, args...)
}
func (logger *Logger) Warningln(args ...interface{}) {
- if logger.IsLevelEnabled(WarnLevel) {
- entry := logger.newEntry()
- entry.Warnln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Warnln(args...)
}
func (logger *Logger) Errorln(args ...interface{}) {
- if logger.IsLevelEnabled(ErrorLevel) {
- entry := logger.newEntry()
- entry.Errorln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(ErrorLevel, args...)
}
func (logger *Logger) Fatalln(args ...interface{}) {
- if logger.IsLevelEnabled(FatalLevel) {
- entry := logger.newEntry()
- entry.Fatalln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(FatalLevel, args...)
logger.Exit(1)
}
func (logger *Logger) Panicln(args ...interface{}) {
- if logger.IsLevelEnabled(PanicLevel) {
- entry := logger.newEntry()
- entry.Panicln(args...)
- logger.releaseEntry(entry)
- }
+ logger.Logln(PanicLevel, args...)
}
func (logger *Logger) Exit(code int) {
@@ -413,3 +408,10 @@ func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks {
logger.mu.Unlock()
return oldHooks
}
+
+// SetBufferPool sets the logger buffer pool.
+func (logger *Logger) SetBufferPool(pool BufferPool) {
+ logger.mu.Lock()
+ defer logger.mu.Unlock()
+ logger.BufferPool = pool
+}
diff --git a/vendor/github.com/sirupsen/logrus/logrus.go b/vendor/github.com/sirupsen/logrus/logrus.go
index 4ef45186..2f16224c 100644
--- a/vendor/github.com/sirupsen/logrus/logrus.go
+++ b/vendor/github.com/sirupsen/logrus/logrus.go
@@ -14,24 +14,11 @@ type Level uint32
// Convert the Level to a string. E.g. PanicLevel becomes "panic".
func (level Level) String() string {
- switch level {
- case TraceLevel:
- return "trace"
- case DebugLevel:
- return "debug"
- case InfoLevel:
- return "info"
- case WarnLevel:
- return "warning"
- case ErrorLevel:
- return "error"
- case FatalLevel:
- return "fatal"
- case PanicLevel:
- return "panic"
+ if b, err := level.MarshalText(); err == nil {
+ return string(b)
+ } else {
+ return "unknown"
}
-
- return "unknown"
}
// ParseLevel takes a string level and returns the Logrus log level constant.
@@ -64,11 +51,32 @@ func (level *Level) UnmarshalText(text []byte) error {
return err
}
- *level = Level(l)
+ *level = l
return nil
}
+func (level Level) MarshalText() ([]byte, error) {
+ switch level {
+ case TraceLevel:
+ return []byte("trace"), nil
+ case DebugLevel:
+ return []byte("debug"), nil
+ case InfoLevel:
+ return []byte("info"), nil
+ case WarnLevel:
+ return []byte("warning"), nil
+ case ErrorLevel:
+ return []byte("error"), nil
+ case FatalLevel:
+ return []byte("fatal"), nil
+ case PanicLevel:
+ return []byte("panic"), nil
+ }
+
+ return nil, fmt.Errorf("not a valid logrus level %d", level)
+}
+
// A constant exposing all logging levels
var AllLevels = []Level{
PanicLevel,
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
new file mode 100644
index 00000000..49978998
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
@@ -0,0 +1,13 @@
+// +build darwin dragonfly freebsd netbsd openbsd
+// +build !js
+
+package logrus
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TIOCGETA
+
+func isTerminal(fd int) bool {
+ _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+ return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_js.go b/vendor/github.com/sirupsen/logrus/terminal_check_js.go
index 0c209750..ebdae3ec 100644
--- a/vendor/github.com/sirupsen/logrus/terminal_check_js.go
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_js.go
@@ -2,10 +2,6 @@
package logrus
-import (
- "io"
-)
-
-func checkIfTerminal(w io.Writer) bool {
+func isTerminal(fd int) bool {
return false
}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
new file mode 100644
index 00000000..97af92c6
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
@@ -0,0 +1,11 @@
+// +build js nacl plan9
+
+package logrus
+
+import (
+ "io"
+)
+
+func checkIfTerminal(w io.Writer) bool {
+ return false
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
index cf309d6f..3293fb3c 100644
--- a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
@@ -1,18 +1,16 @@
-// +build !appengine,!js,!windows
+// +build !appengine,!js,!windows,!nacl,!plan9
package logrus
import (
"io"
"os"
-
- "golang.org/x/crypto/ssh/terminal"
)
func checkIfTerminal(w io.Writer) bool {
switch v := w.(type) {
case *os.File:
- return terminal.IsTerminal(int(v.Fd()))
+ return isTerminal(int(v.Fd()))
default:
return false
}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
new file mode 100644
index 00000000..f6710b3b
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
@@ -0,0 +1,11 @@
+package logrus
+
+import (
+ "golang.org/x/sys/unix"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func isTerminal(fd int) bool {
+ _, err := unix.IoctlGetTermio(fd, unix.TCGETA)
+ return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
new file mode 100644
index 00000000..04748b85
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
@@ -0,0 +1,13 @@
+// +build linux aix zos
+// +build !js
+
+package logrus
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETS
+
+func isTerminal(fd int) bool {
+ _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+ return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
index 3b9d2864..2879eb50 100644
--- a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
@@ -5,16 +5,23 @@ package logrus
import (
"io"
"os"
- "syscall"
+
+ "golang.org/x/sys/windows"
)
func checkIfTerminal(w io.Writer) bool {
switch v := w.(type) {
case *os.File:
+ handle := windows.Handle(v.Fd())
var mode uint32
- err := syscall.GetConsoleMode(syscall.Handle(v.Fd()), &mode)
- return err == nil
- default:
- return false
+ if err := windows.GetConsoleMode(handle, &mode); err != nil {
+ return false
+ }
+ mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING
+ if err := windows.SetConsoleMode(handle, mode); err != nil {
+ return false
+ }
+ return true
}
+ return false
}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_notwindows.go b/vendor/github.com/sirupsen/logrus/terminal_notwindows.go
deleted file mode 100644
index 3dbd2372..00000000
--- a/vendor/github.com/sirupsen/logrus/terminal_notwindows.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// +build !windows
-
-package logrus
-
-import "io"
-
-func initTerminal(w io.Writer) {
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_windows.go b/vendor/github.com/sirupsen/logrus/terminal_windows.go
deleted file mode 100644
index b4ef5286..00000000
--- a/vendor/github.com/sirupsen/logrus/terminal_windows.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// +build !appengine,!js,windows
-
-package logrus
-
-import (
- "io"
- "os"
- "syscall"
-
- sequences "github.com/konsorten/go-windows-terminal-sequences"
-)
-
-func initTerminal(w io.Writer) {
- switch v := w.(type) {
- case *os.File:
- sequences.EnableVirtualTerminalProcessing(syscall.Handle(v.Fd()), true)
- }
-}
diff --git a/vendor/github.com/sirupsen/logrus/text_formatter.go b/vendor/github.com/sirupsen/logrus/text_formatter.go
index 49ec92f1..be2c6efe 100644
--- a/vendor/github.com/sirupsen/logrus/text_formatter.go
+++ b/vendor/github.com/sirupsen/logrus/text_formatter.go
@@ -4,25 +4,23 @@ import (
"bytes"
"fmt"
"os"
+ "runtime"
"sort"
+ "strconv"
"strings"
"sync"
"time"
+ "unicode/utf8"
)
const (
- nocolor = 0
- red = 31
- green = 32
- yellow = 33
- blue = 36
- gray = 37
+ red = 31
+ yellow = 33
+ blue = 36
+ gray = 37
)
-var (
- baseTimestamp time.Time
- emptyFieldMap FieldMap
-)
+var baseTimestamp time.Time
func init() {
baseTimestamp = time.Now()
@@ -36,6 +34,14 @@ type TextFormatter struct {
// Force disabling colors.
DisableColors bool
+ // Force quoting of all values
+ ForceQuote bool
+
+ // DisableQuote disables quoting for all values.
+ // DisableQuote will have a lower priority than ForceQuote.
+ // If both of them are set to true, quote will be forced on all values.
+ DisableQuote bool
+
// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
EnvironmentOverrideColors bool
@@ -47,7 +53,10 @@ type TextFormatter struct {
// the time passed since beginning of execution.
FullTimestamp bool
- // TimestampFormat to use for display when a full timestamp is printed
+ // TimestampFormat to use for display when a full timestamp is printed.
+ // The format to use is the same than for time.Format or time.Parse from the standard
+ // library.
+ // The standard Library already provides a set of predefined format.
TimestampFormat string
// The fields are sorted by default for a consistent output. For applications
@@ -61,6 +70,10 @@ type TextFormatter struct {
// Disables the truncation of the level text to 4 characters.
DisableLevelTruncation bool
+ // PadLevelText Adds padding the level text so that all the levels output at the same length
+ // PadLevelText is a superset of the DisableLevelTruncation option
+ PadLevelText bool
+
// QuoteEmptyFields will wrap empty fields in quotes if true
QuoteEmptyFields bool
@@ -76,28 +89,39 @@ type TextFormatter struct {
// FieldKeyMsg: "@message"}}
FieldMap FieldMap
+ // CallerPrettyfier can be set by the user to modify the content
+ // of the function and file keys in the data when ReportCaller is
+ // activated. If any of the returned value is the empty string the
+ // corresponding key will be removed from fields.
+ CallerPrettyfier func(*runtime.Frame) (function string, file string)
+
terminalInitOnce sync.Once
+
+ // The max length of the level text, generated dynamically on init
+ levelTextMaxLength int
}
func (f *TextFormatter) init(entry *Entry) {
if entry.Logger != nil {
f.isTerminal = checkIfTerminal(entry.Logger.Out)
-
- if f.isTerminal {
- initTerminal(entry.Logger.Out)
+ }
+ // Get the max length of the level text
+ for _, level := range AllLevels {
+ levelTextLength := utf8.RuneCount([]byte(level.String()))
+ if levelTextLength > f.levelTextMaxLength {
+ f.levelTextMaxLength = levelTextLength
}
}
}
func (f *TextFormatter) isColored() bool {
- isColored := f.ForceColors || f.isTerminal
+ isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
if f.EnvironmentOverrideColors {
- if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" {
+ switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); {
+ case ok && force != "0":
isColored = true
- } else if ok && force == "0" {
- isColored = false
- } else if os.Getenv("CLICOLOR") == "0" {
+ case ok && force == "0", os.Getenv("CLICOLOR") == "0":
isColored = false
}
}
@@ -107,14 +131,19 @@ func (f *TextFormatter) isColored() bool {
// Format renders a single log entry
func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
- prefixFieldClashes(entry.Data, f.FieldMap, entry.HasCaller())
-
- keys := make([]string, 0, len(entry.Data))
- for k := range entry.Data {
+ data := make(Fields)
+ for k, v := range entry.Data {
+ data[k] = v
+ }
+ prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
+ keys := make([]string, 0, len(data))
+ for k := range data {
keys = append(keys, k)
}
- fixedKeys := make([]string, 0, 4+len(entry.Data))
+ var funcVal, fileVal string
+
+ fixedKeys := make([]string, 0, 4+len(data))
if !f.DisableTimestamp {
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
}
@@ -126,8 +155,19 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
}
if entry.HasCaller() {
- fixedKeys = append(fixedKeys,
- f.FieldMap.resolve(FieldKeyFunc), f.FieldMap.resolve(FieldKeyFile))
+ if f.CallerPrettyfier != nil {
+ funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+ } else {
+ funcVal = entry.Caller.Function
+ fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+ }
+
+ if funcVal != "" {
+ fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
+ }
+ if fileVal != "" {
+ fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
+ }
}
if !f.DisableSorting {
@@ -160,8 +200,9 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
timestampFormat = defaultTimestampFormat
}
if f.isColored() {
- f.printColored(b, entry, keys, timestampFormat)
+ f.printColored(b, entry, keys, data, timestampFormat)
} else {
+
for _, key := range fixedKeys {
var value interface{}
switch {
@@ -174,11 +215,11 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
case key == f.FieldMap.resolve(FieldKeyLogrusError):
value = entry.err
case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
- value = entry.Caller.Function
+ value = funcVal
case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
- value = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+ value = fileVal
default:
- value = entry.Data[key]
+ value = data[key]
}
f.appendKeyValue(b, key, value)
}
@@ -188,7 +229,7 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
return b.Bytes(), nil
}
-func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
var levelColor int
switch entry.Level {
case DebugLevel, TraceLevel:
@@ -197,44 +238,73 @@ func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []strin
levelColor = yellow
case ErrorLevel, FatalLevel, PanicLevel:
levelColor = red
+ case InfoLevel:
+ levelColor = blue
default:
levelColor = blue
}
levelText := strings.ToUpper(entry.Level.String())
- if !f.DisableLevelTruncation {
+ if !f.DisableLevelTruncation && !f.PadLevelText {
levelText = levelText[0:4]
}
+ if f.PadLevelText {
+ // Generates the format string used in the next line, for example "%-6s" or "%-7s".
+ // Based on the max level text length.
+ formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s"
+ // Formats the level text by appending spaces up to the max length, for example:
+ // - "INFO "
+ // - "WARNING"
+ levelText = fmt.Sprintf(formatString, levelText)
+ }
// Remove a single newline if it already exists in the message to keep
// the behavior of logrus text_formatter the same as the stdlib log package
entry.Message = strings.TrimSuffix(entry.Message, "\n")
caller := ""
-
if entry.HasCaller() {
- caller = fmt.Sprintf("%s:%d %s()",
- entry.Caller.File, entry.Caller.Line, entry.Caller.Function)
+ funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
+ fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+
+ if f.CallerPrettyfier != nil {
+ funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+ }
+
+ if fileVal == "" {
+ caller = funcVal
+ } else if funcVal == "" {
+ caller = fileVal
+ } else {
+ caller = fileVal + " " + funcVal
+ }
}
- if f.DisableTimestamp {
+ switch {
+ case f.DisableTimestamp:
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
- } else if !f.FullTimestamp {
+ case !f.FullTimestamp:
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
- } else {
+ default:
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
}
for _, k := range keys {
- v := entry.Data[k]
+ v := data[k]
fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
f.appendValue(b, v)
}
}
func (f *TextFormatter) needsQuoting(text string) bool {
+ if f.ForceQuote {
+ return true
+ }
if f.QuoteEmptyFields && len(text) == 0 {
return true
}
+ if f.DisableQuote {
+ return false
+ }
for _, ch := range text {
if !((ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z') ||
diff --git a/vendor/github.com/sirupsen/logrus/writer.go b/vendor/github.com/sirupsen/logrus/writer.go
index 9e1f7513..074fd4b8 100644
--- a/vendor/github.com/sirupsen/logrus/writer.go
+++ b/vendor/github.com/sirupsen/logrus/writer.go
@@ -4,25 +4,35 @@ import (
"bufio"
"io"
"runtime"
+ "strings"
)
+// Writer at INFO level. See WriterLevel for details.
func (logger *Logger) Writer() *io.PipeWriter {
return logger.WriterLevel(InfoLevel)
}
+// WriterLevel returns an io.Writer that can be used to write arbitrary text to
+// the logger at the given log level. Each line written to the writer will be
+// printed in the usual way using formatters and hooks. The writer is part of an
+// io.Pipe and it is the callers responsibility to close the writer when done.
+// This can be used to override the standard library logger easily.
func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
return NewEntry(logger).WriterLevel(level)
}
+// Writer returns an io.Writer that writes to the logger at the info log level
func (entry *Entry) Writer() *io.PipeWriter {
return entry.WriterLevel(InfoLevel)
}
+// WriterLevel returns an io.Writer that writes to the logger at the given log level
func (entry *Entry) WriterLevel(level Level) *io.PipeWriter {
reader, writer := io.Pipe()
var printFunc func(args ...interface{})
+ // Determine which log function to use based on the specified log level
switch level {
case TraceLevel:
printFunc = entry.Trace
@@ -42,23 +52,51 @@ func (entry *Entry) WriterLevel(level Level) *io.PipeWriter {
printFunc = entry.Print
}
+ // Start a new goroutine to scan the input and write it to the logger using the specified print function.
+ // It splits the input into chunks of up to 64KB to avoid buffer overflows.
go entry.writerScanner(reader, printFunc)
+
+ // Set a finalizer function to close the writer when it is garbage collected
runtime.SetFinalizer(writer, writerFinalizer)
return writer
}
+// writerScanner scans the input from the reader and writes it to the logger
func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
scanner := bufio.NewScanner(reader)
+
+ // Set the buffer size to the maximum token size to avoid buffer overflows
+ scanner.Buffer(make([]byte, bufio.MaxScanTokenSize), bufio.MaxScanTokenSize)
+
+ // Define a split function to split the input into chunks of up to 64KB
+ chunkSize := bufio.MaxScanTokenSize // 64KB
+ splitFunc := func(data []byte, atEOF bool) (int, []byte, error) {
+ if len(data) >= chunkSize {
+ return chunkSize, data[:chunkSize], nil
+ }
+
+ return bufio.ScanLines(data, atEOF)
+ }
+
+ // Use the custom split function to split the input
+ scanner.Split(splitFunc)
+
+ // Scan the input and write it to the logger using the specified print function
for scanner.Scan() {
- printFunc(scanner.Text())
+ printFunc(strings.TrimRight(scanner.Text(), "\r\n"))
}
+
+ // If there was an error while scanning the input, log an error
if err := scanner.Err(); err != nil {
entry.Errorf("Error while reading from Writer: %s", err)
}
+
+ // Close the reader when we are done
reader.Close()
}
+// WriterFinalizer is a finalizer function that closes then given writer when it is garbage collected
func writerFinalizer(writer *io.PipeWriter) {
writer.Close()
}
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_compare.go b/vendor/github.com/stretchr/testify/assert/assertion_compare.go
index 95d8e59d..b774da88 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_compare.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_compare.go
@@ -352,9 +352,9 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
// Greater asserts that the first element is greater than the second
//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
+// assert.Greater(t, 2, 1)
+// assert.Greater(t, float64(2), float64(1))
+// assert.Greater(t, "b", "a")
func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -364,10 +364,10 @@ func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface
// GreaterOrEqual asserts that the first element is greater than or equal to the second
//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
+// assert.GreaterOrEqual(t, 2, 1)
+// assert.GreaterOrEqual(t, 2, 2)
+// assert.GreaterOrEqual(t, "b", "a")
+// assert.GreaterOrEqual(t, "b", "b")
func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -377,9 +377,9 @@ func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...in
// Less asserts that the first element is less than the second
//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
+// assert.Less(t, 1, 2)
+// assert.Less(t, float64(1), float64(2))
+// assert.Less(t, "a", "b")
func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -389,10 +389,10 @@ func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})
// LessOrEqual asserts that the first element is less than or equal to the second
//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
+// assert.LessOrEqual(t, 1, 2)
+// assert.LessOrEqual(t, 2, 2)
+// assert.LessOrEqual(t, "a", "b")
+// assert.LessOrEqual(t, "b", "b")
func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -402,8 +402,8 @@ func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...inter
// Positive asserts that the specified element is positive
//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
+// assert.Positive(t, 1)
+// assert.Positive(t, 1.23)
func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -414,8 +414,8 @@ func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
// Negative asserts that the specified element is negative
//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
+// assert.Negative(t, -1)
+// assert.Negative(t, -1.23)
func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go b/vendor/github.com/stretchr/testify/assert/assertion_format.go
index 7880b8f9..84dbd6c7 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_format.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go
@@ -22,9 +22,9 @@ func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bo
// Containsf asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -56,7 +56,7 @@ func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string
// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
+// assert.Emptyf(t, obj, "error message %s", "formatted")
func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -66,7 +66,7 @@ func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) boo
// Equalf asserts that two objects are equal.
//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
+// assert.Equalf(t, 123, 123, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -81,8 +81,8 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar
// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -90,10 +90,27 @@ func EqualErrorf(t TestingT, theError error, errString string, msg string, args
return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
}
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+// assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
// EqualValuesf asserts that two objects are equal or convertable to the same types
// and equal.
//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
+// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -103,10 +120,10 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri
// Errorf asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
+// actualObj, err := SomeFunction()
+// if assert.Errorf(t, err, "error message %s", "formatted") {
+// assert.Equal(t, expectedErrorf, err)
+// }
func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -126,8 +143,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int
// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -147,7 +164,7 @@ func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface
// Eventuallyf asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -155,9 +172,34 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick
return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
}
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ return EventuallyWithT(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
+}
+
// Exactlyf asserts that two objects are equal in value and type.
//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
+// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -183,7 +225,7 @@ func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}
// Falsef asserts that the specified value is false.
//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
+// assert.Falsef(t, myBool, "error message %s", "formatted")
func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -202,9 +244,9 @@ func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool
// Greaterf asserts that the first element is greater than the second
//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
+// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
+// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
+// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -214,10 +256,10 @@ func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...in
// GreaterOrEqualf asserts that the first element is greater than or equal to the second
//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -228,7 +270,7 @@ func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, arg
// HTTPBodyContainsf asserts that a specified handler returns a
// body that contains a string.
//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@@ -241,7 +283,7 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url
// HTTPBodyNotContainsf asserts that a specified handler returns a
// body that does not contain a string.
//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@@ -253,7 +295,7 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u
// HTTPErrorf asserts that a specified handler returns an error status code.
//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -265,7 +307,7 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string,
// HTTPRedirectf asserts that a specified handler returns a redirect status code.
//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -277,7 +319,7 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri
// HTTPStatusCodef asserts that a specified handler returns a specified status code.
//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
@@ -289,7 +331,7 @@ func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url st
// HTTPSuccessf asserts that a specified handler returns a success status code.
//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -301,7 +343,7 @@ func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url strin
// Implementsf asserts that an object is implemented by the specified interface.
//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -311,7 +353,7 @@ func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, ms
// InDeltaf asserts that the two numerals are within delta of each other.
//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -353,9 +395,9 @@ func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsil
// IsDecreasingf asserts that the collection is decreasing
//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -365,9 +407,9 @@ func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface
// IsIncreasingf asserts that the collection is increasing
//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -377,9 +419,9 @@ func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface
// IsNonDecreasingf asserts that the collection is not decreasing
//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -389,9 +431,9 @@ func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interf
// IsNonIncreasingf asserts that the collection is not increasing
//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -409,7 +451,7 @@ func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg strin
// JSONEqf asserts that two JSON strings are equivalent.
//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -420,7 +462,7 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int
// Lenf asserts that the specified object has specific length.
// Lenf also fails if the object has a type that len() not accept.
//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -430,9 +472,9 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf
// Lessf asserts that the first element is less than the second
//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
+// assert.Lessf(t, 1, 2, "error message %s", "formatted")
+// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
+// assert.Lessf(t, "a", "b", "error message %s", "formatted")
func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -442,10 +484,10 @@ func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...inter
// LessOrEqualf asserts that the first element is less than or equal to the second
//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
+// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
+// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
+// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
+// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -455,8 +497,8 @@ func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args .
// Negativef asserts that the specified element is negative
//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
+// assert.Negativef(t, -1, "error message %s", "formatted")
+// assert.Negativef(t, -1.23, "error message %s", "formatted")
func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -467,7 +509,7 @@ func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool
// Neverf asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -477,7 +519,7 @@ func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.
// Nilf asserts that the specified object is nil.
//
-// assert.Nilf(t, err, "error message %s", "formatted")
+// assert.Nilf(t, err, "error message %s", "formatted")
func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -496,10 +538,10 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool
// NoErrorf asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if assert.NoErrorf(t, err, "error message %s", "formatted") {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -519,9 +561,9 @@ func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) boo
// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -532,9 +574,9 @@ func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, a
// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
+// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+// assert.Equal(t, "two", obj[1])
+// }
func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -544,7 +586,7 @@ func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{})
// NotEqualf asserts that the specified values are NOT equal.
//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -557,7 +599,7 @@ func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string,
// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
+// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -576,7 +618,7 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf
// NotNilf asserts that the specified object is not nil.
//
-// assert.NotNilf(t, err, "error message %s", "formatted")
+// assert.NotNilf(t, err, "error message %s", "formatted")
func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -586,7 +628,7 @@ func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bo
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -596,8 +638,8 @@ func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bo
// NotRegexpf asserts that a specified regexp does not match a string.
//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -607,7 +649,7 @@ func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ..
// NotSamef asserts that two pointers do not reference the same object.
//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
+// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -621,7 +663,7 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string,
// NotSubsetf asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -639,7 +681,7 @@ func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
// Panicsf asserts that the code inside the specified PanicTestFunc panics.
//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -651,7 +693,7 @@ func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -662,7 +704,7 @@ func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string,
// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -672,8 +714,8 @@ func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg str
// Positivef asserts that the specified element is positive
//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
+// assert.Positivef(t, 1, "error message %s", "formatted")
+// assert.Positivef(t, 1.23, "error message %s", "formatted")
func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -683,8 +725,8 @@ func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool
// Regexpf asserts that a specified regexp matches a string.
//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -694,7 +736,7 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in
// Samef asserts that two pointers reference the same object.
//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
+// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -708,7 +750,7 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg
// Subsetf asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -718,7 +760,7 @@ func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args
// Truef asserts that the specified value is true.
//
-// assert.Truef(t, myBool, "error message %s", "formatted")
+// assert.Truef(t, myBool, "error message %s", "formatted")
func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -728,7 +770,7 @@ func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
// WithinDurationf asserts that the two times are within duration delta of each other.
//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -738,7 +780,7 @@ func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta tim
// WithinRangef asserts that a time is within a time range (inclusive).
//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
index 339515b8..b1d94aec 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
@@ -30,9 +30,9 @@ func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}
// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
+// a.Contains("Hello World", "World")
+// a.Contains(["Hello", "World"], "World")
+// a.Contains({"Hello": "World"}, "Hello")
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -43,9 +43,9 @@ func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ..
// Containsf asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
+// a.Containsf("Hello World", "World", "error message %s", "formatted")
+// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
+// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -98,7 +98,7 @@ func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg st
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// a.Empty(obj)
+// a.Empty(obj)
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -109,7 +109,7 @@ func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// a.Emptyf(obj, "error message %s", "formatted")
+// a.Emptyf(obj, "error message %s", "formatted")
func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -119,7 +119,7 @@ func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{})
// Equal asserts that two objects are equal.
//
-// a.Equal(123, 123)
+// a.Equal(123, 123)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -134,8 +134,8 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs
// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
+// actualObj, err := SomeFunction()
+// a.EqualError(err, expectedErrorString)
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -146,8 +146,8 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...
// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -155,10 +155,44 @@ func (a *Assertions) EqualErrorf(theError error, errString string, msg string, a
return EqualErrorf(a.t, theError, errString, msg, args...)
}
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
+// a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
+func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ return EqualExportedValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+// a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ return EqualExportedValuesf(a.t, expected, actual, msg, args...)
+}
+
// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
-// a.EqualValues(uint32(123), int32(123))
+// a.EqualValues(uint32(123), int32(123))
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -169,7 +203,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn
// EqualValuesf asserts that two objects are equal or convertable to the same types
// and equal.
//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
+// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -179,7 +213,7 @@ func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg
// Equalf asserts that two objects are equal.
//
-// a.Equalf(123, 123, "error message %s", "formatted")
+// a.Equalf(123, 123, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -193,10 +227,10 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string
// Error asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
+// actualObj, err := SomeFunction()
+// if a.Error(err) {
+// assert.Equal(t, expectedError, err)
+// }
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -225,8 +259,8 @@ func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ..
// ErrorContains asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
+// actualObj, err := SomeFunction()
+// a.ErrorContains(err, expectedErrorSubString)
func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -237,8 +271,8 @@ func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs .
// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -266,10 +300,10 @@ func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...inter
// Errorf asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
+// actualObj, err := SomeFunction()
+// if a.Errorf(err, "error message %s", "formatted") {
+// assert.Equal(t, expectedErrorf, err)
+// }
func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -280,7 +314,7 @@ func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
// Eventually asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
+// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -288,10 +322,60 @@ func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, ti
return Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
}
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// a.EventuallyWithT(func(c *assert.CollectT) {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ return EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ return EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
+}
+
// Eventuallyf asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -301,7 +385,7 @@ func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, t
// Exactly asserts that two objects are equal in value and type.
//
-// a.Exactly(int32(123), int64(123))
+// a.Exactly(int32(123), int64(123))
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -311,7 +395,7 @@ func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArg
// Exactlyf asserts that two objects are equal in value and type.
//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
+// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -353,7 +437,7 @@ func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{
// False asserts that the specified value is false.
//
-// a.False(myBool)
+// a.False(myBool)
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -363,7 +447,7 @@ func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
// Falsef asserts that the specified value is false.
//
-// a.Falsef(myBool, "error message %s", "formatted")
+// a.Falsef(myBool, "error message %s", "formatted")
func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -391,9 +475,9 @@ func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) b
// Greater asserts that the first element is greater than the second
//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
+// a.Greater(2, 1)
+// a.Greater(float64(2), float64(1))
+// a.Greater("b", "a")
func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -403,10 +487,10 @@ func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...inter
// GreaterOrEqual asserts that the first element is greater than or equal to the second
//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
+// a.GreaterOrEqual(2, 1)
+// a.GreaterOrEqual(2, 2)
+// a.GreaterOrEqual("b", "a")
+// a.GreaterOrEqual("b", "b")
func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -416,10 +500,10 @@ func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs .
// GreaterOrEqualf asserts that the first element is greater than or equal to the second
//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
+// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
+// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
+// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
+// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -429,9 +513,9 @@ func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string,
// Greaterf asserts that the first element is greater than the second
//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
+// a.Greaterf(2, 1, "error message %s", "formatted")
+// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
+// a.Greaterf("b", "a", "error message %s", "formatted")
func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -442,7 +526,7 @@ func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args .
// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
@@ -455,7 +539,7 @@ func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, u
// HTTPBodyContainsf asserts that a specified handler returns a
// body that contains a string.
//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@@ -468,7 +552,7 @@ func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string,
// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
@@ -481,7 +565,7 @@ func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string
// HTTPBodyNotContainsf asserts that a specified handler returns a
// body that does not contain a string.
//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@@ -493,7 +577,7 @@ func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method strin
// HTTPError asserts that a specified handler returns an error status code.
//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -505,7 +589,7 @@ func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url stri
// HTTPErrorf asserts that a specified handler returns an error status code.
//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -517,7 +601,7 @@ func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url str
// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -529,7 +613,7 @@ func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url s
// HTTPRedirectf asserts that a specified handler returns a redirect status code.
//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -541,7 +625,7 @@ func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url
// HTTPStatusCode asserts that a specified handler returns a specified status code.
//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
+// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
@@ -553,7 +637,7 @@ func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url
// HTTPStatusCodef asserts that a specified handler returns a specified status code.
//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
@@ -565,7 +649,7 @@ func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, ur
// HTTPSuccess asserts that a specified handler returns a success status code.
//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -577,7 +661,7 @@ func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url st
// HTTPSuccessf asserts that a specified handler returns a success status code.
//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@@ -589,7 +673,7 @@ func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url s
// Implements asserts that an object is implemented by the specified interface.
//
-// a.Implements((*MyInterface)(nil), new(MyObject))
+// a.Implements((*MyInterface)(nil), new(MyObject))
func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -599,7 +683,7 @@ func (a *Assertions) Implements(interfaceObject interface{}, object interface{},
// Implementsf asserts that an object is implemented by the specified interface.
//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -609,7 +693,7 @@ func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}
// InDelta asserts that the two numerals are within delta of each other.
//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
+// a.InDelta(math.Pi, 22/7.0, 0.01)
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -651,7 +735,7 @@ func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, del
// InDeltaf asserts that the two numerals are within delta of each other.
//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -693,9 +777,9 @@ func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilo
// IsDecreasing asserts that the collection is decreasing
//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
+// a.IsDecreasing([]int{2, 1, 0})
+// a.IsDecreasing([]float{2, 1})
+// a.IsDecreasing([]string{"b", "a"})
func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -705,9 +789,9 @@ func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{})
// IsDecreasingf asserts that the collection is decreasing
//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
+// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
+// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
+// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -717,9 +801,9 @@ func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...inter
// IsIncreasing asserts that the collection is increasing
//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
+// a.IsIncreasing([]int{1, 2, 3})
+// a.IsIncreasing([]float{1, 2})
+// a.IsIncreasing([]string{"a", "b"})
func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -729,9 +813,9 @@ func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{})
// IsIncreasingf asserts that the collection is increasing
//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
+// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
+// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
+// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -741,9 +825,9 @@ func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...inter
// IsNonDecreasing asserts that the collection is not decreasing
//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
+// a.IsNonDecreasing([]int{1, 1, 2})
+// a.IsNonDecreasing([]float{1, 2})
+// a.IsNonDecreasing([]string{"a", "b"})
func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -753,9 +837,9 @@ func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface
// IsNonDecreasingf asserts that the collection is not decreasing
//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -765,9 +849,9 @@ func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...in
// IsNonIncreasing asserts that the collection is not increasing
//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
+// a.IsNonIncreasing([]int{2, 1, 1})
+// a.IsNonIncreasing([]float{2, 1})
+// a.IsNonIncreasing([]string{"b", "a"})
func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -777,9 +861,9 @@ func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface
// IsNonIncreasingf asserts that the collection is not increasing
//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -805,7 +889,7 @@ func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg s
// JSONEq asserts that two JSON strings are equivalent.
//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -815,7 +899,7 @@ func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interf
// JSONEqf asserts that two JSON strings are equivalent.
//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -826,7 +910,7 @@ func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ..
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
-// a.Len(mySlice, 3)
+// a.Len(mySlice, 3)
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -837,7 +921,7 @@ func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface
// Lenf asserts that the specified object has specific length.
// Lenf also fails if the object has a type that len() not accept.
//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
+// a.Lenf(mySlice, 3, "error message %s", "formatted")
func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -847,9 +931,9 @@ func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...in
// Less asserts that the first element is less than the second
//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
+// a.Less(1, 2)
+// a.Less(float64(1), float64(2))
+// a.Less("a", "b")
func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -859,10 +943,10 @@ func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interfac
// LessOrEqual asserts that the first element is less than or equal to the second
//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
+// a.LessOrEqual(1, 2)
+// a.LessOrEqual(2, 2)
+// a.LessOrEqual("a", "b")
+// a.LessOrEqual("b", "b")
func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -872,10 +956,10 @@ func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...i
// LessOrEqualf asserts that the first element is less than or equal to the second
//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
+// a.LessOrEqualf(1, 2, "error message %s", "formatted")
+// a.LessOrEqualf(2, 2, "error message %s", "formatted")
+// a.LessOrEqualf("a", "b", "error message %s", "formatted")
+// a.LessOrEqualf("b", "b", "error message %s", "formatted")
func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -885,9 +969,9 @@ func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, ar
// Lessf asserts that the first element is less than the second
//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
+// a.Lessf(1, 2, "error message %s", "formatted")
+// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
+// a.Lessf("a", "b", "error message %s", "formatted")
func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -897,8 +981,8 @@ func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...i
// Negative asserts that the specified element is negative
//
-// a.Negative(-1)
-// a.Negative(-1.23)
+// a.Negative(-1)
+// a.Negative(-1.23)
func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -908,8 +992,8 @@ func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool {
// Negativef asserts that the specified element is negative
//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
+// a.Negativef(-1, "error message %s", "formatted")
+// a.Negativef(-1.23, "error message %s", "formatted")
func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -920,7 +1004,7 @@ func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) b
// Never asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
+// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -931,7 +1015,7 @@ func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick ti
// Neverf asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -941,7 +1025,7 @@ func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick t
// Nil asserts that the specified object is nil.
//
-// a.Nil(err)
+// a.Nil(err)
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -951,7 +1035,7 @@ func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
// Nilf asserts that the specified object is nil.
//
-// a.Nilf(err, "error message %s", "formatted")
+// a.Nilf(err, "error message %s", "formatted")
func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -979,10 +1063,10 @@ func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{})
// NoError asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if a.NoError(err) {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -992,10 +1076,10 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
// NoErrorf asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if a.NoErrorf(err, "error message %s", "formatted") {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1024,9 +1108,9 @@ func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{})
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
+// a.NotContains("Hello World", "Earth")
+// a.NotContains(["Hello", "World"], "Earth")
+// a.NotContains({"Hello": "World"}, "Earth")
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1037,9 +1121,9 @@ func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs
// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
+// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
+// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
+// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1050,9 +1134,9 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
+// if a.NotEmpty(obj) {
+// assert.Equal(t, "two", obj[1])
+// }
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1063,9 +1147,9 @@ func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) boo
// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
+// if a.NotEmptyf(obj, "error message %s", "formatted") {
+// assert.Equal(t, "two", obj[1])
+// }
func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1075,7 +1159,7 @@ func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface
// NotEqual asserts that the specified values are NOT equal.
//
-// a.NotEqual(obj1, obj2)
+// a.NotEqual(obj1, obj2)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1088,7 +1172,7 @@ func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndAr
// NotEqualValues asserts that two objects are not equal even when converted to the same type
//
-// a.NotEqualValues(obj1, obj2)
+// a.NotEqualValues(obj1, obj2)
func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1098,7 +1182,7 @@ func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, ms
// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
+// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1108,7 +1192,7 @@ func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, m
// NotEqualf asserts that the specified values are NOT equal.
//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
+// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1139,7 +1223,7 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in
// NotNil asserts that the specified object is not nil.
//
-// a.NotNil(err)
+// a.NotNil(err)
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1149,7 +1233,7 @@ func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool
// NotNilf asserts that the specified object is not nil.
//
-// a.NotNilf(err, "error message %s", "formatted")
+// a.NotNilf(err, "error message %s", "formatted")
func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1159,7 +1243,7 @@ func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// a.NotPanics(func(){ RemainCalm() })
+// a.NotPanics(func(){ RemainCalm() })
func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1169,7 +1253,7 @@ func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
+// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1179,8 +1263,8 @@ func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}
// NotRegexp asserts that a specified regexp does not match a string.
//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
+// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+// a.NotRegexp("^start", "it's not starting")
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1190,8 +1274,8 @@ func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...in
// NotRegexpf asserts that a specified regexp does not match a string.
//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
+// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1201,7 +1285,7 @@ func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, arg
// NotSame asserts that two pointers do not reference the same object.
//
-// a.NotSame(ptr1, ptr2)
+// a.NotSame(ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1214,7 +1298,7 @@ func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArg
// NotSamef asserts that two pointers do not reference the same object.
//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
+// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1228,7 +1312,7 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri
// NotSubset asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1239,7 +1323,7 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs
// NotSubsetf asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1265,7 +1349,7 @@ func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bo
// Panics asserts that the code inside the specified PanicTestFunc panics.
//
-// a.Panics(func(){ GoCrazy() })
+// a.Panics(func(){ GoCrazy() })
func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1277,7 +1361,7 @@ func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
+// a.PanicsWithError("crazy error", func(){ GoCrazy() })
func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1289,7 +1373,7 @@ func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndAr
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1300,7 +1384,7 @@ func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg str
// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
+// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1311,7 +1395,7 @@ func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgA
// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1321,7 +1405,7 @@ func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg
// Panicsf asserts that the code inside the specified PanicTestFunc panics.
//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
+// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1331,8 +1415,8 @@ func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) b
// Positive asserts that the specified element is positive
//
-// a.Positive(1)
-// a.Positive(1.23)
+// a.Positive(1)
+// a.Positive(1.23)
func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1342,8 +1426,8 @@ func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool {
// Positivef asserts that the specified element is positive
//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
+// a.Positivef(1, "error message %s", "formatted")
+// a.Positivef(1.23, "error message %s", "formatted")
func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1353,8 +1437,8 @@ func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) b
// Regexp asserts that a specified regexp matches a string.
//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
+// a.Regexp(regexp.MustCompile("start"), "it's starting")
+// a.Regexp("start...$", "it's not starting")
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1364,8 +1448,8 @@ func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...inter
// Regexpf asserts that a specified regexp matches a string.
//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
+// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1375,7 +1459,7 @@ func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args .
// Same asserts that two pointers reference the same object.
//
-// a.Same(ptr1, ptr2)
+// a.Same(ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1388,7 +1472,7 @@ func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs .
// Samef asserts that two pointers reference the same object.
//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
+// a.Samef(ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1402,7 +1486,7 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string,
// Subset asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1413,7 +1497,7 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...
// Subsetf asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1423,7 +1507,7 @@ func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, a
// True asserts that the specified value is true.
//
-// a.True(myBool)
+// a.True(myBool)
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1433,7 +1517,7 @@ func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
// Truef asserts that the specified value is true.
//
-// a.Truef(myBool, "error message %s", "formatted")
+// a.Truef(myBool, "error message %s", "formatted")
func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1443,7 +1527,7 @@ func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
// WithinDuration asserts that the two times are within duration delta of each other.
//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
+// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1453,7 +1537,7 @@ func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta
// WithinDurationf asserts that the two times are within duration delta of each other.
//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1463,7 +1547,7 @@ func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta
// WithinRange asserts that a time is within a time range (inclusive).
//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1473,7 +1557,7 @@ func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Tim
// WithinRangef asserts that a time is within a time range (inclusive).
//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
if h, ok := a.t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_order.go b/vendor/github.com/stretchr/testify/assert/assertion_order.go
index 75944878..00df62a0 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_order.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_order.go
@@ -46,36 +46,36 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []CompareT
// IsIncreasing asserts that the collection is increasing
//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
+// assert.IsIncreasing(t, []int{1, 2, 3})
+// assert.IsIncreasing(t, []float{1, 2})
+// assert.IsIncreasing(t, []string{"a", "b"})
func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
return isOrdered(t, object, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
}
// IsNonIncreasing asserts that the collection is not increasing
//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
+// assert.IsNonIncreasing(t, []int{2, 1, 1})
+// assert.IsNonIncreasing(t, []float{2, 1})
+// assert.IsNonIncreasing(t, []string{"b", "a"})
func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
return isOrdered(t, object, []CompareType{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
}
// IsDecreasing asserts that the collection is decreasing
//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
+// assert.IsDecreasing(t, []int{2, 1, 0})
+// assert.IsDecreasing(t, []float{2, 1})
+// assert.IsDecreasing(t, []string{"b", "a"})
func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
return isOrdered(t, object, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
}
// IsNonDecreasing asserts that the collection is not decreasing
//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
+// assert.IsNonDecreasing(t, []int{1, 1, 2})
+// assert.IsNonDecreasing(t, []float{1, 2})
+// assert.IsNonDecreasing(t, []string{"a", "b"})
func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
return isOrdered(t, object, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
}
diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go
index 2924cf3a..a55d1bba 100644
--- a/vendor/github.com/stretchr/testify/assert/assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/assertions.go
@@ -75,6 +75,77 @@ func ObjectsAreEqual(expected, actual interface{}) bool {
return bytes.Equal(exp, act)
}
+// copyExportedFields iterates downward through nested data structures and creates a copy
+// that only contains the exported struct fields.
+func copyExportedFields(expected interface{}) interface{} {
+ if isNil(expected) {
+ return expected
+ }
+
+ expectedType := reflect.TypeOf(expected)
+ expectedKind := expectedType.Kind()
+ expectedValue := reflect.ValueOf(expected)
+
+ switch expectedKind {
+ case reflect.Struct:
+ result := reflect.New(expectedType).Elem()
+ for i := 0; i < expectedType.NumField(); i++ {
+ field := expectedType.Field(i)
+ isExported := field.IsExported()
+ if isExported {
+ fieldValue := expectedValue.Field(i)
+ if isNil(fieldValue) || isNil(fieldValue.Interface()) {
+ continue
+ }
+ newValue := copyExportedFields(fieldValue.Interface())
+ result.Field(i).Set(reflect.ValueOf(newValue))
+ }
+ }
+ return result.Interface()
+
+ case reflect.Ptr:
+ result := reflect.New(expectedType.Elem())
+ unexportedRemoved := copyExportedFields(expectedValue.Elem().Interface())
+ result.Elem().Set(reflect.ValueOf(unexportedRemoved))
+ return result.Interface()
+
+ case reflect.Array, reflect.Slice:
+ result := reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len())
+ for i := 0; i < expectedValue.Len(); i++ {
+ index := expectedValue.Index(i)
+ if isNil(index) {
+ continue
+ }
+ unexportedRemoved := copyExportedFields(index.Interface())
+ result.Index(i).Set(reflect.ValueOf(unexportedRemoved))
+ }
+ return result.Interface()
+
+ case reflect.Map:
+ result := reflect.MakeMap(expectedType)
+ for _, k := range expectedValue.MapKeys() {
+ index := expectedValue.MapIndex(k)
+ unexportedRemoved := copyExportedFields(index.Interface())
+ result.SetMapIndex(k, reflect.ValueOf(unexportedRemoved))
+ }
+ return result.Interface()
+
+ default:
+ return expected
+ }
+}
+
+// ObjectsExportedFieldsAreEqual determines if the exported (public) fields of two objects are
+// considered equal. This comparison of only exported fields is applied recursively to nested data
+// structures.
+//
+// This function does no assertion of any kind.
+func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool {
+ expectedCleaned := copyExportedFields(expected)
+ actualCleaned := copyExportedFields(actual)
+ return ObjectsAreEqualValues(expectedCleaned, actualCleaned)
+}
+
// ObjectsAreEqualValues gets whether two objects are equal, or if their
// values are equal.
func ObjectsAreEqualValues(expected, actual interface{}) bool {
@@ -271,7 +342,7 @@ type labeledContent struct {
// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:
//
-// \t{{label}}:{{align_spaces}}\t{{content}}\n
+// \t{{label}}:{{align_spaces}}\t{{content}}\n
//
// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.
// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this
@@ -294,7 +365,7 @@ func labeledOutput(content ...labeledContent) string {
// Implements asserts that an object is implemented by the specified interface.
//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -326,7 +397,7 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs
// Equal asserts that two objects are equal.
//
-// assert.Equal(t, 123, 123)
+// assert.Equal(t, 123, 123)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -367,7 +438,7 @@ func validateEqualArgs(expected, actual interface{}) error {
// Same asserts that two pointers reference the same object.
//
-// assert.Same(t, ptr1, ptr2)
+// assert.Same(t, ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -387,7 +458,7 @@ func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) b
// NotSame asserts that two pointers do not reference the same object.
//
-// assert.NotSame(t, ptr1, ptr2)
+// assert.NotSame(t, ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -455,7 +526,7 @@ func truncatingFormat(data interface{}) string {
// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
-// assert.EqualValues(t, uint32(123), int32(123))
+// assert.EqualValues(t, uint32(123), int32(123))
func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -473,9 +544,53 @@ func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interfa
}
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
+// assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
+func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+
+ aType := reflect.TypeOf(expected)
+ bType := reflect.TypeOf(actual)
+
+ if aType != bType {
+ return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
+ }
+
+ if aType.Kind() != reflect.Struct {
+ return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
+ }
+
+ if bType.Kind() != reflect.Struct {
+ return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
+ }
+
+ expected = copyExportedFields(expected)
+ actual = copyExportedFields(actual)
+
+ if !ObjectsAreEqualValues(expected, actual) {
+ diff := diff(expected, actual)
+ expected, actual = formatUnequalValues(expected, actual)
+ return Fail(t, fmt.Sprintf("Not equal (comparing only exported fields): \n"+
+ "expected: %s\n"+
+ "actual : %s%s", expected, actual, diff), msgAndArgs...)
+ }
+
+ return true
+}
+
// Exactly asserts that two objects are equal in value and type.
//
-// assert.Exactly(t, int32(123), int64(123))
+// assert.Exactly(t, int32(123), int64(123))
func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -494,7 +609,7 @@ func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}
// NotNil asserts that the specified object is not nil.
//
-// assert.NotNil(t, err)
+// assert.NotNil(t, err)
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
if !isNil(object) {
return true
@@ -540,7 +655,7 @@ func isNil(object interface{}) bool {
// Nil asserts that the specified object is nil.
//
-// assert.Nil(t, err)
+// assert.Nil(t, err)
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
if isNil(object) {
return true
@@ -583,7 +698,7 @@ func isEmpty(object interface{}) bool {
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// assert.Empty(t, obj)
+// assert.Empty(t, obj)
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
pass := isEmpty(object)
if !pass {
@@ -600,9 +715,9 @@ func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
+// if assert.NotEmpty(t, obj) {
+// assert.Equal(t, "two", obj[1])
+// }
func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
pass := !isEmpty(object)
if !pass {
@@ -631,7 +746,7 @@ func getLen(x interface{}) (ok bool, length int) {
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
-// assert.Len(t, mySlice, 3)
+// assert.Len(t, mySlice, 3)
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -649,7 +764,7 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})
// True asserts that the specified value is true.
//
-// assert.True(t, myBool)
+// assert.True(t, myBool)
func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
if !value {
if h, ok := t.(tHelper); ok {
@@ -664,7 +779,7 @@ func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
// False asserts that the specified value is false.
//
-// assert.False(t, myBool)
+// assert.False(t, myBool)
func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
if value {
if h, ok := t.(tHelper); ok {
@@ -679,7 +794,7 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
// NotEqual asserts that the specified values are NOT equal.
//
-// assert.NotEqual(t, obj1, obj2)
+// assert.NotEqual(t, obj1, obj2)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -702,7 +817,7 @@ func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{
// NotEqualValues asserts that two objects are not equal even when converted to the same type
//
-// assert.NotEqualValues(t, obj1, obj2)
+// assert.NotEqualValues(t, obj1, obj2)
func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -761,9 +876,9 @@ func containsElement(list interface{}, element interface{}) (ok, found bool) {
// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
+// assert.Contains(t, "Hello World", "World")
+// assert.Contains(t, ["Hello", "World"], "World")
+// assert.Contains(t, {"Hello": "World"}, "Hello")
func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -784,9 +899,9 @@ func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bo
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
+// assert.NotContains(t, "Hello World", "Earth")
+// assert.NotContains(t, ["Hello", "World"], "Earth")
+// assert.NotContains(t, {"Hello": "World"}, "Earth")
func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -794,10 +909,10 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})
ok, found := containsElement(s, contains)
if !ok {
- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+ return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
}
if found {
- return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
+ return Fail(t, fmt.Sprintf("%#v should not contain %#v", s, contains), msgAndArgs...)
}
return true
@@ -807,7 +922,7 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})
// Subset asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -863,7 +978,7 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok
// NotSubset asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1048,7 +1163,7 @@ func didPanic(f PanicTestFunc) (didPanic bool, message interface{}, stack string
// Panics asserts that the code inside the specified PanicTestFunc panics.
//
-// assert.Panics(t, func(){ GoCrazy() })
+// assert.Panics(t, func(){ GoCrazy() })
func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1064,7 +1179,7 @@ func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
+// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1085,7 +1200,7 @@ func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndAr
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
+// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1105,7 +1220,7 @@ func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs .
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// assert.NotPanics(t, func(){ RemainCalm() })
+// assert.NotPanics(t, func(){ RemainCalm() })
func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1120,7 +1235,7 @@ func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
// WithinDuration asserts that the two times are within duration delta of each other.
//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
+// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1136,7 +1251,7 @@ func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration,
// WithinRange asserts that a time is within a time range (inclusive).
//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
func WithinRange(t TestingT, actual, start, end time.Time, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1195,7 +1310,7 @@ func toFloat(x interface{}) (float64, bool) {
// InDelta asserts that the two numerals are within delta of each other.
//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
+// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1368,10 +1483,10 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m
// NoError asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if assert.NoError(t, err) {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
if err != nil {
if h, ok := t.(tHelper); ok {
@@ -1385,10 +1500,10 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
// Error asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err) {
+// assert.Equal(t, expectedError, err)
+// }
func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
if err == nil {
if h, ok := t.(tHelper); ok {
@@ -1403,8 +1518,8 @@ func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
+// actualObj, err := SomeFunction()
+// assert.EqualError(t, err, expectedErrorString)
func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1426,8 +1541,8 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte
// ErrorContains asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
+// actualObj, err := SomeFunction()
+// assert.ErrorContains(t, err, expectedErrorSubString)
func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1460,8 +1575,8 @@ func matchRegexp(rx interface{}, str interface{}) bool {
// Regexp asserts that a specified regexp matches a string.
//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1478,8 +1593,8 @@ func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface
// NotRegexp asserts that a specified regexp does not match a string.
//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1591,7 +1706,7 @@ func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
// JSONEq asserts that two JSON strings are equivalent.
//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1714,7 +1829,7 @@ type tHelper interface {
// Eventually asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
+// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1744,10 +1859,93 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t
}
}
+// CollectT implements the TestingT interface and collects all errors.
+type CollectT struct {
+ errors []error
+}
+
+// Errorf collects the error.
+func (c *CollectT) Errorf(format string, args ...interface{}) {
+ c.errors = append(c.errors, fmt.Errorf(format, args...))
+}
+
+// FailNow panics.
+func (c *CollectT) FailNow() {
+ panic("Assertion failed")
+}
+
+// Reset clears the collected errors.
+func (c *CollectT) Reset() {
+ c.errors = nil
+}
+
+// Copy copies the collected errors to the supplied t.
+func (c *CollectT) Copy(t TestingT) {
+ if tt, ok := t.(tHelper); ok {
+ tt.Helper()
+ }
+ for _, err := range c.errors {
+ t.Errorf("%v", err)
+ }
+}
+
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// assert.EventuallyWithT(t, func(c *assert.CollectT) {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+
+ collect := new(CollectT)
+ ch := make(chan bool, 1)
+
+ timer := time.NewTimer(waitFor)
+ defer timer.Stop()
+
+ ticker := time.NewTicker(tick)
+ defer ticker.Stop()
+
+ for tick := ticker.C; ; {
+ select {
+ case <-timer.C:
+ collect.Copy(t)
+ return Fail(t, "Condition never satisfied", msgAndArgs...)
+ case <-tick:
+ tick = nil
+ collect.Reset()
+ go func() {
+ condition(collect)
+ ch <- len(collect.errors) == 0
+ }()
+ case v := <-ch:
+ if v {
+ return true
+ }
+ tick = ticker.C
+ }
+ }
+}
+
// Never asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
+// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go
index c9dccc4d..4953981d 100644
--- a/vendor/github.com/stretchr/testify/assert/doc.go
+++ b/vendor/github.com/stretchr/testify/assert/doc.go
@@ -1,39 +1,40 @@
// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
//
-// Example Usage
+// # Example Usage
//
// The following is a complete example using assert in a standard test function:
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// )
//
-// func TestSomething(t *testing.T) {
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
//
-// var a string = "Hello"
-// var b string = "Hello"
+// func TestSomething(t *testing.T) {
//
-// assert.Equal(t, a, b, "The two words should be the same.")
+// var a string = "Hello"
+// var b string = "Hello"
//
-// }
+// assert.Equal(t, a, b, "The two words should be the same.")
+//
+// }
//
// if you assert many times, use the format below:
//
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// )
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
//
-// func TestSomething(t *testing.T) {
-// assert := assert.New(t)
+// func TestSomething(t *testing.T) {
+// assert := assert.New(t)
//
-// var a string = "Hello"
-// var b string = "Hello"
+// var a string = "Hello"
+// var b string = "Hello"
//
-// assert.Equal(a, b, "The two words should be the same.")
-// }
+// assert.Equal(a, b, "The two words should be the same.")
+// }
//
-// Assertions
+// # Assertions
//
// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
// All assertion functions take, as the first argument, the `*testing.T` object provided by the
diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go
index 4ed341dd..d8038c28 100644
--- a/vendor/github.com/stretchr/testify/assert/http_assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go
@@ -23,7 +23,7 @@ func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (
// HTTPSuccess asserts that a specified handler returns a success status code.
//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -45,7 +45,7 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value
// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -67,7 +67,7 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu
// HTTPError asserts that a specified handler returns an error status code.
//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@@ -89,7 +89,7 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values
// HTTPStatusCode asserts that a specified handler returns a specified status code.
//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
+// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
@@ -124,7 +124,7 @@ func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) s
// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
@@ -144,7 +144,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string,
// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go
index 169de392..96843472 100644
--- a/vendor/github.com/stretchr/testify/require/doc.go
+++ b/vendor/github.com/stretchr/testify/require/doc.go
@@ -1,24 +1,25 @@
// Package require implements the same assertions as the `assert` package but
// stops test execution when a test fails.
//
-// Example Usage
+// # Example Usage
//
// The following is a complete example using require in a standard test function:
-// import (
-// "testing"
-// "github.com/stretchr/testify/require"
-// )
//
-// func TestSomething(t *testing.T) {
+// import (
+// "testing"
+// "github.com/stretchr/testify/require"
+// )
//
-// var a string = "Hello"
-// var b string = "Hello"
+// func TestSomething(t *testing.T) {
//
-// require.Equal(t, a, b, "The two words should be the same.")
+// var a string = "Hello"
+// var b string = "Hello"
//
-// }
+// require.Equal(t, a, b, "The two words should be the same.")
//
-// Assertions
+// }
+//
+// # Assertions
//
// The `require` package have same global functions as in the `assert` package,
// but instead of returning a boolean result they call `t.FailNow()`.
diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go
index 880853f5..63f85214 100644
--- a/vendor/github.com/stretchr/testify/require/require.go
+++ b/vendor/github.com/stretchr/testify/require/require.go
@@ -37,9 +37,9 @@ func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interfac
// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
+// assert.Contains(t, "Hello World", "World")
+// assert.Contains(t, ["Hello", "World"], "World")
+// assert.Contains(t, {"Hello": "World"}, "Hello")
func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -53,9 +53,9 @@ func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...int
// Containsf asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -123,7 +123,7 @@ func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// assert.Empty(t, obj)
+// assert.Empty(t, obj)
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -137,7 +137,7 @@ func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
+// assert.Emptyf(t, obj, "error message %s", "formatted")
func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -150,7 +150,7 @@ func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
// Equal asserts that two objects are equal.
//
-// assert.Equal(t, 123, 123)
+// assert.Equal(t, 123, 123)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -168,8 +168,8 @@ func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...i
// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
+// actualObj, err := SomeFunction()
+// assert.EqualError(t, err, expectedErrorString)
func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -183,8 +183,8 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte
// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -195,10 +195,50 @@ func EqualErrorf(t TestingT, theError error, errString string, msg string, args
t.FailNow()
}
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
+// assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
+func EqualExportedValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ if assert.EqualExportedValues(t, expected, actual, msgAndArgs...) {
+ return
+ }
+ t.FailNow()
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+// assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ if assert.EqualExportedValuesf(t, expected, actual, msg, args...) {
+ return
+ }
+ t.FailNow()
+}
+
// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
-// assert.EqualValues(t, uint32(123), int32(123))
+// assert.EqualValues(t, uint32(123), int32(123))
func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -212,7 +252,7 @@ func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArg
// EqualValuesf asserts that two objects are equal or convertable to the same types
// and equal.
//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
+// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -225,7 +265,7 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri
// Equalf asserts that two objects are equal.
//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
+// assert.Equalf(t, 123, 123, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -242,10 +282,10 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar
// Error asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err) {
+// assert.Equal(t, expectedError, err)
+// }
func Error(t TestingT, err error, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -283,8 +323,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int
// ErrorContains asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
+// actualObj, err := SomeFunction()
+// assert.ErrorContains(t, err, expectedErrorSubString)
func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -298,8 +338,8 @@ func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...in
// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -336,10 +376,10 @@ func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface
// Errorf asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
+// actualObj, err := SomeFunction()
+// if assert.Errorf(t, err, "error message %s", "formatted") {
+// assert.Equal(t, expectedErrorf, err)
+// }
func Errorf(t TestingT, err error, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -353,7 +393,7 @@ func Errorf(t TestingT, err error, msg string, args ...interface{}) {
// Eventually asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
+// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -364,10 +404,66 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t
t.FailNow()
}
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// assert.EventuallyWithT(t, func(c *assert.CollectT) {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithT(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ if assert.EventuallyWithT(t, condition, waitFor, tick, msgAndArgs...) {
+ return
+ }
+ t.FailNow()
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithTf(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+ if h, ok := t.(tHelper); ok {
+ h.Helper()
+ }
+ if assert.EventuallyWithTf(t, condition, waitFor, tick, msg, args...) {
+ return
+ }
+ t.FailNow()
+}
+
// Eventuallyf asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -380,7 +476,7 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick
// Exactly asserts that two objects are equal in value and type.
//
-// assert.Exactly(t, int32(123), int64(123))
+// assert.Exactly(t, int32(123), int64(123))
func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -393,7 +489,7 @@ func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ..
// Exactlyf asserts that two objects are equal in value and type.
//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
+// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -450,7 +546,7 @@ func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) {
// False asserts that the specified value is false.
//
-// assert.False(t, myBool)
+// assert.False(t, myBool)
func False(t TestingT, value bool, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -463,7 +559,7 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) {
// Falsef asserts that the specified value is false.
//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
+// assert.Falsef(t, myBool, "error message %s", "formatted")
func Falsef(t TestingT, value bool, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -500,9 +596,9 @@ func FileExistsf(t TestingT, path string, msg string, args ...interface{}) {
// Greater asserts that the first element is greater than the second
//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
+// assert.Greater(t, 2, 1)
+// assert.Greater(t, float64(2), float64(1))
+// assert.Greater(t, "b", "a")
func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -515,10 +611,10 @@ func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface
// GreaterOrEqual asserts that the first element is greater than or equal to the second
//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
+// assert.GreaterOrEqual(t, 2, 1)
+// assert.GreaterOrEqual(t, 2, 2)
+// assert.GreaterOrEqual(t, "b", "a")
+// assert.GreaterOrEqual(t, "b", "b")
func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -531,10 +627,10 @@ func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...in
// GreaterOrEqualf asserts that the first element is greater than or equal to the second
//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
+// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -547,9 +643,9 @@ func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, arg
// Greaterf asserts that the first element is greater than the second
//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
+// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
+// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
+// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -563,7 +659,7 @@ func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...in
// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
@@ -579,7 +675,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url s
// HTTPBodyContainsf asserts that a specified handler returns a
// body that contains a string.
//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
@@ -595,7 +691,7 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url
// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
@@ -611,7 +707,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, ur
// HTTPBodyNotContainsf asserts that a specified handler returns a
// body that does not contain a string.
//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
@@ -626,7 +722,7 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u
// HTTPError asserts that a specified handler returns an error status code.
//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -641,7 +737,7 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string,
// HTTPErrorf asserts that a specified handler returns an error status code.
//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -656,7 +752,7 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string,
// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -671,7 +767,7 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url strin
// HTTPRedirectf asserts that a specified handler returns a redirect status code.
//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -686,7 +782,7 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri
// HTTPStatusCode asserts that a specified handler returns a specified status code.
//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
+// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
@@ -701,7 +797,7 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url str
// HTTPStatusCodef asserts that a specified handler returns a specified status code.
//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
@@ -716,7 +812,7 @@ func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url st
// HTTPSuccess asserts that a specified handler returns a success status code.
//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -731,7 +827,7 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string
// HTTPSuccessf asserts that a specified handler returns a success status code.
//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -746,7 +842,7 @@ func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url strin
// Implements asserts that an object is implemented by the specified interface.
//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -759,7 +855,7 @@ func Implements(t TestingT, interfaceObject interface{}, object interface{}, msg
// Implementsf asserts that an object is implemented by the specified interface.
//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -772,7 +868,7 @@ func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, ms
// InDelta asserts that the two numerals are within delta of each other.
//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
+// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -829,7 +925,7 @@ func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta f
// InDeltaf asserts that the two numerals are within delta of each other.
//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -886,9 +982,9 @@ func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon fl
// IsDecreasing asserts that the collection is decreasing
//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
+// assert.IsDecreasing(t, []int{2, 1, 0})
+// assert.IsDecreasing(t, []float{2, 1})
+// assert.IsDecreasing(t, []string{"b", "a"})
func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -901,9 +997,9 @@ func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// IsDecreasingf asserts that the collection is decreasing
//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
+// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -916,9 +1012,9 @@ func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface
// IsIncreasing asserts that the collection is increasing
//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
+// assert.IsIncreasing(t, []int{1, 2, 3})
+// assert.IsIncreasing(t, []float{1, 2})
+// assert.IsIncreasing(t, []string{"a", "b"})
func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -931,9 +1027,9 @@ func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// IsIncreasingf asserts that the collection is increasing
//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
+// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -946,9 +1042,9 @@ func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface
// IsNonDecreasing asserts that the collection is not decreasing
//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
+// assert.IsNonDecreasing(t, []int{1, 1, 2})
+// assert.IsNonDecreasing(t, []float{1, 2})
+// assert.IsNonDecreasing(t, []string{"a", "b"})
func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -961,9 +1057,9 @@ func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{})
// IsNonDecreasingf asserts that the collection is not decreasing
//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
+// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -976,9 +1072,9 @@ func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interf
// IsNonIncreasing asserts that the collection is not increasing
//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
+// assert.IsNonIncreasing(t, []int{2, 1, 1})
+// assert.IsNonIncreasing(t, []float{2, 1})
+// assert.IsNonIncreasing(t, []string{"b", "a"})
func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -991,9 +1087,9 @@ func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{})
// IsNonIncreasingf asserts that the collection is not increasing
//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
+// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1028,7 +1124,7 @@ func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg strin
// JSONEq asserts that two JSON strings are equivalent.
//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1041,7 +1137,7 @@ func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{
// JSONEqf asserts that two JSON strings are equivalent.
//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1055,7 +1151,7 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
-// assert.Len(t, mySlice, 3)
+// assert.Len(t, mySlice, 3)
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1069,7 +1165,7 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})
// Lenf asserts that the specified object has specific length.
// Lenf also fails if the object has a type that len() not accept.
//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1082,9 +1178,9 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf
// Less asserts that the first element is less than the second
//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
+// assert.Less(t, 1, 2)
+// assert.Less(t, float64(1), float64(2))
+// assert.Less(t, "a", "b")
func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1097,10 +1193,10 @@ func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})
// LessOrEqual asserts that the first element is less than or equal to the second
//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
+// assert.LessOrEqual(t, 1, 2)
+// assert.LessOrEqual(t, 2, 2)
+// assert.LessOrEqual(t, "a", "b")
+// assert.LessOrEqual(t, "b", "b")
func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1113,10 +1209,10 @@ func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...inter
// LessOrEqualf asserts that the first element is less than or equal to the second
//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
+// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
+// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
+// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
+// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1129,9 +1225,9 @@ func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args .
// Lessf asserts that the first element is less than the second
//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
+// assert.Lessf(t, 1, 2, "error message %s", "formatted")
+// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
+// assert.Lessf(t, "a", "b", "error message %s", "formatted")
func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1144,8 +1240,8 @@ func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...inter
// Negative asserts that the specified element is negative
//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
+// assert.Negative(t, -1)
+// assert.Negative(t, -1.23)
func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1158,8 +1254,8 @@ func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) {
// Negativef asserts that the specified element is negative
//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
+// assert.Negativef(t, -1, "error message %s", "formatted")
+// assert.Negativef(t, -1.23, "error message %s", "formatted")
func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1173,7 +1269,7 @@ func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) {
// Never asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
+// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1187,7 +1283,7 @@ func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.D
// Neverf asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1200,7 +1296,7 @@ func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.
// Nil asserts that the specified object is nil.
//
-// assert.Nil(t, err)
+// assert.Nil(t, err)
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1213,7 +1309,7 @@ func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// Nilf asserts that the specified object is nil.
//
-// assert.Nilf(t, err, "error message %s", "formatted")
+// assert.Nilf(t, err, "error message %s", "formatted")
func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1250,10 +1346,10 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) {
// NoError asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if assert.NoError(t, err) {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1266,10 +1362,10 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
// NoErrorf asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if assert.NoErrorf(t, err, "error message %s", "formatted") {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func NoErrorf(t TestingT, err error, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1307,9 +1403,9 @@ func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) {
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
+// assert.NotContains(t, "Hello World", "Earth")
+// assert.NotContains(t, ["Hello", "World"], "Earth")
+// assert.NotContains(t, {"Hello": "World"}, "Earth")
func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1323,9 +1419,9 @@ func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...
// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1339,9 +1435,9 @@ func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, a
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
+// if assert.NotEmpty(t, obj) {
+// assert.Equal(t, "two", obj[1])
+// }
func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1355,9 +1451,9 @@ func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
+// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+// assert.Equal(t, "two", obj[1])
+// }
func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1370,7 +1466,7 @@ func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{})
// NotEqual asserts that the specified values are NOT equal.
//
-// assert.NotEqual(t, obj1, obj2)
+// assert.NotEqual(t, obj1, obj2)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1386,7 +1482,7 @@ func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs .
// NotEqualValues asserts that two objects are not equal even when converted to the same type
//
-// assert.NotEqualValues(t, obj1, obj2)
+// assert.NotEqualValues(t, obj1, obj2)
func NotEqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1399,7 +1495,7 @@ func NotEqualValues(t TestingT, expected interface{}, actual interface{}, msgAnd
// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
+// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1412,7 +1508,7 @@ func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg s
// NotEqualf asserts that the specified values are NOT equal.
//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1452,7 +1548,7 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf
// NotNil asserts that the specified object is not nil.
//
-// assert.NotNil(t, err)
+// assert.NotNil(t, err)
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1465,7 +1561,7 @@ func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
// NotNilf asserts that the specified object is not nil.
//
-// assert.NotNilf(t, err, "error message %s", "formatted")
+// assert.NotNilf(t, err, "error message %s", "formatted")
func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1478,7 +1574,7 @@ func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) {
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// assert.NotPanics(t, func(){ RemainCalm() })
+// assert.NotPanics(t, func(){ RemainCalm() })
func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1491,7 +1587,7 @@ func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1504,8 +1600,8 @@ func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interfac
// NotRegexp asserts that a specified regexp does not match a string.
//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1518,8 +1614,8 @@ func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interf
// NotRegexpf asserts that a specified regexp does not match a string.
//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1532,7 +1628,7 @@ func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ..
// NotSame asserts that two pointers do not reference the same object.
//
-// assert.NotSame(t, ptr1, ptr2)
+// assert.NotSame(t, ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1548,7 +1644,7 @@ func NotSame(t TestingT, expected interface{}, actual interface{}, msgAndArgs ..
// NotSamef asserts that two pointers do not reference the same object.
//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
+// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1565,7 +1661,7 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string,
// NotSubset asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1579,7 +1675,7 @@ func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...i
// NotSubsetf asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1614,7 +1710,7 @@ func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) {
// Panics asserts that the code inside the specified PanicTestFunc panics.
//
-// assert.Panics(t, func(){ GoCrazy() })
+// assert.Panics(t, func(){ GoCrazy() })
func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1629,7 +1725,7 @@ func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
+// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1644,7 +1740,7 @@ func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAn
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1658,7 +1754,7 @@ func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg
// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
+// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1672,7 +1768,7 @@ func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, m
// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1685,7 +1781,7 @@ func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc,
// Panicsf asserts that the code inside the specified PanicTestFunc panics.
//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1698,8 +1794,8 @@ func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}
// Positive asserts that the specified element is positive
//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
+// assert.Positive(t, 1)
+// assert.Positive(t, 1.23)
func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1712,8 +1808,8 @@ func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) {
// Positivef asserts that the specified element is positive
//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
+// assert.Positivef(t, 1, "error message %s", "formatted")
+// assert.Positivef(t, 1.23, "error message %s", "formatted")
func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1726,8 +1822,8 @@ func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) {
// Regexp asserts that a specified regexp matches a string.
//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1740,8 +1836,8 @@ func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface
// Regexpf asserts that a specified regexp matches a string.
//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1754,7 +1850,7 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in
// Same asserts that two pointers reference the same object.
//
-// assert.Same(t, ptr1, ptr2)
+// assert.Same(t, ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1770,7 +1866,7 @@ func Same(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...in
// Samef asserts that two pointers reference the same object.
//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
+// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1787,7 +1883,7 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg
// Subset asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1801,7 +1897,7 @@ func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...inte
// Subsetf asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1814,7 +1910,7 @@ func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args
// True asserts that the specified value is true.
//
-// assert.True(t, myBool)
+// assert.True(t, myBool)
func True(t TestingT, value bool, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1827,7 +1923,7 @@ func True(t TestingT, value bool, msgAndArgs ...interface{}) {
// Truef asserts that the specified value is true.
//
-// assert.Truef(t, myBool, "error message %s", "formatted")
+// assert.Truef(t, myBool, "error message %s", "formatted")
func Truef(t TestingT, value bool, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1840,7 +1936,7 @@ func Truef(t TestingT, value bool, msg string, args ...interface{}) {
// WithinDuration asserts that the two times are within duration delta of each other.
//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
+// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1853,7 +1949,7 @@ func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time
// WithinDurationf asserts that the two times are within duration delta of each other.
//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1866,7 +1962,7 @@ func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta tim
// WithinRange asserts that a time is within a time range (inclusive).
//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
func WithinRange(t TestingT, actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
@@ -1879,7 +1975,7 @@ func WithinRange(t TestingT, actual time.Time, start time.Time, end time.Time, m
// WithinRangef asserts that a time is within a time range (inclusive).
//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
if h, ok := t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go
index 960bf6f2..3b5b0933 100644
--- a/vendor/github.com/stretchr/testify/require/require_forward.go
+++ b/vendor/github.com/stretchr/testify/require/require_forward.go
@@ -31,9 +31,9 @@ func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...inte
// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
+// a.Contains("Hello World", "World")
+// a.Contains(["Hello", "World"], "World")
+// a.Contains({"Hello": "World"}, "Hello")
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -44,9 +44,9 @@ func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ..
// Containsf asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
+// a.Containsf("Hello World", "World", "error message %s", "formatted")
+// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
+// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -99,7 +99,7 @@ func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg st
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// a.Empty(obj)
+// a.Empty(obj)
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -110,7 +110,7 @@ func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// a.Emptyf(obj, "error message %s", "formatted")
+// a.Emptyf(obj, "error message %s", "formatted")
func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -120,7 +120,7 @@ func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{})
// Equal asserts that two objects are equal.
//
-// a.Equal(123, 123)
+// a.Equal(123, 123)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -135,8 +135,8 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs
// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
+// actualObj, err := SomeFunction()
+// a.EqualError(err, expectedErrorString)
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -147,8 +147,8 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...
// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -156,10 +156,44 @@ func (a *Assertions) EqualErrorf(theError error, errString string, msg string, a
EqualErrorf(a.t, theError, errString, msg, args...)
}
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
+// a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
+func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ EqualExportedValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+// type S struct {
+// Exported int
+// notExported int
+// }
+// a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+// a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ EqualExportedValuesf(a.t, expected, actual, msg, args...)
+}
+
// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
-// a.EqualValues(uint32(123), int32(123))
+// a.EqualValues(uint32(123), int32(123))
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -170,7 +204,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn
// EqualValuesf asserts that two objects are equal or convertable to the same types
// and equal.
//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
+// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -180,7 +214,7 @@ func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg
// Equalf asserts that two objects are equal.
//
-// a.Equalf(123, 123, "error message %s", "formatted")
+// a.Equalf(123, 123, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
@@ -194,10 +228,10 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string
// Error asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
+// actualObj, err := SomeFunction()
+// if a.Error(err) {
+// assert.Equal(t, expectedError, err)
+// }
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -226,8 +260,8 @@ func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ..
// ErrorContains asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
+// actualObj, err := SomeFunction()
+// a.ErrorContains(err, expectedErrorSubString)
func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -238,8 +272,8 @@ func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs .
// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
// and that the error contains the specified substring.
//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
+// actualObj, err := SomeFunction()
+// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -267,10 +301,10 @@ func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...inter
// Errorf asserts that a function returned an error (i.e. not `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
+// actualObj, err := SomeFunction()
+// if a.Errorf(err, "error message %s", "formatted") {
+// assert.Equal(t, expectedErrorf, err)
+// }
func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -281,7 +315,7 @@ func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
// Eventually asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
+// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -289,10 +323,60 @@ func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, ti
Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
}
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// a.EventuallyWithT(func(c *assert.CollectT) {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+// externalValue := false
+// go func() {
+// time.Sleep(8*time.Second)
+// externalValue = true
+// }()
+// a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+// // add assertions as needed; any assertion failure will fail the current tick
+// assert.True(c, externalValue, "expected 'externalValue' to be true")
+// }, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithTf(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+ if h, ok := a.t.(tHelper); ok {
+ h.Helper()
+ }
+ EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
+}
+
// Eventuallyf asserts that given condition will be met in waitFor time,
// periodically checking target function each tick.
//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -302,7 +386,7 @@ func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, t
// Exactly asserts that two objects are equal in value and type.
//
-// a.Exactly(int32(123), int64(123))
+// a.Exactly(int32(123), int64(123))
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -312,7 +396,7 @@ func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArg
// Exactlyf asserts that two objects are equal in value and type.
//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
+// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -354,7 +438,7 @@ func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{
// False asserts that the specified value is false.
//
-// a.False(myBool)
+// a.False(myBool)
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -364,7 +448,7 @@ func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
// Falsef asserts that the specified value is false.
//
-// a.Falsef(myBool, "error message %s", "formatted")
+// a.Falsef(myBool, "error message %s", "formatted")
func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -392,9 +476,9 @@ func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) {
// Greater asserts that the first element is greater than the second
//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
+// a.Greater(2, 1)
+// a.Greater(float64(2), float64(1))
+// a.Greater("b", "a")
func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -404,10 +488,10 @@ func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...inter
// GreaterOrEqual asserts that the first element is greater than or equal to the second
//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
+// a.GreaterOrEqual(2, 1)
+// a.GreaterOrEqual(2, 2)
+// a.GreaterOrEqual("b", "a")
+// a.GreaterOrEqual("b", "b")
func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -417,10 +501,10 @@ func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs .
// GreaterOrEqualf asserts that the first element is greater than or equal to the second
//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
+// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
+// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
+// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
+// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -430,9 +514,9 @@ func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string,
// Greaterf asserts that the first element is greater than the second
//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
+// a.Greaterf(2, 1, "error message %s", "formatted")
+// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
+// a.Greaterf("b", "a", "error message %s", "formatted")
func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -443,7 +527,7 @@ func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args .
// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
@@ -456,7 +540,7 @@ func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, u
// HTTPBodyContainsf asserts that a specified handler returns a
// body that contains a string.
//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
@@ -469,7 +553,7 @@ func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string,
// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
@@ -482,7 +566,7 @@ func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string
// HTTPBodyNotContainsf asserts that a specified handler returns a
// body that does not contain a string.
//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
@@ -494,7 +578,7 @@ func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method strin
// HTTPError asserts that a specified handler returns an error status code.
//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -506,7 +590,7 @@ func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url stri
// HTTPErrorf asserts that a specified handler returns an error status code.
//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -518,7 +602,7 @@ func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url str
// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -530,7 +614,7 @@ func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url s
// HTTPRedirectf asserts that a specified handler returns a redirect status code.
//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -542,7 +626,7 @@ func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url
// HTTPStatusCode asserts that a specified handler returns a specified status code.
//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
+// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
@@ -554,7 +638,7 @@ func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url
// HTTPStatusCodef asserts that a specified handler returns a specified status code.
//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
@@ -566,7 +650,7 @@ func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, ur
// HTTPSuccess asserts that a specified handler returns a success status code.
//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
@@ -578,7 +662,7 @@ func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url st
// HTTPSuccessf asserts that a specified handler returns a success status code.
//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
@@ -590,7 +674,7 @@ func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url s
// Implements asserts that an object is implemented by the specified interface.
//
-// a.Implements((*MyInterface)(nil), new(MyObject))
+// a.Implements((*MyInterface)(nil), new(MyObject))
func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -600,7 +684,7 @@ func (a *Assertions) Implements(interfaceObject interface{}, object interface{},
// Implementsf asserts that an object is implemented by the specified interface.
//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -610,7 +694,7 @@ func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}
// InDelta asserts that the two numerals are within delta of each other.
//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
+// a.InDelta(math.Pi, 22/7.0, 0.01)
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -652,7 +736,7 @@ func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, del
// InDeltaf asserts that the two numerals are within delta of each other.
//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -694,9 +778,9 @@ func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilo
// IsDecreasing asserts that the collection is decreasing
//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
+// a.IsDecreasing([]int{2, 1, 0})
+// a.IsDecreasing([]float{2, 1})
+// a.IsDecreasing([]string{"b", "a"})
func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -706,9 +790,9 @@ func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{})
// IsDecreasingf asserts that the collection is decreasing
//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
+// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
+// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
+// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -718,9 +802,9 @@ func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...inter
// IsIncreasing asserts that the collection is increasing
//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
+// a.IsIncreasing([]int{1, 2, 3})
+// a.IsIncreasing([]float{1, 2})
+// a.IsIncreasing([]string{"a", "b"})
func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -730,9 +814,9 @@ func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{})
// IsIncreasingf asserts that the collection is increasing
//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
+// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
+// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
+// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -742,9 +826,9 @@ func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...inter
// IsNonDecreasing asserts that the collection is not decreasing
//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
+// a.IsNonDecreasing([]int{1, 1, 2})
+// a.IsNonDecreasing([]float{1, 2})
+// a.IsNonDecreasing([]string{"a", "b"})
func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -754,9 +838,9 @@ func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface
// IsNonDecreasingf asserts that the collection is not decreasing
//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
+// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -766,9 +850,9 @@ func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...in
// IsNonIncreasing asserts that the collection is not increasing
//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
+// a.IsNonIncreasing([]int{2, 1, 1})
+// a.IsNonIncreasing([]float{2, 1})
+// a.IsNonIncreasing([]string{"b", "a"})
func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -778,9 +862,9 @@ func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface
// IsNonIncreasingf asserts that the collection is not increasing
//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
+// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -806,7 +890,7 @@ func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg s
// JSONEq asserts that two JSON strings are equivalent.
//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -816,7 +900,7 @@ func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interf
// JSONEqf asserts that two JSON strings are equivalent.
//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -827,7 +911,7 @@ func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ..
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
-// a.Len(mySlice, 3)
+// a.Len(mySlice, 3)
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -838,7 +922,7 @@ func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface
// Lenf asserts that the specified object has specific length.
// Lenf also fails if the object has a type that len() not accept.
//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
+// a.Lenf(mySlice, 3, "error message %s", "formatted")
func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -848,9 +932,9 @@ func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...in
// Less asserts that the first element is less than the second
//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
+// a.Less(1, 2)
+// a.Less(float64(1), float64(2))
+// a.Less("a", "b")
func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -860,10 +944,10 @@ func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interfac
// LessOrEqual asserts that the first element is less than or equal to the second
//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
+// a.LessOrEqual(1, 2)
+// a.LessOrEqual(2, 2)
+// a.LessOrEqual("a", "b")
+// a.LessOrEqual("b", "b")
func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -873,10 +957,10 @@ func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...i
// LessOrEqualf asserts that the first element is less than or equal to the second
//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
+// a.LessOrEqualf(1, 2, "error message %s", "formatted")
+// a.LessOrEqualf(2, 2, "error message %s", "formatted")
+// a.LessOrEqualf("a", "b", "error message %s", "formatted")
+// a.LessOrEqualf("b", "b", "error message %s", "formatted")
func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -886,9 +970,9 @@ func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, ar
// Lessf asserts that the first element is less than the second
//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
+// a.Lessf(1, 2, "error message %s", "formatted")
+// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
+// a.Lessf("a", "b", "error message %s", "formatted")
func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -898,8 +982,8 @@ func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...i
// Negative asserts that the specified element is negative
//
-// a.Negative(-1)
-// a.Negative(-1.23)
+// a.Negative(-1)
+// a.Negative(-1.23)
func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -909,8 +993,8 @@ func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) {
// Negativef asserts that the specified element is negative
//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
+// a.Negativef(-1, "error message %s", "formatted")
+// a.Negativef(-1.23, "error message %s", "formatted")
func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -921,7 +1005,7 @@ func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) {
// Never asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
+// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -932,7 +1016,7 @@ func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick ti
// Neverf asserts that the given condition doesn't satisfy in waitFor time,
// periodically checking the target function each tick.
//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -942,7 +1026,7 @@ func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick t
// Nil asserts that the specified object is nil.
//
-// a.Nil(err)
+// a.Nil(err)
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -952,7 +1036,7 @@ func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
// Nilf asserts that the specified object is nil.
//
-// a.Nilf(err, "error message %s", "formatted")
+// a.Nilf(err, "error message %s", "formatted")
func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -980,10 +1064,10 @@ func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{})
// NoError asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if a.NoError(err) {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -993,10 +1077,10 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
// NoErrorf asserts that a function returned no error (i.e. `nil`).
//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
+// actualObj, err := SomeFunction()
+// if a.NoErrorf(err, "error message %s", "formatted") {
+// assert.Equal(t, expectedObj, actualObj)
+// }
func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1025,9 +1109,9 @@ func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{})
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
+// a.NotContains("Hello World", "Earth")
+// a.NotContains(["Hello", "World"], "Earth")
+// a.NotContains({"Hello": "World"}, "Earth")
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1038,9 +1122,9 @@ func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs
// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
+// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
+// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
+// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1051,9 +1135,9 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
+// if a.NotEmpty(obj) {
+// assert.Equal(t, "two", obj[1])
+// }
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1064,9 +1148,9 @@ func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
+// if a.NotEmptyf(obj, "error message %s", "formatted") {
+// assert.Equal(t, "two", obj[1])
+// }
func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1076,7 +1160,7 @@ func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface
// NotEqual asserts that the specified values are NOT equal.
//
-// a.NotEqual(obj1, obj2)
+// a.NotEqual(obj1, obj2)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1089,7 +1173,7 @@ func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndAr
// NotEqualValues asserts that two objects are not equal even when converted to the same type
//
-// a.NotEqualValues(obj1, obj2)
+// a.NotEqualValues(obj1, obj2)
func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1099,7 +1183,7 @@ func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, ms
// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
+// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1109,7 +1193,7 @@ func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, m
// NotEqualf asserts that the specified values are NOT equal.
//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
+// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
@@ -1140,7 +1224,7 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in
// NotNil asserts that the specified object is not nil.
//
-// a.NotNil(err)
+// a.NotNil(err)
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1150,7 +1234,7 @@ func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
// NotNilf asserts that the specified object is not nil.
//
-// a.NotNilf(err, "error message %s", "formatted")
+// a.NotNilf(err, "error message %s", "formatted")
func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1160,7 +1244,7 @@ func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// a.NotPanics(func(){ RemainCalm() })
+// a.NotPanics(func(){ RemainCalm() })
func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1170,7 +1254,7 @@ func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
+// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1180,8 +1264,8 @@ func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...inte
// NotRegexp asserts that a specified regexp does not match a string.
//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
+// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+// a.NotRegexp("^start", "it's not starting")
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1191,8 +1275,8 @@ func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...in
// NotRegexpf asserts that a specified regexp does not match a string.
//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
+// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1202,7 +1286,7 @@ func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, arg
// NotSame asserts that two pointers do not reference the same object.
//
-// a.NotSame(ptr1, ptr2)
+// a.NotSame(ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1215,7 +1299,7 @@ func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArg
// NotSamef asserts that two pointers do not reference the same object.
//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
+// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1229,7 +1313,7 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri
// NotSubset asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1240,7 +1324,7 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs
// NotSubsetf asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1266,7 +1350,7 @@ func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) {
// Panics asserts that the code inside the specified PanicTestFunc panics.
//
-// a.Panics(func(){ GoCrazy() })
+// a.Panics(func(){ GoCrazy() })
func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1278,7 +1362,7 @@ func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
+// a.PanicsWithError("crazy error", func(){ GoCrazy() })
func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1290,7 +1374,7 @@ func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, m
// panics, and that the recovered panic value is an error that satisfies the
// EqualError comparison.
//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1301,7 +1385,7 @@ func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc,
// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
+// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1312,7 +1396,7 @@ func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFun
// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1322,7 +1406,7 @@ func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFu
// Panicsf asserts that the code inside the specified PanicTestFunc panics.
//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
+// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1332,8 +1416,8 @@ func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interfa
// Positive asserts that the specified element is positive
//
-// a.Positive(1)
-// a.Positive(1.23)
+// a.Positive(1)
+// a.Positive(1.23)
func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1343,8 +1427,8 @@ func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) {
// Positivef asserts that the specified element is positive
//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
+// a.Positivef(1, "error message %s", "formatted")
+// a.Positivef(1.23, "error message %s", "formatted")
func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1354,8 +1438,8 @@ func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) {
// Regexp asserts that a specified regexp matches a string.
//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
+// a.Regexp(regexp.MustCompile("start"), "it's starting")
+// a.Regexp("start...$", "it's not starting")
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1365,8 +1449,8 @@ func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...inter
// Regexpf asserts that a specified regexp matches a string.
//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
+// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1376,7 +1460,7 @@ func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args .
// Same asserts that two pointers reference the same object.
//
-// a.Same(ptr1, ptr2)
+// a.Same(ptr1, ptr2)
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1389,7 +1473,7 @@ func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs .
// Samef asserts that two pointers reference the same object.
//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
+// a.Samef(ptr1, ptr2, "error message %s", "formatted")
//
// Both arguments must be pointer variables. Pointer variable sameness is
// determined based on the equality of both type and value.
@@ -1403,7 +1487,7 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string,
// Subset asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1414,7 +1498,7 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...
// Subsetf asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1424,7 +1508,7 @@ func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, a
// True asserts that the specified value is true.
//
-// a.True(myBool)
+// a.True(myBool)
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1434,7 +1518,7 @@ func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
// Truef asserts that the specified value is true.
//
-// a.Truef(myBool, "error message %s", "formatted")
+// a.Truef(myBool, "error message %s", "formatted")
func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1444,7 +1528,7 @@ func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
// WithinDuration asserts that the two times are within duration delta of each other.
//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
+// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1454,7 +1538,7 @@ func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta
// WithinDurationf asserts that the two times are within duration delta of each other.
//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1464,7 +1548,7 @@ func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta
// WithinRange asserts that a time is within a time range (inclusive).
//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
@@ -1474,7 +1558,7 @@ func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Tim
// WithinRangef asserts that a time is within a time range (inclusive).
//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
if h, ok := a.t.(tHelper); ok {
h.Helper()
diff --git a/vendor/github.com/stretchr/testify/suite/doc.go b/vendor/github.com/stretchr/testify/suite/doc.go
index f91a245d..8d55a3aa 100644
--- a/vendor/github.com/stretchr/testify/suite/doc.go
+++ b/vendor/github.com/stretchr/testify/suite/doc.go
@@ -29,37 +29,38 @@
// Suite object has assertion methods.
//
// A crude example:
-// // Basic imports
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// "github.com/stretchr/testify/suite"
-// )
//
-// // Define the suite, and absorb the built-in basic suite
-// // functionality from testify - including a T() method which
-// // returns the current testing context
-// type ExampleTestSuite struct {
-// suite.Suite
-// VariableThatShouldStartAtFive int
-// }
+// // Basic imports
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// "github.com/stretchr/testify/suite"
+// )
//
-// // Make sure that VariableThatShouldStartAtFive is set to five
-// // before each test
-// func (suite *ExampleTestSuite) SetupTest() {
-// suite.VariableThatShouldStartAtFive = 5
-// }
+// // Define the suite, and absorb the built-in basic suite
+// // functionality from testify - including a T() method which
+// // returns the current testing context
+// type ExampleTestSuite struct {
+// suite.Suite
+// VariableThatShouldStartAtFive int
+// }
//
-// // All methods that begin with "Test" are run as tests within a
-// // suite.
-// func (suite *ExampleTestSuite) TestExample() {
-// assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
-// suite.Equal(5, suite.VariableThatShouldStartAtFive)
-// }
+// // Make sure that VariableThatShouldStartAtFive is set to five
+// // before each test
+// func (suite *ExampleTestSuite) SetupTest() {
+// suite.VariableThatShouldStartAtFive = 5
+// }
//
-// // In order for 'go test' to run this suite, we need to create
-// // a normal test function and pass our suite to suite.Run
-// func TestExampleTestSuite(t *testing.T) {
-// suite.Run(t, new(ExampleTestSuite))
-// }
+// // All methods that begin with "Test" are run as tests within a
+// // suite.
+// func (suite *ExampleTestSuite) TestExample() {
+// assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
+// suite.Equal(5, suite.VariableThatShouldStartAtFive)
+// }
+//
+// // In order for 'go test' to run this suite, we need to create
+// // a normal test function and pass our suite to suite.Run
+// func TestExampleTestSuite(t *testing.T) {
+// suite.Run(t, new(ExampleTestSuite))
+// }
package suite
diff --git a/vendor/github.com/ztrue/tracerr/.travis.yml b/vendor/github.com/ztrue/tracerr/.travis.yml
index 6fa4d856..6e20d5cd 100644
--- a/vendor/github.com/ztrue/tracerr/.travis.yml
+++ b/vendor/github.com/ztrue/tracerr/.travis.yml
@@ -1,7 +1,6 @@
language: go
before_install:
- - go get github.com/logrusorgru/aurora
- go get github.com/mattn/goveralls
go:
diff --git a/vendor/github.com/ztrue/tracerr/CHANGELOG.md b/vendor/github.com/ztrue/tracerr/CHANGELOG.md
index b8560c97..7a8a2a84 100644
--- a/vendor/github.com/ztrue/tracerr/CHANGELOG.md
+++ b/vendor/github.com/ztrue/tracerr/CHANGELOG.md
@@ -1,5 +1,12 @@
# Changelog
+## [0.4.0] - 2023-05-21
+
+### Changed
+
+- `github.com/logrusorgru/aurora` dependency removed.
+- Deprecated `ioutil.ReadFile` replaced with `os.ReadFile`.
+
## [0.3.0] - 2019-03-15
### Added
diff --git a/vendor/github.com/ztrue/tracerr/colors.go b/vendor/github.com/ztrue/tracerr/colors.go
new file mode 100644
index 00000000..c96999e9
--- /dev/null
+++ b/vendor/github.com/ztrue/tracerr/colors.go
@@ -0,0 +1,27 @@
+package tracerr
+
+import (
+ "fmt"
+)
+
+// Colorize outputs using [ANSI Escape Codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
+
+func color(code int, in string) string {
+ return fmt.Sprintf("\x1b[%dm%s\x1b[0m", code, in)
+}
+
+func bold(in string) string {
+ return color(1, in)
+}
+
+func black(in string) string {
+ return color(30, in)
+}
+
+func red(in string) string {
+ return color(31, in)
+}
+
+func yellow(in string) string {
+ return color(33, in)
+}
diff --git a/vendor/github.com/ztrue/tracerr/print.go b/vendor/github.com/ztrue/tracerr/print.go
index 2249ace6..c6d36406 100644
--- a/vendor/github.com/ztrue/tracerr/print.go
+++ b/vendor/github.com/ztrue/tracerr/print.go
@@ -2,11 +2,10 @@ package tracerr
import (
"fmt"
- "io/ioutil"
+ "os"
+ "strconv"
"strings"
"sync"
-
- "github.com/logrusorgru/aurora"
)
// DefaultLinesAfter is number of source lines after traced line to display.
@@ -26,7 +25,7 @@ func Print(err error) {
// PrintSource prints error message with stack trace and source fragments.
//
-// By default 6 lines of source code will be printed,
+// By default, 6 lines of source code will be printed,
// see DefaultLinesAfter and DefaultLinesBefore.
//
// Pass a single number to specify a total number of source lines.
@@ -95,7 +94,7 @@ func readLines(path string) ([]string, error) {
return lines, nil
}
- b, err := ioutil.ReadFile(path)
+ b, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("tracerr: file %s not found", path)
}
@@ -111,7 +110,7 @@ func sourceRows(rows []string, frame Frame, before, after int, colorized bool) [
if err != nil {
message := err.Error()
if colorized {
- message = aurora.Brown(message).String()
+ message = yellow(message)
}
return append(rows, message, "")
}
@@ -121,7 +120,7 @@ func sourceRows(rows []string, frame Frame, before, after int, colorized bool) [
len(lines), frame.Line,
)
if colorized {
- message = aurora.Brown(message).String()
+ message = yellow(message)
}
return append(rows, message, "")
}
@@ -136,14 +135,14 @@ func sourceRows(rows []string, frame Frame, before, after int, colorized bool) [
var message string
// TODO Pad to the same length.
if i == frame.Line-1 {
- message = fmt.Sprintf("%d\t%s", i+1, string(line))
+ message = fmt.Sprintf("%d\t%s", i+1, line)
if colorized {
- message = aurora.Red(message).String()
+ message = red(message)
}
} else if colorized {
- message = aurora.Sprintf("%d\t%s", aurora.Black(i+1), string(line))
+ message = fmt.Sprintf("%s\t%s", black(strconv.Itoa(i+1)), line)
} else {
- message = fmt.Sprintf("%d\t%s", i+1, string(line))
+ message = fmt.Sprintf("%d\t%s", i+1, line)
}
rows = append(rows, message)
}
@@ -172,7 +171,7 @@ func sprint(err error, nums []int, colorized bool) string {
for _, frame := range frames {
message := frame.String()
if colorized {
- message = aurora.Bold(message).String()
+ message = bold(message)
}
rows = append(rows, message)
if withSource {
diff --git a/vendor/golang.org/x/crypto/PATENTS b/vendor/golang.org/x/crypto/PATENTS
deleted file mode 100644
index 73309904..00000000
--- a/vendor/golang.org/x/crypto/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go. This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation. If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/crypto/ssh/terminal/terminal.go b/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
deleted file mode 100644
index a4d1919a..00000000
--- a/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2011 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.
-
-// Package terminal provides support functions for dealing with terminals, as
-// commonly found on UNIX systems.
-//
-// Deprecated: this package moved to golang.org/x/term.
-package terminal
-
-import (
- "io"
-
- "golang.org/x/term"
-)
-
-// EscapeCodes contains escape sequences that can be written to the terminal in
-// order to achieve different styles of text.
-type EscapeCodes = term.EscapeCodes
-
-// Terminal contains the state for running a VT100 terminal that is capable of
-// reading lines of input.
-type Terminal = term.Terminal
-
-// NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
-// a local terminal, that terminal must first have been put into raw mode.
-// prompt is a string that is written at the start of each input line (i.e.
-// "> ").
-func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
- return term.NewTerminal(c, prompt)
-}
-
-// ErrPasteIndicator may be returned from ReadLine as the error, in addition
-// to valid line data. It indicates that bracketed paste mode is enabled and
-// that the returned line consists only of pasted data. Programs may wish to
-// interpret pasted data more literally than typed data.
-var ErrPasteIndicator = term.ErrPasteIndicator
-
-// State contains the state of a terminal.
-type State = term.State
-
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
- return term.IsTerminal(fd)
-}
-
-// ReadPassword reads a line of input from a terminal without local echo. This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
- return term.ReadPassword(fd)
-}
-
-// MakeRaw puts the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd int) (*State, error) {
- return term.MakeRaw(fd)
-}
-
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, oldState *State) error {
- return term.Restore(fd, oldState)
-}
-
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
- return term.GetState(fd)
-}
-
-// GetSize returns the dimensions of the given terminal.
-func GetSize(fd int) (width, height int, err error) {
- return term.GetSize(fd)
-}
diff --git a/vendor/golang.org/x/mod/internal/lazyregexp/lazyre.go b/vendor/golang.org/x/mod/internal/lazyregexp/lazyre.go
index 2681af35..150f887e 100644
--- a/vendor/golang.org/x/mod/internal/lazyregexp/lazyre.go
+++ b/vendor/golang.org/x/mod/internal/lazyregexp/lazyre.go
@@ -13,7 +13,7 @@ import (
"sync"
)
-// Regexp is a wrapper around regexp.Regexp, where the underlying regexp will be
+// Regexp is a wrapper around [regexp.Regexp], where the underlying regexp will be
// compiled the first time it is needed.
type Regexp struct {
str string
diff --git a/vendor/golang.org/x/mod/modfile/print.go b/vendor/golang.org/x/mod/modfile/print.go
index 524f9302..2a0123d4 100644
--- a/vendor/golang.org/x/mod/modfile/print.go
+++ b/vendor/golang.org/x/mod/modfile/print.go
@@ -16,7 +16,13 @@ import (
func Format(f *FileSyntax) []byte {
pr := &printer{}
pr.file(f)
- return pr.Bytes()
+
+ // remove trailing blank lines
+ b := pr.Bytes()
+ for len(b) > 0 && b[len(b)-1] == '\n' && (len(b) == 1 || b[len(b)-2] == '\n') {
+ b = b[:len(b)-1]
+ }
+ return b
}
// A printer collects the state during printing of a file or expression.
@@ -59,7 +65,11 @@ func (p *printer) newline() {
}
p.trim()
- p.printf("\n")
+ if b := p.Bytes(); len(b) == 0 || (len(b) >= 2 && b[len(b)-1] == '\n' && b[len(b)-2] == '\n') {
+ // skip the blank line at top of file or after a blank line
+ } else {
+ p.printf("\n")
+ }
for i := 0; i < p.margin; i++ {
p.printf("\t")
}
diff --git a/vendor/golang.org/x/mod/modfile/read.go b/vendor/golang.org/x/mod/modfile/read.go
index a503bc21..5b5bb5e1 100644
--- a/vendor/golang.org/x/mod/modfile/read.go
+++ b/vendor/golang.org/x/mod/modfile/read.go
@@ -65,7 +65,7 @@ type Comments struct {
}
// Comment returns the receiver. This isn't useful by itself, but
-// a Comments struct is embedded into all the expression
+// a [Comments] struct is embedded into all the expression
// implementation types, and this gives each of those a Comment
// method to satisfy the Expr interface.
func (c *Comments) Comment() *Comments {
diff --git a/vendor/golang.org/x/mod/modfile/rule.go b/vendor/golang.org/x/mod/modfile/rule.go
index 6bcde8fa..35fd1f53 100644
--- a/vendor/golang.org/x/mod/modfile/rule.go
+++ b/vendor/golang.org/x/mod/modfile/rule.go
@@ -5,17 +5,17 @@
// Package modfile implements a parser and formatter for go.mod files.
//
// The go.mod syntax is described in
-// https://golang.org/cmd/go/#hdr-The_go_mod_file.
+// https://pkg.go.dev/cmd/go/#hdr-The_go_mod_file.
//
-// The Parse and ParseLax functions both parse a go.mod file and return an
+// The [Parse] and [ParseLax] functions both parse a go.mod file and return an
// abstract syntax tree. ParseLax ignores unknown statements and may be used to
// parse go.mod files that may have been developed with newer versions of Go.
//
-// The File struct returned by Parse and ParseLax represent an abstract
-// go.mod file. File has several methods like AddNewRequire and DropReplace
-// that can be used to programmatically edit a file.
+// The [File] struct returned by Parse and ParseLax represent an abstract
+// go.mod file. File has several methods like [File.AddNewRequire] and
+// [File.DropReplace] that can be used to programmatically edit a file.
//
-// The Format function formats a File back to a byte slice which can be
+// The [Format] function formats a File back to a byte slice which can be
// written to a file.
package modfile
@@ -35,12 +35,13 @@ import (
// A File is the parsed, interpreted form of a go.mod file.
type File struct {
- Module *Module
- Go *Go
- Require []*Require
- Exclude []*Exclude
- Replace []*Replace
- Retract []*Retract
+ Module *Module
+ Go *Go
+ Toolchain *Toolchain
+ Require []*Require
+ Exclude []*Exclude
+ Replace []*Replace
+ Retract []*Retract
Syntax *FileSyntax
}
@@ -58,6 +59,12 @@ type Go struct {
Syntax *Line
}
+// A Toolchain is the toolchain statement.
+type Toolchain struct {
+ Name string // "go1.21rc1"
+ Syntax *Line
+}
+
// An Exclude is a single exclude statement.
type Exclude struct {
Mod module.Version
@@ -219,7 +226,7 @@ var dontFixRetract VersionFixer = func(_, vers string) (string, error) {
// data is the content of the file.
//
// fix is an optional function that canonicalizes module versions.
-// If fix is nil, all module versions must be canonical (module.CanonicalVersion
+// If fix is nil, all module versions must be canonical ([module.CanonicalVersion]
// must return the same string).
func Parse(file string, data []byte, fix VersionFixer) (*File, error) {
return parseToFile(file, data, fix, true)
@@ -296,9 +303,13 @@ func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (parse
return f, nil
}
-var GoVersionRE = lazyregexp.New(`^([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
+var GoVersionRE = lazyregexp.New(`^([1-9][0-9]*)\.(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))?([a-z]+[0-9]+)?$`)
var laxGoVersionRE = lazyregexp.New(`^v?(([1-9][0-9]*)\.(0|[1-9][0-9]*))([^0-9].*)$`)
+// Toolchains must be named beginning with `go1`,
+// like "go1.20.3" or "go1.20.3-gccgo". As a special case, "default" is also permitted.
+var ToolchainRE = lazyregexp.New(`^default$|^go1($|\.)`)
+
func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, args []string, fix VersionFixer, strict bool) {
// If strict is false, this module is a dependency.
// We ignore all unknown directives as well as main-module-only
@@ -356,7 +367,7 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
}
}
if !fixed {
- errorf("invalid go version '%s': must match format 1.23", args[0])
+ errorf("invalid go version '%s': must match format 1.23.0", args[0])
return
}
}
@@ -364,6 +375,21 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
f.Go = &Go{Syntax: line}
f.Go.Version = args[0]
+ case "toolchain":
+ if f.Toolchain != nil {
+ errorf("repeated toolchain statement")
+ return
+ }
+ if len(args) != 1 {
+ errorf("toolchain directive expects exactly one argument")
+ return
+ } else if strict && !ToolchainRE.MatchString(args[0]) {
+ errorf("invalid toolchain version '%s': must match format go1.23.0 or local", args[0])
+ return
+ }
+ f.Toolchain = &Toolchain{Syntax: line}
+ f.Toolchain.Name = args[0]
+
case "module":
if f.Module != nil {
errorf("repeated module statement")
@@ -516,7 +542,7 @@ func parseReplace(filename string, line *Line, verb string, args []string, fix V
if strings.Contains(ns, "@") {
return nil, errorf("replacement module must match format 'path version', not 'path@version'")
}
- return nil, errorf("replacement module without version must be directory path (rooted or starting with ./ or ../)")
+ return nil, errorf("replacement module without version must be directory path (rooted or starting with . or ..)")
}
if filepath.Separator == '/' && strings.Contains(ns, `\`) {
return nil, errorf("replacement directory appears to be Windows path (on a non-windows system)")
@@ -529,7 +555,6 @@ func parseReplace(filename string, line *Line, verb string, args []string, fix V
}
if IsDirectoryPath(ns) {
return nil, errorf("replacement module directory path %q cannot have version", ns)
-
}
}
return &Replace{
@@ -612,6 +637,22 @@ func (f *WorkFile) add(errs *ErrorList, line *Line, verb string, args []string,
f.Go = &Go{Syntax: line}
f.Go.Version = args[0]
+ case "toolchain":
+ if f.Toolchain != nil {
+ errorf("repeated toolchain statement")
+ return
+ }
+ if len(args) != 1 {
+ errorf("toolchain directive expects exactly one argument")
+ return
+ } else if !ToolchainRE.MatchString(args[0]) {
+ errorf("invalid toolchain version '%s': must match format go1.23 or local", args[0])
+ return
+ }
+
+ f.Toolchain = &Toolchain{Syntax: line}
+ f.Toolchain.Name = args[0]
+
case "use":
if len(args) != 1 {
errorf("usage: %s local/dir", verb)
@@ -637,14 +678,15 @@ func (f *WorkFile) add(errs *ErrorList, line *Line, verb string, args []string,
}
}
-// IsDirectoryPath reports whether the given path should be interpreted
-// as a directory path. Just like on the go command line, relative paths
+// IsDirectoryPath reports whether the given path should be interpreted as a directory path.
+// Just like on the go command line, relative paths starting with a '.' or '..' path component
// and rooted paths are directory paths; the rest are module paths.
func IsDirectoryPath(ns string) bool {
// Because go.mod files can move from one system to another,
// we check all known path syntaxes, both Unix and Windows.
- return strings.HasPrefix(ns, "./") || strings.HasPrefix(ns, "../") || strings.HasPrefix(ns, "/") ||
- strings.HasPrefix(ns, `.\`) || strings.HasPrefix(ns, `..\`) || strings.HasPrefix(ns, `\`) ||
+ return ns == "." || strings.HasPrefix(ns, "./") || strings.HasPrefix(ns, `.\`) ||
+ ns == ".." || strings.HasPrefix(ns, "../") || strings.HasPrefix(ns, `..\`) ||
+ strings.HasPrefix(ns, "/") || strings.HasPrefix(ns, `\`) ||
len(ns) >= 2 && ('A' <= ns[0] && ns[0] <= 'Z' || 'a' <= ns[0] && ns[0] <= 'z') && ns[1] == ':'
}
@@ -881,7 +923,7 @@ func (f *File) Format() ([]byte, error) {
}
// Cleanup cleans up the file f after any edit operations.
-// To avoid quadratic behavior, modifications like DropRequire
+// To avoid quadratic behavior, modifications like [File.DropRequire]
// clear the entry but do not remove it from the slice.
// Cleanup cleans out all the cleared entries.
func (f *File) Cleanup() {
@@ -926,7 +968,7 @@ func (f *File) Cleanup() {
func (f *File) AddGoStmt(version string) error {
if !GoVersionRE.MatchString(version) {
- return fmt.Errorf("invalid language version string %q", version)
+ return fmt.Errorf("invalid language version %q", version)
}
if f.Go == nil {
var hint Expr
@@ -944,6 +986,44 @@ func (f *File) AddGoStmt(version string) error {
return nil
}
+// DropGoStmt deletes the go statement from the file.
+func (f *File) DropGoStmt() {
+ if f.Go != nil {
+ f.Go.Syntax.markRemoved()
+ f.Go = nil
+ }
+}
+
+// DropToolchainStmt deletes the toolchain statement from the file.
+func (f *File) DropToolchainStmt() {
+ if f.Toolchain != nil {
+ f.Toolchain.Syntax.markRemoved()
+ f.Toolchain = nil
+ }
+}
+
+func (f *File) AddToolchainStmt(name string) error {
+ if !ToolchainRE.MatchString(name) {
+ return fmt.Errorf("invalid toolchain name %q", name)
+ }
+ if f.Toolchain == nil {
+ var hint Expr
+ if f.Go != nil && f.Go.Syntax != nil {
+ hint = f.Go.Syntax
+ } else if f.Module != nil && f.Module.Syntax != nil {
+ hint = f.Module.Syntax
+ }
+ f.Toolchain = &Toolchain{
+ Name: name,
+ Syntax: f.Syntax.addLine(hint, "toolchain", name),
+ }
+ } else {
+ f.Toolchain.Name = name
+ f.Syntax.updateLine(f.Toolchain.Syntax, "toolchain", name)
+ }
+ return nil
+}
+
// AddRequire sets the first require line for path to version vers,
// preserving any existing comments for that line and removing all
// other lines for path.
@@ -995,8 +1075,8 @@ func (f *File) AddNewRequire(path, vers string, indirect bool) {
// The requirements in req must specify at most one distinct version for each
// module path.
//
-// If any existing requirements may be removed, the caller should call Cleanup
-// after all edits are complete.
+// If any existing requirements may be removed, the caller should call
+// [File.Cleanup] after all edits are complete.
func (f *File) SetRequire(req []*Require) {
type elem struct {
version string
@@ -1387,13 +1467,21 @@ func (f *File) DropRetract(vi VersionInterval) error {
func (f *File) SortBlocks() {
f.removeDups() // otherwise sorting is unsafe
+ // semanticSortForExcludeVersionV is the Go version (plus leading "v") at which
+ // lines in exclude blocks start to use semantic sort instead of lexicographic sort.
+ // See go.dev/issue/60028.
+ const semanticSortForExcludeVersionV = "v1.21"
+ useSemanticSortForExclude := f.Go != nil && semver.Compare("v"+f.Go.Version, semanticSortForExcludeVersionV) >= 0
+
for _, stmt := range f.Syntax.Stmt {
block, ok := stmt.(*LineBlock)
if !ok {
continue
}
less := lineLess
- if block.Token[0] == "retract" {
+ if block.Token[0] == "exclude" && useSemanticSortForExclude {
+ less = lineExcludeLess
+ } else if block.Token[0] == "retract" {
less = lineRetractLess
}
sort.SliceStable(block.Line, func(i, j int) bool {
@@ -1496,6 +1584,22 @@ func lineLess(li, lj *Line) bool {
return len(li.Token) < len(lj.Token)
}
+// lineExcludeLess reports whether li should be sorted before lj for lines in
+// an "exclude" block.
+func lineExcludeLess(li, lj *Line) bool {
+ if len(li.Token) != 2 || len(lj.Token) != 2 {
+ // Not a known exclude specification.
+ // Fall back to sorting lexicographically.
+ return lineLess(li, lj)
+ }
+ // An exclude specification has two tokens: ModulePath and Version.
+ // Compare module path by string order and version by semver rules.
+ if pi, pj := li.Token[0], lj.Token[0]; pi != pj {
+ return pi < pj
+ }
+ return semver.Compare(li.Token[1], lj.Token[1]) < 0
+}
+
// lineRetractLess returns whether li should be sorted before lj for lines in
// a "retract" block. It treats each line as a version interval. Single versions
// are compared as if they were intervals with the same low and high version.
diff --git a/vendor/golang.org/x/mod/modfile/work.go b/vendor/golang.org/x/mod/modfile/work.go
index 0c0e5215..d7b99376 100644
--- a/vendor/golang.org/x/mod/modfile/work.go
+++ b/vendor/golang.org/x/mod/modfile/work.go
@@ -12,9 +12,10 @@ import (
// A WorkFile is the parsed, interpreted form of a go.work file.
type WorkFile struct {
- Go *Go
- Use []*Use
- Replace []*Replace
+ Go *Go
+ Toolchain *Toolchain
+ Use []*Use
+ Replace []*Replace
Syntax *FileSyntax
}
@@ -33,7 +34,7 @@ type Use struct {
// data is the content of the file.
//
// fix is an optional function that canonicalizes module versions.
-// If fix is nil, all module versions must be canonical (module.CanonicalVersion
+// If fix is nil, all module versions must be canonical ([module.CanonicalVersion]
// must return the same string).
func ParseWork(file string, data []byte, fix VersionFixer) (*WorkFile, error) {
fs, err := parse(file, data)
@@ -82,7 +83,7 @@ func ParseWork(file string, data []byte, fix VersionFixer) (*WorkFile, error) {
}
// Cleanup cleans up the file f after any edit operations.
-// To avoid quadratic behavior, modifications like DropRequire
+// To avoid quadratic behavior, modifications like [WorkFile.DropRequire]
// clear the entry but do not remove it from the slice.
// Cleanup cleans out all the cleared entries.
func (f *WorkFile) Cleanup() {
@@ -109,7 +110,7 @@ func (f *WorkFile) Cleanup() {
func (f *WorkFile) AddGoStmt(version string) error {
if !GoVersionRE.MatchString(version) {
- return fmt.Errorf("invalid language version string %q", version)
+ return fmt.Errorf("invalid language version %q", version)
}
if f.Go == nil {
stmt := &Line{Token: []string{"go", version}}
@@ -117,7 +118,7 @@ func (f *WorkFile) AddGoStmt(version string) error {
Version: version,
Syntax: stmt,
}
- // Find the first non-comment-only block that's and add
+ // Find the first non-comment-only block and add
// the go statement before it. That will keep file comments at the top.
i := 0
for i = 0; i < len(f.Syntax.Stmt); i++ {
@@ -133,6 +134,56 @@ func (f *WorkFile) AddGoStmt(version string) error {
return nil
}
+func (f *WorkFile) AddToolchainStmt(name string) error {
+ if !ToolchainRE.MatchString(name) {
+ return fmt.Errorf("invalid toolchain name %q", name)
+ }
+ if f.Toolchain == nil {
+ stmt := &Line{Token: []string{"toolchain", name}}
+ f.Toolchain = &Toolchain{
+ Name: name,
+ Syntax: stmt,
+ }
+ // Find the go line and add the toolchain line after it.
+ // Or else find the first non-comment-only block and add
+ // the toolchain line before it. That will keep file comments at the top.
+ i := 0
+ for i = 0; i < len(f.Syntax.Stmt); i++ {
+ if line, ok := f.Syntax.Stmt[i].(*Line); ok && len(line.Token) > 0 && line.Token[0] == "go" {
+ i++
+ goto Found
+ }
+ }
+ for i = 0; i < len(f.Syntax.Stmt); i++ {
+ if _, ok := f.Syntax.Stmt[i].(*CommentBlock); !ok {
+ break
+ }
+ }
+ Found:
+ f.Syntax.Stmt = append(append(f.Syntax.Stmt[:i:i], stmt), f.Syntax.Stmt[i:]...)
+ } else {
+ f.Toolchain.Name = name
+ f.Syntax.updateLine(f.Toolchain.Syntax, "toolchain", name)
+ }
+ return nil
+}
+
+// DropGoStmt deletes the go statement from the file.
+func (f *WorkFile) DropGoStmt() {
+ if f.Go != nil {
+ f.Go.Syntax.markRemoved()
+ f.Go = nil
+ }
+}
+
+// DropToolchainStmt deletes the toolchain statement from the file.
+func (f *WorkFile) DropToolchainStmt() {
+ if f.Toolchain != nil {
+ f.Toolchain.Syntax.markRemoved()
+ f.Toolchain = nil
+ }
+}
+
func (f *WorkFile) AddUse(diskPath, modulePath string) error {
need := true
for _, d := range f.Use {
diff --git a/vendor/golang.org/x/mod/module/module.go b/vendor/golang.org/x/mod/module/module.go
index e9dec6e6..2a364b22 100644
--- a/vendor/golang.org/x/mod/module/module.go
+++ b/vendor/golang.org/x/mod/module/module.go
@@ -4,7 +4,7 @@
// Package module defines the module.Version type along with support code.
//
-// The module.Version type is a simple Path, Version pair:
+// The [module.Version] type is a simple Path, Version pair:
//
// type Version struct {
// Path string
@@ -12,7 +12,7 @@
// }
//
// There are no restrictions imposed directly by use of this structure,
-// but additional checking functions, most notably Check, verify that
+// but additional checking functions, most notably [Check], verify that
// a particular path, version pair is valid.
//
// # Escaped Paths
@@ -140,7 +140,7 @@ type ModuleError struct {
Err error
}
-// VersionError returns a ModuleError derived from a Version and error,
+// VersionError returns a [ModuleError] derived from a [Version] and error,
// or err itself if it is already such an error.
func VersionError(v Version, err error) error {
var mErr *ModuleError
@@ -169,7 +169,7 @@ func (e *ModuleError) Unwrap() error { return e.Err }
// An InvalidVersionError indicates an error specific to a version, with the
// module path unknown or specified externally.
//
-// A ModuleError may wrap an InvalidVersionError, but an InvalidVersionError
+// A [ModuleError] may wrap an InvalidVersionError, but an InvalidVersionError
// must not wrap a ModuleError.
type InvalidVersionError struct {
Version string
@@ -193,8 +193,8 @@ func (e *InvalidVersionError) Error() string {
func (e *InvalidVersionError) Unwrap() error { return e.Err }
// An InvalidPathError indicates a module, import, or file path doesn't
-// satisfy all naming constraints. See CheckPath, CheckImportPath,
-// and CheckFilePath for specific restrictions.
+// satisfy all naming constraints. See [CheckPath], [CheckImportPath],
+// and [CheckFilePath] for specific restrictions.
type InvalidPathError struct {
Kind string // "module", "import", or "file"
Path string
@@ -294,7 +294,7 @@ func fileNameOK(r rune) bool {
}
// CheckPath checks that a module path is valid.
-// A valid module path is a valid import path, as checked by CheckImportPath,
+// A valid module path is a valid import path, as checked by [CheckImportPath],
// with three additional constraints.
// First, the leading path element (up to the first slash, if any),
// by convention a domain name, must contain only lower-case ASCII letters,
@@ -380,7 +380,7 @@ const (
// checkPath returns an error describing why the path is not valid.
// Because these checks apply to module, import, and file paths,
// and because other checks may be applied, the caller is expected to wrap
-// this error with InvalidPathError.
+// this error with [InvalidPathError].
func checkPath(path string, kind pathKind) error {
if !utf8.ValidString(path) {
return fmt.Errorf("invalid UTF-8")
@@ -532,7 +532,7 @@ var badWindowsNames = []string{
// they require ".vN" instead of "/vN", and for all N, not just N >= 2.
// SplitPathVersion returns with ok = false when presented with
// a path whose last path element does not satisfy the constraints
-// applied by CheckPath, such as "example.com/pkg/v1" or "example.com/pkg/v1.2".
+// applied by [CheckPath], such as "example.com/pkg/v1" or "example.com/pkg/v1.2".
func SplitPathVersion(path string) (prefix, pathMajor string, ok bool) {
if strings.HasPrefix(path, "gopkg.in/") {
return splitGopkgIn(path)
@@ -582,7 +582,7 @@ func splitGopkgIn(path string) (prefix, pathMajor string, ok bool) {
// MatchPathMajor reports whether the semantic version v
// matches the path major version pathMajor.
//
-// MatchPathMajor returns true if and only if CheckPathMajor returns nil.
+// MatchPathMajor returns true if and only if [CheckPathMajor] returns nil.
func MatchPathMajor(v, pathMajor string) bool {
return CheckPathMajor(v, pathMajor) == nil
}
@@ -622,7 +622,7 @@ func CheckPathMajor(v, pathMajor string) error {
// PathMajorPrefix returns the major-version tag prefix implied by pathMajor.
// An empty PathMajorPrefix allows either v0 or v1.
//
-// Note that MatchPathMajor may accept some versions that do not actually begin
+// Note that [MatchPathMajor] may accept some versions that do not actually begin
// with this prefix: namely, it accepts a 'v0.0.0-' prefix for a '.v1'
// pathMajor, even though that pathMajor implies 'v1' tagging.
func PathMajorPrefix(pathMajor string) string {
@@ -643,7 +643,7 @@ func PathMajorPrefix(pathMajor string) string {
}
// CanonicalVersion returns the canonical form of the version string v.
-// It is the same as semver.Canonical(v) except that it preserves the special build suffix "+incompatible".
+// It is the same as [semver.Canonical] except that it preserves the special build suffix "+incompatible".
func CanonicalVersion(v string) string {
cv := semver.Canonical(v)
if semver.Build(v) == "+incompatible" {
@@ -652,8 +652,8 @@ func CanonicalVersion(v string) string {
return cv
}
-// Sort sorts the list by Path, breaking ties by comparing Version fields.
-// The Version fields are interpreted as semantic versions (using semver.Compare)
+// Sort sorts the list by Path, breaking ties by comparing [Version] fields.
+// The Version fields are interpreted as semantic versions (using [semver.Compare])
// optionally followed by a tie-breaking suffix introduced by a slash character,
// like in "v0.0.1/go.mod".
func Sort(list []Version) {
@@ -793,7 +793,7 @@ func unescapeString(escaped string) (string, bool) {
}
// MatchPrefixPatterns reports whether any path prefix of target matches one of
-// the glob patterns (as defined by path.Match) in the comma-separated globs
+// the glob patterns (as defined by [path.Match]) in the comma-separated globs
// list. This implements the algorithm used when matching a module path to the
// GOPRIVATE environment variable, as described by 'go help module-private'.
//
diff --git a/vendor/golang.org/x/mod/module/pseudo.go b/vendor/golang.org/x/mod/module/pseudo.go
index f04ad378..9cf19d32 100644
--- a/vendor/golang.org/x/mod/module/pseudo.go
+++ b/vendor/golang.org/x/mod/module/pseudo.go
@@ -125,7 +125,7 @@ func IsPseudoVersion(v string) bool {
}
// IsZeroPseudoVersion returns whether v is a pseudo-version with a zero base,
-// timestamp, and revision, as returned by ZeroPseudoVersion.
+// timestamp, and revision, as returned by [ZeroPseudoVersion].
func IsZeroPseudoVersion(v string) bool {
return v == ZeroPseudoVersion(semver.Major(v))
}
diff --git a/vendor/golang.org/x/mod/semver/semver.go b/vendor/golang.org/x/mod/semver/semver.go
index a30a22bf..9a2dfd33 100644
--- a/vendor/golang.org/x/mod/semver/semver.go
+++ b/vendor/golang.org/x/mod/semver/semver.go
@@ -140,7 +140,7 @@ func Compare(v, w string) int {
// Max canonicalizes its arguments and then returns the version string
// that compares greater.
//
-// Deprecated: use Compare instead. In most cases, returning a canonicalized
+// Deprecated: use [Compare] instead. In most cases, returning a canonicalized
// version is not expected or desired.
func Max(v, w string) string {
v = Canonical(v)
@@ -151,7 +151,7 @@ func Max(v, w string) string {
return w
}
-// ByVersion implements sort.Interface for sorting semantic version strings.
+// ByVersion implements [sort.Interface] for sorting semantic version strings.
type ByVersion []string
func (vs ByVersion) Len() int { return len(vs) }
@@ -164,7 +164,7 @@ func (vs ByVersion) Less(i, j int) bool {
return vs[i] < vs[j]
}
-// Sort sorts a list of semantic version strings using ByVersion.
+// Sort sorts a list of semantic version strings using [ByVersion].
func Sort(list []string) {
sort.Sort(ByVersion(list))
}
diff --git a/vendor/golang.org/x/net/context/go17.go b/vendor/golang.org/x/net/context/go17.go
index 2cb9c408..0c1b8679 100644
--- a/vendor/golang.org/x/net/context/go17.go
+++ b/vendor/golang.org/x/net/context/go17.go
@@ -3,7 +3,6 @@
// license that can be found in the LICENSE file.
//go:build go1.7
-// +build go1.7
package context
diff --git a/vendor/golang.org/x/net/context/go19.go b/vendor/golang.org/x/net/context/go19.go
index 64d31ecc..e31e35a9 100644
--- a/vendor/golang.org/x/net/context/go19.go
+++ b/vendor/golang.org/x/net/context/go19.go
@@ -3,7 +3,6 @@
// license that can be found in the LICENSE file.
//go:build go1.9
-// +build go1.9
package context
diff --git a/vendor/golang.org/x/net/context/pre_go17.go b/vendor/golang.org/x/net/context/pre_go17.go
index 7b6b6851..065ff3df 100644
--- a/vendor/golang.org/x/net/context/pre_go17.go
+++ b/vendor/golang.org/x/net/context/pre_go17.go
@@ -3,7 +3,6 @@
// license that can be found in the LICENSE file.
//go:build !go1.7
-// +build !go1.7
package context
diff --git a/vendor/golang.org/x/net/context/pre_go19.go b/vendor/golang.org/x/net/context/pre_go19.go
index 1f971534..ec5a6380 100644
--- a/vendor/golang.org/x/net/context/pre_go19.go
+++ b/vendor/golang.org/x/net/context/pre_go19.go
@@ -3,7 +3,6 @@
// license that can be found in the LICENSE file.
//go:build !go1.9
-// +build !go1.9
package context
diff --git a/vendor/golang.org/x/net/http2/databuffer.go b/vendor/golang.org/x/net/http2/databuffer.go
index a3067f8d..e6f55cbd 100644
--- a/vendor/golang.org/x/net/http2/databuffer.go
+++ b/vendor/golang.org/x/net/http2/databuffer.go
@@ -20,41 +20,44 @@ import (
// TODO: Benchmark to determine if the pools are necessary. The GC may have
// improved enough that we can instead allocate chunks like this:
// make([]byte, max(16<<10, expectedBytesRemaining))
-var (
- dataChunkSizeClasses = []int{
- 1 << 10,
- 2 << 10,
- 4 << 10,
- 8 << 10,
- 16 << 10,
- }
- dataChunkPools = [...]sync.Pool{
- {New: func() interface{} { return make([]byte, 1<<10) }},
- {New: func() interface{} { return make([]byte, 2<<10) }},
- {New: func() interface{} { return make([]byte, 4<<10) }},
- {New: func() interface{} { return make([]byte, 8<<10) }},
- {New: func() interface{} { return make([]byte, 16<<10) }},
- }
-)
+var dataChunkPools = [...]sync.Pool{
+ {New: func() interface{} { return new([1 << 10]byte) }},
+ {New: func() interface{} { return new([2 << 10]byte) }},
+ {New: func() interface{} { return new([4 << 10]byte) }},
+ {New: func() interface{} { return new([8 << 10]byte) }},
+ {New: func() interface{} { return new([16 << 10]byte) }},
+}
func getDataBufferChunk(size int64) []byte {
- i := 0
- for ; i < len(dataChunkSizeClasses)-1; i++ {
- if size <= int64(dataChunkSizeClasses[i]) {
- break
- }
+ switch {
+ case size <= 1<<10:
+ return dataChunkPools[0].Get().(*[1 << 10]byte)[:]
+ case size <= 2<<10:
+ return dataChunkPools[1].Get().(*[2 << 10]byte)[:]
+ case size <= 4<<10:
+ return dataChunkPools[2].Get().(*[4 << 10]byte)[:]
+ case size <= 8<<10:
+ return dataChunkPools[3].Get().(*[8 << 10]byte)[:]
+ default:
+ return dataChunkPools[4].Get().(*[16 << 10]byte)[:]
}
- return dataChunkPools[i].Get().([]byte)
}
func putDataBufferChunk(p []byte) {
- for i, n := range dataChunkSizeClasses {
- if len(p) == n {
- dataChunkPools[i].Put(p)
- return
- }
+ switch len(p) {
+ case 1 << 10:
+ dataChunkPools[0].Put((*[1 << 10]byte)(p))
+ case 2 << 10:
+ dataChunkPools[1].Put((*[2 << 10]byte)(p))
+ case 4 << 10:
+ dataChunkPools[2].Put((*[4 << 10]byte)(p))
+ case 8 << 10:
+ dataChunkPools[3].Put((*[8 << 10]byte)(p))
+ case 16 << 10:
+ dataChunkPools[4].Put((*[16 << 10]byte)(p))
+ default:
+ panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
}
- panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
}
// dataBuffer is an io.ReadWriter backed by a list of data chunks.
diff --git a/vendor/golang.org/x/net/http2/go111.go b/vendor/golang.org/x/net/http2/go111.go
deleted file mode 100644
index 5bf62b03..00000000
--- a/vendor/golang.org/x/net/http2/go111.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2018 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.
-
-//go:build go1.11
-// +build go1.11
-
-package http2
-
-import (
- "net/http/httptrace"
- "net/textproto"
-)
-
-func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool {
- return trace != nil && trace.WroteHeaderField != nil
-}
-
-func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {
- if trace != nil && trace.WroteHeaderField != nil {
- trace.WroteHeaderField(k, []string{v})
- }
-}
-
-func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error {
- if trace != nil {
- return trace.Got1xxResponse
- }
- return nil
-}
diff --git a/vendor/golang.org/x/net/http2/go115.go b/vendor/golang.org/x/net/http2/go115.go
deleted file mode 100644
index 908af1ab..00000000
--- a/vendor/golang.org/x/net/http2/go115.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2021 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.
-
-//go:build go1.15
-// +build go1.15
-
-package http2
-
-import (
- "context"
- "crypto/tls"
-)
-
-// dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS
-// connection.
-func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {
- dialer := &tls.Dialer{
- Config: cfg,
- }
- cn, err := dialer.DialContext(ctx, network, addr)
- if err != nil {
- return nil, err
- }
- tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed
- return tlsCn, nil
-}
diff --git a/vendor/golang.org/x/net/http2/go118.go b/vendor/golang.org/x/net/http2/go118.go
deleted file mode 100644
index aca4b2b3..00000000
--- a/vendor/golang.org/x/net/http2/go118.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2021 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.
-
-//go:build go1.18
-// +build go1.18
-
-package http2
-
-import (
- "crypto/tls"
- "net"
-)
-
-func tlsUnderlyingConn(tc *tls.Conn) net.Conn {
- return tc.NetConn()
-}
diff --git a/vendor/golang.org/x/net/http2/not_go111.go b/vendor/golang.org/x/net/http2/not_go111.go
deleted file mode 100644
index cc0baa81..00000000
--- a/vendor/golang.org/x/net/http2/not_go111.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2018 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.
-
-//go:build !go1.11
-// +build !go1.11
-
-package http2
-
-import (
- "net/http/httptrace"
- "net/textproto"
-)
-
-func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool { return false }
-
-func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {}
-
-func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error {
- return nil
-}
diff --git a/vendor/golang.org/x/net/http2/not_go115.go b/vendor/golang.org/x/net/http2/not_go115.go
deleted file mode 100644
index e6c04cf7..00000000
--- a/vendor/golang.org/x/net/http2/not_go115.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2021 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.
-
-//go:build !go1.15
-// +build !go1.15
-
-package http2
-
-import (
- "context"
- "crypto/tls"
-)
-
-// dialTLSWithContext opens a TLS connection.
-func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {
- cn, err := tls.Dial(network, addr, cfg)
- if err != nil {
- return nil, err
- }
- if err := cn.Handshake(); err != nil {
- return nil, err
- }
- if cfg.InsecureSkipVerify {
- return cn, nil
- }
- if err := cn.VerifyHostname(cfg.ServerName); err != nil {
- return nil, err
- }
- return cn, nil
-}
diff --git a/vendor/golang.org/x/net/http2/not_go118.go b/vendor/golang.org/x/net/http2/not_go118.go
deleted file mode 100644
index eab532c9..00000000
--- a/vendor/golang.org/x/net/http2/not_go118.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2021 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.
-
-//go:build !go1.18
-// +build !go1.18
-
-package http2
-
-import (
- "crypto/tls"
- "net"
-)
-
-func tlsUnderlyingConn(tc *tls.Conn) net.Conn {
- return nil
-}
diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go
index 02c88b6b..ae94c640 100644
--- a/vendor/golang.org/x/net/http2/server.go
+++ b/vendor/golang.org/x/net/http2/server.go
@@ -2549,7 +2549,6 @@ type responseWriterState struct {
wroteHeader bool // WriteHeader called (explicitly or implicitly). Not necessarily sent to user yet.
sentHeader bool // have we sent the header frame?
handlerDone bool // handler has finished
- dirty bool // a Write failed; don't reuse this responseWriterState
sentContentLen int64 // non-zero if handler set a Content-Length header
wroteBytes int64
@@ -2669,7 +2668,6 @@ func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) {
date: date,
})
if err != nil {
- rws.dirty = true
return 0, err
}
if endStream {
@@ -2690,7 +2688,6 @@ func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) {
if len(p) > 0 || endStream {
// only send a 0 byte DATA frame if we're ending the stream.
if err := rws.conn.writeDataFromHandler(rws.stream, p, endStream); err != nil {
- rws.dirty = true
return 0, err
}
}
@@ -2702,9 +2699,6 @@ func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) {
trailers: rws.trailers,
endStream: true,
})
- if err != nil {
- rws.dirty = true
- }
return len(p), err
}
return len(p), nil
@@ -2920,14 +2914,12 @@ func (rws *responseWriterState) writeHeader(code int) {
h.Del("Transfer-Encoding")
}
- if rws.conn.writeHeaders(rws.stream, &writeResHeaders{
+ rws.conn.writeHeaders(rws.stream, &writeResHeaders{
streamID: rws.stream.id,
httpResCode: code,
h: h,
endStream: rws.handlerDone && !rws.hasTrailers(),
- }) != nil {
- rws.dirty = true
- }
+ })
return
}
@@ -2992,19 +2984,10 @@ func (w *responseWriter) write(lenData int, dataB []byte, dataS string) (n int,
func (w *responseWriter) handlerDone() {
rws := w.rws
- dirty := rws.dirty
rws.handlerDone = true
w.Flush()
w.rws = nil
- if !dirty {
- // Only recycle the pool if all prior Write calls to
- // the serverConn goroutine completed successfully. If
- // they returned earlier due to resets from the peer
- // there might still be write goroutines outstanding
- // from the serverConn referencing the rws memory. See
- // issue 20704.
- responseWriterStatePool.Put(rws)
- }
+ responseWriterStatePool.Put(rws)
}
// Push errors.
@@ -3187,6 +3170,7 @@ func (sc *serverConn) startPush(msg *startPushRequest) {
panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
}
+ sc.curHandlers++
go sc.runHandler(rw, req, sc.handler.ServeHTTP)
return promisedID, nil
}
diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go
index 4515b22c..df578b86 100644
--- a/vendor/golang.org/x/net/http2/transport.go
+++ b/vendor/golang.org/x/net/http2/transport.go
@@ -1018,7 +1018,7 @@ func (cc *ClientConn) forceCloseConn() {
if !ok {
return
}
- if nc := tlsUnderlyingConn(tc); nc != nil {
+ if nc := tc.NetConn(); nc != nil {
nc.Close()
}
}
@@ -3201,3 +3201,34 @@ func traceFirstResponseByte(trace *httptrace.ClientTrace) {
trace.GotFirstResponseByte()
}
}
+
+func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool {
+ return trace != nil && trace.WroteHeaderField != nil
+}
+
+func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {
+ if trace != nil && trace.WroteHeaderField != nil {
+ trace.WroteHeaderField(k, []string{v})
+ }
+}
+
+func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error {
+ if trace != nil {
+ return trace.Got1xxResponse
+ }
+ return nil
+}
+
+// dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS
+// connection.
+func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {
+ dialer := &tls.Dialer{
+ Config: cfg,
+ }
+ cn, err := dialer.DialContext(ctx, network, addr)
+ if err != nil {
+ return nil, err
+ }
+ tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed
+ return tlsCn, nil
+}
diff --git a/vendor/golang.org/x/net/idna/go118.go b/vendor/golang.org/x/net/idna/go118.go
index c5c4338d..712f1ad8 100644
--- a/vendor/golang.org/x/net/idna/go118.go
+++ b/vendor/golang.org/x/net/idna/go118.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build go1.18
-// +build go1.18
package idna
diff --git a/vendor/golang.org/x/net/idna/idna10.0.0.go b/vendor/golang.org/x/net/idna/idna10.0.0.go
index 64ccf85f..7b371788 100644
--- a/vendor/golang.org/x/net/idna/idna10.0.0.go
+++ b/vendor/golang.org/x/net/idna/idna10.0.0.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build go1.10
-// +build go1.10
// Package idna implements IDNA2008 using the compatibility processing
// defined by UTS (Unicode Technical Standard) #46, which defines a standard to
diff --git a/vendor/golang.org/x/net/idna/idna9.0.0.go b/vendor/golang.org/x/net/idna/idna9.0.0.go
index ee1698ce..cc6a892a 100644
--- a/vendor/golang.org/x/net/idna/idna9.0.0.go
+++ b/vendor/golang.org/x/net/idna/idna9.0.0.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build !go1.10
-// +build !go1.10
// Package idna implements IDNA2008 using the compatibility processing
// defined by UTS (Unicode Technical Standard) #46, which defines a standard to
diff --git a/vendor/golang.org/x/net/idna/pre_go118.go b/vendor/golang.org/x/net/idna/pre_go118.go
index 3aaccab1..40e74bb3 100644
--- a/vendor/golang.org/x/net/idna/pre_go118.go
+++ b/vendor/golang.org/x/net/idna/pre_go118.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build !go1.18
-// +build !go1.18
package idna
diff --git a/vendor/golang.org/x/net/idna/tables10.0.0.go b/vendor/golang.org/x/net/idna/tables10.0.0.go
index d1d62ef4..c6c2bf10 100644
--- a/vendor/golang.org/x/net/idna/tables10.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables10.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.10 && !go1.13
-// +build go1.10,!go1.13
package idna
diff --git a/vendor/golang.org/x/net/idna/tables11.0.0.go b/vendor/golang.org/x/net/idna/tables11.0.0.go
index 167efba7..76789393 100644
--- a/vendor/golang.org/x/net/idna/tables11.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables11.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.13 && !go1.14
-// +build go1.13,!go1.14
package idna
diff --git a/vendor/golang.org/x/net/idna/tables12.0.0.go b/vendor/golang.org/x/net/idna/tables12.0.0.go
index ab40f7bc..0600cd2a 100644
--- a/vendor/golang.org/x/net/idna/tables12.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables12.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.14 && !go1.16
-// +build go1.14,!go1.16
package idna
diff --git a/vendor/golang.org/x/net/idna/tables13.0.0.go b/vendor/golang.org/x/net/idna/tables13.0.0.go
index 66701ead..2fb768ef 100644
--- a/vendor/golang.org/x/net/idna/tables13.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables13.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.16 && !go1.21
-// +build go1.16,!go1.21
package idna
diff --git a/vendor/golang.org/x/net/idna/tables15.0.0.go b/vendor/golang.org/x/net/idna/tables15.0.0.go
index 40033778..5ff05fe1 100644
--- a/vendor/golang.org/x/net/idna/tables15.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables15.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.21
-// +build go1.21
package idna
diff --git a/vendor/golang.org/x/net/idna/tables9.0.0.go b/vendor/golang.org/x/net/idna/tables9.0.0.go
index 4074b533..0f25e84c 100644
--- a/vendor/golang.org/x/net/idna/tables9.0.0.go
+++ b/vendor/golang.org/x/net/idna/tables9.0.0.go
@@ -1,7 +1,6 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build !go1.10
-// +build !go1.10
package idna
diff --git a/vendor/golang.org/x/net/idna/trie12.0.0.go b/vendor/golang.org/x/net/idna/trie12.0.0.go
index bb63f904..8a75b966 100644
--- a/vendor/golang.org/x/net/idna/trie12.0.0.go
+++ b/vendor/golang.org/x/net/idna/trie12.0.0.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build !go1.16
-// +build !go1.16
package idna
diff --git a/vendor/golang.org/x/net/idna/trie13.0.0.go b/vendor/golang.org/x/net/idna/trie13.0.0.go
index 7d68a8dc..fa45bb90 100644
--- a/vendor/golang.org/x/net/idna/trie13.0.0.go
+++ b/vendor/golang.org/x/net/idna/trie13.0.0.go
@@ -5,7 +5,6 @@
// license that can be found in the LICENSE file.
//go:build go1.16
-// +build go1.16
package idna
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 6202638b..c6492020 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -248,6 +248,7 @@ struct ltchars {
#include
#include
#include
+#include
#include
#include
#include
@@ -283,10 +284,6 @@ struct ltchars {
#include
#endif
-#ifndef MSG_FASTOPEN
-#define MSG_FASTOPEN 0x20000000
-#endif
-
#ifndef PTRACE_GETREGS
#define PTRACE_GETREGS 0xc
#endif
@@ -295,14 +292,6 @@ struct ltchars {
#define PTRACE_SETREGS 0xd
#endif
-#ifndef SOL_NETLINK
-#define SOL_NETLINK 270
-#endif
-
-#ifndef SOL_SMC
-#define SOL_SMC 286
-#endif
-
#ifdef SOL_BLUETOOTH
// SPARC includes this in /usr/include/sparc64-linux-gnu/bits/socket.h
// but it is already in bluetooth_linux.go
@@ -319,10 +308,23 @@ struct ltchars {
#undef TIPC_WAIT_FOREVER
#define TIPC_WAIT_FOREVER 0xffffffff
-// Copied from linux/l2tp.h
-// Including linux/l2tp.h here causes conflicts between linux/in.h
-// and netinet/in.h included via net/route.h above.
-#define IPPROTO_L2TP 115
+// Copied from linux/netfilter/nf_nat.h
+// Including linux/netfilter/nf_nat.h here causes conflicts between linux/in.h
+// and netinet/in.h.
+#define NF_NAT_RANGE_MAP_IPS (1 << 0)
+#define NF_NAT_RANGE_PROTO_SPECIFIED (1 << 1)
+#define NF_NAT_RANGE_PROTO_RANDOM (1 << 2)
+#define NF_NAT_RANGE_PERSISTENT (1 << 3)
+#define NF_NAT_RANGE_PROTO_RANDOM_FULLY (1 << 4)
+#define NF_NAT_RANGE_PROTO_OFFSET (1 << 5)
+#define NF_NAT_RANGE_NETMAP (1 << 6)
+#define NF_NAT_RANGE_PROTO_RANDOM_ALL \
+ (NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PROTO_RANDOM_FULLY)
+#define NF_NAT_RANGE_MASK \
+ (NF_NAT_RANGE_MAP_IPS | NF_NAT_RANGE_PROTO_SPECIFIED | \
+ NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PERSISTENT | \
+ NF_NAT_RANGE_PROTO_RANDOM_FULLY | NF_NAT_RANGE_PROTO_OFFSET | \
+ NF_NAT_RANGE_NETMAP)
// Copied from linux/hid.h.
// Keep in sync with the size of the referenced fields.
@@ -603,6 +605,9 @@ ccflags="$@"
$2 ~ /^FSOPT_/ ||
$2 ~ /^WDIO[CFS]_/ ||
$2 ~ /^NFN/ ||
+ $2 !~ /^NFT_META_IIFTYPE/ &&
+ $2 ~ /^NFT_/ ||
+ $2 ~ /^NF_NAT_/ ||
$2 ~ /^XDP_/ ||
$2 ~ /^RWF_/ ||
$2 ~ /^(HDIO|WIN|SMART)_/ ||
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index c73cfe2f..a5d3ff8d 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -2127,6 +2127,60 @@ const (
NFNL_SUBSYS_QUEUE = 0x3
NFNL_SUBSYS_ULOG = 0x4
NFS_SUPER_MAGIC = 0x6969
+ NFT_CHAIN_FLAGS = 0x7
+ NFT_CHAIN_MAXNAMELEN = 0x100
+ NFT_CT_MAX = 0x17
+ NFT_DATA_RESERVED_MASK = 0xffffff00
+ NFT_DATA_VALUE_MAXLEN = 0x40
+ NFT_EXTHDR_OP_MAX = 0x4
+ NFT_FIB_RESULT_MAX = 0x3
+ NFT_INNER_MASK = 0xf
+ NFT_LOGLEVEL_MAX = 0x8
+ NFT_NAME_MAXLEN = 0x100
+ NFT_NG_MAX = 0x1
+ NFT_OBJECT_CONNLIMIT = 0x5
+ NFT_OBJECT_COUNTER = 0x1
+ NFT_OBJECT_CT_EXPECT = 0x9
+ NFT_OBJECT_CT_HELPER = 0x3
+ NFT_OBJECT_CT_TIMEOUT = 0x7
+ NFT_OBJECT_LIMIT = 0x4
+ NFT_OBJECT_MAX = 0xa
+ NFT_OBJECT_QUOTA = 0x2
+ NFT_OBJECT_SECMARK = 0x8
+ NFT_OBJECT_SYNPROXY = 0xa
+ NFT_OBJECT_TUNNEL = 0x6
+ NFT_OBJECT_UNSPEC = 0x0
+ NFT_OBJ_MAXNAMELEN = 0x100
+ NFT_OSF_MAXGENRELEN = 0x10
+ NFT_QUEUE_FLAG_BYPASS = 0x1
+ NFT_QUEUE_FLAG_CPU_FANOUT = 0x2
+ NFT_QUEUE_FLAG_MASK = 0x3
+ NFT_REG32_COUNT = 0x10
+ NFT_REG32_SIZE = 0x4
+ NFT_REG_MAX = 0x4
+ NFT_REG_SIZE = 0x10
+ NFT_REJECT_ICMPX_MAX = 0x3
+ NFT_RT_MAX = 0x4
+ NFT_SECMARK_CTX_MAXLEN = 0x100
+ NFT_SET_MAXNAMELEN = 0x100
+ NFT_SOCKET_MAX = 0x3
+ NFT_TABLE_F_MASK = 0x3
+ NFT_TABLE_MAXNAMELEN = 0x100
+ NFT_TRACETYPE_MAX = 0x3
+ NFT_TUNNEL_F_MASK = 0x7
+ NFT_TUNNEL_MAX = 0x1
+ NFT_TUNNEL_MODE_MAX = 0x2
+ NFT_USERDATA_MAXLEN = 0x100
+ NFT_XFRM_KEY_MAX = 0x6
+ NF_NAT_RANGE_MAP_IPS = 0x1
+ NF_NAT_RANGE_MASK = 0x7f
+ NF_NAT_RANGE_NETMAP = 0x40
+ NF_NAT_RANGE_PERSISTENT = 0x8
+ NF_NAT_RANGE_PROTO_OFFSET = 0x20
+ NF_NAT_RANGE_PROTO_RANDOM = 0x4
+ NF_NAT_RANGE_PROTO_RANDOM_ALL = 0x14
+ NF_NAT_RANGE_PROTO_RANDOM_FULLY = 0x10
+ NF_NAT_RANGE_PROTO_SPECIFIED = 0x2
NILFS_SUPER_MAGIC = 0x3434
NL0 = 0x0
NL1 = 0x100
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
index a1d06159..9dc42410 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
index 5b2a7409..0d3a0751 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
index f6eda134..c39f7776 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
index 55df20ae..57571d07 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
index 8c1155cb..e62963e6 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
index 7cc80c58..00831354 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
index 0688737f..79029ed5 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
@@ -2297,5 +2297,3 @@ func unveil(path *byte, flags *byte) (err error) {
var libc_unveil_trampoline_addr uintptr
//go:cgo_import_dynamic libc_unveil unveil "libc.so"
-
-
diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go
index 47dc5796..ffb8708c 100644
--- a/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -194,6 +194,7 @@ func NewCallbackCDecl(fn interface{}) uintptr {
//sys GetComputerName(buf *uint16, n *uint32) (err error) = GetComputerNameW
//sys GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) = GetComputerNameExW
//sys SetEndOfFile(handle Handle) (err error)
+//sys SetFileValidData(handle Handle, validDataLength int64) (err error)
//sys GetSystemTimeAsFileTime(time *Filetime)
//sys GetSystemTimePreciseAsFileTime(time *Filetime)
//sys GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index 146a1f01..e8791c82 100644
--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -342,6 +342,7 @@ var (
procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories")
procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW")
procSetEndOfFile = modkernel32.NewProc("SetEndOfFile")
+ procSetFileValidData = modkernel32.NewProc("SetFileValidData")
procSetEnvironmentVariableW = modkernel32.NewProc("SetEnvironmentVariableW")
procSetErrorMode = modkernel32.NewProc("SetErrorMode")
procSetEvent = modkernel32.NewProc("SetEvent")
@@ -2988,6 +2989,14 @@ func SetEndOfFile(handle Handle) (err error) {
return
}
+func SetFileValidData(handle Handle, validDataLength int64) (err error) {
+ r1, _, e1 := syscall.Syscall(procSetFileValidData.Addr(), 2, uintptr(handle), uintptr(validDataLength), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func SetEnvironmentVariable(name *uint16, value *uint16) (err error) {
r1, _, e1 := syscall.Syscall(procSetEnvironmentVariableW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), 0)
if r1 == 0 {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index b72314fd..263f1c43 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,4 +1,4 @@
-# atomicgo.dev/cursor v0.1.1
+# atomicgo.dev/cursor v0.2.0
## explicit; go 1.15
atomicgo.dev/cursor
# atomicgo.dev/keyboard v0.2.9
@@ -6,10 +6,10 @@ atomicgo.dev/cursor
atomicgo.dev/keyboard
atomicgo.dev/keyboard/internal
atomicgo.dev/keyboard/keys
-# bitbucket.org/creachadair/shell v0.0.7
-## explicit; go 1.16
-bitbucket.org/creachadair/shell
-# github.com/bitfield/script v0.21.4
+# atomicgo.dev/schedule v0.1.0
+## explicit; go 1.18
+atomicgo.dev/schedule
+# github.com/bitfield/script v0.22.0
## explicit; go 1.12
github.com/bitfield/script
# github.com/containerd/console v1.0.3
@@ -18,11 +18,8 @@ github.com/containerd/console
# github.com/davecgh/go-spew v1.1.1
## explicit
github.com/davecgh/go-spew/spew
-# github.com/dgrijalva/jwt-go/v4 v4.0.0-preview1
-## explicit; go 1.12
-github.com/dgrijalva/jwt-go/v4
-# github.com/dustin/go-humanize v1.0.0
-## explicit
+# github.com/dustin/go-humanize v1.0.1
+## explicit; go 1.16
github.com/dustin/go-humanize
# github.com/ericchiang/k8s v1.2.0
## explicit
@@ -35,6 +32,9 @@ github.com/ericchiang/k8s/runtime
github.com/ericchiang/k8s/runtime/schema
github.com/ericchiang/k8s/util/intstr
github.com/ericchiang/k8s/watch/versioned
+# github.com/golang-jwt/jwt/v5 v5.2.0
+## explicit; go 1.18
+github.com/golang-jwt/jwt/v5
# github.com/golang/mock v1.6.0
## explicit; go 1.11
github.com/golang/mock/gomock
@@ -45,47 +45,39 @@ github.com/golang/protobuf/ptypes
github.com/golang/protobuf/ptypes/any
github.com/golang/protobuf/ptypes/duration
github.com/golang/protobuf/ptypes/timestamp
-# github.com/gookit/color v1.5.3
+# github.com/gookit/color v1.5.4
## explicit; go 1.18
github.com/gookit/color
-# github.com/gorilla/mux v1.8.0
-## explicit; go 1.12
+# github.com/gorilla/mux v1.8.1
+## explicit; go 1.20
github.com/gorilla/mux
-# github.com/itchyny/gojq v0.12.7
-## explicit; go 1.16
+# github.com/itchyny/gojq v0.12.14
+## explicit; go 1.19
github.com/itchyny/gojq
-# github.com/itchyny/timefmt-go v0.1.3
-## explicit; go 1.14
+# github.com/itchyny/timefmt-go v0.1.5
+## explicit; go 1.17
github.com/itchyny/timefmt-go
-# github.com/konsorten/go-windows-terminal-sequences v1.0.1
-## explicit
-github.com/konsorten/go-windows-terminal-sequences
-# github.com/kr/pretty v0.2.1
-## explicit; go 1.12
-# github.com/lithammer/fuzzysearch v1.1.5
+# github.com/lithammer/fuzzysearch v1.1.8
## explicit; go 1.15
github.com/lithammer/fuzzysearch/fuzzy
-# github.com/logrusorgru/aurora v2.0.3+incompatible
-## explicit
-github.com/logrusorgru/aurora
-# github.com/magefile/mage v1.14.0
+# github.com/magefile/mage v1.15.0
## explicit; go 1.12
github.com/magefile/mage/mg
github.com/magefile/mage/sh
-# github.com/mattn/go-runewidth v0.0.14
+# github.com/mattn/go-runewidth v0.0.15
## explicit; go 1.9
github.com/mattn/go-runewidth
# github.com/pmezard/go-difflib v1.0.0
## explicit
github.com/pmezard/go-difflib/difflib
-# github.com/pterm/pterm v0.12.58
-## explicit; go 1.18
+# github.com/pterm/pterm v0.12.75
+## explicit; go 1.21
github.com/pterm/pterm
github.com/pterm/pterm/internal
# github.com/rivo/uniseg v0.4.4
## explicit; go 1.18
github.com/rivo/uniseg
-# github.com/sheldonhull/magetools v1.0.0
+# github.com/sheldonhull/magetools v1.0.1
## explicit; go 1.18
github.com/sheldonhull/magetools/ci
github.com/sheldonhull/magetools/docgen
@@ -94,31 +86,28 @@ github.com/sheldonhull/magetools/gotools
github.com/sheldonhull/magetools/pkg/magetoolsutils
github.com/sheldonhull/magetools/pkg/req
github.com/sheldonhull/magetools/tooling
-# github.com/sirupsen/logrus v1.2.0
-## explicit
-github.com/sirupsen/logrus
-# github.com/stretchr/testify v1.8.2
+# github.com/sirupsen/logrus v1.9.3
## explicit; go 1.13
+github.com/sirupsen/logrus
+# github.com/stretchr/testify v1.8.4
+## explicit; go 1.20
github.com/stretchr/testify/assert
github.com/stretchr/testify/require
github.com/stretchr/testify/suite
# github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e
## explicit; go 1.19
github.com/xo/terminfo
-# github.com/ztrue/tracerr v0.3.0
+# github.com/ztrue/tracerr v0.4.0
## explicit
github.com/ztrue/tracerr
-# golang.org/x/crypto v0.17.0
+# golang.org/x/mod v0.14.0
## explicit; go 1.18
-golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.8.0
-## explicit; go 1.17
golang.org/x/mod/internal/lazyregexp
golang.org/x/mod/modfile
golang.org/x/mod/module
golang.org/x/mod/semver
-# golang.org/x/net v0.17.0
-## explicit; go 1.17
+# golang.org/x/net v0.20.0
+## explicit; go 1.18
golang.org/x/net/context
golang.org/x/net/http/httpguts
golang.org/x/net/http2
@@ -126,14 +115,12 @@ golang.org/x/net/http2/hpack
golang.org/x/net/idna
golang.org/x/net/internal/timeseries
golang.org/x/net/trace
-# golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4
-## explicit
-# golang.org/x/sys v0.15.0
+# golang.org/x/sys v0.16.0
## explicit; go 1.18
golang.org/x/sys/plan9
golang.org/x/sys/unix
golang.org/x/sys/windows
-# golang.org/x/term v0.15.0
+# golang.org/x/term v0.16.0
## explicit; go 1.18
golang.org/x/term
# golang.org/x/text v0.14.0
@@ -183,3 +170,10 @@ google.golang.org/grpc/tap
# gopkg.in/yaml.v3 v3.0.1
## explicit
gopkg.in/yaml.v3
+# mvdan.cc/sh/v3 v3.7.0
+## explicit; go 1.19
+mvdan.cc/sh/v3/expand
+mvdan.cc/sh/v3/fileutil
+mvdan.cc/sh/v3/pattern
+mvdan.cc/sh/v3/shell
+mvdan.cc/sh/v3/syntax
diff --git a/vendor/golang.org/x/crypto/LICENSE b/vendor/mvdan.cc/sh/v3/LICENSE
similarity index 91%
rename from vendor/golang.org/x/crypto/LICENSE
rename to vendor/mvdan.cc/sh/v3/LICENSE
index 6a66aea5..2a5268e5 100644
--- a/vendor/golang.org/x/crypto/LICENSE
+++ b/vendor/mvdan.cc/sh/v3/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright (c) 2016, Daniel Martí. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
- * Neither the name of Google Inc. nor the names of its
+ * Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/mvdan.cc/sh/v3/expand/arith.go b/vendor/mvdan.cc/sh/v3/expand/arith.go
new file mode 100644
index 00000000..20a45960
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/arith.go
@@ -0,0 +1,221 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+package expand
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+
+ "mvdan.cc/sh/v3/syntax"
+)
+
+func Arithm(cfg *Config, expr syntax.ArithmExpr) (int, error) {
+ switch x := expr.(type) {
+ case *syntax.Word:
+ str, err := Literal(cfg, x)
+ if err != nil {
+ return 0, err
+ }
+ // recursively fetch vars
+ i := 0
+ for syntax.ValidName(str) {
+ val := cfg.envGet(str)
+ if val == "" {
+ break
+ }
+ if i++; i >= maxNameRefDepth {
+ break
+ }
+ str = val
+ }
+ // default to 0
+ return atoi(str), nil
+ case *syntax.ParenArithm:
+ return Arithm(cfg, x.X)
+ case *syntax.UnaryArithm:
+ switch x.Op {
+ case syntax.Inc, syntax.Dec:
+ name := x.X.(*syntax.Word).Lit()
+ old := atoi(cfg.envGet(name))
+ val := old
+ if x.Op == syntax.Inc {
+ val++
+ } else {
+ val--
+ }
+ if err := cfg.envSet(name, strconv.Itoa(val)); err != nil {
+ return 0, err
+ }
+ if x.Post {
+ return old, nil
+ }
+ return val, nil
+ }
+ val, err := Arithm(cfg, x.X)
+ if err != nil {
+ return 0, err
+ }
+ switch x.Op {
+ case syntax.Not:
+ return oneIf(val == 0), nil
+ case syntax.BitNegation:
+ return ^val, nil
+ case syntax.Plus:
+ return val, nil
+ default: // syntax.Minus
+ return -val, nil
+ }
+ case *syntax.BinaryArithm:
+ switch x.Op {
+ case syntax.Assgn, syntax.AddAssgn, syntax.SubAssgn,
+ syntax.MulAssgn, syntax.QuoAssgn, syntax.RemAssgn,
+ syntax.AndAssgn, syntax.OrAssgn, syntax.XorAssgn,
+ syntax.ShlAssgn, syntax.ShrAssgn:
+ return cfg.assgnArit(x)
+ case syntax.TernQuest: // TernColon can't happen here
+ cond, err := Arithm(cfg, x.X)
+ if err != nil {
+ return 0, err
+ }
+ b2 := x.Y.(*syntax.BinaryArithm) // must have Op==TernColon
+ if cond == 1 {
+ return Arithm(cfg, b2.X)
+ }
+ return Arithm(cfg, b2.Y)
+ }
+ left, err := Arithm(cfg, x.X)
+ if err != nil {
+ return 0, err
+ }
+ right, err := Arithm(cfg, x.Y)
+ if err != nil {
+ return 0, err
+ }
+ return binArit(x.Op, left, right)
+ default:
+ panic(fmt.Sprintf("unexpected arithm expr: %T", x))
+ }
+}
+
+func oneIf(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
+
+// atoi is like [strconv.Atoi], but it ignores errors and trims whitespace.
+func atoi(s string) int {
+ s = strings.TrimSpace(s)
+ n, _ := strconv.Atoi(s)
+ return n
+}
+
+func (cfg *Config) assgnArit(b *syntax.BinaryArithm) (int, error) {
+ name := b.X.(*syntax.Word).Lit()
+ val := atoi(cfg.envGet(name))
+ arg, err := Arithm(cfg, b.Y)
+ if err != nil {
+ return 0, err
+ }
+ switch b.Op {
+ case syntax.Assgn:
+ val = arg
+ case syntax.AddAssgn:
+ val += arg
+ case syntax.SubAssgn:
+ val -= arg
+ case syntax.MulAssgn:
+ val *= arg
+ case syntax.QuoAssgn:
+ if arg == 0 {
+ return 0, fmt.Errorf("division by zero")
+ }
+ val /= arg
+ case syntax.RemAssgn:
+ if arg == 0 {
+ return 0, fmt.Errorf("division by zero")
+ }
+ val %= arg
+ case syntax.AndAssgn:
+ val &= arg
+ case syntax.OrAssgn:
+ val |= arg
+ case syntax.XorAssgn:
+ val ^= arg
+ case syntax.ShlAssgn:
+ val <<= uint(arg)
+ case syntax.ShrAssgn:
+ val >>= uint(arg)
+ }
+ if err := cfg.envSet(name, strconv.Itoa(val)); err != nil {
+ return 0, err
+ }
+ return val, nil
+}
+
+func intPow(a, b int) int {
+ p := 1
+ for b > 0 {
+ if b&1 != 0 {
+ p *= a
+ }
+ b >>= 1
+ a *= a
+ }
+ return p
+}
+
+func binArit(op syntax.BinAritOperator, x, y int) (int, error) {
+ switch op {
+ case syntax.Add:
+ return x + y, nil
+ case syntax.Sub:
+ return x - y, nil
+ case syntax.Mul:
+ return x * y, nil
+ case syntax.Quo:
+ if y == 0 {
+ return 0, fmt.Errorf("division by zero")
+ }
+ return x / y, nil
+ case syntax.Rem:
+ if y == 0 {
+ return 0, fmt.Errorf("division by zero")
+ }
+ return x % y, nil
+ case syntax.Pow:
+ return intPow(x, y), nil
+ case syntax.Eql:
+ return oneIf(x == y), nil
+ case syntax.Gtr:
+ return oneIf(x > y), nil
+ case syntax.Lss:
+ return oneIf(x < y), nil
+ case syntax.Neq:
+ return oneIf(x != y), nil
+ case syntax.Leq:
+ return oneIf(x <= y), nil
+ case syntax.Geq:
+ return oneIf(x >= y), nil
+ case syntax.And:
+ return x & y, nil
+ case syntax.Or:
+ return x | y, nil
+ case syntax.Xor:
+ return x ^ y, nil
+ case syntax.Shr:
+ return x >> uint(y), nil
+ case syntax.Shl:
+ return x << uint(y), nil
+ case syntax.AndArit:
+ return oneIf(x != 0 && y != 0), nil
+ case syntax.OrArit:
+ return oneIf(x != 0 || y != 0), nil
+ default: // syntax.Comma
+ // x is executed but its result discarded
+ return y, nil
+ }
+}
diff --git a/vendor/mvdan.cc/sh/v3/expand/braces.go b/vendor/mvdan.cc/sh/v3/expand/braces.go
new file mode 100644
index 00000000..1938a8f0
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/braces.go
@@ -0,0 +1,85 @@
+// Copyright (c) 2018, Daniel Martí
+// See LICENSE for licensing information
+
+package expand
+
+import (
+ "strconv"
+
+ "mvdan.cc/sh/v3/syntax"
+)
+
+// Braces performs brace expansion on a word, given that it contains any
+// [syntax.BraceExp] parts. For example, the word with a brace expansion
+// "foo{bar,baz}" will return two literal words, "foobar" and "foobaz".
+//
+// Note that the resulting words may share word parts.
+func Braces(word *syntax.Word) []*syntax.Word {
+ var all []*syntax.Word
+ var left []syntax.WordPart
+ for i, wp := range word.Parts {
+ br, ok := wp.(*syntax.BraceExp)
+ if !ok {
+ left = append(left, wp)
+ continue
+ }
+ if br.Sequence {
+ chars := false
+ from, err1 := strconv.Atoi(br.Elems[0].Lit())
+ to, err2 := strconv.Atoi(br.Elems[1].Lit())
+ if err1 != nil || err2 != nil {
+ chars = true
+ from = int(br.Elems[0].Lit()[0])
+ to = int(br.Elems[1].Lit()[0])
+ }
+ upward := from <= to
+ incr := 1
+ if !upward {
+ incr = -1
+ }
+ if len(br.Elems) > 2 {
+ n, _ := strconv.Atoi(br.Elems[2].Lit())
+ if n != 0 && n > 0 == upward {
+ incr = n
+ }
+ }
+ n := from
+ for {
+ if upward && n > to {
+ break
+ }
+ if !upward && n < to {
+ break
+ }
+ next := *word
+ next.Parts = next.Parts[i+1:]
+ lit := &syntax.Lit{}
+ if chars {
+ lit.Value = string(rune(n))
+ } else {
+ lit.Value = strconv.Itoa(n)
+ }
+ next.Parts = append([]syntax.WordPart{lit}, next.Parts...)
+ exp := Braces(&next)
+ for _, w := range exp {
+ w.Parts = append(left, w.Parts...)
+ }
+ all = append(all, exp...)
+ n += incr
+ }
+ return all
+ }
+ for _, elem := range br.Elems {
+ next := *word
+ next.Parts = next.Parts[i+1:]
+ next.Parts = append(elem.Parts, next.Parts...)
+ exp := Braces(&next)
+ for _, w := range exp {
+ w.Parts = append(left, w.Parts...)
+ }
+ all = append(all, exp...)
+ }
+ return all
+ }
+ return []*syntax.Word{{Parts: left}}
+}
diff --git a/vendor/mvdan.cc/sh/v3/expand/doc.go b/vendor/mvdan.cc/sh/v3/expand/doc.go
new file mode 100644
index 00000000..19d95180
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/doc.go
@@ -0,0 +1,5 @@
+// Copyright (c) 2018, Daniel Martí
+// See LICENSE for licensing information
+
+// Package expand contains code to perform various shell expansions.
+package expand
diff --git a/vendor/mvdan.cc/sh/v3/expand/environ.go b/vendor/mvdan.cc/sh/v3/expand/environ.go
new file mode 100644
index 00000000..49cbf052
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/environ.go
@@ -0,0 +1,227 @@
+// Copyright (c) 2018, Daniel Martí
+// See LICENSE for licensing information
+
+package expand
+
+import (
+ "runtime"
+ "sort"
+ "strings"
+)
+
+// Environ is the base interface for a shell's environment, allowing it to fetch
+// variables by name and to iterate over all the currently set variables.
+type Environ interface {
+ // Get retrieves a variable by its name. To check if the variable is
+ // set, use Variable.IsSet.
+ Get(name string) Variable
+
+ // Each iterates over all the currently set variables, calling the
+ // supplied function on each variable. Iteration is stopped if the
+ // function returns false.
+ //
+ // The names used in the calls aren't required to be unique or sorted.
+ // If a variable name appears twice, the latest occurrence takes
+ // priority.
+ //
+ // Each is required to forward exported variables when executing
+ // programs.
+ Each(func(name string, vr Variable) bool)
+}
+
+// WriteEnviron is an extension on Environ that supports modifying and deleting
+// variables.
+type WriteEnviron interface {
+ Environ
+ // Set sets a variable by name. If !vr.IsSet(), the variable is being
+ // unset; otherwise, the variable is being replaced.
+ //
+ // It is the implementation's responsibility to handle variable
+ // attributes correctly. For example, changing an exported variable's
+ // value does not unexport it, and overwriting a name reference variable
+ // should modify its target.
+ //
+ // An error may be returned if the operation is invalid, such as if the
+ // name is empty or if we're trying to overwrite a read-only variable.
+ Set(name string, vr Variable) error
+}
+
+type ValueKind uint8
+
+const (
+ Unset ValueKind = iota
+ String
+ NameRef
+ Indexed
+ Associative
+)
+
+// Variable describes a shell variable, which can have a number of attributes
+// and a value.
+//
+// A Variable is unset if its Kind field is Unset, which can be checked via
+// [Variable.IsSet]. The zero value of a Variable is thus a valid unset variable.
+//
+// If a variable is set, its Value field will be a []string if it is an indexed
+// array, a map[string]string if it's an associative array, or a string
+// otherwise.
+type Variable struct {
+ Local bool
+ Exported bool
+ ReadOnly bool
+
+ Kind ValueKind
+
+ Str string // Used when Kind is String or NameRef.
+ List []string // Used when Kind is Indexed.
+ Map map[string]string // Used when Kind is Associative.
+}
+
+// IsSet returns whether the variable is set. An empty variable is set, but an
+// undeclared variable is not.
+func (v Variable) IsSet() bool {
+ return v.Kind != Unset
+}
+
+// String returns the variable's value as a string. In general, this only makes
+// sense if the variable has a string value or no value at all.
+func (v Variable) String() string {
+ switch v.Kind {
+ case String:
+ return v.Str
+ case Indexed:
+ if len(v.List) > 0 {
+ return v.List[0]
+ }
+ case Associative:
+ // nothing to do
+ }
+ return ""
+}
+
+// maxNameRefDepth defines the maximum number of times to follow references when
+// resolving a variable. Otherwise, simple name reference loops could crash a
+// program quite easily.
+const maxNameRefDepth = 100
+
+// Resolve follows a number of nameref variables, returning the last reference
+// name that was followed and the variable that it points to.
+func (v Variable) Resolve(env Environ) (string, Variable) {
+ name := ""
+ for i := 0; i < maxNameRefDepth; i++ {
+ if v.Kind != NameRef {
+ return name, v
+ }
+ name = v.Str // keep name for the next iteration
+ v = env.Get(name)
+ }
+ return name, Variable{}
+}
+
+// FuncEnviron wraps a function mapping variable names to their string values,
+// and implements Environ. Empty strings returned by the function will be
+// treated as unset variables. All variables will be exported.
+//
+// Note that the returned Environ's Each method will be a no-op.
+func FuncEnviron(fn func(string) string) Environ {
+ return funcEnviron(fn)
+}
+
+type funcEnviron func(string) string
+
+func (f funcEnviron) Get(name string) Variable {
+ value := f(name)
+ if value == "" {
+ return Variable{}
+ }
+ return Variable{Exported: true, Kind: String, Str: value}
+}
+
+func (f funcEnviron) Each(func(name string, vr Variable) bool) {}
+
+// ListEnviron returns an Environ with the supplied variables, in the form
+// "key=value". All variables will be exported. The last value in pairs is used
+// if multiple values are present.
+//
+// On Windows, where environment variable names are case-insensitive, the
+// resulting variable names will all be uppercase.
+func ListEnviron(pairs ...string) Environ {
+ return listEnvironWithUpper(runtime.GOOS == "windows", pairs...)
+}
+
+// listEnvironWithUpper implements ListEnviron, but letting the tests specify
+// whether to uppercase all names or not.
+func listEnvironWithUpper(upper bool, pairs ...string) Environ {
+ list := append([]string{}, pairs...)
+ if upper {
+ // Uppercase before sorting, so that we can remove duplicates
+ // without the need for linear search nor a map.
+ for i, s := range list {
+ if sep := strings.IndexByte(s, '='); sep > 0 {
+ list[i] = strings.ToUpper(s[:sep]) + s[sep:]
+ }
+ }
+ }
+
+ sort.SliceStable(list, func(i, j int) bool {
+ isep := strings.IndexByte(list[i], '=')
+ jsep := strings.IndexByte(list[j], '=')
+ if isep < 0 {
+ isep = 0
+ } else {
+ isep += 1
+ }
+ if jsep < 0 {
+ jsep = 0
+ } else {
+ jsep += 1
+ }
+ return list[i][:isep] < list[j][:jsep]
+ })
+
+ last := ""
+ for i := 0; i < len(list); {
+ s := list[i]
+ sep := strings.IndexByte(s, '=')
+ if sep <= 0 {
+ // invalid element; remove it
+ list = append(list[:i], list[i+1:]...)
+ continue
+ }
+ name := s[:sep]
+ if last == name {
+ // duplicate; the last one wins
+ list = append(list[:i-1], list[i:]...)
+ continue
+ }
+ last = name
+ i++
+ }
+ return listEnviron(list)
+}
+
+// listEnviron is a sorted list of "name=value" strings.
+type listEnviron []string
+
+func (l listEnviron) Get(name string) Variable {
+ prefix := name + "="
+ i := sort.SearchStrings(l, prefix)
+ if i < len(l) && strings.HasPrefix(l[i], prefix) {
+ return Variable{Exported: true, Kind: String, Str: strings.TrimPrefix(l[i], prefix)}
+ }
+ return Variable{}
+}
+
+func (l listEnviron) Each(fn func(name string, vr Variable) bool) {
+ for _, pair := range l {
+ i := strings.IndexByte(pair, '=')
+ if i < 0 {
+ // should never happen; see listEnvironWithUpper
+ panic("expand.listEnviron: did not expect malformed name-value pair: " + pair)
+ }
+ name, value := pair[:i], pair[i+1:]
+ if !fn(name, Variable{Exported: true, Kind: String, Str: value}) {
+ return
+ }
+ }
+}
diff --git a/vendor/mvdan.cc/sh/v3/expand/expand.go b/vendor/mvdan.cc/sh/v3/expand/expand.go
new file mode 100644
index 00000000..996d496f
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/expand.go
@@ -0,0 +1,1040 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+package expand
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+ "io/fs"
+ "os"
+ "os/user"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "strconv"
+ "strings"
+ "syscall"
+
+ "mvdan.cc/sh/v3/pattern"
+ "mvdan.cc/sh/v3/syntax"
+)
+
+// A Config specifies details about how shell expansion should be performed. The
+// zero value is a valid configuration.
+type Config struct {
+ // Env is used to get and set environment variables when performing
+ // shell expansions. Some special parameters are also expanded via this
+ // interface, such as:
+ //
+ // * "#", "@", "*", "0"-"9" for the shell's parameters
+ // * "?", "$", "PPID" for the shell's status and process
+ // * "HOME foo" to retrieve user foo's home directory (if unset,
+ // os/user.Lookup will be used)
+ //
+ // If nil, there are no environment variables set. Use
+ // ListEnviron(os.Environ()...) to use the system's environment
+ // variables.
+ Env Environ
+
+ // CmdSubst expands a command substitution node, writing its standard
+ // output to the provided io.Writer.
+ //
+ // If nil, encountering a command substitution will result in an
+ // UnexpectedCommandError.
+ CmdSubst func(io.Writer, *syntax.CmdSubst) error
+
+ // ProcSubst expands a process substitution node.
+ //
+ // Note that this feature is a work in progress, and the signature of
+ // this field might change until #451 is completely fixed.
+ ProcSubst func(*syntax.ProcSubst) (string, error)
+
+ // TODO(v4): update to os.Readdir with fs.DirEntry.
+ // We could possibly expose that as a preferred ReadDir2 before then,
+ // to allow users to opt into better performance in v3.
+
+ // ReadDir is used for file path globbing. If nil, globbing is disabled.
+ // Use ioutil.ReadDir to use the filesystem directly.
+ ReadDir func(string) ([]os.FileInfo, error)
+
+ // GlobStar corresponds to the shell option that allows globbing with
+ // "**".
+ GlobStar bool
+
+ // NullGlob corresponds to the shell option that allows globbing
+ // patterns which match nothing to result in zero fields.
+ NullGlob bool
+
+ // NoUnset corresponds to the shell option that treats unset variables
+ // as errors.
+ NoUnset bool
+
+ bufferAlloc bytes.Buffer // TODO: use strings.Builder
+ fieldAlloc [4]fieldPart
+ fieldsAlloc [4][]fieldPart
+
+ ifs string
+ // A pointer to a parameter expansion node, if we're inside one.
+ // Necessary for ${LINENO}.
+ curParam *syntax.ParamExp
+}
+
+// UnexpectedCommandError is returned if a command substitution is encountered
+// when [Config.CmdSubst] is nil.
+type UnexpectedCommandError struct {
+ Node *syntax.CmdSubst
+}
+
+func (u UnexpectedCommandError) Error() string {
+ return fmt.Sprintf("unexpected command substitution at %s", u.Node.Pos())
+}
+
+var zeroConfig = &Config{}
+
+func prepareConfig(cfg *Config) *Config {
+ if cfg == nil {
+ cfg = zeroConfig
+ }
+ if cfg.Env == nil {
+ cfg.Env = FuncEnviron(func(string) string { return "" })
+ }
+
+ cfg.ifs = " \t\n"
+ if vr := cfg.Env.Get("IFS"); vr.IsSet() {
+ cfg.ifs = vr.String()
+ }
+ return cfg
+}
+
+func (cfg *Config) ifsRune(r rune) bool {
+ for _, r2 := range cfg.ifs {
+ if r == r2 {
+ return true
+ }
+ }
+ return false
+}
+
+func (cfg *Config) ifsJoin(strs []string) string {
+ sep := ""
+ if cfg.ifs != "" {
+ sep = cfg.ifs[:1]
+ }
+ return strings.Join(strs, sep)
+}
+
+func (cfg *Config) strBuilder() *bytes.Buffer {
+ b := &cfg.bufferAlloc
+ b.Reset()
+ return b
+}
+
+func (cfg *Config) envGet(name string) string {
+ return cfg.Env.Get(name).String()
+}
+
+func (cfg *Config) envSet(name, value string) error {
+ wenv, ok := cfg.Env.(WriteEnviron)
+ if !ok {
+ return fmt.Errorf("environment is read-only")
+ }
+ return wenv.Set(name, Variable{Kind: String, Str: value})
+}
+
+// Literal expands a single shell word. It is similar to Fields, but the result
+// is a single string. This is the behavior when a word is used as the value in
+// a shell variable assignment, for example.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func Literal(cfg *Config, word *syntax.Word) (string, error) {
+ if word == nil {
+ return "", nil
+ }
+ cfg = prepareConfig(cfg)
+ field, err := cfg.wordField(word.Parts, quoteNone)
+ if err != nil {
+ return "", err
+ }
+ return cfg.fieldJoin(field), nil
+}
+
+// Document expands a single shell word as if it were within double quotes. It
+// is similar to Literal, but without brace expansion, tilde expansion, and
+// globbing.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func Document(cfg *Config, word *syntax.Word) (string, error) {
+ if word == nil {
+ return "", nil
+ }
+ cfg = prepareConfig(cfg)
+ field, err := cfg.wordField(word.Parts, quoteDouble)
+ if err != nil {
+ return "", err
+ }
+ return cfg.fieldJoin(field), nil
+}
+
+const patMode = pattern.Filenames | pattern.Braces
+
+// Pattern expands a single shell word as a pattern, using [syntax.QuotePattern]
+// on any non-quoted parts of the input word. The result can be used on
+// [syntax.TranslatePattern] directly.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func Pattern(cfg *Config, word *syntax.Word) (string, error) {
+ cfg = prepareConfig(cfg)
+ field, err := cfg.wordField(word.Parts, quoteNone)
+ if err != nil {
+ return "", err
+ }
+ buf := cfg.strBuilder()
+ for _, part := range field {
+ if part.quote > quoteNone {
+ buf.WriteString(pattern.QuoteMeta(part.val, patMode))
+ } else {
+ buf.WriteString(part.val)
+ }
+ }
+ return buf.String(), nil
+}
+
+// Format expands a format string with a number of arguments, following the
+// shell's format specifications. These include printf(1), among others.
+//
+// The resulting string is returned, along with the number of arguments used.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func Format(cfg *Config, format string, args []string) (string, int, error) {
+ cfg = prepareConfig(cfg)
+ buf := cfg.strBuilder()
+
+ consumed, err := formatIntoBuffer(buf, format, args)
+ if err != nil {
+ return "", 0, err
+ }
+
+ return buf.String(), consumed, err
+}
+
+// Format expands a format string with a number of arguments, following the
+// shell's format specifications. These include printf(1), among others.
+//
+// The resulting string is written to the provided buffer, and the number
+// of arguments used is returned.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func formatIntoBuffer(buf *bytes.Buffer, format string, args []string) (int, error) {
+ var fmts []byte
+ initialArgs := len(args)
+
+formatLoop:
+ for i := 0; i < len(format); i++ {
+ // readDigits reads from 0 to max digits, either octal or
+ // hexadecimal.
+ readDigits := func(max int, hex bool) string {
+ j := 0
+ for ; j < max; j++ {
+ c := format[i+j]
+ if (c >= '0' && c <= '9') ||
+ (hex && c >= 'a' && c <= 'f') ||
+ (hex && c >= 'A' && c <= 'F') {
+ // valid octal or hex char
+ } else {
+ break
+ }
+ }
+ digits := format[i : i+j]
+ i += j - 1 // -1 since the outer loop does i++
+ return digits
+ }
+ c := format[i]
+ switch {
+ case c == '\\': // escaped
+ i++
+ switch c = format[i]; c {
+ case 'a': // bell
+ buf.WriteByte('\a')
+ case 'b': // backspace
+ buf.WriteByte('\b')
+ case 'e', 'E': // escape
+ buf.WriteByte('\x1b')
+ case 'f': // form feed
+ buf.WriteByte('\f')
+ case 'n': // new line
+ buf.WriteByte('\n')
+ case 'r': // carriage return
+ buf.WriteByte('\r')
+ case 't': // horizontal tab
+ buf.WriteByte('\t')
+ case 'v': // vertical tab
+ buf.WriteByte('\v')
+ case '\\', '\'', '"', '?': // just the character
+ buf.WriteByte(c)
+ case '0', '1', '2', '3', '4', '5', '6', '7':
+ digits := readDigits(3, false)
+ // if digits don't fit in 8 bits, 0xff via strconv
+ n, _ := strconv.ParseUint(digits, 8, 8)
+ buf.WriteByte(byte(n))
+ case 'x', 'u', 'U':
+ i++
+ max := 2
+ switch c {
+ case 'u':
+ max = 4
+ case 'U':
+ max = 8
+ }
+ digits := readDigits(max, true)
+ if len(digits) > 0 {
+ // can't error
+ n, _ := strconv.ParseUint(digits, 16, 32)
+ if n == 0 {
+ // If we're about to print \x00,
+ // stop the entire loop, like bash.
+ break formatLoop
+ }
+ if c == 'x' {
+ // always as a single byte
+ buf.WriteByte(byte(n))
+ } else {
+ buf.WriteRune(rune(n))
+ }
+ break
+ }
+ fallthrough
+ default: // no escape sequence
+ buf.WriteByte('\\')
+ buf.WriteByte(c)
+ }
+ case len(fmts) > 0:
+ switch c {
+ case '%':
+ buf.WriteByte('%')
+ fmts = nil
+ case 'c':
+ var b byte
+ if len(args) > 0 {
+ arg := ""
+ arg, args = args[0], args[1:]
+ if len(arg) > 0 {
+ b = arg[0]
+ }
+ }
+ buf.WriteByte(b)
+ fmts = nil
+ case '+', '-', ' ':
+ if len(fmts) > 1 {
+ return 0, fmt.Errorf("invalid format char: %c", c)
+ }
+ fmts = append(fmts, c)
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ fmts = append(fmts, c)
+ case 's', 'b', 'd', 'i', 'u', 'o', 'x':
+ arg := ""
+ if len(args) > 0 {
+ arg, args = args[0], args[1:]
+ }
+ var farg any
+ if c == 'b' {
+ // Passing in nil for args ensures that % format
+ // strings aren't processed; only escape sequences
+ // will be handled.
+ _, err := formatIntoBuffer(buf, arg, nil)
+ if err != nil {
+ return 0, err
+ }
+ } else if c != 's' {
+ n, _ := strconv.ParseInt(arg, 0, 0)
+ if c == 'i' || c == 'd' {
+ farg = int(n)
+ } else {
+ farg = uint(n)
+ }
+ if c == 'i' || c == 'u' {
+ c = 'd'
+ }
+ } else {
+ farg = arg
+ }
+ if farg != nil {
+ fmts = append(fmts, c)
+ fmt.Fprintf(buf, string(fmts), farg)
+ }
+ fmts = nil
+ default:
+ return 0, fmt.Errorf("invalid format char: %c", c)
+ }
+ case args != nil && c == '%':
+ // if args == nil, we are not doing format
+ // arguments
+ fmts = []byte{c}
+ default:
+ buf.WriteByte(c)
+ }
+ }
+ if len(fmts) > 0 {
+ return 0, fmt.Errorf("missing format char")
+ }
+ return initialArgs - len(args), nil
+}
+
+func (cfg *Config) fieldJoin(parts []fieldPart) string {
+ switch len(parts) {
+ case 0:
+ return ""
+ case 1: // short-cut without a string copy
+ return parts[0].val
+ }
+ buf := cfg.strBuilder()
+ for _, part := range parts {
+ buf.WriteString(part.val)
+ }
+ return buf.String()
+}
+
+func (cfg *Config) escapedGlobField(parts []fieldPart) (escaped string, glob bool) {
+ buf := cfg.strBuilder()
+ for _, part := range parts {
+ if part.quote > quoteNone {
+ buf.WriteString(pattern.QuoteMeta(part.val, patMode))
+ continue
+ }
+ buf.WriteString(part.val)
+ if pattern.HasMeta(part.val, patMode) {
+ glob = true
+ }
+ }
+ if glob { // only copy the string if it will be used
+ escaped = buf.String()
+ }
+ return escaped, glob
+}
+
+// Fields expands a number of words as if they were arguments in a shell
+// command. This includes brace expansion, tilde expansion, parameter expansion,
+// command substitution, arithmetic expansion, and quote removal.
+func Fields(cfg *Config, words ...*syntax.Word) ([]string, error) {
+ cfg = prepareConfig(cfg)
+ fields := make([]string, 0, len(words))
+ dir := cfg.envGet("PWD")
+ for _, word := range words {
+ word := *word // make a copy, since SplitBraces replaces the Parts slice
+ afterBraces := []*syntax.Word{&word}
+ if syntax.SplitBraces(&word) {
+ afterBraces = Braces(&word)
+ }
+ for _, word2 := range afterBraces {
+ wfields, err := cfg.wordFields(word2.Parts)
+ if err != nil {
+ return nil, err
+ }
+ for _, field := range wfields {
+ path, doGlob := cfg.escapedGlobField(field)
+ var matches []string
+ var syntaxError *pattern.SyntaxError
+ if doGlob && cfg.ReadDir != nil {
+ matches, err = cfg.glob(dir, path)
+ if !errors.As(err, &syntaxError) {
+ if err != nil {
+ return nil, err
+ }
+ if len(matches) > 0 || cfg.NullGlob {
+ fields = append(fields, matches...)
+ continue
+ }
+ }
+ }
+ fields = append(fields, cfg.fieldJoin(field))
+ }
+ }
+ }
+ return fields, nil
+}
+
+type fieldPart struct {
+ val string
+ quote quoteLevel
+}
+
+type quoteLevel uint
+
+const (
+ quoteNone quoteLevel = iota
+ quoteDouble
+ quoteSingle
+)
+
+func (cfg *Config) wordField(wps []syntax.WordPart, ql quoteLevel) ([]fieldPart, error) {
+ var field []fieldPart
+ for i, wp := range wps {
+ switch x := wp.(type) {
+ case *syntax.Lit:
+ s := x.Value
+ if i == 0 && ql == quoteNone {
+ if prefix, rest := cfg.expandUser(s); prefix != "" {
+ // TODO: return two separate fieldParts,
+ // like in wordFields?
+ s = prefix + rest
+ }
+ }
+ if ql == quoteDouble && strings.Contains(s, "\\") {
+ buf := cfg.strBuilder()
+ for i := 0; i < len(s); i++ {
+ b := s[i]
+ if b == '\\' && i+1 < len(s) {
+ switch s[i+1] {
+ case '"', '\\', '$', '`': // special chars
+ continue
+ }
+ }
+ buf.WriteByte(b)
+ }
+ s = buf.String()
+ }
+ if i := strings.IndexByte(s, '\x00'); i >= 0 {
+ s = s[:i]
+ }
+ field = append(field, fieldPart{val: s})
+ case *syntax.SglQuoted:
+ fp := fieldPart{quote: quoteSingle, val: x.Value}
+ if x.Dollar {
+ fp.val, _, _ = Format(cfg, fp.val, nil)
+ }
+ field = append(field, fp)
+ case *syntax.DblQuoted:
+ wfield, err := cfg.wordField(x.Parts, quoteDouble)
+ if err != nil {
+ return nil, err
+ }
+ for _, part := range wfield {
+ part.quote = quoteDouble
+ field = append(field, part)
+ }
+ case *syntax.ParamExp:
+ val, err := cfg.paramExp(x)
+ if err != nil {
+ return nil, err
+ }
+ field = append(field, fieldPart{val: val})
+ case *syntax.CmdSubst:
+ val, err := cfg.cmdSubst(x)
+ if err != nil {
+ return nil, err
+ }
+ field = append(field, fieldPart{val: val})
+ case *syntax.ArithmExp:
+ n, err := Arithm(cfg, x.X)
+ if err != nil {
+ return nil, err
+ }
+ field = append(field, fieldPart{val: strconv.Itoa(n)})
+ case *syntax.ProcSubst:
+ path, err := cfg.ProcSubst(x)
+ if err != nil {
+ return nil, err
+ }
+ field = append(field, fieldPart{val: path})
+ default:
+ panic(fmt.Sprintf("unhandled word part: %T", x))
+ }
+ }
+ return field, nil
+}
+
+func (cfg *Config) cmdSubst(cs *syntax.CmdSubst) (string, error) {
+ if cfg.CmdSubst == nil {
+ return "", UnexpectedCommandError{Node: cs}
+ }
+ buf := cfg.strBuilder()
+ if err := cfg.CmdSubst(buf, cs); err != nil {
+ return "", err
+ }
+ out := buf.String()
+ if strings.IndexByte(out, '\x00') >= 0 {
+ out = strings.ReplaceAll(out, "\x00", "")
+ }
+ return strings.TrimRight(out, "\n"), nil
+}
+
+func (cfg *Config) wordFields(wps []syntax.WordPart) ([][]fieldPart, error) {
+ fields := cfg.fieldsAlloc[:0]
+ curField := cfg.fieldAlloc[:0]
+ allowEmpty := false
+ flush := func() {
+ if len(curField) == 0 {
+ return
+ }
+ fields = append(fields, curField)
+ curField = nil
+ }
+ splitAdd := func(val string) {
+ fieldStart := -1
+ for i, r := range val {
+ if cfg.ifsRune(r) {
+ if fieldStart >= 0 { // ending a field
+ curField = append(curField, fieldPart{val: val[fieldStart:i]})
+ fieldStart = -1
+ }
+ flush()
+ } else {
+ if fieldStart < 0 { // starting a new field
+ fieldStart = i
+ }
+ }
+ }
+ if fieldStart >= 0 { // ending a field without IFS
+ curField = append(curField, fieldPart{val: val[fieldStart:]})
+ }
+ }
+ for i, wp := range wps {
+ switch x := wp.(type) {
+ case *syntax.Lit:
+ s := x.Value
+ if i == 0 {
+ prefix, rest := cfg.expandUser(s)
+ curField = append(curField, fieldPart{
+ quote: quoteSingle,
+ val: prefix,
+ })
+ s = rest
+ }
+ if strings.Contains(s, "\\") {
+ buf := cfg.strBuilder()
+ for i := 0; i < len(s); i++ {
+ b := s[i]
+ if b == '\\' {
+ if i++; i >= len(s) {
+ break
+ }
+ b = s[i]
+ }
+ buf.WriteByte(b)
+ }
+ s = buf.String()
+ }
+ curField = append(curField, fieldPart{val: s})
+ case *syntax.SglQuoted:
+ allowEmpty = true
+ fp := fieldPart{quote: quoteSingle, val: x.Value}
+ if x.Dollar {
+ fp.val, _, _ = Format(cfg, fp.val, nil)
+ }
+ curField = append(curField, fp)
+ case *syntax.DblQuoted:
+ if len(x.Parts) == 1 {
+ pe, _ := x.Parts[0].(*syntax.ParamExp)
+ if elems := cfg.quotedElemFields(pe); elems != nil {
+ for i, elem := range elems {
+ if i > 0 {
+ flush()
+ }
+ curField = append(curField, fieldPart{
+ quote: quoteDouble,
+ val: elem,
+ })
+ }
+ continue
+ }
+ }
+ allowEmpty = true
+ wfield, err := cfg.wordField(x.Parts, quoteDouble)
+ if err != nil {
+ return nil, err
+ }
+ for _, part := range wfield {
+ part.quote = quoteDouble
+ curField = append(curField, part)
+ }
+ case *syntax.ParamExp:
+ val, err := cfg.paramExp(x)
+ if err != nil {
+ return nil, err
+ }
+ splitAdd(val)
+ case *syntax.CmdSubst:
+ val, err := cfg.cmdSubst(x)
+ if err != nil {
+ return nil, err
+ }
+ splitAdd(val)
+ case *syntax.ArithmExp:
+ n, err := Arithm(cfg, x.X)
+ if err != nil {
+ return nil, err
+ }
+ curField = append(curField, fieldPart{val: strconv.Itoa(n)})
+ case *syntax.ProcSubst:
+ path, err := cfg.ProcSubst(x)
+ if err != nil {
+ return nil, err
+ }
+ splitAdd(path)
+ case *syntax.ExtGlob:
+ return nil, fmt.Errorf("extended globbing is not supported")
+ default:
+ panic(fmt.Sprintf("unhandled word part: %T", x))
+ }
+ }
+ flush()
+ if allowEmpty && len(fields) == 0 {
+ fields = append(fields, curField)
+ }
+ return fields, nil
+}
+
+// quotedElemFields returns the list of elements resulting from a quoted
+// parameter expansion that should be treated especially, like "${foo[@]}".
+func (cfg *Config) quotedElemFields(pe *syntax.ParamExp) []string {
+ if pe == nil || pe.Length || pe.Width {
+ return nil
+ }
+ name := pe.Param.Value
+ if pe.Excl {
+ switch pe.Names {
+ case syntax.NamesPrefixWords: // "${!prefix@}"
+ return cfg.namesByPrefix(pe.Param.Value)
+ case syntax.NamesPrefix: // "${!prefix*}"
+ return nil
+ }
+ switch nodeLit(pe.Index) {
+ case "@": // "${!name[@]}"
+ switch vr := cfg.Env.Get(name); vr.Kind {
+ case Indexed:
+ keys := make([]string, 0, len(vr.Map))
+ for key := range vr.List {
+ keys = append(keys, strconv.Itoa(key))
+ }
+ return keys
+ case Associative:
+ keys := make([]string, 0, len(vr.Map))
+ for key := range vr.Map {
+ keys = append(keys, key)
+ }
+ return keys
+ }
+ }
+ return nil
+ }
+ switch name {
+ case "*": // "${*}"
+ return []string{cfg.ifsJoin(cfg.Env.Get(name).List)}
+ case "@": // "${@}"
+ return cfg.Env.Get(name).List
+ }
+ switch nodeLit(pe.Index) {
+ case "@": // "${name[@]}"
+ switch vr := cfg.Env.Get(name); vr.Kind {
+ case Indexed:
+ return vr.List
+ case Associative:
+ elems := make([]string, 0, len(vr.Map))
+ for _, elem := range vr.Map {
+ elems = append(elems, elem)
+ }
+ return elems
+ }
+ case "*": // "${name[*]}"
+ if vr := cfg.Env.Get(name); vr.Kind == Indexed {
+ return []string{cfg.ifsJoin(vr.List)}
+ }
+ }
+ return nil
+}
+
+func (cfg *Config) expandUser(field string) (prefix, rest string) {
+ if len(field) == 0 || field[0] != '~' {
+ return "", field
+ }
+ name := field[1:]
+ if i := strings.Index(name, "/"); i >= 0 {
+ rest = name[i:]
+ name = name[:i]
+ }
+ if name == "" {
+ // Current user; try via "HOME", otherwise fall back to the
+ // system's appropriate home dir env var. Don't use os/user, as
+ // that's overkill. We can't use os.UserHomeDir, because we want
+ // to use cfg.Env, and we always want to check "HOME" first.
+
+ if vr := cfg.Env.Get("HOME"); vr.IsSet() {
+ return vr.String(), rest
+ }
+
+ if runtime.GOOS == "windows" {
+ if vr := cfg.Env.Get("USERPROFILE"); vr.IsSet() {
+ return vr.String(), rest
+ }
+ }
+ return "", field
+ }
+
+ // Not the current user; try via "HOME ", otherwise fall back to
+ // os/user. There isn't a way to lookup user home dirs without cgo.
+
+ if vr := cfg.Env.Get("HOME " + name); vr.IsSet() {
+ return vr.String(), rest
+ }
+
+ u, err := user.Lookup(name)
+ if err != nil {
+ return "", field
+ }
+ return u.HomeDir, rest
+}
+
+func findAllIndex(pat, name string, n int) [][]int {
+ expr, err := pattern.Regexp(pat, 0)
+ if err != nil {
+ return nil
+ }
+ rx := regexp.MustCompile(expr)
+ return rx.FindAllStringIndex(name, n)
+}
+
+var rxGlobStar = regexp.MustCompile(".*")
+
+// pathJoin2 is a simpler version of [filepath.Join] without cleaning the result,
+// since that's needed for globbing.
+func pathJoin2(elem1, elem2 string) string {
+ if elem1 == "" {
+ return elem2
+ }
+ if strings.HasSuffix(elem1, string(filepath.Separator)) {
+ return elem1 + elem2
+ }
+ return elem1 + string(filepath.Separator) + elem2
+}
+
+// pathSplit splits a file path into its elements, retaining empty ones. Before
+// splitting, slashes are replaced with [filepath.Separator], so that splitting
+// Unix paths on Windows works as well.
+func pathSplit(path string) []string {
+ path = filepath.FromSlash(path)
+ return strings.Split(path, string(filepath.Separator))
+}
+
+func (cfg *Config) glob(base, pat string) ([]string, error) {
+ parts := pathSplit(pat)
+ matches := []string{""}
+ if filepath.IsAbs(pat) {
+ if parts[0] == "" {
+ // unix-like
+ matches[0] = string(filepath.Separator)
+ } else {
+ // windows (for some reason it won't work without the
+ // trailing separator)
+ matches[0] = parts[0] + string(filepath.Separator)
+ }
+ parts = parts[1:]
+ }
+ // TODO: as an optimization, we could do chunks of the path all at once,
+ // like doing a single stat for "/foo/bar" in "/foo/bar/*".
+
+ // TODO: Another optimization would be to reduce the number of ReadDir calls.
+ // For example, /foo/* can end up doing one duplicate call:
+ //
+ // ReadDir("/foo") to ensure that "/foo/" exists and only matches a directory
+ // ReadDir("/foo") glob "*"
+
+ for i, part := range parts {
+ // Keep around for debugging.
+ // log.Printf("matches %q part %d %q", matches, i, part)
+
+ wantDir := i < len(parts)-1
+ switch {
+ case part == "", part == ".", part == "..":
+ for i, dir := range matches {
+ matches[i] = pathJoin2(dir, part)
+ }
+ continue
+ case !pattern.HasMeta(part, patMode):
+ var newMatches []string
+ for _, dir := range matches {
+ match := dir
+ if !filepath.IsAbs(match) {
+ match = filepath.Join(base, match)
+ }
+ match = pathJoin2(match, part)
+ // We can't use ReadDir on the parent and match the directory
+ // entry by name, because short paths on Windows break that.
+ // Our only option is to ReadDir on the directory entry itself,
+ // which can be wasteful if we only want to see if it exists,
+ // but at least it's correct in all scenarios.
+ if _, err := cfg.ReadDir(match); err != nil {
+ const errPathNotFound = syscall.Errno(3) // from syscall/types_windows.go, to avoid a build tag
+ var pathErr *os.PathError
+ if runtime.GOOS == "windows" && errors.As(err, &pathErr) && pathErr.Err == errPathNotFound {
+ // Unfortunately, os.File.Readdir on a regular file on
+ // Windows returns an error that satisfies ErrNotExist.
+ // Luckily, it returns a special "path not found" rather
+ // than the normal "file not found" for missing files,
+ // so we can use that knowledge to work around the bug.
+ // See https://github.com/golang/go/issues/46734.
+ // TODO: remove when the Go issue above is resolved.
+ } else if errors.Is(err, fs.ErrNotExist) {
+ continue // simply doesn't exist
+ }
+ if wantDir {
+ continue // exists but not a directory
+ }
+ }
+ newMatches = append(newMatches, pathJoin2(dir, part))
+ }
+ matches = newMatches
+ continue
+ case part == "**" && cfg.GlobStar:
+ // Find all recursive matches for "**".
+ // Note that we need the results to be in depth-first order,
+ // and to avoid recursion, we use a slice as a stack.
+ // Since we pop from the back, we populate the stack backwards.
+ stack := make([]string, 0, len(matches))
+ for i := len(matches) - 1; i >= 0; i-- {
+ // "a/**" should match "a/ a/b a/b/cfg ...";
+ // note how the zero-match case has a trailing separator.
+ stack = append(stack, pathJoin2(matches[i], ""))
+ }
+ matches = matches[:0]
+ var newMatches []string // to reuse its capacity
+ for len(stack) > 0 {
+ dir := stack[len(stack)-1]
+ stack = stack[:len(stack)-1]
+
+ // Don't include the original "" match as it's not a valid path.
+ if dir != "" {
+ matches = append(matches, dir)
+ }
+
+ // If dir is not a directory, we keep the stack as-is and continue.
+ newMatches = newMatches[:0]
+ newMatches, _ = cfg.globDir(base, dir, rxGlobStar, false, wantDir, newMatches)
+ for i := len(newMatches) - 1; i >= 0; i-- {
+ stack = append(stack, newMatches[i])
+ }
+ }
+ continue
+ }
+ expr, err := pattern.Regexp(part, pattern.Filenames|pattern.EntireString)
+ if err != nil {
+ return nil, err
+ }
+ rx := regexp.MustCompile(expr)
+ matchHidden := part[0] == byte('.')
+ var newMatches []string
+ for _, dir := range matches {
+ newMatches, err = cfg.globDir(base, dir, rx, matchHidden, wantDir, newMatches)
+ if err != nil {
+ return nil, err
+ }
+ }
+ matches = newMatches
+ }
+ return matches, nil
+}
+
+func (cfg *Config) globDir(base, dir string, rx *regexp.Regexp, matchHidden bool, wantDir bool, matches []string) ([]string, error) {
+ fullDir := dir
+ if !filepath.IsAbs(dir) {
+ fullDir = filepath.Join(base, dir)
+ }
+ infos, err := cfg.ReadDir(fullDir)
+ if err != nil {
+ // We still want to return matches, for the sake of reusing slices.
+ return matches, err
+ }
+ for _, info := range infos {
+ name := info.Name()
+ if !wantDir {
+ // No filtering.
+ } else if mode := info.Mode(); mode&os.ModeSymlink != 0 {
+ // We need to know if the symlink points to a directory.
+ // This requires an extra syscall, as ReadDir on the parent directory
+ // does not follow symlinks for each of the directory entries.
+ // ReadDir is somewhat wasteful here, as we only want its error result,
+ // but we could try to reuse its result as per the TODO in Config.glob.
+ if _, err := cfg.ReadDir(filepath.Join(fullDir, info.Name())); err != nil {
+ continue
+ }
+ } else if !mode.IsDir() {
+ // Not a symlink nor a directory.
+ continue
+ }
+ if !matchHidden && name[0] == '.' {
+ continue
+ }
+ if rx.MatchString(name) {
+ matches = append(matches, pathJoin2(dir, name))
+ }
+ }
+ return matches, nil
+}
+
+// ReadFields splits and returns n fields from s, like the "read" shell builtin.
+// If raw is set, backslash escape sequences are not interpreted.
+//
+// The config specifies shell expansion options; nil behaves the same as an
+// empty config.
+func ReadFields(cfg *Config, s string, n int, raw bool) []string {
+ cfg = prepareConfig(cfg)
+ type pos struct {
+ start, end int
+ }
+ var fpos []pos
+
+ runes := make([]rune, 0, len(s))
+ infield := false
+ esc := false
+ for _, r := range s {
+ if infield {
+ if cfg.ifsRune(r) && (raw || !esc) {
+ fpos[len(fpos)-1].end = len(runes)
+ infield = false
+ }
+ } else {
+ if !cfg.ifsRune(r) && (raw || !esc) {
+ fpos = append(fpos, pos{start: len(runes), end: -1})
+ infield = true
+ }
+ }
+ if r == '\\' {
+ if raw || esc {
+ runes = append(runes, r)
+ }
+ esc = !esc
+ continue
+ }
+ runes = append(runes, r)
+ esc = false
+ }
+ if len(fpos) == 0 {
+ return nil
+ }
+ if infield {
+ fpos[len(fpos)-1].end = len(runes)
+ }
+
+ switch {
+ case n == 1:
+ // include heading/trailing IFSs
+ fpos[0].start, fpos[0].end = 0, len(runes)
+ fpos = fpos[:1]
+ case n != -1 && n < len(fpos):
+ // combine to max n fields
+ fpos[n-1].end = fpos[len(fpos)-1].end
+ fpos = fpos[:n]
+ }
+
+ fields := make([]string, len(fpos))
+ for i, p := range fpos {
+ fields[i] = string(runes[p.start:p.end])
+ }
+ return fields
+}
diff --git a/vendor/mvdan.cc/sh/v3/expand/param.go b/vendor/mvdan.cc/sh/v3/expand/param.go
new file mode 100644
index 00000000..1f1a475f
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/expand/param.go
@@ -0,0 +1,427 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+package expand
+
+import (
+ "fmt"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "mvdan.cc/sh/v3/pattern"
+ "mvdan.cc/sh/v3/syntax"
+)
+
+func nodeLit(node syntax.Node) string {
+ if word, ok := node.(*syntax.Word); ok {
+ return word.Lit()
+ }
+ return ""
+}
+
+type UnsetParameterError struct {
+ Node *syntax.ParamExp
+ Message string
+}
+
+func (u UnsetParameterError) Error() string {
+ return fmt.Sprintf("%s: %s", u.Node.Param.Value, u.Message)
+}
+
+func overridingUnset(pe *syntax.ParamExp) bool {
+ if pe.Exp == nil {
+ return false
+ }
+ switch pe.Exp.Op {
+ case syntax.AlternateUnset, syntax.AlternateUnsetOrNull,
+ syntax.DefaultUnset, syntax.DefaultUnsetOrNull,
+ syntax.ErrorUnset, syntax.ErrorUnsetOrNull,
+ syntax.AssignUnset, syntax.AssignUnsetOrNull:
+ return true
+ }
+ return false
+}
+
+func (cfg *Config) paramExp(pe *syntax.ParamExp) (string, error) {
+ oldParam := cfg.curParam
+ cfg.curParam = pe
+ defer func() { cfg.curParam = oldParam }()
+
+ name := pe.Param.Value
+ index := pe.Index
+ switch name {
+ case "@", "*":
+ index = &syntax.Word{Parts: []syntax.WordPart{
+ &syntax.Lit{Value: name},
+ }}
+ }
+ var vr Variable
+ switch name {
+ case "LINENO":
+ // This is the only parameter expansion that the environment
+ // interface cannot satisfy.
+ line := uint64(cfg.curParam.Pos().Line())
+ vr = Variable{Kind: String, Str: strconv.FormatUint(line, 10)}
+ default:
+ vr = cfg.Env.Get(name)
+ }
+ orig := vr
+ _, vr = vr.Resolve(cfg.Env)
+ if cfg.NoUnset && vr.Kind == Unset && !overridingUnset(pe) {
+ return "", UnsetParameterError{
+ Node: pe,
+ Message: "unbound variable",
+ }
+ }
+
+ var sliceOffset, sliceLen int
+ if pe.Slice != nil {
+ var err error
+ if pe.Slice.Offset != nil {
+ sliceOffset, err = Arithm(cfg, pe.Slice.Offset)
+ if err != nil {
+ return "", err
+ }
+ }
+ if pe.Slice.Length != nil {
+ sliceLen, err = Arithm(cfg, pe.Slice.Length)
+ if err != nil {
+ return "", err
+ }
+ }
+ }
+
+ var (
+ str string
+ elems []string
+
+ indexAllElements bool // true if var has been accessed with * or @ index
+ callVarInd = true
+ )
+
+ switch nodeLit(index) {
+ case "@", "*":
+ switch vr.Kind {
+ case Unset:
+ elems = nil
+ indexAllElements = true
+ case Indexed:
+ indexAllElements = true
+ callVarInd = false
+ elems = vr.List
+ slicePos := func(n int) int {
+ if n < 0 {
+ n = len(elems) + n
+ if n < 0 {
+ n = len(elems)
+ }
+ } else if n > len(elems) {
+ n = len(elems)
+ }
+ return n
+ }
+ if pe.Slice != nil && pe.Slice.Offset != nil {
+ elems = elems[slicePos(sliceOffset):]
+ }
+ if pe.Slice != nil && pe.Slice.Length != nil {
+ elems = elems[:slicePos(sliceLen)]
+ }
+ str = strings.Join(elems, " ")
+ }
+ }
+ if callVarInd {
+ var err error
+ str, err = cfg.varInd(vr, index)
+ if err != nil {
+ return "", err
+ }
+ }
+ if !indexAllElements {
+ elems = []string{str}
+ }
+
+ switch {
+ case pe.Length:
+ n := len(elems)
+ switch nodeLit(index) {
+ case "@", "*":
+ default:
+ n = utf8.RuneCountInString(str)
+ }
+ str = strconv.Itoa(n)
+ case pe.Excl:
+ var strs []string
+ switch {
+ case pe.Names != 0:
+ strs = cfg.namesByPrefix(pe.Param.Value)
+ case orig.Kind == NameRef:
+ strs = append(strs, orig.Str)
+ case pe.Index != nil && vr.Kind == Indexed:
+ for i, e := range vr.List {
+ if e != "" {
+ strs = append(strs, strconv.Itoa(i))
+ }
+ }
+ case pe.Index != nil && vr.Kind == Associative:
+ for k := range vr.Map {
+ strs = append(strs, k)
+ }
+ case vr.Kind == Unset:
+ return "", fmt.Errorf("invalid indirect expansion")
+ case str == "":
+ return "", nil
+ default:
+ vr = cfg.Env.Get(str)
+ strs = append(strs, vr.String())
+ }
+ sort.Strings(strs)
+ str = strings.Join(strs, " ")
+ case pe.Slice != nil:
+ if callVarInd {
+ slicePos := func(n int) int {
+ if n < 0 {
+ n = len(str) + n
+ if n < 0 {
+ n = len(str)
+ }
+ } else if n > len(str) {
+ n = len(str)
+ }
+ return n
+ }
+ if pe.Slice.Offset != nil {
+ str = str[slicePos(sliceOffset):]
+ }
+ if pe.Slice.Length != nil {
+ str = str[:slicePos(sliceLen)]
+ }
+ } // else, elems are already sliced
+ case pe.Repl != nil:
+ orig, err := Pattern(cfg, pe.Repl.Orig)
+ if err != nil {
+ return "", err
+ }
+ with, err := Literal(cfg, pe.Repl.With)
+ if err != nil {
+ return "", err
+ }
+ n := 1
+ if pe.Repl.All {
+ n = -1
+ }
+ locs := findAllIndex(orig, str, n)
+ buf := cfg.strBuilder()
+ last := 0
+ for _, loc := range locs {
+ buf.WriteString(str[last:loc[0]])
+ buf.WriteString(with)
+ last = loc[1]
+ }
+ buf.WriteString(str[last:])
+ str = buf.String()
+ case pe.Exp != nil:
+ arg, err := Literal(cfg, pe.Exp.Word)
+ if err != nil {
+ return "", err
+ }
+ switch op := pe.Exp.Op; op {
+ case syntax.AlternateUnsetOrNull:
+ if str == "" {
+ break
+ }
+ fallthrough
+ case syntax.AlternateUnset:
+ if vr.IsSet() {
+ str = arg
+ }
+ case syntax.DefaultUnset:
+ if vr.IsSet() {
+ break
+ }
+ fallthrough
+ case syntax.DefaultUnsetOrNull:
+ if str == "" {
+ str = arg
+ }
+ case syntax.ErrorUnset:
+ if vr.IsSet() {
+ break
+ }
+ fallthrough
+ case syntax.ErrorUnsetOrNull:
+ if str == "" {
+ return "", UnsetParameterError{
+ Node: pe,
+ Message: arg,
+ }
+ }
+ case syntax.AssignUnset:
+ if vr.IsSet() {
+ break
+ }
+ fallthrough
+ case syntax.AssignUnsetOrNull:
+ if str == "" {
+ if err := cfg.envSet(name, arg); err != nil {
+ return "", err
+ }
+ str = arg
+ }
+ case syntax.RemSmallPrefix, syntax.RemLargePrefix,
+ syntax.RemSmallSuffix, syntax.RemLargeSuffix:
+ suffix := op == syntax.RemSmallSuffix || op == syntax.RemLargeSuffix
+ small := op == syntax.RemSmallPrefix || op == syntax.RemSmallSuffix
+ for i, elem := range elems {
+ elems[i] = removePattern(elem, arg, suffix, small)
+ }
+ str = strings.Join(elems, " ")
+ case syntax.UpperFirst, syntax.UpperAll,
+ syntax.LowerFirst, syntax.LowerAll:
+
+ caseFunc := unicode.ToLower
+ if op == syntax.UpperFirst || op == syntax.UpperAll {
+ caseFunc = unicode.ToUpper
+ }
+ all := op == syntax.UpperAll || op == syntax.LowerAll
+
+ // empty string means '?'; nothing to do there
+ expr, err := pattern.Regexp(arg, 0)
+ if err != nil {
+ return str, nil
+ }
+ rx := regexp.MustCompile(expr)
+
+ for i, elem := range elems {
+ rs := []rune(elem)
+ for ri, r := range rs {
+ if rx.MatchString(string(r)) {
+ rs[ri] = caseFunc(r)
+ if !all {
+ break
+ }
+ }
+ }
+ elems[i] = string(rs)
+ }
+ str = strings.Join(elems, " ")
+ case syntax.OtherParamOps:
+ switch arg {
+ case "Q":
+ str, err = syntax.Quote(str, syntax.LangBash)
+ if err != nil {
+ // Is this even possible? If a user runs into this panic,
+ // it's most likely a bug we need to fix.
+ panic(err)
+ }
+ case "E":
+ tail := str
+ var rns []rune
+ for tail != "" {
+ var rn rune
+ rn, _, tail, _ = strconv.UnquoteChar(tail, 0)
+ rns = append(rns, rn)
+ }
+ str = string(rns)
+ case "P", "A", "a":
+ panic(fmt.Sprintf("unhandled @%s param expansion", arg))
+ default:
+ panic(fmt.Sprintf("unexpected @%s param expansion", arg))
+ }
+ }
+ }
+ return str, nil
+}
+
+func removePattern(str, pat string, fromEnd, shortest bool) string {
+ var mode pattern.Mode
+ if shortest {
+ mode |= pattern.Shortest
+ }
+ expr, err := pattern.Regexp(pat, mode)
+ if err != nil {
+ return str
+ }
+ switch {
+ case fromEnd && shortest:
+ // use .* to get the right-most shortest match
+ expr = ".*(" + expr + ")$"
+ case fromEnd:
+ // simple suffix
+ expr = "(" + expr + ")$"
+ default:
+ // simple prefix
+ expr = "^(" + expr + ")"
+ }
+ // no need to check error as Translate returns one
+ rx := regexp.MustCompile(expr)
+ if loc := rx.FindStringSubmatchIndex(str); loc != nil {
+ // remove the original pattern (the submatch)
+ str = str[:loc[2]] + str[loc[3]:]
+ }
+ return str
+}
+
+func (cfg *Config) varInd(vr Variable, idx syntax.ArithmExpr) (string, error) {
+ if idx == nil {
+ return vr.String(), nil
+ }
+ switch vr.Kind {
+ case String:
+ n, err := Arithm(cfg, idx)
+ if err != nil {
+ return "", err
+ }
+ if n == 0 {
+ return vr.Str, nil
+ }
+ case Indexed:
+ switch nodeLit(idx) {
+ case "*", "@":
+ return strings.Join(vr.List, " "), nil
+ }
+ i, err := Arithm(cfg, idx)
+ if err != nil {
+ return "", err
+ }
+ if i < 0 {
+ return "", fmt.Errorf("negative array index")
+ }
+ if i < len(vr.List) {
+ return vr.List[i], nil
+ }
+ case Associative:
+ switch lit := nodeLit(idx); lit {
+ case "@", "*":
+ strs := make([]string, 0, len(vr.Map))
+ for _, val := range vr.Map {
+ strs = append(strs, val)
+ }
+ sort.Strings(strs)
+ if lit == "*" {
+ return cfg.ifsJoin(strs), nil
+ }
+ return strings.Join(strs, " "), nil
+ }
+ val, err := Literal(cfg, idx.(*syntax.Word))
+ if err != nil {
+ return "", err
+ }
+ return vr.Map[val], nil
+ }
+ return "", nil
+}
+
+func (cfg *Config) namesByPrefix(prefix string) []string {
+ var names []string
+ cfg.Env.Each(func(name string, vr Variable) bool {
+ if strings.HasPrefix(name, prefix) {
+ names = append(names, name)
+ }
+ return true
+ })
+ return names
+}
diff --git a/vendor/mvdan.cc/sh/v3/fileutil/file.go b/vendor/mvdan.cc/sh/v3/fileutil/file.go
new file mode 100644
index 00000000..249ae94c
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/fileutil/file.go
@@ -0,0 +1,85 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+// Package fileutil allows inspecting shell files, such as detecting whether a
+// file may be shell or extracting its shebang.
+package fileutil
+
+import (
+ "io/fs"
+ "os"
+ "regexp"
+ "strings"
+)
+
+var (
+ shebangRe = regexp.MustCompile(`^#!\s?/(usr/)?bin/(env\s+)?(sh|bash|mksh|bats|zsh)(\s|$)`)
+ extRe = regexp.MustCompile(`\.(sh|bash|mksh|bats|zsh)$`)
+)
+
+// TODO: consider removing HasShebang in favor of Shebang in v4
+
+// HasShebang reports whether bs begins with a valid shell shebang.
+// It supports variations with /usr and env.
+func HasShebang(bs []byte) bool {
+ return Shebang(bs) != ""
+}
+
+// Shebang parses a "#!" sequence from the beginning of the input bytes,
+// and returns the shell that it points to.
+//
+// For instance, it returns "sh" for "#!/bin/sh",
+// and "bash" for "#!/usr/bin/env bash".
+func Shebang(bs []byte) string {
+ m := shebangRe.FindSubmatch(bs)
+ if m == nil {
+ return ""
+ }
+ return string(m[3])
+}
+
+// ScriptConfidence defines how likely a file is to be a shell script,
+// from complete certainty that it is not one to complete certainty that
+// it is one.
+type ScriptConfidence int
+
+const (
+ // ConfNotScript describes files which are definitely not shell scripts,
+ // such as non-regular files or files with a non-shell extension.
+ ConfNotScript ScriptConfidence = iota
+
+ // ConfIfShebang describes files which might be shell scripts, depending
+ // on the shebang line in the file's contents. Since CouldBeScript only
+ // works on os.FileInfo, the answer in this case can't be final.
+ ConfIfShebang
+
+ // ConfIsScript describes files which are definitely shell scripts,
+ // which are regular files with a valid shell extension.
+ ConfIsScript
+)
+
+// CouldBeScript is a shortcut for CouldBeScript2(fs.FileInfoToDirEntry(info)).
+//
+// Deprecated: prefer CouldBeScript2, which usually requires fewer syscalls.
+func CouldBeScript(info os.FileInfo) ScriptConfidence {
+ return CouldBeScript2(fs.FileInfoToDirEntry(info))
+}
+
+// CouldBeScript2 reports how likely a directory entry is to be a shell script.
+// It discards directories, symlinks, hidden files and files with non-shell
+// extensions.
+func CouldBeScript2(entry fs.DirEntry) ScriptConfidence {
+ name := entry.Name()
+ switch {
+ case entry.IsDir(), name[0] == '.':
+ return ConfNotScript
+ case entry.Type()&os.ModeSymlink != 0:
+ return ConfNotScript
+ case extRe.MatchString(name):
+ return ConfIsScript
+ case strings.IndexByte(name, '.') > 0:
+ return ConfNotScript // different extension
+ default:
+ return ConfIfShebang
+ }
+}
diff --git a/vendor/mvdan.cc/sh/v3/pattern/pattern.go b/vendor/mvdan.cc/sh/v3/pattern/pattern.go
new file mode 100644
index 00000000..7cd98d14
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/pattern/pattern.go
@@ -0,0 +1,335 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+// Package pattern allows working with shell pattern matching notation, also
+// known as wildcards or globbing.
+//
+// For reference, see
+// https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13.
+package pattern
+
+import (
+ "bytes"
+ "fmt"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+// Mode can be used to supply a number of options to the package's functions.
+// Not all functions change their behavior with all of the options below.
+type Mode uint
+
+type SyntaxError struct {
+ msg string
+ err error
+}
+
+func (e SyntaxError) Error() string { return e.msg }
+
+func (e SyntaxError) Unwrap() error { return e.err }
+
+const (
+ Shortest Mode = 1 << iota // prefer the shortest match.
+ Filenames // "*" and "?" don't match slashes; only "**" does
+ Braces // support "{a,b}" and "{1..4}"
+ EntireString // match the entire string using ^$ delimiters
+)
+
+var numRange = regexp.MustCompile(`^([+-]?\d+)\.\.([+-]?\d+)}`)
+
+// Regexp turns a shell pattern into a regular expression that can be used with
+// [regexp.Compile]. It will return an error if the input pattern was incorrect.
+// Otherwise, the returned expression can be passed to [regexp.MustCompile].
+//
+// For example, Regexp(`foo*bar?`, true) returns `foo.*bar.`.
+//
+// Note that this function (and [QuoteMeta]) should not be directly used with file
+// paths if Windows is supported, as the path separator on that platform is the
+// same character as the escaping character for shell patterns.
+func Regexp(pat string, mode Mode) (string, error) {
+ needsEscaping := false
+noopLoop:
+ for _, r := range pat {
+ switch r {
+ // including those that need escaping since they are
+ // regular expression metacharacters
+ case '*', '?', '[', '\\', '.', '+', '(', ')', '|',
+ ']', '{', '}', '^', '$':
+ needsEscaping = true
+ break noopLoop
+ }
+ }
+ if !needsEscaping && mode&EntireString == 0 { // short-cut without a string copy
+ return pat, nil
+ }
+ closingBraces := []int{}
+ var buf bytes.Buffer
+ // Enable matching `\n` with the `.` metacharacter as globs match `\n`
+ buf.WriteString("(?s)")
+ dotMeta := false
+ if mode&EntireString != 0 {
+ buf.WriteString("^")
+ }
+writeLoop:
+ for i := 0; i < len(pat); i++ {
+ switch c := pat[i]; c {
+ case '*':
+ if mode&Filenames != 0 {
+ if i++; i < len(pat) && pat[i] == '*' {
+ if i++; i < len(pat) && pat[i] == '/' {
+ buf.WriteString("(.*/|)")
+ dotMeta = true
+ } else {
+ buf.WriteString(".*")
+ dotMeta = true
+ i--
+ }
+ } else {
+ buf.WriteString("[^/]*")
+ i--
+ }
+ } else {
+ buf.WriteString(".*")
+ dotMeta = true
+ }
+ if mode&Shortest != 0 {
+ buf.WriteByte('?')
+ }
+ case '?':
+ if mode&Filenames != 0 {
+ buf.WriteString("[^/]")
+ } else {
+ buf.WriteByte('.')
+ dotMeta = true
+ }
+ case '\\':
+ if i++; i >= len(pat) {
+ return "", &SyntaxError{msg: `\ at end of pattern`}
+ }
+ buf.WriteString(regexp.QuoteMeta(string(pat[i])))
+ case '[':
+ name, err := charClass(pat[i:])
+ if err != nil {
+ return "", &SyntaxError{msg: "charClass invalid", err: err}
+ }
+ if name != "" {
+ buf.WriteString(name)
+ i += len(name) - 1
+ break
+ }
+ if mode&Filenames != 0 {
+ for _, c := range pat[i:] {
+ if c == ']' {
+ break
+ } else if c == '/' {
+ buf.WriteString("\\[")
+ continue writeLoop
+ }
+ }
+ }
+ buf.WriteByte(c)
+ if i++; i >= len(pat) {
+ return "", &SyntaxError{msg: "[ was not matched with a closing ]"}
+ }
+ switch c = pat[i]; c {
+ case '!', '^':
+ buf.WriteByte('^')
+ if i++; i >= len(pat) {
+ return "", &SyntaxError{msg: "[ was not matched with a closing ]"}
+ }
+ }
+ if c = pat[i]; c == ']' {
+ buf.WriteByte(']')
+ if i++; i >= len(pat) {
+ return "", &SyntaxError{msg: "[ was not matched with a closing ]"}
+ }
+ }
+ rangeStart := byte(0)
+ loopBracket:
+ for ; i < len(pat); i++ {
+ c = pat[i]
+ buf.WriteByte(c)
+ switch c {
+ case '\\':
+ if i++; i < len(pat) {
+ buf.WriteByte(pat[i])
+ }
+ continue
+ case ']':
+ break loopBracket
+ }
+ if rangeStart != 0 && rangeStart > c {
+ return "", &SyntaxError{msg: fmt.Sprintf("invalid range: %c-%c", rangeStart, c)}
+ }
+ if c == '-' {
+ rangeStart = pat[i-1]
+ } else {
+ rangeStart = 0
+ }
+ }
+ if i >= len(pat) {
+ return "", &SyntaxError{msg: "[ was not matched with a closing ]"}
+ }
+ case '{':
+ if mode&Braces == 0 {
+ buf.WriteString(regexp.QuoteMeta(string(c)))
+ break
+ }
+ innerLevel := 1
+ commas := false
+ peekBrace:
+ for j := i + 1; j < len(pat); j++ {
+ switch c := pat[j]; c {
+ case '{':
+ innerLevel++
+ case ',':
+ commas = true
+ case '\\':
+ j++
+ case '}':
+ if innerLevel--; innerLevel > 0 {
+ continue
+ }
+ if !commas {
+ break peekBrace
+ }
+ closingBraces = append(closingBraces, j)
+ buf.WriteString("(?:")
+ continue writeLoop
+ }
+ }
+ if match := numRange.FindStringSubmatch(pat[i+1:]); len(match) == 3 {
+ start, err1 := strconv.Atoi(match[1])
+ end, err2 := strconv.Atoi(match[2])
+ if err1 != nil || err2 != nil || start > end {
+ return "", &SyntaxError{msg: fmt.Sprintf("invalid range: %q", match[0])}
+ }
+ // TODO: can we do better here?
+ buf.WriteString("(?:")
+ for n := start; n <= end; n++ {
+ if n > start {
+ buf.WriteByte('|')
+ }
+ fmt.Fprintf(&buf, "%d", n)
+ }
+ buf.WriteByte(')')
+ i += len(match[0])
+ break
+ }
+ buf.WriteString(regexp.QuoteMeta(string(c)))
+ case ',':
+ if len(closingBraces) == 0 {
+ buf.WriteString(regexp.QuoteMeta(string(c)))
+ } else {
+ buf.WriteByte('|')
+ }
+ case '}':
+ if len(closingBraces) > 0 && closingBraces[len(closingBraces)-1] == i {
+ buf.WriteByte(')')
+ closingBraces = closingBraces[:len(closingBraces)-1]
+ } else {
+ buf.WriteString(regexp.QuoteMeta(string(c)))
+ }
+ default:
+ if c > 128 {
+ buf.WriteByte(c)
+ } else {
+ buf.WriteString(regexp.QuoteMeta(string(c)))
+ }
+ }
+ }
+ if mode&EntireString != 0 {
+ buf.WriteString("$")
+ }
+ // No `.` metacharacters were used, so don't return the flag.
+ if !dotMeta {
+ return string(buf.Bytes()[4:]), nil
+ }
+ return buf.String(), nil
+}
+
+func charClass(s string) (string, error) {
+ if strings.HasPrefix(s, "[[.") || strings.HasPrefix(s, "[[=") {
+ return "", fmt.Errorf("collating features not available")
+ }
+ if !strings.HasPrefix(s, "[[:") {
+ return "", nil
+ }
+ name := s[3:]
+ end := strings.Index(name, ":]]")
+ if end < 0 {
+ return "", fmt.Errorf("[[: was not matched with a closing :]]")
+ }
+ name = name[:end]
+ switch name {
+ case "alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
+ "lower", "print", "punct", "space", "upper", "word", "xdigit":
+ default:
+ return "", fmt.Errorf("invalid character class: %q", name)
+ }
+ return s[:len(name)+6], nil
+}
+
+// HasMeta returns whether a string contains any unescaped pattern
+// metacharacters: '*', '?', or '['. When the function returns false, the given
+// pattern can only match at most one string.
+//
+// For example, HasMeta(`foo\*bar`) returns false, but HasMeta(`foo*bar`)
+// returns true.
+//
+// This can be useful to avoid extra work, like TranslatePattern. Note that this
+// function cannot be used to avoid QuotePattern, as backslashes are quoted by
+// that function but ignored here.
+func HasMeta(pat string, mode Mode) bool {
+ for i := 0; i < len(pat); i++ {
+ switch pat[i] {
+ case '\\':
+ i++
+ case '*', '?', '[':
+ return true
+ case '{':
+ if mode&Braces != 0 {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// QuoteMeta returns a string that quotes all pattern metacharacters in the
+// given text. The returned string is a pattern that matches the literal text.
+//
+// For example, QuoteMeta(`foo*bar?`) returns `foo\*bar\?`.
+func QuoteMeta(pat string, mode Mode) string {
+ needsEscaping := false
+loop:
+ for _, r := range pat {
+ switch r {
+ case '{':
+ if mode&Braces == 0 {
+ continue
+ }
+ fallthrough
+ case '*', '?', '[', '\\':
+ needsEscaping = true
+ break loop
+ }
+ }
+ if !needsEscaping { // short-cut without a string copy
+ return pat
+ }
+ var buf bytes.Buffer
+ for _, r := range pat {
+ switch r {
+ case '*', '?', '[', '\\':
+ buf.WriteByte('\\')
+ case '{':
+ if mode&Braces != 0 {
+ buf.WriteByte('\\')
+ }
+ }
+ buf.WriteRune(r)
+ }
+ return buf.String()
+}
diff --git a/vendor/mvdan.cc/sh/v3/shell/doc.go b/vendor/mvdan.cc/sh/v3/shell/doc.go
new file mode 100644
index 00000000..81e0c2f7
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/shell/doc.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+// Package shell contains high-level features that use the syntax, expand, and
+// interp packages under the hood.
+//
+// Please note that this package uses POSIX Shell syntax. As such, path names on
+// Windows need to use double backslashes or be within single quotes when given
+// to functions like Fields. For example:
+//
+// shell.Fields("echo /foo/bar") // on Unix-like
+// shell.Fields("echo C:\\foo\\bar") // on Windows
+// shell.Fields("echo 'C:\foo\bar'") // on Windows, with quotes
+package shell
diff --git a/vendor/mvdan.cc/sh/v3/shell/expand.go b/vendor/mvdan.cc/sh/v3/shell/expand.go
new file mode 100644
index 00000000..e286c0a9
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/shell/expand.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2018, Daniel Martí
+// See LICENSE for licensing information
+
+package shell
+
+import (
+ "os"
+ "strings"
+
+ "mvdan.cc/sh/v3/expand"
+ "mvdan.cc/sh/v3/syntax"
+)
+
+// Expand performs shell expansion on s as if it were within double quotes,
+// using env to resolve variables. This includes parameter expansion, arithmetic
+// expansion, and quote removal.
+//
+// If env is nil, the current environment variables are used. Empty variables
+// are treated as unset; to support variables which are set but empty, use the
+// expand package directly.
+//
+// Command substitutions like $(echo foo) aren't supported to avoid running
+// arbitrary code. To support those, use an interpreter with the expand package.
+//
+// An error will be reported if the input string had invalid syntax.
+func Expand(s string, env func(string) string) (string, error) {
+ p := syntax.NewParser()
+ word, err := p.Document(strings.NewReader(s))
+ if err != nil {
+ return "", err
+ }
+ if env == nil {
+ env = os.Getenv
+ }
+ cfg := &expand.Config{Env: expand.FuncEnviron(env)}
+ return expand.Document(cfg, word)
+}
+
+// Fields performs shell expansion on s as if it were a command's arguments,
+// using env to resolve variables. It is similar to Expand, but includes brace
+// expansion, tilde expansion, and globbing.
+//
+// If env is nil, the current environment variables are used. Empty variables
+// are treated as unset; to support variables which are set but empty, use the
+// expand package directly.
+//
+// An error will be reported if the input string had invalid syntax.
+func Fields(s string, env func(string) string) ([]string, error) {
+ p := syntax.NewParser()
+ var words []*syntax.Word
+ err := p.Words(strings.NewReader(s), func(w *syntax.Word) bool {
+ words = append(words, w)
+ return true
+ })
+ if err != nil {
+ return nil, err
+ }
+ if env == nil {
+ env = os.Getenv
+ }
+ cfg := &expand.Config{Env: expand.FuncEnviron(env)}
+ return expand.Fields(cfg, words...)
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/braces.go b/vendor/mvdan.cc/sh/v3/syntax/braces.go
new file mode 100644
index 00000000..f3452819
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/braces.go
@@ -0,0 +1,177 @@
+// Copyright (c) 2018, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import "strconv"
+
+var (
+ litLeftBrace = &Lit{Value: "{"}
+ litComma = &Lit{Value: ","}
+ litDots = &Lit{Value: ".."}
+ litRightBrace = &Lit{Value: "}"}
+)
+
+// SplitBraces parses brace expansions within a word's literal parts. If any
+// valid brace expansions are found, they are replaced with BraceExp nodes, and
+// the function returns true. Otherwise, the word is left untouched and the
+// function returns false.
+//
+// For example, a literal word "foo{bar,baz}" will result in a word containing
+// the literal "foo", and a brace expansion with the elements "bar" and "baz".
+//
+// It does not return an error; malformed brace expansions are simply skipped.
+// For example, the literal word "a{b" is left unchanged.
+func SplitBraces(word *Word) bool {
+ toSplit := false
+ top := &Word{}
+ acc := top
+ var cur *BraceExp
+ open := []*BraceExp{}
+
+ pop := func() *BraceExp {
+ old := cur
+ open = open[:len(open)-1]
+ if len(open) == 0 {
+ cur = nil
+ acc = top
+ } else {
+ cur = open[len(open)-1]
+ acc = cur.Elems[len(cur.Elems)-1]
+ }
+ return old
+ }
+ addLit := func(lit *Lit) {
+ acc.Parts = append(acc.Parts, lit)
+ }
+
+ for _, wp := range word.Parts {
+ lit, ok := wp.(*Lit)
+ if !ok {
+ acc.Parts = append(acc.Parts, wp)
+ continue
+ }
+ last := 0
+ for j := 0; j < len(lit.Value); j++ {
+ addlitidx := func() {
+ if last == j {
+ return // empty lit
+ }
+ l2 := *lit
+ l2.Value = l2.Value[last:j]
+ addLit(&l2)
+ }
+ switch lit.Value[j] {
+ case '{':
+ addlitidx()
+ acc = &Word{}
+ cur = &BraceExp{Elems: []*Word{acc}}
+ open = append(open, cur)
+ case ',':
+ if cur == nil {
+ continue
+ }
+ addlitidx()
+ acc = &Word{}
+ cur.Elems = append(cur.Elems, acc)
+ case '.':
+ if cur == nil {
+ continue
+ }
+ if j+1 >= len(lit.Value) || lit.Value[j+1] != '.' {
+ continue
+ }
+ addlitidx()
+ cur.Sequence = true
+ acc = &Word{}
+ cur.Elems = append(cur.Elems, acc)
+ j++
+ case '}':
+ if cur == nil {
+ continue
+ }
+ toSplit = true
+ addlitidx()
+ br := pop()
+ if len(br.Elems) == 1 {
+ // return {x} to a non-brace
+ addLit(litLeftBrace)
+ acc.Parts = append(acc.Parts, br.Elems[0].Parts...)
+ addLit(litRightBrace)
+ break
+ }
+ if !br.Sequence {
+ acc.Parts = append(acc.Parts, br)
+ break
+ }
+ var chars [2]bool
+ broken := false
+ for i, elem := range br.Elems[:2] {
+ val := elem.Lit()
+ if _, err := strconv.Atoi(val); err == nil {
+ } else if len(val) == 1 &&
+ 'a' <= val[0] && val[0] <= 'z' {
+ chars[i] = true
+ } else {
+ broken = true
+ }
+ }
+ if len(br.Elems) == 3 {
+ // increment must be a number
+ val := br.Elems[2].Lit()
+ if _, err := strconv.Atoi(val); err != nil {
+ broken = true
+ }
+ }
+ // are start and end both chars or
+ // non-chars?
+ if chars[0] != chars[1] {
+ broken = true
+ }
+ if !broken {
+ acc.Parts = append(acc.Parts, br)
+ break
+ }
+ // return broken {x..y[..incr]} to a non-brace
+ addLit(litLeftBrace)
+ for i, elem := range br.Elems {
+ if i > 0 {
+ addLit(litDots)
+ }
+ acc.Parts = append(acc.Parts, elem.Parts...)
+ }
+ addLit(litRightBrace)
+ default:
+ continue
+ }
+ last = j + 1
+ }
+ if last == 0 {
+ addLit(lit)
+ } else {
+ left := *lit
+ left.Value = left.Value[last:]
+ addLit(&left)
+ }
+ }
+ if !toSplit {
+ return false
+ }
+ // open braces that were never closed fall back to non-braces
+ for acc != top {
+ br := pop()
+ addLit(litLeftBrace)
+ for i, elem := range br.Elems {
+ if i > 0 {
+ if br.Sequence {
+ addLit(litDots)
+ } else {
+ addLit(litComma)
+ }
+ }
+ acc.Parts = append(acc.Parts, elem.Parts...)
+ }
+ }
+ *word = *top
+ return true
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/canonical.sh b/vendor/mvdan.cc/sh/v3/syntax/canonical.sh
new file mode 100644
index 00000000..012f48dd
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/canonical.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# separate comment
+
+! foo bar >a &
+
+foo() { bar; }
+
+{
+ var1="some long value" # var1 comment
+ var2=short # var2 comment
+}
+
+if foo; then bar; fi
+
+for foo in a b c; do
+ bar
+done
+
+case $foo in
+a) A ;;
+b)
+ B
+ ;;
+esac
+
+foo | bar
+foo &&
+ $(bar) &&
+ (more)
+
+foo 2>&1
+foo <<-EOF
+ bar
+EOF
+
+$((3 + 4))
diff --git a/vendor/mvdan.cc/sh/v3/syntax/doc.go b/vendor/mvdan.cc/sh/v3/syntax/doc.go
new file mode 100644
index 00000000..5c6275e4
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/doc.go
@@ -0,0 +1,6 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+// Package syntax implements parsing and formatting of shell programs.
+// It supports POSIX Shell, Bash, and mksh.
+package syntax
diff --git a/vendor/mvdan.cc/sh/v3/syntax/lexer.go b/vendor/mvdan.cc/sh/v3/syntax/lexer.go
new file mode 100644
index 00000000..b5dddab7
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/lexer.go
@@ -0,0 +1,1209 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "bytes"
+ "io"
+ "unicode/utf8"
+)
+
+// bytes that form or start a token
+func regOps(r rune) bool {
+ switch r {
+ case ';', '"', '\'', '(', ')', '$', '|', '&', '>', '<', '`':
+ return true
+ }
+ return false
+}
+
+// tokenize these inside parameter expansions
+func paramOps(r rune) bool {
+ switch r {
+ case '}', '#', '!', ':', '-', '+', '=', '?', '%', '[', ']', '/', '^',
+ ',', '@', '*':
+ return true
+ }
+ return false
+}
+
+// these start a parameter expansion name
+func paramNameOp(r rune) bool {
+ switch r {
+ case '}', ':', '+', '=', '%', '[', ']', '/', '^', ',':
+ return false
+ }
+ return true
+}
+
+// tokenize these inside arithmetic expansions
+func arithmOps(r rune) bool {
+ switch r {
+ case '+', '-', '!', '~', '*', '/', '%', '(', ')', '^', '<', '>', ':', '=',
+ ',', '?', '|', '&', '[', ']', '#':
+ return true
+ }
+ return false
+}
+
+func bquoteEscaped(b byte) bool {
+ switch b {
+ case '$', '`', '\\':
+ return true
+ }
+ return false
+}
+
+const escNewl rune = utf8.RuneSelf + 1
+
+func (p *Parser) rune() rune {
+ if p.r == '\n' || p.r == escNewl {
+ // p.r instead of b so that newline
+ // character positions don't have col 0.
+ if p.line++; p.line > lineMax {
+ p.lineOverflow = true
+ }
+ p.col = 0
+ p.colOverflow = false
+ }
+ if p.col += p.w; p.col > colMax {
+ p.colOverflow = true
+ }
+ bquotes := 0
+retry:
+ if p.bsp < len(p.bs) {
+ if b := p.bs[p.bsp]; b < utf8.RuneSelf {
+ p.bsp++
+ if b == '\x00' {
+ // Ignore null bytes while parsing, like bash.
+ goto retry
+ }
+ if b == '\\' {
+ if p.r == '\\' {
+ } else if p.peekByte('\n') {
+ p.bsp++
+ p.w, p.r = 1, escNewl
+ return escNewl
+ } else if p.peekBytes("\r\n") {
+ p.bsp += 2
+ p.w, p.r = 2, escNewl
+ return escNewl
+ }
+ if p.openBquotes > 0 && bquotes < p.openBquotes &&
+ p.bsp < len(p.bs) && bquoteEscaped(p.bs[p.bsp]) {
+ bquotes++
+ goto retry
+ }
+ }
+ if b == '`' {
+ p.lastBquoteEsc = bquotes
+ }
+ if p.litBs != nil {
+ p.litBs = append(p.litBs, b)
+ }
+ p.w, p.r = 1, rune(b)
+ return p.r
+ }
+ if !utf8.FullRune(p.bs[p.bsp:]) {
+ // we need more bytes to read a full non-ascii rune
+ p.fill()
+ }
+ var w int
+ p.r, w = utf8.DecodeRune(p.bs[p.bsp:])
+ if p.litBs != nil {
+ p.litBs = append(p.litBs, p.bs[p.bsp:p.bsp+w]...)
+ }
+ p.bsp += w
+ if p.r == utf8.RuneError && w == 1 {
+ p.posErr(p.nextPos(), "invalid UTF-8 encoding")
+ }
+ p.w = w
+ } else {
+ if p.r == utf8.RuneSelf {
+ } else if p.fill(); p.bs == nil {
+ p.bsp++
+ p.r = utf8.RuneSelf
+ p.w = 1
+ } else {
+ goto retry
+ }
+ }
+ return p.r
+}
+
+// fill reads more bytes from the input src into readBuf. Any bytes that
+// had not yet been used at the end of the buffer are slid into the
+// beginning of the buffer.
+func (p *Parser) fill() {
+ p.offs += p.bsp
+ left := len(p.bs) - p.bsp
+ copy(p.readBuf[:left], p.readBuf[p.bsp:])
+readAgain:
+ n, err := 0, p.readErr
+ if err == nil {
+ n, err = p.src.Read(p.readBuf[left:])
+ p.readErr = err
+ }
+ if n == 0 {
+ if err == nil {
+ goto readAgain
+ }
+ // don't use p.errPass as we don't want to overwrite p.tok
+ if err != io.EOF {
+ p.err = err
+ }
+ if left > 0 {
+ p.bs = p.readBuf[:left]
+ } else {
+ p.bs = nil
+ }
+ } else {
+ p.bs = p.readBuf[:left+n]
+ }
+ p.bsp = 0
+}
+
+func (p *Parser) nextKeepSpaces() {
+ r := p.r
+ if p.quote != hdocBody && p.quote != hdocBodyTabs {
+ // Heredocs handle escaped newlines in a special way, but others
+ // do not.
+ for r == escNewl {
+ r = p.rune()
+ }
+ }
+ p.pos = p.nextPos()
+ switch p.quote {
+ case paramExpRepl:
+ switch r {
+ case '}', '/':
+ p.tok = p.paramToken(r)
+ case '`', '"', '$', '\'':
+ p.tok = p.regToken(r)
+ default:
+ p.advanceLitOther(r)
+ }
+ case dblQuotes:
+ switch r {
+ case '`', '"', '$':
+ p.tok = p.dqToken(r)
+ default:
+ p.advanceLitDquote(r)
+ }
+ case hdocBody, hdocBodyTabs:
+ switch r {
+ case '`', '$':
+ p.tok = p.dqToken(r)
+ default:
+ p.advanceLitHdoc(r)
+ }
+ default: // paramExpExp:
+ switch r {
+ case '}':
+ p.tok = p.paramToken(r)
+ case '`', '"', '$', '\'':
+ p.tok = p.regToken(r)
+ default:
+ p.advanceLitOther(r)
+ }
+ }
+ if p.err != nil && p.tok != _EOF {
+ p.tok = _EOF
+ }
+}
+
+func (p *Parser) next() {
+ if p.r == utf8.RuneSelf {
+ p.tok = _EOF
+ return
+ }
+ p.spaced = false
+ if p.quote&allKeepSpaces != 0 {
+ p.nextKeepSpaces()
+ return
+ }
+ r := p.r
+ for r == escNewl {
+ r = p.rune()
+ }
+skipSpace:
+ for {
+ switch r {
+ case utf8.RuneSelf:
+ p.tok = _EOF
+ return
+ case escNewl:
+ r = p.rune()
+ case ' ', '\t', '\r':
+ p.spaced = true
+ r = p.rune()
+ case '\n':
+ if p.tok == _Newl {
+ // merge consecutive newline tokens
+ r = p.rune()
+ continue
+ }
+ p.spaced = true
+ p.tok = _Newl
+ if p.quote != hdocWord && len(p.heredocs) > p.buriedHdocs {
+ p.doHeredocs()
+ }
+ return
+ default:
+ break skipSpace
+ }
+ }
+ if p.stopAt != nil && (p.spaced || p.tok == illegalTok || p.stopToken()) {
+ w := utf8.RuneLen(r)
+ if bytes.HasPrefix(p.bs[p.bsp-w:], p.stopAt) {
+ p.r = utf8.RuneSelf
+ p.w = 1
+ p.tok = _EOF
+ return
+ }
+ }
+ p.pos = p.nextPos()
+ switch {
+ case p.quote&allRegTokens != 0:
+ switch r {
+ case ';', '"', '\'', '(', ')', '$', '|', '&', '>', '<', '`':
+ p.tok = p.regToken(r)
+ case '#':
+ // If we're parsing $foo#bar, ${foo}#bar, 'foo'#bar, or "foo"#bar,
+ // #bar is a continuation of the same word, not a comment.
+ // TODO: support $(foo)#bar and `foo`#bar as well, which is slightly tricky,
+ // as we can't easily tell them apart from (foo)#bar and `#bar`,
+ // where #bar should remain a comment.
+ if !p.spaced {
+ switch p.tok {
+ case _LitWord, rightBrace, sglQuote, dblQuote:
+ p.advanceLitNone(r)
+ return
+ }
+ }
+ r = p.rune()
+ p.newLit(r)
+ runeLoop:
+ for {
+ switch r {
+ case '\n', utf8.RuneSelf:
+ break runeLoop
+ case escNewl:
+ p.litBs = append(p.litBs, '\\', '\n')
+ break runeLoop
+ case '`':
+ if p.backquoteEnd() {
+ break runeLoop
+ }
+ }
+ r = p.rune()
+ }
+ if p.keepComments {
+ *p.curComs = append(*p.curComs, Comment{
+ Hash: p.pos,
+ Text: p.endLit(),
+ })
+ } else {
+ p.litBs = nil
+ }
+ p.next()
+ case '[', '=':
+ if p.quote == arrayElems {
+ p.tok = p.paramToken(r)
+ } else {
+ p.advanceLitNone(r)
+ }
+ case '?', '*', '+', '@', '!':
+ if p.extendedGlob() {
+ switch r {
+ case '?':
+ p.tok = globQuest
+ case '*':
+ p.tok = globStar
+ case '+':
+ p.tok = globPlus
+ case '@':
+ p.tok = globAt
+ default: // '!'
+ p.tok = globExcl
+ }
+ p.rune()
+ p.rune()
+ } else {
+ p.advanceLitNone(r)
+ }
+ default:
+ p.advanceLitNone(r)
+ }
+ case p.quote&allArithmExpr != 0 && arithmOps(r):
+ p.tok = p.arithmToken(r)
+ case p.quote&allParamExp != 0 && paramOps(r):
+ p.tok = p.paramToken(r)
+ case p.quote == testExprRegexp:
+ if !p.rxFirstPart && p.spaced {
+ p.quote = noState
+ goto skipSpace
+ }
+ p.rxFirstPart = false
+ switch r {
+ case ';', '"', '\'', '$', '&', '>', '<', '`':
+ p.tok = p.regToken(r)
+ case ')':
+ if p.rxOpenParens > 0 {
+ // continuation of open paren
+ p.advanceLitRe(r)
+ } else {
+ p.tok = rightParen
+ p.quote = noState
+ p.rune() // we are tokenizing manually
+ }
+ default: // including '(', '|'
+ p.advanceLitRe(r)
+ }
+ case regOps(r):
+ p.tok = p.regToken(r)
+ default:
+ p.advanceLitOther(r)
+ }
+ if p.err != nil && p.tok != _EOF {
+ p.tok = _EOF
+ }
+}
+
+// extendedGlob determines whether we're parsing a Bash extended globbing expression.
+// For example, whether `*` or `@` are followed by `(` to form `@(foo)`.
+func (p *Parser) extendedGlob() bool {
+ if p.val == "function" {
+ return false
+ }
+ if p.peekByte('(') {
+ // NOTE: empty pattern list is a valid globbing syntax like `@()`,
+ // but we'll operate on the "likelihood" that it is a function;
+ // only tokenize if its a non-empty pattern list.
+ // We do this after peeking for just one byte, so that the input `echo *`
+ // followed by a newline does not hang an interactive shell parser until
+ // another byte is input.
+ return !p.peekBytes("()")
+ }
+ return false
+}
+
+func (p *Parser) peekBytes(s string) bool {
+ peekEnd := p.bsp + len(s)
+ // TODO: This should loop for slow readers, e.g. those providing one byte at
+ // a time. Use a loop and test it with testing/iotest.OneByteReader.
+ if peekEnd > len(p.bs) {
+ p.fill()
+ }
+ return peekEnd <= len(p.bs) && bytes.HasPrefix(p.bs[p.bsp:peekEnd], []byte(s))
+}
+
+func (p *Parser) peekByte(b byte) bool {
+ if p.bsp == len(p.bs) {
+ p.fill()
+ }
+ return p.bsp < len(p.bs) && p.bs[p.bsp] == b
+}
+
+func (p *Parser) regToken(r rune) token {
+ switch r {
+ case '\'':
+ if p.openBquotes > 0 {
+ // bury openBquotes
+ p.buriedBquotes = p.openBquotes
+ p.openBquotes = 0
+ }
+ p.rune()
+ return sglQuote
+ case '"':
+ p.rune()
+ return dblQuote
+ case '`':
+ // Don't call p.rune, as we need to work out p.openBquotes to
+ // properly handle backslashes in the lexer.
+ return bckQuote
+ case '&':
+ switch p.rune() {
+ case '&':
+ p.rune()
+ return andAnd
+ case '>':
+ if p.rune() == '>' {
+ p.rune()
+ return appAll
+ }
+ return rdrAll
+ }
+ return and
+ case '|':
+ switch p.rune() {
+ case '|':
+ p.rune()
+ return orOr
+ case '&':
+ if p.lang == LangPOSIX {
+ break
+ }
+ p.rune()
+ return orAnd
+ }
+ return or
+ case '$':
+ switch p.rune() {
+ case '\'':
+ if p.lang == LangPOSIX {
+ break
+ }
+ p.rune()
+ return dollSglQuote
+ case '"':
+ if p.lang == LangPOSIX {
+ break
+ }
+ p.rune()
+ return dollDblQuote
+ case '{':
+ p.rune()
+ return dollBrace
+ case '[':
+ if !p.lang.isBash() || p.quote == paramExpName {
+ // latter to not tokenise ${$[@]} as $[
+ break
+ }
+ p.rune()
+ return dollBrack
+ case '(':
+ if p.rune() == '(' {
+ p.rune()
+ return dollDblParen
+ }
+ return dollParen
+ }
+ return dollar
+ case '(':
+ if p.rune() == '(' && p.lang != LangPOSIX && p.quote != testExpr {
+ p.rune()
+ return dblLeftParen
+ }
+ return leftParen
+ case ')':
+ p.rune()
+ return rightParen
+ case ';':
+ switch p.rune() {
+ case ';':
+ if p.rune() == '&' && p.lang.isBash() {
+ p.rune()
+ return dblSemiAnd
+ }
+ return dblSemicolon
+ case '&':
+ if p.lang == LangPOSIX {
+ break
+ }
+ p.rune()
+ return semiAnd
+ case '|':
+ if p.lang != LangMirBSDKorn {
+ break
+ }
+ p.rune()
+ return semiOr
+ }
+ return semicolon
+ case '<':
+ switch p.rune() {
+ case '<':
+ if r = p.rune(); r == '-' {
+ p.rune()
+ return dashHdoc
+ } else if r == '<' {
+ p.rune()
+ return wordHdoc
+ }
+ return hdoc
+ case '>':
+ p.rune()
+ return rdrInOut
+ case '&':
+ p.rune()
+ return dplIn
+ case '(':
+ if !p.lang.isBash() {
+ break
+ }
+ p.rune()
+ return cmdIn
+ }
+ return rdrIn
+ default: // '>'
+ switch p.rune() {
+ case '>':
+ p.rune()
+ return appOut
+ case '&':
+ p.rune()
+ return dplOut
+ case '|':
+ p.rune()
+ return clbOut
+ case '(':
+ if !p.lang.isBash() {
+ break
+ }
+ p.rune()
+ return cmdOut
+ }
+ return rdrOut
+ }
+}
+
+func (p *Parser) dqToken(r rune) token {
+ switch r {
+ case '"':
+ p.rune()
+ return dblQuote
+ case '`':
+ // Don't call p.rune, as we need to work out p.openBquotes to
+ // properly handle backslashes in the lexer.
+ return bckQuote
+ default: // '$'
+ switch p.rune() {
+ case '{':
+ p.rune()
+ return dollBrace
+ case '[':
+ if !p.lang.isBash() {
+ break
+ }
+ p.rune()
+ return dollBrack
+ case '(':
+ if p.rune() == '(' {
+ p.rune()
+ return dollDblParen
+ }
+ return dollParen
+ }
+ return dollar
+ }
+}
+
+func (p *Parser) paramToken(r rune) token {
+ switch r {
+ case '}':
+ p.rune()
+ return rightBrace
+ case ':':
+ switch p.rune() {
+ case '+':
+ p.rune()
+ return colPlus
+ case '-':
+ p.rune()
+ return colMinus
+ case '?':
+ p.rune()
+ return colQuest
+ case '=':
+ p.rune()
+ return colAssgn
+ }
+ return colon
+ case '+':
+ p.rune()
+ return plus
+ case '-':
+ p.rune()
+ return minus
+ case '?':
+ p.rune()
+ return quest
+ case '=':
+ p.rune()
+ return assgn
+ case '%':
+ if p.rune() == '%' {
+ p.rune()
+ return dblPerc
+ }
+ return perc
+ case '#':
+ if p.rune() == '#' {
+ p.rune()
+ return dblHash
+ }
+ return hash
+ case '!':
+ p.rune()
+ return exclMark
+ case '[':
+ p.rune()
+ return leftBrack
+ case ']':
+ p.rune()
+ return rightBrack
+ case '/':
+ if p.rune() == '/' && p.quote != paramExpRepl {
+ p.rune()
+ return dblSlash
+ }
+ return slash
+ case '^':
+ if p.rune() == '^' {
+ p.rune()
+ return dblCaret
+ }
+ return caret
+ case ',':
+ if p.rune() == ',' {
+ p.rune()
+ return dblComma
+ }
+ return comma
+ case '@':
+ p.rune()
+ return at
+ default: // '*'
+ p.rune()
+ return star
+ }
+}
+
+func (p *Parser) arithmToken(r rune) token {
+ switch r {
+ case '!':
+ if p.rune() == '=' {
+ p.rune()
+ return nequal
+ }
+ return exclMark
+ case '=':
+ if p.rune() == '=' {
+ p.rune()
+ return equal
+ }
+ return assgn
+ case '~':
+ p.rune()
+ return tilde
+ case '(':
+ p.rune()
+ return leftParen
+ case ')':
+ p.rune()
+ return rightParen
+ case '&':
+ switch p.rune() {
+ case '&':
+ p.rune()
+ return andAnd
+ case '=':
+ p.rune()
+ return andAssgn
+ }
+ return and
+ case '|':
+ switch p.rune() {
+ case '|':
+ p.rune()
+ return orOr
+ case '=':
+ p.rune()
+ return orAssgn
+ }
+ return or
+ case '<':
+ switch p.rune() {
+ case '<':
+ if p.rune() == '=' {
+ p.rune()
+ return shlAssgn
+ }
+ return hdoc
+ case '=':
+ p.rune()
+ return lequal
+ }
+ return rdrIn
+ case '>':
+ switch p.rune() {
+ case '>':
+ if p.rune() == '=' {
+ p.rune()
+ return shrAssgn
+ }
+ return appOut
+ case '=':
+ p.rune()
+ return gequal
+ }
+ return rdrOut
+ case '+':
+ switch p.rune() {
+ case '+':
+ p.rune()
+ return addAdd
+ case '=':
+ p.rune()
+ return addAssgn
+ }
+ return plus
+ case '-':
+ switch p.rune() {
+ case '-':
+ p.rune()
+ return subSub
+ case '=':
+ p.rune()
+ return subAssgn
+ }
+ return minus
+ case '%':
+ if p.rune() == '=' {
+ p.rune()
+ return remAssgn
+ }
+ return perc
+ case '*':
+ switch p.rune() {
+ case '*':
+ p.rune()
+ return power
+ case '=':
+ p.rune()
+ return mulAssgn
+ }
+ return star
+ case '/':
+ if p.rune() == '=' {
+ p.rune()
+ return quoAssgn
+ }
+ return slash
+ case '^':
+ if p.rune() == '=' {
+ p.rune()
+ return xorAssgn
+ }
+ return caret
+ case '[':
+ p.rune()
+ return leftBrack
+ case ']':
+ p.rune()
+ return rightBrack
+ case ',':
+ p.rune()
+ return comma
+ case '?':
+ p.rune()
+ return quest
+ case ':':
+ p.rune()
+ return colon
+ default: // '#'
+ p.rune()
+ return hash
+ }
+}
+
+func (p *Parser) newLit(r rune) {
+ switch {
+ case r < utf8.RuneSelf:
+ p.litBs = p.litBuf[:1]
+ p.litBs[0] = byte(r)
+ case r > escNewl:
+ w := utf8.RuneLen(r)
+ p.litBs = append(p.litBuf[:0], p.bs[p.bsp-w:p.bsp]...)
+ default:
+ // don't let r == utf8.RuneSelf go to the second case as RuneLen
+ // would return -1
+ p.litBs = p.litBuf[:0]
+ }
+}
+
+func (p *Parser) endLit() (s string) {
+ if p.r == utf8.RuneSelf || p.r == escNewl {
+ s = string(p.litBs)
+ } else {
+ s = string(p.litBs[:len(p.litBs)-p.w])
+ }
+ p.litBs = nil
+ return
+}
+
+func (p *Parser) isLitRedir() bool {
+ lit := p.litBs[:len(p.litBs)-1]
+ if lit[0] == '{' && lit[len(lit)-1] == '}' {
+ return ValidName(string(lit[1 : len(lit)-1]))
+ }
+ for _, b := range lit {
+ switch b {
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ default:
+ return false
+ }
+ }
+ return true
+}
+
+func (p *Parser) advanceNameCont(r rune) {
+ // we know that r is a letter or underscore
+loop:
+ for p.newLit(r); r != utf8.RuneSelf; r = p.rune() {
+ switch {
+ case 'a' <= r && r <= 'z':
+ case 'A' <= r && r <= 'Z':
+ case r == '_':
+ case '0' <= r && r <= '9':
+ case r == escNewl:
+ default:
+ break loop
+ }
+ }
+ p.tok, p.val = _LitWord, p.endLit()
+}
+
+func (p *Parser) advanceLitOther(r rune) {
+ tok := _LitWord
+loop:
+ for p.newLit(r); r != utf8.RuneSelf; r = p.rune() {
+ switch r {
+ case '\\': // escaped byte follows
+ p.rune()
+ case '\'', '"', '`', '$':
+ tok = _Lit
+ break loop
+ case '}':
+ if p.quote&allParamExp != 0 {
+ break loop
+ }
+ case '/':
+ if p.quote != paramExpExp {
+ break loop
+ }
+ case ':', '=', '%', '^', ',', '?', '!', '~', '*':
+ if p.quote&allArithmExpr != 0 || p.quote == paramExpName {
+ break loop
+ }
+ case '[', ']':
+ if p.lang != LangPOSIX && p.quote&allArithmExpr != 0 {
+ break loop
+ }
+ fallthrough
+ case '#', '@':
+ if p.quote&allParamReg != 0 {
+ break loop
+ }
+ case '+', '-', ' ', '\t', ';', '&', '>', '<', '|', '(', ')', '\n', '\r':
+ if p.quote&allKeepSpaces == 0 {
+ break loop
+ }
+ }
+ }
+ p.tok, p.val = tok, p.endLit()
+}
+
+func (p *Parser) advanceLitNone(r rune) {
+ p.eqlOffs = -1
+ tok := _LitWord
+loop:
+ for p.newLit(r); r != utf8.RuneSelf; r = p.rune() {
+ switch r {
+ case ' ', '\t', '\n', '\r', '&', '|', ';', '(', ')':
+ break loop
+ case '\\': // escaped byte follows
+ p.rune()
+ case '>', '<':
+ if p.peekByte('(') {
+ tok = _Lit
+ } else if p.isLitRedir() {
+ tok = _LitRedir
+ }
+ break loop
+ case '`':
+ if p.quote != subCmdBckquo {
+ tok = _Lit
+ }
+ break loop
+ case '"', '\'', '$':
+ tok = _Lit
+ break loop
+ case '?', '*', '+', '@', '!':
+ if p.extendedGlob() {
+ tok = _Lit
+ break loop
+ }
+ case '=':
+ if p.eqlOffs < 0 {
+ p.eqlOffs = len(p.litBs) - 1
+ }
+ case '[':
+ if p.lang != LangPOSIX && len(p.litBs) > 1 && p.litBs[0] != '[' {
+ tok = _Lit
+ break loop
+ }
+ }
+ }
+ p.tok, p.val = tok, p.endLit()
+}
+
+func (p *Parser) advanceLitDquote(r rune) {
+ tok := _LitWord
+loop:
+ for p.newLit(r); r != utf8.RuneSelf; r = p.rune() {
+ switch r {
+ case '"':
+ break loop
+ case '\\': // escaped byte follows
+ p.rune()
+ case escNewl, '`', '$':
+ tok = _Lit
+ break loop
+ }
+ }
+ p.tok, p.val = tok, p.endLit()
+}
+
+func (p *Parser) advanceLitHdoc(r rune) {
+ // Unlike the rest of nextKeepSpaces quote states, we handle escaped
+ // newlines here. If lastTok==_Lit, then we know we're following an
+ // escaped newline, so the first line can't end the heredoc.
+ lastTok := p.tok
+ for r == escNewl {
+ r = p.rune()
+ lastTok = _Lit
+ }
+ p.pos = p.nextPos()
+
+ p.tok = _Lit
+ p.newLit(r)
+ if p.quote == hdocBodyTabs {
+ for r == '\t' {
+ r = p.rune()
+ }
+ }
+ lStart := len(p.litBs) - 1
+ stop := p.hdocStops[len(p.hdocStops)-1]
+ for ; ; r = p.rune() {
+ switch r {
+ case escNewl, '$':
+ p.val = p.endLit()
+ return
+ case '\\': // escaped byte follows
+ p.rune()
+ case '`':
+ if !p.backquoteEnd() {
+ p.val = p.endLit()
+ return
+ }
+ fallthrough
+ case '\n', utf8.RuneSelf:
+ if p.parsingDoc {
+ if r == utf8.RuneSelf {
+ p.tok = _LitWord
+ p.val = p.endLit()
+ return
+ }
+ } else if lStart == 0 && lastTok == _Lit {
+ // This line starts right after an escaped
+ // newline, so it should never end the heredoc.
+ } else if lStart >= 0 {
+ // Compare the current line with the stop word.
+ line := p.litBs[lStart:]
+ if r != utf8.RuneSelf && len(line) > 0 {
+ line = line[:len(line)-1] // minus trailing character
+ }
+ if bytes.Equal(line, stop) {
+ p.tok = _LitWord
+ p.val = p.endLit()[:lStart]
+ if p.val == "" {
+ p.tok = _Newl
+ }
+ p.hdocStops[len(p.hdocStops)-1] = nil
+ return
+ }
+ }
+ if r != '\n' {
+ return // hit an unexpected EOF or closing backquote
+ }
+ if p.quote == hdocBodyTabs {
+ for p.peekByte('\t') {
+ p.rune()
+ }
+ }
+ lStart = len(p.litBs)
+ }
+ }
+}
+
+func (p *Parser) quotedHdocWord() *Word {
+ r := p.r
+ p.newLit(r)
+ pos := p.nextPos()
+ stop := p.hdocStops[len(p.hdocStops)-1]
+ for ; ; r = p.rune() {
+ if r == utf8.RuneSelf {
+ return nil
+ }
+ if p.quote == hdocBodyTabs {
+ for r == '\t' {
+ r = p.rune()
+ }
+ }
+ lStart := len(p.litBs) - 1
+ runeLoop:
+ for {
+ switch r {
+ case utf8.RuneSelf, '\n':
+ break runeLoop
+ case '`':
+ if p.backquoteEnd() {
+ break runeLoop
+ }
+ case escNewl:
+ p.litBs = append(p.litBs, '\\', '\n')
+ break runeLoop
+ }
+ r = p.rune()
+ }
+ if lStart < 0 {
+ continue
+ }
+ // Compare the current line with the stop word.
+ line := p.litBs[lStart:]
+ if r != utf8.RuneSelf && len(line) > 0 {
+ line = line[:len(line)-1] // minus \n
+ }
+ if bytes.Equal(line, stop) {
+ p.hdocStops[len(p.hdocStops)-1] = nil
+ val := p.endLit()[:lStart]
+ if val == "" {
+ return nil
+ }
+ return p.wordOne(p.lit(pos, val))
+ }
+ }
+}
+
+func (p *Parser) advanceLitRe(r rune) {
+ for p.newLit(r); ; r = p.rune() {
+ switch r {
+ case '\\':
+ p.rune()
+ case '(':
+ p.rxOpenParens++
+ case ')':
+ if p.rxOpenParens--; p.rxOpenParens < 0 {
+ p.tok, p.val = _LitWord, p.endLit()
+ p.quote = noState
+ return
+ }
+ case ' ', '\t', '\r', '\n', ';', '&', '>', '<':
+ if p.rxOpenParens <= 0 {
+ p.tok, p.val = _LitWord, p.endLit()
+ p.quote = noState
+ return
+ }
+ case '"', '\'', '$', '`':
+ p.tok, p.val = _Lit, p.endLit()
+ return
+ case utf8.RuneSelf:
+ p.tok, p.val = _LitWord, p.endLit()
+ p.quote = noState
+ return
+ }
+ }
+}
+
+func testUnaryOp(val string) UnTestOperator {
+ switch val {
+ case "!":
+ return TsNot
+ case "-e", "-a":
+ return TsExists
+ case "-f":
+ return TsRegFile
+ case "-d":
+ return TsDirect
+ case "-c":
+ return TsCharSp
+ case "-b":
+ return TsBlckSp
+ case "-p":
+ return TsNmPipe
+ case "-S":
+ return TsSocket
+ case "-L", "-h":
+ return TsSmbLink
+ case "-k":
+ return TsSticky
+ case "-g":
+ return TsGIDSet
+ case "-u":
+ return TsUIDSet
+ case "-G":
+ return TsGrpOwn
+ case "-O":
+ return TsUsrOwn
+ case "-N":
+ return TsModif
+ case "-r":
+ return TsRead
+ case "-w":
+ return TsWrite
+ case "-x":
+ return TsExec
+ case "-s":
+ return TsNoEmpty
+ case "-t":
+ return TsFdTerm
+ case "-z":
+ return TsEmpStr
+ case "-n":
+ return TsNempStr
+ case "-o":
+ return TsOptSet
+ case "-v":
+ return TsVarSet
+ case "-R":
+ return TsRefVar
+ default:
+ return 0
+ }
+}
+
+func testBinaryOp(val string) BinTestOperator {
+ switch val {
+ case "=":
+ return TsMatchShort
+ case "==":
+ return TsMatch
+ case "!=":
+ return TsNoMatch
+ case "=~":
+ return TsReMatch
+ case "-nt":
+ return TsNewer
+ case "-ot":
+ return TsOlder
+ case "-ef":
+ return TsDevIno
+ case "-eq":
+ return TsEql
+ case "-ne":
+ return TsNeq
+ case "-le":
+ return TsLeq
+ case "-ge":
+ return TsGeq
+ case "-lt":
+ return TsLss
+ case "-gt":
+ return TsGtr
+ default:
+ return 0
+ }
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/nodes.go b/vendor/mvdan.cc/sh/v3/syntax/nodes.go
new file mode 100644
index 00000000..88eb7fea
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/nodes.go
@@ -0,0 +1,953 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "strconv"
+ "strings"
+)
+
+// Node represents a syntax tree node.
+type Node interface {
+ // Pos returns the position of the first character of the node. Comments
+ // are ignored, except if the node is a *File.
+ Pos() Pos
+ // End returns the position of the character immediately after the node.
+ // If the character is a newline, the line number won't cross into the
+ // next line. Comments are ignored, except if the node is a *File.
+ End() Pos
+}
+
+// File represents a shell source file.
+type File struct {
+ Name string
+
+ Stmts []*Stmt
+ Last []Comment
+}
+
+func (f *File) Pos() Pos { return stmtsPos(f.Stmts, f.Last) }
+func (f *File) End() Pos { return stmtsEnd(f.Stmts, f.Last) }
+
+func stmtsPos(stmts []*Stmt, last []Comment) Pos {
+ if len(stmts) > 0 {
+ s := stmts[0]
+ sPos := s.Pos()
+ if len(s.Comments) > 0 {
+ if cPos := s.Comments[0].Pos(); sPos.After(cPos) {
+ return cPos
+ }
+ }
+ return sPos
+ }
+ if len(last) > 0 {
+ return last[0].Pos()
+ }
+ return Pos{}
+}
+
+func stmtsEnd(stmts []*Stmt, last []Comment) Pos {
+ if len(last) > 0 {
+ return last[len(last)-1].End()
+ }
+ if len(stmts) > 0 {
+ s := stmts[len(stmts)-1]
+ sEnd := s.End()
+ if len(s.Comments) > 0 {
+ if cEnd := s.Comments[0].End(); cEnd.After(sEnd) {
+ return cEnd
+ }
+ }
+ return sEnd
+ }
+ return Pos{}
+}
+
+// Pos is a position within a shell source file.
+type Pos struct {
+ offs, lineCol uint32
+}
+
+// We used to split line and column numbers evenly in 16 bits, but line numbers
+// are significantly more important in practice. Use more bits for them.
+const (
+ lineBitSize = 18
+ lineMax = (1 << lineBitSize) - 1
+
+ colBitSize = 32 - lineBitSize
+ colMax = (1 << colBitSize) - 1
+ colBitMask = colMax
+)
+
+// TODO(v4): consider using uint32 for Offset/Line/Col to better represent bit sizes.
+// Or go with int64, which more closely resembles portable "sizes" elsewhere.
+// The latter is probably nicest, as then we can change the number of internal
+// bits later, and we can also do overflow checks for the user in NewPos.
+
+// NewPos creates a position with the given offset, line, and column.
+//
+// Note that Pos uses a limited number of bits to store these numbers.
+// If line or column overflow their allocated space, they are replaced with 0.
+func NewPos(offset, line, column uint) Pos {
+ if line > lineMax {
+ line = 0 // protect against overflows; rendered as "?"
+ }
+ if column > colMax {
+ column = 0 // protect against overflows; rendered as "?"
+ }
+ return Pos{
+ offs: uint32(offset),
+ lineCol: (uint32(line) << colBitSize) | uint32(column),
+ }
+}
+
+// Offset returns the byte offset of the position in the original source file.
+// Byte offsets start at 0.
+//
+// Note that Offset is not protected against overflows;
+// if an input is larger than 4GiB, the offset will wrap around to 0.
+func (p Pos) Offset() uint { return uint(p.offs) }
+
+// Line returns the line number of the position, starting at 1.
+//
+// Line is protected against overflows; if an input has too many lines, extra
+// lines will have a line number of 0, rendered as "?" by [Pos.String].
+func (p Pos) Line() uint { return uint(p.lineCol >> colBitSize) }
+
+// Col returns the column number of the position, starting at 1. It counts in
+// bytes.
+//
+// Col is protected against overflows; if an input line has too many columns,
+// extra columns will have a column number of 0, rendered as "?" by [Pos.String].
+func (p Pos) Col() uint { return uint(p.lineCol & colBitMask) }
+
+func (p Pos) String() string {
+ var b strings.Builder
+ if line := p.Line(); line > 0 {
+ b.WriteString(strconv.FormatUint(uint64(line), 10))
+ } else {
+ b.WriteByte('?')
+ }
+ b.WriteByte(':')
+ if col := p.Col(); col > 0 {
+ b.WriteString(strconv.FormatUint(uint64(col), 10))
+ } else {
+ b.WriteByte('?')
+ }
+ return b.String()
+}
+
+// IsValid reports whether the position contains useful position information.
+// Some positions returned via [Parse] may be invalid: for example, [Stmt.Semicolon]
+// will only be valid if a statement contained a closing token such as ';'.
+func (p Pos) IsValid() bool { return p != Pos{} }
+
+// After reports whether the position p is after p2. It is a more expressive
+// version of p.Offset() > p2.Offset().
+func (p Pos) After(p2 Pos) bool { return p.offs > p2.offs }
+
+func posAddCol(p Pos, n int) Pos {
+ // TODO: guard against overflows
+ p.lineCol += uint32(n)
+ p.offs += uint32(n)
+ return p
+}
+
+func posMax(p1, p2 Pos) Pos {
+ if p2.After(p1) {
+ return p2
+ }
+ return p1
+}
+
+// Comment represents a single comment on a single line.
+type Comment struct {
+ Hash Pos
+ Text string
+}
+
+func (c *Comment) Pos() Pos { return c.Hash }
+func (c *Comment) End() Pos { return posAddCol(c.Hash, 1+len(c.Text)) }
+
+// Stmt represents a statement, also known as a "complete command". It is
+// compromised of a command and other components that may come before or after
+// it.
+type Stmt struct {
+ Comments []Comment
+ Cmd Command
+ Position Pos
+ Semicolon Pos // position of ';', '&', or '|&', if any
+ Negated bool // ! stmt
+ Background bool // stmt &
+ Coprocess bool // mksh's |&
+
+ Redirs []*Redirect // stmt >a 0 {
+ end = posMax(end, s.Redirs[len(s.Redirs)-1].End())
+ }
+ return end
+}
+
+// Command represents all nodes that are simple or compound commands, including
+// function declarations.
+//
+// These are *CallExpr, *IfClause, *WhileClause, *ForClause, *CaseClause,
+// *Block, *Subshell, *BinaryCmd, *FuncDecl, *ArithmCmd, *TestClause,
+// *DeclClause, *LetClause, *TimeClause, and *CoprocClause.
+type Command interface {
+ Node
+ commandNode()
+}
+
+func (*CallExpr) commandNode() {}
+func (*IfClause) commandNode() {}
+func (*WhileClause) commandNode() {}
+func (*ForClause) commandNode() {}
+func (*CaseClause) commandNode() {}
+func (*Block) commandNode() {}
+func (*Subshell) commandNode() {}
+func (*BinaryCmd) commandNode() {}
+func (*FuncDecl) commandNode() {}
+func (*ArithmCmd) commandNode() {}
+func (*TestClause) commandNode() {}
+func (*DeclClause) commandNode() {}
+func (*LetClause) commandNode() {}
+func (*TimeClause) commandNode() {}
+func (*CoprocClause) commandNode() {}
+func (*TestDecl) commandNode() {}
+
+// Assign represents an assignment to a variable.
+//
+// Here and elsewhere, Index can mean either an index expression into an indexed
+// array, or a string key into an associative array.
+//
+// If Index is non-nil, the value will be a word and not an array as nested
+// arrays are not allowed.
+//
+// If Naked is true and Name is nil, the assignment is part of a DeclClause and
+// the argument (in the Value field) will be evaluated at run-time. This
+// includes parameter expansions, which may expand to assignments or options.
+type Assign struct {
+ Append bool // +=
+ Naked bool // without '='
+ Name *Lit // must be a valid name
+ Index ArithmExpr // [i], ["k"]
+ Value *Word // =val
+ Array *ArrayExpr // =(arr)
+}
+
+func (a *Assign) Pos() Pos {
+ if a.Name == nil {
+ return a.Value.Pos()
+ }
+ return a.Name.Pos()
+}
+
+func (a *Assign) End() Pos {
+ if a.Value != nil {
+ return a.Value.End()
+ }
+ if a.Array != nil {
+ return a.Array.End()
+ }
+ if a.Index != nil {
+ return posAddCol(a.Index.End(), 2)
+ }
+ if a.Naked {
+ return a.Name.End()
+ }
+ return posAddCol(a.Name.End(), 1)
+}
+
+// Redirect represents an input/output redirection.
+type Redirect struct {
+ OpPos Pos
+ Op RedirOperator
+ N *Lit // fd>, or {varname}> in Bash
+ Word *Word // >word
+ Hdoc *Word // here-document body
+}
+
+func (r *Redirect) Pos() Pos {
+ if r.N != nil {
+ return r.N.Pos()
+ }
+ return r.OpPos
+}
+
+func (r *Redirect) End() Pos {
+ if r.Hdoc != nil {
+ return r.Hdoc.End()
+ }
+ return r.Word.End()
+}
+
+// CallExpr represents a command execution or function call, otherwise known as
+// a "simple command".
+//
+// If Args is empty, Assigns apply to the shell environment. Otherwise, they are
+// variables that cannot be arrays and which only apply to the call.
+type CallExpr struct {
+ Assigns []*Assign // a=x b=y args
+ Args []*Word
+}
+
+func (c *CallExpr) Pos() Pos {
+ if len(c.Assigns) > 0 {
+ return c.Assigns[0].Pos()
+ }
+ return c.Args[0].Pos()
+}
+
+func (c *CallExpr) End() Pos {
+ if len(c.Args) == 0 {
+ return c.Assigns[len(c.Assigns)-1].End()
+ }
+ return c.Args[len(c.Args)-1].End()
+}
+
+// Subshell represents a series of commands that should be executed in a nested
+// shell environment.
+type Subshell struct {
+ Lparen, Rparen Pos
+
+ Stmts []*Stmt
+ Last []Comment
+}
+
+func (s *Subshell) Pos() Pos { return s.Lparen }
+func (s *Subshell) End() Pos { return posAddCol(s.Rparen, 1) }
+
+// Block represents a series of commands that should be executed in a nested
+// scope. It is essentially a list of statements within curly braces.
+type Block struct {
+ Lbrace, Rbrace Pos
+
+ Stmts []*Stmt
+ Last []Comment
+}
+
+func (b *Block) Pos() Pos { return b.Lbrace }
+func (b *Block) End() Pos { return posAddCol(b.Rbrace, 1) }
+
+// IfClause represents an if statement.
+type IfClause struct {
+ Position Pos // position of the starting "if", "elif", or "else" token
+ ThenPos Pos // position of "then", empty if this is an "else"
+ FiPos Pos // position of "fi", shared with .Else if non-nil
+
+ Cond []*Stmt
+ CondLast []Comment
+ Then []*Stmt
+ ThenLast []Comment
+
+ Else *IfClause // if non-nil, an "elif" or an "else"
+
+ Last []Comment // comments on the first "elif", "else", or "fi"
+}
+
+func (c *IfClause) Pos() Pos { return c.Position }
+func (c *IfClause) End() Pos { return posAddCol(c.FiPos, 2) }
+
+// WhileClause represents a while or an until clause.
+type WhileClause struct {
+ WhilePos, DoPos, DonePos Pos
+ Until bool
+
+ Cond []*Stmt
+ CondLast []Comment
+ Do []*Stmt
+ DoLast []Comment
+}
+
+func (w *WhileClause) Pos() Pos { return w.WhilePos }
+func (w *WhileClause) End() Pos { return posAddCol(w.DonePos, 4) }
+
+// ForClause represents a for or a select clause. The latter is only present in
+// Bash.
+type ForClause struct {
+ ForPos, DoPos, DonePos Pos
+ Select bool
+ Braces bool // deprecated form with { } instead of do/done
+ Loop Loop
+
+ Do []*Stmt
+ DoLast []Comment
+}
+
+func (f *ForClause) Pos() Pos { return f.ForPos }
+func (f *ForClause) End() Pos { return posAddCol(f.DonePos, 4) }
+
+// Loop holds either *WordIter or *CStyleLoop.
+type Loop interface {
+ Node
+ loopNode()
+}
+
+func (*WordIter) loopNode() {}
+func (*CStyleLoop) loopNode() {}
+
+// WordIter represents the iteration of a variable over a series of words in a
+// for clause. If InPos is an invalid position, the "in" token was missing, so
+// the iteration is over the shell's positional parameters.
+type WordIter struct {
+ Name *Lit
+ InPos Pos // position of "in"
+ Items []*Word
+}
+
+func (w *WordIter) Pos() Pos { return w.Name.Pos() }
+func (w *WordIter) End() Pos {
+ if len(w.Items) > 0 {
+ return wordLastEnd(w.Items)
+ }
+ return posMax(w.Name.End(), posAddCol(w.InPos, 2))
+}
+
+// CStyleLoop represents the behavior of a for clause similar to the C
+// language.
+//
+// This node will only appear with LangBash.
+type CStyleLoop struct {
+ Lparen, Rparen Pos
+ // Init, Cond, Post can each be nil, if the for loop construct omits it.
+ Init, Cond, Post ArithmExpr
+}
+
+func (c *CStyleLoop) Pos() Pos { return c.Lparen }
+func (c *CStyleLoop) End() Pos { return posAddCol(c.Rparen, 2) }
+
+// BinaryCmd represents a binary expression between two statements.
+type BinaryCmd struct {
+ OpPos Pos
+ Op BinCmdOperator
+ X, Y *Stmt
+}
+
+func (b *BinaryCmd) Pos() Pos { return b.X.Pos() }
+func (b *BinaryCmd) End() Pos { return b.Y.End() }
+
+// FuncDecl represents the declaration of a function.
+type FuncDecl struct {
+ Position Pos
+ RsrvWord bool // non-posix "function f" style
+ Parens bool // with () parentheses, only meaningful with RsrvWord=true
+ Name *Lit
+ Body *Stmt
+}
+
+func (f *FuncDecl) Pos() Pos { return f.Position }
+func (f *FuncDecl) End() Pos { return f.Body.End() }
+
+// Word represents a shell word, containing one or more word parts contiguous to
+// each other. The word is delimited by word boundaries, such as spaces,
+// newlines, semicolons, or parentheses.
+type Word struct {
+ Parts []WordPart
+}
+
+func (w *Word) Pos() Pos { return w.Parts[0].Pos() }
+func (w *Word) End() Pos { return w.Parts[len(w.Parts)-1].End() }
+
+// Lit returns the word as a literal value, if the word consists of *Lit nodes
+// only. An empty string is returned otherwise. Words with multiple literals,
+// which can appear in some edge cases, are handled properly.
+//
+// For example, the word "foo" will return "foo", but the word "foo${bar}" will
+// return "".
+func (w *Word) Lit() string {
+ // In the usual case, we'll have either a single part that's a literal,
+ // or one of the parts being a non-literal. Using strings.Join instead
+ // of a strings.Builder avoids extra work in these cases, since a single
+ // part is a shortcut, and many parts don't incur string copies.
+ lits := make([]string, 0, 1)
+ for _, part := range w.Parts {
+ lit, ok := part.(*Lit)
+ if !ok {
+ return ""
+ }
+ lits = append(lits, lit.Value)
+ }
+ return strings.Join(lits, "")
+}
+
+// WordPart represents all nodes that can form part of a word.
+//
+// These are *Lit, *SglQuoted, *DblQuoted, *ParamExp, *CmdSubst, *ArithmExp,
+// *ProcSubst, and *ExtGlob.
+type WordPart interface {
+ Node
+ wordPartNode()
+}
+
+func (*Lit) wordPartNode() {}
+func (*SglQuoted) wordPartNode() {}
+func (*DblQuoted) wordPartNode() {}
+func (*ParamExp) wordPartNode() {}
+func (*CmdSubst) wordPartNode() {}
+func (*ArithmExp) wordPartNode() {}
+func (*ProcSubst) wordPartNode() {}
+func (*ExtGlob) wordPartNode() {}
+func (*BraceExp) wordPartNode() {}
+
+// Lit represents a string literal.
+//
+// Note that a parsed string literal may not appear as-is in the original source
+// code, as it is possible to split literals by escaping newlines. The splitting
+// is lost, but the end position is not.
+type Lit struct {
+ ValuePos, ValueEnd Pos
+ Value string
+}
+
+func (l *Lit) Pos() Pos { return l.ValuePos }
+func (l *Lit) End() Pos { return l.ValueEnd }
+
+// SglQuoted represents a string within single quotes.
+type SglQuoted struct {
+ Left, Right Pos
+ Dollar bool // $''
+ Value string
+}
+
+func (q *SglQuoted) Pos() Pos { return q.Left }
+func (q *SglQuoted) End() Pos { return posAddCol(q.Right, 1) }
+
+// DblQuoted represents a list of nodes within double quotes.
+type DblQuoted struct {
+ Left, Right Pos
+ Dollar bool // $""
+ Parts []WordPart
+}
+
+func (q *DblQuoted) Pos() Pos { return q.Left }
+func (q *DblQuoted) End() Pos { return posAddCol(q.Right, 1) }
+
+// CmdSubst represents a command substitution.
+type CmdSubst struct {
+ Left, Right Pos
+
+ Stmts []*Stmt
+ Last []Comment
+
+ Backquotes bool // deprecated `foo`
+ TempFile bool // mksh's ${ foo;}
+ ReplyVar bool // mksh's ${|foo;}
+}
+
+func (c *CmdSubst) Pos() Pos { return c.Left }
+func (c *CmdSubst) End() Pos { return posAddCol(c.Right, 1) }
+
+// ParamExp represents a parameter expansion.
+type ParamExp struct {
+ Dollar, Rbrace Pos
+
+ Short bool // $a instead of ${a}
+ Excl bool // ${!a}
+ Length bool // ${#a}
+ Width bool // ${%a}
+ Param *Lit
+ Index ArithmExpr // ${a[i]}, ${a["k"]}
+ Slice *Slice // ${a:x:y}
+ Repl *Replace // ${a/x/y}
+ Names ParNamesOperator // ${!prefix*} or ${!prefix@}
+ Exp *Expansion // ${a:-b}, ${a#b}, etc
+}
+
+func (p *ParamExp) Pos() Pos { return p.Dollar }
+func (p *ParamExp) End() Pos {
+ if !p.Short {
+ return posAddCol(p.Rbrace, 1)
+ }
+ if p.Index != nil {
+ return posAddCol(p.Index.End(), 1)
+ }
+ return p.Param.End()
+}
+
+func (p *ParamExp) nakedIndex() bool {
+ return p.Short && p.Index != nil
+}
+
+// Slice represents a character slicing expression inside a ParamExp.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type Slice struct {
+ Offset, Length ArithmExpr
+}
+
+// Replace represents a search and replace expression inside a ParamExp.
+type Replace struct {
+ All bool
+ Orig, With *Word
+}
+
+// Expansion represents string manipulation in a ParamExp other than those
+// covered by Replace.
+type Expansion struct {
+ Op ParExpOperator
+ Word *Word
+}
+
+// ArithmExp represents an arithmetic expansion.
+type ArithmExp struct {
+ Left, Right Pos
+ Bracket bool // deprecated $[expr] form
+ Unsigned bool // mksh's $((# expr))
+
+ X ArithmExpr
+}
+
+func (a *ArithmExp) Pos() Pos { return a.Left }
+func (a *ArithmExp) End() Pos {
+ if a.Bracket {
+ return posAddCol(a.Right, 1)
+ }
+ return posAddCol(a.Right, 2)
+}
+
+// ArithmCmd represents an arithmetic command.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type ArithmCmd struct {
+ Left, Right Pos
+ Unsigned bool // mksh's ((# expr))
+
+ X ArithmExpr
+}
+
+func (a *ArithmCmd) Pos() Pos { return a.Left }
+func (a *ArithmCmd) End() Pos { return posAddCol(a.Right, 2) }
+
+// ArithmExpr represents all nodes that form arithmetic expressions.
+//
+// These are *BinaryArithm, *UnaryArithm, *ParenArithm, and *Word.
+type ArithmExpr interface {
+ Node
+ arithmExprNode()
+}
+
+func (*BinaryArithm) arithmExprNode() {}
+func (*UnaryArithm) arithmExprNode() {}
+func (*ParenArithm) arithmExprNode() {}
+func (*Word) arithmExprNode() {}
+
+// BinaryArithm represents a binary arithmetic expression.
+//
+// If Op is any assign operator, X will be a word with a single *Lit whose value
+// is a valid name.
+//
+// Ternary operators like "a ? b : c" are fit into this structure. Thus, if
+// Op==TernQuest, Y will be a *BinaryArithm with Op==TernColon. Op can only be
+// TernColon in that scenario.
+type BinaryArithm struct {
+ OpPos Pos
+ Op BinAritOperator
+ X, Y ArithmExpr
+}
+
+func (b *BinaryArithm) Pos() Pos { return b.X.Pos() }
+func (b *BinaryArithm) End() Pos { return b.Y.End() }
+
+// UnaryArithm represents an unary arithmetic expression. The unary operator
+// may come before or after the sub-expression.
+//
+// If Op is Inc or Dec, X will be a word with a single *Lit whose value is a
+// valid name.
+type UnaryArithm struct {
+ OpPos Pos
+ Op UnAritOperator
+ Post bool
+ X ArithmExpr
+}
+
+func (u *UnaryArithm) Pos() Pos {
+ if u.Post {
+ return u.X.Pos()
+ }
+ return u.OpPos
+}
+
+func (u *UnaryArithm) End() Pos {
+ if u.Post {
+ return posAddCol(u.OpPos, 2)
+ }
+ return u.X.End()
+}
+
+// ParenArithm represents an arithmetic expression within parentheses.
+type ParenArithm struct {
+ Lparen, Rparen Pos
+
+ X ArithmExpr
+}
+
+func (p *ParenArithm) Pos() Pos { return p.Lparen }
+func (p *ParenArithm) End() Pos { return posAddCol(p.Rparen, 1) }
+
+// CaseClause represents a case (switch) clause.
+type CaseClause struct {
+ Case, In, Esac Pos
+ Braces bool // deprecated mksh form with braces instead of in/esac
+
+ Word *Word
+ Items []*CaseItem
+ Last []Comment
+}
+
+func (c *CaseClause) Pos() Pos { return c.Case }
+func (c *CaseClause) End() Pos { return posAddCol(c.Esac, 4) }
+
+// CaseItem represents a pattern list (case) within a CaseClause.
+type CaseItem struct {
+ Op CaseOperator
+ OpPos Pos // unset if it was finished by "esac"
+ Comments []Comment
+ Patterns []*Word
+
+ Stmts []*Stmt
+ Last []Comment
+}
+
+func (c *CaseItem) Pos() Pos { return c.Patterns[0].Pos() }
+func (c *CaseItem) End() Pos {
+ if c.OpPos.IsValid() {
+ return posAddCol(c.OpPos, len(c.Op.String()))
+ }
+ return stmtsEnd(c.Stmts, c.Last)
+}
+
+// TestClause represents a Bash extended test clause.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type TestClause struct {
+ Left, Right Pos
+
+ X TestExpr
+}
+
+func (t *TestClause) Pos() Pos { return t.Left }
+func (t *TestClause) End() Pos { return posAddCol(t.Right, 2) }
+
+// TestExpr represents all nodes that form test expressions.
+//
+// These are *BinaryTest, *UnaryTest, *ParenTest, and *Word.
+type TestExpr interface {
+ Node
+ testExprNode()
+}
+
+func (*BinaryTest) testExprNode() {}
+func (*UnaryTest) testExprNode() {}
+func (*ParenTest) testExprNode() {}
+func (*Word) testExprNode() {}
+
+// BinaryTest represents a binary test expression.
+type BinaryTest struct {
+ OpPos Pos
+ Op BinTestOperator
+ X, Y TestExpr
+}
+
+func (b *BinaryTest) Pos() Pos { return b.X.Pos() }
+func (b *BinaryTest) End() Pos { return b.Y.End() }
+
+// UnaryTest represents a unary test expression. The unary operator may come
+// before or after the sub-expression.
+type UnaryTest struct {
+ OpPos Pos
+ Op UnTestOperator
+ X TestExpr
+}
+
+func (u *UnaryTest) Pos() Pos { return u.OpPos }
+func (u *UnaryTest) End() Pos { return u.X.End() }
+
+// ParenTest represents a test expression within parentheses.
+type ParenTest struct {
+ Lparen, Rparen Pos
+
+ X TestExpr
+}
+
+func (p *ParenTest) Pos() Pos { return p.Lparen }
+func (p *ParenTest) End() Pos { return posAddCol(p.Rparen, 1) }
+
+// DeclClause represents a Bash declare clause.
+//
+// Args can contain a mix of regular and naked assignments. The naked
+// assignments can represent either options or variable names.
+//
+// This node will only appear with LangBash.
+type DeclClause struct {
+ // Variant is one of "declare", "local", "export", "readonly",
+ // "typeset", or "nameref".
+ Variant *Lit
+ Args []*Assign
+}
+
+func (d *DeclClause) Pos() Pos { return d.Variant.Pos() }
+func (d *DeclClause) End() Pos {
+ if len(d.Args) > 0 {
+ return d.Args[len(d.Args)-1].End()
+ }
+ return d.Variant.End()
+}
+
+// ArrayExpr represents a Bash array expression.
+//
+// This node will only appear with LangBash.
+type ArrayExpr struct {
+ Lparen, Rparen Pos
+
+ Elems []*ArrayElem
+ Last []Comment
+}
+
+func (a *ArrayExpr) Pos() Pos { return a.Lparen }
+func (a *ArrayExpr) End() Pos { return posAddCol(a.Rparen, 1) }
+
+// ArrayElem represents a Bash array element.
+//
+// Index can be nil; for example, declare -a x=(value).
+// Value can be nil; for example, declare -A x=([index]=).
+// Finally, neither can be nil; for example, declare -A x=([index]=value)
+type ArrayElem struct {
+ Index ArithmExpr
+ Value *Word
+ Comments []Comment
+}
+
+func (a *ArrayElem) Pos() Pos {
+ if a.Index != nil {
+ return a.Index.Pos()
+ }
+ return a.Value.Pos()
+}
+
+func (a *ArrayElem) End() Pos {
+ if a.Value != nil {
+ return a.Value.End()
+ }
+ return posAddCol(a.Index.Pos(), 1)
+}
+
+// ExtGlob represents a Bash extended globbing expression. Note that these are
+// parsed independently of whether shopt has been called or not.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type ExtGlob struct {
+ OpPos Pos
+ Op GlobOperator
+ Pattern *Lit
+}
+
+func (e *ExtGlob) Pos() Pos { return e.OpPos }
+func (e *ExtGlob) End() Pos { return posAddCol(e.Pattern.End(), 1) }
+
+// ProcSubst represents a Bash process substitution.
+//
+// This node will only appear with LangBash.
+type ProcSubst struct {
+ OpPos, Rparen Pos
+ Op ProcOperator
+
+ Stmts []*Stmt
+ Last []Comment
+}
+
+func (s *ProcSubst) Pos() Pos { return s.OpPos }
+func (s *ProcSubst) End() Pos { return posAddCol(s.Rparen, 1) }
+
+// TimeClause represents a Bash time clause. PosixFormat corresponds to the -p
+// flag.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type TimeClause struct {
+ Time Pos
+ PosixFormat bool
+ Stmt *Stmt
+}
+
+func (c *TimeClause) Pos() Pos { return c.Time }
+func (c *TimeClause) End() Pos {
+ if c.Stmt == nil {
+ return posAddCol(c.Time, 4)
+ }
+ return c.Stmt.End()
+}
+
+// CoprocClause represents a Bash coproc clause.
+//
+// This node will only appear with LangBash.
+type CoprocClause struct {
+ Coproc Pos
+ Name *Word
+ Stmt *Stmt
+}
+
+func (c *CoprocClause) Pos() Pos { return c.Coproc }
+func (c *CoprocClause) End() Pos { return c.Stmt.End() }
+
+// LetClause represents a Bash let clause.
+//
+// This node will only appear in LangBash and LangMirBSDKorn.
+type LetClause struct {
+ Let Pos
+ Exprs []ArithmExpr
+}
+
+func (l *LetClause) Pos() Pos { return l.Let }
+func (l *LetClause) End() Pos { return l.Exprs[len(l.Exprs)-1].End() }
+
+// BraceExp represents a Bash brace expression, such as "{a,f}" or "{1..10}".
+//
+// This node will only appear as a result of SplitBraces.
+type BraceExp struct {
+ Sequence bool // {x..y[..incr]} instead of {x,y[,...]}
+ Elems []*Word
+}
+
+func (b *BraceExp) Pos() Pos {
+ return posAddCol(b.Elems[0].Pos(), -1)
+}
+
+func (b *BraceExp) End() Pos {
+ return posAddCol(wordLastEnd(b.Elems), 1)
+}
+
+// TestDecl represents the declaration of a Bats test function.
+type TestDecl struct {
+ Position Pos
+ Description *Word
+ Body *Stmt
+}
+
+func (f *TestDecl) Pos() Pos { return f.Position }
+func (f *TestDecl) End() Pos { return f.Body.End() }
+
+func wordLastEnd(ws []*Word) Pos {
+ if len(ws) == 0 {
+ return Pos{}
+ }
+ return ws[len(ws)-1].End()
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/parser.go b/vendor/mvdan.cc/sh/v3/syntax/parser.go
new file mode 100644
index 00000000..99ae17c2
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/parser.go
@@ -0,0 +1,2489 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// ParserOption is a function which can be passed to NewParser
+// to alter its behavior. To apply option to existing Parser
+// call it directly, for example KeepComments(true)(parser).
+type ParserOption func(*Parser)
+
+// KeepComments makes the parser parse comments and attach them to
+// nodes, as opposed to discarding them.
+func KeepComments(enabled bool) ParserOption {
+ return func(p *Parser) { p.keepComments = enabled }
+}
+
+// LangVariant describes a shell language variant to use when tokenizing and
+// parsing shell code. The zero value is LangBash.
+type LangVariant int
+
+const (
+ // LangBash corresponds to the GNU Bash language, as described in its
+ // manual at https://www.gnu.org/software/bash/manual/bash.html.
+ //
+ // We currently follow Bash version 5.1.
+ //
+ // Its string representation is "bash".
+ LangBash LangVariant = iota
+
+ // LangPOSIX corresponds to the POSIX Shell language, as described at
+ // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html.
+ //
+ // Its string representation is "posix" or "sh".
+ LangPOSIX
+
+ // LangMirBSDKorn corresponds to the MirBSD Korn Shell, also known as
+ // mksh, as described at http://www.mirbsd.org/htman/i386/man1/mksh.htm.
+ // Note that it shares some features with Bash, due to the the shared
+ // ancestry that is ksh.
+ //
+ // We currently follow mksh version 59.
+ //
+ // Its string representation is "mksh".
+ LangMirBSDKorn
+
+ // LangBats corresponds to the Bash Automated Testing System language,
+ // as described at https://github.com/bats-core/bats-core. Note that
+ // it's just a small extension of the Bash language.
+ //
+ // Its string representation is "bats".
+ LangBats
+
+ // LangAuto corresponds to automatic language detection,
+ // commonly used by end-user applications like shfmt,
+ // which can guess a file's language variant given its filename or shebang.
+ //
+ // At this time, the Parser does not support LangAuto.
+ LangAuto
+)
+
+// Variant changes the shell language variant that the parser will
+// accept.
+//
+// The passed language variant must be one of the constant values defined in
+// this package.
+func Variant(l LangVariant) ParserOption {
+ switch l {
+ case LangBash, LangPOSIX, LangMirBSDKorn, LangBats:
+ case LangAuto:
+ panic("LangAuto is not supported by the parser at this time")
+ default:
+ panic(fmt.Sprintf("unknown shell language variant: %d", l))
+ }
+ return func(p *Parser) { p.lang = l }
+}
+
+func (l LangVariant) String() string {
+ switch l {
+ case LangBash:
+ return "bash"
+ case LangPOSIX:
+ return "posix"
+ case LangMirBSDKorn:
+ return "mksh"
+ case LangBats:
+ return "bats"
+ case LangAuto:
+ return "auto"
+ }
+ return "unknown shell language variant"
+}
+
+func (l *LangVariant) Set(s string) error {
+ switch s {
+ case "bash":
+ *l = LangBash
+ case "posix", "sh":
+ *l = LangPOSIX
+ case "mksh":
+ *l = LangMirBSDKorn
+ case "bats":
+ *l = LangBats
+ case "auto":
+ *l = LangAuto
+ default:
+ return fmt.Errorf("unknown shell language variant: %q", s)
+ }
+ return nil
+}
+
+func (l LangVariant) isBash() bool {
+ return l == LangBash || l == LangBats
+}
+
+// StopAt configures the lexer to stop at an arbitrary word, treating it
+// as if it were the end of the input. It can contain any characters
+// except whitespace, and cannot be over four bytes in size.
+//
+// This can be useful to embed shell code within another language, as
+// one can use a special word to mark the delimiters between the two.
+//
+// As a word, it will only apply when following whitespace or a
+// separating token. For example, StopAt("$$") will act on the inputs
+// "foo $$" and "foo;$$", but not on "foo '$$'".
+//
+// The match is done by prefix, so the example above will also act on
+// "foo $$bar".
+func StopAt(word string) ParserOption {
+ if len(word) > 4 {
+ panic("stop word can't be over four bytes in size")
+ }
+ if strings.ContainsAny(word, " \t\n\r") {
+ panic("stop word can't contain whitespace characters")
+ }
+ return func(p *Parser) { p.stopAt = []byte(word) }
+}
+
+// NewParser allocates a new Parser and applies any number of options.
+func NewParser(options ...ParserOption) *Parser {
+ p := &Parser{}
+ for _, opt := range options {
+ opt(p)
+ }
+ return p
+}
+
+// Parse reads and parses a shell program with an optional name. It
+// returns the parsed program if no issues were encountered. Otherwise,
+// an error is returned. Reads from r are buffered.
+//
+// Parse can be called more than once, but not concurrently. That is, a
+// Parser can be reused once it is done working.
+func (p *Parser) Parse(r io.Reader, name string) (*File, error) {
+ p.reset()
+ p.f = &File{Name: name}
+ p.src = r
+ p.rune()
+ p.next()
+ p.f.Stmts, p.f.Last = p.stmtList()
+ if p.err == nil {
+ // EOF immediately after heredoc word so no newline to
+ // trigger it
+ p.doHeredocs()
+ }
+ return p.f, p.err
+}
+
+// Stmts reads and parses statements one at a time, calling a function
+// each time one is parsed. If the function returns false, parsing is
+// stopped and the function is not called again.
+func (p *Parser) Stmts(r io.Reader, fn func(*Stmt) bool) error {
+ p.reset()
+ p.f = &File{}
+ p.src = r
+ p.rune()
+ p.next()
+ p.stmts(fn)
+ if p.err == nil {
+ // EOF immediately after heredoc word so no newline to
+ // trigger it
+ p.doHeredocs()
+ }
+ return p.err
+}
+
+type wrappedReader struct {
+ *Parser
+ io.Reader
+
+ lastLine int
+ accumulated []*Stmt
+ fn func([]*Stmt) bool
+}
+
+func (w *wrappedReader) Read(p []byte) (n int, err error) {
+ // If we lexed a newline for the first time, we just finished a line, so
+ // we may need to give a callback for the edge cases below not covered
+ // by Parser.Stmts.
+ if (w.r == '\n' || w.r == escNewl) && w.line > w.lastLine {
+ if w.Incomplete() {
+ // Incomplete statement; call back to print "> ".
+ if !w.fn(w.accumulated) {
+ return 0, io.EOF
+ }
+ } else if len(w.accumulated) == 0 {
+ // Nothing was parsed; call back to print another "$ ".
+ if !w.fn(nil) {
+ return 0, io.EOF
+ }
+ }
+ w.lastLine = w.line
+ }
+ return w.Reader.Read(p)
+}
+
+// Interactive implements what is necessary to parse statements in an
+// interactive shell. The parser will call the given function under two
+// circumstances outlined below.
+//
+// If a line containing any number of statements is parsed, the function will be
+// called with said statements.
+//
+// If a line ending in an incomplete statement is parsed, the function will be
+// called with any fully parsed statements, and [Parser.Incomplete] will return true.
+//
+// One can imagine a simple interactive shell implementation as follows:
+//
+// fmt.Fprintf(os.Stdout, "$ ")
+// parser.Interactive(os.Stdin, func(stmts []*syntax.Stmt) bool {
+// if parser.Incomplete() {
+// fmt.Fprintf(os.Stdout, "> ")
+// return true
+// }
+// run(stmts)
+// fmt.Fprintf(os.Stdout, "$ ")
+// return true
+// }
+//
+// If the callback function returns false, parsing is stopped and the function
+// is not called again.
+func (p *Parser) Interactive(r io.Reader, fn func([]*Stmt) bool) error {
+ w := wrappedReader{Parser: p, Reader: r, fn: fn}
+ return p.Stmts(&w, func(stmt *Stmt) bool {
+ w.accumulated = append(w.accumulated, stmt)
+ // We finished parsing a statement and we're at a newline token,
+ // so we finished fully parsing a number of statements. Call
+ // back to run the statements and print "$ ".
+ if p.tok == _Newl {
+ if !fn(w.accumulated) {
+ return false
+ }
+ w.accumulated = w.accumulated[:0]
+ // The callback above would already print "$ ", so we
+ // don't want the subsequent wrappedReader.Read to cause
+ // another "$ " print thinking that nothing was parsed.
+ w.lastLine = w.line + 1
+ }
+ return true
+ })
+}
+
+// Words reads and parses words one at a time, calling a function each time one
+// is parsed. If the function returns false, parsing is stopped and the function
+// is not called again.
+//
+// Newlines are skipped, meaning that multi-line input will work fine. If the
+// parser encounters a token that isn't a word, such as a semicolon, an error
+// will be returned.
+//
+// Note that the lexer doesn't currently tokenize spaces, so it may need to read
+// a non-space byte such as a newline or a letter before finishing the parsing
+// of a word. This will be fixed in the future.
+func (p *Parser) Words(r io.Reader, fn func(*Word) bool) error {
+ p.reset()
+ p.f = &File{}
+ p.src = r
+ p.rune()
+ p.next()
+ for {
+ p.got(_Newl)
+ w := p.getWord()
+ if w == nil {
+ if p.tok != _EOF {
+ p.curErr("%s is not a valid word", p.tok)
+ }
+ return p.err
+ }
+ if !fn(w) {
+ return nil
+ }
+ }
+}
+
+// Document parses a single here-document word. That is, it parses the input as
+// if they were lines following a < 0 || p.litBs != nil
+}
+
+const bufSize = 1 << 10
+
+func (p *Parser) reset() {
+ p.tok, p.val = illegalTok, ""
+ p.eqlOffs = 0
+ p.bs, p.bsp = nil, 0
+ p.offs, p.line, p.col = 0, 1, 1
+ p.r, p.w = 0, 0
+ p.err, p.readErr = nil, nil
+ p.quote, p.forbidNested = noState, false
+ p.openStmts = 0
+ p.heredocs, p.buriedHdocs = p.heredocs[:0], 0
+ p.parsingDoc = false
+ p.openBquotes, p.buriedBquotes = 0, 0
+ p.accComs, p.curComs = nil, &p.accComs
+ p.litBatch = nil
+ p.wordBatch = nil
+ p.stmtBatch = nil
+ p.callBatch = nil
+}
+
+func (p *Parser) nextPos() Pos {
+ // TODO: detect offset overflow while lexing as well.
+ var line, col uint
+ if !p.lineOverflow {
+ line = uint(p.line)
+ }
+ if !p.colOverflow {
+ col = uint(p.col)
+ }
+ return NewPos(uint(p.offs+p.bsp-p.w), line, col)
+}
+
+func (p *Parser) lit(pos Pos, val string) *Lit {
+ if len(p.litBatch) == 0 {
+ p.litBatch = make([]Lit, 64)
+ }
+ l := &p.litBatch[0]
+ p.litBatch = p.litBatch[1:]
+ l.ValuePos = pos
+ l.ValueEnd = p.nextPos()
+ l.Value = val
+ return l
+}
+
+type wordAlloc struct {
+ word Word
+ parts [1]WordPart
+}
+
+func (p *Parser) wordAnyNumber() *Word {
+ if len(p.wordBatch) == 0 {
+ p.wordBatch = make([]wordAlloc, 32)
+ }
+ alloc := &p.wordBatch[0]
+ p.wordBatch = p.wordBatch[1:]
+ w := &alloc.word
+ w.Parts = p.wordParts(alloc.parts[:0])
+ return w
+}
+
+func (p *Parser) wordOne(part WordPart) *Word {
+ if len(p.wordBatch) == 0 {
+ p.wordBatch = make([]wordAlloc, 32)
+ }
+ alloc := &p.wordBatch[0]
+ p.wordBatch = p.wordBatch[1:]
+ w := &alloc.word
+ w.Parts = alloc.parts[:1]
+ w.Parts[0] = part
+ return w
+}
+
+func (p *Parser) stmt(pos Pos) *Stmt {
+ if len(p.stmtBatch) == 0 {
+ p.stmtBatch = make([]Stmt, 32)
+ }
+ s := &p.stmtBatch[0]
+ p.stmtBatch = p.stmtBatch[1:]
+ s.Position = pos
+ return s
+}
+
+type callAlloc struct {
+ ce CallExpr
+ ws [4]*Word
+}
+
+func (p *Parser) call(w *Word) *CallExpr {
+ if len(p.callBatch) == 0 {
+ p.callBatch = make([]callAlloc, 32)
+ }
+ alloc := &p.callBatch[0]
+ p.callBatch = p.callBatch[1:]
+ ce := &alloc.ce
+ ce.Args = alloc.ws[:1]
+ ce.Args[0] = w
+ return ce
+}
+
+//go:generate stringer -type=quoteState
+
+type quoteState uint32
+
+const (
+ noState quoteState = 1 << iota
+ subCmd
+ subCmdBckquo
+ dblQuotes
+ hdocWord
+ hdocBody
+ hdocBodyTabs
+ arithmExpr
+ arithmExprLet
+ arithmExprCmd
+ arithmExprBrack
+ testExpr
+ testExprRegexp
+ switchCase
+ paramExpName
+ paramExpSlice
+ paramExpRepl
+ paramExpExp
+ arrayElems
+
+ allKeepSpaces = paramExpRepl | dblQuotes | hdocBody |
+ hdocBodyTabs | paramExpExp
+ allRegTokens = noState | subCmd | subCmdBckquo | hdocWord |
+ switchCase | arrayElems | testExpr
+ allArithmExpr = arithmExpr | arithmExprLet | arithmExprCmd |
+ arithmExprBrack | paramExpSlice
+ allParamReg = paramExpName | paramExpSlice
+ allParamExp = allParamReg | paramExpRepl | paramExpExp | arithmExprBrack
+)
+
+type saveState struct {
+ quote quoteState
+ buriedHdocs int
+}
+
+func (p *Parser) preNested(quote quoteState) (s saveState) {
+ s.quote, s.buriedHdocs = p.quote, p.buriedHdocs
+ p.buriedHdocs, p.quote = len(p.heredocs), quote
+ return
+}
+
+func (p *Parser) postNested(s saveState) {
+ p.quote, p.buriedHdocs = s.quote, s.buriedHdocs
+}
+
+func (p *Parser) unquotedWordBytes(w *Word) ([]byte, bool) {
+ buf := make([]byte, 0, 4)
+ didUnquote := false
+ for _, wp := range w.Parts {
+ buf, didUnquote = p.unquotedWordPart(buf, wp, false)
+ }
+ return buf, didUnquote
+}
+
+func (p *Parser) unquotedWordPart(buf []byte, wp WordPart, quotes bool) (_ []byte, quoted bool) {
+ switch x := wp.(type) {
+ case *Lit:
+ for i := 0; i < len(x.Value); i++ {
+ if b := x.Value[i]; b == '\\' && !quotes {
+ if i++; i < len(x.Value) {
+ buf = append(buf, x.Value[i])
+ }
+ quoted = true
+ } else {
+ buf = append(buf, b)
+ }
+ }
+ case *SglQuoted:
+ buf = append(buf, []byte(x.Value)...)
+ quoted = true
+ case *DblQuoted:
+ for _, wp2 := range x.Parts {
+ buf, _ = p.unquotedWordPart(buf, wp2, true)
+ }
+ quoted = true
+ }
+ return buf, quoted
+}
+
+func (p *Parser) doHeredocs() {
+ hdocs := p.heredocs[p.buriedHdocs:]
+ if len(hdocs) == 0 {
+ // Nothing do do; don't even issue a read.
+ return
+ }
+ p.rune() // consume '\n', since we know p.tok == _Newl
+ old := p.quote
+ p.heredocs = p.heredocs[:p.buriedHdocs]
+ for i, r := range hdocs {
+ if p.err != nil {
+ break
+ }
+ p.quote = hdocBody
+ if r.Op == DashHdoc {
+ p.quote = hdocBodyTabs
+ }
+ stop, quoted := p.unquotedWordBytes(r.Word)
+ p.hdocStops = append(p.hdocStops, stop)
+ if i > 0 && p.r == '\n' {
+ p.rune()
+ }
+ lastLine := p.line
+ if quoted {
+ r.Hdoc = p.quotedHdocWord()
+ } else {
+ p.next()
+ r.Hdoc = p.getWord()
+ }
+ if r.Hdoc != nil {
+ lastLine = int(r.Hdoc.End().Line())
+ }
+ if lastLine < p.line {
+ // TODO: It seems like this triggers more often than it
+ // should. Look into it.
+ l := p.lit(p.nextPos(), "")
+ if r.Hdoc == nil {
+ r.Hdoc = p.wordOne(l)
+ } else {
+ r.Hdoc.Parts = append(r.Hdoc.Parts, l)
+ }
+ }
+ if stop := p.hdocStops[len(p.hdocStops)-1]; stop != nil {
+ p.posErr(r.Pos(), "unclosed here-document '%s'", stop)
+ }
+ p.hdocStops = p.hdocStops[:len(p.hdocStops)-1]
+ }
+ p.quote = old
+}
+
+func (p *Parser) got(tok token) bool {
+ if p.tok == tok {
+ p.next()
+ return true
+ }
+ return false
+}
+
+func (p *Parser) gotRsrv(val string) (Pos, bool) {
+ pos := p.pos
+ if p.tok == _LitWord && p.val == val {
+ p.next()
+ return pos, true
+ }
+ return pos, false
+}
+
+func readableStr(s string) string {
+ // don't quote tokens like & or }
+ if s != "" && s[0] >= 'a' && s[0] <= 'z' {
+ return strconv.Quote(s)
+ }
+ return s
+}
+
+func (p *Parser) followErr(pos Pos, left, right string) {
+ leftStr := readableStr(left)
+ p.posErr(pos, "%s must be followed by %s", leftStr, right)
+}
+
+func (p *Parser) followErrExp(pos Pos, left string) {
+ p.followErr(pos, left, "an expression")
+}
+
+func (p *Parser) follow(lpos Pos, left string, tok token) {
+ if !p.got(tok) {
+ p.followErr(lpos, left, tok.String())
+ }
+}
+
+func (p *Parser) followRsrv(lpos Pos, left, val string) Pos {
+ pos, ok := p.gotRsrv(val)
+ if !ok {
+ p.followErr(lpos, left, fmt.Sprintf("%q", val))
+ }
+ return pos
+}
+
+func (p *Parser) followStmts(left string, lpos Pos, stops ...string) ([]*Stmt, []Comment) {
+ if p.got(semicolon) {
+ return nil, nil
+ }
+ newLine := p.got(_Newl)
+ stmts, last := p.stmtList(stops...)
+ if len(stmts) < 1 && !newLine {
+ p.followErr(lpos, left, "a statement list")
+ }
+ return stmts, last
+}
+
+func (p *Parser) followWordTok(tok token, pos Pos) *Word {
+ w := p.getWord()
+ if w == nil {
+ p.followErr(pos, tok.String(), "a word")
+ }
+ return w
+}
+
+func (p *Parser) stmtEnd(n Node, start, end string) Pos {
+ pos, ok := p.gotRsrv(end)
+ if !ok {
+ p.posErr(n.Pos(), "%s statement must end with %q", start, end)
+ }
+ return pos
+}
+
+func (p *Parser) quoteErr(lpos Pos, quote token) {
+ p.posErr(lpos, "reached %s without closing quote %s",
+ p.tok.String(), quote)
+}
+
+func (p *Parser) matchingErr(lpos Pos, left, right any) {
+ p.posErr(lpos, "reached %s without matching %s with %s",
+ p.tok.String(), left, right)
+}
+
+func (p *Parser) matched(lpos Pos, left, right token) Pos {
+ pos := p.pos
+ if !p.got(right) {
+ p.matchingErr(lpos, left, right)
+ }
+ return pos
+}
+
+func (p *Parser) errPass(err error) {
+ if p.err == nil {
+ p.err = err
+ p.bsp = len(p.bs) + 1
+ p.r = utf8.RuneSelf
+ p.w = 1
+ p.tok = _EOF
+ }
+}
+
+// IsIncomplete reports whether a Parser error could have been avoided with
+// extra input bytes. For example, if an [io.EOF] was encountered while there was
+// an unclosed quote or parenthesis.
+func IsIncomplete(err error) bool {
+ perr, ok := err.(ParseError)
+ return ok && perr.Incomplete
+}
+
+// IsKeyword returns true if the given word is part of the language keywords.
+func IsKeyword(word string) bool {
+ // This list has been copied from the bash 5.1 source code, file y.tab.c +4460
+ switch word {
+ case
+ "!",
+ "[[", // only if COND_COMMAND is defined
+ "]]", // only if COND_COMMAND is defined
+ "case",
+ "coproc", // only if COPROCESS_SUPPORT is defined
+ "do",
+ "done",
+ "else",
+ "esac",
+ "fi",
+ "for",
+ "function",
+ "if",
+ "in",
+ "select", // only if SELECT_COMMAND is defined
+ "then",
+ "time", // only if COMMAND_TIMING is defined
+ "until",
+ "while",
+ "{",
+ "}":
+ return true
+ }
+ return false
+}
+
+// ParseError represents an error found when parsing a source file, from which
+// the parser cannot recover.
+type ParseError struct {
+ Filename string
+ Pos Pos
+ Text string
+
+ Incomplete bool
+}
+
+func (e ParseError) Error() string {
+ if e.Filename == "" {
+ return fmt.Sprintf("%s: %s", e.Pos.String(), e.Text)
+ }
+ return fmt.Sprintf("%s:%s: %s", e.Filename, e.Pos.String(), e.Text)
+}
+
+// LangError is returned when the parser encounters code that is only valid in
+// other shell language variants. The error includes what feature is not present
+// in the current language variant, and what languages support it.
+type LangError struct {
+ Filename string
+ Pos Pos
+ Feature string
+ Langs []LangVariant
+}
+
+func (e LangError) Error() string {
+ var buf bytes.Buffer
+ if e.Filename != "" {
+ buf.WriteString(e.Filename + ":")
+ }
+ buf.WriteString(e.Pos.String() + ": ")
+ buf.WriteString(e.Feature)
+ if strings.HasSuffix(e.Feature, "s") {
+ buf.WriteString(" are a ")
+ } else {
+ buf.WriteString(" is a ")
+ }
+ for i, lang := range e.Langs {
+ if i > 0 {
+ buf.WriteString("/")
+ }
+ buf.WriteString(lang.String())
+ }
+ buf.WriteString(" feature")
+ return buf.String()
+}
+
+func (p *Parser) posErr(pos Pos, format string, a ...any) {
+ p.errPass(ParseError{
+ Filename: p.f.Name,
+ Pos: pos,
+ Text: fmt.Sprintf(format, a...),
+ Incomplete: p.tok == _EOF && p.Incomplete(),
+ })
+}
+
+func (p *Parser) curErr(format string, a ...any) {
+ p.posErr(p.pos, format, a...)
+}
+
+func (p *Parser) langErr(pos Pos, feature string, langs ...LangVariant) {
+ p.errPass(LangError{
+ Filename: p.f.Name,
+ Pos: pos,
+ Feature: feature,
+ Langs: langs,
+ })
+}
+
+func (p *Parser) stmts(fn func(*Stmt) bool, stops ...string) {
+ gotEnd := true
+loop:
+ for p.tok != _EOF {
+ newLine := p.got(_Newl)
+ switch p.tok {
+ case _LitWord:
+ for _, stop := range stops {
+ if p.val == stop {
+ break loop
+ }
+ }
+ case rightParen:
+ if p.quote == subCmd {
+ break loop
+ }
+ case bckQuote:
+ if p.backquoteEnd() {
+ break loop
+ }
+ case dblSemicolon, semiAnd, dblSemiAnd, semiOr:
+ if p.quote == switchCase {
+ break loop
+ }
+ p.curErr("%s can only be used in a case clause", p.tok)
+ }
+ if !newLine && !gotEnd {
+ p.curErr("statements must be separated by &, ; or a newline")
+ }
+ if p.tok == _EOF {
+ break
+ }
+ p.openStmts++
+ s := p.getStmt(true, false, false)
+ p.openStmts--
+ if s == nil {
+ p.invalidStmtStart()
+ break
+ }
+ gotEnd = s.Semicolon.IsValid()
+ if !fn(s) {
+ break
+ }
+ }
+}
+
+func (p *Parser) stmtList(stops ...string) ([]*Stmt, []Comment) {
+ var stmts []*Stmt
+ var last []Comment
+ fn := func(s *Stmt) bool {
+ stmts = append(stmts, s)
+ return true
+ }
+ p.stmts(fn, stops...)
+ split := len(p.accComs)
+ if p.tok == _LitWord && (p.val == "elif" || p.val == "else" || p.val == "fi") {
+ // Split the comments, so that any aligned with an opening token
+ // get attached to it. For example:
+ //
+ // if foo; then
+ // # inside the body
+ // # document the else
+ // else
+ // fi
+ // TODO(mvdan): look into deduplicating this with similar logic
+ // in caseItems.
+ for i := len(p.accComs) - 1; i >= 0; i-- {
+ c := p.accComs[i]
+ if c.Pos().Col() != p.pos.Col() {
+ break
+ }
+ split = i
+ }
+ }
+ if split > 0 { // keep last nil if empty
+ last = p.accComs[:split]
+ }
+ p.accComs = p.accComs[split:]
+ return stmts, last
+}
+
+func (p *Parser) invalidStmtStart() {
+ switch p.tok {
+ case semicolon, and, or, andAnd, orOr:
+ p.curErr("%s can only immediately follow a statement", p.tok)
+ case rightParen:
+ p.curErr("%s can only be used to close a subshell", p.tok)
+ default:
+ p.curErr("%s is not a valid start for a statement", p.tok)
+ }
+}
+
+func (p *Parser) getWord() *Word {
+ if w := p.wordAnyNumber(); len(w.Parts) > 0 && p.err == nil {
+ return w
+ }
+ return nil
+}
+
+func (p *Parser) getLit() *Lit {
+ switch p.tok {
+ case _Lit, _LitWord, _LitRedir:
+ l := p.lit(p.pos, p.val)
+ p.next()
+ return l
+ }
+ return nil
+}
+
+func (p *Parser) wordParts(wps []WordPart) []WordPart {
+ for {
+ n := p.wordPart()
+ if n == nil {
+ if len(wps) == 0 {
+ return nil // normalize empty lists into nil
+ }
+ return wps
+ }
+ wps = append(wps, n)
+ if p.spaced {
+ return wps
+ }
+ }
+}
+
+func (p *Parser) ensureNoNested() {
+ if p.forbidNested {
+ p.curErr("expansions not allowed in heredoc words")
+ }
+}
+
+func (p *Parser) wordPart() WordPart {
+ switch p.tok {
+ case _Lit, _LitWord, _LitRedir:
+ l := p.lit(p.pos, p.val)
+ p.next()
+ return l
+ case dollBrace:
+ p.ensureNoNested()
+ switch p.r {
+ case '|':
+ if p.lang != LangMirBSDKorn {
+ p.curErr(`"${|stmts;}" is a mksh feature`)
+ }
+ fallthrough
+ case ' ', '\t', '\n':
+ if p.lang != LangMirBSDKorn {
+ p.curErr(`"${ stmts;}" is a mksh feature`)
+ }
+ cs := &CmdSubst{
+ Left: p.pos,
+ TempFile: p.r != '|',
+ ReplyVar: p.r == '|',
+ }
+ old := p.preNested(subCmd)
+ p.rune() // don't tokenize '|'
+ p.next()
+ cs.Stmts, cs.Last = p.stmtList("}")
+ p.postNested(old)
+ pos, ok := p.gotRsrv("}")
+ if !ok {
+ p.matchingErr(cs.Left, "${", "}")
+ }
+ cs.Right = pos
+ return cs
+ default:
+ return p.paramExp()
+ }
+ case dollDblParen, dollBrack:
+ p.ensureNoNested()
+ left := p.tok
+ ar := &ArithmExp{Left: p.pos, Bracket: left == dollBrack}
+ var old saveState
+ if ar.Bracket {
+ old = p.preNested(arithmExprBrack)
+ } else {
+ old = p.preNested(arithmExpr)
+ }
+ p.next()
+ if p.got(hash) {
+ if p.lang != LangMirBSDKorn {
+ p.langErr(ar.Pos(), "unsigned expressions", LangMirBSDKorn)
+ }
+ ar.Unsigned = true
+ }
+ ar.X = p.followArithm(left, ar.Left)
+ if ar.Bracket {
+ if p.tok != rightBrack {
+ p.arithmMatchingErr(ar.Left, dollBrack, rightBrack)
+ }
+ p.postNested(old)
+ ar.Right = p.pos
+ p.next()
+ } else {
+ ar.Right = p.arithmEnd(dollDblParen, ar.Left, old)
+ }
+ return ar
+ case dollParen:
+ p.ensureNoNested()
+ cs := &CmdSubst{Left: p.pos}
+ old := p.preNested(subCmd)
+ p.next()
+ cs.Stmts, cs.Last = p.stmtList()
+ p.postNested(old)
+ cs.Right = p.matched(cs.Left, leftParen, rightParen)
+ return cs
+ case dollar:
+ r := p.r
+ switch {
+ case singleRuneParam(r):
+ p.tok, p.val = _LitWord, string(r)
+ p.rune()
+ case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z',
+ '0' <= r && r <= '9', r == '_', r == '\\':
+ p.advanceNameCont(r)
+ default:
+ l := p.lit(p.pos, "$")
+ p.next()
+ return l
+ }
+ p.ensureNoNested()
+ pe := &ParamExp{Dollar: p.pos, Short: true}
+ p.pos = posAddCol(p.pos, 1)
+ pe.Param = p.getLit()
+ if pe.Param != nil && pe.Param.Value == "" {
+ l := p.lit(pe.Dollar, "$")
+ // e.g. "$\\\"" within double quotes, so we must
+ // keep the rest of the literal characters.
+ l.ValueEnd = posAddCol(l.ValuePos, 1)
+ return l
+ }
+ return pe
+ case cmdIn, cmdOut:
+ p.ensureNoNested()
+ ps := &ProcSubst{Op: ProcOperator(p.tok), OpPos: p.pos}
+ old := p.preNested(subCmd)
+ p.next()
+ ps.Stmts, ps.Last = p.stmtList()
+ p.postNested(old)
+ ps.Rparen = p.matched(ps.OpPos, token(ps.Op), rightParen)
+ return ps
+ case sglQuote, dollSglQuote:
+ sq := &SglQuoted{Left: p.pos, Dollar: p.tok == dollSglQuote}
+ r := p.r
+ for p.newLit(r); ; r = p.rune() {
+ switch r {
+ case '\\':
+ if sq.Dollar {
+ p.rune()
+ }
+ case '\'':
+ sq.Right = p.nextPos()
+ sq.Value = p.endLit()
+
+ // restore openBquotes
+ p.openBquotes = p.buriedBquotes
+ p.buriedBquotes = 0
+
+ p.rune()
+ p.next()
+ return sq
+ case escNewl:
+ p.litBs = append(p.litBs, '\\', '\n')
+ case utf8.RuneSelf:
+ p.tok = _EOF
+ p.quoteErr(sq.Pos(), sglQuote)
+ return nil
+ }
+ }
+ case dblQuote, dollDblQuote:
+ if p.quote == dblQuotes {
+ // p.tok == dblQuote, as "foo$" puts $ in the lit
+ return nil
+ }
+ return p.dblQuoted()
+ case bckQuote:
+ if p.backquoteEnd() {
+ return nil
+ }
+ p.ensureNoNested()
+ cs := &CmdSubst{Left: p.pos, Backquotes: true}
+ old := p.preNested(subCmdBckquo)
+ p.openBquotes++
+
+ // The lexer didn't call p.rune for us, so that it could have
+ // the right p.openBquotes to properly handle backslashes.
+ p.rune()
+
+ p.next()
+ cs.Stmts, cs.Last = p.stmtList()
+ if p.tok == bckQuote && p.lastBquoteEsc < p.openBquotes-1 {
+ // e.g. found ` before the nested backquote \` was closed.
+ p.tok = _EOF
+ p.quoteErr(cs.Pos(), bckQuote)
+ }
+ p.postNested(old)
+ p.openBquotes--
+ cs.Right = p.pos
+
+ // Like above, the lexer didn't call p.rune for us.
+ p.rune()
+ if !p.got(bckQuote) {
+ p.quoteErr(cs.Pos(), bckQuote)
+ }
+ return cs
+ case globQuest, globStar, globPlus, globAt, globExcl:
+ if p.lang == LangPOSIX {
+ p.langErr(p.pos, "extended globs", LangBash, LangMirBSDKorn)
+ }
+ eg := &ExtGlob{Op: GlobOperator(p.tok), OpPos: p.pos}
+ lparens := 1
+ r := p.r
+ globLoop:
+ for p.newLit(r); ; r = p.rune() {
+ switch r {
+ case utf8.RuneSelf:
+ break globLoop
+ case '(':
+ lparens++
+ case ')':
+ if lparens--; lparens == 0 {
+ break globLoop
+ }
+ }
+ }
+ eg.Pattern = p.lit(posAddCol(eg.OpPos, 2), p.endLit())
+ p.rune()
+ p.next()
+ if lparens != 0 {
+ p.matchingErr(eg.OpPos, eg.Op, rightParen)
+ }
+ return eg
+ default:
+ return nil
+ }
+}
+
+func (p *Parser) dblQuoted() *DblQuoted {
+ alloc := &struct {
+ quoted DblQuoted
+ parts [1]WordPart
+ }{
+ quoted: DblQuoted{Left: p.pos, Dollar: p.tok == dollDblQuote},
+ }
+ q := &alloc.quoted
+ old := p.quote
+ p.quote = dblQuotes
+ p.next()
+ q.Parts = p.wordParts(alloc.parts[:0])
+ p.quote = old
+ q.Right = p.pos
+ if !p.got(dblQuote) {
+ p.quoteErr(q.Pos(), dblQuote)
+ }
+ return q
+}
+
+func singleRuneParam(r rune) bool {
+ switch r {
+ case '@', '*', '#', '$', '?', '!', '-',
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ return true
+ }
+ return false
+}
+
+func (p *Parser) paramExp() *ParamExp {
+ pe := &ParamExp{Dollar: p.pos}
+ old := p.quote
+ p.quote = paramExpName
+ if p.r == '#' {
+ p.tok = hash
+ p.pos = p.nextPos()
+ p.rune()
+ } else {
+ p.next()
+ }
+ switch p.tok {
+ case hash:
+ if paramNameOp(p.r) {
+ pe.Length = true
+ p.next()
+ }
+ case perc:
+ if p.lang != LangMirBSDKorn {
+ p.posErr(pe.Pos(), `"${%%foo}" is a mksh feature`)
+ }
+ if paramNameOp(p.r) {
+ pe.Width = true
+ p.next()
+ }
+ case exclMark:
+ if paramNameOp(p.r) {
+ pe.Excl = true
+ p.next()
+ }
+ }
+ op := p.tok
+ switch p.tok {
+ case _Lit, _LitWord:
+ if !numberLiteral(p.val) && !ValidName(p.val) {
+ p.curErr("invalid parameter name")
+ }
+ pe.Param = p.lit(p.pos, p.val)
+ p.next()
+ case quest, minus:
+ if pe.Length && p.r != '}' {
+ // actually ${#-default}, not ${#-}; fix the ambiguity
+ pe.Length = false
+ pe.Param = p.lit(posAddCol(p.pos, -1), "#")
+ pe.Param.ValueEnd = p.pos
+ break
+ }
+ fallthrough
+ case at, star, hash, exclMark, dollar:
+ pe.Param = p.lit(p.pos, p.tok.String())
+ p.next()
+ default:
+ p.curErr("parameter expansion requires a literal")
+ }
+ switch p.tok {
+ case _Lit, _LitWord:
+ p.curErr("%s cannot be followed by a word", op)
+ case rightBrace:
+ if pe.Excl && p.lang == LangPOSIX {
+ p.posErr(pe.Pos(), `"${!foo}" is a bash/mksh feature`)
+ }
+ pe.Rbrace = p.pos
+ p.quote = old
+ p.next()
+ return pe
+ case leftBrack:
+ if p.lang == LangPOSIX {
+ p.langErr(p.pos, "arrays", LangBash, LangMirBSDKorn)
+ }
+ if !ValidName(pe.Param.Value) {
+ p.curErr("cannot index a special parameter name")
+ }
+ pe.Index = p.eitherIndex()
+ }
+ if p.tok == rightBrace {
+ pe.Rbrace = p.pos
+ p.quote = old
+ p.next()
+ return pe
+ }
+ if p.tok != _EOF && (pe.Length || pe.Width) {
+ p.curErr("cannot combine multiple parameter expansion operators")
+ }
+ switch p.tok {
+ case slash, dblSlash:
+ // pattern search and replace
+ if p.lang == LangPOSIX {
+ p.langErr(p.pos, "search and replace", LangBash, LangMirBSDKorn)
+ }
+ pe.Repl = &Replace{All: p.tok == dblSlash}
+ p.quote = paramExpRepl
+ p.next()
+ pe.Repl.Orig = p.getWord()
+ p.quote = paramExpExp
+ if p.got(slash) {
+ pe.Repl.With = p.getWord()
+ }
+ case colon:
+ // slicing
+ if p.lang == LangPOSIX {
+ p.langErr(p.pos, "slicing", LangBash, LangMirBSDKorn)
+ }
+ pe.Slice = &Slice{}
+ colonPos := p.pos
+ p.quote = paramExpSlice
+ if p.next(); p.tok != colon {
+ pe.Slice.Offset = p.followArithm(colon, colonPos)
+ }
+ colonPos = p.pos
+ if p.got(colon) {
+ pe.Slice.Length = p.followArithm(colon, colonPos)
+ }
+ // Need to use a different matched style so arithm errors
+ // get reported correctly
+ p.quote = old
+ pe.Rbrace = p.pos
+ p.matchedArithm(pe.Dollar, dollBrace, rightBrace)
+ return pe
+ case caret, dblCaret, comma, dblComma:
+ // upper/lower case
+ if !p.lang.isBash() {
+ p.langErr(p.pos, "this expansion operator", LangBash)
+ }
+ pe.Exp = p.paramExpExp()
+ case at, star:
+ switch {
+ case p.tok == at && p.lang == LangPOSIX:
+ p.langErr(p.pos, "this expansion operator", LangBash, LangMirBSDKorn)
+ case p.tok == star && !pe.Excl:
+ p.curErr("not a valid parameter expansion operator: %v", p.tok)
+ case pe.Excl && p.r == '}':
+ if !p.lang.isBash() {
+ p.posErr(pe.Pos(), `"${!foo`+p.tok.String()+`}" is a bash feature`)
+ }
+ pe.Names = ParNamesOperator(p.tok)
+ p.next()
+ default:
+ pe.Exp = p.paramExpExp()
+ }
+ case plus, colPlus, minus, colMinus, quest, colQuest, assgn, colAssgn,
+ perc, dblPerc, hash, dblHash:
+ pe.Exp = p.paramExpExp()
+ case _EOF:
+ default:
+ p.curErr("not a valid parameter expansion operator: %v", p.tok)
+ }
+ p.quote = old
+ pe.Rbrace = p.pos
+ p.matched(pe.Dollar, dollBrace, rightBrace)
+ return pe
+}
+
+func (p *Parser) paramExpExp() *Expansion {
+ op := ParExpOperator(p.tok)
+ p.quote = paramExpExp
+ p.next()
+ if op == OtherParamOps {
+ switch p.tok {
+ case _Lit, _LitWord:
+ default:
+ p.curErr("@ expansion operator requires a literal")
+ }
+ switch p.val {
+ case "a", "u", "A", "E", "K", "L", "P", "U":
+ if !p.lang.isBash() {
+ p.langErr(p.pos, "this expansion operator", LangBash)
+ }
+ case "#":
+ if p.lang != LangMirBSDKorn {
+ p.langErr(p.pos, "this expansion operator", LangMirBSDKorn)
+ }
+ case "Q":
+ default:
+ p.curErr("invalid @ expansion operator")
+ }
+ }
+ return &Expansion{Op: op, Word: p.getWord()}
+}
+
+func (p *Parser) eitherIndex() ArithmExpr {
+ old := p.quote
+ lpos := p.pos
+ p.quote = arithmExprBrack
+ p.next()
+ if p.tok == star || p.tok == at {
+ p.tok, p.val = _LitWord, p.tok.String()
+ }
+ expr := p.followArithm(leftBrack, lpos)
+ p.quote = old
+ p.matchedArithm(lpos, leftBrack, rightBrack)
+ return expr
+}
+
+func (p *Parser) stopToken() bool {
+ switch p.tok {
+ case _EOF, _Newl, semicolon, and, or, andAnd, orOr, orAnd, dblSemicolon,
+ semiAnd, dblSemiAnd, semiOr, rightParen:
+ return true
+ case bckQuote:
+ return p.backquoteEnd()
+ }
+ return false
+}
+
+func (p *Parser) backquoteEnd() bool {
+ return p.lastBquoteEsc < p.openBquotes
+}
+
+// ValidName returns whether val is a valid name as per the POSIX spec.
+func ValidName(val string) bool {
+ if val == "" {
+ return false
+ }
+ for i, r := range val {
+ switch {
+ case 'a' <= r && r <= 'z':
+ case 'A' <= r && r <= 'Z':
+ case r == '_':
+ case i > 0 && '0' <= r && r <= '9':
+ default:
+ return false
+ }
+ }
+ return true
+}
+
+func numberLiteral(val string) bool {
+ for _, r := range val {
+ if '0' > r || r > '9' {
+ return false
+ }
+ }
+ return true
+}
+
+func (p *Parser) hasValidIdent() bool {
+ if p.tok != _Lit && p.tok != _LitWord {
+ return false
+ }
+ if end := p.eqlOffs; end > 0 {
+ if p.val[end-1] == '+' && p.lang != LangPOSIX {
+ end-- // a+=x
+ }
+ if ValidName(p.val[:end]) {
+ return true
+ }
+ } else if !ValidName(p.val) {
+ return false // *[i]=x
+ }
+ return p.r == '[' // a[i]=x
+}
+
+func (p *Parser) getAssign(needEqual bool) *Assign {
+ as := &Assign{}
+ if p.eqlOffs > 0 { // foo=bar
+ nameEnd := p.eqlOffs
+ if p.lang != LangPOSIX && p.val[p.eqlOffs-1] == '+' {
+ // a+=b
+ as.Append = true
+ nameEnd--
+ }
+ as.Name = p.lit(p.pos, p.val[:nameEnd])
+ // since we're not using the entire p.val
+ as.Name.ValueEnd = posAddCol(as.Name.ValuePos, nameEnd)
+ left := p.lit(posAddCol(p.pos, 1), p.val[p.eqlOffs+1:])
+ if left.Value != "" {
+ left.ValuePos = posAddCol(left.ValuePos, p.eqlOffs)
+ as.Value = p.wordOne(left)
+ }
+ p.next()
+ } else { // foo[x]=bar
+ as.Name = p.lit(p.pos, p.val)
+ // hasValidIdent already checks p.r is '['
+ p.rune()
+ p.pos = posAddCol(p.pos, 1)
+ as.Index = p.eitherIndex()
+ if p.spaced || p.stopToken() {
+ if needEqual {
+ p.followErr(as.Pos(), "a[b]", "=")
+ } else {
+ as.Naked = true
+ return as
+ }
+ }
+ if len(p.val) > 0 && p.val[0] == '+' {
+ as.Append = true
+ p.val = p.val[1:]
+ p.pos = posAddCol(p.pos, 1)
+ }
+ if len(p.val) < 1 || p.val[0] != '=' {
+ if as.Append {
+ p.followErr(as.Pos(), "a[b]+", "=")
+ } else {
+ p.followErr(as.Pos(), "a[b]", "=")
+ }
+ return nil
+ }
+ p.pos = posAddCol(p.pos, 1)
+ p.val = p.val[1:]
+ if p.val == "" {
+ p.next()
+ }
+ }
+ if p.spaced || p.stopToken() {
+ return as
+ }
+ if as.Value == nil && p.tok == leftParen {
+ if p.lang == LangPOSIX {
+ p.langErr(p.pos, "arrays", LangBash, LangMirBSDKorn)
+ }
+ if as.Index != nil {
+ p.curErr("arrays cannot be nested")
+ }
+ as.Array = &ArrayExpr{Lparen: p.pos}
+ newQuote := p.quote
+ if p.lang.isBash() {
+ newQuote = arrayElems
+ }
+ old := p.preNested(newQuote)
+ p.next()
+ p.got(_Newl)
+ for p.tok != _EOF && p.tok != rightParen {
+ ae := &ArrayElem{}
+ ae.Comments, p.accComs = p.accComs, nil
+ if p.tok == leftBrack {
+ left := p.pos
+ ae.Index = p.eitherIndex()
+ p.follow(left, `"[x]"`, assgn)
+ }
+ if ae.Value = p.getWord(); ae.Value == nil {
+ switch p.tok {
+ case leftParen:
+ p.curErr("arrays cannot be nested")
+ return nil
+ case _Newl, rightParen, leftBrack:
+ // TODO: support [index]=[
+ default:
+ p.curErr("array element values must be words")
+ return nil
+ }
+ }
+ if len(p.accComs) > 0 {
+ c := p.accComs[0]
+ if c.Pos().Line() == ae.End().Line() {
+ ae.Comments = append(ae.Comments, c)
+ p.accComs = p.accComs[1:]
+ }
+ }
+ as.Array.Elems = append(as.Array.Elems, ae)
+ p.got(_Newl)
+ }
+ as.Array.Last, p.accComs = p.accComs, nil
+ p.postNested(old)
+ as.Array.Rparen = p.matched(as.Array.Lparen, leftParen, rightParen)
+ } else if w := p.getWord(); w != nil {
+ if as.Value == nil {
+ as.Value = w
+ } else {
+ as.Value.Parts = append(as.Value.Parts, w.Parts...)
+ }
+ }
+ return as
+}
+
+func (p *Parser) peekRedir() bool {
+ switch p.tok {
+ case rdrOut, appOut, rdrIn, dplIn, dplOut, clbOut, rdrInOut,
+ hdoc, dashHdoc, wordHdoc, rdrAll, appAll, _LitRedir:
+ return true
+ }
+ return false
+}
+
+func (p *Parser) doRedirect(s *Stmt) {
+ var r *Redirect
+ if s.Redirs == nil {
+ var alloc struct {
+ redirs [4]*Redirect
+ redir Redirect
+ }
+ s.Redirs = alloc.redirs[:0]
+ r = &alloc.redir
+ s.Redirs = append(s.Redirs, r)
+ } else {
+ r = &Redirect{}
+ s.Redirs = append(s.Redirs, r)
+ }
+ r.N = p.getLit()
+ if !p.lang.isBash() && r.N != nil && r.N.Value[0] == '{' {
+ p.langErr(r.N.Pos(), "{varname} redirects", LangBash)
+ }
+ if p.lang == LangPOSIX && (p.tok == rdrAll || p.tok == appAll) {
+ p.langErr(p.pos, "&> redirects", LangBash, LangMirBSDKorn)
+ }
+ r.Op, r.OpPos = RedirOperator(p.tok), p.pos
+ p.next()
+ switch r.Op {
+ case Hdoc, DashHdoc:
+ old := p.quote
+ p.quote, p.forbidNested = hdocWord, true
+ p.heredocs = append(p.heredocs, r)
+ r.Word = p.followWordTok(token(r.Op), r.OpPos)
+ p.quote, p.forbidNested = old, false
+ if p.tok == _Newl {
+ if len(p.accComs) > 0 {
+ c := p.accComs[0]
+ if c.Pos().Line() == s.End().Line() {
+ s.Comments = append(s.Comments, c)
+ p.accComs = p.accComs[1:]
+ }
+ }
+ p.doHeredocs()
+ }
+ case WordHdoc:
+ if p.lang == LangPOSIX {
+ p.langErr(r.OpPos, "herestrings", LangBash, LangMirBSDKorn)
+ }
+ fallthrough
+ default:
+ r.Word = p.followWordTok(token(r.Op), r.OpPos)
+ }
+}
+
+func (p *Parser) getStmt(readEnd, binCmd, fnBody bool) *Stmt {
+ pos, ok := p.gotRsrv("!")
+ s := p.stmt(pos)
+ if ok {
+ s.Negated = true
+ if p.stopToken() {
+ p.posErr(s.Pos(), `"!" cannot form a statement alone`)
+ }
+ if _, ok := p.gotRsrv("!"); ok {
+ p.posErr(s.Pos(), `cannot negate a command multiple times`)
+ }
+ }
+ if s = p.gotStmtPipe(s, false); s == nil || p.err != nil {
+ return nil
+ }
+ // instead of using recursion, iterate manually
+ for p.tok == andAnd || p.tok == orOr {
+ if binCmd {
+ // left associativity: in a list of BinaryCmds, the
+ // right recursion should only read a single element
+ return s
+ }
+ b := &BinaryCmd{
+ OpPos: p.pos,
+ Op: BinCmdOperator(p.tok),
+ X: s,
+ }
+ p.next()
+ p.got(_Newl)
+ b.Y = p.getStmt(false, true, false)
+ if b.Y == nil || p.err != nil {
+ p.followErr(b.OpPos, b.Op.String(), "a statement")
+ return nil
+ }
+ s = p.stmt(s.Position)
+ s.Cmd = b
+ s.Comments, b.X.Comments = b.X.Comments, nil
+ }
+ if readEnd {
+ switch p.tok {
+ case semicolon:
+ s.Semicolon = p.pos
+ p.next()
+ case and:
+ s.Semicolon = p.pos
+ p.next()
+ s.Background = true
+ case orAnd:
+ s.Semicolon = p.pos
+ p.next()
+ s.Coprocess = true
+ }
+ }
+ if len(p.accComs) > 0 && !binCmd && !fnBody {
+ c := p.accComs[0]
+ if c.Pos().Line() == s.End().Line() {
+ s.Comments = append(s.Comments, c)
+ p.accComs = p.accComs[1:]
+ }
+ }
+ return s
+}
+
+func (p *Parser) gotStmtPipe(s *Stmt, binCmd bool) *Stmt {
+ s.Comments, p.accComs = p.accComs, nil
+ switch p.tok {
+ case _LitWord:
+ switch p.val {
+ case "{":
+ p.block(s)
+ case "if":
+ p.ifClause(s)
+ case "while", "until":
+ p.whileClause(s, p.val == "until")
+ case "for":
+ p.forClause(s)
+ case "case":
+ p.caseClause(s)
+ case "}":
+ p.curErr(`%q can only be used to close a block`, p.val)
+ case "then":
+ p.curErr(`%q can only be used in an if`, p.val)
+ case "elif":
+ p.curErr(`%q can only be used in an if`, p.val)
+ case "fi":
+ p.curErr(`%q can only be used to end an if`, p.val)
+ case "do":
+ p.curErr(`%q can only be used in a loop`, p.val)
+ case "done":
+ p.curErr(`%q can only be used to end a loop`, p.val)
+ case "esac":
+ p.curErr(`%q can only be used to end a case`, p.val)
+ case "!":
+ if !s.Negated {
+ p.curErr(`"!" can only be used in full statements`)
+ break
+ }
+ case "[[":
+ if p.lang != LangPOSIX {
+ p.testClause(s)
+ }
+ case "]]":
+ if p.lang != LangPOSIX {
+ p.curErr(`%q can only be used to close a test`, p.val)
+ }
+ case "let":
+ if p.lang != LangPOSIX {
+ p.letClause(s)
+ }
+ case "function":
+ if p.lang != LangPOSIX {
+ p.bashFuncDecl(s)
+ }
+ case "declare":
+ if p.lang.isBash() { // Note that mksh lacks this one.
+ p.declClause(s)
+ }
+ case "local", "export", "readonly", "typeset", "nameref":
+ if p.lang != LangPOSIX {
+ p.declClause(s)
+ }
+ case "time":
+ if p.lang != LangPOSIX {
+ p.timeClause(s)
+ }
+ case "coproc":
+ if p.lang.isBash() { // Note that mksh lacks this one.
+ p.coprocClause(s)
+ }
+ case "select":
+ if p.lang != LangPOSIX {
+ p.selectClause(s)
+ }
+ case "@test":
+ if p.lang == LangBats {
+ p.testDecl(s)
+ }
+ }
+ if s.Cmd != nil {
+ break
+ }
+ if p.hasValidIdent() {
+ p.callExpr(s, nil, true)
+ break
+ }
+ name := p.lit(p.pos, p.val)
+ if p.next(); p.got(leftParen) {
+ p.follow(name.ValuePos, "foo(", rightParen)
+ if p.lang == LangPOSIX && !ValidName(name.Value) {
+ p.posErr(name.Pos(), "invalid func name")
+ }
+ p.funcDecl(s, name, name.ValuePos, true)
+ } else {
+ p.callExpr(s, p.wordOne(name), false)
+ }
+ case rdrOut, appOut, rdrIn, dplIn, dplOut, clbOut, rdrInOut,
+ hdoc, dashHdoc, wordHdoc, rdrAll, appAll, _LitRedir:
+ p.doRedirect(s)
+ p.callExpr(s, nil, false)
+ case bckQuote:
+ if p.backquoteEnd() {
+ return nil
+ }
+ fallthrough
+ case _Lit, dollBrace, dollDblParen, dollParen, dollar, cmdIn, cmdOut,
+ sglQuote, dollSglQuote, dblQuote, dollDblQuote, dollBrack,
+ globQuest, globStar, globPlus, globAt, globExcl:
+ if p.hasValidIdent() {
+ p.callExpr(s, nil, true)
+ break
+ }
+ w := p.wordAnyNumber()
+ if p.got(leftParen) {
+ p.posErr(w.Pos(), "invalid func name")
+ }
+ p.callExpr(s, w, false)
+ case leftParen:
+ p.subshell(s)
+ case dblLeftParen:
+ p.arithmExpCmd(s)
+ default:
+ if len(s.Redirs) == 0 {
+ return nil
+ }
+ }
+ for p.peekRedir() {
+ p.doRedirect(s)
+ }
+ // instead of using recursion, iterate manually
+ for p.tok == or || p.tok == orAnd {
+ if binCmd {
+ // left associativity: in a list of BinaryCmds, the
+ // right recursion should only read a single element
+ return s
+ }
+ if p.tok == orAnd && p.lang == LangMirBSDKorn {
+ // No need to check for LangPOSIX, as on that language
+ // we parse |& as two tokens.
+ break
+ }
+ b := &BinaryCmd{OpPos: p.pos, Op: BinCmdOperator(p.tok), X: s}
+ p.next()
+ p.got(_Newl)
+ if b.Y = p.gotStmtPipe(p.stmt(p.pos), true); b.Y == nil || p.err != nil {
+ p.followErr(b.OpPos, b.Op.String(), "a statement")
+ break
+ }
+ s = p.stmt(s.Position)
+ s.Cmd = b
+ s.Comments, b.X.Comments = b.X.Comments, nil
+ // in "! x | y", the bang applies to the entire pipeline
+ s.Negated = b.X.Negated
+ b.X.Negated = false
+ }
+ return s
+}
+
+func (p *Parser) subshell(s *Stmt) {
+ sub := &Subshell{Lparen: p.pos}
+ old := p.preNested(subCmd)
+ p.next()
+ sub.Stmts, sub.Last = p.stmtList()
+ p.postNested(old)
+ sub.Rparen = p.matched(sub.Lparen, leftParen, rightParen)
+ s.Cmd = sub
+}
+
+func (p *Parser) arithmExpCmd(s *Stmt) {
+ ar := &ArithmCmd{Left: p.pos}
+ old := p.preNested(arithmExprCmd)
+ p.next()
+ if p.got(hash) {
+ if p.lang != LangMirBSDKorn {
+ p.langErr(ar.Pos(), "unsigned expressions", LangMirBSDKorn)
+ }
+ ar.Unsigned = true
+ }
+ ar.X = p.followArithm(dblLeftParen, ar.Left)
+ ar.Right = p.arithmEnd(dblLeftParen, ar.Left, old)
+ s.Cmd = ar
+}
+
+func (p *Parser) block(s *Stmt) {
+ b := &Block{Lbrace: p.pos}
+ p.next()
+ b.Stmts, b.Last = p.stmtList("}")
+ pos, ok := p.gotRsrv("}")
+ b.Rbrace = pos
+ if !ok {
+ p.matchingErr(b.Lbrace, "{", "}")
+ }
+ s.Cmd = b
+}
+
+func (p *Parser) ifClause(s *Stmt) {
+ rootIf := &IfClause{Position: p.pos}
+ p.next()
+ rootIf.Cond, rootIf.CondLast = p.followStmts("if", rootIf.Position, "then")
+ rootIf.ThenPos = p.followRsrv(rootIf.Position, "if ", "then")
+ rootIf.Then, rootIf.ThenLast = p.followStmts("then", rootIf.ThenPos, "fi", "elif", "else")
+ curIf := rootIf
+ for p.tok == _LitWord && p.val == "elif" {
+ elf := &IfClause{Position: p.pos}
+ curIf.Last = p.accComs
+ p.accComs = nil
+ p.next()
+ elf.Cond, elf.CondLast = p.followStmts("elif", elf.Position, "then")
+ elf.ThenPos = p.followRsrv(elf.Position, "elif ", "then")
+ elf.Then, elf.ThenLast = p.followStmts("then", elf.ThenPos, "fi", "elif", "else")
+ curIf.Else = elf
+ curIf = elf
+ }
+ if elsePos, ok := p.gotRsrv("else"); ok {
+ curIf.Last = p.accComs
+ p.accComs = nil
+ els := &IfClause{Position: elsePos}
+ els.Then, els.ThenLast = p.followStmts("else", els.Position, "fi")
+ curIf.Else = els
+ curIf = els
+ }
+ curIf.Last = p.accComs
+ p.accComs = nil
+ rootIf.FiPos = p.stmtEnd(rootIf, "if", "fi")
+ for els := rootIf.Else; els != nil; els = els.Else {
+ // All the nested IfClauses share the same FiPos.
+ els.FiPos = rootIf.FiPos
+ }
+ s.Cmd = rootIf
+}
+
+func (p *Parser) whileClause(s *Stmt, until bool) {
+ wc := &WhileClause{WhilePos: p.pos, Until: until}
+ rsrv := "while"
+ rsrvCond := "while "
+ if wc.Until {
+ rsrv = "until"
+ rsrvCond = "until "
+ }
+ p.next()
+ wc.Cond, wc.CondLast = p.followStmts(rsrv, wc.WhilePos, "do")
+ wc.DoPos = p.followRsrv(wc.WhilePos, rsrvCond, "do")
+ wc.Do, wc.DoLast = p.followStmts("do", wc.DoPos, "done")
+ wc.DonePos = p.stmtEnd(wc, rsrv, "done")
+ s.Cmd = wc
+}
+
+func (p *Parser) forClause(s *Stmt) {
+ fc := &ForClause{ForPos: p.pos}
+ p.next()
+ fc.Loop = p.loop(fc.ForPos)
+
+ start, end := "do", "done"
+ if pos, ok := p.gotRsrv("{"); ok {
+ if p.lang == LangPOSIX {
+ p.langErr(pos, "for loops with braces", LangBash, LangMirBSDKorn)
+ }
+ fc.DoPos = pos
+ fc.Braces = true
+ start, end = "{", "}"
+ } else {
+ fc.DoPos = p.followRsrv(fc.ForPos, "for foo [in words]", start)
+ }
+
+ s.Comments = append(s.Comments, p.accComs...)
+ p.accComs = nil
+ fc.Do, fc.DoLast = p.followStmts(start, fc.DoPos, end)
+ fc.DonePos = p.stmtEnd(fc, "for", end)
+ s.Cmd = fc
+}
+
+func (p *Parser) loop(fpos Pos) Loop {
+ if !p.lang.isBash() {
+ switch p.tok {
+ case leftParen, dblLeftParen:
+ p.langErr(p.pos, "c-style fors", LangBash)
+ }
+ }
+ if p.tok == dblLeftParen {
+ cl := &CStyleLoop{Lparen: p.pos}
+ old := p.preNested(arithmExprCmd)
+ p.next()
+ cl.Init = p.arithmExpr(false)
+ if !p.got(dblSemicolon) {
+ p.follow(p.pos, "expr", semicolon)
+ cl.Cond = p.arithmExpr(false)
+ p.follow(p.pos, "expr", semicolon)
+ }
+ cl.Post = p.arithmExpr(false)
+ cl.Rparen = p.arithmEnd(dblLeftParen, cl.Lparen, old)
+ p.got(semicolon)
+ p.got(_Newl)
+ return cl
+ }
+ return p.wordIter("for", fpos)
+}
+
+func (p *Parser) wordIter(ftok string, fpos Pos) *WordIter {
+ wi := &WordIter{}
+ if wi.Name = p.getLit(); wi.Name == nil {
+ p.followErr(fpos, ftok, "a literal")
+ }
+ if p.got(semicolon) {
+ p.got(_Newl)
+ return wi
+ }
+ p.got(_Newl)
+ if pos, ok := p.gotRsrv("in"); ok {
+ wi.InPos = pos
+ for !p.stopToken() {
+ if w := p.getWord(); w == nil {
+ p.curErr("word list can only contain words")
+ } else {
+ wi.Items = append(wi.Items, w)
+ }
+ }
+ p.got(semicolon)
+ p.got(_Newl)
+ } else if p.tok == _LitWord && p.val == "do" {
+ } else {
+ p.followErr(fpos, ftok+" foo", `"in", "do", ;, or a newline`)
+ }
+ return wi
+}
+
+func (p *Parser) selectClause(s *Stmt) {
+ fc := &ForClause{ForPos: p.pos, Select: true}
+ p.next()
+ fc.Loop = p.wordIter("select", fc.ForPos)
+ fc.DoPos = p.followRsrv(fc.ForPos, "select foo [in words]", "do")
+ fc.Do, fc.DoLast = p.followStmts("do", fc.DoPos, "done")
+ fc.DonePos = p.stmtEnd(fc, "select", "done")
+ s.Cmd = fc
+}
+
+func (p *Parser) caseClause(s *Stmt) {
+ cc := &CaseClause{Case: p.pos}
+ p.next()
+ cc.Word = p.getWord()
+ if cc.Word == nil {
+ p.followErr(cc.Case, "case", "a word")
+ }
+ end := "esac"
+ p.got(_Newl)
+ if pos, ok := p.gotRsrv("{"); ok {
+ cc.In = pos
+ cc.Braces = true
+ if p.lang != LangMirBSDKorn {
+ p.posErr(cc.Pos(), `"case i {" is a mksh feature`)
+ }
+ end = "}"
+ } else {
+ cc.In = p.followRsrv(cc.Case, "case x", "in")
+ }
+ cc.Items = p.caseItems(end)
+ cc.Last, p.accComs = p.accComs, nil
+ cc.Esac = p.stmtEnd(cc, "case", end)
+ s.Cmd = cc
+}
+
+func (p *Parser) caseItems(stop string) (items []*CaseItem) {
+ p.got(_Newl)
+ for p.tok != _EOF && (p.tok != _LitWord || p.val != stop) {
+ ci := &CaseItem{}
+ ci.Comments, p.accComs = p.accComs, nil
+ p.got(leftParen)
+ for p.tok != _EOF {
+ if w := p.getWord(); w == nil {
+ p.curErr("case patterns must consist of words")
+ } else {
+ ci.Patterns = append(ci.Patterns, w)
+ }
+ if p.tok == rightParen {
+ break
+ }
+ if !p.got(or) {
+ p.curErr("case patterns must be separated with |")
+ }
+ }
+ old := p.preNested(switchCase)
+ p.next()
+ ci.Stmts, ci.Last = p.stmtList(stop)
+ p.postNested(old)
+ switch p.tok {
+ case dblSemicolon, semiAnd, dblSemiAnd, semiOr:
+ default:
+ ci.Op = Break
+ items = append(items, ci)
+ return
+ }
+ ci.Last = append(ci.Last, p.accComs...)
+ p.accComs = nil
+ ci.OpPos = p.pos
+ ci.Op = CaseOperator(p.tok)
+ p.next()
+ p.got(_Newl)
+
+ // Split the comments:
+ //
+ // case x in
+ // a)
+ // foo
+ // ;;
+ // # comment for a
+ // # comment for b
+ // b)
+ // [...]
+ split := len(p.accComs)
+ for i := len(p.accComs) - 1; i >= 0; i-- {
+ c := p.accComs[i]
+ if c.Pos().Col() != p.pos.Col() {
+ break
+ }
+ split = i
+ }
+ ci.Comments = append(ci.Comments, p.accComs[:split]...)
+ p.accComs = p.accComs[split:]
+
+ items = append(items, ci)
+ }
+ return
+}
+
+func (p *Parser) testClause(s *Stmt) {
+ tc := &TestClause{Left: p.pos}
+ old := p.preNested(testExpr)
+ p.next()
+ if _, ok := p.gotRsrv("]]"); ok || p.tok == _EOF {
+ p.posErr(tc.Left, "test clause requires at least one expression")
+ }
+ tc.X = p.testExpr(dblLeftBrack, tc.Left, false)
+ if tc.X == nil {
+ p.followErrExp(tc.Left, "[[")
+ }
+ tc.Right = p.pos
+ if _, ok := p.gotRsrv("]]"); !ok {
+ p.matchingErr(tc.Left, "[[", "]]")
+ }
+ p.postNested(old)
+ s.Cmd = tc
+}
+
+func (p *Parser) testExpr(ftok token, fpos Pos, pastAndOr bool) TestExpr {
+ p.got(_Newl)
+ var left TestExpr
+ if pastAndOr {
+ left = p.testExprBase()
+ } else {
+ left = p.testExpr(ftok, fpos, true)
+ }
+ if left == nil {
+ return left
+ }
+ p.got(_Newl)
+ switch p.tok {
+ case andAnd, orOr:
+ case _LitWord:
+ if p.val == "]]" {
+ return left
+ }
+ if p.tok = token(testBinaryOp(p.val)); p.tok == illegalTok {
+ p.curErr("not a valid test operator: %s", p.val)
+ }
+ case rdrIn, rdrOut:
+ case _EOF, rightParen:
+ return left
+ case _Lit:
+ p.curErr("test operator words must consist of a single literal")
+ default:
+ p.curErr("not a valid test operator: %v", p.tok)
+ }
+ b := &BinaryTest{
+ OpPos: p.pos,
+ Op: BinTestOperator(p.tok),
+ X: left,
+ }
+ // Save the previous quoteState, since we change it in TsReMatch.
+ oldQuote := p.quote
+
+ switch b.Op {
+ case AndTest, OrTest:
+ p.next()
+ if b.Y = p.testExpr(token(b.Op), b.OpPos, false); b.Y == nil {
+ p.followErrExp(b.OpPos, b.Op.String())
+ }
+ case TsReMatch:
+ if !p.lang.isBash() {
+ p.langErr(p.pos, "regex tests", LangBash)
+ }
+ p.rxOpenParens = 0
+ p.rxFirstPart = true
+ // TODO(mvdan): Using nested states within a regex will break in
+ // all sorts of ways. The better fix is likely to use a stop
+ // token, like we do with heredocs.
+ p.quote = testExprRegexp
+ fallthrough
+ default:
+ if _, ok := b.X.(*Word); !ok {
+ p.posErr(b.OpPos, "expected %s, %s or %s after complex expr",
+ AndTest, OrTest, "]]")
+ }
+ p.next()
+ b.Y = p.followWordTok(token(b.Op), b.OpPos)
+ }
+ p.quote = oldQuote
+ return b
+}
+
+func (p *Parser) testExprBase() TestExpr {
+ switch p.tok {
+ case _EOF, rightParen:
+ return nil
+ case _LitWord:
+ op := token(testUnaryOp(p.val))
+ switch op {
+ case illegalTok:
+ case tsRefVar, tsModif: // not available in mksh
+ if p.lang.isBash() {
+ p.tok = op
+ }
+ default:
+ p.tok = op
+ }
+ }
+ switch p.tok {
+ case exclMark:
+ u := &UnaryTest{OpPos: p.pos, Op: TsNot}
+ p.next()
+ if u.X = p.testExpr(token(u.Op), u.OpPos, false); u.X == nil {
+ p.followErrExp(u.OpPos, u.Op.String())
+ }
+ return u
+ case tsExists, tsRegFile, tsDirect, tsCharSp, tsBlckSp, tsNmPipe,
+ tsSocket, tsSmbLink, tsSticky, tsGIDSet, tsUIDSet, tsGrpOwn,
+ tsUsrOwn, tsModif, tsRead, tsWrite, tsExec, tsNoEmpty,
+ tsFdTerm, tsEmpStr, tsNempStr, tsOptSet, tsVarSet, tsRefVar:
+ u := &UnaryTest{OpPos: p.pos, Op: UnTestOperator(p.tok)}
+ p.next()
+ u.X = p.followWordTok(token(u.Op), u.OpPos)
+ return u
+ case leftParen:
+ pe := &ParenTest{Lparen: p.pos}
+ p.next()
+ if pe.X = p.testExpr(leftParen, pe.Lparen, false); pe.X == nil {
+ p.followErrExp(pe.Lparen, "(")
+ }
+ pe.Rparen = p.matched(pe.Lparen, leftParen, rightParen)
+ return pe
+ case _LitWord:
+ if p.val == "]]" {
+ return nil
+ }
+ fallthrough
+ default:
+ if w := p.getWord(); w != nil {
+ return w
+ }
+ // otherwise we'd return a typed nil above
+ return nil
+ }
+}
+
+func (p *Parser) declClause(s *Stmt) {
+ ds := &DeclClause{Variant: p.lit(p.pos, p.val)}
+ p.next()
+ for !p.stopToken() && !p.peekRedir() {
+ if p.hasValidIdent() {
+ ds.Args = append(ds.Args, p.getAssign(false))
+ } else if p.eqlOffs > 0 {
+ p.curErr("invalid var name")
+ } else if p.tok == _LitWord && ValidName(p.val) {
+ ds.Args = append(ds.Args, &Assign{
+ Naked: true,
+ Name: p.getLit(),
+ })
+ } else if w := p.getWord(); w != nil {
+ ds.Args = append(ds.Args, &Assign{
+ Naked: true,
+ Value: w,
+ })
+ } else {
+ p.followErr(p.pos, ds.Variant.Value, "names or assignments")
+ }
+ }
+ s.Cmd = ds
+}
+
+func isBashCompoundCommand(tok token, val string) bool {
+ switch tok {
+ case leftParen, dblLeftParen:
+ return true
+ case _LitWord:
+ switch val {
+ case "{", "if", "while", "until", "for", "case", "[[",
+ "coproc", "let", "function", "declare", "local",
+ "export", "readonly", "typeset", "nameref":
+ return true
+ }
+ }
+ return false
+}
+
+func (p *Parser) timeClause(s *Stmt) {
+ tc := &TimeClause{Time: p.pos}
+ p.next()
+ if _, ok := p.gotRsrv("-p"); ok {
+ tc.PosixFormat = true
+ }
+ tc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
+ s.Cmd = tc
+}
+
+func (p *Parser) coprocClause(s *Stmt) {
+ cc := &CoprocClause{Coproc: p.pos}
+ if p.next(); isBashCompoundCommand(p.tok, p.val) {
+ // has no name
+ cc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
+ s.Cmd = cc
+ return
+ }
+ cc.Name = p.getWord()
+ cc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
+ if cc.Stmt == nil {
+ if cc.Name == nil {
+ p.posErr(cc.Coproc, "coproc clause requires a command")
+ return
+ }
+ // name was in fact the stmt
+ cc.Stmt = p.stmt(cc.Name.Pos())
+ cc.Stmt.Cmd = p.call(cc.Name)
+ cc.Name = nil
+ } else if cc.Name != nil {
+ if call, ok := cc.Stmt.Cmd.(*CallExpr); ok {
+ // name was in fact the start of a call
+ call.Args = append([]*Word{cc.Name}, call.Args...)
+ cc.Name = nil
+ }
+ }
+ s.Cmd = cc
+}
+
+func (p *Parser) letClause(s *Stmt) {
+ lc := &LetClause{Let: p.pos}
+ old := p.preNested(arithmExprLet)
+ p.next()
+ for !p.stopToken() && !p.peekRedir() {
+ x := p.arithmExpr(true)
+ if x == nil {
+ break
+ }
+ lc.Exprs = append(lc.Exprs, x)
+ }
+ if len(lc.Exprs) == 0 {
+ p.followErrExp(lc.Let, "let")
+ }
+ p.postNested(old)
+ s.Cmd = lc
+}
+
+func (p *Parser) bashFuncDecl(s *Stmt) {
+ fpos := p.pos
+ if p.next(); p.tok != _LitWord {
+ p.followErr(fpos, "function", "a name")
+ }
+ name := p.lit(p.pos, p.val)
+ hasParens := false
+ if p.next(); p.got(leftParen) {
+ hasParens = true
+ p.follow(name.ValuePos, "foo(", rightParen)
+ }
+ p.funcDecl(s, name, fpos, hasParens)
+}
+
+func (p *Parser) testDecl(s *Stmt) {
+ td := &TestDecl{Position: p.pos}
+ p.next()
+ if td.Description = p.getWord(); td.Description == nil {
+ p.followErr(td.Position, "@test", "a description word")
+ }
+ if td.Body = p.getStmt(false, false, true); td.Body == nil {
+ p.followErr(td.Position, `@test "desc"`, "a statement")
+ }
+ s.Cmd = td
+}
+
+func (p *Parser) callExpr(s *Stmt, w *Word, assign bool) {
+ ce := p.call(w)
+ if w == nil {
+ ce.Args = ce.Args[:0]
+ }
+ if assign {
+ ce.Assigns = append(ce.Assigns, p.getAssign(true))
+ }
+loop:
+ for {
+ switch p.tok {
+ case _EOF, _Newl, semicolon, and, or, andAnd, orOr, orAnd,
+ dblSemicolon, semiAnd, dblSemiAnd, semiOr:
+ break loop
+ case _LitWord:
+ if len(ce.Args) == 0 && p.hasValidIdent() {
+ ce.Assigns = append(ce.Assigns, p.getAssign(true))
+ break
+ }
+ ce.Args = append(ce.Args, p.wordOne(p.lit(p.pos, p.val)))
+ p.next()
+ case _Lit:
+ if len(ce.Args) == 0 && p.hasValidIdent() {
+ ce.Assigns = append(ce.Assigns, p.getAssign(true))
+ break
+ }
+ ce.Args = append(ce.Args, p.wordAnyNumber())
+ case bckQuote:
+ if p.backquoteEnd() {
+ break loop
+ }
+ fallthrough
+ case dollBrace, dollDblParen, dollParen, dollar, cmdIn, cmdOut,
+ sglQuote, dollSglQuote, dblQuote, dollDblQuote, dollBrack,
+ globQuest, globStar, globPlus, globAt, globExcl:
+ ce.Args = append(ce.Args, p.wordAnyNumber())
+ case rdrOut, appOut, rdrIn, dplIn, dplOut, clbOut, rdrInOut,
+ hdoc, dashHdoc, wordHdoc, rdrAll, appAll, _LitRedir:
+ p.doRedirect(s)
+ case dblLeftParen:
+ p.curErr("%s can only be used to open an arithmetic cmd", p.tok)
+ case rightParen:
+ if p.quote == subCmd {
+ break loop
+ }
+ fallthrough
+ default:
+ // Note that we'll only keep the first error that happens.
+ if len(ce.Args) > 0 {
+ if cmd := ce.Args[0].Lit(); p.lang == LangPOSIX && isBashCompoundCommand(_LitWord, cmd) {
+ p.curErr("the %q builtin exists in bash; tried parsing as posix", cmd)
+ }
+ }
+ p.curErr("a command can only contain words and redirects; encountered %s", p.tok)
+ }
+ }
+ if len(ce.Assigns) == 0 && len(ce.Args) == 0 {
+ return
+ }
+ if len(ce.Args) == 0 {
+ ce.Args = nil
+ } else {
+ for _, asgn := range ce.Assigns {
+ if asgn.Index != nil || asgn.Array != nil {
+ p.posErr(asgn.Pos(), "inline variables cannot be arrays")
+ }
+ }
+ }
+ s.Cmd = ce
+}
+
+func (p *Parser) funcDecl(s *Stmt, name *Lit, pos Pos, withParens bool) {
+ fd := &FuncDecl{
+ Position: pos,
+ RsrvWord: pos != name.ValuePos,
+ Parens: withParens,
+ Name: name,
+ }
+ p.got(_Newl)
+ if fd.Body = p.getStmt(false, false, true); fd.Body == nil {
+ p.followErr(fd.Pos(), "foo()", "a statement")
+ }
+ s.Cmd = fd
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/parser_arithm.go b/vendor/mvdan.cc/sh/v3/syntax/parser_arithm.go
new file mode 100644
index 00000000..a6d6a951
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/parser_arithm.go
@@ -0,0 +1,353 @@
+package syntax
+
+// compact specifies whether we allow spaces between expressions.
+// This is true for let
+func (p *Parser) arithmExpr(compact bool) ArithmExpr {
+ return p.arithmExprComma(compact)
+}
+
+// These function names are inspired by Bash's expr.c
+
+func (p *Parser) arithmExprComma(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprAssign, Comma)
+}
+
+func (p *Parser) arithmExprAssign(compact bool) ArithmExpr {
+ // Assign is different from the other binary operators because it's
+ // right-associative and needs to check that it's placed after a name
+ value := p.arithmExprTernary(compact)
+ switch BinAritOperator(p.tok) {
+ case AddAssgn, SubAssgn, MulAssgn, QuoAssgn, RemAssgn, AndAssgn,
+ OrAssgn, XorAssgn, ShlAssgn, ShrAssgn, Assgn:
+ if compact && p.spaced {
+ return value
+ }
+ if !isArithName(value) {
+ p.posErr(p.pos, "%s must follow a name", p.tok.String())
+ }
+ pos := p.pos
+ tok := p.tok
+ p.nextArithOp(compact)
+ y := p.arithmExprAssign(compact)
+ if y == nil {
+ p.followErrExp(pos, tok.String())
+ }
+ return &BinaryArithm{
+ OpPos: pos,
+ Op: BinAritOperator(tok),
+ X: value,
+ Y: y,
+ }
+ }
+ return value
+}
+
+func (p *Parser) arithmExprTernary(compact bool) ArithmExpr {
+ value := p.arithmExprLor(compact)
+ if BinAritOperator(p.tok) != TernQuest || (compact && p.spaced) {
+ return value
+ }
+
+ if value == nil {
+ p.curErr("%s must follow an expression", p.tok.String())
+ }
+ questPos := p.pos
+ p.nextArithOp(compact)
+ if BinAritOperator(p.tok) == TernColon {
+ p.followErrExp(questPos, TernQuest.String())
+ }
+ trueExpr := p.arithmExpr(compact)
+ if trueExpr == nil {
+ p.followErrExp(questPos, TernQuest.String())
+ }
+ if BinAritOperator(p.tok) != TernColon {
+ p.posErr(questPos, "ternary operator missing : after ?")
+ }
+ colonPos := p.pos
+ p.nextArithOp(compact)
+ falseExpr := p.arithmExprTernary(compact)
+ if falseExpr == nil {
+ p.followErrExp(colonPos, TernColon.String())
+ }
+ return &BinaryArithm{
+ OpPos: questPos,
+ Op: TernQuest,
+ X: value,
+ Y: &BinaryArithm{
+ OpPos: colonPos,
+ Op: TernColon,
+ X: trueExpr,
+ Y: falseExpr,
+ },
+ }
+}
+
+func (p *Parser) arithmExprLor(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprLand, OrArit)
+}
+
+func (p *Parser) arithmExprLand(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprBor, AndArit)
+}
+
+func (p *Parser) arithmExprBor(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprBxor, Or)
+}
+
+func (p *Parser) arithmExprBxor(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprBand, Xor)
+}
+
+func (p *Parser) arithmExprBand(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprEquality, And)
+}
+
+func (p *Parser) arithmExprEquality(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprComparison, Eql, Neq)
+}
+
+func (p *Parser) arithmExprComparison(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprShift, Lss, Gtr, Leq, Geq)
+}
+
+func (p *Parser) arithmExprShift(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprAddition, Shl, Shr)
+}
+
+func (p *Parser) arithmExprAddition(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprMultiplication, Add, Sub)
+}
+
+func (p *Parser) arithmExprMultiplication(compact bool) ArithmExpr {
+ return p.arithmExprBinary(compact, p.arithmExprPower, Mul, Quo, Rem)
+}
+
+func (p *Parser) arithmExprPower(compact bool) ArithmExpr {
+ // Power is different from the other binary operators because it's right-associative
+ value := p.arithmExprUnary(compact)
+ if BinAritOperator(p.tok) != Pow || (compact && p.spaced) {
+ return value
+ }
+
+ if value == nil {
+ p.curErr("%s must follow an expression", p.tok.String())
+ }
+
+ op := p.tok
+ pos := p.pos
+ p.nextArithOp(compact)
+ y := p.arithmExprPower(compact)
+ if y == nil {
+ p.followErrExp(pos, op.String())
+ }
+ return &BinaryArithm{
+ OpPos: pos,
+ Op: BinAritOperator(op),
+ X: value,
+ Y: y,
+ }
+}
+
+func (p *Parser) arithmExprUnary(compact bool) ArithmExpr {
+ if !compact {
+ p.got(_Newl)
+ }
+
+ switch UnAritOperator(p.tok) {
+ case Not, BitNegation, Plus, Minus:
+ ue := &UnaryArithm{OpPos: p.pos, Op: UnAritOperator(p.tok)}
+ p.nextArithOp(compact)
+ if ue.X = p.arithmExprUnary(compact); ue.X == nil {
+ p.followErrExp(ue.OpPos, ue.Op.String())
+ }
+ return ue
+ }
+ return p.arithmExprValue(compact)
+}
+
+func (p *Parser) arithmExprValue(compact bool) ArithmExpr {
+ var x ArithmExpr
+ switch p.tok {
+ case addAdd, subSub:
+ ue := &UnaryArithm{OpPos: p.pos, Op: UnAritOperator(p.tok)}
+ p.nextArith(compact)
+ if p.tok != _LitWord {
+ p.followErr(ue.OpPos, token(ue.Op).String(), "a literal")
+ }
+ ue.X = p.arithmExprValue(compact)
+ return ue
+ case leftParen:
+ pe := &ParenArithm{Lparen: p.pos}
+ p.nextArithOp(compact)
+ pe.X = p.followArithm(leftParen, pe.Lparen)
+ pe.Rparen = p.matched(pe.Lparen, leftParen, rightParen)
+ x = pe
+ case leftBrack:
+ p.curErr("[ must follow a name")
+ case colon:
+ p.curErr("ternary operator missing ? before :")
+ case _LitWord:
+ l := p.getLit()
+ if p.tok != leftBrack {
+ x = p.wordOne(l)
+ break
+ }
+ pe := &ParamExp{Dollar: l.ValuePos, Short: true, Param: l}
+ pe.Index = p.eitherIndex()
+ x = p.wordOne(pe)
+ case bckQuote:
+ if p.quote == arithmExprLet && p.openBquotes > 0 {
+ return nil
+ }
+ fallthrough
+ default:
+ if w := p.getWord(); w != nil {
+ x = w
+ } else {
+ return nil
+ }
+ }
+
+ if compact && p.spaced {
+ return x
+ }
+ if !compact {
+ p.got(_Newl)
+ }
+
+ // we want real nil, not (*Word)(nil) as that
+ // sets the type to non-nil and then x != nil
+ if p.tok == addAdd || p.tok == subSub {
+ if !isArithName(x) {
+ p.curErr("%s must follow a name", p.tok.String())
+ }
+ u := &UnaryArithm{
+ Post: true,
+ OpPos: p.pos,
+ Op: UnAritOperator(p.tok),
+ X: x,
+ }
+ p.nextArith(compact)
+ return u
+ }
+ return x
+}
+
+// nextArith consumes a token.
+// It returns true if compact and the token was followed by spaces
+func (p *Parser) nextArith(compact bool) bool {
+ p.next()
+ if compact && p.spaced {
+ return true
+ }
+ if !compact {
+ p.got(_Newl)
+ }
+ return false
+}
+
+func (p *Parser) nextArithOp(compact bool) {
+ pos := p.pos
+ tok := p.tok
+ if p.nextArith(compact) {
+ p.followErrExp(pos, tok.String())
+ }
+}
+
+// arithmExprBinary is used for all left-associative binary operators
+func (p *Parser) arithmExprBinary(compact bool, nextOp func(bool) ArithmExpr, operators ...BinAritOperator) ArithmExpr {
+ value := nextOp(compact)
+ for {
+ var foundOp BinAritOperator
+ for _, op := range operators {
+ if p.tok == token(op) {
+ foundOp = op
+ break
+ }
+ }
+
+ if token(foundOp) == illegalTok || (compact && p.spaced) {
+ return value
+ }
+
+ if value == nil {
+ p.curErr("%s must follow an expression", p.tok.String())
+ }
+
+ pos := p.pos
+ p.nextArithOp(compact)
+ y := nextOp(compact)
+ if y == nil {
+ p.followErrExp(pos, foundOp.String())
+ }
+
+ value = &BinaryArithm{
+ OpPos: pos,
+ Op: foundOp,
+ X: value,
+ Y: y,
+ }
+ }
+}
+
+func isArithName(left ArithmExpr) bool {
+ w, ok := left.(*Word)
+ if !ok || len(w.Parts) != 1 {
+ return false
+ }
+ switch x := w.Parts[0].(type) {
+ case *Lit:
+ return ValidName(x.Value)
+ case *ParamExp:
+ return x.nakedIndex()
+ default:
+ return false
+ }
+}
+
+func (p *Parser) followArithm(ftok token, fpos Pos) ArithmExpr {
+ x := p.arithmExpr(false)
+ if x == nil {
+ p.followErrExp(fpos, ftok.String())
+ }
+ return x
+}
+
+func (p *Parser) peekArithmEnd() bool {
+ return p.tok == rightParen && p.r == ')'
+}
+
+func (p *Parser) arithmMatchingErr(pos Pos, left, right token) {
+ switch p.tok {
+ case _Lit, _LitWord:
+ p.curErr("not a valid arithmetic operator: %s", p.val)
+ case leftBrack:
+ p.curErr("[ must follow a name")
+ case colon:
+ p.curErr("ternary operator missing ? before :")
+ case rightParen, _EOF:
+ p.matchingErr(pos, left, right)
+ default:
+ if p.quote == arithmExpr {
+ p.curErr("not a valid arithmetic operator: %v", p.tok)
+ }
+ p.matchingErr(pos, left, right)
+ }
+}
+
+func (p *Parser) matchedArithm(lpos Pos, left, right token) {
+ if !p.got(right) {
+ p.arithmMatchingErr(lpos, left, right)
+ }
+}
+
+func (p *Parser) arithmEnd(ltok token, lpos Pos, old saveState) Pos {
+ if !p.peekArithmEnd() {
+ p.arithmMatchingErr(lpos, ltok, dblRightParen)
+ }
+ p.rune()
+ p.postNested(old)
+ pos := p.pos
+ p.next()
+ return pos
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/printer.go b/vendor/mvdan.cc/sh/v3/syntax/printer.go
new file mode 100644
index 00000000..84ad6850
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/printer.go
@@ -0,0 +1,1530 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+ "strings"
+ "text/tabwriter"
+ "unicode"
+
+ "mvdan.cc/sh/v3/fileutil"
+)
+
+// PrinterOption is a function which can be passed to NewPrinter
+// to alter its behavior. To apply option to existing Printer
+// call it directly, for example KeepPadding(true)(printer).
+type PrinterOption func(*Printer)
+
+// Indent sets the number of spaces used for indentation. If set to 0,
+// tabs will be used instead.
+func Indent(spaces uint) PrinterOption {
+ return func(p *Printer) { p.indentSpaces = spaces }
+}
+
+// BinaryNextLine will make binary operators appear on the next line
+// when a binary command, such as a pipe, spans multiple lines. A
+// backslash will be used.
+func BinaryNextLine(enabled bool) PrinterOption {
+ return func(p *Printer) { p.binNextLine = enabled }
+}
+
+// SwitchCaseIndent will make switch cases be indented. As such, switch
+// case bodies will be two levels deeper than the switch itself.
+func SwitchCaseIndent(enabled bool) PrinterOption {
+ return func(p *Printer) { p.swtCaseIndent = enabled }
+}
+
+// TODO(v4): consider turning this into a "space all operators" option, to also
+// allow foo=( bar baz ), (( x + y )), and so on.
+
+// SpaceRedirects will put a space after most redirection operators. The
+// exceptions are '>&', '<&', '>(', and '<('.
+func SpaceRedirects(enabled bool) PrinterOption {
+ return func(p *Printer) { p.spaceRedirects = enabled }
+}
+
+// KeepPadding will keep most nodes and tokens in the same column that
+// they were in the original source. This allows the user to decide how
+// to align and pad their code with spaces.
+//
+// Note that this feature is best-effort and will only keep the
+// alignment stable, so it may need some human help the first time it is
+// run.
+func KeepPadding(enabled bool) PrinterOption {
+ return func(p *Printer) {
+ if enabled && !p.keepPadding {
+ // Enable the flag, and set up the writer wrapper.
+ p.keepPadding = true
+ p.cols.Writer = p.bufWriter.(*bufio.Writer)
+ p.bufWriter = &p.cols
+
+ } else if !enabled && p.keepPadding {
+ // Ensure we reset the state to that of NewPrinter.
+ p.keepPadding = false
+ p.bufWriter = p.cols.Writer
+ p.cols = colCounter{}
+ }
+ }
+}
+
+// Minify will print programs in a way to save the most bytes possible.
+// For example, indentation and comments are skipped, and extra
+// whitespace is avoided when possible.
+func Minify(enabled bool) PrinterOption {
+ return func(p *Printer) { p.minify = enabled }
+}
+
+// SingleLine will attempt to print programs in one line. For example, lists of
+// commands or nested blocks do not use newlines in this mode. Note that some
+// newlines must still appear, such as those following comments or around
+// here-documents.
+//
+// Print's trailing newline when given a *File is not affected by this option.
+func SingleLine(enabled bool) PrinterOption {
+ return func(p *Printer) { p.singleLine = enabled }
+}
+
+// FunctionNextLine will place a function's opening braces on the next line.
+func FunctionNextLine(enabled bool) PrinterOption {
+ return func(p *Printer) { p.funcNextLine = enabled }
+}
+
+// NewPrinter allocates a new Printer and applies any number of options.
+func NewPrinter(opts ...PrinterOption) *Printer {
+ p := &Printer{
+ bufWriter: bufio.NewWriter(nil),
+ tabWriter: new(tabwriter.Writer),
+ }
+ for _, opt := range opts {
+ opt(p)
+ }
+ return p
+}
+
+// Print "pretty-prints" the given syntax tree node to the given writer. Writes
+// to w are buffered.
+//
+// The node types supported at the moment are *File, *Stmt, *Word, *Assign, any
+// Command node, and any WordPart node. A trailing newline will only be printed
+// when a *File is used.
+func (p *Printer) Print(w io.Writer, node Node) error {
+ p.reset()
+
+ if p.minify && p.singleLine {
+ return fmt.Errorf("Minify and SingleLine together are not supported yet; please file an issue describing your use case: https://github.com/mvdan/sh/issues")
+ }
+
+ // TODO: consider adding a raw mode to skip the tab writer, much like in
+ // go/printer.
+ twmode := tabwriter.DiscardEmptyColumns | tabwriter.StripEscape
+ tabwidth := 8
+ if p.indentSpaces == 0 {
+ // indenting with tabs
+ twmode |= tabwriter.TabIndent
+ } else {
+ // indenting with spaces
+ tabwidth = int(p.indentSpaces)
+ }
+ p.tabWriter.Init(w, 0, tabwidth, 1, ' ', twmode)
+ w = p.tabWriter
+
+ p.bufWriter.Reset(w)
+ switch x := node.(type) {
+ case *File:
+ p.stmtList(x.Stmts, x.Last)
+ p.newline(Pos{})
+ case *Stmt:
+ p.stmtList([]*Stmt{x}, nil)
+ case Command:
+ p.command(x, nil)
+ case *Word:
+ p.line = x.Pos().Line()
+ p.word(x)
+ case WordPart:
+ p.line = x.Pos().Line()
+ p.wordPart(x, nil)
+ case *Assign:
+ p.line = x.Pos().Line()
+ p.assigns([]*Assign{x})
+ default:
+ return fmt.Errorf("unsupported node type: %T", x)
+ }
+ p.flushHeredocs()
+ p.flushComments()
+
+ // flush the writers
+ if err := p.bufWriter.Flush(); err != nil {
+ return err
+ }
+ if tw, _ := w.(*tabwriter.Writer); tw != nil {
+ if err := tw.Flush(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+type bufWriter interface {
+ Write([]byte) (int, error)
+ WriteString(string) (int, error)
+ WriteByte(byte) error
+ Reset(io.Writer)
+ Flush() error
+}
+
+type colCounter struct {
+ *bufio.Writer
+ column int
+ lineStart bool
+}
+
+func (c *colCounter) addByte(b byte) {
+ switch b {
+ case '\n':
+ c.column = 0
+ c.lineStart = true
+ case '\t', ' ', tabwriter.Escape:
+ default:
+ c.lineStart = false
+ }
+ c.column++
+}
+
+func (c *colCounter) WriteByte(b byte) error {
+ c.addByte(b)
+ return c.Writer.WriteByte(b)
+}
+
+func (c *colCounter) WriteString(s string) (int, error) {
+ for _, b := range []byte(s) {
+ c.addByte(b)
+ }
+ return c.Writer.WriteString(s)
+}
+
+func (c *colCounter) Reset(w io.Writer) {
+ c.column = 1
+ c.lineStart = true
+ c.Writer.Reset(w)
+}
+
+// Printer holds the internal state of the printing mechanism of a
+// program.
+type Printer struct {
+ bufWriter // TODO: embedding this makes the methods part of the API, which we did not intend
+ tabWriter *tabwriter.Writer
+ cols colCounter
+
+ indentSpaces uint
+ binNextLine bool
+ swtCaseIndent bool
+ spaceRedirects bool
+ keepPadding bool
+ minify bool
+ singleLine bool
+ funcNextLine bool
+
+ wantSpace wantSpaceState // whether space is required or has been written
+
+ wantNewline bool // newline is wanted for pretty-printing; ignored by singleLine; ignored by singleLine
+ mustNewline bool // newline is required to keep shell syntax valid
+ wroteSemi bool // wrote ';' for the current statement
+
+ // pendingComments are any comments in the current line or statement
+ // that we have yet to print. This is useful because that way, we can
+ // ensure that all comments are written immediately before a newline.
+ // Otherwise, in some edge cases we might wrongly place words after a
+ // comment in the same line, breaking programs.
+ pendingComments []Comment
+
+ // firstLine means we are still writing the first line
+ firstLine bool
+ // line is the current line number
+ line uint
+
+ // lastLevel is the last level of indentation that was used.
+ lastLevel uint
+ // level is the current level of indentation.
+ level uint
+ // levelIncs records which indentation level increments actually
+ // took place, to revert them once their section ends.
+ levelIncs []bool
+
+ nestedBinary bool
+
+ // pendingHdocs is the list of pending heredocs to write.
+ pendingHdocs []*Redirect
+
+ // used when printing <<- heredocs with tab indentation
+ tabsPrinter *Printer
+}
+
+func (p *Printer) reset() {
+ p.wantSpace = spaceWritten
+ p.wantNewline, p.mustNewline = false, false
+ p.pendingComments = p.pendingComments[:0]
+
+ // minification uses its own newline logic
+ p.firstLine = !p.minify
+ p.line = 0
+
+ p.lastLevel, p.level = 0, 0
+ p.levelIncs = p.levelIncs[:0]
+ p.nestedBinary = false
+ p.pendingHdocs = p.pendingHdocs[:0]
+}
+
+func (p *Printer) spaces(n uint) {
+ for i := uint(0); i < n; i++ {
+ p.WriteByte(' ')
+ }
+}
+
+func (p *Printer) space() {
+ p.WriteByte(' ')
+ p.wantSpace = spaceWritten
+}
+
+func (p *Printer) spacePad(pos Pos) {
+ if p.cols.lineStart && p.indentSpaces == 0 {
+ // Never add padding at the start of a line unless we are indenting
+ // with spaces, since this may result in mixing of spaces and tabs.
+ return
+ }
+ if p.wantSpace == spaceRequired {
+ p.WriteByte(' ')
+ p.wantSpace = spaceWritten
+ }
+ for p.cols.column > 0 && p.cols.column < int(pos.Col()) {
+ p.WriteByte(' ')
+ }
+}
+
+// wantsNewline reports whether we want to print at least one newline before
+// printing a node at a given position. A zero position can be given to simply
+// tell if we want a newline following what's just been printed.
+func (p *Printer) wantsNewline(pos Pos, escapingNewline bool) bool {
+ if p.mustNewline {
+ // We must have a newline here.
+ return true
+ }
+ if p.singleLine && len(p.pendingComments) == 0 {
+ // The newline is optional, and singleLine skips it.
+ // Don't skip if there are any pending comments,
+ // as that might move them further down to the wrong place.
+ return false
+ }
+ if escapingNewline && p.minify {
+ return false
+ }
+ // The newline is optional, and we want it via either wantNewline or via
+ // the position's line.
+ return p.wantNewline || pos.Line() > p.line
+}
+
+func (p *Printer) bslashNewl() {
+ if p.wantSpace == spaceRequired {
+ p.space()
+ }
+ p.WriteString("\\\n")
+ p.line++
+ p.indent()
+}
+
+func (p *Printer) spacedString(s string, pos Pos) {
+ p.spacePad(pos)
+ p.WriteString(s)
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) spacedToken(s string, pos Pos) {
+ if p.minify {
+ p.WriteString(s)
+ p.wantSpace = spaceNotRequired
+ return
+ }
+ p.spacePad(pos)
+ p.WriteString(s)
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) semiOrNewl(s string, pos Pos) {
+ if p.wantsNewline(Pos{}, false) {
+ p.newline(pos)
+ p.indent()
+ } else {
+ if !p.wroteSemi {
+ p.WriteByte(';')
+ }
+ if !p.minify {
+ p.space()
+ }
+ p.advanceLine(pos.Line())
+ }
+ p.WriteString(s)
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) writeLit(s string) {
+ // If p.tabWriter is nil, this is the nested printer being used to print
+ // <<- heredoc bodies, so the parent printer will add the escape bytes
+ // later.
+ if p.tabWriter != nil && strings.Contains(s, "\t") {
+ p.WriteByte(tabwriter.Escape)
+ defer p.WriteByte(tabwriter.Escape)
+ }
+ p.WriteString(s)
+}
+
+func (p *Printer) incLevel() {
+ inc := false
+ if p.level <= p.lastLevel || len(p.levelIncs) == 0 {
+ p.level++
+ inc = true
+ } else if last := &p.levelIncs[len(p.levelIncs)-1]; *last {
+ *last = false
+ inc = true
+ }
+ p.levelIncs = append(p.levelIncs, inc)
+}
+
+func (p *Printer) decLevel() {
+ if p.levelIncs[len(p.levelIncs)-1] {
+ p.level--
+ }
+ p.levelIncs = p.levelIncs[:len(p.levelIncs)-1]
+}
+
+func (p *Printer) indent() {
+ if p.minify {
+ return
+ }
+ p.lastLevel = p.level
+ switch {
+ case p.level == 0:
+ case p.indentSpaces == 0:
+ p.WriteByte(tabwriter.Escape)
+ for i := uint(0); i < p.level; i++ {
+ p.WriteByte('\t')
+ }
+ p.WriteByte(tabwriter.Escape)
+ default:
+ p.spaces(p.indentSpaces * p.level)
+ }
+}
+
+// TODO(mvdan): add an indent call at the end of newline?
+
+// newline prints one newline and advances p.line to pos.Line().
+func (p *Printer) newline(pos Pos) {
+ p.flushHeredocs()
+ p.flushComments()
+ p.WriteByte('\n')
+ p.wantSpace = spaceWritten
+ p.wantNewline, p.mustNewline = false, false
+ p.advanceLine(pos.Line())
+}
+
+func (p *Printer) advanceLine(line uint) {
+ if p.line < line {
+ p.line = line
+ }
+}
+
+func (p *Printer) flushHeredocs() {
+ if len(p.pendingHdocs) == 0 {
+ return
+ }
+ hdocs := p.pendingHdocs
+ p.pendingHdocs = p.pendingHdocs[:0]
+ coms := p.pendingComments
+ p.pendingComments = nil
+ if len(coms) > 0 {
+ c := coms[0]
+ if c.Pos().Line() == p.line {
+ p.pendingComments = append(p.pendingComments, c)
+ p.flushComments()
+ coms = coms[1:]
+ }
+ }
+
+ // Reuse the last indentation level, as
+ // indentation levels are usually changed before
+ // newlines are printed along with their
+ // subsequent indentation characters.
+ newLevel := p.level
+ p.level = p.lastLevel
+
+ for _, r := range hdocs {
+ p.line++
+ p.WriteByte('\n')
+ p.wantSpace = spaceWritten
+ p.wantNewline, p.wantNewline = false, false
+ if r.Op == DashHdoc && p.indentSpaces == 0 && !p.minify {
+ if r.Hdoc != nil {
+ extra := extraIndenter{
+ bufWriter: p.bufWriter,
+ baseIndent: int(p.level + 1),
+ firstIndent: -1,
+ }
+ p.tabsPrinter = &Printer{
+ bufWriter: &extra,
+
+ // The options need to persist.
+ indentSpaces: p.indentSpaces,
+ binNextLine: p.binNextLine,
+ swtCaseIndent: p.swtCaseIndent,
+ spaceRedirects: p.spaceRedirects,
+ keepPadding: p.keepPadding,
+ minify: p.minify,
+ funcNextLine: p.funcNextLine,
+
+ line: r.Hdoc.Pos().Line(),
+ }
+ p.tabsPrinter.wordParts(r.Hdoc.Parts, true)
+ }
+ p.indent()
+ } else if r.Hdoc != nil {
+ p.wordParts(r.Hdoc.Parts, true)
+ }
+ p.unquotedWord(r.Word)
+ if r.Hdoc != nil {
+ // Overwrite p.line, since printing r.Word again can set
+ // p.line to the beginning of the heredoc again.
+ p.advanceLine(r.Hdoc.End().Line())
+ }
+ p.wantSpace = spaceNotRequired
+ }
+ p.level = newLevel
+ p.pendingComments = coms
+ p.mustNewline = true
+}
+
+// newline prints between zero and two newlines.
+// If any newlines are printed, it advances p.line to pos.Line().
+func (p *Printer) newlines(pos Pos) {
+ if p.firstLine && len(p.pendingComments) == 0 {
+ p.firstLine = false
+ return // no empty lines at the top
+ }
+ if !p.wantsNewline(pos, false) {
+ return
+ }
+ p.flushHeredocs()
+ p.flushComments()
+ p.WriteByte('\n')
+ p.wantSpace = spaceWritten
+ p.wantNewline, p.mustNewline = false, false
+
+ l := pos.Line()
+ if l > p.line+1 && !p.minify {
+ p.WriteByte('\n') // preserve single empty lines
+ }
+ p.advanceLine(l)
+ p.indent()
+}
+
+func (p *Printer) rightParen(pos Pos) {
+ if len(p.pendingHdocs) > 0 || !p.minify {
+ p.newlines(pos)
+ }
+ p.WriteByte(')')
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) semiRsrv(s string, pos Pos) {
+ if p.wantsNewline(pos, false) {
+ p.newlines(pos)
+ } else {
+ if !p.wroteSemi {
+ p.WriteByte(';')
+ }
+ if !p.minify {
+ p.spacePad(pos)
+ }
+ }
+ p.WriteString(s)
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) flushComments() {
+ for i, c := range p.pendingComments {
+ if i == 0 {
+ // Flush any pending heredocs first. Otherwise, the
+ // comments would become part of a heredoc body.
+ p.flushHeredocs()
+ }
+ p.firstLine = false
+ // We can't call any of the newline methods, as they call this
+ // function and we'd recurse forever.
+ cline := c.Hash.Line()
+ switch {
+ case p.mustNewline, i > 0, cline > p.line && p.line > 0:
+ p.WriteByte('\n')
+ if cline > p.line+1 {
+ p.WriteByte('\n')
+ }
+ p.indent()
+ p.wantSpace = spaceWritten
+ p.spacePad(c.Pos())
+ case p.wantSpace == spaceRequired:
+ if p.keepPadding {
+ p.spacePad(c.Pos())
+ } else {
+ p.WriteByte('\t')
+ }
+ case p.wantSpace != spaceWritten:
+ p.space()
+ }
+ // don't go back one line, which may happen in some edge cases
+ p.advanceLine(cline)
+ p.WriteByte('#')
+ p.writeLit(strings.TrimRightFunc(c.Text, unicode.IsSpace))
+ p.wantNewline = true
+ p.mustNewline = true
+ }
+ p.pendingComments = nil
+}
+
+func (p *Printer) comments(comments ...Comment) {
+ if p.minify {
+ for _, c := range comments {
+ if fileutil.Shebang([]byte("#"+c.Text)) != "" && c.Hash.Col() == 1 && c.Hash.Line() == 1 {
+ p.WriteString(strings.TrimRightFunc("#"+c.Text, unicode.IsSpace))
+ p.WriteString("\n")
+ p.line++
+ }
+ }
+ return
+ }
+ p.pendingComments = append(p.pendingComments, comments...)
+}
+
+func (p *Printer) wordParts(wps []WordPart, quoted bool) {
+ // We disallow unquoted escaped newlines between word parts below.
+ // However, we want to allow a leading escaped newline for cases such as:
+ //
+ // foo <<< \
+ // "bar baz"
+ if !quoted && !p.singleLine && wps[0].Pos().Line() > p.line {
+ p.bslashNewl()
+ }
+ for i, wp := range wps {
+ var next WordPart
+ if i+1 < len(wps) {
+ next = wps[i+1]
+ }
+ // Keep escaped newlines separating word parts when quoted.
+ // Note that those escaped newlines don't cause indentaiton.
+ // When not quoted, we strip them out consistently,
+ // because attempting to keep them would prevent indentation.
+ // Can't use p.wantsNewline here, since this is only about
+ // escaped newlines.
+ for quoted && !p.singleLine && wp.Pos().Line() > p.line {
+ p.WriteString("\\\n")
+ p.line++
+ }
+ p.wordPart(wp, next)
+ p.advanceLine(wp.End().Line())
+ }
+}
+
+func (p *Printer) wordPart(wp, next WordPart) {
+ switch x := wp.(type) {
+ case *Lit:
+ p.writeLit(x.Value)
+ case *SglQuoted:
+ if x.Dollar {
+ p.WriteByte('$')
+ }
+ p.WriteByte('\'')
+ p.writeLit(x.Value)
+ p.WriteByte('\'')
+ p.advanceLine(x.End().Line())
+ case *DblQuoted:
+ p.dblQuoted(x)
+ case *CmdSubst:
+ p.advanceLine(x.Pos().Line())
+ switch {
+ case x.TempFile:
+ p.WriteString("${")
+ p.wantSpace = spaceRequired
+ p.nestedStmts(x.Stmts, x.Last, x.Right)
+ p.wantSpace = spaceNotRequired
+ p.semiRsrv("}", x.Right)
+ case x.ReplyVar:
+ p.WriteString("${|")
+ p.nestedStmts(x.Stmts, x.Last, x.Right)
+ p.wantSpace = spaceNotRequired
+ p.semiRsrv("}", x.Right)
+ // Special case: `# inline comment`
+ case x.Backquotes && len(x.Stmts) == 0 &&
+ len(x.Last) == 1 && x.Right.Line() == p.line:
+ p.WriteString("`#")
+ p.WriteString(x.Last[0].Text)
+ p.WriteString("`")
+ default:
+ p.WriteString("$(")
+ if len(x.Stmts) > 0 && startsWithLparen(x.Stmts[0]) {
+ p.wantSpace = spaceRequired
+ } else {
+ p.wantSpace = spaceNotRequired
+ }
+ p.nestedStmts(x.Stmts, x.Last, x.Right)
+ p.rightParen(x.Right)
+ }
+ case *ParamExp:
+ litCont := ";"
+ if nextLit, ok := next.(*Lit); ok && nextLit.Value != "" {
+ litCont = nextLit.Value[:1]
+ }
+ name := x.Param.Value
+ switch {
+ case !p.minify:
+ case x.Excl, x.Length, x.Width:
+ case x.Index != nil, x.Slice != nil:
+ case x.Repl != nil, x.Exp != nil:
+ case len(name) > 1 && !ValidName(name): // ${10}
+ case ValidName(name + litCont): // ${var}cont
+ default:
+ x2 := *x
+ x2.Short = true
+ p.paramExp(&x2)
+ return
+ }
+ p.paramExp(x)
+ case *ArithmExp:
+ p.WriteString("$((")
+ if x.Unsigned {
+ p.WriteString("# ")
+ }
+ p.arithmExpr(x.X, false, false)
+ p.WriteString("))")
+ case *ExtGlob:
+ p.WriteString(x.Op.String())
+ p.writeLit(x.Pattern.Value)
+ p.WriteByte(')')
+ case *ProcSubst:
+ // avoid conflict with << and others
+ if p.wantSpace == spaceRequired {
+ p.space()
+ }
+ p.WriteString(x.Op.String())
+ p.nestedStmts(x.Stmts, x.Last, x.Rparen)
+ p.rightParen(x.Rparen)
+ }
+}
+
+func (p *Printer) dblQuoted(dq *DblQuoted) {
+ if dq.Dollar {
+ p.WriteByte('$')
+ }
+ p.WriteByte('"')
+ if len(dq.Parts) > 0 {
+ p.wordParts(dq.Parts, true)
+ }
+ // Add any trailing escaped newlines.
+ for p.line < dq.Right.Line() {
+ p.WriteString("\\\n")
+ p.line++
+ }
+ p.WriteByte('"')
+}
+
+func (p *Printer) wroteIndex(index ArithmExpr) bool {
+ if index == nil {
+ return false
+ }
+ p.WriteByte('[')
+ p.arithmExpr(index, false, false)
+ p.WriteByte(']')
+ return true
+}
+
+func (p *Printer) paramExp(pe *ParamExp) {
+ if pe.nakedIndex() { // arr[x]
+ p.writeLit(pe.Param.Value)
+ p.wroteIndex(pe.Index)
+ return
+ }
+ if pe.Short { // $var
+ p.WriteByte('$')
+ p.writeLit(pe.Param.Value)
+ return
+ }
+ // ${var...}
+ p.WriteString("${")
+ switch {
+ case pe.Length:
+ p.WriteByte('#')
+ case pe.Width:
+ p.WriteByte('%')
+ case pe.Excl:
+ p.WriteByte('!')
+ }
+ p.writeLit(pe.Param.Value)
+ p.wroteIndex(pe.Index)
+ switch {
+ case pe.Slice != nil:
+ p.WriteByte(':')
+ p.arithmExpr(pe.Slice.Offset, true, true)
+ if pe.Slice.Length != nil {
+ p.WriteByte(':')
+ p.arithmExpr(pe.Slice.Length, true, false)
+ }
+ case pe.Repl != nil:
+ if pe.Repl.All {
+ p.WriteByte('/')
+ }
+ p.WriteByte('/')
+ if pe.Repl.Orig != nil {
+ p.word(pe.Repl.Orig)
+ }
+ p.WriteByte('/')
+ if pe.Repl.With != nil {
+ p.word(pe.Repl.With)
+ }
+ case pe.Names != 0:
+ p.writeLit(pe.Names.String())
+ case pe.Exp != nil:
+ p.WriteString(pe.Exp.Op.String())
+ if pe.Exp.Word != nil {
+ p.word(pe.Exp.Word)
+ }
+ }
+ p.WriteByte('}')
+}
+
+func (p *Printer) loop(loop Loop) {
+ switch x := loop.(type) {
+ case *WordIter:
+ p.writeLit(x.Name.Value)
+ if x.InPos.IsValid() {
+ p.spacedString(" in", Pos{})
+ p.wordJoin(x.Items)
+ }
+ case *CStyleLoop:
+ p.WriteString("((")
+ if x.Init == nil {
+ p.space()
+ }
+ p.arithmExpr(x.Init, false, false)
+ p.WriteString("; ")
+ p.arithmExpr(x.Cond, false, false)
+ p.WriteString("; ")
+ p.arithmExpr(x.Post, false, false)
+ p.WriteString("))")
+ }
+}
+
+func (p *Printer) arithmExpr(expr ArithmExpr, compact, spacePlusMinus bool) {
+ if p.minify {
+ compact = true
+ }
+ switch x := expr.(type) {
+ case *Word:
+ p.word(x)
+ case *BinaryArithm:
+ if compact {
+ p.arithmExpr(x.X, compact, spacePlusMinus)
+ p.WriteString(x.Op.String())
+ p.arithmExpr(x.Y, compact, false)
+ } else {
+ p.arithmExpr(x.X, compact, spacePlusMinus)
+ if x.Op != Comma {
+ p.space()
+ }
+ p.WriteString(x.Op.String())
+ p.space()
+ p.arithmExpr(x.Y, compact, false)
+ }
+ case *UnaryArithm:
+ if x.Post {
+ p.arithmExpr(x.X, compact, spacePlusMinus)
+ p.WriteString(x.Op.String())
+ } else {
+ if spacePlusMinus {
+ switch x.Op {
+ case Plus, Minus:
+ p.space()
+ }
+ }
+ p.WriteString(x.Op.String())
+ p.arithmExpr(x.X, compact, false)
+ }
+ case *ParenArithm:
+ p.WriteByte('(')
+ p.arithmExpr(x.X, false, false)
+ p.WriteByte(')')
+ }
+}
+
+func (p *Printer) testExpr(expr TestExpr) {
+ // Multi-line test expressions don't need to escape newlines.
+ if expr.Pos().Line() > p.line {
+ p.newlines(expr.Pos())
+ p.spacePad(expr.Pos())
+ } else if p.wantSpace == spaceRequired {
+ p.space()
+ }
+ p.testExprSameLine(expr)
+}
+
+func (p *Printer) testExprSameLine(expr TestExpr) {
+ p.advanceLine(expr.Pos().Line())
+ switch x := expr.(type) {
+ case *Word:
+ p.word(x)
+ case *BinaryTest:
+ p.testExprSameLine(x.X)
+ p.space()
+ p.WriteString(x.Op.String())
+ switch x.Op {
+ case AndTest, OrTest:
+ p.wantSpace = spaceRequired
+ p.testExpr(x.Y)
+ default:
+ p.space()
+ p.testExprSameLine(x.Y)
+ }
+ case *UnaryTest:
+ p.WriteString(x.Op.String())
+ p.space()
+ p.testExprSameLine(x.X)
+ case *ParenTest:
+ p.WriteByte('(')
+ if startsWithLparen(x.X) {
+ p.wantSpace = spaceRequired
+ } else {
+ p.wantSpace = spaceNotRequired
+ }
+ p.testExpr(x.X)
+ p.WriteByte(')')
+ }
+}
+
+func (p *Printer) word(w *Word) {
+ p.wordParts(w.Parts, false)
+ p.wantSpace = spaceRequired
+}
+
+func (p *Printer) unquotedWord(w *Word) {
+ for _, wp := range w.Parts {
+ switch x := wp.(type) {
+ case *SglQuoted:
+ p.writeLit(x.Value)
+ case *DblQuoted:
+ p.wordParts(x.Parts, true)
+ case *Lit:
+ for i := 0; i < len(x.Value); i++ {
+ if b := x.Value[i]; b == '\\' {
+ if i++; i < len(x.Value) {
+ p.WriteByte(x.Value[i])
+ }
+ } else {
+ p.WriteByte(b)
+ }
+ }
+ }
+ }
+}
+
+func (p *Printer) wordJoin(ws []*Word) {
+ anyNewline := false
+ for _, w := range ws {
+ if pos := w.Pos(); pos.Line() > p.line && !p.singleLine {
+ if !anyNewline {
+ p.incLevel()
+ anyNewline = true
+ }
+ p.bslashNewl()
+ }
+ p.spacePad(w.Pos())
+ p.word(w)
+ }
+ if anyNewline {
+ p.decLevel()
+ }
+}
+
+func (p *Printer) casePatternJoin(pats []*Word) {
+ anyNewline := false
+ for i, w := range pats {
+ if i > 0 {
+ p.spacedToken("|", Pos{})
+ }
+ if p.wantsNewline(w.Pos(), true) {
+ if !anyNewline {
+ p.incLevel()
+ anyNewline = true
+ }
+ p.bslashNewl()
+ } else {
+ p.spacePad(w.Pos())
+ }
+ p.word(w)
+ }
+ if anyNewline {
+ p.decLevel()
+ }
+}
+
+func (p *Printer) elemJoin(elems []*ArrayElem, last []Comment) {
+ p.incLevel()
+ for _, el := range elems {
+ var left []Comment
+ for _, c := range el.Comments {
+ if c.Pos().After(el.Pos()) {
+ left = append(left, c)
+ break
+ }
+ p.comments(c)
+ }
+ // Multi-line array expressions don't need to escape newlines.
+ if el.Pos().Line() > p.line {
+ p.newlines(el.Pos())
+ p.spacePad(el.Pos())
+ } else if p.wantSpace == spaceRequired {
+ p.space()
+ }
+ if p.wroteIndex(el.Index) {
+ p.WriteByte('=')
+ }
+ if el.Value != nil {
+ p.word(el.Value)
+ }
+ p.comments(left...)
+ }
+ if len(last) > 0 {
+ p.comments(last...)
+ p.flushComments()
+ }
+ p.decLevel()
+}
+
+func (p *Printer) stmt(s *Stmt) {
+ p.wroteSemi = false
+ if s.Negated {
+ p.spacedString("!", s.Pos())
+ }
+ var startRedirs int
+ if s.Cmd != nil {
+ startRedirs = p.command(s.Cmd, s.Redirs)
+ }
+ p.incLevel()
+ for _, r := range s.Redirs[startRedirs:] {
+ if p.wantsNewline(r.OpPos, true) {
+ p.bslashNewl()
+ }
+ if p.wantSpace == spaceRequired {
+ p.spacePad(r.Pos())
+ }
+ if r.N != nil {
+ p.writeLit(r.N.Value)
+ }
+ p.WriteString(r.Op.String())
+ if p.spaceRedirects && (r.Op != DplIn && r.Op != DplOut) {
+ p.space()
+ } else {
+ p.wantSpace = spaceRequired
+ }
+ p.word(r.Word)
+ if r.Op == Hdoc || r.Op == DashHdoc {
+ p.pendingHdocs = append(p.pendingHdocs, r)
+ }
+ }
+ sep := s.Semicolon.IsValid() && s.Semicolon.Line() > p.line && !p.singleLine
+ if sep || s.Background || s.Coprocess {
+ if sep {
+ p.bslashNewl()
+ } else if !p.minify {
+ p.space()
+ }
+ if s.Background {
+ p.WriteString("&")
+ } else if s.Coprocess {
+ p.WriteString("|&")
+ } else {
+ p.WriteString(";")
+ }
+ p.wroteSemi = true
+ p.wantSpace = spaceRequired
+ }
+ p.decLevel()
+}
+
+func (p *Printer) command(cmd Command, redirs []*Redirect) (startRedirs int) {
+ p.advanceLine(cmd.Pos().Line())
+ p.spacePad(cmd.Pos())
+ switch x := cmd.(type) {
+ case *CallExpr:
+ p.assigns(x.Assigns)
+ if len(x.Args) <= 1 {
+ p.wordJoin(x.Args)
+ return 0
+ }
+ p.wordJoin(x.Args[:1])
+ for _, r := range redirs {
+ if r.Pos().After(x.Args[1].Pos()) || r.Op == Hdoc || r.Op == DashHdoc {
+ break
+ }
+ if p.wantSpace == spaceRequired {
+ p.spacePad(r.Pos())
+ }
+ if r.N != nil {
+ p.writeLit(r.N.Value)
+ }
+ p.WriteString(r.Op.String())
+ if p.spaceRedirects && (r.Op != DplIn && r.Op != DplOut) {
+ p.space()
+ } else {
+ p.wantSpace = spaceRequired
+ }
+ p.word(r.Word)
+ startRedirs++
+ }
+ p.wordJoin(x.Args[1:])
+ case *Block:
+ p.WriteByte('{')
+ p.wantSpace = spaceRequired
+ // Forbid "foo()\n{ bar; }"
+ p.wantNewline = p.wantNewline || p.funcNextLine
+ p.nestedStmts(x.Stmts, x.Last, x.Rbrace)
+ p.semiRsrv("}", x.Rbrace)
+ case *IfClause:
+ p.ifClause(x, false)
+ case *Subshell:
+ p.WriteByte('(')
+ stmts := x.Stmts
+ if len(stmts) > 0 && startsWithLparen(stmts[0]) {
+ p.wantSpace = spaceRequired
+ // Add a space between nested parentheses if we're printing them in a single line,
+ // to avoid the ambiguity between `((` and `( (`.
+ if (x.Lparen.Line() != stmts[0].Pos().Line() || len(stmts) > 1) && !p.singleLine {
+ p.wantSpace = spaceNotRequired
+
+ if p.minify {
+ p.mustNewline = true
+ }
+ }
+ } else {
+ p.wantSpace = spaceNotRequired
+ }
+
+ p.spacePad(stmtsPos(x.Stmts, x.Last))
+ p.nestedStmts(x.Stmts, x.Last, x.Rparen)
+ p.wantSpace = spaceNotRequired
+ p.spacePad(x.Rparen)
+ p.rightParen(x.Rparen)
+ case *WhileClause:
+ if x.Until {
+ p.spacedString("until", x.Pos())
+ } else {
+ p.spacedString("while", x.Pos())
+ }
+ p.nestedStmts(x.Cond, x.CondLast, Pos{})
+ p.semiOrNewl("do", x.DoPos)
+ p.nestedStmts(x.Do, x.DoLast, x.DonePos)
+ p.semiRsrv("done", x.DonePos)
+ case *ForClause:
+ if x.Select {
+ p.WriteString("select ")
+ } else {
+ p.WriteString("for ")
+ }
+ p.loop(x.Loop)
+ p.semiOrNewl("do", x.DoPos)
+ p.nestedStmts(x.Do, x.DoLast, x.DonePos)
+ p.semiRsrv("done", x.DonePos)
+ case *BinaryCmd:
+ p.stmt(x.X)
+ if p.minify || p.singleLine || x.Y.Pos().Line() <= p.line {
+ // leave p.nestedBinary untouched
+ p.spacedToken(x.Op.String(), x.OpPos)
+ p.advanceLine(x.Y.Pos().Line())
+ p.stmt(x.Y)
+ break
+ }
+ indent := !p.nestedBinary
+ if indent {
+ p.incLevel()
+ }
+ if p.binNextLine {
+ if len(p.pendingHdocs) == 0 {
+ p.bslashNewl()
+ }
+ p.spacedToken(x.Op.String(), x.OpPos)
+ if len(x.Y.Comments) > 0 {
+ p.wantSpace = spaceNotRequired
+ p.newline(x.Y.Pos())
+ p.indent()
+ p.comments(x.Y.Comments...)
+ p.newline(Pos{})
+ p.indent()
+ }
+ } else {
+ p.spacedToken(x.Op.String(), x.OpPos)
+ p.advanceLine(x.OpPos.Line())
+ p.comments(x.Y.Comments...)
+ p.newline(Pos{})
+ p.indent()
+ }
+ p.advanceLine(x.Y.Pos().Line())
+ _, p.nestedBinary = x.Y.Cmd.(*BinaryCmd)
+ p.stmt(x.Y)
+ if indent {
+ p.decLevel()
+ }
+ p.nestedBinary = false
+ case *FuncDecl:
+ if x.RsrvWord {
+ p.WriteString("function ")
+ }
+ p.writeLit(x.Name.Value)
+ if !x.RsrvWord || x.Parens {
+ p.WriteString("()")
+ }
+ if p.funcNextLine {
+ p.newline(Pos{})
+ p.indent()
+ } else if !x.Parens || !p.minify {
+ p.space()
+ }
+ p.advanceLine(x.Body.Pos().Line())
+ p.comments(x.Body.Comments...)
+ p.stmt(x.Body)
+ case *CaseClause:
+ p.WriteString("case ")
+ p.word(x.Word)
+ p.WriteString(" in")
+ p.advanceLine(x.In.Line())
+ p.wantSpace = spaceRequired
+ if p.swtCaseIndent {
+ p.incLevel()
+ }
+ if len(x.Items) == 0 {
+ // Apparently "case x in; esac" is invalid shell.
+ p.mustNewline = true
+ }
+ for i, ci := range x.Items {
+ var last []Comment
+ for i, c := range ci.Comments {
+ if c.Pos().After(ci.Pos()) {
+ last = ci.Comments[i:]
+ break
+ }
+ p.comments(c)
+ }
+ p.newlines(ci.Pos())
+ p.spacePad(ci.Pos())
+ p.casePatternJoin(ci.Patterns)
+ p.WriteByte(')')
+ if !p.minify {
+ p.wantSpace = spaceRequired
+ } else {
+ p.wantSpace = spaceNotRequired
+ }
+
+ bodyPos := stmtsPos(ci.Stmts, ci.Last)
+ bodyEnd := stmtsEnd(ci.Stmts, ci.Last)
+ sep := len(ci.Stmts) > 1 || bodyPos.Line() > p.line ||
+ (bodyEnd.IsValid() && ci.OpPos.Line() > bodyEnd.Line())
+ p.nestedStmts(ci.Stmts, ci.Last, ci.OpPos)
+ p.level++
+ if !p.minify || i != len(x.Items)-1 {
+ if sep {
+ p.newlines(ci.OpPos)
+ p.wantNewline = true
+ }
+ p.spacedToken(ci.Op.String(), ci.OpPos)
+ p.advanceLine(ci.OpPos.Line())
+ // avoid ; directly after tokens like ;;
+ p.wroteSemi = true
+ }
+ p.comments(last...)
+ p.flushComments()
+ p.level--
+ }
+ p.comments(x.Last...)
+ if p.swtCaseIndent {
+ p.flushComments()
+ p.decLevel()
+ }
+ p.semiRsrv("esac", x.Esac)
+ case *ArithmCmd:
+ p.WriteString("((")
+ if x.Unsigned {
+ p.WriteString("# ")
+ }
+ p.arithmExpr(x.X, false, false)
+ p.WriteString("))")
+ case *TestClause:
+ p.WriteString("[[ ")
+ p.incLevel()
+ p.testExpr(x.X)
+ p.decLevel()
+ p.spacedString("]]", x.Right)
+ case *DeclClause:
+ p.spacedString(x.Variant.Value, x.Pos())
+ p.assigns(x.Args)
+ case *TimeClause:
+ p.spacedString("time", x.Pos())
+ if x.PosixFormat {
+ p.spacedString("-p", x.Pos())
+ }
+ if x.Stmt != nil {
+ p.stmt(x.Stmt)
+ }
+ case *CoprocClause:
+ p.spacedString("coproc", x.Pos())
+ if x.Name != nil {
+ p.space()
+ p.word(x.Name)
+ }
+ p.space()
+ p.stmt(x.Stmt)
+ case *LetClause:
+ p.spacedString("let", x.Pos())
+ for _, n := range x.Exprs {
+ p.space()
+ p.arithmExpr(n, true, false)
+ }
+ case *TestDecl:
+ p.spacedString("@test", x.Pos())
+ p.space()
+ p.word(x.Description)
+ p.space()
+ p.stmt(x.Body)
+ default:
+ panic(fmt.Sprintf("syntax.Printer: unexpected node type %T", x))
+ }
+ return startRedirs
+}
+
+func (p *Printer) ifClause(ic *IfClause, elif bool) {
+ if !elif {
+ p.spacedString("if", ic.Pos())
+ }
+ p.nestedStmts(ic.Cond, ic.CondLast, Pos{})
+ p.semiOrNewl("then", ic.ThenPos)
+ thenEnd := ic.FiPos
+ el := ic.Else
+ if el != nil {
+ thenEnd = el.Position
+ }
+ p.nestedStmts(ic.Then, ic.ThenLast, thenEnd)
+
+ if el != nil && el.ThenPos.IsValid() {
+ p.comments(ic.Last...)
+ p.semiRsrv("elif", el.Position)
+ p.ifClause(el, true)
+ return
+ }
+ if el == nil {
+ p.comments(ic.Last...)
+ } else {
+ var left []Comment
+ for _, c := range ic.Last {
+ if c.Pos().After(el.Position) {
+ left = append(left, c)
+ break
+ }
+ p.comments(c)
+ }
+ p.semiRsrv("else", el.Position)
+ p.comments(left...)
+ p.nestedStmts(el.Then, el.ThenLast, ic.FiPos)
+ p.comments(el.Last...)
+ }
+ p.semiRsrv("fi", ic.FiPos)
+}
+
+func (p *Printer) stmtList(stmts []*Stmt, last []Comment) {
+ sep := p.wantNewline || (len(stmts) > 0 && stmts[0].Pos().Line() > p.line)
+ for i, s := range stmts {
+ if i > 0 && p.singleLine && p.wantNewline && !p.wroteSemi {
+ // In singleLine mode, ensure we use semicolons between
+ // statements.
+ p.WriteByte(';')
+ p.wantSpace = spaceRequired
+ }
+ pos := s.Pos()
+ var midComs, endComs []Comment
+ for _, c := range s.Comments {
+ // Comments after the end of this command. Note that
+ // this includes "< 1:
+ // Force a newline if we find:
+ // { stmt; stmt; }
+ p.wantNewline = true
+ case closing.Line() > p.line && len(stmts) > 0 &&
+ stmtsEnd(stmts, last).Line() < closing.Line():
+ // Force a newline if we find:
+ // { stmt
+ // }
+ p.wantNewline = true
+ case len(p.pendingComments) > 0 && len(stmts) > 0:
+ // Force a newline if we find:
+ // for i in a b # stmt
+ // do foo; done
+ p.wantNewline = true
+ }
+ p.stmtList(stmts, last)
+ if closing.IsValid() {
+ p.flushComments()
+ }
+ p.decLevel()
+}
+
+func (p *Printer) assigns(assigns []*Assign) {
+ p.incLevel()
+ for _, a := range assigns {
+ if p.wantsNewline(a.Pos(), true) {
+ p.bslashNewl()
+ } else {
+ p.spacePad(a.Pos())
+ }
+ if a.Name != nil {
+ p.writeLit(a.Name.Value)
+ p.wroteIndex(a.Index)
+ if a.Append {
+ p.WriteByte('+')
+ }
+ if !a.Naked {
+ p.WriteByte('=')
+ }
+ }
+ if a.Value != nil {
+ // Ensure we don't use an escaped newline after '=',
+ // because that can result in indentation, thus
+ // splitting "foo=bar" into "foo= bar".
+ p.advanceLine(a.Value.Pos().Line())
+ p.word(a.Value)
+ } else if a.Array != nil {
+ p.wantSpace = spaceNotRequired
+ p.WriteByte('(')
+ p.elemJoin(a.Array.Elems, a.Array.Last)
+ p.rightParen(a.Array.Rparen)
+ }
+ p.wantSpace = spaceRequired
+ }
+ p.decLevel()
+}
+
+type wantSpaceState uint8
+
+const (
+ spaceNotRequired wantSpaceState = iota
+ spaceRequired // we should generally print a space or a newline next
+ spaceWritten // we have just written a space or newline
+)
+
+// extraIndenter ensures that all lines in a '<<-' heredoc body have at least
+// baseIndent leading tabs. Those that had more tab indentation than the first
+// heredoc line will keep that relative indentation.
+type extraIndenter struct {
+ bufWriter
+ baseIndent int
+
+ firstIndent int
+ firstChange int
+ curLine []byte
+}
+
+func (e *extraIndenter) WriteByte(b byte) error {
+ e.curLine = append(e.curLine, b)
+ if b != '\n' {
+ return nil
+ }
+ trimmed := bytes.TrimLeft(e.curLine, "\t")
+ if len(trimmed) == 1 {
+ // no tabs if this is an empty line, i.e. "\n"
+ e.bufWriter.Write(trimmed)
+ e.curLine = e.curLine[:0]
+ return nil
+ }
+
+ lineIndent := len(e.curLine) - len(trimmed)
+ if e.firstIndent < 0 {
+ // This is the first heredoc line we add extra indentation to.
+ // Keep track of how much we indented.
+ e.firstIndent = lineIndent
+ e.firstChange = e.baseIndent - lineIndent
+ lineIndent = e.baseIndent
+
+ } else if lineIndent < e.firstIndent {
+ // This line did not have enough indentation; simply indent it
+ // like the first line.
+ lineIndent = e.firstIndent
+ } else {
+ // This line had plenty of indentation. Add the extra
+ // indentation that the first line had, for consistency.
+ lineIndent += e.firstChange
+ }
+ e.bufWriter.WriteByte(tabwriter.Escape)
+ for i := 0; i < lineIndent; i++ {
+ e.bufWriter.WriteByte('\t')
+ }
+ e.bufWriter.WriteByte(tabwriter.Escape)
+ e.bufWriter.Write(trimmed)
+ e.curLine = e.curLine[:0]
+ return nil
+}
+
+func (e *extraIndenter) WriteString(s string) (int, error) {
+ for i := 0; i < len(s); i++ {
+ e.WriteByte(s[i])
+ }
+ return len(s), nil
+}
+
+func startsWithLparen(node Node) bool {
+ switch node := node.(type) {
+ case *Stmt:
+ return startsWithLparen(node.Cmd)
+ case *BinaryCmd:
+ return startsWithLparen(node.X)
+ case *Subshell:
+ return true // keep ( (
+ case *ArithmCmd:
+ return true // keep ( ((
+ }
+ return false
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/quote.go b/vendor/mvdan.cc/sh/v3/syntax/quote.go
new file mode 100644
index 00000000..6f27eba1
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/quote.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2021, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "fmt"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+)
+
+type QuoteError struct {
+ ByteOffset int
+ Message string
+}
+
+func (e QuoteError) Error() string {
+ return fmt.Sprintf("cannot quote character at byte %d: %s", e.ByteOffset, e.Message)
+}
+
+const (
+ quoteErrNull = "shell strings cannot contain null bytes"
+ quoteErrPOSIX = "POSIX shell lacks escape sequences"
+ quoteErrRange = "rune out of range"
+ quoteErrMksh = "mksh cannot escape codepoints above 16 bits"
+)
+
+// Quote returns a quoted version of the input string,
+// so that the quoted version is expanded or interpreted
+// as the original string in the given language variant.
+//
+// Quoting is necessary when using arbitrary literal strings
+// as words in a shell script or command.
+// Without quoting, one can run into syntax errors,
+// as well as the possibility of running unintended code.
+//
+// An error is returned when a string cannot be quoted for a variant.
+// For instance, POSIX lacks escape sequences for non-printable characters,
+// and no language variant can represent a string containing null bytes.
+// In such cases, the returned error type will be *QuoteError.
+//
+// The quoting strategy is chosen on a best-effort basis,
+// to minimize the amount of extra bytes necessary.
+//
+// Some strings do not require any quoting and are returned unchanged.
+// Those strings can be directly surrounded in single quotes as well.
+func Quote(s string, lang LangVariant) (string, error) {
+ if s == "" {
+ // Special case; an empty string must always be quoted,
+ // as otherwise it expands to zero fields.
+ return "''", nil
+ }
+ shellChars := false
+ nonPrintable := false
+ offs := 0
+ for rem := s; len(rem) > 0; {
+ r, size := utf8.DecodeRuneInString(rem)
+ switch r {
+ // Like regOps; token characters.
+ case ';', '"', '\'', '(', ')', '$', '|', '&', '>', '<', '`',
+ // Whitespace; might result in multiple fields.
+ ' ', '\t', '\r', '\n',
+ // Escape sequences would be expanded.
+ '\\',
+ // Would start a comment unless quoted.
+ '#',
+ // Might result in brace expansion.
+ '{',
+ // Might result in tilde expansion.
+ '~',
+ // Might result in globbing.
+ '*', '?', '[',
+ // Might result in an assignment.
+ '=':
+ shellChars = true
+ case '\x00':
+ return "", &QuoteError{ByteOffset: offs, Message: quoteErrNull}
+ }
+ if r == utf8.RuneError || !unicode.IsPrint(r) {
+ if lang == LangPOSIX {
+ return "", &QuoteError{ByteOffset: offs, Message: quoteErrPOSIX}
+ }
+ nonPrintable = true
+ }
+ rem = rem[size:]
+ offs += size
+ }
+ if !shellChars && !nonPrintable && !IsKeyword(s) {
+ // Nothing to quote; avoid allocating.
+ return s, nil
+ }
+
+ // Single quotes are usually best,
+ // as they don't require any escaping of characters.
+ // If we have any invalid utf8 or non-printable runes,
+ // use $'' so that we can escape them.
+ // Note that we can't use double quotes for those.
+ var b strings.Builder
+ if nonPrintable {
+ b.WriteString("$'")
+ lastRequoteIfHex := false
+ offs := 0
+ for rem := s; len(rem) > 0; {
+ nextRequoteIfHex := false
+ r, size := utf8.DecodeRuneInString(rem)
+ switch {
+ case r == '\'', r == '\\':
+ b.WriteByte('\\')
+ b.WriteRune(r)
+ case unicode.IsPrint(r) && r != utf8.RuneError:
+ if lastRequoteIfHex && isHex(r) {
+ b.WriteString("'$'")
+ }
+ b.WriteRune(r)
+ case r == '\a':
+ b.WriteString(`\a`)
+ case r == '\b':
+ b.WriteString(`\b`)
+ case r == '\f':
+ b.WriteString(`\f`)
+ case r == '\n':
+ b.WriteString(`\n`)
+ case r == '\r':
+ b.WriteString(`\r`)
+ case r == '\t':
+ b.WriteString(`\t`)
+ case r == '\v':
+ b.WriteString(`\v`)
+ case r < utf8.RuneSelf, r == utf8.RuneError && size == 1:
+ // \xXX, fixed at two hexadecimal characters.
+ fmt.Fprintf(&b, "\\x%02x", rem[0])
+ // Unfortunately, mksh allows \x to consume more hex characters.
+ // Ensure that we don't allow it to read more than two.
+ if lang == LangMirBSDKorn {
+ nextRequoteIfHex = true
+ }
+ case r > utf8.MaxRune:
+ // Not a valid Unicode code point?
+ return "", &QuoteError{ByteOffset: offs, Message: quoteErrRange}
+ case lang == LangMirBSDKorn && r > 0xFFFD:
+ // From the CAVEATS section in R59's man page:
+ //
+ // mksh currently uses OPTU-16 internally, which is the same as
+ // UTF-8 and CESU-8 with 0000..FFFD being valid codepoints.
+ return "", &QuoteError{ByteOffset: offs, Message: quoteErrMksh}
+ case r < 0x10000:
+ // \uXXXX, fixed at four hexadecimal characters.
+ fmt.Fprintf(&b, "\\u%04x", r)
+ default:
+ // \UXXXXXXXX, fixed at eight hexadecimal characters.
+ fmt.Fprintf(&b, "\\U%08x", r)
+ }
+ rem = rem[size:]
+ lastRequoteIfHex = nextRequoteIfHex
+ offs += size
+ }
+ b.WriteString("'")
+ return b.String(), nil
+ }
+
+ // Single quotes without any need for escaping.
+ if !strings.Contains(s, "'") {
+ return "'" + s + "'", nil
+ }
+
+ // The string contains single quotes,
+ // so fall back to double quotes.
+ b.WriteByte('"')
+ for _, r := range s {
+ switch r {
+ case '"', '\\', '`', '$':
+ b.WriteByte('\\')
+ }
+ b.WriteRune(r)
+ }
+ b.WriteByte('"')
+ return b.String(), nil
+}
+
+func isHex(r rune) bool {
+ return (r >= '0' && r <= '9') ||
+ (r >= 'a' && r <= 'f') ||
+ (r >= 'A' && r <= 'F')
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/quotestate_string.go b/vendor/mvdan.cc/sh/v3/syntax/quotestate_string.go
new file mode 100644
index 00000000..d43466f8
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/quotestate_string.go
@@ -0,0 +1,61 @@
+// Code generated by "stringer -type=quoteState"; DO NOT EDIT.
+
+package syntax
+
+import "strconv"
+
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[noState-1]
+ _ = x[subCmd-2]
+ _ = x[subCmdBckquo-4]
+ _ = x[dblQuotes-8]
+ _ = x[hdocWord-16]
+ _ = x[hdocBody-32]
+ _ = x[hdocBodyTabs-64]
+ _ = x[arithmExpr-128]
+ _ = x[arithmExprLet-256]
+ _ = x[arithmExprCmd-512]
+ _ = x[arithmExprBrack-1024]
+ _ = x[testExpr-2048]
+ _ = x[testExprRegexp-4096]
+ _ = x[switchCase-8192]
+ _ = x[paramExpName-16384]
+ _ = x[paramExpSlice-32768]
+ _ = x[paramExpRepl-65536]
+ _ = x[paramExpExp-131072]
+ _ = x[arrayElems-262144]
+}
+
+const _quoteState_name = "noStatesubCmdsubCmdBckquodblQuoteshdocWordhdocBodyhdocBodyTabsarithmExprarithmExprLetarithmExprCmdarithmExprBracktestExprtestExprRegexpswitchCaseparamExpNameparamExpSliceparamExpReplparamExpExparrayElems"
+
+var _quoteState_map = map[quoteState]string{
+ 1: _quoteState_name[0:7],
+ 2: _quoteState_name[7:13],
+ 4: _quoteState_name[13:25],
+ 8: _quoteState_name[25:34],
+ 16: _quoteState_name[34:42],
+ 32: _quoteState_name[42:50],
+ 64: _quoteState_name[50:62],
+ 128: _quoteState_name[62:72],
+ 256: _quoteState_name[72:85],
+ 512: _quoteState_name[85:98],
+ 1024: _quoteState_name[98:113],
+ 2048: _quoteState_name[113:121],
+ 4096: _quoteState_name[121:135],
+ 8192: _quoteState_name[135:145],
+ 16384: _quoteState_name[145:157],
+ 32768: _quoteState_name[157:170],
+ 65536: _quoteState_name[170:182],
+ 131072: _quoteState_name[182:193],
+ 262144: _quoteState_name[193:203],
+}
+
+func (i quoteState) String() string {
+ if str, ok := _quoteState_map[i]; ok {
+ return str
+ }
+ return "quoteState(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/simplify.go b/vendor/mvdan.cc/sh/v3/syntax/simplify.go
new file mode 100644
index 00000000..e82fd55a
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/simplify.go
@@ -0,0 +1,250 @@
+// Copyright (c) 2017, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import "bytes"
+
+// Simplify modifies a node to remove redundant pieces of syntax, and returns
+// whether any changes were made.
+//
+// The changes currently applied are:
+//
+// Remove clearly useless parentheses $(( (expr) ))
+// Remove dollars from vars in exprs (($var))
+// Remove duplicate subshells $( (stmts) )
+// Remove redundant quotes [[ "$var" == str ]]
+// Merge negations with unary operators [[ ! -n $var ]]
+// Use single quotes to shorten literals "\$foo"
+func Simplify(n Node) bool {
+ s := simplifier{}
+ Walk(n, s.visit)
+ return s.modified
+}
+
+type simplifier struct {
+ modified bool
+}
+
+func (s *simplifier) visit(node Node) bool {
+ switch x := node.(type) {
+ case *Assign:
+ x.Index = s.removeParensArithm(x.Index)
+ // Don't inline params, as x[i] and x[$i] mean
+ // different things when x is an associative
+ // array; the first means "i", the second "$i".
+ case *ParamExp:
+ x.Index = s.removeParensArithm(x.Index)
+ // don't inline params - same as above.
+
+ if x.Slice == nil {
+ break
+ }
+ x.Slice.Offset = s.removeParensArithm(x.Slice.Offset)
+ x.Slice.Offset = s.inlineSimpleParams(x.Slice.Offset)
+ x.Slice.Length = s.removeParensArithm(x.Slice.Length)
+ x.Slice.Length = s.inlineSimpleParams(x.Slice.Length)
+ case *ArithmExp:
+ x.X = s.removeParensArithm(x.X)
+ x.X = s.inlineSimpleParams(x.X)
+ case *ArithmCmd:
+ x.X = s.removeParensArithm(x.X)
+ x.X = s.inlineSimpleParams(x.X)
+ case *ParenArithm:
+ x.X = s.removeParensArithm(x.X)
+ x.X = s.inlineSimpleParams(x.X)
+ case *BinaryArithm:
+ x.X = s.inlineSimpleParams(x.X)
+ x.Y = s.inlineSimpleParams(x.Y)
+ case *CmdSubst:
+ x.Stmts = s.inlineSubshell(x.Stmts)
+ case *Subshell:
+ x.Stmts = s.inlineSubshell(x.Stmts)
+ case *Word:
+ x.Parts = s.simplifyWord(x.Parts)
+ case *TestClause:
+ x.X = s.removeParensTest(x.X)
+ x.X = s.removeNegateTest(x.X)
+ case *ParenTest:
+ x.X = s.removeParensTest(x.X)
+ x.X = s.removeNegateTest(x.X)
+ case *BinaryTest:
+ x.X = s.unquoteParams(x.X)
+ x.X = s.removeNegateTest(x.X)
+ if x.Op == TsMatchShort {
+ s.modified = true
+ x.Op = TsMatch
+ }
+ switch x.Op {
+ case TsMatch, TsNoMatch:
+ // unquoting enables globbing
+ default:
+ x.Y = s.unquoteParams(x.Y)
+ }
+ x.Y = s.removeNegateTest(x.Y)
+ case *UnaryTest:
+ x.X = s.unquoteParams(x.X)
+ }
+ return true
+}
+
+func (s *simplifier) simplifyWord(wps []WordPart) []WordPart {
+parts:
+ for i, wp := range wps {
+ dq, _ := wp.(*DblQuoted)
+ if dq == nil || len(dq.Parts) != 1 {
+ break
+ }
+ lit, _ := dq.Parts[0].(*Lit)
+ if lit == nil {
+ break
+ }
+ var buf bytes.Buffer
+ escaped := false
+ for _, r := range lit.Value {
+ switch r {
+ case '\\':
+ escaped = !escaped
+ if escaped {
+ continue
+ }
+ case '\'':
+ continue parts
+ case '$', '"', '`':
+ escaped = false
+ default:
+ if escaped {
+ continue parts
+ }
+ escaped = false
+ }
+ buf.WriteRune(r)
+ }
+ newVal := buf.String()
+ if newVal == lit.Value {
+ break
+ }
+ s.modified = true
+ wps[i] = &SglQuoted{
+ Left: dq.Pos(),
+ Right: dq.End(),
+ Dollar: dq.Dollar,
+ Value: newVal,
+ }
+ }
+ return wps
+}
+
+func (s *simplifier) removeParensArithm(x ArithmExpr) ArithmExpr {
+ for {
+ par, _ := x.(*ParenArithm)
+ if par == nil {
+ return x
+ }
+ s.modified = true
+ x = par.X
+ }
+}
+
+func (s *simplifier) inlineSimpleParams(x ArithmExpr) ArithmExpr {
+ w, _ := x.(*Word)
+ if w == nil || len(w.Parts) != 1 {
+ return x
+ }
+ pe, _ := w.Parts[0].(*ParamExp)
+ if pe == nil || !ValidName(pe.Param.Value) {
+ // Not a parameter expansion, or not a valid name, like $3.
+ return x
+ }
+ if pe.Excl || pe.Length || pe.Width || pe.Slice != nil ||
+ pe.Repl != nil || pe.Exp != nil || pe.Index != nil {
+ // A complex parameter expansion can't be simplified.
+ //
+ // Note that index expressions can't generally be simplified
+ // either. It's fine to turn ${a[0]} into a[0], but others like
+ // a[*] are invalid in many shells including Bash.
+ return x
+ }
+ s.modified = true
+ return &Word{Parts: []WordPart{pe.Param}}
+}
+
+func (s *simplifier) inlineSubshell(stmts []*Stmt) []*Stmt {
+ for len(stmts) == 1 {
+ st := stmts[0]
+ if st.Negated || st.Background || st.Coprocess ||
+ len(st.Redirs) > 0 {
+ break
+ }
+ sub, _ := st.Cmd.(*Subshell)
+ if sub == nil {
+ break
+ }
+ s.modified = true
+ stmts = sub.Stmts
+ }
+ return stmts
+}
+
+func (s *simplifier) unquoteParams(x TestExpr) TestExpr {
+ w, _ := x.(*Word)
+ if w == nil || len(w.Parts) != 1 {
+ return x
+ }
+ dq, _ := w.Parts[0].(*DblQuoted)
+ if dq == nil || len(dq.Parts) != 1 {
+ return x
+ }
+ if _, ok := dq.Parts[0].(*ParamExp); !ok {
+ return x
+ }
+ s.modified = true
+ w.Parts = dq.Parts
+ return w
+}
+
+func (s *simplifier) removeParensTest(x TestExpr) TestExpr {
+ for {
+ par, _ := x.(*ParenTest)
+ if par == nil {
+ return x
+ }
+ s.modified = true
+ x = par.X
+ }
+}
+
+func (s *simplifier) removeNegateTest(x TestExpr) TestExpr {
+ u, _ := x.(*UnaryTest)
+ if u == nil || u.Op != TsNot {
+ return x
+ }
+ switch y := u.X.(type) {
+ case *UnaryTest:
+ switch y.Op {
+ case TsEmpStr:
+ y.Op = TsNempStr
+ s.modified = true
+ return y
+ case TsNempStr:
+ y.Op = TsEmpStr
+ s.modified = true
+ return y
+ case TsNot:
+ s.modified = true
+ return y.X
+ }
+ case *BinaryTest:
+ switch y.Op {
+ case TsMatch:
+ y.Op = TsNoMatch
+ s.modified = true
+ return y
+ case TsNoMatch:
+ y.Op = TsMatch
+ s.modified = true
+ return y
+ }
+ }
+ return x
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/token_string.go b/vendor/mvdan.cc/sh/v3/syntax/token_string.go
new file mode 100644
index 00000000..ab5c83ac
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/token_string.go
@@ -0,0 +1,149 @@
+// Code generated by "stringer -type token -linecomment -trimprefix _"; DO NOT EDIT.
+
+package syntax
+
+import "strconv"
+
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[illegalTok-0]
+ _ = x[_EOF-1]
+ _ = x[_Newl-2]
+ _ = x[_Lit-3]
+ _ = x[_LitWord-4]
+ _ = x[_LitRedir-5]
+ _ = x[sglQuote-6]
+ _ = x[dblQuote-7]
+ _ = x[bckQuote-8]
+ _ = x[and-9]
+ _ = x[andAnd-10]
+ _ = x[orOr-11]
+ _ = x[or-12]
+ _ = x[orAnd-13]
+ _ = x[dollar-14]
+ _ = x[dollSglQuote-15]
+ _ = x[dollDblQuote-16]
+ _ = x[dollBrace-17]
+ _ = x[dollBrack-18]
+ _ = x[dollParen-19]
+ _ = x[dollDblParen-20]
+ _ = x[leftBrack-21]
+ _ = x[dblLeftBrack-22]
+ _ = x[leftParen-23]
+ _ = x[dblLeftParen-24]
+ _ = x[rightBrace-25]
+ _ = x[rightBrack-26]
+ _ = x[rightParen-27]
+ _ = x[dblRightParen-28]
+ _ = x[semicolon-29]
+ _ = x[dblSemicolon-30]
+ _ = x[semiAnd-31]
+ _ = x[dblSemiAnd-32]
+ _ = x[semiOr-33]
+ _ = x[exclMark-34]
+ _ = x[tilde-35]
+ _ = x[addAdd-36]
+ _ = x[subSub-37]
+ _ = x[star-38]
+ _ = x[power-39]
+ _ = x[equal-40]
+ _ = x[nequal-41]
+ _ = x[lequal-42]
+ _ = x[gequal-43]
+ _ = x[addAssgn-44]
+ _ = x[subAssgn-45]
+ _ = x[mulAssgn-46]
+ _ = x[quoAssgn-47]
+ _ = x[remAssgn-48]
+ _ = x[andAssgn-49]
+ _ = x[orAssgn-50]
+ _ = x[xorAssgn-51]
+ _ = x[shlAssgn-52]
+ _ = x[shrAssgn-53]
+ _ = x[rdrOut-54]
+ _ = x[appOut-55]
+ _ = x[rdrIn-56]
+ _ = x[rdrInOut-57]
+ _ = x[dplIn-58]
+ _ = x[dplOut-59]
+ _ = x[clbOut-60]
+ _ = x[hdoc-61]
+ _ = x[dashHdoc-62]
+ _ = x[wordHdoc-63]
+ _ = x[rdrAll-64]
+ _ = x[appAll-65]
+ _ = x[cmdIn-66]
+ _ = x[cmdOut-67]
+ _ = x[plus-68]
+ _ = x[colPlus-69]
+ _ = x[minus-70]
+ _ = x[colMinus-71]
+ _ = x[quest-72]
+ _ = x[colQuest-73]
+ _ = x[assgn-74]
+ _ = x[colAssgn-75]
+ _ = x[perc-76]
+ _ = x[dblPerc-77]
+ _ = x[hash-78]
+ _ = x[dblHash-79]
+ _ = x[caret-80]
+ _ = x[dblCaret-81]
+ _ = x[comma-82]
+ _ = x[dblComma-83]
+ _ = x[at-84]
+ _ = x[slash-85]
+ _ = x[dblSlash-86]
+ _ = x[colon-87]
+ _ = x[tsExists-88]
+ _ = x[tsRegFile-89]
+ _ = x[tsDirect-90]
+ _ = x[tsCharSp-91]
+ _ = x[tsBlckSp-92]
+ _ = x[tsNmPipe-93]
+ _ = x[tsSocket-94]
+ _ = x[tsSmbLink-95]
+ _ = x[tsSticky-96]
+ _ = x[tsGIDSet-97]
+ _ = x[tsUIDSet-98]
+ _ = x[tsGrpOwn-99]
+ _ = x[tsUsrOwn-100]
+ _ = x[tsModif-101]
+ _ = x[tsRead-102]
+ _ = x[tsWrite-103]
+ _ = x[tsExec-104]
+ _ = x[tsNoEmpty-105]
+ _ = x[tsFdTerm-106]
+ _ = x[tsEmpStr-107]
+ _ = x[tsNempStr-108]
+ _ = x[tsOptSet-109]
+ _ = x[tsVarSet-110]
+ _ = x[tsRefVar-111]
+ _ = x[tsReMatch-112]
+ _ = x[tsNewer-113]
+ _ = x[tsOlder-114]
+ _ = x[tsDevIno-115]
+ _ = x[tsEql-116]
+ _ = x[tsNeq-117]
+ _ = x[tsLeq-118]
+ _ = x[tsGeq-119]
+ _ = x[tsLss-120]
+ _ = x[tsGtr-121]
+ _ = x[globQuest-122]
+ _ = x[globStar-123]
+ _ = x[globPlus-124]
+ _ = x[globAt-125]
+ _ = x[globExcl-126]
+}
+
+const _token_name = "illegalTokEOFNewlLitLitWordLitRedir'\"`&&&||||&$$'$\"${$[$($(([[[(((}])));;;;&;;&;|!~++--***==!=<=>=+=-=*=/=%=&=|=^=<<=>>=>>><<><&>&>|<<<<-<<<&>&>><(>(+:+-:-?:?=:=%%%###^^^,,,@///:-e-f-d-c-b-p-S-L-k-g-u-G-O-N-r-w-x-s-t-z-n-o-v-R=~-nt-ot-ef-eq-ne-le-ge-lt-gt?(*(+(@(!("
+
+var _token_index = [...]uint16{0, 10, 13, 17, 20, 27, 35, 36, 37, 38, 39, 41, 43, 44, 46, 47, 49, 51, 53, 55, 57, 60, 61, 63, 64, 66, 67, 68, 69, 71, 72, 74, 76, 79, 81, 82, 83, 85, 87, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 117, 120, 121, 123, 124, 126, 128, 130, 132, 134, 137, 140, 142, 145, 147, 149, 150, 152, 153, 155, 156, 158, 159, 161, 162, 164, 165, 167, 168, 170, 171, 173, 174, 175, 177, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 231, 234, 237, 240, 243, 246, 249, 252, 255, 257, 259, 261, 263, 265}
+
+func (i token) String() string {
+ if i >= token(len(_token_index)-1) {
+ return "token(" + strconv.FormatInt(int64(i), 10) + ")"
+ }
+ return _token_name[_token_index[i]:_token_index[i+1]]
+}
diff --git a/vendor/mvdan.cc/sh/v3/syntax/tokens.go b/vendor/mvdan.cc/sh/v3/syntax/tokens.go
new file mode 100644
index 00000000..6a64b213
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/tokens.go
@@ -0,0 +1,349 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+//go:generate stringer -type token -linecomment -trimprefix _
+
+type token uint32
+
+// The list of all possible tokens.
+const (
+ illegalTok token = iota
+
+ _EOF
+ _Newl
+ _Lit
+ _LitWord
+ _LitRedir
+
+ sglQuote // '
+ dblQuote // "
+ bckQuote // `
+
+ and // &
+ andAnd // &&
+ orOr // ||
+ or // |
+ orAnd // |&
+
+ dollar // $
+ dollSglQuote // $'
+ dollDblQuote // $"
+ dollBrace // ${
+ dollBrack // $[
+ dollParen // $(
+ dollDblParen // $((
+ leftBrack // [
+ dblLeftBrack // [[
+ leftParen // (
+ dblLeftParen // ((
+
+ rightBrace // }
+ rightBrack // ]
+ rightParen // )
+ dblRightParen // ))
+ semicolon // ;
+
+ dblSemicolon // ;;
+ semiAnd // ;&
+ dblSemiAnd // ;;&
+ semiOr // ;|
+
+ exclMark // !
+ tilde // ~
+ addAdd // ++
+ subSub // --
+ star // *
+ power // **
+ equal // ==
+ nequal // !=
+ lequal // <=
+ gequal // >=
+
+ addAssgn // +=
+ subAssgn // -=
+ mulAssgn // *=
+ quoAssgn // /=
+ remAssgn // %=
+ andAssgn // &=
+ orAssgn // |=
+ xorAssgn // ^=
+ shlAssgn // <<=
+ shrAssgn // >>=
+
+ rdrOut // >
+ appOut // >>
+ rdrIn // <
+ rdrInOut // <>
+ dplIn // <&
+ dplOut // >&
+ clbOut // >|
+ hdoc // <<
+ dashHdoc // <<-
+ wordHdoc // <<<
+ rdrAll // &>
+ appAll // &>>
+
+ cmdIn // <(
+ cmdOut // >(
+
+ plus // +
+ colPlus // :+
+ minus // -
+ colMinus // :-
+ quest // ?
+ colQuest // :?
+ assgn // =
+ colAssgn // :=
+ perc // %
+ dblPerc // %%
+ hash // #
+ dblHash // ##
+ caret // ^
+ dblCaret // ^^
+ comma // ,
+ dblComma // ,,
+ at // @
+ slash // /
+ dblSlash // //
+ colon // :
+
+ tsExists // -e
+ tsRegFile // -f
+ tsDirect // -d
+ tsCharSp // -c
+ tsBlckSp // -b
+ tsNmPipe // -p
+ tsSocket // -S
+ tsSmbLink // -L
+ tsSticky // -k
+ tsGIDSet // -g
+ tsUIDSet // -u
+ tsGrpOwn // -G
+ tsUsrOwn // -O
+ tsModif // -N
+ tsRead // -r
+ tsWrite // -w
+ tsExec // -x
+ tsNoEmpty // -s
+ tsFdTerm // -t
+ tsEmpStr // -z
+ tsNempStr // -n
+ tsOptSet // -o
+ tsVarSet // -v
+ tsRefVar // -R
+
+ tsReMatch // =~
+ tsNewer // -nt
+ tsOlder // -ot
+ tsDevIno // -ef
+ tsEql // -eq
+ tsNeq // -ne
+ tsLeq // -le
+ tsGeq // -ge
+ tsLss // -lt
+ tsGtr // -gt
+
+ globQuest // ?(
+ globStar // *(
+ globPlus // +(
+ globAt // @(
+ globExcl // !(
+)
+
+type RedirOperator token
+
+const (
+ RdrOut = RedirOperator(rdrOut) + iota // >
+ AppOut // >>
+ RdrIn // <
+ RdrInOut // <>
+ DplIn // <&
+ DplOut // >&
+ ClbOut // >|
+ Hdoc // <<
+ DashHdoc // <<-
+ WordHdoc // <<<
+ RdrAll // &>
+ AppAll // &>>
+)
+
+type ProcOperator token
+
+const (
+ CmdIn = ProcOperator(cmdIn) + iota // <(
+ CmdOut // >(
+)
+
+type GlobOperator token
+
+const (
+ GlobZeroOrOne = GlobOperator(globQuest) + iota // ?(
+ GlobZeroOrMore // *(
+ GlobOneOrMore // +(
+ GlobOne // @(
+ GlobExcept // !(
+)
+
+type BinCmdOperator token
+
+const (
+ AndStmt = BinCmdOperator(andAnd) + iota // &&
+ OrStmt // ||
+ Pipe // |
+ PipeAll // |&
+)
+
+type CaseOperator token
+
+const (
+ Break = CaseOperator(dblSemicolon) + iota // ;;
+ Fallthrough // ;&
+ Resume // ;;&
+ ResumeKorn // ;|
+)
+
+type ParNamesOperator token
+
+const (
+ NamesPrefix = ParNamesOperator(star) // *
+ NamesPrefixWords = ParNamesOperator(at) // @
+)
+
+type ParExpOperator token
+
+const (
+ AlternateUnset = ParExpOperator(plus) + iota // +
+ AlternateUnsetOrNull // :+
+ DefaultUnset // -
+ DefaultUnsetOrNull // :-
+ ErrorUnset // ?
+ ErrorUnsetOrNull // :?
+ AssignUnset // =
+ AssignUnsetOrNull // :=
+ RemSmallSuffix // %
+ RemLargeSuffix // %%
+ RemSmallPrefix // #
+ RemLargePrefix // ##
+ UpperFirst // ^
+ UpperAll // ^^
+ LowerFirst // ,
+ LowerAll // ,,
+ OtherParamOps // @
+)
+
+type UnAritOperator token
+
+const (
+ Not = UnAritOperator(exclMark) + iota // !
+ BitNegation // ~
+ Inc // ++
+ Dec // --
+ Plus = UnAritOperator(plus) // +
+ Minus = UnAritOperator(minus) // -
+)
+
+type BinAritOperator token
+
+const (
+ Add = BinAritOperator(plus) // +
+ Sub = BinAritOperator(minus) // -
+ Mul = BinAritOperator(star) // *
+ Quo = BinAritOperator(slash) // /
+ Rem = BinAritOperator(perc) // %
+ Pow = BinAritOperator(power) // **
+ Eql = BinAritOperator(equal) // ==
+ Gtr = BinAritOperator(rdrOut) // >
+ Lss = BinAritOperator(rdrIn) // <
+ Neq = BinAritOperator(nequal) // !=
+ Leq = BinAritOperator(lequal) // <=
+ Geq = BinAritOperator(gequal) // >=
+ And = BinAritOperator(and) // &
+ Or = BinAritOperator(or) // |
+ Xor = BinAritOperator(caret) // ^
+ Shr = BinAritOperator(appOut) // >>
+ Shl = BinAritOperator(hdoc) // <<
+
+ AndArit = BinAritOperator(andAnd) // &&
+ OrArit = BinAritOperator(orOr) // ||
+ Comma = BinAritOperator(comma) // ,
+ TernQuest = BinAritOperator(quest) // ?
+ TernColon = BinAritOperator(colon) // :
+
+ Assgn = BinAritOperator(assgn) // =
+ AddAssgn = BinAritOperator(addAssgn) // +=
+ SubAssgn = BinAritOperator(subAssgn) // -=
+ MulAssgn = BinAritOperator(mulAssgn) // *=
+ QuoAssgn = BinAritOperator(quoAssgn) // /=
+ RemAssgn = BinAritOperator(remAssgn) // %=
+ AndAssgn = BinAritOperator(andAssgn) // &=
+ OrAssgn = BinAritOperator(orAssgn) // |=
+ XorAssgn = BinAritOperator(xorAssgn) // ^=
+ ShlAssgn = BinAritOperator(shlAssgn) // <<=
+ ShrAssgn = BinAritOperator(shrAssgn) // >>=
+)
+
+type UnTestOperator token
+
+const (
+ TsExists = UnTestOperator(tsExists) + iota // -e
+ TsRegFile // -f
+ TsDirect // -d
+ TsCharSp // -c
+ TsBlckSp // -b
+ TsNmPipe // -p
+ TsSocket // -S
+ TsSmbLink // -L
+ TsSticky // -k
+ TsGIDSet // -g
+ TsUIDSet // -u
+ TsGrpOwn // -G
+ TsUsrOwn // -O
+ TsModif // -N
+ TsRead // -r
+ TsWrite // -w
+ TsExec // -x
+ TsNoEmpty // -s
+ TsFdTerm // -t
+ TsEmpStr // -z
+ TsNempStr // -n
+ TsOptSet // -o
+ TsVarSet // -v
+ TsRefVar // -R
+ TsNot = UnTestOperator(exclMark) // !
+)
+
+type BinTestOperator token
+
+const (
+ TsReMatch = BinTestOperator(tsReMatch) + iota // =~
+ TsNewer // -nt
+ TsOlder // -ot
+ TsDevIno // -ef
+ TsEql // -eq
+ TsNeq // -ne
+ TsLeq // -le
+ TsGeq // -ge
+ TsLss // -lt
+ TsGtr // -gt
+ AndTest = BinTestOperator(andAnd) // &&
+ OrTest = BinTestOperator(orOr) // ||
+ TsMatchShort = BinTestOperator(assgn) // =
+ TsMatch = BinTestOperator(equal) // ==
+ TsNoMatch = BinTestOperator(nequal) // !=
+ TsBefore = BinTestOperator(rdrIn) // <
+ TsAfter = BinTestOperator(rdrOut) // >
+)
+
+func (o RedirOperator) String() string { return token(o).String() }
+func (o ProcOperator) String() string { return token(o).String() }
+func (o GlobOperator) String() string { return token(o).String() }
+func (o BinCmdOperator) String() string { return token(o).String() }
+func (o CaseOperator) String() string { return token(o).String() }
+func (o ParNamesOperator) String() string { return token(o).String() }
+func (o ParExpOperator) String() string { return token(o).String() }
+func (o UnAritOperator) String() string { return token(o).String() }
+func (o BinAritOperator) String() string { return token(o).String() }
+func (o UnTestOperator) String() string { return token(o).String() }
+func (o BinTestOperator) String() string { return token(o).String() }
diff --git a/vendor/mvdan.cc/sh/v3/syntax/walk.go b/vendor/mvdan.cc/sh/v3/syntax/walk.go
new file mode 100644
index 00000000..5be8f9c6
--- /dev/null
+++ b/vendor/mvdan.cc/sh/v3/syntax/walk.go
@@ -0,0 +1,313 @@
+// Copyright (c) 2016, Daniel Martí
+// See LICENSE for licensing information
+
+package syntax
+
+import (
+ "fmt"
+ "io"
+ "reflect"
+)
+
+func walkStmts(stmts []*Stmt, last []Comment, f func(Node) bool) {
+ for _, s := range stmts {
+ Walk(s, f)
+ }
+ for _, c := range last {
+ Walk(&c, f)
+ }
+}
+
+func walkWords(words []*Word, f func(Node) bool) {
+ for _, w := range words {
+ Walk(w, f)
+ }
+}
+
+// Walk traverses a syntax tree in depth-first order: It starts by calling
+// f(node); node must not be nil. If f returns true, Walk invokes f
+// recursively for each of the non-nil children of node, followed by
+// f(nil).
+func Walk(node Node, f func(Node) bool) {
+ if !f(node) {
+ return
+ }
+
+ switch x := node.(type) {
+ case *File:
+ walkStmts(x.Stmts, x.Last, f)
+ case *Comment:
+ case *Stmt:
+ for _, c := range x.Comments {
+ if !x.End().After(c.Pos()) {
+ defer Walk(&c, f)
+ break
+ }
+ Walk(&c, f)
+ }
+ if x.Cmd != nil {
+ Walk(x.Cmd, f)
+ }
+ for _, r := range x.Redirs {
+ Walk(r, f)
+ }
+ case *Assign:
+ if x.Name != nil {
+ Walk(x.Name, f)
+ }
+ if x.Value != nil {
+ Walk(x.Value, f)
+ }
+ if x.Index != nil {
+ Walk(x.Index, f)
+ }
+ if x.Array != nil {
+ Walk(x.Array, f)
+ }
+ case *Redirect:
+ if x.N != nil {
+ Walk(x.N, f)
+ }
+ Walk(x.Word, f)
+ if x.Hdoc != nil {
+ Walk(x.Hdoc, f)
+ }
+ case *CallExpr:
+ for _, a := range x.Assigns {
+ Walk(a, f)
+ }
+ walkWords(x.Args, f)
+ case *Subshell:
+ walkStmts(x.Stmts, x.Last, f)
+ case *Block:
+ walkStmts(x.Stmts, x.Last, f)
+ case *IfClause:
+ walkStmts(x.Cond, x.CondLast, f)
+ walkStmts(x.Then, x.ThenLast, f)
+ if x.Else != nil {
+ Walk(x.Else, f)
+ }
+ case *WhileClause:
+ walkStmts(x.Cond, x.CondLast, f)
+ walkStmts(x.Do, x.DoLast, f)
+ case *ForClause:
+ Walk(x.Loop, f)
+ walkStmts(x.Do, x.DoLast, f)
+ case *WordIter:
+ Walk(x.Name, f)
+ walkWords(x.Items, f)
+ case *CStyleLoop:
+ if x.Init != nil {
+ Walk(x.Init, f)
+ }
+ if x.Cond != nil {
+ Walk(x.Cond, f)
+ }
+ if x.Post != nil {
+ Walk(x.Post, f)
+ }
+ case *BinaryCmd:
+ Walk(x.X, f)
+ Walk(x.Y, f)
+ case *FuncDecl:
+ Walk(x.Name, f)
+ Walk(x.Body, f)
+ case *Word:
+ for _, wp := range x.Parts {
+ Walk(wp, f)
+ }
+ case *Lit:
+ case *SglQuoted:
+ case *DblQuoted:
+ for _, wp := range x.Parts {
+ Walk(wp, f)
+ }
+ case *CmdSubst:
+ walkStmts(x.Stmts, x.Last, f)
+ case *ParamExp:
+ Walk(x.Param, f)
+ if x.Index != nil {
+ Walk(x.Index, f)
+ }
+ if x.Repl != nil {
+ if x.Repl.Orig != nil {
+ Walk(x.Repl.Orig, f)
+ }
+ if x.Repl.With != nil {
+ Walk(x.Repl.With, f)
+ }
+ }
+ if x.Exp != nil && x.Exp.Word != nil {
+ Walk(x.Exp.Word, f)
+ }
+ case *ArithmExp:
+ Walk(x.X, f)
+ case *ArithmCmd:
+ Walk(x.X, f)
+ case *BinaryArithm:
+ Walk(x.X, f)
+ Walk(x.Y, f)
+ case *BinaryTest:
+ Walk(x.X, f)
+ Walk(x.Y, f)
+ case *UnaryArithm:
+ Walk(x.X, f)
+ case *UnaryTest:
+ Walk(x.X, f)
+ case *ParenArithm:
+ Walk(x.X, f)
+ case *ParenTest:
+ Walk(x.X, f)
+ case *CaseClause:
+ Walk(x.Word, f)
+ for _, ci := range x.Items {
+ Walk(ci, f)
+ }
+ for _, c := range x.Last {
+ Walk(&c, f)
+ }
+ case *CaseItem:
+ for _, c := range x.Comments {
+ if c.Pos().After(x.Pos()) {
+ defer Walk(&c, f)
+ break
+ }
+ Walk(&c, f)
+ }
+ walkWords(x.Patterns, f)
+ walkStmts(x.Stmts, x.Last, f)
+ case *TestClause:
+ Walk(x.X, f)
+ case *DeclClause:
+ for _, a := range x.Args {
+ Walk(a, f)
+ }
+ case *ArrayExpr:
+ for _, el := range x.Elems {
+ Walk(el, f)
+ }
+ for _, c := range x.Last {
+ Walk(&c, f)
+ }
+ case *ArrayElem:
+ for _, c := range x.Comments {
+ if c.Pos().After(x.Pos()) {
+ defer Walk(&c, f)
+ break
+ }
+ Walk(&c, f)
+ }
+ if x.Index != nil {
+ Walk(x.Index, f)
+ }
+ if x.Value != nil {
+ Walk(x.Value, f)
+ }
+ case *ExtGlob:
+ Walk(x.Pattern, f)
+ case *ProcSubst:
+ walkStmts(x.Stmts, x.Last, f)
+ case *TimeClause:
+ if x.Stmt != nil {
+ Walk(x.Stmt, f)
+ }
+ case *CoprocClause:
+ if x.Name != nil {
+ Walk(x.Name, f)
+ }
+ Walk(x.Stmt, f)
+ case *LetClause:
+ for _, expr := range x.Exprs {
+ Walk(expr, f)
+ }
+ case *TestDecl:
+ Walk(x.Description, f)
+ Walk(x.Body, f)
+ default:
+ panic(fmt.Sprintf("syntax.Walk: unexpected node type %T", x))
+ }
+
+ f(nil)
+}
+
+// DebugPrint prints the provided syntax tree, spanning multiple lines and with
+// indentation. Can be useful to investigate the content of a syntax tree.
+func DebugPrint(w io.Writer, node Node) error {
+ p := debugPrinter{out: w}
+ p.print(reflect.ValueOf(node))
+ return p.err
+}
+
+type debugPrinter struct {
+ out io.Writer
+ level int
+ err error
+}
+
+func (p *debugPrinter) printf(format string, args ...any) {
+ _, err := fmt.Fprintf(p.out, format, args...)
+ if err != nil && p.err == nil {
+ p.err = err
+ }
+}
+
+func (p *debugPrinter) newline() {
+ p.printf("\n")
+ for i := 0; i < p.level; i++ {
+ p.printf(". ")
+ }
+}
+
+func (p *debugPrinter) print(x reflect.Value) {
+ switch x.Kind() {
+ case reflect.Interface:
+ if x.IsNil() {
+ p.printf("nil")
+ return
+ }
+ p.print(x.Elem())
+ case reflect.Ptr:
+ if x.IsNil() {
+ p.printf("nil")
+ return
+ }
+ p.printf("*")
+ p.print(x.Elem())
+ case reflect.Slice:
+ p.printf("%s (len = %d) {", x.Type(), x.Len())
+ if x.Len() > 0 {
+ p.level++
+ p.newline()
+ for i := 0; i < x.Len(); i++ {
+ p.printf("%d: ", i)
+ p.print(x.Index(i))
+ if i == x.Len()-1 {
+ p.level--
+ }
+ p.newline()
+ }
+ }
+ p.printf("}")
+
+ case reflect.Struct:
+ if v, ok := x.Interface().(Pos); ok {
+ p.printf("%v:%v", v.Line(), v.Col())
+ return
+ }
+ t := x.Type()
+ p.printf("%s {", t)
+ p.level++
+ p.newline()
+ for i := 0; i < t.NumField(); i++ {
+ p.printf("%s: ", t.Field(i).Name)
+ p.print(x.Field(i))
+ if i == x.NumField()-1 {
+ p.level--
+ }
+ p.newline()
+ }
+ p.printf("}")
+ default:
+ p.printf("%#v", x.Interface())
+ }
+}