pax_global_header00006660000000000000000000000064142277235150014522gustar00rootroot0000000000000052 comment=547681d557cd991738423af2350722cb462ba62f strftime-1.0.6/000077500000000000000000000000001422772351500133635ustar00rootroot00000000000000strftime-1.0.6/.github/000077500000000000000000000000001422772351500147235ustar00rootroot00000000000000strftime-1.0.6/.github/FUNDING.yml000066400000000000000000000012061422772351500165370ustar00rootroot00000000000000# These are supported funding model platforms github: ["lestrrat"] patreon: # Replace with a single Patreon username open_collective: # Replace with a single Open Collective username ko_fi: # Replace with a single Ko-fi username tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] strftime-1.0.6/.github/workflows/000077500000000000000000000000001422772351500167605ustar00rootroot00000000000000strftime-1.0.6/.github/workflows/ci.yml000066400000000000000000000013711422772351500201000ustar00rootroot00000000000000name: CI on: [push, pull_request] jobs: build: runs-on: ubuntu-latest strategy: matrix: go: [ '1.18', '1.17', '1.16', '1.15', '1.14', '1.13' ] tags: [ 'strftime_native_errors', '' ] fail-fast: false name: "Go ${{ matrix.go }} test (tags: ${{ matrix.tags }})" steps: - name: Checkout repository uses: actions/checkout@v2 - name: Install Go stable version uses: actions/setup-go@v3 with: go-version: ${{ matrix.go }} - name: Test with coverage run: make STRFTIME_TAGS=${{ matrix.tags }} cover - name: Upload code coverage to codecov if: matrix.go == '1.18' uses: codecov/codecov-action@v1 with: file: ./coverage.out strftime-1.0.6/.github/workflows/lint.yml000066400000000000000000000005761422772351500204610ustar00rootroot00000000000000name: lint on: [push] jobs: golangci: name: lint runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-go@v3 with: go-version: 1.18 check-latest: true - uses: golangci/golangci-lint-action@v2 with: version: v1.45.2 - name: Run go vet run: | go vet ./... strftime-1.0.6/.gitignore000066400000000000000000000004121422772351500153500ustar00rootroot00000000000000# 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 *.prof strftime-1.0.6/.golangci.yml000066400000000000000000000001211422772351500157410ustar00rootroot00000000000000issues: exclude-rules: - path: _test\.go linters: - errcheck strftime-1.0.6/Changes000066400000000000000000000022101422772351500146510ustar00rootroot00000000000000Changes ======= v1.0.6 - 20 Apr 2022 [Miscellaneous] * Minimum go version is now go 1.13 * github.com/pkg/errors is going to be phased out in steps. In this release, users may opt-in to using native errors using `fmt.Errorf("%w")` by specifying the tag `strftime_native_errors`. In the next release, the default will be to use native errors, but users will be able to opt-in to using github.com/pkg/errors using a tag. The version after will remove github.com/pkg/errors. This is something that we normally would do over a major version upgrade but since we do not expect this library to receive API breaking changes in the near future and thus no v2 is expected, we have decided to do this over few non-major releases. v1.0.5 [New features] * `(strftime.Strftime).FormatBuffer([]byte, time.Time) []byte` has been added. This allows the user to provide the same underlying `[]byte` buffer for each call to `FormatBuffer`, which avoid allocation per call. * `%I` formatted midnight as `00`, where it should have been using `01` before v1.0.4 Apparently we have failed to provide Changes prior to v1.0.5 :( strftime-1.0.6/LICENSE000066400000000000000000000020511422772351500143660ustar00rootroot00000000000000MIT License Copyright (c) 2016 lestrrat 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. strftime-1.0.6/Makefile000066400000000000000000000007751422772351500150340ustar00rootroot00000000000000.PHONY: bench realclean cover viewcover test lint bench: go test -tags bench -benchmem -bench . @git checkout go.mod @rm go.sum realclean: rm coverage.out test: go test -v -race ./... cover: ifeq ($(strip $(STRFTIME_TAGS)),) go test -v -race -coverpkg=./... -coverprofile=coverage.out ./... else go test -v -tags $(STRFTIME_TAGS) -race -coverpkg=./... -coverprofile=coverage.out ./... endif viewcover: go tool cover -html=coverage.out lint: golangci-lint run ./... imports: goimports -w ./ strftime-1.0.6/README.md000066400000000000000000000234041422772351500146450ustar00rootroot00000000000000# strftime Fast strftime for Go [![Build Status](https://travis-ci.org/lestrrat-go/strftime.png?branch=master)](https://travis-ci.org/lestrrat-go/strftime) [![GoDoc](https://godoc.org/github.com/lestrrat-go/strftime?status.svg)](https://godoc.org/github.com/lestrrat-go/strftime) # SYNOPSIS ```go f, err := strftime.New(`.... pattern ...`) if err := f.Format(buf, time.Now()); err != nil { log.Println(err.Error()) } ``` # DESCRIPTION The goals for this library are * Optimized for the same pattern being called repeatedly * Be flexible about destination to write the results out * Be as complete as possible in terms of conversion specifications # API ## Format(string, time.Time) (string, error) Takes the pattern and the time, and formats it. This function is a utility function that recompiles the pattern every time the function is called. If you know beforehand that you will be formatting the same pattern multiple times, consider using `New` to create a `Strftime` object and reuse it. ## New(string) (\*Strftime, error) Takes the pattern and creates a new `Strftime` object. ## obj.Pattern() string Returns the pattern string used to create this `Strftime` object ## obj.Format(io.Writer, time.Time) error Formats the time according to the pre-compiled pattern, and writes the result to the specified `io.Writer` ## obj.FormatString(time.Time) string Formats the time according to the pre-compiled pattern, and returns the result string. # SUPPORTED CONVERSION SPECIFICATIONS | pattern | description | |:--------|:------------| | %A | national representation of the full weekday name | | %a | national representation of the abbreviated weekday | | %B | national representation of the full month name | | %b | national representation of the abbreviated month name | | %C | (year / 100) as decimal number; single digits are preceded by a zero | | %c | national representation of time and date | | %D | equivalent to %m/%d/%y | | %d | day of the month as a decimal number (01-31) | | %e | the day of the month as a decimal number (1-31); single digits are preceded by a blank | | %F | equivalent to %Y-%m-%d | | %H | the hour (24-hour clock) as a decimal number (00-23) | | %h | same as %b | | %I | the hour (12-hour clock) as a decimal number (01-12) | | %j | the day of the year as a decimal number (001-366) | | %k | the hour (24-hour clock) as a decimal number (0-23); single digits are preceded by a blank | | %l | the hour (12-hour clock) as a decimal number (1-12); single digits are preceded by a blank | | %M | the minute as a decimal number (00-59) | | %m | the month as a decimal number (01-12) | | %n | a newline | | %p | national representation of either "ante meridiem" (a.m.) or "post meridiem" (p.m.) as appropriate. | | %R | equivalent to %H:%M | | %r | equivalent to %I:%M:%S %p | | %S | the second as a decimal number (00-60) | | %T | equivalent to %H:%M:%S | | %t | a tab | | %U | the week number of the year (Sunday as the first day of the week) as a decimal number (00-53) | | %u | the weekday (Monday as the first day of the week) as a decimal number (1-7) | | %V | the week number of the year (Monday as the first day of the week) as a decimal number (01-53) | | %v | equivalent to %e-%b-%Y | | %W | the week number of the year (Monday as the first day of the week) as a decimal number (00-53) | | %w | the weekday (Sunday as the first day of the week) as a decimal number (0-6) | | %X | national representation of the time | | %x | national representation of the date | | %Y | the year with century as a decimal number | | %y | the year without century as a decimal number (00-99) | | %Z | the time zone name | | %z | the time zone offset from UTC | | %% | a '%' | # EXTENSIONS / CUSTOM SPECIFICATIONS This library in general tries to be POSIX compliant, but sometimes you just need that extra specification or two that is relatively widely used but is not included in the POSIX specification. For example, POSIX does not specify how to print out milliseconds, but popular implementations allow `%f` or `%L` to achieve this. For those instances, `strftime.Strftime` can be configured to use a custom set of specifications: ``` ss := strftime.NewSpecificationSet() ss.Set('L', ...) // provide implementation for `%L` // pass this new specification set to the strftime instance p, err := strftime.New(`%L`, strftime.WithSpecificationSet(ss)) p.Format(..., time.Now()) ``` The implementation must implement the `Appender` interface, which is ``` type Appender interface { Append([]byte, time.Time) []byte } ``` For commonly used extensions such as the millisecond example and Unix timestamp, we provide a default implementation so the user can do one of the following: ``` // (1) Pass a specification byte and the Appender // This allows you to pass arbitrary Appenders p, err := strftime.New( `%L`, strftime.WithSpecification('L', strftime.Milliseconds), ) // (2) Pass an option that knows to use strftime.Milliseconds p, err := strftime.New( `%L`, strftime.WithMilliseconds('L'), ) ``` Similarly for Unix Timestamp: ``` // (1) Pass a specification byte and the Appender // This allows you to pass arbitrary Appenders p, err := strftime.New( `%s`, strftime.WithSpecification('s', strftime.UnixSeconds), ) // (2) Pass an option that knows to use strftime.UnixSeconds p, err := strftime.New( `%s`, strftime.WithUnixSeconds('s'), ) ``` If a common specification is missing, please feel free to submit a PR (but please be sure to be able to defend how "common" it is) ## List of available extensions - [`Milliseconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#Milliseconds) (related option: [`WithMilliseconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#WithMilliseconds)); - [`Microseconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#Microseconds) (related option: [`WithMicroseconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#WithMicroseconds)); - [`UnixSeconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#UnixSeconds) (related option: [`WithUnixSeconds`](https://pkg.go.dev/github.com/lestrrat-go/strftime?tab=doc#WithUnixSeconds)). # PERFORMANCE / OTHER LIBRARIES The following benchmarks were run separately because some libraries were using cgo on specific platforms (notabley, the fastly version) ``` // On my OS X 10.14.6, 2.3 GHz Intel Core i5, 16GB memory. // go version go1.13.4 darwin/amd64 hummingbird% go test -tags bench -benchmem -bench . BenchmarkTebeka-4 297471 3905 ns/op 257 B/op 20 allocs/op BenchmarkJehiah-4 818444 1773 ns/op 256 B/op 17 allocs/op BenchmarkFastly-4 2330794 550 ns/op 80 B/op 5 allocs/op BenchmarkLestrrat-4 916365 1458 ns/op 80 B/op 2 allocs/op BenchmarkLestrratCachedString-4 2527428 546 ns/op 128 B/op 2 allocs/op BenchmarkLestrratCachedWriter-4 537422 2155 ns/op 192 B/op 3 allocs/op PASS ok github.com/lestrrat-go/strftime 25.618s ``` ``` // On a host on Google Cloud Platform, machine-type: f1-micro (vCPU x 1, memory: 0.6GB) // (Yes, I was being skimpy) // Linux 4.9.0-11-amd64 #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20) x86_64 GNU/Linux // go version go1.13.4 linux/amd64 hummingbird% go test -tags bench -benchmem -bench . BenchmarkTebeka 254997 4726 ns/op 256 B/op 20 allocs/op BenchmarkJehiah 659289 1882 ns/op 256 B/op 17 allocs/op BenchmarkFastly 389150 3044 ns/op 224 B/op 13 allocs/op BenchmarkLestrrat 699069 1780 ns/op 80 B/op 2 allocs/op BenchmarkLestrratCachedString 2081594 589 ns/op 128 B/op 2 allocs/op BenchmarkLestrratCachedWriter 825763 1480 ns/op 192 B/op 3 allocs/op PASS ok github.com/lestrrat-go/strftime 11.355s ``` This library is much faster than other libraries *IF* you can reuse the format pattern. Here's the annotated list from the benchmark results. You can clearly see that (re)using a `Strftime` object and producing a string is the fastest. Writing to an `io.Writer` seems a bit sluggish, but since the one producing the string is doing almost exactly the same thing, we believe this is purely the overhead of writing to an `io.Writer` | Import Path | Score | Note | |:------------------------------------|--------:|:--------------------------------| | github.com/lestrrat-go/strftime | 3000000 | Using `FormatString()` (cached) | | github.com/fastly/go-utils/strftime | 2000000 | Pure go version on OS X | | github.com/lestrrat-go/strftime | 1000000 | Using `Format()` (NOT cached) | | github.com/jehiah/go-strftime | 1000000 | | | github.com/fastly/go-utils/strftime | 1000000 | cgo version on Linux | | github.com/lestrrat-go/strftime | 500000 | Using `Format()` (cached) | | github.com/tebeka/strftime | 300000 | | However, depending on your pattern, this speed may vary. If you find a particular pattern that seems sluggish, please send in patches or tests. Please also note that this benchmark only uses the subset of conversion specifications that are supported by *ALL* of the libraries compared. Somethings to consider when making performance comparisons in the future: * Can it write to io.Writer? * Which `%specification` does it handle? strftime-1.0.6/appenders.go000066400000000000000000000203661422772351500157020ustar00rootroot00000000000000package strftime import ( "bytes" "fmt" "io" "strconv" "strings" "time" ) // These are all of the standard, POSIX compliant specifications. // Extensions should be in extensions.go var ( fullWeekDayName = StdlibFormat("Monday") abbrvWeekDayName = StdlibFormat("Mon") fullMonthName = StdlibFormat("January") abbrvMonthName = StdlibFormat("Jan") centuryDecimal = AppendFunc(appendCentury) timeAndDate = StdlibFormat("Mon Jan _2 15:04:05 2006") mdy = StdlibFormat("01/02/06") dayOfMonthZeroPad = StdlibFormat("02") dayOfMonthSpacePad = StdlibFormat("_2") ymd = StdlibFormat("2006-01-02") twentyFourHourClockZeroPad = &hourPadded{twelveHour: false, pad: '0'} twelveHourClockZeroPad = &hourPadded{twelveHour: true, pad: '0'} dayOfYear = AppendFunc(appendDayOfYear) twentyFourHourClockSpacePad = &hourPadded{twelveHour: false, pad: ' '} twelveHourClockSpacePad = &hourPadded{twelveHour: true, pad: ' '} minutesZeroPad = StdlibFormat("04") monthNumberZeroPad = StdlibFormat("01") newline = Verbatim("\n") ampm = StdlibFormat("PM") hm = StdlibFormat("15:04") imsp = hmsWAMPM{} secondsNumberZeroPad = StdlibFormat("05") hms = StdlibFormat("15:04:05") tab = Verbatim("\t") weekNumberSundayOrigin = weeknumberOffset(0) // week number of the year, Sunday first weekdayMondayOrigin = weekday(1) // monday as the first day, and 01 as the first value weekNumberMondayOriginOneOrigin = AppendFunc(appendWeekNumber) eby = StdlibFormat("_2-Jan-2006") // monday as the first day, and 00 as the first value weekNumberMondayOrigin = weeknumberOffset(1) // week number of the year, Monday first weekdaySundayOrigin = weekday(0) natReprTime = StdlibFormat("15:04:05") // national representation of the time XXX is this correct? natReprDate = StdlibFormat("01/02/06") // national representation of the date XXX is this correct? year = StdlibFormat("2006") // year with century yearNoCentury = StdlibFormat("06") // year w/o century timezone = StdlibFormat("MST") // time zone name timezoneOffset = StdlibFormat("-0700") // time zone ofset from UTC percent = Verbatim("%") ) // Appender is the interface that must be fulfilled by components that // implement the translation of specifications to actual time value. // // The Append method takes the accumulated byte buffer, and the time to // use to generate the textual representation. The resulting byte // sequence must be returned by this method, normally by using the // append() builtin function. type Appender interface { Append([]byte, time.Time) []byte } // AppendFunc is an utility type to allow users to create a // function-only version of an Appender type AppendFunc func([]byte, time.Time) []byte func (af AppendFunc) Append(b []byte, t time.Time) []byte { return af(b, t) } type appenderList []Appender type dumper interface { dump(io.Writer) } func (l appenderList) dump(out io.Writer) { var buf bytes.Buffer ll := len(l) for i, a := range l { if dumper, ok := a.(dumper); ok { dumper.dump(&buf) } else { fmt.Fprintf(&buf, "%#v", a) } if i < ll-1 { fmt.Fprintf(&buf, ",\n") } } if _, err := buf.WriteTo(out); err != nil { panic(err) } } // does the time.Format thing type stdlibFormat struct { s string } // StdlibFormat returns an Appender that simply goes through `time.Format()` // For example, if you know you want to display the abbreviated month name for %b, // you can create a StdlibFormat with the pattern `Jan` and register that // for specification `b`: // // a := StdlibFormat(`Jan`) // ss := NewSpecificationSet() // ss.Set('b', a) // does %b -> abbreviated month name func StdlibFormat(s string) Appender { return &stdlibFormat{s: s} } func (v stdlibFormat) Append(b []byte, t time.Time) []byte { return t.AppendFormat(b, v.s) } func (v stdlibFormat) str() string { return v.s } func (v stdlibFormat) canCombine() bool { return true } func (v stdlibFormat) combine(w combiner) Appender { return StdlibFormat(v.s + w.str()) } func (v stdlibFormat) dump(out io.Writer) { fmt.Fprintf(out, "stdlib: %s", v.s) } type verbatimw struct { s string } // Verbatim returns an Appender suitable for generating static text. // For static text, this method is slightly favorable than creating // your own appender, as adjacent verbatim blocks will be combined // at compile time to produce more efficient Appenders func Verbatim(s string) Appender { return &verbatimw{s: s} } func (v verbatimw) Append(b []byte, _ time.Time) []byte { return append(b, v.s...) } func (v verbatimw) canCombine() bool { return canCombine(v.s) } func (v verbatimw) combine(w combiner) Appender { if _, ok := w.(*stdlibFormat); ok { return StdlibFormat(v.s + w.str()) } return Verbatim(v.s + w.str()) } func (v verbatimw) str() string { return v.s } func (v verbatimw) dump(out io.Writer) { fmt.Fprintf(out, "verbatim: %s", v.s) } // These words below, as well as any decimal character var combineExclusion = []string{ "Mon", "Monday", "Jan", "January", "MST", "PM", "pm", } func canCombine(s string) bool { if strings.ContainsAny(s, "0123456789") { return false } for _, word := range combineExclusion { if strings.Contains(s, word) { return false } } return true } type combiner interface { canCombine() bool combine(combiner) Appender str() string } // this is container for the compiler to keep track of appenders, // and combine them as we parse and compile the pattern type combiningAppend struct { list appenderList prev Appender prevCanCombine bool } func (ca *combiningAppend) Append(w Appender) { if ca.prevCanCombine { if wc, ok := w.(combiner); ok && wc.canCombine() { ca.prev = ca.prev.(combiner).combine(wc) ca.list[len(ca.list)-1] = ca.prev return } } ca.list = append(ca.list, w) ca.prev = w ca.prevCanCombine = false if comb, ok := w.(combiner); ok { if comb.canCombine() { ca.prevCanCombine = true } } } func appendCentury(b []byte, t time.Time) []byte { n := t.Year() / 100 if n < 10 { b = append(b, '0') } return append(b, strconv.Itoa(n)...) } type weekday int func (v weekday) Append(b []byte, t time.Time) []byte { n := int(t.Weekday()) if n < int(v) { n += 7 } return append(b, byte(n+48)) } type weeknumberOffset int func (v weeknumberOffset) Append(b []byte, t time.Time) []byte { yd := t.YearDay() offset := int(t.Weekday()) - int(v) if offset < 0 { offset += 7 } if yd < offset { return append(b, '0', '0') } n := ((yd - offset) / 7) + 1 if n < 10 { b = append(b, '0') } return append(b, strconv.Itoa(n)...) } func appendWeekNumber(b []byte, t time.Time) []byte { _, n := t.ISOWeek() if n < 10 { b = append(b, '0') } return append(b, strconv.Itoa(n)...) } func appendDayOfYear(b []byte, t time.Time) []byte { n := t.YearDay() if n < 10 { b = append(b, '0', '0') } else if n < 100 { b = append(b, '0') } return append(b, strconv.Itoa(n)...) } type hourPadded struct { pad byte twelveHour bool } func (v hourPadded) Append(b []byte, t time.Time) []byte { h := t.Hour() if v.twelveHour && h > 12 { h = h - 12 } if v.twelveHour && h == 0 { h = 12 } if h < 10 { b = append(b, v.pad) b = append(b, byte(h+48)) } else { b = unrollTwoDigits(b, h) } return b } func unrollTwoDigits(b []byte, v int) []byte { b = append(b, byte((v/10)+48)) b = append(b, byte((v%10)+48)) return b } type hmsWAMPM struct{} func (v hmsWAMPM) Append(b []byte, t time.Time) []byte { h := t.Hour() var am bool if h == 0 { b = append(b, '1') b = append(b, '2') am = true } else { switch { case h == 12: // no op case h > 12: h = h - 12 default: am = true } b = unrollTwoDigits(b, h) } b = append(b, ':') b = unrollTwoDigits(b, t.Minute()) b = append(b, ':') b = unrollTwoDigits(b, t.Second()) b = append(b, ' ') if am { b = append(b, 'A') } else { b = append(b, 'P') } b = append(b, 'M') return b } strftime-1.0.6/bench/000077500000000000000000000000001422772351500144425ustar00rootroot00000000000000strftime-1.0.6/bench/bench_test.go000066400000000000000000000032001422772351500171020ustar00rootroot00000000000000package bench_test import ( "bytes" "log" "net/http" _ "net/http/pprof" "testing" "time" fastly "github.com/fastly/go-utils/strftime" jehiah "github.com/jehiah/go-strftime" lestrrat "github.com/lestrrat-go/strftime" tebeka "github.com/tebeka/strftime" ) func init() { go func() { log.Println(http.ListenAndServe("localhost:8080", nil)) }() } const benchfmt = `%A %a %B %b %d %H %I %M %m %p %S %Y %y %Z` func BenchmarkTebeka(b *testing.B) { var t time.Time for i := 0; i < b.N; i++ { tebeka.Format(benchfmt, t) } } func BenchmarkJehiah(b *testing.B) { // Grr, uses byte slices, and does it faster, but with more allocs var t time.Time for i := 0; i < b.N; i++ { jehiah.Format(benchfmt, t) } } func BenchmarkFastly(b *testing.B) { var t time.Time for i := 0; i < b.N; i++ { fastly.Strftime(benchfmt, t) } } func BenchmarkLestrrat(b *testing.B) { var t time.Time for i := 0; i < b.N; i++ { lestrrat.Format(benchfmt, t) } } func BenchmarkLestrratCachedString(b *testing.B) { var t time.Time f, _ := lestrrat.New(benchfmt) // This benchmark does not take into effect the compilation time for i := 0; i < b.N; i++ { f.FormatString(t) } } func BenchmarkLestrratCachedWriter(b *testing.B) { var t time.Time f, _ := lestrrat.New(benchfmt) var buf bytes.Buffer b.ResetTimer() // This benchmark does not take into effect the compilation time for i := 0; i < b.N; i++ { buf.Reset() f.Format(&buf, t) } } func BenchmarkLestrratCachedFormatBuffer(b *testing.B) { var t time.Time f, _ := lestrrat.New(benchfmt) b.ResetTimer() var buf []byte for i := 0; i < b.N; i++ { buf = f.FormatBuffer(buf[:0], t) } } strftime-1.0.6/bench/go.mod000066400000000000000000000004171422772351500155520ustar00rootroot00000000000000module github.com/lestrrat-go/strftime/bench go 1.16 require ( github.com/fastly/go-utils v0.0.0-20180712184237-d95a45783239 github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869 github.com/lestrrat-go/strftime v1.0.3 github.com/tebeka/strftime v0.1.5 ) strftime-1.0.6/extension.go000066400000000000000000000032531422772351500157310ustar00rootroot00000000000000package strftime import ( "strconv" "time" ) // NOTE: declare private variable and iniitalize once in init(), // and leave the Milliseconds() function as returning static content. // This way, `go doc -all` does not show the contents of the // milliseconds function var milliseconds Appender var microseconds Appender var unixseconds Appender func init() { milliseconds = AppendFunc(func(b []byte, t time.Time) []byte { millisecond := int(t.Nanosecond()) / int(time.Millisecond) if millisecond < 100 { b = append(b, '0') } if millisecond < 10 { b = append(b, '0') } return append(b, strconv.Itoa(millisecond)...) }) microseconds = AppendFunc(func(b []byte, t time.Time) []byte { microsecond := int(t.Nanosecond()) / int(time.Microsecond) if microsecond < 100000 { b = append(b, '0') } if microsecond < 10000 { b = append(b, '0') } if microsecond < 1000 { b = append(b, '0') } if microsecond < 100 { b = append(b, '0') } if microsecond < 10 { b = append(b, '0') } return append(b, strconv.Itoa(microsecond)...) }) unixseconds = AppendFunc(func(b []byte, t time.Time) []byte { return append(b, strconv.FormatInt(t.Unix(), 10)...) }) } // Milliseconds returns the Appender suitable for creating a zero-padded, // 3-digit millisecond textual representation. func Milliseconds() Appender { return milliseconds } // Microsecond returns the Appender suitable for creating a zero-padded, // 6-digit microsecond textual representation. func Microseconds() Appender { return microseconds } // UnixSeconds returns the Appender suitable for creating // unix timestamp textual representation. func UnixSeconds() Appender { return unixseconds } strftime-1.0.6/go.mod000066400000000000000000000003021422772351500144640ustar00rootroot00000000000000module github.com/lestrrat-go/strftime go 1.13 require ( github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc github.com/pkg/errors v0.9.1 github.com/stretchr/testify v1.3.0 ) strftime-1.0.6/go.sum000066400000000000000000000017541422772351500145250ustar00rootroot00000000000000github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc h1:RKf14vYWi2ttpEmkA4aQ3j4u9dStX2t4M8UM6qqNsG8= github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc/go.mod h1:kopuH9ugFRkIXf3YoqHKyrJ9YfUFsckUU9S7B+XP+is= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= strftime-1.0.6/internal/000077500000000000000000000000001422772351500151775ustar00rootroot00000000000000strftime-1.0.6/internal/errors/000077500000000000000000000000001422772351500165135ustar00rootroot00000000000000strftime-1.0.6/internal/errors/errors_fmt.go000066400000000000000000000004661422772351500212320ustar00rootroot00000000000000//go:build strftime_native_errors // +build strftime_native_errors package errors import "fmt" func New(s string) error { return fmt.Errorf(s) } func Errorf(s string, args ...interface{}) error { return fmt.Errorf(s, args...) } func Wrap(err error, s string) error { return fmt.Errorf(s+`: %w`, err) } strftime-1.0.6/internal/errors/errors_pkg.go000066400000000000000000000005071422772351500212210ustar00rootroot00000000000000//go:build !strftime_native_errors // +build !strftime_native_errors package errors import "github.com/pkg/errors" func New(s string) error { return errors.New(s) } func Errorf(s string, args ...interface{}) error { return errors.Errorf(s, args...) } func Wrap(err error, s string) error { return errors.Wrap(err, s) } strftime-1.0.6/internal_test.go000066400000000000000000000010141422772351500165610ustar00rootroot00000000000000package strftime import ( "testing" "github.com/stretchr/testify/assert" ) func TestCombine(t *testing.T) { { s, err := New(`%A foo`) if !assert.NoError(t, err, `New should succeed`) { return } if !assert.Equal(t, 1, len(s.compiled), "there are 1 element") { return } } { s, _ := New(`%A 100`) if !assert.Equal(t, 2, len(s.compiled), "there are two elements") { return } } { s, _ := New(`%A Mon`) if !assert.Equal(t, 2, len(s.compiled), "there are two elements") { return } } } strftime-1.0.6/options.go000066400000000000000000000035171422772351500154130ustar00rootroot00000000000000package strftime type Option interface { Name() string Value() interface{} } type option struct { name string value interface{} } func (o *option) Name() string { return o.name } func (o *option) Value() interface{} { return o.value } const optSpecificationSet = `opt-specification-set` // WithSpecification allows you to specify a custom specification set func WithSpecificationSet(ds SpecificationSet) Option { return &option{ name: optSpecificationSet, value: ds, } } type optSpecificationPair struct { name byte appender Appender } const optSpecification = `opt-specification` // WithSpecification allows you to create a new specification set on the fly, // to be used only for that invocation. func WithSpecification(b byte, a Appender) Option { return &option{ name: optSpecification, value: &optSpecificationPair{ name: b, appender: a, }, } } // WithMilliseconds is similar to WithSpecification, and specifies that // the Strftime object should interpret the pattern `%b` (where b // is the byte that you specify as the argument) // as the zero-padded, 3 letter milliseconds of the time. func WithMilliseconds(b byte) Option { return WithSpecification(b, Milliseconds()) } // WithMicroseconds is similar to WithSpecification, and specifies that // the Strftime object should interpret the pattern `%b` (where b // is the byte that you specify as the argument) // as the zero-padded, 3 letter microseconds of the time. func WithMicroseconds(b byte) Option { return WithSpecification(b, Microseconds()) } // WithUnixSeconds is similar to WithSpecification, and specifies that // the Strftime object should interpret the pattern `%b` (where b // is the byte that you specify as the argument) // as the unix timestamp in seconds func WithUnixSeconds(b byte) Option { return WithSpecification(b, UnixSeconds()) } strftime-1.0.6/specifications.go000066400000000000000000000070241422772351500167200ustar00rootroot00000000000000package strftime import ( "fmt" "sync" "github.com/lestrrat-go/strftime/internal/errors" ) // because there is no such thing was a sync.RWLocker type rwLocker interface { RLock() RUnlock() sync.Locker } // SpecificationSet is a container for patterns that Strftime uses. // If you want a custom strftime, you can copy the default // SpecificationSet and tweak it type SpecificationSet interface { Lookup(byte) (Appender, error) Delete(byte) error Set(byte, Appender) error } type specificationSet struct { mutable bool lock rwLocker store map[byte]Appender } // The default specification set does not need any locking as it is never // accessed from the outside, and is never mutated. var defaultSpecificationSet SpecificationSet func init() { defaultSpecificationSet = newImmutableSpecificationSet() } func newImmutableSpecificationSet() SpecificationSet { // Create a mutable one so that populateDefaultSpecifications work through // its magic, then copy the associated map // (NOTE: this is done this way because there used to be // two struct types for specification set, united under an interface. // it can now be removed, but we would need to change the entire // populateDefaultSpecifications method, and I'm currently too lazy // PRs welcome) tmp := NewSpecificationSet() ss := &specificationSet{ mutable: false, lock: nil, // never used, so intentionally not initialized store: tmp.(*specificationSet).store, } return ss } // NewSpecificationSet creates a specification set with the default specifications. func NewSpecificationSet() SpecificationSet { ds := &specificationSet{ mutable: true, lock: &sync.RWMutex{}, store: make(map[byte]Appender), } populateDefaultSpecifications(ds) return ds } var defaultSpecifications = map[byte]Appender{ 'A': fullWeekDayName, 'a': abbrvWeekDayName, 'B': fullMonthName, 'b': abbrvMonthName, 'C': centuryDecimal, 'c': timeAndDate, 'D': mdy, 'd': dayOfMonthZeroPad, 'e': dayOfMonthSpacePad, 'F': ymd, 'H': twentyFourHourClockZeroPad, 'h': abbrvMonthName, 'I': twelveHourClockZeroPad, 'j': dayOfYear, 'k': twentyFourHourClockSpacePad, 'l': twelveHourClockSpacePad, 'M': minutesZeroPad, 'm': monthNumberZeroPad, 'n': newline, 'p': ampm, 'R': hm, 'r': imsp, 'S': secondsNumberZeroPad, 'T': hms, 't': tab, 'U': weekNumberSundayOrigin, 'u': weekdayMondayOrigin, 'V': weekNumberMondayOriginOneOrigin, 'v': eby, 'W': weekNumberMondayOrigin, 'w': weekdaySundayOrigin, 'X': natReprTime, 'x': natReprDate, 'Y': year, 'y': yearNoCentury, 'Z': timezone, 'z': timezoneOffset, '%': percent, } func populateDefaultSpecifications(ds SpecificationSet) { for c, handler := range defaultSpecifications { if err := ds.Set(c, handler); err != nil { panic(fmt.Sprintf("failed to set default specification for %c: %s", c, err)) } } } func (ds *specificationSet) Lookup(b byte) (Appender, error) { if ds.mutable { ds.lock.RLock() defer ds.lock.RLock() } v, ok := ds.store[b] if !ok { return nil, errors.Errorf(`lookup failed: '%%%c' was not found in specification set`, b) } return v, nil } func (ds *specificationSet) Delete(b byte) error { if !ds.mutable { return errors.New(`delete failed: this specification set is marked immutable`) } ds.lock.Lock() defer ds.lock.Unlock() delete(ds.store, b) return nil } func (ds *specificationSet) Set(b byte, a Appender) error { if !ds.mutable { return errors.New(`set failed: this specification set is marked immutable`) } ds.lock.Lock() defer ds.lock.Unlock() ds.store[b] = a return nil } strftime-1.0.6/strftime.go000066400000000000000000000131771422772351500155600ustar00rootroot00000000000000package strftime import ( "io" "strings" "sync" "time" "github.com/lestrrat-go/strftime/internal/errors" ) type compileHandler interface { handle(Appender) } // compile, and create an appender list type appenderListBuilder struct { list *combiningAppend } func (alb *appenderListBuilder) handle(a Appender) { alb.list.Append(a) } // compile, and execute the appenders on the fly type appenderExecutor struct { t time.Time dst []byte } func (ae *appenderExecutor) handle(a Appender) { ae.dst = a.Append(ae.dst, ae.t) } func compile(handler compileHandler, p string, ds SpecificationSet) error { for l := len(p); l > 0; l = len(p) { // This is a really tight loop, so we don't even calls to // Verbatim() to cuase extra stuff var verbatim verbatimw i := strings.IndexByte(p, '%') if i < 0 { verbatim.s = p handler.handle(&verbatim) // this is silly, but I don't trust break keywords when there's a // possibility of this piece of code being rearranged p = p[l:] continue } if i == l-1 { return errors.New(`stray % at the end of pattern`) } // we found a '%'. we need the next byte to decide what to do next // we already know that i < l - 1 // everything up to the i is verbatim if i > 0 { verbatim.s = p[:i] handler.handle(&verbatim) p = p[i:] } specification, err := ds.Lookup(p[1]) if err != nil { return errors.Wrap(err, `pattern compilation failed`) } handler.handle(specification) p = p[2:] } return nil } func getSpecificationSetFor(options ...Option) (SpecificationSet, error) { var ds SpecificationSet = defaultSpecificationSet var extraSpecifications []*optSpecificationPair for _, option := range options { switch option.Name() { case optSpecificationSet: ds = option.Value().(SpecificationSet) case optSpecification: extraSpecifications = append(extraSpecifications, option.Value().(*optSpecificationPair)) } } if len(extraSpecifications) > 0 { // If ds is immutable, we're going to need to create a new // one. oh what a waste! if raw, ok := ds.(*specificationSet); ok && !raw.mutable { ds = NewSpecificationSet() } for _, v := range extraSpecifications { if err := ds.Set(v.name, v.appender); err != nil { return nil, err } } } return ds, nil } var fmtAppendExecutorPool = sync.Pool{ New: func() interface{} { var h appenderExecutor h.dst = make([]byte, 0, 32) return &h }, } func getFmtAppendExecutor() *appenderExecutor { return fmtAppendExecutorPool.Get().(*appenderExecutor) } func releasdeFmtAppendExecutor(v *appenderExecutor) { // TODO: should we discard the buffer if it's too long? v.dst = v.dst[:0] fmtAppendExecutorPool.Put(v) } // Format takes the format `s` and the time `t` to produce the // format date/time. Note that this function re-compiles the // pattern every time it is called. // // If you know beforehand that you will be reusing the pattern // within your application, consider creating a `Strftime` object // and reusing it. func Format(p string, t time.Time, options ...Option) (string, error) { // TODO: this may be premature optimization ds, err := getSpecificationSetFor(options...) if err != nil { return "", errors.Wrap(err, `failed to get specification set`) } h := getFmtAppendExecutor() defer releasdeFmtAppendExecutor(h) h.t = t if err := compile(h, p, ds); err != nil { return "", errors.Wrap(err, `failed to compile format`) } return string(h.dst), nil } // Strftime is the object that represents a compiled strftime pattern type Strftime struct { pattern string compiled appenderList } // New creates a new Strftime object. If the compilation fails, then // an error is returned in the second argument. func New(p string, options ...Option) (*Strftime, error) { // TODO: this may be premature optimization ds, err := getSpecificationSetFor(options...) if err != nil { return nil, errors.Wrap(err, `failed to get specification set`) } var h appenderListBuilder h.list = &combiningAppend{} if err := compile(&h, p, ds); err != nil { return nil, errors.Wrap(err, `failed to compile format`) } return &Strftime{ pattern: p, compiled: h.list.list, }, nil } // Pattern returns the original pattern string func (f *Strftime) Pattern() string { return f.pattern } // Format takes the destination `dst` and time `t`. It formats the date/time // using the pre-compiled pattern, and outputs the results to `dst` func (f *Strftime) Format(dst io.Writer, t time.Time) error { const bufSize = 64 var b []byte max := len(f.pattern) + 10 if max < bufSize { var buf [bufSize]byte b = buf[:0] } else { b = make([]byte, 0, max) } if _, err := dst.Write(f.format(b, t)); err != nil { return err } return nil } // FormatBuffer is equivalent to Format, but appends the result directly to // supplied slice dst, returning the updated slice. This avoids any internal // memory allocation. func (f *Strftime) FormatBuffer(dst []byte, t time.Time) []byte { return f.format(dst, t) } // Dump outputs the internal structure of the formatter, for debugging purposes. // Please do NOT assume the output format to be fixed: it is expected to change // in the future. func (f *Strftime) Dump(out io.Writer) { f.compiled.dump(out) } func (f *Strftime) format(b []byte, t time.Time) []byte { for _, w := range f.compiled { b = w.Append(b, t) } return b } // FormatString takes the time `t` and formats it, returning the // string containing the formated data. func (f *Strftime) FormatString(t time.Time) string { const bufSize = 64 var b []byte max := len(f.pattern) + 10 if max < bufSize { var buf [bufSize]byte b = buf[:0] } else { b = make([]byte, 0, max) } return string(f.format(b, t)) } strftime-1.0.6/strftime_test.go000066400000000000000000000220361422772351500166110ustar00rootroot00000000000000package strftime_test import ( "bytes" "fmt" "os" "testing" "time" envload "github.com/lestrrat-go/envload" "github.com/lestrrat-go/strftime" "github.com/stretchr/testify/assert" ) var ref = time.Unix(1136239445, 123456789).UTC() func TestExclusion(t *testing.T) { s, err := strftime.New("%p PM") if !assert.NoError(t, err, `strftime.New should succeed`) { return } var tm time.Time if !assert.Equal(t, "AM PM", s.FormatString(tm)) { return } } func TestInvalid(t *testing.T) { _, err := strftime.New("%") if !assert.Error(t, err, `strftime.New should return error`) { return } _, err = strftime.New(" %") if !assert.Error(t, err, `strftime.New should return error`) { return } _, err = strftime.New(" % ") if !assert.Error(t, err, `strftime.New should return error`) { return } } func TestFormatMethods(t *testing.T) { l := envload.New() defer l.Restore() os.Setenv("LC_ALL", "C") formatString := `%A %a %B %b %C %c %D %d %e %F %H %h %I %j %k %l %M %m %n %p %R %r %S %T %t %U %u %V %v %W %w %X %x %Y %y %Z %z` resultString := "Monday Mon January Jan 20 Mon Jan 2 22:04:05 2006 01/02/06 02 2 2006-01-02 22 Jan 10 002 22 10 04 01 \n PM 22:04 10:04:05 PM 05 22:04:05 \t 01 1 01 2-Jan-2006 01 1 22:04:05 01/02/06 2006 06 UTC +0000" s, err := strftime.Format(formatString, ref) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, resultString, s, `formatted result matches`) { return } formatter, err := strftime.New(formatString) if !assert.NoError(t, err, `strftime.New succeeds`) { return } if !assert.Equal(t, resultString, formatter.FormatString(ref), `formatted result matches`) { return } var buf bytes.Buffer err = formatter.Format(&buf, ref) if !assert.NoError(t, err, `Format method succeeds`) { return } if !assert.Equal(t, resultString, buf.String(), `formatted result matches`) { return } var dst []byte dst = formatter.FormatBuffer(dst, ref) if !assert.Equal(t, resultString, string(dst), `formatted result matches`) { return } dst = []byte("nonsense") dst = formatter.FormatBuffer(dst[:0], ref) if !assert.Equal(t, resultString, string(dst), `overwritten result matches`) { return } dst = []byte("nonsense") dst = formatter.FormatBuffer(dst, ref) if !assert.Equal(t, "nonsense"+resultString, string(dst), `appended result matches`) { return } } func TestFormatBlanks(t *testing.T) { l := envload.New() defer l.Restore() os.Setenv("LC_ALL", "C") { dt := time.Date(1, 1, 1, 18, 0, 0, 0, time.UTC) s, err := strftime.Format("%l", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, " 6", s, "leading blank is properly set") { return } } { dt := time.Date(1, 1, 1, 6, 0, 0, 0, time.UTC) s, err := strftime.Format("%k", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, " 6", s, "leading blank is properly set") { return } } } func TestFormatZeropad(t *testing.T) { l := envload.New() defer l.Restore() os.Setenv("LC_ALL", "C") { dt := time.Date(1, 1, 1, 1, 0, 0, 0, time.UTC) s, err := strftime.Format("%j", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, "001", s, "padding is properly set") { return } } { dt := time.Date(1, 1, 10, 6, 0, 0, 0, time.UTC) s, err := strftime.Format("%j", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, "010", s, "padding is properly set") { return } } { dt := time.Date(1, 6, 1, 6, 0, 0, 0, time.UTC) s, err := strftime.Format("%j", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, "152", s, "padding is properly set") { return } } { dt := time.Date(100, 1, 1, 1, 0, 0, 0, time.UTC) s, err := strftime.Format("%C", dt) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, "01", s, "padding is properly set") { return } } } func TestGHIssue5(t *testing.T) { const expected = `apm-test/logs/apm.log.01000101` p, _ := strftime.New("apm-test/logs/apm.log.%Y%m%d") dt := time.Date(100, 1, 1, 1, 0, 0, 0, time.UTC) if !assert.Equal(t, expected, p.FormatString(dt), `patterns including 'pm' should be treated as verbatim formatter`) { return } } func TestGHPR7(t *testing.T) { const expected = `123` p, _ := strftime.New(`%L`, strftime.WithMilliseconds('L')) if !assert.Equal(t, expected, p.FormatString(ref), `patterns should match for custom specification`) { return } } func TestWithMicroseconds(t *testing.T) { const expected = `123456` p, _ := strftime.New(`%f`, strftime.WithMicroseconds('f')) if !assert.Equal(t, expected, p.FormatString(ref), `patterns should match for custom specification`) { return } } func TestWithUnixSeconds(t *testing.T) { const expected = `1136239445` p, _ := strftime.New(`%s`, strftime.WithUnixSeconds('s')) if !assert.Equal(t, expected, p.FormatString(ref), `patterns should match for custom specification`) { return } } func ExampleSpecificationSet() { { // I want %L as milliseconds! p, err := strftime.New(`%L`, strftime.WithMilliseconds('L')) if err != nil { fmt.Println(err) return } p.Format(os.Stdout, ref) os.Stdout.Write([]byte{'\n'}) } { // I want %f as milliseconds! p, err := strftime.New(`%f`, strftime.WithMilliseconds('f')) if err != nil { fmt.Println(err) return } p.Format(os.Stdout, ref) os.Stdout.Write([]byte{'\n'}) } { // I want %X to print out my name! a := strftime.Verbatim(`Daisuke Maki`) p, err := strftime.New(`%X`, strftime.WithSpecification('X', a)) if err != nil { fmt.Println(err) return } p.Format(os.Stdout, ref) os.Stdout.Write([]byte{'\n'}) } { // I want a completely new specification set, and I want %X to print out my name! a := strftime.Verbatim(`Daisuke Maki`) ds := strftime.NewSpecificationSet() ds.Set('X', a) p, err := strftime.New(`%X`, strftime.WithSpecificationSet(ds)) if err != nil { fmt.Println(err) return } p.Format(os.Stdout, ref) os.Stdout.Write([]byte{'\n'}) } { // I want %s as unix timestamp! p, err := strftime.New(`%s`, strftime.WithUnixSeconds('s')) if err != nil { fmt.Println(err) return } p.Format(os.Stdout, ref) os.Stdout.Write([]byte{'\n'}) } // OUTPUT: // 123 // 123 // Daisuke Maki // Daisuke Maki // 1136239445 } func TestGHIssue9(t *testing.T) { pattern, _ := strftime.New("/full1/test2/to3/proveIssue9isfixed/11%C22/12345%Y%m%d.%H.log.%C.log") testTime := time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC) correctString := "/full1/test2/to3/proveIssue9isfixed/112022/1234520200101.01.log.20.log" var buf bytes.Buffer pattern.Format(&buf, testTime) // Using a fixed time should give us a fixed output. if !assert.True(t, buf.String() == correctString) { t.Logf("Buffer [%s] should be [%s]", buf.String(), correctString) return } } func TestGHIssue18(t *testing.T) { testIH := func(twelveHour bool) func(t *testing.T) { var patternString string if twelveHour { patternString = "%I" } else { patternString = "%H" } return func(t *testing.T) { t.Helper() var buf bytes.Buffer pattern, _ := strftime.New(patternString) for i := 0; i < 24; i++ { testTime := time.Date(2020, 1, 1, i, 1, 1, 1, time.UTC) var correctString string switch { case twelveHour && i == 0: correctString = fmt.Sprintf("%02d", 12) case twelveHour && i > 12: correctString = fmt.Sprintf("%02d", i-12) default: correctString = fmt.Sprintf("%02d", i) } buf.Reset() pattern.Format(&buf, testTime) if !assert.Equal(t, correctString, buf.String(), "Buffer [%s] should be [%s] for time %s", buf.String(), correctString, testTime) { return } } } } testR := func(t *testing.T) { t.Helper() patternString := "%r" var buf bytes.Buffer pattern, _ := strftime.New(patternString) for i := 0; i < 24; i++ { testTime := time.Date(2020, 1, 1, i, 1, 1, 1, time.UTC) var correctString string switch { case i == 0: correctString = fmt.Sprintf("%02d:%02d:%02d AM", 12, testTime.Minute(), testTime.Second()) case i == 12: correctString = fmt.Sprintf("%02d:%02d:%02d PM", 12, testTime.Minute(), testTime.Second()) case i > 12: correctString = fmt.Sprintf("%02d:%02d:%02d PM", i-12, testTime.Minute(), testTime.Second()) default: correctString = fmt.Sprintf("%02d:%02d:%02d AM", i, testTime.Minute(), testTime.Second()) } buf.Reset() t.Logf("%s", correctString) pattern.Format(&buf, testTime) if !assert.Equal(t, correctString, buf.String(), "Buffer [%s] should be [%s] for time %s", buf.String(), correctString, testTime) { continue } } } t.Run("12 hour zero pad %I", testIH(true)) t.Run("24 hour zero pad %H", testIH(false)) t.Run("12 hour zero pad %r", testR) } func TestFormat12AM(t *testing.T) { s, err := strftime.Format(`%H %I %l`, time.Time{}) if !assert.NoError(t, err, `strftime.Format succeeds`) { return } if !assert.Equal(t, "00 12 12", s, "correctly format the hour") { return } }