rails-diff-time 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0df096d6ed881a33af5f513b00298f22b6e689d95b0f473682941e8d6eadc8a5
-  data.tar.gz: e325fa3d700ef58840ca6eaca3bd0c5148aaf4c809136ca4693b174966ed9829
+  metadata.gz: 9748702954e4f33f487e7ad5a8c657b89bbcc9966cfe384f0791fb2c60428b6e
+  data.tar.gz: dcd1fee4443c63efeab7d4acc4742a2e3dd9e042ec0ce4fae7a8c6fd68809e51
 SHA512:
-  metadata.gz: 556b016fb84ba4f42836b2cbe46db4691e50b96665a125314791e8aff55e7df0abfb3f30a1fbeca6aeb972c890672a750a376b2473571b43527de64b9f080100
-  data.tar.gz: a3c3921bf4231dcccd71a0979b7aff25bcefbf9f845906cb4b724e23f677ddec18496ca2c72250a1af62616a3104175fce2e0b847bfa965f41b88be299c6862c
+  metadata.gz: 3690429964d2704bf55479a1fae0083f46924a7098d3e24aa81899f3a0cebfe3f83feca3ae8ccf854e16928fae4799ce88e559561a49dc67d178d0aabb5c4aaf
+  data.tar.gz: ca7e1e72f9d52fa0da0fcceaa28921f73b90453098beea0ae7723c1bf6287cc94826a588a7bd182790871477ce6905e7a8bc20aef35fe83e39b32d663212d575

data/app/views/rails-diff-time/_diff_time.html.erb

@@ -1,8 +1,14 @@
 <%
-  _element_name ||= locals[:element_name] || "span"
-  _diff_time = locals[:diff_time]
-  _attributes ||= locals[:attributes] || {}
+  element_name ||= locals[:element_name] || "span"
+  diff_time = locals[:diff_time]
+  attributes ||= locals[:attributes] || {}
+  certain_time = locals[:certain_time]
+  auto_update = locals[:auto_update]
+
+  if auto_update
+    attributes[:data] ||= {}
+    attributes[:data][:diff_time_target] = "display"
+    attributes[:data][:certain_time] = certain_time.iso8601
+  end
 %>
-<% if _diff_time %>
-  <%= content_tag(_element_name.to_sym, _diff_time, _attributes) %>
-<% end %>
+<%= content_tag(element_name.to_sym, diff_time, attributes) %>

data/lib/rails/diff/time/engine.rb

@@ -14,4 +14,4 @@ module RailsDiffTime
       end
     end
   end
-end
+end

data/lib/rails/diff/time/helpers.rb

@@ -2,32 +2,229 @@
 
 module RailsDiffTime
   # Helper methods for displaying time differences in a human-readable format.
-  #
-  # This module provides methods to format time differences as relative strings
-  # (e.g., "2 hours ago", "3 days later") and integrates with Rails views.
-  # The helpers can be used directly in templates or through the provided
-  # render helper method.
-  #
-  # @example Usage in a Rails view
-  #   <%= diff_time(user.created_at) %>
-  #   <%= diff_time(event.start_time, "div", class: "timestamp") %>
   module Helpers
-    def diff_time(certain_time, element_name = "span", attributes = {})
-      render "rails-diff-time/diff_time", locals: {
+    def diff_time(certain_time, element_name = "span", attributes = {}, auto_update: false)
+      return "" if certain_time.nil?
+
+      result = render "rails-diff-time/diff_time", locals: {
         diff_time: diff_time_str(certain_time),
         element_name: element_name,
-        attributes: attributes
+        attributes: attributes,
+        certain_time: certain_time,
+        auto_update: auto_update
       }
+
+      # If auto_update is enabled and the script has not been included yet
+      if auto_update && !@_diff_time_script_included
+        @_diff_time_script_included = true
+        result = result + diff_time_script_tag
+      end
+
+      result
     end
 
     private
 
+    def diff_time_script_tag
+      javascript_tag do
+        <<~JAVASCRIPT.html_safe
+          (function() {
+            'use strict';
+            
+            class DiffTimeUpdater {
+              constructor() {
+                this.updateInterval = 60000;
+                this.elements = [];
+                this.timerId = null;
+              }
+              
+              init() {
+                this.findElements();
+                if (this.elements.length > 0) {
+                  this.startAutoUpdate();
+                }
+              }
+              
+              findElements() {
+                this.elements = Array.from(
+                  document.querySelectorAll('[data-diff-time-target="display"]')
+                );
+              }
+              
+              startAutoUpdate() {
+                if (this.timerId) clearInterval(this.timerId);
+                this.timerId = setInterval(() => this.updateAll(), this.updateInterval);
+              }
+              
+              updateAll() {
+                this.elements.forEach(element => this.updateElement(element));
+              }
+              
+              updateElement(element) {
+                const certainTimeStr = element.dataset.certainTime;
+                if (!certainTimeStr) return;
+                const certainTime = new Date(certainTimeStr);
+                const diffTimeStr = this.calculateDiffTime(certainTime);
+                element.textContent = diffTimeStr;
+              }
+              
+              calculateDiffTime(certainTime) {
+                const now = new Date();
+                const diff = certainTime - now;
+                const differenceInSeconds = Math.abs(diff) / 1000;
+                
+                if (differenceInSeconds <= 5) return "now";
+                
+                const isLater = diff > 0;
+                
+                if (differenceInSeconds >= this.yearInSeconds()) {
+                  return this.formatYears(differenceInSeconds, isLater);
+                } else if (differenceInSeconds >= this.monthInSeconds()) {
+                  return this.formatMonths(differenceInSeconds, isLater);
+                } else if (differenceInSeconds >= this.weekInSeconds()) {
+                  return this.formatWeeks(differenceInSeconds, isLater);
+                } else if (differenceInSeconds >= this.dayInSeconds()) {
+                  return this.formatDays(differenceInSeconds, isLater);
+                } else if (differenceInSeconds >= this.hourInSeconds()) {
+                  return this.formatHours(differenceInSeconds, isLater);
+                } else if (differenceInSeconds >= this.minuteInSeconds()) {
+                  return this.formatMinutes(differenceInSeconds, isLater);
+                } else {
+                  return this.formatSeconds(differenceInSeconds, isLater);
+                }
+              }
+              
+              formatYears(seconds, isLater) {
+                const years = Math.floor(seconds / this.yearInSeconds());
+                let remaining = seconds - (years * this.yearInSeconds());
+                let result = this.timeStr(years, "year");
+                
+                if (remaining >= this.monthInSeconds()) {
+                  const months = Math.floor(remaining / this.monthInSeconds());
+                  remaining -= months * this.monthInSeconds();
+                  result += ` ${this.timeStr(months, "month")}`;
+                  
+                  if (remaining >= this.dayInSeconds()) {
+                    const days = Math.floor(remaining / this.dayInSeconds());
+                    result += ` ${this.timeStr(days, "day")}`;
+                  }
+                }
+                return `${result} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatMonths(seconds, isLater) {
+                const months = Math.floor(seconds / this.monthInSeconds());
+                const remaining = seconds - (months * this.monthInSeconds());
+                let result = this.timeStr(months, "month");
+                
+                if (remaining >= this.dayInSeconds()) {
+                  const days = Math.floor(remaining / this.dayInSeconds());
+                  result += ` ${this.timeStr(days, "day")}`;
+                }
+                return `${result} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatWeeks(seconds, isLater) {
+                const weeks = Math.floor(seconds / this.weekInSeconds());
+                return `${this.timeStr(weeks, "week")} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatDays(seconds, isLater) {
+                const days = Math.floor(seconds / this.dayInSeconds());
+                return `${this.timeStr(days, "day")} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatHours(seconds, isLater) {
+                const hours = Math.floor(seconds / this.hourInSeconds());
+                const remaining = seconds - (hours * this.hourInSeconds());
+                let result = this.timeStr(hours, "hour");
+                
+                if (remaining >= this.minuteInSeconds()) {
+                  const minutes = Math.floor(remaining / this.minuteInSeconds());
+                  result += ` ${this.timeStr(minutes, "minute")}`;
+                }
+                return `${result} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatMinutes(seconds, isLater) {
+                const minutes = Math.floor(seconds / this.minuteInSeconds());
+                const remaining = seconds - (minutes * this.minuteInSeconds());
+                let result = this.timeStr(minutes, "minute");
+                
+                if (remaining > 0) {
+                  const secs = Math.floor(remaining);
+                  result += ` ${this.timeStr(secs, "second")}`;
+                }
+                return `${result} ${this.agoOrLater(isLater)}`;
+              }
+              
+              formatSeconds(seconds, isLater) {
+                const secs = Math.floor(seconds);
+                return `${this.timeStr(secs, "second")} ${this.agoOrLater(isLater)}`;
+              }
+              
+              yearInSeconds() { return 365.25 * 24 * 3600; }
+              monthInSeconds() { return 30 * 24 * 3600; }
+              weekInSeconds() { return 7 * 24 * 3600; }
+              dayInSeconds() { return 24 * 3600; }
+              hourInSeconds() { return 3600; }
+              minuteInSeconds() { return 60; }
+              
+              agoOrLater(isLater) { return isLater ? "later" : "ago"; }
+              
+              timeStr(count, singular) {
+                const plural = singular + "s";
+                return `${count} ${count === 1 ? singular : plural}`;
+              }
+              
+              destroy() {
+                if (this.timerId) {
+                  clearInterval(this.timerId);
+                  this.timerId = null;
+                }
+                this.elements = [];
+              }
+            }
+            
+            let updater = null;
+            
+            function initUpdater() {
+              if (updater) updater.destroy();
+              updater = new DiffTimeUpdater();
+              updater.init();
+            }
+            
+            if (document.readyState === 'loading') {
+              document.addEventListener('DOMContentLoaded', initUpdater);
+            } else {
+              initUpdater();
+            }
+            
+            document.addEventListener('turbolinks:load', initUpdater);
+            document.addEventListener('turbo:load', initUpdater);
+            
+            document.addEventListener('turbolinks:before-cache', function() {
+              if (updater) updater.destroy();
+            });
+            
+            document.addEventListener('turbo:before-cache', function() {
+              if (updater) updater.destroy();
+            });
+            
+            window.RailsDiffTime = {
+              updater: updater,
+              DiffTimeUpdater: DiffTimeUpdater
+            };
+          })();
+        JAVASCRIPT
+      end
+    end
+
     def diff_time_str(certain_time)
       now = ::Time.now
       diff = certain_time - now
       difference_in_seconds = diff.abs
 
-      # Display "now" if within 5 seconds
       return "now" if difference_in_seconds <= 5
 
       case difference_in_seconds
@@ -118,13 +315,12 @@ module RailsDiffTime
       "#{time_str(seconds, "second")} #{ago_or_later(diff)}"
     end
 
-    # Time unit constant methods
     def year_in_seconds
-      365.25 * 24 * 3600 # Considering leap years
+      365.25 * 24 * 3600
     end
 
     def month_in_seconds
-      30 * 24 * 3600 # Average 30 days
+      30 * 24 * 3600
     end
 
     def week_in_seconds
@@ -143,7 +339,6 @@ module RailsDiffTime
       60
     end
 
-    # Threshold methods
     def year_threshold
       year_in_seconds
     end
@@ -177,3 +372,4 @@ module RailsDiffTime
     end
   end
 end
+

data/lib/rails/diff/time/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsDiffTime
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-diff-time
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - dhq_boiler
@@ -10,8 +10,10 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A Rails gem that provides helper methods to display time differences
-  in a human-readable format (e.g., '2 hours ago', '3 days later'). Integrates seamlessly
-  with Rails views and supports various time units from seconds to years.
+  in a human-readable format (e.g., '2 hours ago', '3 days later'). Features include
+  auto-updating timestamps every minute without page reload, no JavaScript imports
+  required, and seamless integration with Rails views. Supports various time units
+  from seconds to years.
 email:
 - dhq_boiler@live.jp
 executables: []
@@ -53,5 +55,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Rails helper for displaying human-readable time differences
+summary: Rails helper for displaying human-readable time differences with auto-update
 test_files: []