diff options
Diffstat (limited to 'vendor/github.com')
23 files changed, 2256 insertions, 316 deletions
diff --git a/vendor/github.com/hashicorp/golang-lru/v2/.gitignore b/vendor/github.com/hashicorp/golang-lru/v2/.gitignore new file mode 100644 index 000000000..836562412 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/.gitignore @@ -0,0 +1,23 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe +*.test diff --git a/vendor/github.com/hashicorp/golang-lru/v2/.golangci.yml b/vendor/github.com/hashicorp/golang-lru/v2/.golangci.yml new file mode 100644 index 000000000..7e7b8a962 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/.golangci.yml @@ -0,0 +1,46 @@ +# Copyright (c) HashiCorp, Inc. +# SPDX-License-Identifier: MPL-2.0 + +linters: + fast: false + disable-all: true + enable: + - revive + - megacheck + - govet + - unconvert + - gas + - gocyclo + - dupl + - misspell + - unparam + - unused + - typecheck + - ineffassign + # - stylecheck + - exportloopref + - gocritic + - nakedret + - gosimple + - prealloc + +# golangci-lint configuration file +linters-settings: + revive: + ignore-generated-header: true + severity: warning + rules: + - name: package-comments + severity: warning + disabled: true + - name: exported + severity: warning + disabled: false + arguments: ["checkPrivateReceivers", "disableStutteringCheck"] + +issues: + exclude-use-default: false + exclude-rules: + - path: _test\.go + linters: + - dupl diff --git a/vendor/github.com/hashicorp/golang-lru/v2/2q.go b/vendor/github.com/hashicorp/golang-lru/v2/2q.go new file mode 100644 index 000000000..8c95252b6 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/2q.go @@ -0,0 +1,267 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package lru + +import ( + "errors" + "sync" + + "github.com/hashicorp/golang-lru/v2/simplelru" +) + +const ( + // Default2QRecentRatio is the ratio of the 2Q cache dedicated + // to recently added entries that have only been accessed once. + Default2QRecentRatio = 0.25 + + // Default2QGhostEntries is the default ratio of ghost + // entries kept to track entries recently evicted + Default2QGhostEntries = 0.50 +) + +// TwoQueueCache is a thread-safe fixed size 2Q cache. +// 2Q is an enhancement over the standard LRU cache +// in that it tracks both frequently and recently used +// entries separately. This avoids a burst in access to new +// entries from evicting frequently used entries. It adds some +// additional tracking overhead to the standard LRU cache, and is +// computationally about 2x the cost, and adds some metadata over +// head. The ARCCache is similar, but does not require setting any +// parameters. +type TwoQueueCache[K comparable, V any] struct { + size int + recentSize int + recentRatio float64 + ghostRatio float64 + + recent simplelru.LRUCache[K, V] + frequent simplelru.LRUCache[K, V] + recentEvict simplelru.LRUCache[K, struct{}] + lock sync.RWMutex +} + +// New2Q creates a new TwoQueueCache using the default +// values for the parameters. +func New2Q[K comparable, V any](size int) (*TwoQueueCache[K, V], error) { + return New2QParams[K, V](size, Default2QRecentRatio, Default2QGhostEntries) +} + +// New2QParams creates a new TwoQueueCache using the provided +// parameter values. +func New2QParams[K comparable, V any](size int, recentRatio, ghostRatio float64) (*TwoQueueCache[K, V], error) { + if size <= 0 { + return nil, errors.New("invalid size") + } + if recentRatio < 0.0 || recentRatio > 1.0 { + return nil, errors.New("invalid recent ratio") + } + if ghostRatio < 0.0 || ghostRatio > 1.0 { + return nil, errors.New("invalid ghost ratio") + } + + // Determine the sub-sizes + recentSize := int(float64(size) * recentRatio) + evictSize := int(float64(size) * ghostRatio) + + // Allocate the LRUs + recent, err := simplelru.NewLRU[K, V](size, nil) + if err != nil { + return nil, err + } + frequent, err := simplelru.NewLRU[K, V](size, nil) + if err != nil { + return nil, err + } + recentEvict, err := simplelru.NewLRU[K, struct{}](evictSize, nil) + if err != nil { + return nil, err + } + + // Initialize the cache + c := &TwoQueueCache[K, V]{ + size: size, + recentSize: recentSize, + recentRatio: recentRatio, + ghostRatio: ghostRatio, + recent: recent, + frequent: frequent, + recentEvict: recentEvict, + } + return c, nil +} + +// Get looks up a key's value from the cache. +func (c *TwoQueueCache[K, V]) Get(key K) (value V, ok bool) { + c.lock.Lock() + defer c.lock.Unlock() + + // Check if this is a frequent value + if val, ok := c.frequent.Get(key); ok { + return val, ok + } + + // If the value is contained in recent, then we + // promote it to frequent + if val, ok := c.recent.Peek(key); ok { + c.recent.Remove(key) + c.frequent.Add(key, val) + return val, ok + } + + // No hit + return +} + +// Add adds a value to the cache. +func (c *TwoQueueCache[K, V]) Add(key K, value V) { + c.lock.Lock() + defer c.lock.Unlock() + + // Check if the value is frequently used already, + // and just update the value + if c.frequent.Contains(key) { + c.frequent.Add(key, value) + return + } + + // Check if the value is recently used, and promote + // the value into the frequent list + if c.recent.Contains(key) { + c.recent.Remove(key) + c.frequent.Add(key, value) + return + } + + // If the value was recently evicted, add it to the + // frequently used list + if c.recentEvict.Contains(key) { + c.ensureSpace(true) + c.recentEvict.Remove(key) + c.frequent.Add(key, value) + return + } + + // Add to the recently seen list + c.ensureSpace(false) + c.recent.Add(key, value) +} + +// ensureSpace is used to ensure we have space in the cache +func (c *TwoQueueCache[K, V]) ensureSpace(recentEvict bool) { + // If we have space, nothing to do + recentLen := c.recent.Len() + freqLen := c.frequent.Len() + if recentLen+freqLen < c.size { + return + } + + // If the recent buffer is larger than + // the target, evict from there + if recentLen > 0 && (recentLen > c.recentSize || (recentLen == c.recentSize && !recentEvict)) { + k, _, _ := c.recent.RemoveOldest() + c.recentEvict.Add(k, struct{}{}) + return + } + + // Remove from the frequent list otherwise + c.frequent.RemoveOldest() +} + +// Len returns the number of items in the cache. +func (c *TwoQueueCache[K, V]) Len() int { + c.lock.RLock() + defer c.lock.RUnlock() + return c.recent.Len() + c.frequent.Len() +} + +// Resize changes the cache size. +func (c *TwoQueueCache[K, V]) Resize(size int) (evicted int) { + c.lock.Lock() + defer c.lock.Unlock() + + // Recalculate the sub-sizes + recentSize := int(float64(size) * c.recentRatio) + evictSize := int(float64(size) * c.ghostRatio) + c.size = size + c.recentSize = recentSize + + // ensureSpace + diff := c.recent.Len() + c.frequent.Len() - size + if diff < 0 { + diff = 0 + } + for i := 0; i < diff; i++ { + c.ensureSpace(true) + } + + // Reallocate the LRUs + c.recent.Resize(size) + c.frequent.Resize(size) + c.recentEvict.Resize(evictSize) + + return diff +} + +// Keys returns a slice of the keys in the cache. +// The frequently used keys are first in the returned slice. +func (c *TwoQueueCache[K, V]) Keys() []K { + c.lock.RLock() + defer c.lock.RUnlock() + k1 := c.frequent.Keys() + k2 := c.recent.Keys() + return append(k1, k2...) +} + +// Values returns a slice of the values in the cache. +// The frequently used values are first in the returned slice. +func (c *TwoQueueCache[K, V]) Values() []V { + c.lock.RLock() + defer c.lock.RUnlock() + v1 := c.frequent.Values() + v2 := c.recent.Values() + return append(v1, v2...) +} + +// Remove removes the provided key from the cache. +func (c *TwoQueueCache[K, V]) Remove(key K) { + c.lock.Lock() + defer c.lock.Unlock() + if c.frequent.Remove(key) { + return + } + if c.recent.Remove(key) { + return + } + if c.recentEvict.Remove(key) { + return + } +} + +// Purge is used to completely clear the cache. +func (c *TwoQueueCache[K, V]) Purge() { + c.lock.Lock() + defer c.lock.Unlock() + c.recent.Purge() + c.frequent.Purge() + c.recentEvict.Purge() +} + +// Contains is used to check if the cache contains a key +// without updating recency or frequency. +func (c *TwoQueueCache[K, V]) Contains(key K) bool { + c.lock.RLock() + defer c.lock.RUnlock() + return c.frequent.Contains(key) || c.recent.Contains(key) +} + +// Peek is used to inspect the cache value of a key +// without updating recency or frequency. +func (c *TwoQueueCache[K, V]) Peek(key K) (value V, ok bool) { + c.lock.RLock() + defer c.lock.RUnlock() + if val, ok := c.frequent.Peek(key); ok { + return val, ok + } + return c.recent.Peek(key) +} diff --git a/vendor/github.com/hashicorp/golang-lru/v2/LICENSE b/vendor/github.com/hashicorp/golang-lru/v2/LICENSE new file mode 100644 index 000000000..0e5d580e0 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/LICENSE @@ -0,0 +1,364 @@ +Copyright (c) 2014 HashiCorp, Inc. + +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. "Contributor" + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. "Contributor Version" + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the terms of + a Secondary License. + +1.6. "Executable Form" + + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + + means a work that combines Covered Software with other material, in a + separate file or files, that is not Covered Software. + +1.8. "License" + + means this document. + +1.9. "Licensable" + + means having the right to grant, to the maximum extent possible, whether + at the time of the initial grant or subsequently, any and all of the + rights conveyed by this License. + +1.10. "Modifications" + + means any of the following: + + a. any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. "Patent Claims" of a Contributor + + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the License, + by the making, using, selling, offering for sale, having made, import, + or transfer of either its Contributions or its Contributor Version. + +1.12. "Secondary License" + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. "Source Code Form" + + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, "control" means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution + become effective for each Contribution on the date the Contributor first + distributes such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under + this License. No additional rights or licenses will be implied from the + distribution or licensing of Covered Software under this License. + Notwithstanding Section 2.1(b) above, no patent license is granted by a + Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of + its Contributions. + + This License does not grant any rights in the trademarks, service marks, + or logos of any Contributor (except as may be necessary to comply with + the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this + License (see Section 10.2) or under the terms of a Secondary License (if + permitted under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its + Contributions are its original creation(s) or it has sufficient rights to + grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under + applicable copyright doctrines of fair use, fair dealing, or other + equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under + the terms of this License. You must inform recipients that the Source + Code Form of the Covered Software is governed by the terms of this + License, and how they can obtain a copy of this License. You may not + attempt to alter or restrict the recipients' rights in the Source Code + Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter the + recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for + the Covered Software. If the Larger Work is a combination of Covered + Software with a work governed by one or more Secondary Licenses, and the + Covered Software is not Incompatible With Secondary Licenses, this + License permits You to additionally distribute such Covered Software + under the terms of such Secondary License(s), so that the recipient of + the Larger Work may, at their option, further distribute the Covered + Software under the terms of either this License or such Secondary + License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices + (including copyright notices, patent notices, disclaimers of warranty, or + limitations of liability) contained within the Source Code Form of the + Covered Software, except that You may alter any license notices to the + extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on + behalf of any Contributor. You must make it absolutely clear that any + such warranty, support, indemnity, or liability obligation is offered by + You alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, + judicial order, or regulation then You must: (a) comply with the terms of + this License to the maximum extent possible; and (b) describe the + limitations and the code they affect. Such description must be placed in a + text file included with all distributions of the Covered Software under + this License. Except to the extent prohibited by statute or regulation, + such description must be sufficiently detailed for a recipient of ordinary + skill to be able to understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing + basis, if such Contributor fails to notify You of the non-compliance by + some reasonable means prior to 60 days after You have come back into + compliance. Moreover, Your grants from a particular Contributor are + reinstated on an ongoing basis if such Contributor notifies You of the + non-compliance by some reasonable means, this is the first time You have + received notice of non-compliance with this License from such + Contributor, and You become compliant prior to 30 days after Your receipt + of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, + counter-claims, and cross-claims) alleging that a Contributor Version + directly or indirectly infringes any patent, then the rights granted to + You by any and all Contributors for the Covered Software under Section + 2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an "as is" basis, + without warranty of any kind, either expressed, implied, or statutory, + including, without limitation, warranties that the Covered Software is free + of defects, merchantable, fit for a particular purpose or non-infringing. + The entire risk as to the quality and performance of the Covered Software + is with You. Should any Covered Software prove defective in any respect, + You (not any Contributor) assume the cost of any necessary servicing, + repair, or correction. This disclaimer of warranty constitutes an essential + part of this License. No use of any Covered Software is authorized under + this License except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from + such party's negligence to the extent applicable law prohibits such + limitation. Some jurisdictions do not allow the exclusion or limitation of + incidental or consequential damages, so this exclusion and limitation may + not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts + of a jurisdiction where the defendant maintains its principal place of + business and such litigation shall be governed by laws of that + jurisdiction, without reference to its conflict-of-law provisions. Nothing + in this Section shall prevent a party's ability to bring cross-claims or + counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject + matter hereof. If any provision of this License is held to be + unenforceable, such provision shall be reformed only to the extent + necessary to make it enforceable. Any law or regulation which provides that + the language of a contract shall be construed against the drafter shall not + be used to construe this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version + of the License under which You originally received the Covered Software, + or under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a + modified version of this License if you rename the license and remove + any references to the name of the license steward (except to note that + such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary + Licenses If You choose to distribute Source Code Form that is + Incompatible With Secondary Licenses under the terms of this version of + the License, the notice described in Exhibit B of this License must be + attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, +then You may include the notice in a location (such as a LICENSE file in a +relevant directory) where a recipient would be likely to look for such a +notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice + + This Source Code Form is "Incompatible + With Secondary Licenses", as defined by + the Mozilla Public License, v. 2.0. diff --git a/vendor/github.com/hashicorp/golang-lru/v2/README.md b/vendor/github.com/hashicorp/golang-lru/v2/README.md new file mode 100644 index 000000000..a942eb539 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/README.md @@ -0,0 +1,79 @@ +golang-lru +========== + +This provides the `lru` package which implements a fixed-size +thread safe LRU cache. It is based on the cache in Groupcache. + +Documentation +============= + +Full docs are available on [Go Packages](https://pkg.go.dev/github.com/hashicorp/golang-lru/v2) + +LRU cache example +================= + +```go +package main + +import ( + "fmt" + "github.com/hashicorp/golang-lru/v2" +) + +func main() { + l, _ := lru.New[int, any](128) + for i := 0; i < 256; i++ { + l.Add(i, nil) + } + if l.Len() != 128 { + panic(fmt.Sprintf("bad len: %v", l.Len())) + } +} +``` + +Expirable LRU cache example +=========================== + +```go +package main + +import ( + "fmt" + "time" + + "github.com/hashicorp/golang-lru/v2/expirable" +) + +func main() { + // make cache with 10ms TTL and 5 max keys + cache := expirable.NewLRU[string, string](5, nil, time.Millisecond*10) + + + // set value under key1. + cache.Add("key1", "val1") + + // get value under key1 + r, ok := cache.Get("key1") + + // check for OK value + if ok { + fmt.Printf("value before expiration is found: %v, value: %q\n", ok, r) + } + + // wait for cache to expire + time.Sleep(time.Millisecond * 12) + + // get value under key1 after key expiration + r, ok = cache.Get("key1") + fmt.Printf("value after expiration is found: %v, value: %q\n", ok, r) + + // set value under key2, would evict old entry because it is already expired. + cache.Add("key2", "val2") + + fmt.Printf("Cache len: %d\n", cache.Len()) + // Output: + // value before expiration is found: true, value: "val1" + // value after expiration is found: false, value: "" + // Cache len: 1 +} +``` diff --git a/vendor/github.com/hashicorp/golang-lru/v2/doc.go b/vendor/github.com/hashicorp/golang-lru/v2/doc.go new file mode 100644 index 000000000..24107ee0e --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/doc.go @@ -0,0 +1,24 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +// Package lru provides three different LRU caches of varying sophistication. +// +// Cache is a simple LRU cache. It is based on the LRU implementation in +// groupcache: https://github.com/golang/groupcache/tree/master/lru +// +// TwoQueueCache tracks frequently used and recently used entries separately. +// This avoids a burst of accesses from taking out frequently used entries, at +// the cost of about 2x computational overhead and some extra bookkeeping. +// +// ARCCache is an adaptive replacement cache. It tracks recent evictions as well +// as recent usage in both the frequent and recent caches. Its computational +// overhead is comparable to TwoQueueCache, but the memory overhead is linear +// with the size of the cache. +// +// ARC has been patented by IBM, so do not use it if that is problematic for +// your program. For this reason, it is in a separate go module contained within +// this repository. +// +// All caches in this package take locks while operating, and are therefore +// thread-safe for consumers. +package lru diff --git a/vendor/github.com/hashicorp/golang-lru/v2/internal/list.go b/vendor/github.com/hashicorp/golang-lru/v2/internal/list.go new file mode 100644 index 000000000..5cd74a034 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/internal/list.go @@ -0,0 +1,142 @@ +// Copyright 2009 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_list file. + +package internal + +import "time" + +// Entry is an LRU Entry +type Entry[K comparable, V any] struct { + // Next and previous pointers in the doubly-linked list of elements. + // To simplify the implementation, internally a list l is implemented + // as a ring, such that &l.root is both the next element of the last + // list element (l.Back()) and the previous element of the first list + // element (l.Front()). + next, prev *Entry[K, V] + + // The list to which this element belongs. + list *LruList[K, V] + + // The LRU Key of this element. + Key K + + // The Value stored with this element. + Value V + + // The time this element would be cleaned up, optional + ExpiresAt time.Time + + // The expiry bucket item was put in, optional + ExpireBucket uint8 +} + +// PrevEntry returns the previous list element or nil. +func (e *Entry[K, V]) PrevEntry() *Entry[K, V] { + if p := e.prev; e.list != nil && p != &e.list.root { + return p + } + return nil +} + +// LruList represents a doubly linked list. +// The zero Value for LruList is an empty list ready to use. +type LruList[K comparable, V any] struct { + root Entry[K, V] // sentinel list element, only &root, root.prev, and root.next are used + len int // current list Length excluding (this) sentinel element +} + +// Init initializes or clears list l. +func (l *LruList[K, V]) Init() *LruList[K, V] { + l.root.next = &l.root + l.root.prev = &l.root + l.len = 0 + return l +} + +// NewList returns an initialized list. +func NewList[K comparable, V any]() *LruList[K, V] { return new(LruList[K, V]).Init() } + +// Length returns the number of elements of list l. +// The complexity is O(1). +func (l *LruList[K, V]) Length() int { return l.len } + +// Back returns the last element of list l or nil if the list is empty. +func (l *LruList[K, V]) Back() *Entry[K, V] { + if l.len == 0 { + return nil + } + return l.root.prev +} + +// lazyInit lazily initializes a zero List Value. +func (l *LruList[K, V]) lazyInit() { + if l.root.next == nil { + l.Init() + } +} + +// insert inserts e after at, increments l.len, and returns e. +func (l *LruList[K, V]) insert(e, at *Entry[K, V]) *Entry[K, V] { + e.prev = at + e.next = at.next + e.prev.next = e + e.next.prev = e + e.list = l + l.len++ + return e +} + +// insertValue is a convenience wrapper for insert(&Entry{Value: v, ExpiresAt: ExpiresAt}, at). +func (l *LruList[K, V]) insertValue(k K, v V, expiresAt time.Time, at *Entry[K, V]) *Entry[K, V] { + return l.insert(&Entry[K, V]{Value: v, Key: k, ExpiresAt: expiresAt}, at) +} + +// Remove removes e from its list, decrements l.len +func (l *LruList[K, V]) Remove(e *Entry[K, V]) V { + e.prev.next = e.next + e.next.prev = e.prev + e.next = nil // avoid memory leaks + e.prev = nil // avoid memory leaks + e.list = nil + l.len-- + + return e.Value +} + +// move moves e to next to at. +func (l *LruList[K, V]) move(e, at *Entry[K, V]) { + if e == at { + return + } + e.prev.next = e.next + e.next.prev = e.prev + + e.prev = at + e.next = at.next + e.prev.next = e + e.next.prev = e +} + +// PushFront inserts a new element e with value v at the front of list l and returns e. +func (l *LruList[K, V]) PushFront(k K, v V) *Entry[K, V] { + l.lazyInit() + return l.insertValue(k, v, time.Time{}, &l.root) +} + +// PushFrontExpirable inserts a new expirable element e with Value v at the front of list l and returns e. +func (l *LruList[K, V]) PushFrontExpirable(k K, v V, expiresAt time.Time) *Entry[K, V] { + l.lazyInit() + return l.insertValue(k, v, expiresAt, &l.root) +} + +// MoveToFront moves element e to the front of list l. +// If e is not an element of l, the list is not modified. +// The element must not be nil. +func (l *LruList[K, V]) MoveToFront(e *Entry[K, V]) { + if e.list != l || l.root.next == e { + return + } + // see comment in List.Remove about initialization of l + l.move(e, &l.root) +} diff --git a/vendor/github.com/hashicorp/golang-lru/v2/lru.go b/vendor/github.com/hashicorp/golang-lru/v2/lru.go new file mode 100644 index 000000000..a2655f1f3 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/lru.go @@ -0,0 +1,250 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package lru + +import ( + "sync" + + "github.com/hashicorp/golang-lru/v2/simplelru" +) + +const ( + // DefaultEvictedBufferSize defines the default buffer size to store evicted key/val + DefaultEvictedBufferSize = 16 +) + +// Cache is a thread-safe fixed size LRU cache. +type Cache[K comparable, V any] struct { + lru *simplelru.LRU[K, V] + evictedKeys []K + evictedVals []V + onEvictedCB func(k K, v V) + lock sync.RWMutex +} + +// New creates an LRU of the given size. +func New[K comparable, V any](size int) (*Cache[K, V], error) { + return NewWithEvict[K, V](size, nil) +} + +// NewWithEvict constructs a fixed size cache with the given eviction +// callback. +func NewWithEvict[K comparable, V any](size int, onEvicted func(key K, value V)) (c *Cache[K, V], err error) { + // create a cache with default settings + c = &Cache[K, V]{ + onEvictedCB: onEvicted, + } + if onEvicted != nil { + c.initEvictBuffers() + onEvicted = c.onEvicted + } + c.lru, err = simplelru.NewLRU(size, onEvicted) + return +} + +func (c *Cache[K, V]) initEvictBuffers() { + c.evictedKeys = make([]K, 0, DefaultEvictedBufferSize) + c.evictedVals = make([]V, 0, DefaultEvictedBufferSize) +} + +// onEvicted save evicted key/val and sent in externally registered callback +// outside of critical section +func (c *Cache[K, V]) onEvicted(k K, v V) { + c.evictedKeys = append(c.evictedKeys, k) + c.evictedVals = append(c.evictedVals, v) +} + +// Purge is used to completely clear the cache. +func (c *Cache[K, V]) Purge() { + var ks []K + var vs []V + c.lock.Lock() + c.lru.Purge() + if c.onEvictedCB != nil && len(c.evictedKeys) > 0 { + ks, vs = c.evictedKeys, c.evictedVals + c.initEvictBuffers() + } + c.lock.Unlock() + // invoke callback outside of critical section + if c.onEvictedCB != nil { + for i := 0; i < len(ks); i++ { + c.onEvictedCB(ks[i], vs[i]) + } + } +} + +// Add adds a value to the cache. Returns true if an eviction occurred. +func (c *Cache[K, V]) Add(key K, value V) (evicted bool) { + var k K + var v V + c.lock.Lock() + evicted = c.lru.Add(key, value) + if c.onEvictedCB != nil && evicted { + k, v = c.evictedKeys[0], c.evictedVals[0] + c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0] + } + c.lock.Unlock() + if c.onEvictedCB != nil && evicted { + c.onEvictedCB(k, v) + } + return +} + +// Get looks up a key's value from the cache. +func (c *Cache[K, V]) Get(key K) (value V, ok bool) { + c.lock.Lock() + value, ok = c.lru.Get(key) + c.lock.Unlock() + return value, ok +} + +// Contains checks if a key is in the cache, without updating the +// recent-ness or deleting it for being stale. +func (c *Cache[K, V]) Contains(key K) bool { + c.lock.RLock() + containKey := c.lru.Contains(key) + c.lock.RUnlock() + return containKey +} + +// Peek returns the key value (or undefined if not found) without updating +// the "recently used"-ness of the key. +func (c *Cache[K, V]) Peek(key K) (value V, ok bool) { + c.lock.RLock() + value, ok = c.lru.Peek(key) + c.lock.RUnlock() + return value, ok +} + +// ContainsOrAdd checks if a key is in the cache without updating the +// recent-ness or deleting it for being stale, and if not, adds the value. +// Returns whether found and whether an eviction occurred. +func (c *Cache[K, V]) ContainsOrAdd(key K, value V) (ok, evicted bool) { + var k K + var v V + c.lock.Lock() + if c.lru.Contains(key) { + c.lock.Unlock() + return true, false + } + evicted = c.lru.Add(key, value) + if c.onEvictedCB != nil && evicted { + k, v = c.evictedKeys[0], c.evictedVals[0] + c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0] + } + c.lock.Unlock() + if c.onEvictedCB != nil && evicted { + c.onEvictedCB(k, v) + } + return false, evicted +} + +// PeekOrAdd checks if a key is in the cache without updating the +// recent-ness or deleting it for being stale, and if not, adds the value. +// Returns whether found and whether an eviction occurred. +func (c *Cache[K, V]) PeekOrAdd(key K, value V) (previous V, ok, evicted bool) { + var k K + var v V + c.lock.Lock() + previous, ok = c.lru.Peek(key) + if ok { + c.lock.Unlock() + return previous, true, false + } + evicted = c.lru.Add(key, value) + if c.onEvictedCB != nil && evicted { + k, v = c.evictedKeys[0], c.evictedVals[0] + c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0] + } + c.lock.Unlock() + if c.onEvictedCB != nil && evicted { + c.onEvictedCB(k, v) + } + return +} + +// Remove removes the provided key from the cache. +func (c *Cache[K, V]) Remove(key K) (present bool) { + var k K + var v V + c.lock.Lock() + present = c.lru.Remove(key) + if c.onEvictedCB != nil && present { + k, v = c.evictedKeys[0], c.evictedVals[0] + c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0] + } + c.lock.Unlock() + if c.onEvictedCB != nil && present { + c.onEvictedCB(k, v) + } + return +} + +// Resize changes the cache size. +func (c *Cache[K, V]) Resize(size int) (evicted int) { + var ks []K + var vs []V + c.lock.Lock() + evicted = c.lru.Resize(size) + if c.onEvictedCB != nil && evicted > 0 { + ks, vs = c.evictedKeys, c.evictedVals + c.initEvictBuffers() + } + c.lock.Unlock() + if c.onEvictedCB != nil && evicted > 0 { + for i := 0; i < len(ks); i++ { + c.onEvictedCB(ks[i], vs[i]) + } + } + return evicted +} + +// RemoveOldest removes the oldest item from the cache. +func (c *Cache[K, V]) RemoveOldest() (key K, value V, ok bool) { + var k K + var v V + c.lock.Lock() + key, value, ok = c.lru.RemoveOldest() + if c.onEvictedCB != nil && ok { + k, v = c.evictedKeys[0], c.evictedVals[0] + c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0] + } + c.lock.Unlock() + if c.onEvictedCB != nil && ok { + c.onEvictedCB(k, v) + } + return +} + +// GetOldest returns the oldest entry +func (c *Cache[K, V]) GetOldest() (key K, value V, ok bool) { + c.lock.RLock() + key, value, ok = c.lru.GetOldest() + c.lock.RUnlock() + return +} + +// Keys returns a slice of the keys in the cache, from oldest to newest. +func (c *Cache[K, V]) Keys() []K { + c.lock.RLock() + keys := c.lru.Keys() + c.lock.RUnlock() + return keys +} + +// Values returns a slice of the values in the cache, from oldest to newest. +func (c *Cache[K, V]) Values() []V { + c.lock.RLock() + values := c.lru.Values() + c.lock.RUnlock() + return values +} + +// Len returns the number of items in the cache. +func (c *Cache[K, V]) Len() int { + c.lock.RLock() + length := c.lru.Len() + c.lock.RUnlock() + return length +} diff --git a/vendor/github.com/hashicorp/golang-lru/v2/simplelru/LICENSE_list b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/LICENSE_list new file mode 100644 index 000000000..c4764e6b2 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/LICENSE_list @@ -0,0 +1,29 @@ +This license applies to simplelru/list.go + +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +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 +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru.go b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru.go new file mode 100644 index 000000000..f69792388 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru.go @@ -0,0 +1,177 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package simplelru + +import ( + "errors" + + "github.com/hashicorp/golang-lru/v2/internal" +) + +// EvictCallback is used to get a callback when a cache entry is evicted +type EvictCallback[K comparable, V any] func(key K, value V) + +// LRU implements a non-thread safe fixed size LRU cache +type LRU[K comparable, V any] struct { + size int + evictList *internal.LruList[K, V] + items map[K]*internal.Entry[K, V] + onEvict EvictCallback[K, V] +} + +// NewLRU constructs an LRU of the given size +func NewLRU[K comparable, V any](size int, onEvict EvictCallback[K, V]) (*LRU[K, V], error) { + if size <= 0 { + return nil, errors.New("must provide a positive size") + } + + c := &LRU[K, V]{ + size: size, + evictList: internal.NewList[K, V](), + items: make(map[K]*internal.Entry[K, V]), + onEvict: onEvict, + } + return c, nil +} + +// Purge is used to completely clear the cache. +func (c *LRU[K, V]) Purge() { + for k, v := range c.items { + if c.onEvict != nil { + c.onEvict(k, v.Value) + } + delete(c.items, k) + } + c.evictList.Init() +} + +// Add adds a value to the cache. Returns true if an eviction occurred. +func (c *LRU[K, V]) Add(key K, value V) (evicted bool) { + // Check for existing item + if ent, ok := c.items[key]; ok { + c.evictList.MoveToFront(ent) + ent.Value = value + return false + } + + // Add new item + ent := c.evictList.PushFront(key, value) + c.items[key] = ent + + evict := c.evictList.Length() > c.size + // Verify size not exceeded + if evict { + c.removeOldest() + } + return evict +} + +// Get looks up a key's value from the cache. +func (c *LRU[K, V]) Get(key K) (value V, ok bool) { + if ent, ok := c.items[key]; ok { + c.evictList.MoveToFront(ent) + return ent.Value, true + } + return +} + +// Contains checks if a key is in the cache, without updating the recent-ness +// or deleting it for being stale. +func (c *LRU[K, V]) Contains(key K) (ok bool) { + _, ok = c.items[key] + return ok +} + +// Peek returns the key value (or undefined if not found) without updating +// the "recently used"-ness of the key. +func (c *LRU[K, V]) Peek(key K) (value V, ok bool) { + var ent *internal.Entry[K, V] + if ent, ok = c.items[key]; ok { + return ent.Value, true + } + return +} + +// Remove removes the provided key from the cache, returning if the +// key was contained. +func (c *LRU[K, V]) Remove(key K) (present bool) { + if ent, ok := c.items[key]; ok { + c.removeElement(ent) + return true + } + return false +} + +// RemoveOldest removes the oldest item from the cache. +func (c *LRU[K, V]) RemoveOldest() (key K, value V, ok bool) { + if ent := c.evictList.Back(); ent != nil { + c.removeElement(ent) + return ent.Key, ent.Value, true + } + return +} + +// GetOldest returns the oldest entry +func (c *LRU[K, V]) GetOldest() (key K, value V, ok bool) { + if ent := c.evictList.Back(); ent != nil { + return ent.Key, ent.Value, true + } + return +} + +// Keys returns a slice of the keys in the cache, from oldest to newest. +func (c *LRU[K, V]) Keys() []K { + keys := make([]K, c.evictList.Length()) + i := 0 + for ent := c.evictList.Back(); ent != nil; ent = ent.PrevEntry() { + keys[i] = ent.Key + i++ + } + return keys +} + +// Values returns a slice of the values in the cache, from oldest to newest. +func (c *LRU[K, V]) Values() []V { + values := make([]V, len(c.items)) + i := 0 + for ent := c.evictList.Back(); ent != nil; ent = ent.PrevEntry() { + values[i] = ent.Value + i++ + } + return values +} + +// Len returns the number of items in the cache. +func (c *LRU[K, V]) Len() int { + return c.evictList.Length() +} + +// Resize changes the cache size. +func (c *LRU[K, V]) Resize(size int) (evicted int) { + diff := c.Len() - size + if diff < 0 { + diff = 0 + } + for i := 0; i < diff; i++ { + c.removeOldest() + } + c.size = size + return diff +} + +// removeOldest removes the oldest item from the cache. +func (c *LRU[K, V]) removeOldest() { + if ent := c.evictList.Back(); ent != nil { + c.removeElement(ent) + } +} + +// removeElement is used to remove a given list element from the cache +func (c *LRU[K, V]) removeElement(e *internal.Entry[K, V]) { + c.evictList.Remove(e) + delete(c.items, e.Key) + if c.onEvict != nil { + c.onEvict(e.Key, e.Value) + } +} diff --git a/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru_interface.go b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru_interface.go new file mode 100644 index 000000000..043b8bcc3 --- /dev/null +++ b/vendor/github.com/hashicorp/golang-lru/v2/simplelru/lru_interface.go @@ -0,0 +1,46 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +// Package simplelru provides simple LRU implementation based on build-in container/list. +package simplelru + +// LRUCache is the interface for simple LRU cache. +type LRUCache[K comparable, V any] interface { + // Adds a value to the cache, returns true if an eviction occurred and + // updates the "recently used"-ness of the key. + Add(key K, value V) bool + + // Returns key's value from the cache and + // updates the "recently used"-ness of the key. #value, isFound + Get(key K) (value V, ok bool) + + // Checks if a key exists in cache without updating the recent-ness. + Contains(key K) (ok bool) + + // Returns key's value without updating the "recently used"-ness of the key. + Peek(key K) (value V, ok bool) + + // Removes a key from the cache. + Remove(key K) bool + + // Removes the oldest entry from cache. + RemoveOldest() (K, V, bool) + + // Returns the oldest entry from the cache. #key, value, isFound + GetOldest() (K, V, bool) + + // Returns a slice of the keys in the cache, from oldest to newest. + Keys() []K + + // Values returns a slice of the values in the cache, from oldest to newest. + Values() []V + + // Returns the number of items in the cache. + Len() int + + // Clears all cache entries. + Purge() + + // Resizes cache, returning number evicted + Resize(int) int +} diff --git a/vendor/github.com/kballard/go-shellquote/LICENSE b/vendor/github.com/kballard/go-shellquote/LICENSE deleted file mode 100644 index a6d77312e..000000000 --- a/vendor/github.com/kballard/go-shellquote/LICENSE +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (C) 2014 Kevin Ballard - -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/github.com/kballard/go-shellquote/README b/vendor/github.com/kballard/go-shellquote/README deleted file mode 100644 index 4d34e87af..000000000 --- a/vendor/github.com/kballard/go-shellquote/README +++ /dev/null @@ -1,36 +0,0 @@ -PACKAGE - -package shellquote - import "github.com/kballard/go-shellquote" - - Shellquote provides utilities for joining/splitting strings using sh's - word-splitting rules. - -VARIABLES - -var ( - UnterminatedSingleQuoteError = errors.New("Unterminated single-quoted string") - UnterminatedDoubleQuoteError = errors.New("Unterminated double-quoted string") - UnterminatedEscapeError = errors.New("Unterminated backslash-escape") -) - - -FUNCTIONS - -func Join(args ...string) string - Join quotes each argument and joins them with a space. If passed to - /bin/sh, the resulting string will be split back into the original - arguments. - -func Split(input string) (words []string, err error) - Split splits a string according to /bin/sh's word-splitting rules. It - supports backslash-escapes, single-quotes, and double-quotes. Notably it - does not support the $'' style of quoting. It also doesn't attempt to - perform any other sort of expansion, including brace expansion, shell - expansion, or pathname expansion. - - If the given input has an unterminated quoted string or ends in a - backslash-escape, one of UnterminatedSingleQuoteError, - UnterminatedDoubleQuoteError, or UnterminatedEscapeError is returned. - - diff --git a/vendor/github.com/kballard/go-shellquote/doc.go b/vendor/github.com/kballard/go-shellquote/doc.go deleted file mode 100644 index 9445fa4ad..000000000 --- a/vendor/github.com/kballard/go-shellquote/doc.go +++ /dev/null @@ -1,3 +0,0 @@ -// Shellquote provides utilities for joining/splitting strings using sh's -// word-splitting rules. -package shellquote diff --git a/vendor/github.com/kballard/go-shellquote/quote.go b/vendor/github.com/kballard/go-shellquote/quote.go deleted file mode 100644 index 72a8cb38b..000000000 --- a/vendor/github.com/kballard/go-shellquote/quote.go +++ /dev/null @@ -1,102 +0,0 @@ -package shellquote - -import ( - "bytes" - "strings" - "unicode/utf8" -) - -// Join quotes each argument and joins them with a space. -// If passed to /bin/sh, the resulting string will be split back into the -// original arguments. -func Join(args ...string) string { - var buf bytes.Buffer - for i, arg := range args { - if i != 0 { - buf.WriteByte(' ') - } - quote(arg, &buf) - } - return buf.String() -} - -const ( - specialChars = "\\'\"`${[|&;<>()*?!" - extraSpecialChars = " \t\n" - prefixChars = "~" -) - -func quote(word string, buf *bytes.Buffer) { - // We want to try to produce a "nice" output. As such, we will - // backslash-escape most characters, but if we encounter a space, or if we - // encounter an extra-special char (which doesn't work with - // backslash-escaping) we switch over to quoting the whole word. We do this - // with a space because it's typically easier for people to read multi-word - // arguments when quoted with a space rather than with ugly backslashes - // everywhere. - origLen := buf.Len() - - if len(word) == 0 { - // oops, no content - buf.WriteString("''") - return - } - - cur, prev := word, word - atStart := true - for len(cur) > 0 { - c, l := utf8.DecodeRuneInString(cur) - cur = cur[l:] - if strings.ContainsRune(specialChars, c) || (atStart && strings.ContainsRune(prefixChars, c)) { - // copy the non-special chars up to this point - if len(cur) < len(prev) { - buf.WriteString(prev[0 : len(prev)-len(cur)-l]) - } - buf.WriteByte('\\') - buf.WriteRune(c) - prev = cur - } else if strings.ContainsRune(extraSpecialChars, c) { - // start over in quote mode - buf.Truncate(origLen) - goto quote - } - atStart = false - } - if len(prev) > 0 { - buf.WriteString(prev) - } - return - -quote: - // quote mode - // Use single-quotes, but if we find a single-quote in the word, we need - // to terminate the string, emit an escaped quote, and start the string up - // again - inQuote := false - for len(word) > 0 { - i := strings.IndexRune(word, '\'') - if i == -1 { - break - } - if i > 0 { - if !inQuote { - buf.WriteByte('\'') - inQuote = true - } - buf.WriteString(word[0:i]) - } - word = word[i+1:] - if inQuote { - buf.WriteByte('\'') - inQuote = false - } - buf.WriteString("\\'") - } - if len(word) > 0 { - if !inQuote { - buf.WriteByte('\'') - } - buf.WriteString(word) - buf.WriteByte('\'') - } -} diff --git a/vendor/github.com/kballard/go-shellquote/unquote.go b/vendor/github.com/kballard/go-shellquote/unquote.go deleted file mode 100644 index b1b13da93..000000000 --- a/vendor/github.com/kballard/go-shellquote/unquote.go +++ /dev/null @@ -1,156 +0,0 @@ -package shellquote - -import ( - "bytes" - "errors" - "strings" - "unicode/utf8" -) - -var ( - UnterminatedSingleQuoteError = errors.New("Unterminated single-quoted string") - UnterminatedDoubleQuoteError = errors.New("Unterminated double-quoted string") - UnterminatedEscapeError = errors.New("Unterminated backslash-escape") -) - -var ( - splitChars = " \n\t" - singleChar = '\'' - doubleChar = '"' - escapeChar = '\\' - doubleEscapeChars = "$`\"\n\\" -) - -// Split splits a string according to /bin/sh's word-splitting rules. It -// supports backslash-escapes, single-quotes, and double-quotes. Notably it does -// not support the $'' style of quoting. It also doesn't attempt to perform any -// other sort of expansion, including brace expansion, shell expansion, or -// pathname expansion. -// -// If the given input has an unterminated quoted string or ends in a -// backslash-escape, one of UnterminatedSingleQuoteError, -// UnterminatedDoubleQuoteError, or UnterminatedEscapeError is returned. -func Split(input string) (words []string, err error) { - var buf bytes.Buffer - words = make([]string, 0) - - for len(input) > 0 { - // skip any splitChars at the start - c, l := utf8.DecodeRuneInString(input) - if strings.ContainsRune(splitChars, c) { - input = input[l:] - continue - } else if c == escapeChar { - // Look ahead for escaped newline so we can skip over it - next := input[l:] - if len(next) == 0 { - err = UnterminatedEscapeError - return - } - c2, l2 := utf8.DecodeRuneInString(next) - if c2 == '\n' { - input = next[l2:] - continue - } - } - - var word string - word, input, err = splitWord(input, &buf) - if err != nil { - return - } - words = append(words, word) - } - return -} - -func splitWord(input string, buf *bytes.Buffer) (word string, remainder string, err error) { - buf.Reset() - -raw: - { - cur := input - for len(cur) > 0 { - c, l := utf8.DecodeRuneInString(cur) - cur = cur[l:] - if c == singleChar { - buf.WriteString(input[0 : len(input)-len(cur)-l]) - input = cur - goto single - } else if c == doubleChar { - buf.WriteString(input[0 : len(input)-len(cur)-l]) - input = cur - goto double - } else if c == escapeChar { - buf.WriteString(input[0 : len(input)-len(cur)-l]) - input = cur - goto escape - } else if strings.ContainsRune(splitChars, c) { - buf.WriteString(input[0 : len(input)-len(cur)-l]) - return buf.String(), cur, nil - } - } - if len(input) > 0 { - buf.WriteString(input) - input = "" - } - goto done - } - -escape: - { - if len(input) == 0 { - return "", "", UnterminatedEscapeError - } - c, l := utf8.DecodeRuneInString(input) - if c == '\n' { - // a backslash-escaped newline is elided from the output entirely - } else { - buf.WriteString(input[:l]) - } - input = input[l:] - } - goto raw - -single: - { - i := strings.IndexRune(input, singleChar) - if i == -1 { - return "", "", UnterminatedSingleQuoteError - } - buf.WriteString(input[0:i]) - input = input[i+1:] - goto raw - } - -double: - { - cur := input - for len(cur) > 0 { - c, l := utf8.DecodeRuneInString(cur) - cur = cur[l:] - if c == doubleChar { - buf.WriteString(input[0 : len(input)-len(cur)-l]) - input = cur - goto raw - } else if c == escapeChar { - // bash only supports certain escapes in double-quoted strings - c2, l2 := utf8.DecodeRuneInString(cur) - cur = cur[l2:] - if strings.ContainsRune(doubleEscapeChars, c2) { - buf.WriteString(input[0 : len(input)-len(cur)-l-l2]) - if c2 == '\n' { - // newline is special, skip the backslash entirely - } else { - buf.WriteRune(c2) - } - input = cur - } - } - } - return "", "", UnterminatedDoubleQuoteError - } - -done: - return buf.String(), input, nil -} diff --git a/vendor/github.com/ncruces/go-strftime/.gitignore b/vendor/github.com/ncruces/go-strftime/.gitignore new file mode 100644 index 000000000..66fd13c90 --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/.gitignore @@ -0,0 +1,15 @@ +# 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/ diff --git a/vendor/github.com/ncruces/go-strftime/LICENSE b/vendor/github.com/ncruces/go-strftime/LICENSE new file mode 100644 index 000000000..7f0f5534c --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Nuno Cruces + +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/github.com/ncruces/go-strftime/README.md b/vendor/github.com/ncruces/go-strftime/README.md new file mode 100644 index 000000000..5b0573cf0 --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/README.md @@ -0,0 +1,5 @@ +# `strftime`/`strptime` compatible time formatting and parsing for Go + +[](https://pkg.go.dev/github.com/ncruces/go-strftime) +[](https://goreportcard.com/report/github.com/ncruces/go-strftime) +[](https://raw.githack.com/wiki/ncruces/go-strftime/coverage.html)
\ No newline at end of file diff --git a/vendor/github.com/ncruces/go-strftime/parser.go b/vendor/github.com/ncruces/go-strftime/parser.go new file mode 100644 index 000000000..b006de38a --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/parser.go @@ -0,0 +1,107 @@ +package strftime + +import "unicode/utf8" + +type parser struct { + format func(spec, flag byte) error + literal func(byte) error +} + +func (p *parser) parse(fmt string) error { + const ( + initial = iota + percent + flagged + modified + ) + + var flag, modifier byte + var err error + state := initial + start := 0 + for i, b := range []byte(fmt) { + switch state { + default: + if b == '%' { + state = percent + start = i + continue + } + err = p.literal(b) + + case percent: + if b == '-' || b == ':' { + state = flagged + flag = b + continue + } + if b == 'E' || b == 'O' { + state = modified + modifier = b + flag = 0 + continue + } + err = p.format(b, 0) + state = initial + + case flagged: + if b == 'E' || b == 'O' { + state = modified + modifier = b + continue + } + err = p.format(b, flag) + state = initial + + case modified: + if okModifier(modifier, b) { + err = p.format(b, flag) + } else { + err = p.literals(fmt[start : i+1]) + } + state = initial + } + + if err != nil { + if err, ok := err.(formatError); ok { + err.setDirective(fmt, start, i) + return err + } + return err + } + } + + if state != initial { + return p.literals(fmt[start:]) + } + return nil +} + +func (p *parser) literals(literal string) error { + for _, b := range []byte(literal) { + if err := p.literal(b); err != nil { + return err + } + } + return nil +} + +type literalErr string + +func (e literalErr) Error() string { + return "strftime: unsupported literal: " + string(e) +} + +type formatError struct { + message string + directive string +} + +func (e formatError) Error() string { + return "strftime: unsupported directive: " + e.directive + " " + e.message +} + +func (e *formatError) setDirective(str string, i, j int) { + _, n := utf8.DecodeRuneInString(str[j:]) + e.directive = str[i : j+n] +} diff --git a/vendor/github.com/ncruces/go-strftime/pkg.go b/vendor/github.com/ncruces/go-strftime/pkg.go new file mode 100644 index 000000000..9a3bbd327 --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/pkg.go @@ -0,0 +1,96 @@ +/* +Package strftime provides strftime/strptime compatible time formatting and parsing. + +The following specifiers are available: + + Date (Year, Month, Day): + %Y - Year with century (can be negative, 4 digits at least) + -0001, 0000, 1995, 2009, 14292, etc. + %C - year / 100 (round down, 20 in 2009) + %y - year % 100 (00..99) + + %m - Month of the year, zero-padded (01..12) + %-m no-padded (1..12) + %B - Full month name (January) + %b - Abbreviated month name (Jan) + %h - Equivalent to %b + + %d - Day of the month, zero-padded (01..31) + %-d no-padded (1..31) + %e - Day of the month, blank-padded ( 1..31) + + %j - Day of the year (001..366) + %-j no-padded (1..366) + + Time (Hour, Minute, Second, Subsecond): + %H - Hour of the day, 24-hour clock, zero-padded (00..23) + %-H no-padded (0..23) + %k - Hour of the day, 24-hour clock, blank-padded ( 0..23) + %I - Hour of the day, 12-hour clock, zero-padded (01..12) + %-I no-padded (1..12) + %l - Hour of the day, 12-hour clock, blank-padded ( 1..12) + %P - Meridian indicator, lowercase (am or pm) + %p - Meridian indicator, uppercase (AM or PM) + + %M - Minute of the hour (00..59) + %-M no-padded (0..59) + + %S - Second of the minute (00..60) + %-S no-padded (0..60) + + %L - Millisecond of the second (000..999) + %f - Microsecond of the second (000000..999999) + %N - Nanosecond of the second (000000000..999999999) + + Time zone: + %z - Time zone as hour and minute offset from UTC (e.g. +0900) + %:z - hour and minute offset from UTC with a colon (e.g. +09:00) + %Z - Time zone abbreviation (e.g. MST) + + Weekday: + %A - Full weekday name (Sunday) + %a - Abbreviated weekday name (Sun) + %u - Day of the week (Monday is 1, 1..7) + %w - Day of the week (Sunday is 0, 0..6) + + ISO 8601 week-based year and week number: + Week 1 of YYYY starts with a Monday and includes YYYY-01-04. + The days in the year before the first week are in the last week of + the previous year. + %G - Week-based year + %g - Last 2 digits of the week-based year (00..99) + %V - Week number of the week-based year (01..53) + %-V no-padded (1..53) + + Week number: + Week 1 of YYYY starts with a Sunday or Monday (according to %U or %W). + The days in the year before the first week are in week 0. + %U - Week number of the year. The week starts with Sunday. (00..53) + %-U no-padded (0..53) + %W - Week number of the year. The week starts with Monday. (00..53) + %-W no-padded (0..53) + + Seconds since the Unix Epoch: + %s - Number of seconds since 1970-01-01 00:00:00 UTC. + %Q - Number of milliseconds since 1970-01-01 00:00:00 UTC. + + Literal string: + %n - Newline character (\n) + %t - Tab character (\t) + %% - Literal % character + + Combination: + %c - date and time (%a %b %e %T %Y) + %D - Date (%m/%d/%y) + %F - ISO 8601 date format (%Y-%m-%d) + %v - VMS date (%e-%b-%Y) + %x - Same as %D + %X - Same as %T + %r - 12-hour time (%I:%M:%S %p) + %R - 24-hour time (%H:%M) + %T - 24-hour time (%H:%M:%S) + %+ - date(1) (%a %b %e %H:%M:%S %Z %Y) + +The modifiers ``E'' and ``O'' are ignored. +*/ +package strftime diff --git a/vendor/github.com/ncruces/go-strftime/specifiers.go b/vendor/github.com/ncruces/go-strftime/specifiers.go new file mode 100644 index 000000000..065f77963 --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/specifiers.go @@ -0,0 +1,241 @@ +package strftime + +import "strings" + +// https://strftime.org/ +func goLayout(spec, flag byte, parsing bool) string { + switch spec { + default: + return "" + + case 'B': + return "January" + case 'b', 'h': + return "Jan" + case 'm': + if flag == '-' || parsing { + return "1" + } + return "01" + case 'A': + return "Monday" + case 'a': + return "Mon" + case 'e': + return "_2" + case 'd': + if flag == '-' || parsing { + return "2" + } + return "02" + case 'j': + if flag == '-' { + if parsing { + return "__2" + } + return "" + } + return "002" + case 'I': + if flag == '-' || parsing { + return "3" + } + return "03" + case 'H': + if flag == '-' && !parsing { + return "" + } + return "15" + case 'M': + if flag == '-' || parsing { + return "4" + } + return "04" + case 'S': + if flag == '-' || parsing { + return "5" + } + return "05" + case 'y': + return "06" + case 'Y': + return "2006" + case 'p': + return "PM" + case 'P': + return "pm" + case 'Z': + return "MST" + case 'z': + if flag == ':' { + if parsing { + return "Z07:00" + } + return "-07:00" + } + if parsing { + return "Z0700" + } + return "-0700" + + case '+': + if parsing { + return "Mon Jan _2 15:4:5 MST 2006" + } + return "Mon Jan _2 15:04:05 MST 2006" + case 'c': + if parsing { + return "Mon Jan _2 15:4:5 2006" + } + return "Mon Jan _2 15:04:05 2006" + case 'v': + return "_2-Jan-2006" + case 'F': + if parsing { + return "2006-1-2" + } + return "2006-01-02" + case 'D', 'x': + if parsing { + return "1/2/06" + } + return "01/02/06" + case 'r': + if parsing { + return "3:4:5 PM" + } + return "03:04:05 PM" + case 'T', 'X': + if parsing { + return "15:4:5" + } + return "15:04:05" + case 'R': + if parsing { + return "15:4" + } + return "15:04" + + case '%': + return "%" + case 't': + return "\t" + case 'n': + return "\n" + } +} + +// https://nsdateformatter.com/ +func uts35Pattern(spec, flag byte) string { + switch spec { + default: + return "" + + case 'B': + return "MMMM" + case 'b', 'h': + return "MMM" + case 'm': + if flag == '-' { + return "M" + } + return "MM" + case 'A': + return "EEEE" + case 'a': + return "E" + case 'd': + if flag == '-' { + return "d" + } + return "dd" + case 'j': + if flag == '-' { + return "D" + } + return "DDD" + case 'I': + if flag == '-' { + return "h" + } + return "hh" + case 'H': + if flag == '-' { + return "H" + } + return "HH" + case 'M': + if flag == '-' { + return "m" + } + return "mm" + case 'S': + if flag == '-' { + return "s" + } + return "ss" + case 'y': + return "yy" + case 'Y': + return "yyyy" + case 'g': + return "YY" + case 'G': + return "YYYY" + case 'V': + if flag == '-' { + return "w" + } + return "ww" + case 'p': + return "a" + case 'Z': + return "zzz" + case 'z': + if flag == ':' { + return "xxx" + } + return "xx" + case 'L': + return "SSS" + case 'f': + return "SSSSSS" + case 'N': + return "SSSSSSSSS" + + case '+': + return "E MMM d HH:mm:ss zzz yyyy" + case 'c': + return "E MMM d HH:mm:ss yyyy" + case 'v': + return "d-MMM-yyyy" + case 'F': + return "yyyy-MM-dd" + case 'D', 'x': + return "MM/dd/yy" + case 'r': + return "hh:mm:ss a" + case 'T', 'X': + return "HH:mm:ss" + case 'R': + return "HH:mm" + + case '%': + return "%" + case 't': + return "\t" + case 'n': + return "\n" + } +} + +// http://man.he.net/man3/strftime +func okModifier(mod, spec byte) bool { + if mod == 'E' { + return strings.Contains("cCxXyY", string(spec)) + } + if mod == 'O' { + return strings.Contains("deHImMSuUVwWy", string(spec)) + } + return false +} diff --git a/vendor/github.com/ncruces/go-strftime/strftime.go b/vendor/github.com/ncruces/go-strftime/strftime.go new file mode 100644 index 000000000..5308ef772 --- /dev/null +++ b/vendor/github.com/ncruces/go-strftime/strftime.go @@ -0,0 +1,324 @@ +package strftime + +import ( + "bytes" + "strconv" + "time" +) + +// Format returns a textual representation of the time value +// formatted according to the strftime format specification. +func Format(fmt string, t time.Time) string { + buf := buffer(fmt) + return string(AppendFormat(buf, fmt, t)) +} + +// AppendFormat is like Format, but appends the textual representation +// to dst and returns the extended buffer. +func AppendFormat(dst []byte, fmt string, t time.Time) []byte { + var parser parser + + parser.literal = func(b byte) error { + dst = append(dst, b) + return nil + } + + parser.format = func(spec, flag byte) error { + switch spec { + case 'A': + dst = append(dst, t.Weekday().String()...) + return nil + case 'a': + dst = append(dst, t.Weekday().String()[:3]...) + return nil + case 'B': + dst = append(dst, t.Month().String()...) + return nil + case 'b', 'h': + dst = append(dst, t.Month().String()[:3]...) + return nil + case 'm': + dst = appendInt2(dst, int(t.Month()), flag) + return nil + case 'd': + dst = appendInt2(dst, int(t.Day()), flag) + return nil + case 'e': + dst = appendInt2(dst, int(t.Day()), ' ') + return nil + case 'I': + dst = append12Hour(dst, t, flag) + return nil + case 'l': + dst = append12Hour(dst, t, ' ') + return nil + case 'H': + dst = appendInt2(dst, t.Hour(), flag) + return nil + case 'k': + dst = appendInt2(dst, t.Hour(), ' ') + return nil + case 'M': + dst = appendInt2(dst, t.Minute(), flag) + return nil + case 'S': + dst = appendInt2(dst, t.Second(), flag) + return nil + case 'L': + dst = append(dst, t.Format(".000")[1:]...) + return nil + case 'f': + dst = append(dst, t.Format(".000000")[1:]...) + return nil + case 'N': + dst = append(dst, t.Format(".000000000")[1:]...) + return nil + case 'y': + dst = t.AppendFormat(dst, "06") + return nil + case 'Y': + dst = t.AppendFormat(dst, "2006") + return nil + case 'C': + dst = t.AppendFormat(dst, "2006") + dst = dst[:len(dst)-2] + return nil + case 'U': + dst = appendWeekNumber(dst, t, flag, true) + return nil + case 'W': + dst = appendWeekNumber(dst, t, flag, false) + return nil + case 'V': + _, w := t.ISOWeek() + dst = appendInt2(dst, w, flag) + return nil + case 'g': + y, _ := t.ISOWeek() + dst = year(y).AppendFormat(dst, "06") + return nil + case 'G': + y, _ := t.ISOWeek() + dst = year(y).AppendFormat(dst, "2006") + return nil + case 's': + dst = strconv.AppendInt(dst, t.Unix(), 10) + return nil + case 'Q': + dst = strconv.AppendInt(dst, t.UnixMilli(), 10) + return nil + case 'w': + w := t.Weekday() + dst = appendInt1(dst, int(w)) + return nil + case 'u': + if w := t.Weekday(); w == 0 { + dst = append(dst, '7') + } else { + dst = appendInt1(dst, int(w)) + } + return nil + case 'j': + if flag == '-' { + dst = strconv.AppendInt(dst, int64(t.YearDay()), 10) + } else { + dst = t.AppendFormat(dst, "002") + } + return nil + } + + if layout := goLayout(spec, flag, false); layout != "" { + dst = t.AppendFormat(dst, layout) + return nil + } + + dst = append(dst, '%') + if flag != 0 { + dst = append(dst, flag) + } + dst = append(dst, spec) + return nil + } + + parser.parse(fmt) + return dst +} + +// Parse converts a textual representation of time to the time value it represents +// according to the strptime format specification. +func Parse(fmt, value string) (time.Time, error) { + pattern, err := layout(fmt, true) + if err != nil { + return time.Time{}, err + } + return time.Parse(pattern, value) +} + +// Layout converts a strftime format specification +// to a Go time pattern specification. +func Layout(fmt string) (string, error) { + return layout(fmt, false) +} + +func layout(fmt string, parsing bool) (string, error) { + dst := buffer(fmt) + var parser parser + + parser.literal = func(b byte) error { + if '0' <= b && b <= '9' { + return literalErr(b) + } + dst = append(dst, b) + if b == 'M' || b == 'T' || b == 'm' || b == 'n' { + switch { + case bytes.HasSuffix(dst, []byte("Jan")): + return literalErr("Jan") + case bytes.HasSuffix(dst, []byte("Mon")): + return literalErr("Mon") + case bytes.HasSuffix(dst, []byte("MST")): + return literalErr("MST") + case bytes.HasSuffix(dst, []byte("PM")): + return literalErr("PM") + case bytes.HasSuffix(dst, []byte("pm")): + return literalErr("pm") + } + } + return nil + } + + parser.format = func(spec, flag byte) error { + if layout := goLayout(spec, flag, parsing); layout != "" { + dst = append(dst, layout...) + return nil + } + + switch spec { + default: + return formatError{} + + case 'L', 'f', 'N': + if bytes.HasSuffix(dst, []byte(".")) || bytes.HasSuffix(dst, []byte(",")) { + switch spec { + default: + dst = append(dst, "000"...) + case 'f': + dst = append(dst, "000000"...) + case 'N': + dst = append(dst, "000000000"...) + } + return nil + } + return formatError{message: "must follow '.' or ','"} + } + } + + if err := parser.parse(fmt); err != nil { + return "", err + } + return string(dst), nil +} + +// UTS35 converts a strftime format specification +// to a Unicode Technical Standard #35 Date Format Pattern. +func UTS35(fmt string) (string, error) { + const quote = '\'' + var quoted bool + dst := buffer(fmt) + + var parser parser + + parser.literal = func(b byte) error { + if b == quote { + dst = append(dst, quote, quote) + return nil + } + if !quoted && ('a' <= b && b <= 'z' || 'A' <= b && b <= 'Z') { + dst = append(dst, quote) + quoted = true + } + dst = append(dst, b) + return nil + } + + parser.format = func(spec, flag byte) error { + if quoted { + dst = append(dst, quote) + quoted = false + } + if pattern := uts35Pattern(spec, flag); pattern != "" { + dst = append(dst, pattern...) + return nil + } + return formatError{} + } + + if err := parser.parse(fmt); err != nil { + return "", err + } + if quoted { + dst = append(dst, quote) + } + return string(dst), nil +} + +func buffer(format string) (buf []byte) { + const bufSize = 64 + max := len(format) + 10 + if max < bufSize { + var b [bufSize]byte + buf = b[:0] + } else { + buf = make([]byte, 0, max) + } + return +} + +func year(y int) time.Time { + return time.Date(y, time.January, 1, 0, 0, 0, 0, time.UTC) +} + +func appendWeekNumber(dst []byte, t time.Time, flag byte, sunday bool) []byte { + offset := int(t.Weekday()) + if sunday { + offset = 6 - offset + } else if offset != 0 { + offset = 7 - offset + } + return appendInt2(dst, (t.YearDay()+offset)/7, flag) +} + +func append12Hour(dst []byte, t time.Time, flag byte) []byte { + h := t.Hour() + if h == 0 { + h = 12 + } else if h > 12 { + h -= 12 + } + return appendInt2(dst, h, flag) +} + +func appendInt1(dst []byte, i int) []byte { + return append(dst, byte('0'+i)) +} + +func appendInt2(dst []byte, i int, flag byte) []byte { + if flag == 0 || i >= 10 { + return append(dst, smallsString[i*2:i*2+2]...) + } + if flag == ' ' { + dst = append(dst, flag) + } + return appendInt1(dst, i) +} + +const smallsString = "" + + "00010203040506070809" + + "10111213141516171819" + + "20212223242526272829" + + "30313233343536373839" + + "40414243444546474849" + + "50515253545556575859" + + "60616263646566676869" + + "70717273747576777879" + + "80818283848586878889" + + "90919293949596979899" |