local_time 3.0.2 → 3.0.3

data/test/javascripts/src/format24_test.js

@@ -0,0 +1,109 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, testAsync, testGroup, getTitle } = LocalTime.TestHelpers
+const { config } = LocalTime
+
+testGroup("format24 (24h time)", () => {
+  testAsync("default behavior", (done) => {
+    const now = moment()
+
+    const el = addTimeEl({ format: "%-l:%M%P", format24: "%H:%M", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("h:mma"))
+      done()
+    })
+  })
+
+  testAsync("turned off", (done) => {
+    const now = moment()
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = false
+
+    const el = addTimeEl({ format: "%-l:%M%P", format24: "%H:%M", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("h:mma"))
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("turned on", (done) => {
+    const now = moment()
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = true
+
+    const el = addTimeEl({ format: "%-l:%M%P", format24: "%H:%M", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("HH:mm"))
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("fallback for missing data-format24 values", (done) => {
+    const now = moment()
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = true
+
+    const el = addTimeEl({ format: "%-l:%M%P", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("h:mma"))
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("turned off for relative time elements", (done) => {
+    const ago = moment().subtract("days", 5)
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = false
+
+    const el = addTimeEl({ type: "time-ago", datetime: ago.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), `${ago.format("dddd")} at ${ago.format("h:mma")}`)
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("turned on for relative time elements", (done) => {
+    const ago = moment().subtract("days", 5)
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = true
+
+    const el = addTimeEl({ type: "time-ago", datetime: ago.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), `${ago.format("dddd")} at ${ago.format("HH:mm")}`)
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("element title when turned off", (done) => {
+    const ago = moment().subtract("days", 5)
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = false
+
+    const el = addTimeEl({ type: "time-ago", datetime: ago.toISOString() })
+    defer(() => {
+      const regex = new RegExp(ago.format('MMMM D, YYYY [at] h:mma') + " (\\w{3,4}|UTC[+-]d+)")
+      assert.ok(regex.test(getTitle(el)), `'${getTitle(el)}' doesn't look correct, it should match regex ${regex}`)
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+
+  testAsync("element title when turned on", (done) => {
+    const ago = moment().subtract("days", 5)
+    const originalFormat24 = config.useFormat24
+    config.useFormat24 = true
+
+    const el = addTimeEl({ type: "time-ago", datetime: ago.toISOString() })
+    defer(() => {
+      const regex = new RegExp(ago.format('MMMM D, YYYY [at] HH:mm') + " (\\w{3,4}|UTC[+-]d+)")
+      assert.ok(regex.test(getTitle(el)), `'${getTitle(el)}' doesn't look correct, it should match regex ${regex}`)
+      config.useFormat24 = originalFormat24
+      done()
+    })
+  })
+})

data/test/javascripts/src/i18n_test.js

@@ -0,0 +1,55 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, setText, test, testAsync, testGroup, triggerEvent } = LocalTime.TestHelpers
+const { config } = LocalTime
+const { i18n } = config
+
+testGroup("i18n", () => {
+  testAsync("updating a value", (done) => {
+    const now = moment()
+    const values = i18n[config.defaultLocale].date
+
+    const originalValue = values.today
+    values.today = "2day"
+
+    const el = addTimeEl({ type: "weekday", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "2day")
+      values.today = originalValue
+      done()
+    })
+  })
+
+  testAsync("adding a new locale", (done) => {
+    const now = moment()
+
+    const originalLocale = config.locale
+    config.locale = "es"
+    i18n.es = { date: { today: "hoy" } }
+
+    const el = addTimeEl({ type: "weekday", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "hoy")
+      config.locale = originalLocale
+      done()
+    })
+  })
+
+  testAsync("falling back to the default locale", (done) => {
+    const now = moment()
+    const yesterday = moment().subtract("days", 1)
+
+    const originalLocale = config.locale
+    config.locale = "es"
+    i18n.es = { date: { yesterday: "ayer" } }
+
+    const elWithTranslation = addTimeEl({ type: "weekday", datetime: yesterday.toISOString() })
+    const elWithoutTranslation = addTimeEl({ type: "weekday", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(elWithTranslation), "ayer")
+      assert.equal(getText(elWithoutTranslation), "today")
+      config.locale = originalLocale
+      done()
+    })
+  })
+})

data/test/javascripts/src/local_time_test.js

@@ -0,0 +1,54 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, setText, test, testAsync, testGroup, triggerEvent } = LocalTime.TestHelpers
+
+testGroup("localized", () => {
+  for (var id of [ "one", "two", "past", "future" ]) {
+    test(id, () => {
+      assertLocalized(id)
+    })
+  }
+
+  test("date", () => {
+    assertLocalized("date", "date")
+  })
+
+  test("unparseable time", () => {
+    const el = addTimeEl({ format: "%Y", datetime: ":(" })
+    setText(el, "2013")
+    assert.equal(getText(el), "2013")
+  })
+})
+
+test("processed timestamp", () => {
+  const el = addTimeEl({ type: "time-or-date", datetime: moment().toISOString() })
+  assert.notOk(el.getAttribute("data-processed-at"))
+  LocalTime.run()
+  assert.ok(el.getAttribute("data-processed-at"))
+})
+
+function assertLocalized(id, type = "time") {
+  let compare, datetime, local, momentFormat
+  switch (type) {
+    case "time":
+      momentFormat = "MMMM D, YYYY h:mma"
+      compare = "toString"
+      break
+    case "date":
+      momentFormat = "MMMM D, YYYY"
+      compare = "dayOfYear"
+      break
+  }
+
+  const el = document.getElementById(id)
+
+  assert.ok(datetime = el.getAttribute("datetime"))
+  assert.ok(local = getText(el))
+
+  const datetimeParsed = moment(datetime)
+  const localParsed = moment(local, momentFormat)
+
+  assert.ok(datetimeParsed.isValid())
+  assert.ok(localParsed.isValid())
+  assert.equal(datetimeParsed[compare](), localParsed[compare]())
+}

data/test/javascripts/src/relative_date_test.js

@@ -0,0 +1,121 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, testAsync, testGroup, stubNow } = LocalTime.TestHelpers
+
+testGroup("relative date", () => {
+  testAsync("this year", (done) => {
+    const now = moment()
+    const el = addTimeEl({ type: "date", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("MMM D"))
+      done()
+    })
+  })
+
+  testAsync("last year", (done) => {
+    const before = moment().subtract("years", 1).subtract("days", 1)
+    const el = addTimeEl({ type: "date", datetime: before.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), before.format("MMM D, YYYY"))
+      done()
+    })
+  })
+})
+
+testGroup("relative time or date", () => {
+  testAsync("today", (done) => {
+    const now = moment()
+    const el = addTimeEl({ type: "time-or-date", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), now.format("h:mma"))
+      done()
+    })
+  })
+
+  testAsync("before today", (done) => {
+    const before = moment().subtract("days", 1)
+    const el = addTimeEl({ type: "time-or-date", datetime: before.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), before.format("MMM D"))
+      done()
+    })
+  })
+})
+
+testGroup("relative weekday", () => {
+  testAsync("today", (done) => {
+    const now = moment()
+    const el = addTimeEl({ type: "weekday", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "today")
+      done()
+    })
+  })
+
+  testAsync("yesterday", (done) => {
+    const yesterday = moment().subtract("days", 1)
+    const el = addTimeEl({ type: "weekday", datetime: yesterday.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "yesterday")
+      done()
+    })
+  })
+
+  testAsync("this week", (done) => {
+    const recent = moment().subtract("days", 3)
+    const el = addTimeEl({ type: "weekday", datetime: recent.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), recent.format("dddd"))
+      done()
+    })
+  })
+
+  testAsync("before this week", (done) => {
+    const before = moment().subtract("days", 8)
+    const el = addTimeEl({ type: "weekday", datetime: before.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "")
+      done()
+    })
+  })
+})
+
+testGroup("relative weekday or date", () => {
+  testAsync("today", (done) => {
+    const now = moment()
+    const el = addTimeEl({ type: "weekday-or-date", datetime: now.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "today")
+      done()
+    })
+  })
+
+  testAsync("yesterday", (done) => {
+    const yesterday = moment().subtract("days", 1)
+    const el = addTimeEl({ type: "weekday-or-date", datetime: yesterday.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), "yesterday")
+      done()
+    })
+  })
+
+  testAsync("this week", (done) => {
+    const recent = moment().subtract("days", 3)
+    const el = addTimeEl({ type: "weekday-or-date", datetime: recent.toISOString() })
+    defer(() => {
+      assert.equal(getText(el), recent.format("dddd"))
+      done()
+    })
+  })
+
+  testAsync("before this week", (done) => {
+    stubNow(`${moment().year()}-03-20`, () => {
+      const before = moment().subtract("days", 8)
+      const el = addTimeEl({ type: "weekday-or-date", datetime: before.toISOString() })
+      defer(() => {
+        assert.equal(getText(el), before.format("MMM D"))
+        done()
+      })
+    })
+  })
+})

data/test/javascripts/src/strftime_test.js

@@ -0,0 +1,151 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, setText, test, testAsync, testGroup, triggerEvent } = LocalTime.TestHelpers
+
+const momentMap = {
+  "%a": "ddd",
+  "%A": "dddd",
+  "%b": "MMM",
+  "%B": "MMMM",
+  "%c": "toString()",
+  "%d": "DD",
+  "%-d": "D",
+  "%e": "D",
+  "%H": "HH",
+  "%-H": "H",
+  "%I": "hh",
+  "%-I": "h",
+  "%l": "h",
+  "%m": "MM",
+  "%-m": "M",
+  "%M": "mm",
+  "%-M": "m",
+  "%p": "A",
+  "%P": "a",
+  "%S": "ss",
+  "%-S": "s",
+  "%w": "e",
+  "%y": "YY",
+  "%Y": "YYYY"
+}
+
+function stubDateToLocaleString(stubImplementation, callback) {
+  const original = Date.prototype.toLocaleString
+  Date.prototype.toLocaleString = stubImplementation
+  try {
+    return callback()
+  } finally {
+    Date.prototype.toLocaleString = original
+  }
+}
+
+function stubDateToString(stubImplementation, callback) {
+  const original = Date.prototype.toString
+  Date.prototype.toString = stubImplementation
+  try {
+    return callback()
+  } finally {
+    Date.prototype.toString = original
+  }
+}
+
+testGroup("strftime", () => {
+  for (let day = 0; day <= 30; day += 6) {
+    for (let hour = 0; hour <= 24; hour += 6) {
+      for (const format in momentMap) {
+        if (Object.prototype.hasOwnProperty.call(momentMap, format)) {
+          const momentFormat = momentMap[ format ]
+
+          test(`${format} (+${day} days, ${hour} hours)`, () => {
+            const now = moment().add("days", day).add("hours", hour)
+            const el = addTimeEl({ format, datetime: now.toISOString() })
+            LocalTime.process(el)
+
+            if (momentFormat.includes("toString()")) {
+              assert.equal(getText(el), now.toDate().toString())
+            } else {
+              assert.equal(getText(el), now.format(momentFormat))
+            }
+          })
+        }
+      }
+
+      test(`%Z Timezone (+${day} days, ${hour} hours)`, () => {
+        const now = moment().add("days", day).add("hours", hour)
+        const el = addTimeEl({ format: "%Z", datetime: now.toISOString() })
+        LocalTime.process(el)
+
+        const text = getText(el)
+        assert.ok(/^(\w{3,4}|UTC[\+\-]\d+)$/.test(text), `'${text}' doesn't look like a timezone. System date: '${new Date}'`)
+      })
+    }
+  }
+})
+
+testGroup("strftime time zones", () => {
+  for (var timeZone of Array.from(Object.keys(LocalTime.knownEdgeCaseTimeZones))) {
+    ((timeZone => test(`edge-case time zone ${timeZone}`, () => {
+      const stub = () => `Thu Nov 30 2023 14:22:57 GMT-0000 (${timeZone})`
+
+      stubDateToLocaleString(stub, () => {
+        const el = addTimeEl({ format: "%Z", datetime: "2023-11-30T14:22:57Z" })
+        LocalTime.process(el)
+
+        assert.equal(getText(el), LocalTime.knownEdgeCaseTimeZones[timeZone])
+      })
+    })))(timeZone)
+  }
+
+  test("time zones Intl can abbreviate are parsed correctly", () => {
+    const stub = (_, options) => {
+      if (options.timeZoneName === "long") {
+        return "Thu Nov 30 2023 14:22:57 GMT-0800 (Alaska Daylight Time)" // not a known edge-case
+      } else if (options.timeZoneName === "short") {
+        return "11/30/2023, 2:22:57 PM AKDT" // possible to abbreviate
+      }
+    }
+
+    stubDateToLocaleString(stub, () => {
+      const el = addTimeEl({ format: "%Z", datetime: "2023-11-30T14:22:57Z" })
+      LocalTime.process(el)
+
+      assert.equal(getText(el), "AKDT")
+    })
+  })
+
+  test("time zones Intl can't abbreviate are parsed by our heuristic", () => {
+    const dateToStringStub = () => "Sat Dec 02 2023 17:20:26 GMT-0600 (Central Standard Time)"
+    const dateToLocaleStringStub = (_, options) => {
+      if (options.timeZoneName === "long") {
+        return "Thu Nov 30 2023 14:22:57 GMT+0700 (Central Twilight Time)" // not a known edge-case
+      } else if (options.timeZoneName === "short") {
+        return "11/30/2023, 2:22:57 PM GMT+7" // not possible to abbreviate
+      }
+    }
+
+    stubDateToString(dateToStringStub, () => stubDateToLocaleString(dateToLocaleStringStub, () => {
+      const el = addTimeEl({ format: "%Z", datetime: "2023-11-30T14:22:57Z" })
+      LocalTime.process(el)
+
+      assert.equal(getText(el), "CST")
+    }))
+  })
+
+  test("time zones Intl can't abbreviate and our heuristic can't parse display GMT offset", () => {
+    const dateToStringStub = () => ""
+    const dateToLocaleStringStub = (_, options) => {
+      if (options.timeZoneName === "long") {
+        return "Thu Nov 30 2023 14:22:57 GMT+0700 (Central Twilight Time)" // not a known edge-case
+      } else if (options.timeZoneName === "short") {
+        return "11/30/2023, 2:22:57 PM GMT+7" // not possible to abbreviate
+      }
+    }
+
+    stubDateToString(dateToStringStub, () => stubDateToLocaleString(dateToLocaleStringStub, () => {
+      const el = addTimeEl({ format: "%Z", datetime: "2023-11-30T14:22:57Z" })
+      LocalTime.process(el)
+
+      assert.equal(getText(el), "GMT+7")
+    }))
+  })
+})

data/test/javascripts/src/test_helpers.js

@@ -0,0 +1,66 @@
+import LocalTime from "local_time"
+
+LocalTime.start()
+
+LocalTime.TestHelpers = {
+  assert: QUnit.assert,
+  testGroup: QUnit.module,
+  test: QUnit.test,
+
+  testAsync(name, callback) {
+    QUnit.test(name, (assert) => {
+      const done = assert.async()
+      callback(done)
+    })
+  },
+
+  addTimeEl(param = {}) {
+    let { format, type, datetime, format24 } = param
+    if (!format) format = "%Y"
+    if (!type) type = "time"
+    if (!datetime) datetime = "2013-11-12T12:13:00Z"
+
+    const el = document.createElement("time")
+    el.setAttribute("data-local", type)
+    el.setAttribute("data-format", format)
+    el.setAttribute("datetime", datetime)
+    if (format24) el.setAttribute("data-format24", format24)
+
+    document.body.appendChild(el)
+    return el
+  },
+
+  setText(el, text) {
+    el.textContent = text
+  },
+
+  getText(el) {
+    // innerHTML works in all browsers so using it ensures we're
+    // reading the text content, not a potentially arbitrary property.
+    return el.innerHTML
+  },
+
+  getTitle(el) {
+    return el.getAttribute("title")
+  },
+
+  triggerEvent(name, el = document) {
+    const event = document.createEvent("Events")
+    event.initEvent(name, true, true)
+    el.dispatchEvent(event)
+  },
+
+  defer(callback) {
+    setTimeout(callback, 1)
+  },
+
+  stubNow(dateString, callback) {
+    const originalNow = moment.now
+    try {
+      moment.now = () => new Date(dateString).getTime()
+      callback()
+    } finally {
+      moment.now = originalNow
+    }
+  }
+}

data/test/javascripts/src/time_ago_test.js

@@ -0,0 +1,72 @@
+import LocalTime from "local_time"
+
+const { addTimeEl, assert, defer, getText, setText, test, testAsync, testGroup, triggerEvent } = LocalTime.TestHelpers
+
+testGroup("time ago", () => {
+  test("a second ago", () => {
+    assertTimeAgo("a second ago", "seconds", 9)
+  })
+
+  test("seconds ago", () => {
+    assertTimeAgo("44 seconds ago", "seconds", 44)
+  })
+
+  test("a minute ago", () => {
+    assertTimeAgo("a minute ago", "seconds", 89)
+  })
+
+  test("minutes ago", () => {
+    assertTimeAgo("44 minutes ago", "minutes", 44)
+  })
+
+  test("an hour ago", () => {
+    assertTimeAgo("an hour ago", "minutes", 89)
+  })
+
+  test("hours ago", () => {
+    assertTimeAgo("23 hours ago", "hours", 23)
+  })
+
+  test("yesterday", () => {
+    const time = moment().subtract("days", 1).format("h:mma")
+    assertTimeAgo(`yesterday at ${time}`, "days", 1)
+  })
+
+  test("tomorrow", () => {
+    const time = moment().add("days", 1).format("h:mma")
+    assertTimeAgo(`tomorrow at ${time}`, "days", -1)
+  })
+
+  test("last week", () => {
+    const ago = moment().subtract("days", 5)
+    const day = ago.format("dddd")
+    const time = ago.format("h:mma")
+
+    assertTimeAgo(`${day} at ${time}`, "days", 5)
+  })
+
+  test("this year", () => {
+    const clock = sinon.useFakeTimers(new Date(2013, 11, 11, 11, 11).getTime(), "Date")
+    const date = moment().subtract("days", 7).format("MMM D")
+    assertTimeAgo(`on ${date}`, "days", 7)
+    clock.restore()
+  })
+
+  test("last year", () => {
+    const date = moment().subtract("days", 366).format("MMM D, YYYY")
+    assertTimeAgo(`on ${date}`, "days", 366)
+  })
+
+  test("next year", () => {
+    const date = moment().add("days", 366).format("MMM D, YYYY")
+    assertTimeAgo(`on ${date}`, "days", -366)
+  })
+})
+
+function assertTimeAgo(string, unit, amount) {
+  const el = document.getElementById("ago")
+  el.setAttribute("data-local", "time-ago")
+  el.setAttribute("datetime", moment().subtract(unit, amount).utc().toISOString())
+  LocalTime.run()
+  assert.equal(getText(el), string)
+}