[![Build Status](https://travis-ci.org/awoodbeck/strftime.svg?branch=master)](https://travis-ci.org/awoodbeck/strftime)
[![Coverage Status](https://coveralls.io/repos/github/awoodbeck/strftime/badge.svg)](https://coveralls.io/github/awoodbeck/strftime)
[![Go Report Card](https://goreportcard.com/badge/github.com/awoodbeck/strftime)](https://goreportcard.com/report/github.com/awoodbeck/strftime)
[![GoDoc](https://godoc.org/github.com/awoodbeck/strftime?status.svg)](https://godoc.org/github.com/awoodbeck/strftime)

# strftime

C99-compatible strftime formatter for use with Go time.Time instances.

See [strftime](http://en.cppreference.com/w/c/chrono/strftime) for available conversion specifiers.  Specific locale specifiers are not yet supported.


strftime

For interacting with intervals of time, defined as a start time and a duration.

timespan
========

timespan is a [Go](http://golang.org/) library for interacting with intervals of time, defined as a start time and a duration.

Documentation
-------------

- [API](http://godoc.org/github.com/SaidinWoT/timespan)

Installation
------------

Install timespan using the "go get" command:

	go get github.com/SaidinWoT/timespan

Contributing
------------
Contributions are welcome. Simply send a pull request my way.

License
-------
timespan is available under the [MIT License](https://github.com/SaidinWoT/timespan/blob/master/LICENSE)


timespan

A Duration extension supporting parsing/printing durations in days, weeks and years.

# approx

[![Build Status](https://github.com/goschtalt/approx/actions/workflows/ci.yml/badge.svg)](https://github.com/goschtalt/approx/actions/workflows/ci.yml)
[![codecov.io](http://codecov.io/github/goschtalt/approx/coverage.svg?branch=main)](http://codecov.io/github/goschtalt/approx?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/goschtalt/approx)](https://goreportcard.com/report/github.com/goschtalt/approx)
[![GitHub Release](https://img.shields.io/github/release/goschtalt/approx.svg)](https://github.com/goschtalt/approx/releases)
[![GoDoc](https://pkg.go.dev/badge/github.com/goschtalt/approx)](https://pkg.go.dev/github.com/goschtalt/approx)

Package approx adds support for durations of days, weeks and years.  The code
used is from the go standard library.  Only very minor adjustments were made
to enable parsing to support extra units of time.

# Usage

This really simple library allows you to normally use the `time.Duration` object
from the go standard library, but suppliments two functions for handling
approximate time durations.

```golang
package main

import (
	"fmt"

	"github.com/goschtalt/approx"
)

func main() {
	d, err := approx.ParseDuration("1w4d")
	if err != nil {
		panic(err)
	}

	fmt.Println(approx.String(d))
	fmt.Println(d)
}
```

[Go Playground](https://go.dev/play/p/zX2FeTrC8Qb)


approx

A simple, semantic and developer-friendly golang package for datetime.

carbon

Simple Time extension with a lot of util methods, ported from PHP Carbon library.

Carbon
======
[![Build Status](https://github.com/uniplaces/carbon/actions/workflows/pull_request.yml/badge.svg)](https://github.com/uniplaces/carbon/actions/workflows/pull_request.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/uniplaces/carbon)](https://goreportcard.com/report/github.com/uniplaces/carbon)
[![codecov](https://codecov.io/gh/uniplaces/carbon/branch/master/graph/badge.svg)](https://codecov.io/gh/uniplaces/carbon)
[![GoDoc](https://godoc.org/github.com/uniplaces/carbon?status.svg)](https://godoc.org/github.com/uniplaces/carbon)
[![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)


A simple extension for [Time](https://golang.org/pkg/time/#Time) based on PHP's [Carbon](http://carbon.nesbot.com) library.

__Features:__

* [Time](https://golang.org/pkg/time/#Time) is embedded into Carbon (provides access to all of [Time](https://golang.org/pkg/time/#Time)'s functionality)
* Supports addition and subtraction of dates
* Provides methods to compare dates
* Supports date formatting in common formats
* Easily calculate difference between dates
* Ease testing with dates by using `carbon.Freeze()` and `carbon.Now()`

__To do:__

* Implement all localization features as in Carbon
* Improve the code style to be more idiomatic Go

## Getting started
Install Carbon:
```
go get github.com/uniplaces/carbon
```

Add to your imports to start using Carbon
```go
import "github.com/uniplaces/carbon"
```

## Examples
A simple example to get you started:
```go
package main

import (
	"fmt"
	"time"

	"github.com/uniplaces/carbon"
)

func main() {
	fmt.Printf("Right now is %s\n", carbon.Now().DateTimeString())

	today, _ := carbon.NowInLocation("America/Vancouver")
	fmt.Printf("Right now in Vancouver is %s\n", today)

	fmt.Printf("Tomorrow is %s\n", carbon.Now().AddDay())
	fmt.Printf("Last week is %s\n", carbon.Now().SubWeek())

	nextOlympics, _ := carbon.CreateFromDate(2016, time.August, 5, "Europe/London")
	nextOlympics = nextOlympics.AddYears(4)
	fmt.Printf("Next olympics are in %d\n", nextOlympics.Year())

	if carbon.Now().IsWeekend() {
		fmt.Printf("Party time!")
	}
}
```

You can also check the `examples/` folder for more examples.

## Contributing
Please feel free to make suggestions, create issues, fork the repository and send pull requests!

## Licence
Copyright 2016 UNIPLACES

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


Parses Cron-style time range expressions, checks if the given time is within any ranges.

# cronrange

[![GoDoc](https://godoc.org/github.com/1set/cronrange?status.svg)](https://godoc.org/github.com/1set/cronrange)
[![License](https://img.shields.io/github/license/1set/cronrange)](https://github.com/1set/cronrange/blob/master/LICENSE)
[![GitHub Action Workflow](https://github.com/1set/cronrange/workflows/build/badge.svg)](https://github.com/1set/cronrange/actions?workflow=build)
[![Go Report Card](https://goreportcard.com/badge/github.com/1set/cronrange)](https://goreportcard.com/report/github.com/1set/cronrange)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/ef272059b4044252b0097270b48d5703)](https://www.codacy.com/manual/an9an63/cronrange)
[![Codecov](https://codecov.io/gh/1set/cronrange/branch/master/graph/badge.svg)](https://codecov.io/gh/1set/cronrange)

cronrange is a Go package for _time range expression_ in _Cron_ style.

In a nutshell, CronRange expression is a combination of Cron expression and time duration to represent periodic time ranges, i.e. **Cron** for Time**Range**. And it made easier to tell if the moment falls within the any time ranges (use [IsWithin()](https://godoc.org/github.com/1set/cronrange#CronRange.IsWithin) method), and what's the next occurrence (use [NextOccurrences()](https://godoc.org/github.com/1set/cronrange#CronRange.NextOccurrences) method).

For example, every New Year's Day in Tokyo can be written as:

```cron
DR=1440; TZ=Asia/Tokyo; 0 0 1 1 *
```

It consists of three parts separated by a semicolon:

-   `DR=1440` stands for duration in minutes, 60 \* 24 = 1440 min;
-   `TZ=Asia/Tokyo` is optional and for time zone using name in [IANA Time Zone database](https://www.iana.org/time-zones);
-   `0 0 1 1 *` is a cron expression representing the beginning of the time range.

## Installation

To download the package:

```bash
go get -u github.com/1set/cronrange
```

## Usage

To import it in your program as:

```go
import "github.com/1set/cronrange"
```

Examples can be found in [GoDoc](https://godoc.org/github.com/1set/cronrange#pkg-examples).

## License

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2F1set%2Fcronrange.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2F1set%2Fcronrange?ref=badge_large)


cronrange

Augments Time for working with dates, date ranges, time spans, periods, and time-of-day.

# date

[![GoDoc](https://img.shields.io/badge/api-Godoc-blue.svg)](https://pkg.go.dev/github.com/rickb777/date/v2)
[![Go Report Card](https://goreportcard.com/badge/github.com/rickb777/date)](https://goreportcard.com/report/github.com/rickb777/date/v2)
[![Issues](https://img.shields.io/github/issues/rickb777/date.svg)](https://github.com/rickb777/date/issues)

Package `date` provides functionality for working with dates.

This package introduces a light-weight `Date` type that is storage-efficient
and convenient for calendrical calculations and date parsing and formatting
(including years outside the [0,9999] interval).

It also provides

 * `clock.Clock` which expresses a wall-clock style hours-minutes-seconds with millisecond precision.
 * `timespan.DateRange` which expresses a period between two dates.
 * `timespan.TimeSpan` which expresses a duration of time between two instants (see RFC5545).
 * `view.VDate` which wraps `Date` for use in templates etc.

See [package documentation](https://godoc.org/github.com/rickb777/date) for
full documentation and examples.

See also [period.Period](https://pkg.go.dev/github.com/rickb777/period), which implements periods corresponding
to the ISO-8601 form (e.g. "PT30S").

## Installation

 go get github.com/rickb777/date/v2

## Status

This library has been in reliable production use for some time. Versioning follows the well-known semantic version pattern.

### Version 2

Changes since v1:

* The [period.Period](https://pkg.go.dev/github.com/rickb777/period) type has moved.
* `clock.Clock` now has nanosecond resolution (formerly millisecond resolution). 
* `date.Date` is now an integer that holds the number of days since year zero. Previously, it was a struct based on year 1970.
* `date.Date` time conversion methods have more explicit names - see table below.
* `date.Date` arithmetic and comparison operations now rely on Go operators; the corresponding methods have been deleted - see table below.
* `date.Date` zero value is now year 0 (Gregorian proleptic astronomical) so 1970 will no longer cause issues.
* `date.PeriodOfDays` has been moved to `timespan.PeriodOfDays`
* `date.DateString` has been deleted; the SQL `driver.Valuer` implementation is now pluggable and serves the same purpose more simply.

Renamed methods:

| Was | Use instead |
|-------------------|-------------------------|
| date.Date`.Local` | date.Date`.Midnight` |
| date.Date`.UTC` | date.Date`.MidnightUTC` |
| date.Date`.In` | date.Date`.MidnightIn` |

Deleted methods and functions:

| Was | Use instead |
|--------------------------------|--------------------|
| date.Date.`Add` | `+` |
| date.Date.`Sub` | `-` |
| date.Date.`IsZero` | `== 0` |
| date.Date.`Equal` | `==` |
| date.Date.`Before` | `<` |
| date.Date.`After` | `>` |
| `date.IsLeap` | `gregorian.IsLeap` |
| `date.DaysIn` | `gregorian.DaysIn` |
| timespan.DateRange.`Normalise` | (not needed) |

Any v1 dates persistently stored as integers will be incorrect; these can be corrected by **adding 719162** (`date.ZeroOffset`) to them, which is the number of days between year zero (v2) and 1970 (v1). Dates stored as strings will be unaffected.

## Credits

This package follows very closely the design of package
[`time`](http://golang.org/pkg/time/) in the standard library;
many of the `Date` methods are implemented using the corresponding methods
of the `time.Time` type and much of the documentation is copied directly
from that package.

The original [Good Work](https://github.com/fxtlabs/date) on which this was
based was done by Filippo Tampieri at Fxtlabs.

date

Parse date's without knowing format in advance.

Go Date Parser 
---------------------------

Parse many date strings without knowing format in advance.  Uses a scanner to read bytes and use a state machine to find format.  Much faster than shotgun based parse methods.  See [bench_test.go](https://github.com/araddon/dateparse/blob/master/bench_test.go) for performance comparison.


[![Code Coverage](https://codecov.io/gh/araddon/dateparse/branch/master/graph/badge.svg)](https://codecov.io/gh/araddon/dateparse)
[![GoDoc](https://godoc.org/github.com/araddon/dateparse?status.svg)](http://godoc.org/github.com/araddon/dateparse)
[![Build Status](https://travis-ci.org/araddon/dateparse.svg?branch=master)](https://travis-ci.org/araddon/dateparse)
[![Go ReportCard](https://goreportcard.com/badge/araddon/dateparse)](https://goreportcard.com/report/araddon/dateparse)

**MM/DD/YYYY VS DD/MM/YYYY** Right now this uses mm/dd/yyyy WHEN ambiguous if this is not desired behavior, use `ParseStrict` which will fail on ambiguous date strings.

**Timezones** The location your server is configured affects the results!  See example or https://play.golang.org/p/IDHRalIyXh and last paragraph here https://golang.org/pkg/time/#Parse.


```go

// Normal parse.  Equivalent Timezone rules as time.Parse()
t, err := dateparse.ParseAny("3/1/2014")

// Parse Strict, error on ambigous mm/dd vs dd/mm dates
t, err := dateparse.ParseStrict("3/1/2014")
> returns error 

// Return a string that represents the layout to parse the given date-time.
layout, err := dateparse.ParseFormat("May 8, 2009 5:57:51 PM")
> "Jan 2, 2006 3:04:05 PM"

```

cli tool for testing dateformats
----------------------------------

[Date Parse CLI](https://github.com/araddon/dateparse/blob/master/dateparse)


Extended example
-------------------

https://github.com/araddon/dateparse/blob/master/example/main.go

```go
package main

import (
	"flag"
	"fmt"
	"time"

	"github.com/scylladb/termtables"
	"github.com/araddon/dateparse"
)

var examples = []string{
	"May 8, 2009 5:57:51 PM",
	"oct 7, 1970",
	"oct 7, '70",
	"oct. 7, 1970",
	"oct. 7, 70",
	"Mon Jan  2 15:04:05 2006",
	"Mon Jan  2 15:04:05 MST 2006",
	"Mon Jan 02 15:04:05 -0700 2006",
	"Monday, 02-Jan-06 15:04:05 MST",
	"Mon, 02 Jan 2006 15:04:05 MST",
	"Tue, 11 Jul 2017 16:28:13 +0200 (CEST)",
	"Mon, 02 Jan 2006 15:04:05 -0700",
	"Mon 30 Sep 2018 09:09:09 PM UTC",
	"Mon Aug 10 15:44:11 UTC+0100 2015",
	"Thu, 4 Jan 2018 17:53:36 +0000",
	"Fri Jul 03 2015 18:04:07 GMT+0100 (GMT Daylight Time)",
	"Sun, 3 Jan 2021 00:12:23 +0800 (GMT+08:00)",
	"September 17, 2012 10:09am",
	"September 17, 2012 at 10:09am PST-08",
	"September 17, 2012, 10:10:09",
	"October 7, 1970",
	"October 7th, 1970",
	"12 Feb 2006, 19:17",
	"12 Feb 2006 19:17",
	"14 May 2019 19:11:40.164",
	"7 oct 70",
	"7 oct 1970",
	"03 February 2013",
	"1 July 2013",
	"2013-Feb-03",
	// dd/Mon/yyy  alpha Months
	"06/Jan/2008:15:04:05 -0700",
	"06/Jan/2008 15:04:05 -0700",
	//   mm/dd/yy
	"3/31/2014",
	"03/31/2014",
	"08/21/71",
	"8/1/71",
	"4/8/2014 22:05",
	"04/08/2014 22:05",
	"4/8/14 22:05",
	"04/2/2014 03:00:51",
	"8/8/1965 12:00:00 AM",
	"8/8/1965 01:00:01 PM",
	"8/8/1965 01:00 PM",
	"8/8/1965 1:00 PM",
	"8/8/1965 12:00 AM",
	"4/02/2014 03:00:51",
	"03/19/2012 10:11:59",
	"03/19/2012 10:11:59.3186369",
	// yyyy/mm/dd
	"2014/3/31",
	"2014/03/31",
	"2014/4/8 22:05",
	"2014/04/08 22:05",
	"2014/04/2 03:00:51",
	"2014/4/02 03:00:51",
	"2012/03/19 10:11:59",
	"2012/03/19 10:11:59.3186369",
	// yyyy:mm:dd
	"2014:3:31",
	"2014:03:31",
	"2014:4:8 22:05",
	"2014:04:08 22:05",
	"2014:04:2 03:00:51",
	"2014:4:02 03:00:51",
	"2012:03:19 10:11:59",
	"2012:03:19 10:11:59.3186369",
	// Chinese
	"2014年04月08日",
	//   yyyy-mm-ddThh
	"2006-01-02T15:04:05+0000",
	"2009-08-12T22:15:09-07:00",
	"2009-08-12T22:15:09",
	"2009-08-12T22:15:09.988",
	"2009-08-12T22:15:09Z",
	"2017-07-19T03:21:51:897+0100",
	"2019-05-29T08:41-04", // no seconds, 2 digit TZ offset
	//   yyyy-mm-dd hh:mm:ss
	"2014-04-26 17:24:37.3186369",
	"2012-08-03 18:31:59.257000000",
	"2014-04-26 17:24:37.123",
	"2013-04-01 22:43",
	"2013-04-01 22:43:22",
	"2014-12-16 06:20:00 UTC",
	"2014-12-16 06:20:00 GMT",
	"2014-04-26 05:24:37 PM",
	"2014-04-26 13:13:43 +0800",
	"2014-04-26 13:13:43 +0800 +08",
	"2014-04-26 13:13:44 +09:00",
	"2012-08-03 18:31:59.257000000 +0000 UTC",
	"2015-09-30 18:48:56.35272715 +0000 UTC",
	"2015-02-18 00:12:00 +0000 GMT",
	"2015-02-18 00:12:00 +0000 UTC",
	"2015-02-08 03:02:00 +0300 MSK m=+0.000000001",
	"2015-02-08 03:02:00.001 +0300 MSK m=+0.000000001",
	"2017-07-19 03:21:51+00:00",
	"2014-04-26",
	"2014-04",
	"2014",
	"2014-05-11 08:20:13,787",
	// yyyy-mm-dd-07:00
	"2020-07-20+08:00",
	// mm.dd.yy
	"3.31.2014",
	"03.31.2014",
	"08.21.71",
	"2014.03",
	"2014.03.30",
	//  yyyymmdd and similar
	"20140601",
	"20140722105203",
	// yymmdd hh:mm:yy  mysql log
	// 080313 05:21:55 mysqld started
	"171113 14:14:20",
	// unix seconds, ms, micro, nano
	"1332151919",
	"1384216367189",
	"1384216367111222",
	"1384216367111222333",
}

var (
	timezone = ""
)

func main() {
	flag.StringVar(&timezone, "timezone", "UTC", "Timezone aka `America/Los_Angeles` formatted time-zone")
	flag.Parse()

	if timezone != "" {
		// NOTE:  This is very, very important to understand
		// time-parsing in go
		loc, err := time.LoadLocation(timezone)
		if err != nil {
			panic(err.Error())
		}
		time.Local = loc
	}

	table := termtables.CreateTable()

	table.AddHeaders("Input", "Parsed, and Output as %v")
	for _, dateExample := range examples {
		t, err := dateparse.ParseLocal(dateExample)
		if err != nil {
			panic(err.Error())
		}
		table.AddRow(dateExample, fmt.Sprintf("%v", t))
	}
	fmt.Println(table.Render())
}

/*
+-------------------------------------------------------+-----------------------------------------+
| Input                                                 | Parsed, and Output as %v                |
+-------------------------------------------------------+-----------------------------------------+
| May 8, 2009 5:57:51 PM                                | 2009-05-08 17:57:51 +0000 UTC           |
| oct 7, 1970                                           | 1970-10-07 00:00:00 +0000 UTC           |
| oct 7, '70                                            | 1970-10-07 00:00:00 +0000 UTC           |
| oct. 7, 1970                                          | 1970-10-07 00:00:00 +0000 UTC           |
| oct. 7, 70                                            | 1970-10-07 00:00:00 +0000 UTC           |
| Mon Jan  2 15:04:05 2006                              | 2006-01-02 15:04:05 +0000 UTC           |
| Mon Jan  2 15:04:05 MST 2006                          | 2006-01-02 15:04:05 +0000 MST           |
| Mon Jan 02 15:04:05 -0700 2006                        | 2006-01-02 15:04:05 -0700 -0700         |
| Monday, 02-Jan-06 15:04:05 MST                        | 2006-01-02 15:04:05 +0000 MST           |
| Mon, 02 Jan 2006 15:04:05 MST                         | 2006-01-02 15:04:05 +0000 MST           |
| Tue, 11 Jul 2017 16:28:13 +0200 (CEST)                | 2017-07-11 16:28:13 +0200 +0200         |
| Mon, 02 Jan 2006 15:04:05 -0700                       | 2006-01-02 15:04:05 -0700 -0700         |
| Mon 30 Sep 2018 09:09:09 PM UTC                       | 2018-09-30 21:09:09 +0000 UTC           |
| Mon Aug 10 15:44:11 UTC+0100 2015                     | 2015-08-10 15:44:11 +0000 UTC           |
| Thu, 4 Jan 2018 17:53:36 +0000                        | 2018-01-04 17:53:36 +0000 UTC           |
| Fri Jul 03 2015 18:04:07 GMT+0100 (GMT Daylight Time) | 2015-07-03 18:04:07 +0100 GMT           |
| Sun, 3 Jan 2021 00:12:23 +0800 (GMT+08:00)            | 2021-01-03 00:12:23 +0800 +0800         |
| September 17, 2012 10:09am                            | 2012-09-17 10:09:00 +0000 UTC           |
| September 17, 2012 at 10:09am PST-08                  | 2012-09-17 10:09:00 -0800 PST           |
| September 17, 2012, 10:10:09                          | 2012-09-17 10:10:09 +0000 UTC           |
| October 7, 1970                                       | 1970-10-07 00:00:00 +0000 UTC           |
| October 7th, 1970                                     | 1970-10-07 00:00:00 +0000 UTC           |
| 12 Feb 2006, 19:17                                    | 2006-02-12 19:17:00 +0000 UTC           |
| 12 Feb 2006 19:17                                     | 2006-02-12 19:17:00 +0000 UTC           |
| 14 May 2019 19:11:40.164                              | 2019-05-14 19:11:40.164 +0000 UTC       |
| 7 oct 70                                              | 1970-10-07 00:00:00 +0000 UTC           |
| 7 oct 1970                                            | 1970-10-07 00:00:00 +0000 UTC           |
| 03 February 2013                                      | 2013-02-03 00:00:00 +0000 UTC           |
| 1 July 2013                                           | 2013-07-01 00:00:00 +0000 UTC           |
| 2013-Feb-03                                           | 2013-02-03 00:00:00 +0000 UTC           |
| 06/Jan/2008:15:04:05 -0700                            | 2008-01-06 15:04:05 -0700 -0700         |
| 06/Jan/2008 15:04:05 -0700                            | 2008-01-06 15:04:05 -0700 -0700         |
| 3/31/2014                                             | 2014-03-31 00:00:00 +0000 UTC           |
| 03/31/2014                                            | 2014-03-31 00:00:00 +0000 UTC           |
| 08/21/71                                              | 1971-08-21 00:00:00 +0000 UTC           |
| 8/1/71                                                | 1971-08-01 00:00:00 +0000 UTC           |
| 4/8/2014 22:05                                        | 2014-04-08 22:05:00 +0000 UTC           |
| 04/08/2014 22:05                                      | 2014-04-08 22:05:00 +0000 UTC           |
| 4/8/14 22:05                                          | 2014-04-08 22:05:00 +0000 UTC           |
| 04/2/2014 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 8/8/1965 12:00:00 AM                                  | 1965-08-08 00:00:00 +0000 UTC           |
| 8/8/1965 01:00:01 PM                                  | 1965-08-08 13:00:01 +0000 UTC           |
| 8/8/1965 01:00 PM                                     | 1965-08-08 13:00:00 +0000 UTC           |
| 8/8/1965 1:00 PM                                      | 1965-08-08 13:00:00 +0000 UTC           |
| 8/8/1965 12:00 AM                                     | 1965-08-08 00:00:00 +0000 UTC           |
| 4/02/2014 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 03/19/2012 10:11:59                                   | 2012-03-19 10:11:59 +0000 UTC           |
| 03/19/2012 10:11:59.3186369                           | 2012-03-19 10:11:59.3186369 +0000 UTC   |
| 2014/3/31                                             | 2014-03-31 00:00:00 +0000 UTC           |
| 2014/03/31                                            | 2014-03-31 00:00:00 +0000 UTC           |
| 2014/4/8 22:05                                        | 2014-04-08 22:05:00 +0000 UTC           |
| 2014/04/08 22:05                                      | 2014-04-08 22:05:00 +0000 UTC           |
| 2014/04/2 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 2014/4/02 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 2012/03/19 10:11:59                                   | 2012-03-19 10:11:59 +0000 UTC           |
| 2012/03/19 10:11:59.3186369                           | 2012-03-19 10:11:59.3186369 +0000 UTC   |
| 2014:3:31                                             | 2014-03-31 00:00:00 +0000 UTC           |
| 2014:03:31                                            | 2014-03-31 00:00:00 +0000 UTC           |
| 2014:4:8 22:05                                        | 2014-04-08 22:05:00 +0000 UTC           |
| 2014:04:08 22:05                                      | 2014-04-08 22:05:00 +0000 UTC           |
| 2014:04:2 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 2014:4:02 03:00:51                                    | 2014-04-02 03:00:51 +0000 UTC           |
| 2012:03:19 10:11:59                                   | 2012-03-19 10:11:59 +0000 UTC           |
| 2012:03:19 10:11:59.3186369                           | 2012-03-19 10:11:59.3186369 +0000 UTC   |
| 2014年04月08日                                        | 2014-04-08 00:00:00 +0000 UTC           |
| 2006-01-02T15:04:05+0000                              | 2006-01-02 15:04:05 +0000 UTC           |
| 2009-08-12T22:15:09-07:00                             | 2009-08-12 22:15:09 -0700 -0700         |
| 2009-08-12T22:15:09                                   | 2009-08-12 22:15:09 +0000 UTC           |
| 2009-08-12T22:15:09.988                               | 2009-08-12 22:15:09.988 +0000 UTC       |
| 2009-08-12T22:15:09Z                                  | 2009-08-12 22:15:09 +0000 UTC           |
| 2017-07-19T03:21:51:897+0100                          | 2017-07-19 03:21:51.897 +0100 +0100     |
| 2019-05-29T08:41-04                                   | 2019-05-29 08:41:00 -0400 -0400         |
| 2014-04-26 17:24:37.3186369                           | 2014-04-26 17:24:37.3186369 +0000 UTC   |
| 2012-08-03 18:31:59.257000000                         | 2012-08-03 18:31:59.257 +0000 UTC       |
| 2014-04-26 17:24:37.123                               | 2014-04-26 17:24:37.123 +0000 UTC       |
| 2013-04-01 22:43                                      | 2013-04-01 22:43:00 +0000 UTC           |
| 2013-04-01 22:43:22                                   | 2013-04-01 22:43:22 +0000 UTC           |
| 2014-12-16 06:20:00 UTC                               | 2014-12-16 06:20:00 +0000 UTC           |
| 2014-12-16 06:20:00 GMT                               | 2014-12-16 06:20:00 +0000 UTC           |
| 2014-04-26 05:24:37 PM                                | 2014-04-26 17:24:37 +0000 UTC           |
| 2014-04-26 13:13:43 +0800                             | 2014-04-26 13:13:43 +0800 +0800         |
| 2014-04-26 13:13:43 +0800 +08                         | 2014-04-26 13:13:43 +0800 +0800         |
| 2014-04-26 13:13:44 +09:00                            | 2014-04-26 13:13:44 +0900 +0900         |
| 2012-08-03 18:31:59.257000000 +0000 UTC               | 2012-08-03 18:31:59.257 +0000 UTC       |
| 2015-09-30 18:48:56.35272715 +0000 UTC                | 2015-09-30 18:48:56.35272715 +0000 UTC  |
| 2015-02-18 00:12:00 +0000 GMT                         | 2015-02-18 00:12:00 +0000 UTC           |
| 2015-02-18 00:12:00 +0000 UTC                         | 2015-02-18 00:12:00 +0000 UTC           |
| 2015-02-08 03:02:00 +0300 MSK m=+0.000000001          | 2015-02-08 03:02:00 +0300 +0300         |
| 2015-02-08 03:02:00.001 +0300 MSK m=+0.000000001      | 2015-02-08 03:02:00.001 +0300 +0300     |
| 2017-07-19 03:21:51+00:00                             | 2017-07-19 03:21:51 +0000 UTC           |
| 2014-04-26                                            | 2014-04-26 00:00:00 +0000 UTC           |
| 2014-04                                               | 2014-04-01 00:00:00 +0000 UTC           |
| 2014                                                  | 2014-01-01 00:00:00 +0000 UTC           |
| 2014-05-11 08:20:13,787                               | 2014-05-11 08:20:13.787 +0000 UTC       |
| 2020-07-20+08:00                                      | 2020-07-20 00:00:00 +0800 +0800         |
| 3.31.2014                                             | 2014-03-31 00:00:00 +0000 UTC           |
| 03.31.2014                                            | 2014-03-31 00:00:00 +0000 UTC           |
| 08.21.71                                              | 1971-08-21 00:00:00 +0000 UTC           |
| 2014.03                                               | 2014-03-01 00:00:00 +0000 UTC           |
| 2014.03.30                                            | 2014-03-30 00:00:00 +0000 UTC           |
| 20140601                                              | 2014-06-01 00:00:00 +0000 UTC           |
| 20140722105203                                        | 2014-07-22 10:52:03 +0000 UTC           |
| 171113 14:14:20                                       | 2017-11-13 14:14:20 +0000 UTC           |
| 1332151919                                            | 2012-03-19 10:11:59 +0000 UTC           |
| 1384216367189                                         | 2013-11-12 00:32:47.189 +0000 UTC       |
| 1384216367111222                                      | 2013-11-12 00:32:47.111222 +0000 UTC    |
| 1384216367111222333                                   | 2013-11-12 00:32:47.111222333 +0000 UTC |
+-------------------------------------------------------+-----------------------------------------+
*/

```


dateparse

# durafmt

[![Build Status](https://travis-ci.org/hako/durafmt.svg?branch=master)](https://travis-ci.org/hako/durafmt) [![Go Report Card](https://goreportcard.com/badge/github.com/hako/durafmt)](https://goreportcard.com/report/github.com/hako/durafmt) [![codecov](https://codecov.io/gh/hako/durafmt/branch/master/graph/badge.svg)](https://codecov.io/gh/hako/durafmt) [![GoDoc](https://godoc.org/github.com/hako/durafmt?status.svg)](https://godoc.org/github.com/hako/durafmt) 
[![Open Source Helpers](https://www.codetriage.com/hako/durafmt/badges/users.svg)](https://www.codetriage.com/hako/durafmt)



durafmt is a tiny Go library that formats `time.Duration` strings (and types) into a human readable format.

```
go get github.com/hako/durafmt
```

# Why

If you've worked with `time.Duration` in Go, you most likely have come across this:

```
53m28.587093086s // :)
```

The above seems very easy to read, unless your duration looks like this:

```
354h22m3.24s // :S
```

# Usage

### durafmt.ParseString()

```go
package main

import (
	"fmt"
	"github.com/hako/durafmt"
)

func main() {
	duration, err := durafmt.ParseString("354h22m3.24s")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(duration) // 2 weeks 18 hours 22 minutes 3 seconds
	// duration.String() // String representation. "2 weeks 18 hours 22 minutes 3 seconds"
}
```

### durafmt.ParseStringShort()

Version of `durafmt.ParseString()` that only returns the first part of the duration string.

```go
package main

import (
	"fmt"
	"github.com/hako/durafmt"
)

func main() {
	duration, err := durafmt.ParseStringShort("354h22m3.24s")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(duration) // 2 weeks
	// duration.String() // String short representation. "2 weeks"
}
```

### durafmt.Parse()

```go
package main

import (
	"fmt"
	"time"
	"github.com/hako/durafmt"
)

func main() {
	timeduration := (354 * time.Hour) + (22 * time.Minute) + (3 * time.Second)
	duration := durafmt.Parse(timeduration).String()
	fmt.Println(duration) // 2 weeks 18 hours 22 minutes 3 seconds
}
```

#### LimitFirstN()

Like `durafmt.ParseStringShort()` but for limiting the first N parts of the duration string.

```go
package main

import (
	"fmt"
	"time"
	"github.com/hako/durafmt"
)

func main() {
	timeduration := (354 * time.Hour) + (22 * time.Minute) + (3 * time.Second)
	duration := durafmt.Parse(timeduration).LimitFirstN(2) // // limit first two parts.
	fmt.Println(duration) // 2 weeks 18 hours
}
```

#### Custom Units

Like `durafmt.Units{}` and `durafmt.Durafmt.Format(units)` to stringify duration with custom units.

```go
package main

import (
	"fmt"
	"time"
	"github.com/hako/durafmt"
)

func main() {
	timeduration := (354 * time.Hour) + (22 * time.Minute) + (1 * time.Second) + (100*time.Microsecond)
	duration := durafmt.Parse(timeduration)
	// units in portuguese
	units, err := durafmt.DefaultUnitsCoder.Decode("ano,semana,dia,hora,minuto,segundo,milissegundo,microssegundo")
	if err != nil {
		panic(err)
	}
	fmt.Println(duration.Format(units)) // 2 semanas 18 horas 22 minutos 1 segundo 100 microssegundos

    // custom plural (singular:plural)
	units, err = durafmt.DefaultUnitsCoder.Decode("ano,semana:SEMANAS,dia,hora,minuto,segundo,milissegundo,microssegundo")
	if err != nil {
		panic(err)
	}
	fmt.Println(duration.Format(units)) // 2 SEMANAS 18 horas 22 minutos 1 segundo 100 microssegundos
}
```

# Contributing

Contributions are welcome! Fork this repo, add your changes and submit a PR.

If you would like to fix a bug, add a feature or provide feedback you can do so in the issues section.

durafmt is tested against `golangci-lint` and you can run tests with `go test`. 

When contributing, running `go test; go vet; golint` or `golangci-lint` is recommended.

# License

MIT


durafmt

Set of functions to calculate public holidays in Germany, incl. specialization on the states of Germany (Bundesländer). Things like Easter, Pentecost, Thanksgiving...

# Feiertage
Feiertage is a Go/Golang library for calculating German and Austrian bank holidays. It includes the calculation of the date of Easter and, more importantly, offers ways to retrieve public holidays for a state of Germany or Austria (=Bundesland).

The library is probably useful only for people realizing use cases with special requirements inside of Austria or Germany, such as shift schedules or capacity calculation.

### Documentation
See https://godoc.org/github.com/wlbr/feiertage

### Usage:
There are two types of functions:

 * `<feiertag>(year)` and
 * `<region>(year optional:IncludingSundays:true)`

`<feiertag>` returns an extended `time` object (type `feiertag`). It carries the date of the holiday
in the requested year plus the name of the holiday. `<feiertag>` may be any of the following:

||||
|----|-----|----|
`Neujahr` | `Epiphanias` | `HeiligeDreiKönige`
`Valentinstag` | `InternationalerTagDesGedenkensAnDieOpferDesHolocaust` | `Josefitag`
`Weiberfastnacht` | `Karnevalssonntag` | `Rosenmontag`
`Fastnacht` | `Aschermittwoch` | `InternationalerFrauentag`
`Palmsonntag` | `Gründonnerstag` | `Karfreitag`
`Ostern` | `BeginnSommerzeit` | `Ostermontag`
`Walpurgisnacht` | `TagDerArbeit` | `TagDerBefreiung`
`Staatsfeiertag` | `InternationalerTagDerPressefreiheit` | `Florianitag`
`Muttertag` | `Handtuchtag` | `ChristiHimmelfahrt`
 `Vatertag` | `Pfingsten` | `Pfingstmontag`
`Dreifaltigkeitssonntag` | `Fronleichnam` | `TagDesMeeres`
`MariäHimmelfahrt` | `SystemAdministratorAppreciationDay` |`Rupertitag`
`InternationalerKindertag`| `Weltflüchtlingstag` | `TagDerDeutschenEinheit`
`TagDerVolksabstimmung` | `Nationalfeiertag` | `Erntedankfest`
`Reformationstag` | `Halloween` | `BeginnWinterzeit`
`Allerheiligen` | `Allerseelen` | `Martinstag`
`Karnevalsbeginn` | `Leopolditag` | `Weltkindertag`
`BußUndBettag` | `Thanksgiving` | `Blackfriday`
`Volkstrauertag` | `Nikolaus` | `MariäUnbefleckteEmpfängnis`
`MariäEmpfängnis` | `Totensonntag` | `ErsterAdvent`
`ZweiterAdvent` | `DritterAdvent` | `VierterAdvent`
`Heiligabend` | `Weihnachten` | `Christtag`
`Stefanitag` | `ZweiterWeihnachtsfeiertag` | `Silvester`


`<region>` returns an object of type `region`. It offers a list of public holidays valid in the specified state as well as the name and the shortname of the state as attributes.
`<region>` may be any of:

||||
----|-----|----
`BadenWürttemberg` | `Bayern` | `Berlin`
`Brandenburg` | `Bremen` | `Hamburg`
`Hessen` | `MecklenburgVorpommern` | `Niedersachsen`
`NordrheinWestfalen` | `RheinlandPfalz` | `Saarland`
`Sachsen` | `SachsenAnhalt` | `SchleswigHolstein`
`Thüringen` | `Deutschland` | `Burgenland`
`Kärnten` | `Niederösterreich` | `Oberösterreich`
`Salzburg` | `Steiermark` | `Tirol`
`Vorarlberg` | `Wien` | `Österreich`
`All` | &nbsp; | &nbsp;

The optional region function argument `includingSundays` switches the behavior of the region function to include "gesetzliche Feiertage" that fall on Sundays in its output. This is important in Brandenburg, particularly for Easter and Pentecost Sunday. If you are calculating shift costs you will need to know even the holidays "hidden by Sunday".

The region functions return the public holidays ("gesetzliche Feiertage"). The function `all` returns all defined "special dates", such as Penance Day (Buß- und Bettag) or the begin/end of daylight saving time.

The regional functions for Austrian Bundesländer include saints' days which are state-level holidays, meaning
schools etc. are generally closed but workers don't get the day off by default. If you don't want to
include these days in your planning, it's okay to reference `Österreich` instead, as legal holidays are
(more or less) synchronised across all Austrian states (Bundesländer).

### Examples:

 fmt.Println(Ostern(2016))
 --> 27.03.2016 Ostern


 fmt.Println(BußUndBettag(2016))
 --> 16.11.2016 Buß- und Bettag



 fmt.Println(Brandenburg(2016))
 --> Brandenburg (BB)
 01.01.2016 Neujahr
 25.03.2016 Karfreitag
 27.03.2016 Ostern
 28.03.2016 Ostermontag
 01.05.2016 Tag der Arbeit
 05.05.2016 Christi Himmelfahrt
 15.05.2016 Pfingsten
 16.05.2016 Pfingstmontag
 03.10.2016 Tag der deutschen Einheit
 31.10.2016 Reformationstag
 25.12.2016 Weihnachten
 26.12.2016 Zweiter Weihnachtsfeiertag


 fmt.Println(Brandenburg(2016, false))
 --> Brandenburg (BB)
 01.01.2016 Neujahr
 25.03.2016 Karfreitag
 28.03.2016 Ostermontag
 01.05.2016 Tag der Arbeit
 05.05.2016 Christi Himmelfahrt
 16.05.2016 Pfingstmontag
 03.10.2016 Tag der deutschen Einheit
 31.10.2016 Reformationstag
 25.12.2016 Weihnachten
 26.12.2016 Zweiter Weihnachtsfeiertag


## Command line tool

A little command line tool is included as well. It can be compiled using `make buildcmd` or `go build cmd/feiertage/feiertage.go` This will create an executable `feiertage`.

See https://github.com/wlbr/feiertage/releases/latest for downloads.

### Synopsis

`feiertage: [options] year` 
<dl>
<dt>-asTaskjugglerCode (default false)</dt>
<dd>Print the result as valid source code (`leave x y`) for the <a href="http://www.taskjuggler.org/">Taskjuggler</a> planning tool.
<dt>-inklusiveSonntage (default false)</dt>
<dd>Should public holidays on a Sunday be included?</dd>
<dt>-region &lt;regionstring&gt; (default "All")</dt>
<dd>Return public holidays for region `<regionstring>`. 
<dd>&lt;regionstring&gt; may be (case insensitive, plus some other tricks to make it more tolerant): 
&nbsp;BadenWürttemberg 
&nbsp;Bayern 
&nbsp;Berlin 
&nbsp;Brandenburg 
&nbsp;Bremen 
&nbsp;Hamburg 
&nbsp;Hessen 
&nbsp;MecklenburgVorpommern 
&nbsp;Niedersachsen 
&nbsp;NordrheinWestfalen 
&nbsp;RheinlandPfalz 
&nbsp;Saarland 
&nbsp;Sachsen 
&nbsp;SachsenAnhalt 
&nbsp;SchleswigHolstein 
&nbsp;Thüringen 
&nbsp;Deutschland 
&nbsp;Burgenland 
&nbsp;Kärnten 
&nbsp;Niederösterreich 
&nbsp;Oberösterreich 
&nbsp;Salzburg 
&nbsp;Steiermark 
&nbsp;Tirol 
&nbsp;Vorarlberg 
&nbsp;Wien 
&nbsp;Österreich 
&nbsp;All</dd>
</dl>


## Code
* Documentation: https://godoc.org/github.com/wlbr/feiertage
* Lint: http://go-lint.appspot.com/github.com/wlbr/feiertage
* Continuous Integration: [![Travis Status](https://api.travis-ci.com/wlbr/feiertage.svg?branch=master)](https://travis-ci.com/wlbr/feiertage)
* Test Coverage: [![Coverage Status](https://coveralls.io/repos/github/wlbr/feiertage/badge.svg?branch=master)](https://coveralls.io/github/wlbr/feiertage?branch=master)
* Metrics: [![GoReportCard](https://goreportcard.com/badge/github.com/wlbr/feiertage)](https://goreportcard.com/report/github.com/wlbr/feiertage)

feiertage

Parse dates/times like "next dec 22nd at 3pm" and ranges like "from today until next thursday" without knowing the format in advance.

# Go Anytime

[![Go Report Card](https://goreportcard.com/badge/github.com/ijt/go-anytime)](https://goreportcard.com/report/github.com/ijt/go-anytime)
[![codecov](https://codecov.io/gh/ijt/go-anytime/branch/main/graph/badge.svg?token=GA1TIU7OHK)](https://codecov.io/gh/ijt/go-anytime)
[![GoDoc](https://godoc.org/github.com/ijt/go-anytime?status.svg)](https://godoc.org/github.com/ijt/go-anytime)
![](https://img.shields.io/badge/license-MIT-blue.svg)
[![Awesome](https://cdn.rawgit.com/avelino/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/avelino/awesome-go#date-and-time)

Natural date time parsing for Go. This package was originally forked from
[github.com/tj/go-naturaldate](https://github.com/tj/go-naturaldate) but has diverged so much that it needed a new name
to avoid confusion. Here are the largest differences:

1. The `go-anytime` module is written in terms of the [github.com/ijt/goparsify](https://github.com/ijt/goparsify) parser combinator module, rather than the [github.com/pointlander/peg](https://github.com/pointlander/peg) parsing module. That made its development and debugging easier, and also means that its parsers can be use within other parsers that use `ijt/goparsify`.
2. Ranges can be parsed using `ParseRange` or `RangeParser`, for example `"from 3 feb 2022 until 6 oct 2022"`.
3. Dates/times and ranges can be replaced in strings using the funcs `ReplaceTimesByFunc`, `ReplaceRangesByFunc`, and `ReplaceDateRangesByFunc`.
4. Strings can be partitioned into time and non-time parts using the funcs `PartitionTimes` and `PartitionTimesByFuncs`.

## Examples

Here are some examples of expressions that can be parsed by `anytime.Parse()` or `anytime.Parser`:

- now
- today
- yesterday
- 5 minutes ago
- three days ago
- last month
- next month
- one year from now
- yesterday at 10am
- last sunday at 5:30pm
- next sunday at 22:45
- next January
- last February
- next December 25th at 7:30am
- next December 25th at 7:30am UTC-7
- November 3rd, 1986 at 4:30pm
- january 2017
- january, 2017
- oct 7, 1970
- oct 7 1970
- 7 oct 1970
- 7 oct, 1970
- September 17, 2012 UTC+7
- September 17, 2012
- 03 February 2013
- 2 July 2013
- 2014/3/31
- 2014/3/31 UTC
- 2014/3/31 UTC+1
- 2014/03/31
- 2014/03/31 UTC-1
- 2014-04-26
- 2014-4-26
- 2014-4-6
- 31/3/2014 UTC-8
- 31-3-2014 UTC-8
- 31/3/2014
- 31-3-2014
- January
- december 20
- thursday at 23:59
- See the [tests](./anytime_test.go) for more examples

## Range examples

Here are some examples of expressions that can be parsed by `anytime.ParseRange()` or `anytime.RangeParser`:

- from 3 feb 2022 to 6 oct 2022
- 3 feb 2022 to 6 oct 2022
- from 3 feb 2022 until 6 oct 2022
- from tuesday at 5pm -12:00 until thursday 23:52 +14:00
- last year
- today
- next week


go-anytime

## go-datebin


<a href="https://pkg.go.dev/github.com/deatil/go-datebin"><img src="https://pkg.go.dev/badge/deatil/go-datebin.svg" alt="Go Reference"></a>
<a href="https://codecov.io/gh/deatil/go-datebin" >
 <img src="https://codecov.io/gh/deatil/go-datebin/graph/badge.svg?token=SS2Z1IY0XL"/>
</a>
<img src="https://goreportcard.com/badge/github.com/deatil/go-datebin" />
<a href="https://github.com/avelino/awesome-go"><img src="https://awesome.re/mentioned-badge.svg" alt="Mentioned in Awesome Go"></a>



### Desc

* go-datebin is a simple datetime parse pkg.

[中文](README_CN.md) | English


### Download

~~~go
go get -u github.com/deatil/go-datebin
~~~


### Get Starting

~~~go
package main

import (
 "fmt"

 "github.com/deatil/go-datebin/datebin"
)

func main() {
 // now time
 date := datebin.
 Now().
 ToDatetimeString()
 // output: 2024-01-06 12:06:12

 // Parse date and have no timezone
 date2 := datebin.
 Parse("2032-03-15 12:06:17").
 ToDatetimeString(datebin.UTC)
 // output: 2032-03-15 12:06:17

 // Parse date and have timezone
 date2 := datebin.
 ParseWithLayout("2032-03-15 12:06:17", datebin.DatetimeFormat, datebin.GMT).
 ToDatetimeString()
 // output: 2032-03-15 12:06:17

 // set time and format output
 date3 := datebin.
 FromDatetime(2032, 3, 15, 12, 56, 5).
 ToFormatString("Y/m/d H:i:s")
 // output: 2032/03/15 12:56:05
}

~~~


### Examples

~~~go
// format timestamp
var datetimeString string = datebin.FromTimestamp(1705329727, datebin.Shanghai).ToDatetimeString()
// output: 2024-01-15 22:42:07

// format timestamp with timezone
var datetimeString string = datebin.FromTimestamp(1705329727).ToDatetimeString(datebin.Shanghai)
// output: 2024-01-15 22:42:07
~~~

~~~go
// get now timestamp
var timestamp int64 = datebin.Now().Timestamp()
// output: 1705329727
~~~

~~~go
// get now time
var timestamp int64 = datebin.Now(datebin.Iran).ToRFC1123String()
// output: Sun, 21 Jan 2024 07:48:22 +0330
~~~

~~~go
// get now stdtime
var stdTime time.Time = datebin.Now().ToStdTime()
// fmt.Sprintf("%s", stdTime) output: 2024-01-15 23:55:03.0770405 +0800 CST

// get now stdtime with timezone
var stdTime time.Time = datebin.Now(datebin.UTC).ToStdTime()
// fmt.Sprintf("%s", stdTime) output: 2024-01-19 01:59:11.8134897 +0000 UTC
~~~

~~~go
// format stdtime
var datetimeString string = datebin.FromStdTime(stdTime).ToDatetimeString()
// output: 2024-01-15 23:55:03
~~~

~~~go
// format datetime
var datetimeString string = datebin.FromDatetime(2024, 01, 15, 23, 35, 01).ToDatetimeString()
// output: 2024-01-15 23:35:01
~~~

more docs and see [docs](docs.md)


### LICENSE

* The library LICENSE is `Apache2`, using the library need keep the LICENSE.


### Copyright

* Copyright deatil(https://github.com/deatil).

go-datebin

The implementation of the Persian (Solar Hijri) Calendar in Go (golang).

# Go Persian Calendar

[![godoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://pkg.go.dev/github.com/yaa110/go-persian-calendar) [![Test and Build](https://github.com/yaa110/go-persian-calendar/workflows/Test%20and%20Build/badge.svg)](https://github.com/yaa110/go-persian-calendar/actions?query=workflow%3A"Test+and+Build") [![goreportcard](https://img.shields.io/badge/go%20report-A%2B-brightgreen.svg)](http://goreportcard.com/report/yaa110/go-persian-calendar) [![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/yaa110/go-persian-calendar/blob/master/LICENSE)

**Go Persian Calendar** provides functionality for conversion among Persian (Solar Hijri) and Gregorian calendars. A Julian calendar is used as an interface for all conversions. The package name is `ptime` and it is compatible with the package [time](https://golang.org/pkg/time). All months are available with both Iranian and Dari Persian names. This source code is licensed under MIT license that can be found in the LICENSE file.

## Installation

```bash
go get github.com/yaa110/go-persian-calendar
```

## Getting started

1- Import the package `ptime`. Most of the time you need to import `time` and `fmt` packages, too.

```go
import (
    ptime "github.com/yaa110/go-persian-calendar"
    "time"
    "fmt"
)
```

2- Convert Gregorian calendar to Persian calendar.

```go
// Create a new instance of time.Time
var t time.Time = time.Date(2016, time.January, 1, 12, 1, 1, 0, ptime.Iran())

// Get a new instance of ptime.Time using time.Time
pt := ptime.New(t)

// Get the date in Persian calendar
fmt.Println(pt.Date()) // output: 1394 دی 11
```

3- Convert Persian calendar to Gregorian calendar.

```go
// Create a new instance of ptime.Time
var pt ptime.Time = ptime.Date(1394, ptime.Mehr, 2, 12, 59, 59, 0, ptime.Iran())

// Get a new instance of time.Time
t := pt.Time()

// Get the date in Gregorian calendar
fmt.Println(t.Date()) // output: 2015 September 24
```

4- Get the current time.

```go
// Get a new instance of ptime.Time representing the current time
pt := ptime.Now()

// Get year, month, day
fmt.Println(pt.Date()) // output: 1394 بهمن 11
fmt.Println(pt.Year(), pt.Month(), pt.Day()) // output: 1394 بهمن 11

// Get hour, minute, second
fmt.Println(pt.Clock()) // output: 21 54 30
fmt.Println(pt.Hour(), pt.Minute(), pt.Second()) // output: 21 54 30

// Get Unix timestamp (the number of seconds since January 1, 1970 UTC)
fmt.Println(pt.Unix()) // output: 1454277270

// Get yesterday, today and tomorrow
fmt.Println(pt.Yesterday().Weekday()) // output: شنبه
fmt.Println(pt.Weekday()) // output: یک‌شنبه
fmt.Println(pt.Tomorrow().Weekday()) // output: دوشنبه

// Get First and last day of week
fmt.Println(pt.FirstWeekDay().Date()) // output: 1394 بهمن 10
fmt.Println(pt.LastWeekday().Date()) // output: 1394 بهمن 16

// Get First and last day of month
fmt.Println(pt.FirstMonthDay().Weekday()) // output: پنج‌شنبه
fmt.Println(pt.LastMonthDay().Weekday()) // output: جمعه

// Get First and last day of year
fmt.Println(pt.FirstYearDay().Weekday()) // output: شنبه
fmt.Println(pt.LastYearDay().Weekday()) // output: شنبه

// Get the week of month
fmt.Println(pt.MonthWeek()) // output: 3

// Get the week of year
fmt.Println(pt.YearWeek()) // output: 46

// Get the number of remaining weeks of the year
fmt.Println(pt.RYearWeek()) // output: 6
```

5- Format the time.

```go
// Get a new instance of ptime.Time using Unix timestamp
pt := ptime.Unix(1454277270, 0)

fmt.Println(pt.Format("yyyy/MM/dd E hh:mm:ss a")) // output: 1394/11/11 یک‌شنبه 09:54:30 ب.ظ

// yyyy, yyy, y     year (e.g. 1394)
// yy               2-digits representation of year (e.g. 94)
// MMM              the Persian name of month (e.g. فروردین)
// MMI              the Dari name of month (e.g. حمل)
// MM               2-digits representation of month (e.g. 01)
// M                month (e.g. 1)
// rw               remaining weeks of year
// w                week of year
// W                week of month
// RD               remaining days of year
// D                day of year
// rd               remaining days of month
// dd               2-digits representation of day (e.g. 01)
// d                day (e.g. 1)
// E                the Persian name of weekday (e.g. شنبه)
// e                the Persian short name of weekday (e.g. ش)
// A                the Persian name of 12-Hour marker (e.g. قبل از ظهر)
// a                the Persian short name of 12-Hour marker (e.g. ق.ظ)
// HH               2-digits representation of hour [00-23]
// H                hour [0-23]
// kk               2-digits representation of hour [01-24]
// k                hour [1-24]
// hh               2-digits representation of hour [01-12]
// h                hour [1-12]
// KK               2-digits representation of hour [00-11]
// K                hour [0-11]
// mm               2-digits representation of minute [00-59]
// m                minute [0-59]
// ss               2-digits representation of seconds [00-59]
// s                seconds [0-59]
// ns               nanoseconds
// S                3-digits representation of milliseconds (e.g. 001)
// z                the name of location
// Z                zone offset (e.g. +03:30)
```

6- Format the time using [standard format](https://golang.org/src/time/format.go).

```go
pt := ptime.Date(1394, 7, 2, 14, 7, 8, 0, Iran())

fmt.Println(pt.TimeFormat("2 Jan 2006")) // output: 2 مهر 1394

// 2006        four digit year (e.g. 1399)
// 06          two digit year (e.g. 99)
// 01          two digit month (e.g. 01)
// 1           one digit month (e.g. 1)
// Jan         month name (e.g. آذر)
// January     month name (e.g. آذر)
// 02          two digit day (e.g. 07)
// 2           one digit day (e.g. 7)
// _2          right justified two character day (e.g.  7)
// Mon         weekday (e.g. شنبه)
// Monday      weekday (e.g. شنبه)
// 03          two digit 12 hour format (e.g. 03)
// 3           one digit 12 hour format (e.g. 3)
// 15          two digit 24 hour format (e.g. 15)
// 04          two digit minute (e.g. 03)
// 4           one digit minute (e.g. 03)
// 05          two digit minute (e.g. 09)
// 5           one digit minute (e.g. 9)
// .000        millisecond (e.g. .120)
// .000000     microsecond (e.g. .123400)
// .000000000  nanosecond (e.g. .123456000)
// .999        trailing zeros removed millisecond (e.g. .12)
// .999999     trailing zeros removed microsecond (e.g. .1234)
// .999999999  trailing zeros removed nanosecond (e.g. .123456)
// PM          full 12-Hour marker (e.g. قبل از ظهر)
// pm          short 12-Hour marker (e.g. ق.ظ)
// MST         the name of location
// -0700       zone offset (e.g. +0330)
// -07         zone offset (e.g. +03)
// -07:00      zone offset (e.g. +03:30)
// Z0700       zone offset (e.g. +0330)
// Z07:00      zone offset (e.g. +03:30)
```

## Limitations

- The minimum value of Gregorian year is 1097, otherwise a zero instance of `ptime.Time` is returned.

## Documentation

Please read [the documentation](https://pkg.go.dev/github.com/yaa110/go-persian-calendar) for more information about methods and functionality available for `ptime.Time`, `ptime.Month`, `ptime.Weekday` and `ptime.AmPm`.


go-persian-calendar

Convert string to duration. Support time.Duration returned string and more.

# Go String To Duration (go-str2duration)

This package allows to get a time.Duration from a string. The string can be a string retorned for time.Duration or a similar string with weeks or days too!.

<a href="https://goreportcard.com/report/github.com/xhit/go-str2duration/v2"><img src="https://goreportcard.com/badge/github.com/xhit/go-str2duration" alt="Go Report Card"></a>
<a href="https://pkg.go.dev/github.com/xhit/go-str2duration/v2?tab=doc"><img src="https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white" alt="go.dev"></a>

## Download

```bash
go get github.com/xhit/go-str2duration/v2
```

## Features

Go String To Duration supports this strings conversions to duration:
- All strings returned in time.Duration String.
- A string more readable like 1w2d6h3ns (1 week 2 days 6 hours and 3 nanoseconds).
- `µs` and `us` are microsecond.

It's the same `time.ParseDuration` standard function in Go, but with days and week support.

**Note**: a day is 24 hour.

If you don't need days and weeks, use [`time.ParseDuration`](https://golang.org/pkg/time/#ParseDuration).

## Usage

```go
package main

import (
	"fmt"
	str2duration "github.com/xhit/go-str2duration/v2"
	"os"
	"time"
)

func main() {

 for i, tt := range []struct {
 dur string
 expected time.Duration
 }{
 //This times are returned with time.Duration string
 {"1h", time.Duration(time.Hour)},
 {"1m", time.Duration(time.Minute)},
 {"1s", time.Duration(time.Second)},
 {"1ms", time.Duration(time.Millisecond)},
 {"1µs", time.Duration(time.Microsecond)},
 {"1us", time.Duration(time.Microsecond)},
 {"1ns", time.Duration(time.Nanosecond)},
 {"4.000000001s", time.Duration(4*time.Second + time.Nanosecond)},
 {"1h0m4.000000001s", time.Duration(time.Hour + 4*time.Second + time.Nanosecond)},
 {"1h1m0.01s", time.Duration(61*time.Minute + 10*time.Millisecond)},
 {"1h1m0.123456789s", time.Duration(61*time.Minute + 123456789*time.Nanosecond)},
 {"1.00002ms", time.Duration(time.Millisecond + 20*time.Nanosecond)},
 {"1.00000002s", time.Duration(time.Second + 20*time.Nanosecond)},
 {"693ns", time.Duration(693 * time.Nanosecond)},

 //This times aren't returned with time.Duration string, but are easily readable and can be parsed too!
 {"1ms1ns", time.Duration(time.Millisecond + 1*time.Nanosecond)},
 {"1s20ns", time.Duration(time.Second + 20*time.Nanosecond)},
 {"60h8ms", time.Duration(60*time.Hour + 8*time.Millisecond)},
 {"96h63s", time.Duration(96*time.Hour + 63*time.Second)},

 //And works with days and weeks!
 {"2d3s96ns", time.Duration(48*time.Hour + 3*time.Second + 96*time.Nanosecond)},
 {"1w2d3s96ns", time.Duration(168*time.Hour + 48*time.Hour + 3*time.Second + 96*time.Nanosecond)},

 {"10s1us693ns", time.Duration(10*time.Second + time.Microsecond + 693*time.Nanosecond)},

 } {
 durationFromString, err := str2duration.ParseDuration(tt.dur)
 if err != nil {
 panic(err)

 //Check if expected time is the time returned by the parser
 } else if tt.expected != durationFromString {
 fmt.Println(fmt.Sprintf("index %d -> in: %s returned: %s\tnot equal to %s", i, tt.dur, durationFromString.String(), tt.expected.String()))
 }else{
 fmt.Println(fmt.Sprintf("index %d -> in: %s parsed succesfully", i, tt.dur))
 }
 }
}
```

Also, you can convert to string the duration using `String(t time.Duration)` function. This support weeks and days and not return the ugly decimals from golang standard `t.String()` function. Units with 0 values aren't returned. For example: `1d1ms` means 1 day 1 millisecond.

go-str2duration

Useful extensions (Timedelta, Strftime, ...) to the golang's time package.

# timeutil - useful extensions to the golang's time package
[![Build Status](https://travis-ci.org/leekchan/timeutil.svg?branch=master)](https://travis-ci.org/leekchan/timeutil)
[![Coverage Status](https://coveralls.io/repos/leekchan/timeutil/badge.svg?branch=master&service=github)](https://coveralls.io/github/leekchan/timeutil?branch=master)
[![GoDoc](https://godoc.org/github.com/leekchan/timeutil?status.svg)](https://godoc.org/github.com/leekchan/timeutil)

timeutil provides useful extensions (Timedelta, Strftime, ...) to the golang's time package.


## Quick Start

```
go get github.com/leekchan/timeutil
```

example.go

```Go
package main

import (
    "fmt"
    "time"

    "github.com/leekchan/timeutil"
)

func main() {
    // Timedelta
    // A basic usage.
    base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
    td := timeutil.Timedelta{Days: 10, Minutes: 17, Seconds: 56}

    result := base.Add(td.Duration())
    fmt.Println(result) // "2015-02-13 00:17:56 +0000 UTC"

    // Operation : Add
    base = time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)

    td = timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
    td2 := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
    td = td.Add(&td2) // td = td + td2

    result = base.Add(td.Duration())
    fmt.Println(result) // "2015-02-06 00:03:03 +0000 UTC"

    // Operation : Subtract
    base = time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)

    td = timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
    td2 = timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
    td = td.Subtract(&td2) // td = td - td2

    result = base.Add(td.Duration())
    fmt.Println(result) // "2015-02-04 00:01:01 +0000 UTC"

    // Operation : Abs
    base = time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)

    td = timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
    td2 = timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
    td = td.Subtract(&td2) // td = td - td2
    td = td.Abs()          // td = |td|

    result = base.Add(td.Duration())
    fmt.Println(result) // "2015-02-04 00:01:01 +0000 UTC"
    
    
    // Strftime
    date := time.Date(2015, 7, 2, 15, 24, 30, 35, time.UTC)
    str := timeutil.Strftime(&date, "%a %b %d %I:%M:%S %p %Y")
    fmt.Println(str) // "Thu Jul 02 03:24:30 PM 2015"
    
    // Unicode support
    str = timeutil.Strftime(&date, "작성일 : %a %b %d %I:%M:%S %p %Y")
    fmt.Println(str) // "작성일 : Thu Jul 02 03:24:30 PM 2015"
}
```


## Timedelta

Timedelta represents a duration between two dates. (inspired by python's timedelta)

### Timedelta struct

```Go
type Timedelta struct {
    Days, Seconds, Microseconds, Milliseconds, Minutes, Hours, Weeks time.Duration
}
```

### Initialization

All fields are optional and default to 0. You can initialize any type of timedelta by specifying field values which you want to use.

**Examples:**

```Go
td := timeutil.Timedelta{Days: 10}
td = timeutil.Timedelta{Minutes: 17}
td = timeutil.Timedelta{Seconds: 56}
td = timeutil.Timedelta{Days: 10, Minutes: 17, Seconds: 56}
td = timeutil.Timedelta{Days: 1, Seconds: 1, Microseconds: 1, Milliseconds: 1, Minutes: 1, Hours: 1, Weeks: 1}
```

### func (t *Timedelta) Duration() time.Duration

Duration() returns time.Duration. time.Duration can be added to time.Date.

**Examples:**

```Go
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 10, Minutes: 17, Seconds: 56}

result := base.Add(td.Duration())
fmt.Println(result) // "2015-02-13 00:17:56 +0000 UTC"
```

### Operations

#### func (t *Timedelta) Add(t2 *Timedelta)

Add returns the Timedelta t+t2.

**Examples:**

```Go
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td2 := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td = td.Add(&td2) // td = td + td2

result = base.Add(td.Duration())
fmt.Println(result) // "2015-02-06 00:03:03 +0000 UTC"
```

#### func (t *Timedelta) Subtract(t2 *Timedelta) Timedelta

Subtract returns the Timedelta t-t2.

**Examples:**

```Go
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)

td := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td2 := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td = td.Subtract(&td2) // td = td - td2

result = base.Add(td.Duration())
fmt.Println(result) // "2015-02-04 00:01:01 +0000 UTC"
```

#### func (t *Timedelta) Abs() Timedelta

Abs returns the absolute value of t

**Examples:**

```Go
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)

td := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td2 := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td = td.Subtract(&td2) // td = td - td2
td = td.Abs() // td = |td|

result = base.Add(td.Duration())
fmt.Println(result) // "2015-02-04 00:01:01 +0000 UTC"
```


## Strftime

Strftime formats time.Date according to the directives in the given format string. The directives begins with a percent (%) character.

(Strftime supports unicode format string.)


Directive | Meaning | Example
-------------| ------------- | -------------
%a | Weekday as locale’s abbreviated name. | Sun, Mon, ..., Sat
%A | Weekday as locale’s full name.     | Sunday, Monday, ..., Saturday 
%w | Weekday as a decimal number, where 0 is Sunday and 6 is Saturday | 0, 1, ..., 6     
%d | Day of the month as a zero-padded decimal number. | 01, 02, ..., 31 
%b | Month as locale’s abbreviated name. | Jan, Feb, ..., Dec
%B | Month as locale’s full name. | January, February, ..., December
%m | Month as a zero-padded decimal number. | 01, 02, ..., 12
%y | Year without century as a zero-padded decimal number. | 00, 01, ..., 99
%Y | Year with century as a decimal number. |   1970, 1988, 2001, 2013
%H | Hour (24-hour clock) as a zero-padded decimal number. | 00, 01, ..., 23
%I | Hour (12-hour clock) as a zero-padded decimal number. | 01, 02, ..., 12 
%p | Meridian indicator. (AM or PM.) | AM, PM
%M | Minute as a zero-padded decimal number. | 00, 01, ..., 59
%S | Second as a zero-padded decimal number. | 00, 01, ..., 59
%f | Microsecond as a decimal number, zero-padded on the left. | 000000, 000001, ..., 999999
%z | UTC offset in the form +HHMM or -HHMM | +0000
%Z | Time zone name | UTC
%j | Day of the year as a zero-padded decimal number | 001, 002, ..., 366
%U | Week number of the year (Sunday as the first day of the week) as a zero padded decimal number. All days in a new year preceding the first Sunday are considered to be in week 0. | 00, 01, ..., 53 
%W | Week number of the year (Monday as the first day of the week) as a decimal number. All days in a new year preceding the first Monday are considered to be in week 0.   | 00, 01, ..., 53
%c | Date and time representation. | Tue Aug 16 21:30:00 1988
%x | Date representation. | 08/16/88
%X | Time representation. | 21:30:00
%% | A literal '%' character. | %

**Examples:**

```Go
date := time.Date(2015, 7, 2, 15, 24, 30, 35, time.UTC)
str := timeutil.Strftime(&date, "%a %b %d %I:%M:%S %p %Y")
fmt.Println(str) // "Thu Jul 02 03:24:30 PM 2015"

// Unicode support
str = timeutil.Strftime(&date, "작성일 : %a %b %d %I:%M:%S %p %Y")
fmt.Println(str) // "작성일 : Thu Jul 02 03:24:30 PM 2015"
```

## TODO

* Locale support
* Strptime - a function which returns a time.Date parsed according to a format string
* Auto date parser - a generic string parser which is able to parse most known formats to represent a date
* And other useful features...

timeutil

Calculate the sunrise and sunset times for a given location.

## go-sunrise

[![Build Status](https://app.travis-ci.com/nathan-osman/go-sunrise.svg?branch=master)](https://app.travis-ci.com/nathan-osman/go-sunrise)
[![Coverage Status](https://coveralls.io/repos/github/nathan-osman/go-sunrise/badge.svg?branch=master)](https://coveralls.io/github/nathan-osman/go-sunrise?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/nathan-osman/go-sunrise)](https://goreportcard.com/report/github.com/nathan-osman/go-sunrise)
[![GoDoc](https://godoc.org/github.com/nathan-osman/go-sunrise?status.svg)](https://godoc.org/github.com/nathan-osman/go-sunrise)
[![MIT License](http://img.shields.io/badge/license-MIT-9370d8.svg?style=flat)](http://opensource.org/licenses/MIT)

Go package for calculating the sunrise and sunset times for a given location based on [this method](https://en.wikipedia.org/wiki/Sunrise_equation#Complete_calculation_on_Earth).

### Usage

To calculate sunrise and sunset times, you will need the following information:

- the date for which you wish to calculate the times
- the latitude and longitudinal coordinates of the location

Begin by importing the package:

    import "github.com/nathan-osman/go-sunrise"

Next, feed the information into the SunriseSunset() method:

    rise, set := sunrise.SunriseSunset(
        43.65, -79.38,          // Toronto, CA
        2000, time.January, 1,  // 2000-01-01
    )

The two return values will be the sunrise and sunset times for the location on the given day as time.Time values. If sun does not rise or set, both return values will be time.Time{}.


go-sunrise

An efficient package to work with ISO8601 week dates.

[![CircleCI](https://circleci.com/gh/stoewer/go-week/tree/master.svg?style=svg)](https://circleci.com/gh/stoewer/go-week/tree/master)
[![codecov](https://codecov.io/gh/stoewer/go-week/branch/master/graph/badge.svg)](https://codecov.io/gh/stoewer/go-week)
[![GoDoc](https://godoc.org/github.com/stoewer/go-week?status.svg)](https://godoc.org/github.com/stoewer/go-week)
---

go-week
=======

The package `go-week` provides a simple data type representing a week date as defined by [ISO 8601](https://en.wikipedia.org/wiki/ISO_week_date).

Versions and stability
----------------------

This package can be considered stable and ready to use. All releases follow the rules of 
[semantic versioning](http://semver.org).

Although the master branch is supposed to remain stable, there is not guarantee that braking changes will not
be merged into master when major versions are released. Therefore the repository contains version tags in 
order to support vendoring tools. The tag names follow common conventions and have the following format `v1.0.0`. 
This package supports Go modules introduced with version 1.11.

Dependencies
------------

### Build dependencies

* `github.com/pkg/errors`

### Test dependencies

* `github.com/DATA-DOG/go-sqlmock`
* `github.com/lib/pq` (integration tests only)
* `github.com/stretchr/testify`

Run unit and integration tests
------------------------------ 

To run the code analysis and tests, use the following commands:

```
golangci-lint run -v --config .golangci.yml ./...

# without integration tests
go test ./...

# with integration tests (requires test db)
go test -tags=integration ./...
```

License
-------

This project is open source an published under the [MIT license](LICENSE).


go-week

<img src="https://raw.githubusercontent.com/bykof/gostradamus/master/docs/resources/logo.png" alt="Gostradamus logo" width="200"/>


# Gostradamus: Better DateTimes for Go

[![Gostradamus](https://img.shields.io/circleci/build/github/bykof/gostradamus)](https://app.circleci.com/pipelines/github/bykof/gostradamus)
[![Go Report Card](https://goreportcard.com/badge/github.com/bykof/gostradamus)](https://goreportcard.com/report/github.com/bykof/gostradamus)
[![codecov](https://codecov.io/gh/bykof/gostradamus/branch/master/graph/badge.svg)](https://codecov.io/gh/bykof/gostradamus)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/bykof/gostradamus)

## Introduction

Gostradamus is a Go library that offers a lightweight and human-friendly way to create, transform, format, and parse
datetimes.
It uses the underlying Go `time` library and the main gostradamus' type `DateTime` can be easily converted to and
from `time.Time`.

Gostradamus is named after the french pharmacist [Nostradamus](https://en.wikipedia.org/wiki/Nostradamus).
He is known for his prophecies, therefore he worked a lot with time, like Gostradamus.

## Features

✅ Easy conversion between `time.Time` and `gostradamus.DateTime`

✅ Format with common and known format tokens like `YYYY-MM-DD HH:mm:ss`

✅ Generates time spans, floors, ceilings from second to year (weeks included)

✅ Weeks manipulation and helper functions

✅ Timezone-aware with conversion

✅ Fully tested and ready for production

## Basic Usage

```go
package main

import "github.com/bykof/gostradamus"

func main() {
	// Easy parsing
	dateTime, err := gostradamus.Parse("14.07.2017 02:40:00", "DD.MM.YYYY HH:mm:ss")
	if err != nil {
		panic(err)
	}

	// Easy manipulation 
	dateTime = dateTime.ShiftMonths(-5).ShiftDays(2)

	// Easy formatting
	println(dateTime.Format("DD.MM.YYYY HH:mm:ss"))
	// 16.02.2017 02:40:00

	// Easy helper functions
	start, end := dateTime.SpanWeek()

	println(start.String(), end.String())
	// 2017-02-13T00:00:00.000000Z 2017-02-19T23:59:59.999999Z
}
```

## Table of Contents

+ [Types](#types)
+ [Conversion between time.Time and gostradamus.DateTime](#conversion-between-timetime-and-gostradamusdatetime)
+ [Creation](#creation)
+ [Timezones](#timezones)
+ [Shift](#shift)
+ [Replace](#replace)
+ [Token Table](#token-table)
+ [Parsing](#parsing)
+ [Formatting](#formatting)
+ [Floor](#floor)
+ [Ceil](#ceil)
+ [Spans](#spans)
+ [Utils](#utils)
 - [IsBetween](#isBetween)
 - [IsoCalendar](#isoCalendar)
+ [Contribution](#contribution)
+ [License](#license)

## Usage

This part introduces all basic features of gostradamus.
Surely there are more, just look them up in
the [offical documentation](https://pkg.go.dev/github.com/bykof/gostradamus?tab=doc).

## Types

There are two types in this package, which are important to know:

```go
type DateTime time.Time
type Timezone string
```

`DateTime` contains all the creation, transforming, formatting and parsing functions.

`Timezone` is just a string type but gostradamus has all timezones defined as constants.
Look [here](https://github.com/bykof/gostradamus/blob/master/timezone_constants.go).

## Conversion between time.Time and gostradamus.DateTime

You can easily convert between gostradamus.DateTime and time.Time package.
Either with helper functions or with golang's [type conversion](https://tour.golang.org/basics/13)

```go
import "time"

// From gostradamus.DateTime to time.Time
dateTime := gostradamus.Now()
firstTime := dateTime.Time()
secondTime := time.Time(dateTime)

// From time.Time to gostradamus.DateTime
t := time.Now()
dateTime = gostradamus.DateTimeFromTime(t)
dateTime = gostradamus.DateTime(t)
```

## Creation

If you want to create a gostradamus.DateTime you have several ways:

Just create the DateTime from scratch:

```go
// Create it with a defined timezone as you know it
dateTime := gostradamus.NewDateTime(2020, 1, 1, 12, 0, 0, 0, gostradamus.EuropeBerlin)

// Create it with predefined UTC timezone
dateTime := gostradamus.NewUTCDateTime(2020, 1, 1, 12, 0, 0, 0)

// Create it with local timzone
dateTime := gostradamus.NewLocalDateTime(2020, 1, 1, 12, 0, 0, 0)
```

Or create a DateTime from an ISO-8601 format:

```go
dateTime := gostradamus.Parse("2017-07-14T02:40:00.000000+0200", gostradamus.Iso8601)
```

Or from a custom format:

```go
dateTime := gostradamus.Parse("10.02.2010 14:59:53", "DD.MM.YYYY HH:mm:ss")
```

Or an UNIX timestamp for example:

```go 
dateTime := gostradamus.FromUnixTimestamp(1500000000)
```

Or different ways of the current datetime:

```go
// Current DateTime in local timezone
dateTime := gostradamus.Now()

// Current DateTime in UTC timezone
dateTime = gostradamus.UTCNow()

// Current DateTime in given timezone
dateTime = gostradamus.NowInTimezone(gostradamus.EuropeParis)
```

## Timezones

Feel free to use all available timezones,
defined [here](https://github.com/bykof/gostradamus/blob/master/timezone_constants.go):

```go
gostradamus.EuropeParis // Europe/Paris
gostradamus.EuropeBerlin // Europe/Berlin
gostradamus.AmericaNewYork // America/New_York
... and many more
```

Convert between timezones easily:

```go
dateTime := gostradamus.NewUTC(2020, 1, 1, 12, 12, 12, 0).InTimezone(gostradamus.EuropeBerlin)
println(dateTime.String())
// 2020-02-15T13:12:12.000000+0100

dateTime = dateTime.InTimeZone(America_New_York)
println(dateTime.String())
// 2020-02-15T07:12:12.000000-0500
```

## Shift

Shifting helps you to add or subtract years, months, days, hours, minutes, seconds, milliseconds, microseconds, and
nanoseconds.

To add a value use positive integer, to subtract use negative integer.

```go
dateTime := gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.ShiftYears(10)
println(dateTime.String())
// 2030-01-01T01:01:01.000000+0000

dateTime = gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.ShiftDays(-10)
println(dateTime.String())
// 2019-12-22T01:01:01.000000+0000

dateTime = gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.ShiftWeeks(2)
println(dateTime.String())
// 2020-01-15T01:01:01.000000+0000

dateTime = gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.Shift(0, 1, 10, 0, 0, 0, 0)
println(dateTime.String())
// 2020-02-11T01:01:01.000000+0000
``` 

## Replace

Replacing values can be done easily.

```go
dateTime := gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.ReplaceYear(2010)
println(dateTime.String())
// 2010-01-01T01:01:01.000000+0000

dateTime = gostradamus.NewUTCDateTime(2020, 1, 1, 1, 1, 1, 1)
dateTime = dateTime.ReplaceYear(2010).ReplaceMonth(2)
println(dateTime.String())
// 2010-02-01T01:01:01.000000+0000
```

## Token Table

| 	 | Token 	 | Output 	 |
|----------------|---------|-------------------------------------------|
| Year 	 | YYYY 	 | 2000, 2001, 2002 … 2012, 2013 	 |
| 	 | YY 	 | 00, 01, 02 … 12, 13 	 |
| Month 	 | MMMM 	 | January, February, March … 	 |
| 	 | MMM 	 | Jan, Feb, Mar … 	 |
| 	 | MM 	 | 01, 02, 03 … 11, 12 	 |
| 	 | M 	 | 1, 2, 3 … 11, 12 	 |
| Day of Year 	 | DDDD 	 | 001, 002, 003 … 364, 365 	 |
| Day of Month 	 | DD 	 | 01, 02, 03 … 30, 31 	 |
| 	 | D 	 | 1, 2, 3 … 30, 31 	 |
| 	 | Do 	 | 1st, 2nd, 3rd … 	 |
| Day of Week 	 | dddd 	 | Monday, Tuesday, Wednesday … 	 |
| 	 | ddd 	 | Mon, Tue, Wed … 	 |
| Hour 	 | HH 	 | 00, 01, 02 … 23, 24 	 |
| 	 | hh 	 | 01, 02, 03 … 11, 12 	 |
| 	 | h 	 | 1, 2, 3 … 11, 12 	 |
| AM / PM 	 | A 	 | AM, PM 	 |
| 	 | a 	 | am, pm 	 |
| Minute 	 | mm 	 | 00, 01, 02 … 58, 59 	 |
| 	 | m 	 | 0, 1, 2 … 58, 59 	 |
| Second 	 | ss 	 | 00, 01, 02 … 58, 59 	 |
| 	 | s 	 | 0, 1, 2 … 58, 59 	 |
| Microsecond 	 | S 	 | 000000 … 999999 	 |
| Timezone 	 | ZZZ 	 | Asia/Baku, Europe/Warsaw, GMT 	 |
| 	 | zz 	 | -07:00, -06:00 … +06:00, +07:00, +08, Z 	 |
| 	 | Z 	 | -0700, -0600 … +0600, +0700, +08, Z 	 |

## Parsing

> Please consider that you cannot put custom tokens or custom letters into the *parsing* string

Easily parse with `Parse`:

```go
dateTime, err := gostradamus.Parse("10.02.2010 14:59:53", "DD.MM.YYYY HH:mm:ss")
println(dateTime.String())
// 2010-02-10T14:59:53.000000Z
```

You can also specify a timezone while parsing:

```go
dateTime, err := gostradamus.ParseInTimezone("10.02.2010 14:59:53", "DD.MM.YYYY HH:mm:ss", gostradamus.EuropeBerlin)
println(dateTime.String())
// 2010-02-10T14:59:53.000000+0100
```

## Formatting

Formatting is as easy as parsing:

```go
dateTimeString := gostradamus.NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).Format("DD.MM.YYYY Time: HH:mm:ss")
println(dateTimeString)
// 14.07.2017 Time: 02:40:00
```

## Floor

```go
dateTimeString := gostradamus.NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).FloorDay()
println(dateTimeString.String())
// 2017-07-14T00:00:00.000000Z

dateTimeString := gostradamus.NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).FlorHour()
println(dateTimeString.String())
// 2017-07-14T02:00:00.000000Z
```

## Ceil

```go
dateTimeString := gostradamus.NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).CeilMonth()
println(dateTimeString.String())
// 2017-07-31T23:59:59.999999Z

dateTimeString := gostradamus.NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).CeilSecond()
println(dateTimeString.String())
// 2017-07-14T02:40:00.999999Z
```

## Spans

Spans can help you to get quickly the current span of the month or the day:

```go
start, end := NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).SpanMonth()
println(start.String())
// 2017-07-01T00:00:00.000000Z
println(end.String())
// 2017-07-31T23:59:59.999999Z

start, end = NewDateTime(2017, 7, 14, 2, 40, 0, 0, UTC).SpanDay()
println(start.String())
// 2017-07-14T00:00:00.000000Z
println(end.String())
// 2017-07-14T23:59:59.999999Z

start, end = NewDateTime(2012, 12, 12, 2, 40, 0, 0, UTC).SpanWeek()
println(start.String())
// 2012-12-10T00:00:00.000000Z
println(end.String())
// 2012-12-16T23:59:59.999999Z
```

## Utils

Here is the section for some nice helper functions that will save you some time.

### IsBetween

```go
isBetween := gostradamus.NewUTCDateTime(2020, 1, 1, 12, 0, 0, 0).IsBetween(
gostradamus.NewUTCDateTime(2020, 1, 1, 11, 0, 0, 0),
gostradamus.NewUTCDateTime(2020, 1, 1, 13, 0, 0, 0),
)
println(isBetween)
// true

isBetween = gostradamus.NewUTCDateTime(2020, 1, 1, 12, 0, 0, 0).IsBetween(
gostradamus.NewUTCDateTime(2020, 1, 1, 13, 0, 0, 0),
gostradamus.NewUTCDateTime(2020, 1, 1, 14, 0, 0, 0),
)
println(isBetween)
// false
```

### IsoCalendar

Retrieve year, month, day directly as a 3-tuple:

```go
year, month, day := gostradamus.NewUTCDateTime(2020, 1, 1, 12, 0, 0, 0).IsoCalendar()
println(year, month, day)
// 2020 1 1
```

## Contribution

Do you have an idea to improve Gostradamus? -> [Create an issue](https://github.com/bykof/gostradamus/issues/new/choose)

Do you have already coded something for Gostradamus? -> Create a pull request.

Did you discover a bug? -> [Create an issue](https://github.com/bykof/gostradamus/issues/new/choose)

Otherwise feel free to contact me: `michael@bykovski.de` or visit my webpage: [bykovski.de](https://bykovski.de)

## License

MIT licensed. See the LICENSE file for details.

gostradamus

Efficiently parse ISO8601 date-times without regex.

A fast ISO8601 date parser for Go

[![GoDoc](https://godoc.org/github.com/relvacode/iso8601?status.svg)](https://godoc.org/github.com/relvacode/iso8601) ![Build Status](https://github.com/relvacode/iso8601/actions/workflows/verify.yml/badge.svg) [![Go Report Card](https://goreportcard.com/badge/github.com/relvacode/iso8601)](https://goreportcard.com/report/github.com/relvacode/iso8601)


```
go get github.com/relvacode/iso8601
```

The built-in RFC3333 time layout in Go is too restrictive to support any ISO8601 date-time.

This library parses any ISO8601 date into a native Go time object without regular expressions.

## Usage

```go
package main

import "github.com/relvacode/iso8601"

// iso8601.Time can be used as a drop-in replacement for time.Time with JSON responses
type ExternalAPIResponse struct {
	Timestamp *iso8601.Time
}


func main() {
	// iso8601.ParseString can also be called directly
	t, err := iso8601.ParseString("2020-01-02T16:20:00")
}
```

## Benchmark

```
goos: linux
goarch: amd64
pkg: github.com/relvacode/iso8601
cpu: AMD Ryzen 7 7840U w/ Radeon 780M Graphics      
BenchmarkParse-16               35880919                30.89 ns/op            0 B/op          0 allocs/op
```


iso8601

Date and Time - Golang Formatting Library.

<img width="500" src ="https://i.imgur.com/AqveQES.png" />


# Kair
> Date and Time - Golang Formatting Library

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Go Report Card](https://goreportcard.com/badge/github.com/GuilhermeCaruso/kair)](https://goreportcard.com/report/github.com/GuilhermeCaruso/kair) [![codecov](https://codecov.io/gh/GuilhermeCaruso/kair/branch/master/graph/badge.svg)](https://codecov.io/gh/GuilhermeCaruso/kair) [![Build Status](https://travis-ci.com/GuilhermeCaruso/kair.svg?branch=master)](https://travis-ci.com/GuilhermeCaruso/kair) ![GitHub](https://img.shields.io/badge/golang%20->=1.6.3-blue.svg) [![GoDoc](https://godoc.org/github.com/GuilhermeCaruso/kair?status.svg)](https://godoc.org/github.com/GuilhermeCaruso/kair) 

## Setup

To get Kair

##### > Go CLI
```sh
go get github.com/GuilhermeCaruso/kair
```
##### > Go DEP
```sh
dep ensure -add github.com/GuilhermeCaruso/kair
```
##### > Govendor
```sh
govendor fetch github.com/GuilhermeCaruso/kair
```

## Example
```go
package main

import (
	"fmt"

	k "github.com/GuilhermeCaruso/kair"
)

func main() {
	now := k.Now()

 fmt.Printf("Right now is %s \n", now.CustomFormat("dd/MM/YYYY hh:mm:ss"))

	date := k.Date(29, 05, 1980)

	fmt.Printf("The %s was a %s in %s\n",
		date.Format("L"),
		date.CustomFormat("DD"),
 date.CustomFormat("MMMM")) //The 29/05/1980 was a Thursday in May 
}

```

## Formatters
- Standard
```sh
 "LT": 10:20 AM,
 "LTS": 10:20:00 AM,
 "L": 20/05/2018,
 "l": 20/5/2018,
 "LL": May 20, 2018,
 "ll": May 20, 2018,
 "LLL": May 20, 2018 10:20 AM,
 "lll": May 20, 2018 10:20 AM,
 "LLLL": Sunday, May 20, 2018 10:20 AM,
 "llll": Sun, May 20, 2018 10:20 AM,
 "": 2018-05-20 10:20:00 +0000 UTC,
```

- Custom
```sh
 "MMMM": Long Month,
 "MMM": Month,
 "MM": Zero Number Month,
 "M": Number Month,
 "YYYY": Long Year,
 "YY": Year,
 "DD": Long Day,
 "D": Day,
 "dd": Long Number Day,
 "d": Number Day,
 "hh": Long Hour,
 "h": Hour,
 "mm": Long Minute,
 "m": Minute,
 "ss": Long Second,
 "s": Second
```

## Contributing
Please feel free to make suggestions, create issues, fork the repository and send pull requests!

## To do:
- [X] Implement Standard Format
- [X] Implement Custom Format
- [X] Implement Now(), Date() and DateTime() initializers
- [ ] Implement Relative Time (FromNow, StartOf ...)
- [ ] Implement CalendarTime (add, subtract, calendar)

## License

MIT License © Guilherme Caruso

kair

## Now

Now is a time toolkit for golang

[![go report card](https://goreportcard.com/badge/github.com/jinzhu/now "go report card")](https://goreportcard.com/report/github.com/jinzhu/now)
[![test status](https://github.com/jinzhu/now/workflows/tests/badge.svg?branch=master "test status")](https://github.com/jinzhu/now/actions)
[![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)

## Install

```
go get -u github.com/jinzhu/now
```

## Usage

Calculating time based on current time

```go
import "github.com/jinzhu/now"

time.Now() // 2013-11-18 17:51:49.123456789 Mon

now.BeginningOfMinute() // 2013-11-18 17:51:00 Mon
now.BeginningOfHour() // 2013-11-18 17:00:00 Mon
now.BeginningOfDay() // 2013-11-18 00:00:00 Mon
now.BeginningOfWeek() // 2013-11-17 00:00:00 Sun
now.BeginningOfMonth() // 2013-11-01 00:00:00 Fri
now.BeginningOfQuarter() // 2013-10-01 00:00:00 Tue
now.BeginningOfYear() // 2013-01-01 00:00:00 Tue

now.EndOfMinute() // 2013-11-18 17:51:59.999999999 Mon
now.EndOfHour() // 2013-11-18 17:59:59.999999999 Mon
now.EndOfDay() // 2013-11-18 23:59:59.999999999 Mon
now.EndOfWeek() // 2013-11-23 23:59:59.999999999 Sat
now.EndOfMonth() // 2013-11-30 23:59:59.999999999 Sat
now.EndOfQuarter() // 2013-12-31 23:59:59.999999999 Tue
now.EndOfYear() // 2013-12-31 23:59:59.999999999 Tue

now.WeekStartDay = time.Monday // Set Monday as first day, default is Sunday
now.EndOfWeek() // 2013-11-24 23:59:59.999999999 Sun
```

Calculating time based on another time

```go
t := time.Date(2013, 02, 18, 17, 51, 49, 123456789, time.Now().Location())
now.With(t).EndOfMonth() // 2013-02-28 23:59:59.999999999 Thu
```

Calculating time based on configuration

```go
location, err := time.LoadLocation("Asia/Shanghai")

myConfig := &now.Config{
	WeekStartDay: time.Monday,
	TimeLocation: location,
	TimeFormats: []string{"2006-01-02 15:04:05"},
}

t := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.Now().Location()) // // 2013-11-18 17:51:49.123456789 Mon
myConfig.With(t).BeginningOfWeek() // 2013-11-18 00:00:00 Mon

myConfig.Parse("2002-10-12 22:14:01") // 2002-10-12 22:14:01
myConfig.Parse("2002-10-12 22:14") // returns error 'can't parse string as time: 2002-10-12 22:14'
```

### Monday/Sunday

Don't be bothered with the `WeekStartDay` setting, you can use `Monday`, `Sunday`

```go
now.Monday() // 2013-11-18 00:00:00 Mon
now.Monday("17:44") // 2013-11-18 17:44:00 Mon
now.Sunday() // 2013-11-24 00:00:00 Sun (Next Sunday)
now.Sunday("18:19:24") // 2013-11-24 18:19:24 Sun (Next Sunday)
now.EndOfSunday() // 2013-11-24 23:59:59.999999999 Sun (End of next Sunday)

t := time.Date(2013, 11, 24, 17, 51, 49, 123456789, time.Now().Location()) // 2013-11-24 17:51:49.123456789 Sun
now.With(t).Monday() // 2013-11-18 00:00:00 Mon (Last Monday if today is Sunday)
now.With(t).Monday("17:44") // 2013-11-18 17:44:00 Mon (Last Monday if today is Sunday)
now.With(t).Sunday() // 2013-11-24 00:00:00 Sun (Beginning Of Today if today is Sunday)
now.With(t).Sunday("18:19:24") // 2013-11-24 18:19:24 Sun (Beginning Of Today if today is Sunday)
now.With(t).EndOfSunday() // 2013-11-24 23:59:59.999999999 Sun (End of Today if today is Sunday)
```

### Parse String to Time

```go
time.Now() // 2013-11-18 17:51:49.123456789 Mon

// Parse(string) (time.Time, error)
t, err := now.Parse("2017") // 2017-01-01 00:00:00, nil
t, err := now.Parse("2017-10") // 2017-10-01 00:00:00, nil
t, err := now.Parse("2017-10-13") // 2017-10-13 00:00:00, nil
t, err := now.Parse("1999-12-12 12") // 1999-12-12 12:00:00, nil
t, err := now.Parse("1999-12-12 12:20") // 1999-12-12 12:20:00, nil
t, err := now.Parse("1999-12-12 12:20:21") // 1999-12-12 12:20:21, nil
t, err := now.Parse("10-13") // 2013-10-13 00:00:00, nil
t, err := now.Parse("12:20") // 2013-11-18 12:20:00, nil
t, err := now.Parse("12:20:13") // 2013-11-18 12:20:13, nil
t, err := now.Parse("14") // 2013-11-18 14:00:00, nil
t, err := now.Parse("99:99") // 2013-11-18 12:20:00, Can't parse string as time: 99:99

// MustParse must parse string to time or it will panic
now.MustParse("2013-01-13") // 2013-01-13 00:00:00
now.MustParse("02-17") // 2013-02-17 00:00:00
now.MustParse("2-17") // 2013-02-17 00:00:00
now.MustParse("8") // 2013-11-18 08:00:00
now.MustParse("2002-10-12 22:14") // 2002-10-12 22:14:00
now.MustParse("99:99") // panic: Can't parse string as time: 99:99
```

Extend `now` to support more formats is quite easy, just update `now.TimeFormats` with other time layouts, e.g:

```go
now.TimeFormats = append(now.TimeFormats, "02 Jan 2006 15:04")
```

Please send me pull requests if you want a format to be supported officially

## Contributing

You can help to make the project better, check out [http://gorm.io/contribute.html](http://gorm.io/contribute.html) for things you can do.

# Author

**jinzhu**

* <http://github.com/jinzhu>
* <wosmvp@gmail.com>
* <http://twitter.com/zhangjinzhu>

## License

Released under the [MIT License](http://www.opensource.org/licenses/MIT).

# Tuesday: Ruby-Compatible Strftime for Go

 [![Travis badge][travis-svg]][travis-url]
 [![Golangci-lint badge][golangci-lint-svg]][golangci-lint-url]
 [![Appveyor badge][appveyor-svg]][appveyor-url]
 [![Coveralls badge][coveralls-svg]][coveralls-url]
 [![Go Report Card badge][go-report-card-svg]][go-report-card-url]
 [![Godoc badge][godoc-svg]][godoc-url]
 [![MIT License][license-svg]][license-url]

This package provides a function `Strftime` that is compatible with Ruby's [`Time.strftime`](https://ruby-doc.org/core-2.4.1/Time.html#method-i-strftime).

It provides additional flags and conversions beyond C stdlib-like `strftime`s:

* padding flags, *e.g.* `%-m`, `%_m`, `%0e`
* case change flags, *e.g.* `%^A`, `%#b`
* field widths: `%03e`, `%3N`, `%9N`
* Ruby-specific conversions such as `%s`, `%N`, `%:z`, `%::z`

It was developed for use with in [Liquid](https://github.com/osteele/liquid) and [Gojekyll](https://github.com/osteele/gojekyll).

## Install

`go get gopkg.in/osteele/tuesday.v1` # latest snapshot

`go get -u github.com/osteele/tuesday` # development version

## References

* [Ruby Date.strftime](https://ruby-doc.org/stdlib-2.4.1/libdoc/date/rdoc/Date.html#method-i-strftime)
* [Ruby DateTime.strftime](https://ruby-doc.org/stdlib-2.4.1/libdoc/date/rdoc/DateTime.html#method-i-strftime)
* [Ruby Time.strftime](https://ruby-doc.org/core-2.4.1/Time.html#method-i-strftime)

## License

MIT License

[coveralls-url]: https://coveralls.io/r/osteele/tuesday?branch=master
[coveralls-svg]: https://img.shields.io/coveralls/osteele/tuesday.svg?branch=master

[godoc-url]: https://godoc.org/github.com/osteele/tuesday
[godoc-svg]: https://godoc.org/github.com/osteele/tuesday?status.svg

[golangci-lint-url]: https://github.com/osteele/tuesday/actions?query=workflow%3Agolangci-lint
[golangci-lint-svg]: https://github.com/osteele/tuesday/actions/workflows/golangci-lint.yml/badge.svg

[license-url]: https://github.com/osteele/tuesday/blob/master/LICENSE
[license-svg]: https://img.shields.io/badge/license-MIT-blue.svg

[go-report-card-url]: https://goreportcard.com/report/github.com/osteele/tuesday
[go-report-card-svg]: https://goreportcard.com/badge/github.com/osteele/tuesday

[travis-url]: https://travis-ci.com/osteele/tuesday
[travis-svg]: https://img.shields.io/travis/osteele/tuesday.svg?branch=master

[appveyor-url]: https://ci.appveyor.com/project/osteele/tuesday
[appveyor-svg]: https://ci.appveyor.com/api/projects/status/y9cyh4e30yjxshtm?svg=true


The Best Go Libraries For Date and Time - Libraries for working with dates and times. (22)

strftime

timespan

approx

carbon

carbon

cronrange

date

dateparse

durafmt

feiertage

go-anytime

go-datebin

go-persian-calendar

go-str2duration

timeutil

go-sunrise

go-week

gostradamus

iso8601

kair

now

tuesday