diff --git a/go.mod b/go.mod index 66e1c82f4..a26be6f82 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.26.3 require ( github.com/google/go-containerregistry v0.21.5 - github.com/onsi/gomega v1.42.0 + github.com/onsi/gomega v1.44.0 github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 github.com/schollz/progressbar/v3 v3.19.0 github.com/shipwright-io/build v0.20.2 @@ -116,14 +116,14 @@ require ( go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.28.0 // indirect go.yaml.in/yaml/v2 v2.4.4 // indirect - go.yaml.in/yaml/v3 v3.0.4 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f // indirect - golang.org/x/net v0.55.0 // indirect + golang.org/x/net v0.56.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.20.0 // indirect - golang.org/x/sys v0.45.0 // indirect - golang.org/x/term v0.43.0 // indirect - golang.org/x/text v0.37.0 // indirect + golang.org/x/sync v0.21.0 // indirect + golang.org/x/sys v0.46.0 // indirect + golang.org/x/term v0.44.0 // indirect + golang.org/x/text v0.38.0 // indirect golang.org/x/time v0.14.0 // indirect gomodules.xyz/jsonpatch/v2 v2.5.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 // indirect diff --git a/go.sum b/go.sum index d2b8fafbc..96ef5f50e 100644 --- a/go.sum +++ b/go.sum @@ -173,8 +173,8 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/onsi/ginkgo/v2 v2.31.0 h1:GtuJos5DFUV9EerYJo8RhYxosYNGvOdDE5haKq6Grfs= github.com/onsi/ginkgo/v2 v2.31.0/go.mod h1:+aXOY+vzZ5mu2iI2HpTZUPmM//oQfsNFX6gU9kNcA44= -github.com/onsi/gomega v1.42.0 h1:CJby8u36xb7v34W78F8WKvqTQP7PCMIPB78IVDB73l4= -github.com/onsi/gomega v1.42.0/go.mod h1:M/Uqpu/8qTjtzCLUA2zJHX9Iilrau25x1PdoSRbWh5A= +github.com/onsi/gomega v1.44.0 h1:eAiGl3Pw5jz5GQdDff0BcxYpAX1JxW8xD7mFUuwNfZQ= +github.com/onsi/gomega v1.44.0/go.mod h1:e/C2HwaZ1DhvjzXXuFhcR7hY7Sh9pl7MmoWKEjzwcdA= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= @@ -208,8 +208,6 @@ github.com/schollz/progressbar/v3 v3.19.0 h1:Ea18xuIRQXLAUidVDox3AbwfUhD0/1Ivohy github.com/schollz/progressbar/v3 v3.19.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec= github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw= github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= -github.com/shipwright-io/build v0.20.0 h1:gwn7ch4NSNiilMhjK5TosAYbQl6zXS+N77LfaDYzB6Q= -github.com/shipwright-io/build v0.20.0/go.mod h1:4yGXARV6zi7BJCSaLGjBjFXtwCUqQvm1xfDN9g9dQPI= github.com/shipwright-io/build v0.20.2 h1:6RS6vhUI4j5aQOin10K3UFDcTVPCEsHeCg+QZFZqK2w= github.com/shipwright-io/build v0.20.2/go.mod h1:4yGXARV6zi7BJCSaLGjBjFXtwCUqQvm1xfDN9g9dQPI= github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= @@ -273,29 +271,30 @@ go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM= golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80= -golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM= -golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU= -golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= -golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= +golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= +golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= +golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= -golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= -golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= +golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= -golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4= -golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk= -golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= -golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= +golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= +golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= +golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= +golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI= golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4= -golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c= -golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI= +golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= +golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= gomodules.xyz/jsonpatch/v2 v2.5.0 h1:JELs8RLM12qJGXU4u/TO3V25KW8GreMKl9pdkk14RM0= gomodules.xyz/jsonpatch/v2 v2.5.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= diff --git a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count deleted file mode 100644 index 2bcb9c7d1..000000000 Binary files a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ diff --git a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends deleted file mode 100644 index 0cfbf0888..000000000 --- a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends +++ /dev/null @@ -1 +0,0 @@ -2 diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count deleted file mode 100644 index 07405d273..000000000 Binary files a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends deleted file mode 100644 index b8626c4cf..000000000 --- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends +++ /dev/null @@ -1 +0,0 @@ -4 diff --git a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count deleted file mode 100644 index dfd78a88d..000000000 Binary files a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ diff --git a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends deleted file mode 100644 index 1e8b31496..000000000 --- a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends +++ /dev/null @@ -1 +0,0 @@ -6 diff --git a/vendor/github.com/onsi/gomega/.gitignore b/vendor/github.com/onsi/gomega/.gitignore index 425d0a509..b3003b4e0 100644 --- a/vendor/github.com/onsi/gomega/.gitignore +++ b/vendor/github.com/onsi/gomega/.gitignore @@ -4,4 +4,5 @@ .idea gomega.iml TODO -.vscode \ No newline at end of file +.vscode +/.release/ diff --git a/vendor/github.com/onsi/gomega/CHANGELOG.md b/vendor/github.com/onsi/gomega/CHANGELOG.md index e7601cfde..07f33258c 100644 --- a/vendor/github.com/onsi/gomega/CHANGELOG.md +++ b/vendor/github.com/onsi/gomega/CHANGELOG.md @@ -1,3 +1,41 @@ +## Unreleased + +### Features + +### Fixes + +### Maintenance + +## 1.44.0 + +### Fixes +- `BeNumerically` compares signed and unsigned integers by value: `-1` no longer equals `uint64(math.MaxUint64)` and `uint(5)` is now greater than `-3` (#925) [26e3c6b] +- `BeNumerically("~")` no longer overflows when computing the distance between extreme integers (#928) [1955764] +- `BeNumerically("==", x, threshold)` now honors the threshold for floats, as it already did for integers (#927) [10e2aca] +- `HaveKeyWithValue` succeeds if any key accepted by the key matcher has a matching value, rather than depending on map iteration order (#929) [ffc577a] +- `HaveKey` and `HaveKeyWithValue` treat key and value matcher errors like `ContainElement` does: a match wins, and an error is only reported when nothing matches (#926) [dc91598] +- `MatchJSON` no longer treats numbers too large for a float64 as equal to one another (#930) [9d619a5] +- `MatchJSON` compares integers beyond ±2^53 exactly, so neighboring large integers (e.g. IDs) no longer match; all other numbers are still compared as float64s (#931) [8ef1aa7, 630fe12] +- `HaveExactElements` reports missing or extra elements that start at index 0, and reports the first extra element's index rather than the last (#934) [af1b777] +- `MatchYAML` compares every document in a multi-document stream rather than only the first; empty documents (e.g. a leading or trailing `---`) are ignored (#933) [2773796] +- `MatchXML` ignores namespace prefixes: elements and attributes are compared by namespace URI, and the URIs declared on each element must match whatever prefix they are bound to (#932) [c0dbd89, 2565350] + +## 1.43.1 + +### Maintenance +- Update go.yaml.in/yaml/v3 to v3.0.5 [d547015] +- Releases are now cut by a GitHub Actions workflow (Actions -> Release -> Run workflow) rather than by hand, with changelog entries collected under `## Unreleased` as the work happens. Releases still ship the stripped-down tree on `master-lite` - tests removed and Ginkgo dropped from `go.mod` - and the workflow now builds it and checks it on every push. See RELEASING.md. [e9dc84d] + +## 1.43.0 + +### Features + +Add gomock adaptor extension for using Gomega matchers with gomock + +## 1.42.1 + +Bump Dependencies + ## 1.42.0 Add a set of Claude skill as a marketplace plugin diff --git a/vendor/github.com/onsi/gomega/README.md b/vendor/github.com/onsi/gomega/README.md index 6eb36fdf8..ac545907f 100644 --- a/vendor/github.com/onsi/gomega/README.md +++ b/vendor/github.com/onsi/gomega/README.md @@ -1,6 +1,9 @@ -![Gomega: Ginkgo's Preferred Matcher Library](http://onsi.github.io/gomega/images/gomega.png) + + + Gomega: Ginkgo's Preferred Matcher Library + -[![test](https://github.com/onsi/gomega/actions/workflows/test.yml/badge.svg)](https://github.com/onsi/gomega/actions/workflows/test.yml) +[![test](https://github.com/onsi/gomega/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/onsi/gomega/actions/workflows/test.yml?query=branch%3Amaster) [![Gomega Docs](docs/images/docs-badge.svg)](https://onsi.github.io/gomega/) [![Sponsor onsi](docs/images/sponsor-badge.svg)](https://github.com/sponsors/onsi) Jump straight to the [docs](http://onsi.github.io/gomega/) to learn about Gomega, including a list of [all available matchers](http://onsi.github.io/gomega/#provided-matchers). diff --git a/vendor/github.com/onsi/gomega/RELEASING.md b/vendor/github.com/onsi/gomega/RELEASING.md index 9973fff49..fdbeb37cc 100644 --- a/vendor/github.com/onsi/gomega/RELEASING.md +++ b/vendor/github.com/onsi/gomega/RELEASING.md @@ -1,23 +1,143 @@ -A Gomega release is a tagged sha and a GitHub release. To cut a release: - -1. Ensure CHANGELOG.md is up to date. - - Use - ```bash - LAST_VERSION=$(git tag --sort=version:refname | tail -n1) - CHANGES=$(git log --pretty=format:'- %s [%h]' HEAD...$LAST_VERSION) - echo -e "## NEXT\n\n$CHANGES\n\n### Features\n\n### Fixes\n\n### Maintenance\n\n$(cat CHANGELOG.md)" > CHANGELOG.md - ``` - to update the changelog - - Categorize the changes into - - Breaking Changes (requires a major version) - - New Features (minor version) - - Fixes (fix version) - - Maintenance (which in general should not be mentioned in `CHANGELOG.md` as they have no user impact) -1. Update GOMEGA_VERSION in `gomega_dsl.go` -1. Commit, push, and release: - ``` - git commit -m "vM.m.p" - git push - gh release create "vM.m.p" - git fetch --tags origin master - ``` \ No newline at end of file +# Releasing Gomega + +A release is one GitHub Actions run: **Actions → Release → Run workflow → bump: patch | minor**, +from `master`. From the command line: + +```bash +gh workflow run release.yml -f bump=patch # or -f bump=minor +``` + +The run: + +1. Runs the whole test workflow (`test.yml`). Nothing else happens unless it passes. +2. Runs `scripts/release.sh`, which + - computes the next version from `GOMEGA_VERSION` in `gomega_dsl.go`, + - renames `## Unreleased` in `CHANGELOG.md` to `## X.Y.Z` (dropping empty `###` subsections) and + puts a fresh, empty `## Unreleased` above it, + - writes `GOMEGA_VERSION` and stamps the version into every plugin manifest + (`plugins/*/.claude-plugin/plugin.json`), so the Claude Code plugin ships in lockstep, + - commits that on `master` as `vX.Y.Z (full)`, as `github-actions[bot]`, + - builds the released tree on `master-lite` and tags **that** commit `vX.Y.Z` (see below), + - pushes `master`, `master-lite`, and the tag together (`git push --atomic`, fast-forward only), + - creates the GitHub release `vX.Y.Z`, whose notes are the body of `## X.Y.Z`. + +## master and master-lite + +Gomega uses Ginkgo for its own tests, and the go toolchain pulls a dependency's *test* dependencies +into consuming projects as indirect requirements — so a project that uses only Gomega would end up +with all of Ginkgo in its `go.mod`. Since 1.40.0, releases therefore ship a stripped-down tree: + +- `master` holds the real repository, tests and all. The release commit there is `vX.Y.Z (full)`, + and it is **not** what the go toolchain resolves. +- `master-lite` holds the released trees: the same tree with every `_test.go` file deleted and + `go.mod` re-tidied, which drops Ginkgo. `scripts/strip-tests.sh` does that, and asserts that the + result still builds and no longer requires Ginkgo. +- Each release adds one commit to `master-lite`: a merge whose tree is the stripped tree and whose + parents are the previous `master-lite` commit and the `vX.Y.Z (full)` commit on `master`. So + `master-lite`'s history connects to master's, and `git log master-lite` reads as the release + history. +- The `vX.Y.Z` tag is on that `master-lite` commit. It is what `go get github.com/onsi/gomega` + resolves, so `go build` never even sees the test files. + +The test workflow's **Check the released (lite) tree** job runs `scripts/strip-tests.sh` on every +push. If a non-test file ever imports Ginkgo, that job fails long before release day — the released +module could not be built otherwise. + +Release tags are not on `master`, so `git describe` on master does not find them. `GOMEGA_VERSION` +in `gomega_dsl.go` is the version of record, and `git tag --sort=version:refname | tail -n1` names +the latest release. + +If this release process ever causes unexpected changes for a project, please open an issue. + +### Never merge master-lite into master + +`master-lite` always looks ahead of `master`, because its newest commit merges master's release +commit. But its *tree* has the tests taken out, so merging or rebasing it back into master deletes +every `_test.go` file and drops Ginkgo from `go.mod` — cleanly, with no conflicts. GitHub's +"master-lite had recent pushes — Compare & pull request" banner is the one click to avoid. + +Nothing you do locally needs `master-lite`: the release workflow writes it from a fresh checkout. A +stale local `master-lite` branch is harmless, and you can delete it. + +`scripts/check-full-tree.sh` guards against a stripped master: it asserts that a checkout has +`_test.go` files and that `go.mod` requires Ginkgo. The test workflow runs it on every push and +`scripts/release.sh` runs it before cutting a release, so a stripped master gets reported plainly +instead of turning into a test run with nothing in it. + +### Cutting one release after another + +Work on master as usual between releases. The `vX.Y.Z (full)` commit the workflow pushed is an +ordinary commit: `git pull` fast-forwards onto it, it carries the released `CHANGELOG.md` and +`GOMEGA_VERSION`, and you add new `## Unreleased` entries above it. The next release repeats the +same two steps — a new `vX.Y.Z (full)` commit on master, and a new merge on `master-lite` whose +tree is the stripped version of it, carrying the tag. + +Nothing accumulates between releases, and nothing needs reconciling in either direction: each +`master-lite` commit's tree is built from the release commit rather than merged into the previous +one, so `git diff vX.Y.Z vX.Y.Z+1` over two releases shows only the real changes. + +## The changelog + +`CHANGELOG.md` starts with an `## Unreleased` section: + +```markdown +## Unreleased + +### Features + +### Fixes + +### Maintenance + +## 1.43.0 +... +``` + +Add an entry under `## Unreleased` with each user-facing change, as you make it. Never edit a +released section. Empty subsections are dropped when the section is released, so leaving +`### Maintenance` empty costs nothing. + +If `## Unreleased` has no entries (only blank lines and `###` headings), the release stops before +changing anything — and so does a re-run after a successful release. + +To draft entries from the commits since the last release: + +```bash +git log --pretty=format:'- %s [%h]' "$(git tag --sort=version:refname | tail -n1)"..HEAD +``` + +Categorize what you keep into + +- Breaking changes (these need a major version, which this workflow does not cut) +- `### Features` (minor version) +- `### Fixes` (patch version) +- `### Maintenance` (in general, changes with no user impact don't belong in the changelog at all) + +## If a release fails + +Open the failed run and click **Re-run failed jobs**. A re-run checks out the same commit as the +first attempt and computes the same version. It resumes based on what already exists: + +| Where it failed | What a re-run does | +|---|---| +| Tests, or before the push | Nothing reached GitHub. The re-run starts over. | +| The push (master or master-lite moved during the run) | The re-run fails the same way. Start a new run from the current master. | +| After the push (the tag `vX.Y.Z` is on GitHub) | The re-run builds from the tag instead of making new commits. | +| Creating the GitHub release | The release is created, or its notes are refreshed if it already exists. | + +Both branches and the tag are pushed together, so the tag being on GitHub means both release +commits are there too. + +## Trying the release script locally + +`GOMEGA_RELEASE_DRY_RUN=1 scripts/release.sh patch` does the whole release locally — the changelog +and version rewrites, the `master` commit, the stripped `master-lite` commit and the tag on it — +then skips the push and the GitHub release. It still checks `origin` for an existing tag and needs +`origin/master-lite`, so run it in a throwaway clone whose `origin` is a local bare repository, not +in your working copy. + +`scripts/strip-tests.sh` rewrites the working tree in place, so run *it* only on a throwaway +checkout too. + +The version and changelog logic lives in `scripts/release`, with its own Ginkgo suite +(`scripts/release/release_test.go`) that runs with the rest of the suites. diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go index 967d90d0d..cf4eaefae 100644 --- a/vendor/github.com/onsi/gomega/gomega_dsl.go +++ b/vendor/github.com/onsi/gomega/gomega_dsl.go @@ -22,7 +22,7 @@ import ( "github.com/onsi/gomega/types" ) -const GOMEGA_VERSION = "1.42.0" +const GOMEGA_VERSION = "1.44.0" const nilGomegaPanic = `You are trying to make an assertion, but haven't registered Gomega's fail handler. If you're using Ginkgo then you probably forgot to put your assertion in an It(). diff --git a/vendor/github.com/onsi/gomega/matchers.go b/vendor/github.com/onsi/gomega/matchers.go index bf5722605..e3e01f665 100644 --- a/vendor/github.com/onsi/gomega/matchers.go +++ b/vendor/github.com/onsi/gomega/matchers.go @@ -291,6 +291,8 @@ func HaveSuffix(suffix string, args ...any) types.GomegaMatcher { // MatchJSON succeeds if actual is a string or stringer of JSON that matches // the expected JSON. The JSONs are decoded and the resulting objects are compared via // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter. +// Numbers are compared as float64s, except for integers too large to be represented +// exactly by a float64 (beyond ±2^53), which are compared exactly. func MatchJSON(json any) types.GomegaMatcher { return &matchers.MatchJSONMatcher{ JSONToMatch: json, @@ -300,6 +302,8 @@ func MatchJSON(json any) types.GomegaMatcher { // MatchXML succeeds if actual is a string or stringer of XML that matches // the expected XML. The XMLs are decoded and the resulting objects are compared via // reflect.DeepEqual so things like whitespaces shouldn't matter. +// Namespace prefixes are ignored: element and attribute names are compared by +// namespace URI, and the namespace URIs declared on each element must match. func MatchXML(xml any) types.GomegaMatcher { return &matchers.MatchXMLMatcher{ XMLToMatch: xml, @@ -309,6 +313,8 @@ func MatchXML(xml any) types.GomegaMatcher { // MatchYAML succeeds if actual is a string or stringer of YAML that matches // the expected YAML. The YAML's are decoded and the resulting objects are compared via // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter. +// Multi-document YAML streams are compared document by document; empty documents +// (e.g. from a leading or trailing "---") are ignored. func MatchYAML(yaml any) types.GomegaMatcher { return &matchers.MatchYAMLMatcher{ YAMLToMatch: yaml, diff --git a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go index 355b362f4..ea8e5ba1d 100644 --- a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go +++ b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go @@ -9,6 +9,12 @@ type attributesSlice []xml.Attr func (attrs attributesSlice) Len() int { return len(attrs) } func (attrs attributesSlice) Less(i, j int) bool { - return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1 + if attrs[i].Name.Local != attrs[j].Name.Local { + return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1 + } + if attrs[i].Name.Space != attrs[j].Name.Space { + return strings.Compare(attrs[i].Name.Space, attrs[j].Name.Space) == -1 + } + return strings.Compare(attrs[i].Value, attrs[j].Value) == -1 } func (attrs attributesSlice) Swap(i, j int) { attrs[i], attrs[j] = attrs[j], attrs[i] } diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go index 7e6ce154e..02839f349 100644 --- a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go @@ -5,6 +5,7 @@ package matchers import ( "fmt" "math" + "math/big" "github.com/onsi/gomega/format" ) @@ -60,18 +61,12 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error) secondOperand = toFloat(matcher.CompareTo[1]) } success = matcher.matchFloats(toFloat(actual), toFloat(matcher.CompareTo[0]), secondOperand) - } else if isInteger(actual) { - var secondOperand int64 = 0 + } else if isInteger(actual) || isUnsignedInteger(actual) { + var threshold any = 0 if len(matcher.CompareTo) == 2 { - secondOperand = toInteger(matcher.CompareTo[1]) + threshold = matcher.CompareTo[1] } - success = matcher.matchIntegers(toInteger(actual), toInteger(matcher.CompareTo[0]), secondOperand) - } else if isUnsignedInteger(actual) { - var secondOperand uint64 = 0 - if len(matcher.CompareTo) == 2 { - secondOperand = toUnsignedInteger(matcher.CompareTo[1]) - } - success = matcher.matchUnsignedIntegers(toUnsignedInteger(actual), toUnsignedInteger(matcher.CompareTo[0]), secondOperand) + success = matcher.matchIntegers(toBigInt(actual), toBigInt(matcher.CompareTo[0]), threshold) } else { return false, fmt.Errorf("Failed to compare:\n%s\n%s:\n%s", format.Object(actual, 1), matcher.Comparator, format.Object(matcher.CompareTo[0], 1)) } @@ -79,40 +74,35 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error) return success, nil } -func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo, threshold int64) (success bool) { +// matchIntegers compares signed and unsigned integers by their exact mathematical value, using math/big so +// that neither mixing signedness nor computing the distance between the two values can overflow +func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo *big.Int, threshold any) (success bool) { switch matcher.Comparator { case "==", "~": - diff := actual - compareTo - return -threshold <= diff && diff <= threshold + distance := new(big.Int).Sub(actual, compareTo) + return isWithinThreshold(distance.Abs(distance), threshold) case ">": - return (actual > compareTo) + return actual.Cmp(compareTo) > 0 case ">=": - return (actual >= compareTo) + return actual.Cmp(compareTo) >= 0 case "<": - return (actual < compareTo) + return actual.Cmp(compareTo) < 0 case "<=": - return (actual <= compareTo) + return actual.Cmp(compareTo) <= 0 } return false } -func (matcher *BeNumericallyMatcher) matchUnsignedIntegers(actual, compareTo, threshold uint64) (success bool) { - switch matcher.Comparator { - case "==", "~": - if actual < compareTo { - actual, compareTo = compareTo, actual +// isWithinThreshold reports whether the (non-negative) distance is no greater than the threshold, which may be any number +func isWithinThreshold(distance *big.Int, threshold any) bool { + if isFloat(threshold) { + t := toFloat(threshold) + if math.IsNaN(t) { + return false } - return actual-compareTo <= threshold - case ">": - return (actual > compareTo) - case ">=": - return (actual >= compareTo) - case "<": - return (actual < compareTo) - case "<=": - return (actual <= compareTo) + return new(big.Float).SetInt(distance).Cmp(big.NewFloat(t)) <= 0 } - return false + return distance.Cmp(toBigInt(threshold)) <= 0 } func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold float64) (success bool) { @@ -120,6 +110,10 @@ func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold fl case "~": return math.Abs(actual-compareTo) <= threshold case "==": + // an explicit threshold is honored, as it is for integers; without one == means exact equality + if len(matcher.CompareTo) == 2 { + return math.Abs(actual-compareTo) <= threshold + } return (actual == compareTo) case ">": return (actual > compareTo) diff --git a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go index 8b2d297c5..18f7b2846 100644 --- a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go +++ b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go @@ -79,7 +79,7 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er if i >= lenMatchers { matcher.extraIndex = i success = false - continue + return } if i >= lenValues { @@ -110,10 +110,10 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er func (matcher *HaveExactElementsMatcher) FailureMessage(actual any) (message string) { message = format.Message(actual, "to have exact elements with", presentable(matcher.Elements)) - if matcher.missingIndex > 0 { + if matcher.missingIndex >= 0 { message = fmt.Sprintf("%s\nthe missing elements start from index %d", message, matcher.missingIndex) } - if matcher.extraIndex > 0 { + if matcher.extraIndex >= 0 { message = fmt.Sprintf("%s\nthe extra elements start from index %d", message, matcher.extraIndex) } if len(matcher.mismatchFailures) != 0 { @@ -131,6 +131,7 @@ func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual any) (mess func (matcher *HaveExactElementsMatcher) resetState() { matcher.mismatchFailures = nil - matcher.missingIndex = 0 - matcher.extraIndex = 0 + // -1 means "no missing/extra elements"; 0 is a valid starting index + matcher.missingIndex = -1 + matcher.extraIndex = -1 } diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go index 16630c18e..5b27babed 100644 --- a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go @@ -24,31 +24,41 @@ func (matcher *HaveKeyMatcher) Match(actual any) (success bool, err error) { keyMatcher = &EqualMatcher{Expected: matcher.Key} } + // As with ContainElement, a key the key matcher accepts wins regardless of + // errors on other keys; the matcher's (last) error is only reported when + // no key matches. + var lastError error if miter.IsSeq2(actual) { - var success bool - var err error + found := false miter.IterateKV(actual, func(k, v reflect.Value) bool { - success, err = keyMatcher.Match(k.Interface()) + success, err := keyMatcher.Match(k.Interface()) if err != nil { - err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error()) - return false + lastError = err + return true } - return !success + found = success + return !found }) - return success, err - } - - keys := reflect.ValueOf(actual).MapKeys() - for i := range keys { - success, err := keyMatcher.Match(keys[i].Interface()) - if err != nil { - return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error()) - } - if success { + if found { return true, nil } + } else { + keys := reflect.ValueOf(actual).MapKeys() + for i := range keys { + success, err := keyMatcher.Match(keys[i].Interface()) + if err != nil { + lastError = err + continue + } + if success { + return true, nil + } + } } + if lastError != nil { + return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, lastError.Error()) + } return false, nil } diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go index 0cd708153..29410a5fd 100644 --- a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go @@ -30,44 +30,46 @@ func (matcher *HaveKeyWithValueMatcher) Match(actual any) (success bool, err err valueMatcher = &EqualMatcher{Expected: matcher.Value} } + // As with ContainElement, an entry whose key and value both match wins + // regardless of errors on other entries; the (last) key or value matcher + // error is only reported when no entry matches. + var lastError error + entryMatches := func(k, v reflect.Value) bool { + success, err := keyMatcher.Match(k.Interface()) + if err != nil { + lastError = fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error()) + return false + } + if !success { + return false + } + success, err = valueMatcher.Match(v.Interface()) + if err != nil { + lastError = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error()) + return false + } + return success + } + if miter.IsSeq2(actual) { - var success bool - var err error + found := false miter.IterateKV(actual, func(k, v reflect.Value) bool { - success, err = keyMatcher.Match(k.Interface()) - if err != nil { - err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error()) - return false - } - if success { - success, err = valueMatcher.Match(v.Interface()) - if err != nil { - err = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error()) - return false - } - } - return !success + found = entryMatches(k, v) + return !found }) - return success, err - } - - keys := reflect.ValueOf(actual).MapKeys() - for i := range keys { - success, err := keyMatcher.Match(keys[i].Interface()) - if err != nil { - return false, fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error()) + if found { + return true, nil } - if success { - actualValue := reflect.ValueOf(actual).MapIndex(keys[i]) - success, err := valueMatcher.Match(actualValue.Interface()) - if err != nil { - return false, fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error()) + } else { + value := reflect.ValueOf(actual) + for _, k := range value.MapKeys() { + if entryMatches(k, value.MapIndex(k)) { + return true, nil } - return success, nil } } - return false, nil + return false, lastError } func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual any) (message string) { diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go index 331f289ab..96f5246f9 100644 --- a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go @@ -4,6 +4,9 @@ import ( "bytes" "encoding/json" "fmt" + "math/big" + "strconv" + "strings" "github.com/onsi/gomega/format" ) @@ -22,14 +25,103 @@ func (matcher *MatchJSONMatcher) Match(actual any) (success bool, err error) { var aval any var eval any - // this is guarded by prettyPrint - json.Unmarshal([]byte(actualString), &aval) - json.Unmarshal([]byte(expectedString), &eval) + // prettyPrint has already checked the syntax, so decoding is not expected to fail + if aval, err = decodeJSON(actualString); err != nil { + return false, fmt.Errorf("Actual '%s' should be valid JSON, but it is not.\nUnderlying error:%s", actualString, err) + } + if eval, err = decodeJSON(expectedString); err != nil { + return false, fmt.Errorf("Expected '%s' should be valid JSON, but it is not.\nUnderlying error:%s", expectedString, err) + } var equal bool equal, matcher.firstFailurePath = deepEqual(aval, eval) return equal, nil } +// decodeJSON decodes s as json.Unmarshal would into an any, except that +// integers too large to be represented exactly by a float64 are decoded as +// canonicalJSONNumbers, so that they are compared exactly rather than after +// rounding to the nearest float64. +func decodeJSON(s string) (any, error) { + decoder := json.NewDecoder(strings.NewReader(s)) + decoder.UseNumber() + var value any + if err := decoder.Decode(&value); err != nil { + return nil, err + } + return decodeJSONNumbers(value), nil +} + +func decodeJSONNumbers(value any) any { + switch v := value.(type) { + case []any: + for i, element := range v { + v[i] = decodeJSONNumbers(element) + } + case map[string]any: + for key, element := range v { + v[key] = decodeJSONNumbers(element) + } + case json.Number: + return decodeJSONNumber(v) + } + return value +} + +// canonicalJSONNumber is a JSON number written as its significant digits +// followed by a base-10 exponent, e.g. 12345678901234567890 and +// 1.234567890123456789e19 are both 123456789012345678900e1. Two JSON numbers +// have the same value exactly when they have the same canonical form. +type canonicalJSONNumber string + +// maxExactFloat64Integer is 2^53: every integer with a magnitude no greater +// than this is represented exactly by a float64. +var maxExactFloat64Integer = new(big.Int).Lsh(big.NewInt(1), 53) + +// decodeJSONNumber returns integers whose magnitude exceeds 2^53 in canonical +// form, and every other number as the float64 that json.Unmarshal would +// produce. Numbers that are not integers but are too large for a float64 are +// also returned in canonical form. +func decodeJSONNumber(n json.Number) any { + s, sign := string(n), "" + if rest, negative := strings.CutPrefix(s, "-"); negative { + s, sign = rest, "-" + } + mantissa, exponentString, _ := strings.Cut(strings.ToLower(s), "e") + integerPart, fractionPart, _ := strings.Cut(mantissa, ".") + + digits := strings.TrimLeft(integerPart+fractionPart, "0") + significantDigits := strings.TrimRight(digits, "0") + + // the exponent is parsed as a big.Int as JSON puts no limit on its size + exponent := new(big.Int) + if exponentString != "" { + exponent.SetString(exponentString, 10) // the syntax has been checked by the decoder + } + exponent.Add(exponent, big.NewInt(int64(len(digits)-len(significantDigits)-len(fractionPart)))) + canonical := canonicalJSONNumber(sign + significantDigits + "e" + exponent.String()) + + if significantDigits != "" && exponent.Sign() >= 0 && exceedsMaxExactFloat64Integer(significantDigits, exponent) { + return canonical + } + f, err := strconv.ParseFloat(string(n), 64) + if err != nil { + // the syntax has been checked, so the number must be too large for a float64 + return canonical + } + return f +} + +// exceedsMaxExactFloat64Integer reports whether significantDigits * 10^exponent, +// with exponent >= 0, is greater than 2^53. +func exceedsMaxExactFloat64Integer(significantDigits string, exponent *big.Int) bool { + if exponent.Cmp(big.NewInt(16)) >= 0 { + return true // 10^16 > 2^53 + } + value, _ := new(big.Int).SetString(significantDigits, 10) + value.Mul(value, new(big.Int).Exp(big.NewInt(10), exponent, nil)) + return value.Cmp(maxExactFloat64Integer) > 0 +} + func (matcher *MatchJSONMatcher) FailureMessage(actual any) (message string) { actualString, expectedString, _ := matcher.prettyPrint(actual) return formattedMessage(format.Message(actualString, "to match JSON of", expectedString), matcher.firstFailurePath) diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go index f7dcaf6fd..86bf2f2dc 100644 --- a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go @@ -83,9 +83,9 @@ func parseXmlContent(content string) (*xmlNode, error) { switch tok := tok.(type) { case xml.StartElement: - attrs := attributesSlice(tok.Attr) + attrs := withNormalizedNamespaceDeclarations(tok.Attr) sort.Sort(attrs) - allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: tok.Attr}) + allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: attrs}) case xml.EndElement: if len(allNodes) > 1 { allNodes[lastNodeIndex-1].Nodes = append(allNodes[lastNodeIndex-1].Nodes, lastNode) @@ -109,6 +109,22 @@ func parseXmlContent(content string) (*xmlNode, error) { return firstNode, nil } +// withNormalizedNamespaceDeclarations replaces the name of each xmlns="..." and +// xmlns:prefix="..." attribute with the same placeholder name, so that only the +// namespace URIs declared on the element are compared, not the prefixes bound +// to them. The decoder has already resolved element and attribute names to +// namespace URIs, so the prefixes play no other part in the comparison. +func withNormalizedNamespaceDeclarations(attrs []xml.Attr) attributesSlice { + normalized := make(attributesSlice, len(attrs)) + for i, attr := range attrs { + if attr.Name.Space == "xmlns" || (attr.Name.Space == "" && attr.Name.Local == "xmlns") { + attr.Name = xml.Name{Space: "xmlns"} + } + normalized[i] = attr + } + return normalized +} + func newXmlDecoder(reader io.Reader) *xml.Decoder { dec := xml.NewDecoder(reader) dec.CharsetReader = charset.NewReaderLabel diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go index c3da9bd48..a6c558d9c 100644 --- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go +++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go @@ -1,7 +1,9 @@ package matchers import ( + "errors" "fmt" + "io" "strings" "github.com/onsi/gomega/format" @@ -11,37 +13,60 @@ import ( type MatchYAMLMatcher struct { YAMLToMatch any firstFailurePath []any + // the 1-based number of the first mismatched document when comparing + // multi-document streams; 0 otherwise + firstFailureDocument int } func (matcher *MatchYAMLMatcher) Match(actual any) (success bool, err error) { + matcher.firstFailurePath = nil + matcher.firstFailureDocument = 0 + actualString, expectedString, err := matcher.toStrings(actual) if err != nil { return false, err } - var aval any - var eval any - - if err := yaml.Unmarshal([]byte(actualString), &aval); err != nil { + adocs, err := decodeYAMLDocuments(actualString) + if err != nil { return false, fmt.Errorf("Actual '%s' should be valid YAML, but it is not.\nUnderlying error:%s", actualString, err) } - if err := yaml.Unmarshal([]byte(expectedString), &eval); err != nil { + edocs, err := decodeYAMLDocuments(expectedString) + if err != nil { return false, fmt.Errorf("Expected '%s' should be valid YAML, but it is not.\nUnderlying error:%s", expectedString, err) } - var equal bool - equal, matcher.firstFailurePath = deepEqual(aval, eval) - return equal, nil + if len(adocs) != len(edocs) { + return false, nil + } + for i := range adocs { + var equal bool + equal, matcher.firstFailurePath = deepEqual(adocs[i], edocs[i]) + if !equal { + if len(adocs) > 1 { + matcher.firstFailureDocument = i + 1 + } + return false, nil + } + } + return true, nil } func (matcher *MatchYAMLMatcher) FailureMessage(actual any) (message string) { actualString, expectedString, _ := matcher.toNormalisedStrings(actual) - return formattedMessage(format.Message(actualString, "to match YAML of", expectedString), matcher.firstFailurePath) + return matcher.formattedMessage(format.Message(actualString, "to match YAML of", expectedString)) } func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual any) (message string) { actualString, expectedString, _ := matcher.toNormalisedStrings(actual) - return formattedMessage(format.Message(actualString, "not to match YAML of", expectedString), matcher.firstFailurePath) + return matcher.formattedMessage(format.Message(actualString, "not to match YAML of", expectedString)) +} + +func (matcher *MatchYAMLMatcher) formattedMessage(comparisonMessage string) string { + if matcher.firstFailureDocument > 0 { + comparisonMessage = fmt.Sprintf("%s\n\nfirst mismatched document: %d (counting from 1)", comparisonMessage, matcher.firstFailureDocument) + } + return formattedMessage(comparisonMessage, matcher.firstFailurePath) } func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatted, expectedFormatted string, err error) { @@ -50,16 +75,63 @@ func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatte } func normalise(input string) string { - var val any - err := yaml.Unmarshal([]byte(input), &val) + docs, err := decodeYAMLDocuments(input) if err != nil { - panic(err) // unreachable since Match already calls Unmarshal + panic(err) // unreachable since Match already decodes the input } - output, err := yaml.Marshal(val) - if err != nil { - panic(err) // untested section, unreachable since we Unmarshal above + outputs := make([]string, len(docs)) + for i, doc := range docs { + output, err := yaml.Marshal(doc) + if err != nil { + panic(err) // untested section, unreachable since we decode above + } + outputs[i] = string(output) + } + return strings.TrimSpace(strings.Join(outputs, "---\n")) +} + +// decodeYAMLDocuments decodes every document in a YAML stream. +// +// Empty documents - such as those produced by a leading or trailing "---" - are +// skipped, so "---\na: 1\n---\n" is the single document "a: 1". A stream with +// no documents at all is treated as a single null document, as yaml.Unmarshal +// does. +func decodeYAMLDocuments(input string) ([]any, error) { + docs := []any{} + decoder := yaml.NewDecoder(strings.NewReader(input)) + for { + var node yaml.Node + err := decoder.Decode(&node) + if errors.Is(err, io.EOF) { + break + } + if err != nil { + return nil, err + } + if isEmptyYAMLDocument(&node) { + continue + } + var doc any + if err := node.Decode(&doc); err != nil { + return nil, err + } + docs = append(docs, doc) + } + if len(docs) == 0 { + docs = append(docs, nil) + } + return docs, nil +} + +// isEmptyYAMLDocument reports whether a document has no content at all. +// Explicit nulls (e.g. "~" or "null") are content. +func isEmptyYAMLDocument(document *yaml.Node) bool { + if len(document.Content) != 1 { + return false } - return strings.TrimSpace(string(output)) + content := document.Content[0] + return content.Kind == yaml.ScalarNode && content.ShortTag() == "!!null" && content.Value == "" && + content.Style == 0 && content.Anchor == "" } func (matcher *MatchYAMLMatcher) toStrings(actual any) (actualFormatted, expectedFormatted string, err error) { diff --git a/vendor/github.com/onsi/gomega/matchers/type_support.go b/vendor/github.com/onsi/gomega/matchers/type_support.go index d020dedc3..89056f447 100644 --- a/vendor/github.com/onsi/gomega/matchers/type_support.go +++ b/vendor/github.com/onsi/gomega/matchers/type_support.go @@ -14,6 +14,7 @@ package matchers import ( "encoding/json" "fmt" + "math/big" "reflect" "github.com/onsi/gomega/matchers/internal/miter" @@ -52,26 +53,11 @@ func isFloat(a any) bool { return reflect.Float32 <= kind && kind <= reflect.Float64 } -func toInteger(a any) int64 { +func toBigInt(a any) *big.Int { if isInteger(a) { - return reflect.ValueOf(a).Int() - } else if isUnsignedInteger(a) { - return int64(reflect.ValueOf(a).Uint()) - } else if isFloat(a) { - return int64(reflect.ValueOf(a).Float()) - } - panic(fmt.Sprintf("Expected a number! Got <%T> %#v", a, a)) -} - -func toUnsignedInteger(a any) uint64 { - if isInteger(a) { - return uint64(reflect.ValueOf(a).Int()) - } else if isUnsignedInteger(a) { - return reflect.ValueOf(a).Uint() - } else if isFloat(a) { - return uint64(reflect.ValueOf(a).Float()) + return big.NewInt(reflect.ValueOf(a).Int()) } - panic(fmt.Sprintf("Expected a number! Got <%T> %#v", a, a)) + return new(big.Int).SetUint64(reflect.ValueOf(a).Uint()) } func toFloat(a any) float64 { diff --git a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count deleted file mode 100644 index 09ce56ae8..000000000 Binary files a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ diff --git a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends deleted file mode 100644 index 7ed6ff82d..000000000 --- a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends +++ /dev/null @@ -1 +0,0 @@ -5 diff --git a/vendor/go.yaml.in/yaml/v3/parserc.go b/vendor/go.yaml.in/yaml/v3/parserc.go index 25fe82363..f35829db4 100644 --- a/vendor/go.yaml.in/yaml/v3/parserc.go +++ b/vendor/go.yaml.in/yaml/v3/parserc.go @@ -226,9 +226,9 @@ func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool } // Parse the production: -// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END // -// ************ +// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +// ************ func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -249,13 +249,11 @@ func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) } // Parse the productions: -// implicit_document ::= block_node DOCUMENT-END* -// -// * // -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* -// -// ************************* +// implicit_document ::= block_node DOCUMENT-END* +// * +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// ************************* func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool { token := peek_token(parser) @@ -359,9 +357,9 @@ func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t } // Parse the productions: -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* // -// *********** +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// *********** func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -382,11 +380,10 @@ func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event } // Parse the productions: -// implicit_document ::= block_node DOCUMENT-END* -// -// ************* // -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +// implicit_document ::= block_node DOCUMENT-END* +// ************* +// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -432,42 +429,32 @@ func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t) } // Parse the productions: -// block_node_or_indentless_sequence ::= -// -// ALIAS -// ***** -// | properties (block_content | indentless_block_sequence)? -// ********** * -// | block_content | indentless_block_sequence -// * -// -// block_node ::= ALIAS -// -// ***** -// | properties block_content? -// ********** * -// | block_content -// * -// -// flow_node ::= ALIAS -// -// ***** -// | properties flow_content? -// ********** * -// | flow_content -// * -// -// properties ::= TAG ANCHOR? | ANCHOR TAG? -// -// ************************* -// -// block_content ::= block_collection | flow_collection | SCALAR -// -// ****** // -// flow_content ::= flow_collection | SCALAR -// -// ****** +// block_node_or_indentless_sequence ::= +// ALIAS +// ***** +// | properties (block_content | indentless_block_sequence)? +// ********** * +// | block_content | indentless_block_sequence +// * +// block_node ::= ALIAS +// ***** +// | properties block_content? +// ********** * +// | block_content +// * +// flow_node ::= ALIAS +// ***** +// | properties flow_content? +// ********** * +// | flow_content +// * +// properties ::= TAG ANCHOR? | ANCHOR TAG? +// ************************* +// block_content ::= block_collection | flow_collection | SCALAR +// ****** +// flow_content ::= flow_collection | SCALAR +// ****** func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool { //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)() @@ -697,9 +684,9 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i } // Parse the productions: -// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END // -// ******************** *********** * ********* +// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +// ******************** *********** * ********* func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { if first { token := peek_token(parser) @@ -755,9 +742,9 @@ func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_e } // Parse the productions: -// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ // -// *********** * +// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +// *********** * func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -821,15 +808,15 @@ func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) { } // Parse the productions: -// block_mapping ::= BLOCK-MAPPING_START // -// ******************* -// ((KEY block_node_or_indentless_sequence?)? -// *** * -// (VALUE block_node_or_indentless_sequence?)?)* +// block_mapping ::= BLOCK-MAPPING_START +// ******************* +// ((KEY block_node_or_indentless_sequence?)? +// *** * +// (VALUE block_node_or_indentless_sequence?)?)* // -// BLOCK-END -// ********* +// BLOCK-END +// ********* func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { if first { token := peek_token(parser) @@ -896,13 +883,14 @@ func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_even } // Parse the productions: -// block_mapping ::= BLOCK-MAPPING_START // -// ((KEY block_node_or_indentless_sequence?)? +// block_mapping ::= BLOCK-MAPPING_START +// +// ((KEY block_node_or_indentless_sequence?)? // -// (VALUE block_node_or_indentless_sequence?)?)* -// ***** * -// BLOCK-END +// (VALUE block_node_or_indentless_sequence?)?)* +// ***** * +// BLOCK-END func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -929,19 +917,17 @@ func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_ev } // Parse the productions: -// flow_sequence ::= FLOW-SEQUENCE-START -// -// ******************* -// (flow_sequence_entry FLOW-ENTRY)* -// * ********** -// flow_sequence_entry? -// * -// FLOW-SEQUENCE-END -// ***************** // -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// -// * +// flow_sequence ::= FLOW-SEQUENCE-START +// ******************* +// (flow_sequence_entry FLOW-ENTRY)* +// * ********** +// flow_sequence_entry? +// * +// FLOW-SEQUENCE-END +// ***************** +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { if first { token := peek_token(parser) @@ -1005,9 +991,9 @@ func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_ev } // Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? // -// *** * +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// *** * func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -1026,9 +1012,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, ev } // Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? // -// ***** * +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// ***** * func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -1050,9 +1036,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, } // Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? // -// * +// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool { token := peek_token(parser) if token == nil { @@ -1068,18 +1054,17 @@ func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, ev } // Parse the productions: -// flow_mapping ::= FLOW-MAPPING-START -// -// ****************** -// (flow_mapping_entry FLOW-ENTRY)* -// * ********** -// flow_mapping_entry? -// ****************** -// FLOW-MAPPING-END -// **************** // -// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// - *** * +// flow_mapping ::= FLOW-MAPPING-START +// ****************** +// (flow_mapping_entry FLOW-ENTRY)* +// * ********** +// flow_mapping_entry? +// ****************** +// FLOW-MAPPING-END +// **************** +// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * *** * func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { if first { token := peek_token(parser) @@ -1144,8 +1129,9 @@ func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event } // Parse the productions: -// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// - ***** * +// +// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +// * ***** * func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool { token := peek_token(parser) if token == nil { diff --git a/vendor/go.yaml.in/yaml/v3/yamlh.go b/vendor/go.yaml.in/yaml/v3/yamlh.go index f59aa40f6..07c442361 100644 --- a/vendor/go.yaml.in/yaml/v3/yamlh.go +++ b/vendor/go.yaml.in/yaml/v3/yamlh.go @@ -433,21 +433,19 @@ type yaml_document_t struct { // The prototype of a read handler. // -// The read handler is called when the parser needs to read more bytes from the -// source. The handler should write not more than size bytes to the buffer. -// The number of written bytes should be set to the size_read variable. +// The read handler is called when the parser needs to read more bytes from the +// source. The handler should write not more than size bytes to the buffer. +// The number of written bytes should be set to the size_read variable. // -// [in,out] data A pointer to an application data specified by +// [in,out] data A pointer to an application data specified by +// yaml_parser_set_input(). +// [out] buffer The buffer to write the data from the source. +// [in] size The size of the buffer. +// [out] size_read The actual number of bytes read from the source. // -// yaml_parser_set_input(). -// -// [out] buffer The buffer to write the data from the source. -// [in] size The size of the buffer. -// [out] size_read The actual number of bytes read from the source. -// -// On success, the handler should return 1. If the handler failed, -// the returned value should be 0. On EOF, the handler should set the -// size_read to 0 and return 1. +// On success, the handler should return 1. If the handler failed, +// the returned value should be 0. On EOF, the handler should set the +// size_read to 0 and return 1. type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error) // This structure holds information about a potential simple key. @@ -655,19 +653,17 @@ type yaml_comment_t struct { // The prototype of a write handler. // -// The write handler is called when the emitter needs to flush the accumulated -// characters to the output. The handler should write @a size bytes of the -// @a buffer to the output. -// -// @param[in,out] data A pointer to an application data specified by -// -// yaml_emitter_set_output(). +// The write handler is called when the emitter needs to flush the accumulated +// characters to the output. The handler should write @a size bytes of the +// @a buffer to the output. // -// @param[in] buffer The buffer with bytes to be written. -// @param[in] size The size of the buffer. +// @param[in,out] data A pointer to an application data specified by +// yaml_emitter_set_output(). +// @param[in] buffer The buffer with bytes to be written. +// @param[in] size The size of the buffer. // -// @returns On success, the handler should return @c 1. If the handler failed, -// the returned value should be @c 0. +// @returns On success, the handler should return @c 1. If the handler failed, +// the returned value should be @c 0. type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error type yaml_emitter_state_t int diff --git a/vendor/golang.org/x/net/html/entity.go b/vendor/golang.org/x/net/html/entity.go index b628880a0..4e8d5d55f 100644 --- a/vendor/golang.org/x/net/html/entity.go +++ b/vendor/golang.org/x/net/html/entity.go @@ -2156,9 +2156,8 @@ var entity = map[string]rune{ // HTML entities that are two unicode codepoints. var entity2 = map[string][2]rune{ - // TODO(nigeltao): Handle replacements that are wider than their names. - // "nLt;": {'\u226A', '\u20D2'}, - // "nGt;": {'\u226B', '\u20D2'}, + "nLt;": {'\u226A', '\u20D2'}, + "nGt;": {'\u226B', '\u20D2'}, "NotEqualTilde;": {'\u2242', '\u0338'}, "NotGreaterFullEqual;": {'\u2267', '\u0338'}, "NotGreaterGreater;": {'\u226B', '\u0338'}, diff --git a/vendor/golang.org/x/net/html/escape.go b/vendor/golang.org/x/net/html/escape.go index 12f227370..df3edc5b1 100644 --- a/vendor/golang.org/x/net/html/escape.go +++ b/vendor/golang.org/x/net/html/escape.go @@ -6,6 +6,7 @@ package html import ( "bytes" + "slices" "strings" "unicode/utf8" ) @@ -50,25 +51,24 @@ var replacementTable = [...]rune{ // 0x0D->'\u000D' is a no-op. } -// unescapeEntity reads an entity like "<" from b[src:] and writes the -// corresponding "<" to b[dst:], returning the incremented dst and src cursors. -// Precondition: b[src] == '&' && dst <= src. -// attribute should be true if parsing an attribute value. -func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) { +// unescapeEntity attempts to consume a character reference from s[src:], +// returning the rune, potential second rune, and number of bytes consumed +// (which indicates the length of the character reference). It is assumed that +// the first byte of s is '&'. attribute should be true if parsing an attribute +// value. +func unescapeEntity(s []byte, attribute bool) (rune, rune, int) { // https://html.spec.whatwg.org/multipage/syntax.html#consume-a-character-reference // i starts at 1 because we already know that s[0] == '&'. - i, s := 1, b[src:] + i := 1 if len(s) <= 1 { - b[dst] = b[src] - return dst + 1, src + 1 + return '&', 0, 1 } if s[i] == '#' { - if len(s) <= 3 { // We need to have at least "&#.". - b[dst] = b[src] - return dst + 1, src + 1 + if len(s) <= 2 { // We need to have at least "&#". + return '&', 0, 1 } i++ c := s[i] @@ -78,34 +78,43 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) { i++ } + i0 := i x := '\x00' for i < len(s) { c = s[i] - i++ + var d rune + var mult rune if hex { + mult = 16 if '0' <= c && c <= '9' { - x = 16*x + rune(c) - '0' - continue + d = rune(c) - '0' } else if 'a' <= c && c <= 'f' { - x = 16*x + rune(c) - 'a' + 10 - continue + d = rune(c) - 'a' + 10 } else if 'A' <= c && c <= 'F' { - x = 16*x + rune(c) - 'A' + 10 - continue + d = rune(c) - 'A' + 10 + } else { + break + } + } else { + mult = 10 + if '0' <= c && c <= '9' { + d = rune(c) - '0' + } else { + break } - } else if '0' <= c && c <= '9' { - x = 10*x + rune(c) - '0' - continue } - if c != ';' { - i-- + if x <= 0x10FFFF { + x = mult*x + d } - break + i++ + } + + if i == i0 { // No characters matched. + return '&', 0, 1 } - if i <= 3 { // No characters matched. - b[dst] = b[src] - return dst + 1, src + 1 + if i < len(s) && s[i] == ';' { + i++ } if 0x80 <= x && x <= 0x9F { @@ -116,7 +125,7 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) { x = '\uFFFD' } - return dst + utf8.EncodeRune(b[dst:], x), src + i + return x, 0, i } // Consume the maximum number of characters possible, with the @@ -141,10 +150,9 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) { } else if attribute && entityName[len(entityName)-1] != ';' && len(s) > i && s[i] == '=' { // No-op. } else if x := entity[entityName]; x != 0 { - return dst + utf8.EncodeRune(b[dst:], x), src + i + return x, 0, i } else if x := entity2[entityName]; x[0] != 0 { - dst1 := dst + utf8.EncodeRune(b[dst:], x[0]) - return dst1 + utf8.EncodeRune(b[dst1:], x[1]), src + i + return x[0], x[1], i } else if !attribute { maxLen := len(entityName) - 1 if maxLen > longestEntityWithoutSemicolon { @@ -152,35 +160,67 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) { } for j := maxLen; j > 1; j-- { if x := entity[entityName[:j]]; x != 0 { - return dst + utf8.EncodeRune(b[dst:], x), src + j + 1 + return x, 0, j + 1 } } } - dst1, src1 = dst+i, src+i - copy(b[dst:dst1], b[src:src1]) - return dst1, src1 + return '&', 0, 1 } -// unescape unescapes b's entities in-place, so that "a<b" becomes "a entityNameLen { + if reusingB { + out = slices.Clone(out) + reusingB = false } - return b[0:dst] + out = slices.Grow(out, replLen) + } + out = utf8.AppendRune(out, r1) + if r2 != 0 { + out = utf8.AppendRune(out, r2) } + + src += entityNameLen } - return b + + return out } // lower lower-cases the A-Z bytes in b in-place, so that "aBc" becomes "abc". diff --git a/vendor/golang.org/x/net/html/foreign.go b/vendor/golang.org/x/net/html/foreign.go index e8515d8e8..65d01d1ed 100644 --- a/vendor/golang.org/x/net/html/foreign.go +++ b/vendor/golang.org/x/net/html/foreign.go @@ -23,7 +23,7 @@ func adjustForeignAttributes(aa []Attribute) { } switch a.Key { case "xlink:actuate", "xlink:arcrole", "xlink:href", "xlink:role", "xlink:show", - "xlink:title", "xlink:type", "xml:base", "xml:lang", "xml:space", "xmlns:xlink": + "xlink:title", "xlink:type", "xml:lang", "xml:space", "xmlns:xlink": j := strings.Index(a.Key, ":") aa[i].Namespace = a.Key[:j] aa[i].Key = a.Key[j+1:] diff --git a/vendor/golang.org/x/net/html/parse.go b/vendor/golang.org/x/net/html/parse.go index b3d2a2558..165b6108d 100644 --- a/vendor/golang.org/x/net/html/parse.go +++ b/vendor/golang.org/x/net/html/parse.go @@ -63,7 +63,7 @@ func (p *parser) top() *Node { // Stop tags for use in popUntil. These come from section 12.2.4.2. var ( defaultScopeStopTags = map[string][]a.Atom{ - "": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template}, + "": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template, a.Select}, "math": {a.AnnotationXml, a.Mi, a.Mn, a.Mo, a.Ms, a.Mtext}, "svg": {a.Desc, a.ForeignObject, a.Title}, } @@ -78,7 +78,6 @@ const ( tableScope tableRowScope tableBodyScope - selectScope ) // popUntil pops the stack of open elements at the highest element whose tag @@ -133,10 +132,6 @@ func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int { if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template { return -1 } - case selectScope: - if tagAtom != a.Optgroup && tagAtom != a.Option { - return -1 - } default: panic(fmt.Sprintf("html: internal error: indexOfElementInScope unknown scope: %d", s)) } @@ -460,21 +455,6 @@ func (p *parser) resetInsertionMode() { } switch n.DataAtom { - case a.Select: - if !last { - for ancestor, first := n, p.oe[0]; ancestor != first; { - ancestor = p.oe[p.oe.index(ancestor)-1] - switch ancestor.DataAtom { - case a.Template: - p.im = inSelectIM - return - case a.Table: - p.im = inSelectInTableIM - return - } - } - } - p.im = inSelectIM case a.Td, a.Th: // TODO: remove this divergence from the HTML5 spec. // @@ -1002,7 +982,10 @@ func inBodyIM(p *parser) bool { p.popUntil(buttonScope, a.P) p.addElement() case a.Button: - p.popUntil(defaultScope, a.Button) + if p.elementInScope(defaultScope, a.Button) { + p.generateImpliedEndTags() + p.popUntil(defaultScope, a.Button) + } p.reconstructActiveFormattingElements() p.addElement() p.framesetOK = false @@ -1040,7 +1023,18 @@ func inBodyIM(p *parser) bool { p.framesetOK = false p.im = inTableIM return true - case a.Area, a.Br, a.Embed, a.Img, a.Input, a.Keygen, a.Wbr: + case a.Area, a.Br, a.Embed, a.Img, a.Keygen, a.Wbr: + p.reconstructActiveFormattingElements() + p.addElement() + p.oe.pop() + p.acknowledgeSelfClosingTag() + p.framesetOK = false + case a.Input: + if p.fragment && p.context.DataAtom == a.Select { + // Ignore the token. + return true + } + p.popUntil(defaultScope, a.Select) p.reconstructActiveFormattingElements() p.addElement() p.oe.pop() @@ -1061,7 +1055,13 @@ func inBodyIM(p *parser) bool { p.oe.pop() p.acknowledgeSelfClosingTag() case a.Hr: - p.popUntil(buttonScope, a.P) + if p.elementInScope(buttonScope, a.P) { + p.generateImpliedEndTags("p") + p.popUntil(defaultScope, a.P) + } + if p.elementInScope(defaultScope, a.Select) { + p.generateImpliedEndTags() + } p.addElement() p.oe.pop() p.acknowledgeSelfClosingTag() @@ -1095,13 +1095,30 @@ func inBodyIM(p *parser) bool { // Don't let the tokenizer go into raw text mode when scripting is disabled. p.tokenizer.NextIsNotRawText() case a.Select: + if p.fragment && p.context.DataAtom == a.Select { + // Ignore the token. + return true + } else if p.popUntil(defaultScope, a.Select) { + return true + } p.reconstructActiveFormattingElements() p.addElement() p.framesetOK = false - p.im = inSelectIM return true - case a.Optgroup, a.Option: - if p.top().DataAtom == a.Option { + case a.Option: + if p.elementInScope(defaultScope, a.Select) { + p.generateImpliedEndTags("optgroup") + // If oe has option element in scope, parse error? + } else if p.top().DataAtom == a.Option { + p.oe.pop() + } + p.reconstructActiveFormattingElements() + p.addElement() + case a.Optgroup: + if p.elementInScope(defaultScope, a.Select) { + p.generateImpliedEndTags() + // If oe has option or optgroup element in scope, parse error? + } else if p.top().DataAtom == a.Option { p.oe.pop() } p.reconstructActiveFormattingElements() @@ -1149,7 +1166,12 @@ func inBodyIM(p *parser) bool { return false } return true - case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Main, a.Menu, a.Nav, a.Ol, a.Pre, a.Search, a.Section, a.Summary, a.Ul: + case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Main, a.Menu, a.Nav, a.Ol, a.Pre, a.Search, a.Section, a.Select, a.Summary, a.Ul: + if !p.elementInScope(defaultScope, p.tok.DataAtom) { + // Ignore the token. + return true + } + p.generateImpliedEndTags() p.popUntil(defaultScope, p.tok.DataAtom) case a.Form: if p.oe.contains(a.Template) { @@ -1488,17 +1510,6 @@ func inTableIM(p *parser) bool { } p.addElement() p.form = p.oe.pop() - case a.Select: - p.reconstructActiveFormattingElements() - switch p.top().DataAtom { - case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr: - p.fosterParenting = true - } - p.addElement() - p.fosterParenting = false - p.framesetOK = false - p.im = inSelectInTableIM - return true } case EndTagToken: switch p.tok.DataAtom { @@ -1547,12 +1558,6 @@ func inCaptionIM(p *parser) bool { p.clearActiveFormattingElements() p.im = inTableIM return false - case a.Select: - p.reconstructActiveFormattingElements() - p.addElement() - p.framesetOK = false - p.im = inSelectInTableIM - return true } case EndTagToken: switch p.tok.DataAtom { @@ -1762,12 +1767,6 @@ func inCellIM(p *parser) bool { } // Ignore the token. return true - case a.Select: - p.reconstructActiveFormattingElements() - p.addElement() - p.framesetOK = false - p.im = inSelectInTableIM - return true } case EndTagToken: switch p.tok.DataAtom { @@ -1798,118 +1797,6 @@ func inCellIM(p *parser) bool { return inBodyIM(p) } -// Section 12.2.6.4.16. -func inSelectIM(p *parser) bool { - switch p.tok.Type { - case TextToken: - p.addText(strings.Replace(p.tok.Data, "\x00", "", -1)) - case StartTagToken: - switch p.tok.DataAtom { - case a.Html: - return inBodyIM(p) - case a.Option: - if p.top().DataAtom == a.Option { - p.oe.pop() - } - p.addElement() - case a.Optgroup: - if p.top().DataAtom == a.Option { - p.oe.pop() - } - if p.top().DataAtom == a.Optgroup { - p.oe.pop() - } - p.addElement() - case a.Select: - if !p.popUntil(selectScope, a.Select) { - // Ignore the token. - return true - } - p.resetInsertionMode() - case a.Input, a.Keygen, a.Textarea: - if p.elementInScope(selectScope, a.Select) { - p.parseImpliedToken(EndTagToken, a.Select, a.Select.String()) - return false - } - // In order to properly ignore