202 lines
4.5 KiB
Go
202 lines
4.5 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
)
|
|
|
|
func renderYear() string {
|
|
|
|
// Get Current time
|
|
var ct time.Time
|
|
var offset int
|
|
ct, offset = getCurrentTime()
|
|
|
|
// So what the following does is
|
|
// Add one year to the current time (and call it next year)
|
|
// Get the start of this year
|
|
// Get the start of the next year
|
|
|
|
// The New Year
|
|
ny := ct.AddDate(1, 0, 0)
|
|
|
|
// Get the start of this and next year
|
|
t1 := startYear(ct.Year(), 1, 1)
|
|
t2 := startYear(ny.Year(), 1, 1)
|
|
|
|
// Subtract the current year in seconds from next year, in seconds.
|
|
// This will leave us with the total year in seconds
|
|
// I do this in case there is a leap-year,
|
|
// or some dodgy science reason to add 30 seconds to a day.
|
|
seconds := t2.Sub(t1).Seconds()
|
|
|
|
// From the current time, subtract the start of this year, in seconds.
|
|
// This should leave us with how far we are into the year, in seconds.
|
|
tdiff := ct.Sub(t1).Seconds()
|
|
|
|
// Calculate the percentages
|
|
percentage := calcPercentageFloat64(seconds, tdiff+float64(offset))
|
|
|
|
// Wrap things up
|
|
var render string
|
|
render = renderPercentage(percentage)
|
|
render = render + fmt.Sprintf(" %.7f%%", percentage)
|
|
|
|
return render
|
|
}
|
|
|
|
func renderDay() string {
|
|
|
|
// Get Current time
|
|
var ct time.Time
|
|
var offset int
|
|
ct, offset = getCurrentTime()
|
|
|
|
// Get the Start of the Day
|
|
sd := time.Date(ct.Year(), ct.Month(), ct.Day(), 0, 0, 0, 0, time.UTC)
|
|
|
|
// Get the End of the Day
|
|
ed := ct.AddDate(0, 0, 1)
|
|
ed = time.Date(ed.Year(), ed.Month(), ed.Day(), 0, 0, 0, 0, time.UTC)
|
|
|
|
// From the end of the day, subtract the end of the day to get the number of seconds.
|
|
// Normally this would be 86400, thanks to science this may change.
|
|
// Think Leap Seconds
|
|
//
|
|
// Get the current number of seconds into the day
|
|
seconds_total := ed.Sub(sd).Seconds()
|
|
seconds_tmp := ed.Sub(ct).Seconds()
|
|
seconds_current := seconds_total - seconds_tmp
|
|
|
|
// Calculate the percentages
|
|
percentage := calcPercentageFloat64(seconds_total, seconds_current+float64(offset))
|
|
|
|
// Wrap everything up
|
|
var render string
|
|
render = renderPercentage(percentage)
|
|
render = render + fmt.Sprintf(" %.7f%%", percentage)
|
|
|
|
return render
|
|
}
|
|
|
|
func renderCustom(t1 time.Time, t2 time.Time) string {
|
|
|
|
var ct time.Time
|
|
var offset int
|
|
ct, offset = getCurrentTime()
|
|
|
|
seconds := t2.Sub(t1).Seconds()
|
|
tdiff := ct.Sub(t1).Seconds()
|
|
|
|
percentage := calcPercentageFloat64(seconds, tdiff+float64(offset))
|
|
|
|
var render string
|
|
render = renderPercentage(percentage)
|
|
render = render + fmt.Sprintf(" %.7f%%", percentage)
|
|
|
|
return render
|
|
|
|
}
|
|
|
|
func getCurrentTime() (time.Time, int) {
|
|
// Declarations
|
|
var offset int
|
|
var loc *time.Location
|
|
var err error
|
|
|
|
// Current Time
|
|
ct := time.Now()
|
|
|
|
// Get the offset from whatever the system timezone is
|
|
_, offset = ct.Local().Zone()
|
|
|
|
// Make sure that the time is in UTC, so the offset makes sense
|
|
loc, err = time.LoadLocation("UTC")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
ct = ct.In(loc)
|
|
|
|
// Return things
|
|
return ct, offset
|
|
}
|
|
|
|
// displayPercentage Print a string of blocks simulating percentages
|
|
func renderPercentage(percentage float64) string {
|
|
|
|
var counter int
|
|
var balk string
|
|
|
|
for percentage > 2 {
|
|
balk = balk + "▓"
|
|
percentage = percentage - 2
|
|
counter++
|
|
}
|
|
|
|
if percentage < 2 {
|
|
balk = balk + "▒"
|
|
counter++
|
|
}
|
|
|
|
for counter < 50 {
|
|
balk = balk + "░"
|
|
counter++
|
|
}
|
|
|
|
return balk
|
|
}
|
|
|
|
// Get the percentages between two float64s
|
|
func calcPercentageFloat64(full float64, part float64) float64 {
|
|
var percentage float64
|
|
percentage = part / (full / 100)
|
|
if percentage >= 100 {
|
|
percentage = percentage - 100
|
|
}
|
|
return percentage
|
|
}
|
|
|
|
// Get the start of the year.
|
|
func startYear(year, month, day int) time.Time {
|
|
return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
|
|
}
|
|
|
|
func main() {
|
|
|
|
var dayFlag = flag.Bool("day", true, "Display progress of the day.")
|
|
var yearFlag = flag.Bool("year", true, "Display progress of this year.")
|
|
|
|
var customFlag = flag.Bool("custom", false, "Display a custom range")
|
|
var customStart = flag.String("custom-start", "", "Start of the custom range")
|
|
var customStop = flag.String("custom-stop", "", "Start of the custom range")
|
|
|
|
flag.Parse()
|
|
|
|
if *dayFlag {
|
|
fmt.Println(renderDay())
|
|
}
|
|
|
|
if *yearFlag {
|
|
fmt.Println(renderYear())
|
|
}
|
|
|
|
if *customFlag {
|
|
|
|
bt, err := time.Parse(time.RFC3339, *customStart)
|
|
if err != nil {
|
|
log.Fatalln("Error parsing start time: ", err)
|
|
}
|
|
|
|
pa, err := time.Parse(time.RFC3339, *customStop)
|
|
if err != nil {
|
|
log.Fatalln("Error parsing stop time: ", err)
|
|
}
|
|
|
|
fmt.Println(renderCustom(bt, pa))
|
|
|
|
}
|
|
|
|
}
|