Handle Interval Date Format similar to the JS variant

https://github.com/grafana/grafana/pull/10343/commits/7e14e272fa37df5b4d412c16845d1e525711f726

Gopkg.lock

@@ -295,6 +295,12 @@
   packages = ["."]
   revision = "7cafcd837844e784b526369c9bce262804aebc60"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/leibowitz/moment"
+  packages = ["."]
+  revision = "8548108dcca204a1110b99e5fec966817499fe84"
+
 [[projects]]
   branch = "master"
   name = "github.com/lib/pq"
@@ -642,6 +648,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "5e65aeace832f1b4be17e7ff5d5714513c40f31b94b885f64f98f2332968d7c6"
+  inputs-digest = "9895ff7b1516b9639d0fc280ca155c8958486656a2086fc45e91f727fccea0d2"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -201,3 +201,7 @@ ignored = [
 [[constraint]]
   name = "github.com/denisenkom/go-mssqldb"
   revision = "270bc3860bb94dd3a3ffd047377d746c5e276726"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/leibowitz/moment"

pkg/tsdb/elasticsearch/model_parser.go

@@ -7,6 +7,7 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/leibowitz/moment"
 	"src/github.com/davecgh/go-spew/spew"
 	"strconv"
 	"strings"
@@ -63,7 +64,7 @@ func (qp *ElasticSearchQueryParser) getQueryHeader() *QueryHeader {
 	}
 	header.SearchType = searchType
 	header.IgnoreUnavailable = true
-	header.Index = qp.getIndexList()
+	header.Index = getIndexList(qp.DsInfo.Database, qp.DsInfo.JsonData.Get("interval").MustString(""), qp.TimeRange)
 
 	if esVersion >= 56 {
 		header.MaxConcurrentShardRequests = qp.DsInfo.JsonData.Get("maxConcurrentShardRequests").MustInt()
@@ -87,11 +88,42 @@ func (qp *ElasticSearchQueryParser) payloadReplace(payload string, model *simple
 	return payload, nil
 }
 
-func (qp *ElasticSearchQueryParser) getIndexList() string {
-	_, err := qp.DsInfo.JsonData.Get("interval").String()
-	if err != nil {
-		return qp.DsInfo.Database
+func getIndexList(pattern string, interval string, timeRange *tsdb.TimeRange) string {
+	if interval == "" {
+		return pattern
+	}
+
+	var indexes []string
+	indexParts := strings.Split(strings.TrimLeft(pattern, "["), "]")
+	indexBase := indexParts[0]
+	if len(indexParts) <= 1 {
+		return pattern
+	}
+
+	indexDateFormat := indexParts[1]
+
+	start := moment.NewMoment(timeRange.MustGetFrom())
+	end := moment.NewMoment(timeRange.MustGetTo())
+
+	indexes = append(indexes, fmt.Sprintf("%s%s", indexBase, start.Format(indexDateFormat)))
+	for start.IsBefore(*end) {
+		switch interval {
+		case "Hourly":
+			start = start.AddHours(1)
+
+		case "Daily":
+			start = start.AddDay()
+
+		case "Weekly":
+			start = start.AddWeeks(1)
+
+		case "Monthly":
+			start = start.AddMonths(1)
+
+		case "Yearly":
+			start = start.AddYears(1)
+		}
+		indexes = append(indexes, fmt.Sprintf("%s%s", indexBase, start.Format(indexDateFormat)))
 	}
-	// todo: support interval
-	return qp.DsInfo.Database
+	return strings.Join(indexes, ",")
 }

pkg/tsdb/elasticsearch/model_parser_test.go

@@ -0,0 +1,49 @@
+package elasticsearch
+
+import (
+	"github.com/grafana/grafana/pkg/tsdb"
+	. "github.com/smartystreets/goconvey/convey"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func makeTime(hour int) string {
+	//unixtime 1500000000 == 2017-07-14T02:40:00+00:00
+	return strconv.Itoa((1500000000 + hour*60*60) * 1000)
+}
+
+func getIndexListByTime(pattern string, interval string, hour int) string {
+	timeRange := &tsdb.TimeRange{
+		From: makeTime(0),
+		To:   makeTime(hour),
+	}
+	return getIndexList(pattern, interval, timeRange)
+}
+
+func TestElasticsearchGetIndexList(t *testing.T) {
+	Convey("Test Elasticsearch getIndex ", t, func() {
+
+		Convey("Parse Interval Formats", func() {
+			So(getIndexListByTime("[logstash-]YYYY.MM.DD", "Daily", 48),
+				ShouldEqual, "logstash-2017.07.14,logstash-2017.07.15,logstash-2017.07.16")
+
+			So(len(strings.Split(getIndexListByTime("[logstash-]YYYY.MM.DD.HH", "Hourly", 3), ",")),
+				ShouldEqual, 4)
+
+			So(getIndexListByTime("[logstash-]YYYY.W", "Weekly", 100),
+				ShouldEqual, "logstash-2017.28,logstash-2017.29")
+
+			So(getIndexListByTime("[logstash-]YYYY.MM", "Monthly", 700),
+				ShouldEqual, "logstash-2017.07,logstash-2017.08")
+
+			So(getIndexListByTime("[logstash-]YYYY", "Yearly", 10000),
+				ShouldEqual, "logstash-2017,logstash-2018,logstash-2019")
+		})
+
+		Convey("No Interval", func() {
+			index := getIndexListByTime("logstash-test", "", 1)
+			So(index, ShouldEqual, "logstash-test")
+		})
+	})
+}

vendor/github.com/leibowitz/moment/diff.go

@@ -0,0 +1,75 @@
+package moment
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+// @todo In months/years requires the old and new to calculate correctly, right?
+// @todo decide how to handle rounding (i.e. always floor?)
+type Diff struct {
+	duration time.Duration
+}
+
+func (d *Diff) InSeconds() int {
+	return int(d.duration.Seconds())
+}
+
+func (d *Diff) InMinutes() int {
+	return int(d.duration.Minutes())
+}
+
+func (d *Diff) InHours() int {
+	return int(d.duration.Hours())
+}
+
+func (d *Diff) InDays() int {
+	return int(math.Floor(float64(d.InSeconds()) / 86400))
+}
+
+// This depends on where the weeks fall?
+func (d *Diff) InWeeks() int {
+	return int(math.Floor(float64(d.InDays() / 7)))
+}
+
+func (d *Diff) InMonths() int {
+	return 0
+}
+
+func (d *Diff) InYears() int {
+	return 0
+}
+
+// http://momentjs.com/docs/#/durations/humanize/
+func (d *Diff) Humanize() string {
+	diffInSeconds := d.InSeconds()
+
+	if diffInSeconds <= 45 {
+		return fmt.Sprintf("%d seconds ago", diffInSeconds)
+	} else if diffInSeconds <= 90 {
+		return "a minute ago"
+	}
+
+	diffInMinutes := d.InMinutes()
+
+	if diffInMinutes <= 45 {
+		return fmt.Sprintf("%d minutes ago", diffInMinutes)
+	} else if diffInMinutes <= 90 {
+		return "an hour ago"
+	}
+
+	diffInHours := d.InHours()
+
+	if diffInHours <= 22 {
+		return fmt.Sprintf("%d hours ago", diffInHours)
+	} else if diffInHours <= 36 {
+		return "a day ago"
+	}
+
+	return "diff is in days"
+}
+
+// In Months
+
+// In years

vendor/github.com/leibowitz/moment/moment.go

@@ -0,0 +1,1185 @@
+package moment
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// links
+// http://en.wikipedia.org/wiki/ISO_week_date
+// http://golang.org/src/pkg/time/format.go
+// http://www.php.net/manual/en/class.datetime.php#datetime.constants.rfc822
+// http://php.net/manual/en/function.date.php
+// http://www.php.net/manual/en/datetime.formats.relative.php
+
+// @todo are these constants needed if they are in the time package?
+// There are a lot of extras here, and RFC822 doesn't match up. Why?
+// Also, is timezone usage wrong? Double-check
+const (
+	ATOM    = "2006-01-02T15:04:05Z07:00"
+	COOKIE  = "Monday, 02-Jan-06 15:04:05 MST"
+	ISO8601 = "2006-01-02T15:04:05Z0700"
+	RFC822  = "Mon, 02 Jan 06 15:04:05 Z0700"
+	RFC850  = "Monday, 02-Jan-06 15:04:05 MST"
+	RFC1036 = "Mon, 02 Jan 06 15:04:05 Z0700"
+	RFC1123 = "Mon, 02 Jan 2006 15:04:05 Z0700"
+	RFC2822 = "Mon, 02 Jan 2006 15:04:05 Z0700"
+	RFC3339 = "2006-01-02T15:04:05Z07:00"
+	RSS     = "Mon, 02 Jan 2006 15:04:05 Z0700"
+	W3C     = "2006-01-02T15:04:05Z07:00"
+)
+
+var (
+	regex_days    = "monday|mon|tuesday|tues|wednesday|wed|thursday|thurs|friday|fri|saturday|sat|sunday|sun"
+	regex_period  = "second|minute|hour|day|week|month|year"
+	regex_numbers = "one|two|three|four|five|six|seven|eight|nine|ten"
+)
+
+// regexp
+var (
+	compiled    = regexp.MustCompile(`\s{2,}`)
+	relativeday = regexp.MustCompile(`(yesterday|today|tomorrow)`)
+	//relative1      = regexp.MustCompile(`(first|last) day of (this|next|last|previous) (week|month|year)`)
+	//relative2      = regexp.MustCompile(`(first|last) day of (` + "jan|january|feb|february|mar|march|apr|april|may|jun|june|jul|july|aug|august|sep|september|oct|october|nov|november|dec|december" + `)(?:\s(\d{4,4}))?`)
+	relative3 = regexp.MustCompile(`((?P<relperiod>this|next|last|previous) )?(` + regex_days + `)`)
+	//relativeval    = regexp.MustCompile(`([0-9]+) (day|week|month|year)s? ago`)
+	ago            = regexp.MustCompile(`([0-9]+) (` + regex_period + `)s? ago`)
+	ordinal        = regexp.MustCompile("([0-9]+)(st|nd|rd|th)")
+	written        = regexp.MustCompile(regex_numbers)
+	relativediff   = regexp.MustCompile(`([\+\-])?([0-9]+),? ?(` + regex_period + `)s?`)
+	relativetime   = regexp.MustCompile(`(?P<hour>\d\d?):(?P<minutes>\d\d?)(:(?P<seconds>\d\d?))?\s?(?P<meridiem>am|pm)?\s?(?P<zone>[a-z]{3,3})?|(?P<relativetime>noon|midnight)`)
+	yearmonthday   = regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})`)
+	relativeperiod = regexp.MustCompile(`(?P<relperiod>this|next|last) (week|month|year)`)
+	numberRegex    = regexp.MustCompile("([0-9]+)(?:<stdOrdinal>)")
+)
+
+// http://golang.org/src/pkg/time/format.go?s=12686:12728#L404
+
+// Timezone implementation
+// https://groups.google.com/forum/#!topic/golang-nuts/XEVN4QwTvHw
+// http://en.wikipedia.org/wiki/Zone.tab
+
+// Support ISO8601 Duration Parsing?
+// http://en.wikipedia.org/wiki/ISO_8601
+
+// Differences
+// Months are NOT zero-index, MOmentJS they are
+// Weeks are 0 indexed
+//     -- Sunday being the last day of the week ISO-8601 - is that diff from Moment?
+// From/FromNow Return a Diff object rather than strings
+
+// Support for locale and languages with English as default
+
+// Support for strftime
+// https://github.com/benjaminoakes/moment-strftime
+// Format: https://php.net/strftime
+
+type Moment struct {
+	time time.Time
+
+	Parser
+}
+
+type Parser interface {
+	Convert(string) string
+}
+
+func New() *Moment {
+	m := &Moment{time.Now(), new(MomentParser)}
+
+	return m
+}
+
+func NewMoment(t time.Time) *Moment {
+	m := &Moment{t, new(MomentParser)}
+
+	return m
+}
+
+func (m *Moment) GetTime() time.Time {
+	return m.time
+}
+
+func (m *Moment) Now() *Moment {
+	m.time = time.Now().In(m.GetTime().Location())
+
+	return m
+}
+
+func (m *Moment) Moment(layout string, datetime string) *Moment {
+	return m.MomentGo(m.Convert(layout), datetime)
+}
+
+func (m *Moment) MomentGo(layout string, datetime string) *Moment {
+	time, _ := time.Parse(layout, datetime)
+
+	m.time = time
+
+	return m
+}
+
+// This method is nowhere near done - requires lots of work.
+func (m *Moment) Strtotime(str string) *Moment {
+	str = strings.ToLower(strings.TrimSpace(str))
+	str = compiled.ReplaceAllString(str, " ")
+
+	// Replace written numbers (i.e. nine, ten) with actual numbers (9, 10)
+	str = written.ReplaceAllStringFunc(str, func(n string) string {
+		switch n {
+		case "one":
+			return "1"
+		case "two":
+			return "2"
+		case "three":
+			return "3"
+		case "four":
+			return "4"
+		case "five":
+			return "5"
+		case "six":
+			return "6"
+		case "seven":
+			return "7"
+		case "eight":
+			return "8"
+		case "nine":
+			return "9"
+		case "ten":
+			return "10"
+		}
+
+		return ""
+	})
+
+	// Remove ordinal suffixes st, nd, rd, th
+	str = ordinal.ReplaceAllString(str, "$1")
+
+	// Replace n second|minute|hour... ago to -n second|minute|hour... to consolidate parsing
+	str = ago.ReplaceAllString(str, "-$1 $2")
+
+	// Look for relative +1day, +3 days 5 hours 15 minutes
+	if match := relativediff.FindAllStringSubmatch(str, -1); match != nil {
+		for i := range match {
+			switch match[i][1] {
+			case "-":
+				number, _ := strconv.Atoi(match[i][2])
+				m.Subtract(match[i][3], number)
+			default:
+				number, _ := strconv.Atoi(match[i][2])
+				m.Add(match[i][3], number)
+			}
+
+			str = strings.Replace(str, match[i][0], "", 1)
+		}
+	}
+
+	// Remove any words that aren't needed for consistency
+	str = strings.Replace(str, " at ", " ", -1)
+	str = strings.Replace(str, " on ", " ", -1)
+
+	// Support for interchangeable previous/last
+	str = strings.Replace(str, "previous", "last", -1)
+
+	var dateDefaults = map[string]int{
+		"year":  0,
+		"month": 0,
+		"day":   0,
+	}
+
+	dateMatches := dateDefaults
+	if match := yearmonthday.FindStringSubmatch(str); match != nil {
+		for i, name := range yearmonthday.SubexpNames() {
+			if i == 0 {
+				str = strings.Replace(str, match[i], "", 1)
+				continue
+			}
+
+			if match[i] == "" {
+				continue
+			}
+
+			if name == "year" || name == "month" || name == "day" {
+				dateMatches[name], _ = strconv.Atoi(match[i])
+			}
+
+		}
+
+		defer m.strtotimeSetDate(dateMatches)
+		if str == "" {
+			// Nothing left to parse
+			return m
+		}
+
+		str = strings.TrimSpace(str)
+	}
+
+	// Try to parse out time from the string
+	var timeDefaults = map[string]int{
+		"hour":    0,
+		"minutes": 0,
+		"seconds": 0,
+	}
+
+	timeMatches := timeDefaults
+	var zone string
+	if match := relativetime.FindStringSubmatch(str); match != nil {
+		for i, name := range relativetime.SubexpNames() {
+			if i == 0 {
+				str = strings.Replace(str, match[i], "", 1)
+				continue
+			}
+
+			if match[i] == "" {
+				continue
+			}
+
+			// Midnight is all zero's so nothing to do
+			if name == "relativetime" && match[i] == "noon" {
+				timeDefaults["hour"] = 12
+			}
+
+			if name == "zone" {
+				zone = match[i]
+			}
+
+			if name == "meridiem" && match[i] == "pm" && timeMatches["hour"] < 12 {
+				timeMatches["hour"] += 12
+			}
+
+			if name == "hour" || name == "minutes" || name == "seconds" {
+				timeMatches[name], _ = strconv.Atoi(match[i])
+			}
+		}
+
+		// Processing time is always last
+		defer m.strtotimeSetTime(timeMatches, zone)
+
+		if str == "" {
+			// Nothing left to parse
+			return m
+		}
+
+		str = strings.TrimSpace(str)
+	}
+
+	// m.StartOf("month", "January").GoTo(time.Sunday)
+
+	if match := relativeperiod.FindStringSubmatch(str); match != nil {
+		period := match[1]
+		unit := match[2]
+
+		str = strings.Replace(str, match[0], "", 1)
+
+		switch period {
+		case "next":
+			if unit == "year" {
+				m.AddYears(1)
+			}
+			if unit == "month" {
+				m.AddMonths(1)
+			}
+			if unit == "week" {
+				m.AddWeeks(1)
+			}
+		case "last":
+			if unit == "year" {
+				m.SubYears(1)
+			}
+			if unit == "month" {
+				m.SubMonths(1)
+			}
+			if unit == "week" {
+				m.SubWeeks(1)
+			}
+		}
+
+		str = strings.TrimSpace(str)
+
+		// first := regexp.MustCompile("(?P<relperiod>first|last)?")
+	}
+
+	/*
+
+							   relativeday:        first day of
+							   relativeperiod:     this, last, next
+							   relativeperiodunit  week, month, year
+							   day:                monday, tues, wednesday
+							   month:              january, feb
+
+
+							   YYYY-MM-DD (HH:MM:SS MST)?
+							   MM-DD-YYYY (HH:MM:SS MST)
+							   10 September 2015 (HH:MM:SS MST)?
+							   September, 10 2015 (HH:MM:SS MST)?
+							   September 10 2015 (HH:MM:SS M
+
+		                           this year 2014
+		                           next year 2015
+		                           last year 2013
+
+		                        this month April
+		                        next month May
+		                        last month Mar
+
+		                        first day of April
+		                        last day of April
+
+
+							   DONE 3PM
+							   DONE 3:00 PM
+							   DONE 3:00:05 MST
+							   3PM on January 5th
+							   January 5th at 3:00PM
+							   first saturday _of_ next month
+							   first saturday _of_ next month _at_ 3:00PM
+							   saturday of next week
+							   saturday of last week
+							        saturday next week
+							        monday next week
+							   saturday of this week
+							   saturday at 3:00pm
+							   saturday at 4:00PM
+							   saturday at midn
+							   first of january
+							   last of january
+				               january of next year
+							   first day of january
+							   last day of january
+							   		      first day of February
+
+						       DONE midnight
+						       DONE noon
+							   DONE 3 days ago
+							   DONE ten days
+							   DONE 9 weeks ago // Convert to -9 weeks
+							   DONE -9 weeks
+
+	*/
+
+	if match := relativeday.FindStringSubmatch(str); match != nil && len(match) > 1 {
+		day := match[1]
+
+		str = strings.Replace(str, match[0], "", 1)
+
+		switch day {
+		case "today":
+			m.Today()
+		case "yesterday":
+			m.Yesterday()
+		case "tomorrow":
+			m.Tomorrow()
+		}
+	}
+
+	if match := relative3.FindStringSubmatch(str); match != nil {
+		var when string
+		for i, name := range relative3.SubexpNames() {
+			if name == "relperiod" {
+				when = match[i]
+			}
+		}
+		weekDay := match[len(match)-1]
+
+		str = strings.Replace(str, match[0], "", 1)
+
+		wDay, err := ParseWeekDay(weekDay)
+		if err == nil {
+			switch when {
+			case "last", "previous":
+				m.GoBackTo(wDay, true)
+
+			case "next":
+				m.GoTo(wDay, true)
+
+			case "", "this":
+				m.GoTo(wDay, false)
+			default:
+				m.GoTo(wDay, false)
+			}
+		}
+	}
+
+	/*
+
+
+	   yesterday 11:00
+	   today 11:00
+	   tomorrow 11:00
+	   midnight
+	   noon
+	   DONE +n (second|day|week|month|year)s?
+	   DONE -n (second|day|week|month|year)s?
+	   next (monday|tuesday|wednesday|thursday|friday|saturday|sunday) 11:00
+	   last (monday|tuesday|wednesday|thursday|friday|saturday|sunday) 11:00
+	   next (month|year)
+	   last (month|year)
+	   first day of (january|february|march...|december) 2014
+	   last day of (january|february|march...|december) 2014
+	   first day of (this|next|last) (week|month|year)
+	   last day of (this|next|last) (week|month|year)
+	   first (monday|tuesday|wednesday) of July 2014
+	   last (monday|tuesday|wednesday) of July 2014
+	   n (day|week|month|year)s? ago
+	   Monday|Tuesday|Wednesday|Thursday|Friday
+	   Monday (last|this|next) week
+
+	   DONE +1 week 2 days 3 hours 4 minutes 5 seconds
+	*/
+
+	return m
+}
+
+// @todo deal with timezone
+func (m *Moment) strtotimeSetTime(time map[string]int, zone string) {
+	m.SetHour(time["hour"]).SetMinute(time["minutes"]).SetSecond(time["seconds"])
+}
+
+func (m *Moment) strtotimeSetDate(date map[string]int) {
+	m.SetYear(date["year"]).SetMonth(time.Month(date["month"])).SetDay(date["day"])
+}
+
+func (m Moment) Clone() *Moment {
+	copy := New()
+	copy.time = m.GetTime()
+
+	return copy
+}
+
+/**
+ * Getters
+ *
+ */
+// https://groups.google.com/forum/#!topic/golang-nuts/pret7hjDc70
+func (m *Moment) Millisecond() {
+
+}
+
+func (m *Moment) Second() int {
+	return m.GetTime().Second()
+}
+
+func (m *Moment) Minute() int {
+	return m.GetTime().Minute()
+}
+
+func (m *Moment) Hour() int {
+	return m.GetTime().Hour()
+}
+
+// Day of month
+func (m *Moment) Date() int {
+	return m.DayOfMonth()
+}
+
+// Carbon convenience method
+func (m *Moment) DayOfMonth() int {
+	return m.GetTime().Day()
+}
+
+// Day of week (int or string)
+func (m *Moment) Day() time.Weekday {
+	return m.DayOfWeek()
+}
+
+// Carbon convenience method
+func (m *Moment) DayOfWeek() time.Weekday {
+	return m.GetTime().Weekday()
+}
+
+func (m *Moment) DayOfWeekISO() int {
+	day := m.GetTime().Weekday()
+
+	if day == time.Sunday {
+		return 7
+	}
+
+	return int(day)
+}
+
+func (m *Moment) DayOfYear() int {
+	return m.GetTime().YearDay()
+}
+
+// Day of Year with zero padding
+func (m *Moment) dayOfYearZero() string {
+	day := m.GetTime().YearDay()
+
+	if day < 10 {
+		return fmt.Sprintf("00%d", day)
+	}
+
+	if day < 100 {
+		return fmt.Sprintf("0%d", day)
+	}
+
+	return fmt.Sprintf("%d", day)
+}
+
+// todo panic?
+func (m *Moment) Weekday(index int) string {
+	if index > 6 {
+		panic("Weekday index must be between 0 and 6")
+	}
+
+	return time.Weekday(index).String()
+}
+
+func (m *Moment) Week() int {
+	return 0
+}
+
+// Is this the week number where as ISOWeekYear is the number of weeks in the year?
+// @see http://stackoverflow.com/questions/18478741/get-weeks-in-year
+func (m *Moment) ISOWeek() int {
+	_, week := m.GetTime().ISOWeek()
+
+	return week
+}
+
+// @todo Consider language support
+func (m *Moment) Month() time.Month {
+	return m.GetTime().Month()
+}
+
+func (m *Moment) Quarter() (quarter int) {
+	quarter = 4
+
+	switch m.Month() {
+	case time.January, time.February, time.March:
+		quarter = 1
+	case time.April, time.May, time.June:
+		quarter = 2
+	case time.July, time.August, time.September:
+		quarter = 3
+	}
+
+	return
+}
+
+func (m *Moment) Year() int {
+	return m.GetTime().Year()
+}
+
+// @see comments for ISOWeek
+func (m *Moment) WeekYear() {
+
+}
+
+func (m *Moment) ISOWeekYear() {
+
+}
+
+/**
+ * Manipulate
+ *
+ */
+func (m *Moment) Add(key string, value int) *Moment {
+	switch key {
+	case "years", "year", "y":
+		m.AddYears(value)
+	case "months", "month", "M":
+		m.AddMonths(value)
+	case "weeks", "week", "w":
+		m.AddWeeks(value)
+	case "days", "day", "d":
+		m.AddDays(value)
+	case "hours", "hour", "h":
+		m.AddHours(value)
+	case "minutes", "minute", "m":
+		m.AddMinutes(value)
+	case "seconds", "second", "s":
+		m.AddSeconds(value)
+	case "milliseconds", "millisecond", "ms":
+
+	}
+
+	return m
+}
+
+// Carbon
+func (m *Moment) AddSeconds(seconds int) *Moment {
+	return m.addTime(time.Second * time.Duration(seconds))
+}
+
+// Carbon
+func (m *Moment) AddMinutes(minutes int) *Moment {
+	return m.addTime(time.Minute * time.Duration(minutes))
+}
+
+// Carbon
+func (m *Moment) AddHours(hours int) *Moment {
+	return m.addTime(time.Hour * time.Duration(hours))
+}
+
+// Carbon
+func (m *Moment) AddDay() *Moment {
+	return m.AddDays(1)
+}
+
+// Carbon
+func (m *Moment) AddDays(days int) *Moment {
+	m.time = m.GetTime().AddDate(0, 0, days)
+
+	return m
+}
+
+// Carbon
+func (m *Moment) AddWeeks(weeks int) *Moment {
+	return m.AddDays(weeks * 7)
+}
+
+// Carbon
+func (m *Moment) AddMonths(months int) *Moment {
+	m.time = m.GetTime().AddDate(0, months, 0)
+
+	return m
+}
+
+// Carbon
+func (m *Moment) AddYears(years int) *Moment {
+	m.time = m.GetTime().AddDate(years, 0, 0)
+
+	return m
+}
+
+func (m *Moment) addTime(d time.Duration) *Moment {
+	m.time = m.GetTime().Add(d)
+
+	return m
+}
+
+func (m *Moment) Subtract(key string, value int) *Moment {
+	switch key {
+	case "years", "year", "y":
+		m.SubYears(value)
+	case "months", "month", "M":
+		m.SubMonths(value)
+	case "weeks", "week", "w":
+		m.SubWeeks(value)
+	case "days", "day", "d":
+		m.SubDays(value)
+	case "hours", "hour", "h":
+		m.SubHours(value)
+	case "minutes", "minute", "m":
+		m.SubMinutes(value)
+	case "seconds", "second", "s":
+		m.SubSeconds(value)
+	case "milliseconds", "millisecond", "ms":
+
+	}
+
+	return m
+}
+
+// Carbon
+func (m *Moment) SubSeconds(seconds int) *Moment {
+	return m.addTime(time.Second * time.Duration(seconds*-1))
+}
+
+// Carbon
+func (m *Moment) SubMinutes(minutes int) *Moment {
+	return m.addTime(time.Minute * time.Duration(minutes*-1))
+}
+
+// Carbon
+func (m *Moment) SubHours(hours int) *Moment {
+	return m.addTime(time.Hour * time.Duration(hours*-1))
+}
+
+// Carbon
+func (m *Moment) SubDay() *Moment {
+	return m.SubDays(1)
+}
+
+// Carbon
+func (m *Moment) SubDays(days int) *Moment {
+	return m.AddDays(days * -1)
+}
+
+func (m *Moment) SubWeeks(weeks int) *Moment {
+	return m.SubDays(weeks * 7)
+}
+
+// Carbon
+func (m *Moment) SubMonths(months int) *Moment {
+	return m.AddMonths(months * -1)
+}
+
+// Carbon
+func (m *Moment) SubYears(years int) *Moment {
+	return m.AddYears(years * -1)
+}
+
+// Carbon
+func (m *Moment) Today() *Moment {
+	return m.Now()
+}
+
+// Carbon
+func (m *Moment) Tomorrow() *Moment {
+	return m.Today().AddDay()
+}
+
+// Carbon
+func (m *Moment) Yesterday() *Moment {
+	return m.Today().SubDay()
+}
+
+func (m *Moment) StartOf(key string) *Moment {
+	switch key {
+	case "year", "y":
+		m.StartOfYear()
+	case "month", "M":
+		m.StartOfMonth()
+	case "week", "w":
+		m.StartOfWeek()
+	case "day", "d":
+		m.StartOfDay()
+	case "hour", "h":
+		if m.Minute() > 0 {
+			m.SubMinutes(m.Minute())
+		}
+
+		if m.Second() > 0 {
+			m.SubSeconds(m.Second())
+		}
+	case "minute", "m":
+		if m.Second() > 0 {
+			m.SubSeconds(m.Second())
+		}
+	case "second", "s":
+
+	}
+
+	return m
+}
+
+// Carbon
+func (m *Moment) StartOfDay() *Moment {
+	if m.Hour() > 0 {
+		_, timeOffset := m.GetTime().Zone()
+		m.SubHours(m.Hour())
+
+		_, newTimeOffset := m.GetTime().Zone()
+		diffOffset := timeOffset - newTimeOffset
+		if diffOffset != 0 {
+			// we need to adjust for time zone difference
+			m.AddSeconds(diffOffset)
+		}
+	}
+
+	return m.StartOf("hour")
+}
+
+// @todo ISO8601 Starts on Monday
+func (m *Moment) StartOfWeek() *Moment {
+	return m.GoBackTo(time.Monday, false).StartOfDay()
+}
+
+// Carbon
+func (m *Moment) StartOfMonth() *Moment {
+	return m.SetDay(1).StartOfDay()
+}
+
+// Carbon
+func (m *Moment) StartOfYear() *Moment {
+	return m.SetMonth(time.January).SetDay(1).StartOfDay()
+}
+
+// Carbon
+func (m *Moment) EndOf(key string) *Moment {
+	switch key {
+	case "year", "y":
+		m.EndOfYear()
+	case "month", "M":
+		m.EndOfMonth()
+	case "week", "w":
+		m.EndOfWeek()
+	case "day", "d":
+		m.EndOfDay()
+	case "hour", "h":
+		if m.Minute() < 59 {
+			m.AddMinutes(59 - m.Minute())
+		}
+	case "minute", "m":
+		if m.Second() < 59 {
+			m.AddSeconds(59 - m.Second())
+		}
+	case "second", "s":
+
+	}
+
+	return m
+}
+
+// Carbon
+func (m *Moment) EndOfDay() *Moment {
+	if m.Hour() < 23 {
+		_, timeOffset := m.GetTime().Zone()
+		m.AddHours(23 - m.Hour())
+
+		_, newTimeOffset := m.GetTime().Zone()
+		diffOffset := newTimeOffset - timeOffset
+		if diffOffset != 0 {
+			// we need to adjust for time zone difference
+			m.SubSeconds(diffOffset)
+		}
+	}
+
+	return m.EndOf("hour")
+}
+
+// @todo ISO8601 Ends on Sunday
+func (m *Moment) EndOfWeek() *Moment {
+	return m.GoTo(time.Sunday, false).EndOfDay()
+}
+
+// Carbon
+func (m *Moment) EndOfMonth() *Moment {
+	return m.SetDay(m.DaysInMonth()).EndOfDay()
+}
+
+// Carbon
+func (m *Moment) EndOfYear() *Moment {
+	return m.GoToMonth(time.December, false).EndOfMonth()
+}
+
+// Custom
+func (m *Moment) GoTo(day time.Weekday, next bool) *Moment {
+	if m.Day() == day {
+		if !next {
+			return m
+		} else {
+			m.AddDay()
+		}
+	}
+
+	var diff int
+	if diff = int(day) - int(m.Day()); diff > 0 {
+		return m.AddDays(diff)
+	}
+
+	return m.AddDays(7 + diff)
+}
+
+// Custom
+func (m *Moment) GoBackTo(day time.Weekday, previous bool) *Moment {
+	if m.Day() == day {
+		if !previous {
+			return m
+		} else {
+			m.SubDay()
+		}
+	}
+
+	var diff int
+	if diff = int(day) - int(m.Day()); diff > 0 {
+		return m.SubDays(7 - diff)
+	}
+
+	return m.SubDays(diff * -1)
+}
+
+// Custom
+func (m *Moment) GoToMonth(month time.Month, next bool) *Moment {
+	if m.Month() == month {
+		if !next {
+			return m
+		} else {
+			m.AddMonths(1)
+		}
+	}
+
+	var diff int
+	if diff = int(month - m.Month()); diff > 0 {
+		return m.AddMonths(diff)
+	}
+
+	return m.AddMonths(12 + diff)
+}
+
+// Custom
+func (m *Moment) GoBackToMonth(month time.Month, previous bool) *Moment {
+	if m.Month() == month {
+		if !previous {
+			return m
+		} else {
+			m.SubMonths(1)
+		}
+	}
+
+	var diff int
+	if diff = int(month) - int(m.Month()); diff > 0 {
+		return m.SubMonths(12 - diff)
+	}
+
+	return m.SubMonths(diff * -1)
+}
+
+func (m *Moment) SetSecond(seconds int) *Moment {
+	if seconds >= 0 && seconds <= 60 {
+		return m.AddSeconds(seconds - m.Second())
+	}
+
+	return m
+}
+
+func (m *Moment) SetMinute(minute int) *Moment {
+	if minute >= 0 && minute <= 60 {
+		return m.AddMinutes(minute - m.Minute())
+	}
+
+	return m
+}
+
+func (m *Moment) SetHour(hour int) *Moment {
+	if hour >= 0 && hour <= 23 {
+		return m.AddHours(hour - m.Hour())
+	}
+
+	return m
+}
+
+// Custom
+func (m *Moment) SetDay(day int) *Moment {
+	if m.DayOfMonth() == day {
+		return m
+	}
+
+	return m.AddDays(day - m.DayOfMonth())
+}
+
+// Custom
+func (m *Moment) SetMonth(month time.Month) *Moment {
+	if m.Month() > month {
+		return m.GoBackToMonth(month, false)
+	}
+
+	return m.GoToMonth(month, false)
+}
+
+// Custom
+func (m *Moment) SetYear(year int) *Moment {
+	if m.Year() == year {
+		return m
+	}
+
+	return m.AddYears(year - m.Year())
+}
+
+// UTC Mode. @see http://momentjs.com/docs/#/parsing/utc/
+func (m *Moment) UTC() *Moment {
+	return m
+}
+
+// http://momentjs.com/docs/#/manipulating/timezone-offset/
+func (m *Moment) Zone() int {
+	_, offset := m.GetTime().Zone()
+
+	return (offset / 60) * -1
+}
+
+/**
+ * Display
+ *
+ */
+func (m *Moment) Format(layout string) string {
+	format := m.Convert(layout)
+	hasCustom := false
+
+	formatted := m.GetTime().Format(format)
+
+	if strings.Contains(formatted, "<std") {
+		hasCustom = true
+		formatted = strings.Replace(formatted, "<stdUnix>", fmt.Sprintf("%d", m.Unix()), -1)
+		formatted = strings.Replace(formatted, "<stdWeekOfYear>", fmt.Sprintf("%d", m.ISOWeek()), -1)
+		formatted = strings.Replace(formatted, "<stdDayOfWeek>", fmt.Sprintf("%d", m.DayOfWeek()), -1)
+		formatted = strings.Replace(formatted, "<stdDayOfWeekISO>", fmt.Sprintf("%d", m.DayOfWeekISO()), -1)
+		formatted = strings.Replace(formatted, "<stdDayOfYear>", fmt.Sprintf("%d", m.DayOfYear()), -1)
+		formatted = strings.Replace(formatted, "<stdQuarter>", fmt.Sprintf("%d", m.Quarter()), -1)
+		formatted = strings.Replace(formatted, "<stdDayOfYearZero>", m.dayOfYearZero(), -1)
+		formatted = strings.Replace(formatted, "<stdHourNoZero>", fmt.Sprintf("%d", m.Hour()), -1)
+	}
+
+	// This has to happen after time.Format
+	if hasCustom && strings.Contains(formatted, "<stdOrdinal>") {
+		formatted = numberRegex.ReplaceAllStringFunc(formatted, func(n string) string {
+			ordinal, _ := strconv.Atoi(strings.Replace(n, "<stdOrdinal>", "", 1))
+			return m.ordinal(ordinal)
+		})
+	}
+
+	return formatted
+}
+
+func (m *Moment) FormatGo(layout string) string {
+	return m.GetTime().Format(layout)
+}
+
+// From Dmytro Shteflyuk @https://groups.google.com/forum/#!topic/golang-nuts/l8NhI74jl-4
+func (m *Moment) ordinal(x int) string {
+	suffix := "th"
+	switch x % 10 {
+	case 1:
+		if x%100 != 11 {
+			suffix = "st"
+		}
+	case 2:
+		if x%100 != 12 {
+			suffix = "nd"
+		}
+	case 3:
+		if x%100 != 13 {
+			suffix = "rd"
+		}
+	}
+
+	return strconv.Itoa(x) + suffix
+}
+
+func (m *Moment) FromNow() Diff {
+	now := new(Moment)
+	now.Now()
+
+	return m.From(now)
+}
+
+// Carbon
+func (m *Moment) From(f *Moment) Diff {
+	return m.GetDiff(f)
+}
+
+/**
+ * Difference
+ *
+ */
+func (m *Moment) Diff(t *Moment, unit string) int {
+	diff := m.GetDiff(t)
+
+	switch unit {
+	case "years":
+		return diff.InYears()
+	case "months":
+		return diff.InMonths()
+	case "weeks":
+		return diff.InWeeks()
+	case "days":
+		return diff.InDays()
+	case "hours":
+		return diff.InHours()
+	case "minutes":
+		return diff.InMinutes()
+	case "seconds":
+		return diff.InSeconds()
+	}
+
+	return 0
+}
+
+// Custom
+func (m *Moment) GetDiff(t *Moment) Diff {
+	duration := m.GetTime().Sub(t.GetTime())
+
+	return Diff{duration}
+}
+
+/**
+ * Display
+ *
+ */
+func (m *Moment) ValueOf() int64 {
+	return m.Unix() * 1000
+}
+
+func (m *Moment) Unix() int64 {
+	return m.GetTime().Unix()
+}
+
+func (m *Moment) DaysInMonth() int {
+	days := 31
+	switch m.Month() {
+	case time.April, time.June, time.September, time.November:
+		days = 30
+		break
+	case time.February:
+		days = 28
+		if m.IsLeapYear() {
+			days = 29
+		}
+		break
+	}
+
+	return days
+}
+
+// or ToSlice?
+func (m *Moment) ToArray() []int {
+	return []int{
+		m.Year(),
+		int(m.Month()),
+		m.DayOfMonth(),
+		m.Hour(),
+		m.Minute(),
+		m.Second(),
+	}
+}
+
+/**
+ * Query
+ *
+ */
+func (m *Moment) IsBefore(t Moment) bool {
+	return m.GetTime().Before(t.GetTime())
+}
+
+func (m *Moment) IsSame(t *Moment, layout string) bool {
+	return m.Format(layout) == t.Format(layout)
+}
+
+func (m *Moment) IsAfter(t Moment) bool {
+	return m.GetTime().After(t.GetTime())
+}
+
+// Carbon
+func (m *Moment) IsToday() bool {
+	today := m.Clone().Today()
+
+	return m.Year() == today.Year() && m.Month() == today.Month() && m.Day() == today.Day()
+}
+
+// Carbon
+func (m *Moment) IsTomorrow() bool {
+	tomorrow := m.Clone().Tomorrow()
+
+	return m.Year() == tomorrow.Year() && m.Month() == tomorrow.Month() && m.Day() == tomorrow.Day()
+}
+
+// Carbon
+func (m *Moment) IsYesterday() bool {
+	yesterday := m.Clone().Yesterday()
+
+	return m.Year() == yesterday.Year() && m.Month() == yesterday.Month() && m.Day() == yesterday.Day()
+}
+
+// Carbon
+func (m *Moment) IsWeekday() bool {
+	return !m.IsWeekend()
+}
+
+// Carbon
+func (m *Moment) IsWeekend() bool {
+	return m.DayOfWeek() == time.Sunday || m.DayOfWeek() == time.Saturday
+}
+
+func (m *Moment) IsLeapYear() bool {
+	year := m.Year()
+	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+}
+
+// Custom
+func (m *Moment) Range(start Moment, end Moment) bool {
+	return m.IsAfter(start) && m.IsBefore(end)
+}

vendor/github.com/leibowitz/moment/moment_parser.go

@@ -0,0 +1,100 @@
+package moment
+
+import (
+	"regexp"
+	"strings"
+)
+
+type MomentParser struct{}
+
+var (
+	date_pattern = regexp.MustCompile("(LT|LL?L?L?|l{1,4}|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|SS?S?|X|zz?|ZZ?|Q)")
+)
+
+/*
+	+	<stdOrdinal> 					S (makes any number before it ordinal)
+	+	stdDayOfYear					1,2,365
+	+	stdDayOfYearZero			001, 002, 365
+	+	stdDayOfWeek					w 0, 1, 2 numeric day of the week (0 = sunday)
+	+	stdDayOfWeekISO				N 1 = Monday
+	+	stdWeekOfYear					W Iso week number of year
+	+	stdUnix								U
+    +   stdQuarter
+*/
+
+// Thanks to https://github.com/fightbulc/moment.php for replacement keys and regex
+var moment_replacements = map[string]string{
+	"M":    "1",                           // stdNumMonth 1 2 ... 11 12
+	"Mo":   "1<stdOrdinal>",               // stdNumMonth 1st 2nd ... 11th 12th
+	"MM":   "01",                          // stdZeroMonth 01 02 ... 11 12
+	"MMM":  "Jan",                         // stdMonth Jan Feb ... Nov Dec
+	"MMMM": "January",                     // stdLongMonth January February ... November December
+	"D":    "2",                           // stdDay 1 2 ... 30 30
+	"Do":   "2<stdOrdinal>",               // stdDay 1st 2nd ... 30th 31st  @todo support st nd th etch
+	"DD":   "02",                          // stdZeroDay 01 02 ... 30 31
+	"DDD":  "<stdDayOfYear>",              // Day of the year 1 2 ... 364 365
+	"DDDo": "<stdDayOfYear><stdOrdinal>",  // Day of the year 1st 2nd ... 364th 365th
+	"DDDD": "<stdDayOfYearZero>",          // Day of the year 001 002 ... 364 365 @todo****
+	"d":    "<stdDayOfWeek>",              // Numeric representation of day of the week 0 1 ... 5 6
+	"do":   "<stdDayOfWeek><stdOrdinal>",  // 0th 1st ... 5th 6th
+	"dd":   "Mon",                         // ***Su Mo ... Fr Sa @todo
+	"ddd":  "Mon",                         // Sun Mon ... Fri Sat
+	"dddd": "Monday",                      // stdLongWeekDay Sunday Monday ... Friday Saturday
+	"e":    "<stdDayOfWeek>",              // Numeric representation of day of the week 0 1 ... 5 6 @todo
+	"E":    "<stdDayOfWeekISO>",           // ISO-8601 numeric representation of the day of the week (added in PHP 5.1.0) 1 2 ... 6 7 @todo
+	"w":    "<stdWeekOfYear>",             // 1 2 ... 52 53
+	"wo":   "<stdWeekOfYear><stdOrdinal>", // 1st 2nd ... 52nd 53rd
+	"ww":   "<stdWeekOfYear>",             // ***01 02 ... 52 53 @todo
+	"W":    "<stdWeekOfYear>",             // 1 2 ... 52 53
+	"Wo":   "<stdWeekOfYear><stdOrdinal>", // 1st 2nd ... 52nd 53rd
+	"WW":   "<stdWeekOfYear>",             // ***01 02 ... 52 53 @todo
+	"YY":   "06",                          // stdYear 70 71 ... 29 30
+	"YYYY": "2006",                        // stdLongYear 1970 1971 ... 2029 2030
+	// "gg"      : "o", 				 // ISO-8601 year number 70 71 ... 29 30 @todo
+	// "gggg"    : "o", // ***1970 1971 ... 2029 2030 @todo
+	// "GG"      : "o", //70 71 ... 29 30 @todo
+	// "GGGG"    : "o", // ***1970 1971 ... 2029 2030 @todo
+	"Q":  "<stdQuarter>",
+	"A":  "PM",              // stdPM AM PM
+	"a":  "pm",              // stdpm am pm
+	"H":  "<stdHourNoZero>", // stdHour 0 1 ... 22 23
+	"HH": "15",              // 00 01 ... 22 23
+	"h":  "3",               // stdHour12 1 2 ... 11 12
+	"hh": "03",              // stdZeroHour12 01 02 ... 11 12
+	"m":  "4",               // stdZeroMinute 0 1 ... 58 59
+	"mm": "04",              // stdZeroMinute 00 01 ... 58 59
+	"s":  "5",               // stdSecond 0 1 ... 58 59
+	"ss": "05",              // stdZeroSecond ***00 01 ... 58 59
+	// "S"       : "", //0 1 ... 8 9
+	// "SS"      : "", //0 1 ... 98 99
+	// "SSS"     : "", //0 1 ... 998 999
+	"z":    "MST",                                        //EST CST ... MST PST
+	"zz":   "MST",                                        //EST CST ... MST PST
+	"Z":    "Z07:00",                                     // stdNumColonTZ -07:00 -06:00 ... +06:00 +07:00
+	"ZZ":   "-0700",                                      // stdNumTZ -0700 -0600 ... +0600 +0700
+	"X":    "<stdUnix>",                                  // Seconds since unix epoch 1360013296
+	"LT":   "3:04 PM",                                    // 8:30 PM
+	"L":    "01/02/2006",                                 //09/04/1986
+	"l":    "1/2/2006",                                   //9/4/1986
+	"LL":   "January 2<stdOrdinal> 2006",                 //September 4th 1986 the php s flag isn't supported
+	"ll":   "Jan 2 2006",                                 //Sep 4 1986
+	"LLL":  "January 2<stdOrdinal> 2006 3:04 PM",         //September 4th 1986 8:30 PM @todo the php s flag isn't supported
+	"lll":  "Jan 2 2006 3:04 PM",                         //Sep 4 1986 8:30 PM
+	"LLLL": "Monday, January 2<stdOrdinal> 2006 3:04 PM", //Thursday, September 4th 1986 8:30 PM the php s flag isn't supported
+	"llll": "Mon, Jan 2 2006 3:04 PM",                    //Thu, Sep 4 1986 8:30 PM
+}
+
+func (p *MomentParser) Convert(layout string) string {
+	var match [][]string
+	if match = date_pattern.FindAllStringSubmatch(layout, -1); match == nil {
+		return layout
+	}
+
+	for i := range match {
+		if replace, ok := moment_replacements[match[i][0]]; ok {
+			layout = strings.Replace(layout, match[i][0], replace, 1)
+		}
+	}
+
+	return layout
+}

vendor/github.com/leibowitz/moment/parse_day.go

@@ -0,0 +1,32 @@
+package moment
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+var (
+	days = []time.Weekday{
+		time.Sunday,
+		time.Monday,
+		time.Tuesday,
+		time.Wednesday,
+		time.Thursday,
+		time.Friday,
+		time.Saturday,
+	}
+)
+
+func ParseWeekDay(day string) (time.Weekday, error) {
+
+	day = strings.ToLower(day)
+
+	for _, d := range days {
+		if day == strings.ToLower(d.String()) {
+			return d, nil
+		}
+	}
+
+	return -1, fmt.Errorf("Unable to parse %s as week day", day)
+}

vendor/github.com/leibowitz/moment/strftime_parser.go

@@ -0,0 +1,68 @@
+package moment
+
+import (
+	"regexp"
+	"strings"
+)
+
+type StrftimeParser struct{}
+
+var (
+	replacements_pattern = regexp.MustCompile("%[mbhBedjwuaAVgyGYpPkHlIMSZzsTrRTDFXx]")
+)
+
+// Not implemented
+// U
+// C
+
+var strftime_replacements = map[string]string{
+	"%m": "01",  // stdZeroMonth 01 02 ... 11 12
+	"%b": "Jan", // stdMonth Jan Feb ... Nov Dec
+	"%h": "Jan",
+	"%B": "January",           // stdLongMonth January February ... November December
+	"%e": "2",                 // stdDay 1 2 ... 30 30
+	"%d": "02",                // stdZeroDay 01 02 ... 30 31
+	"%j": "<stdDayOfYear>",    // Day of the year ***001 002 ... 364 365 @todo****
+	"%w": "<stdDayOfWeek>",    // Numeric representation of day of the week 0 1 ... 5 6
+	"%u": "<stdDayOfWeekISO>", // ISO-8601 numeric representation of the day of the week (added in PHP 5.1.0) 1 2 ... 6 7 @todo
+	"%a": "Mon",               // Sun Mon ... Fri Sat
+	"%A": "Monday",            // stdLongWeekDay Sunday Monday ... Friday Saturday
+	"%V": "<stdWeekOfYear>",   // ***01 02 ... 52 53  @todo begin with zeros
+	"%g": "06",                // stdYear 70 71 ... 29 30
+	"%y": "06",
+	"%G": "2006", // stdLongYear 1970 1971 ... 2029 2030
+	"%Y": "2006",
+	"%p": "PM",        // stdPM AM PM
+	"%P": "pm",        // stdpm am pm
+	"%k": "15",        // stdHour 0 1 ... 22 23
+	"%H": "15",        // 00 01 ... 22 23
+	"%l": "3",         // stdHour12 1 2 ... 11 12
+	"%I": "03",        // stdZeroHour12 01 02 ... 11 12
+	"%M": "04",        // stdZeroMinute 00 01 ... 58 59
+	"%S": "05",        // stdZeroSecond ***00 01 ... 58 59
+	"%Z": "MST",       //EST CST ... MST PST
+	"%z": "-0700",     // stdNumTZ -0700 -0600 ... +0600 +0700
+	"%s": "<stdUnix>", // Seconds since unix epoch 1360013296
+	"%r": "03:04:05 PM",
+	"%R": "15:04",
+	"%T": "15:04:05",
+	"%D": "01/02/06",
+	"%F": "2006-01-02",
+	"%X": "15:04:05",
+	"%x": "01/02/06",
+}
+
+func (p *StrftimeParser) Convert(layout string) string {
+	var match [][]string
+	if match = replacements_pattern.FindAllStringSubmatch(layout, -1); match == nil {
+		return layout
+	}
+
+	for i := range match {
+		if replace, ok := strftime_replacements[match[i][0]]; ok {
+			layout = strings.Replace(layout, match[i][0], replace, 1)
+		}
+	}
+
+	return layout
+}