whenwords 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b632b8d1b88e484cd487236d6f074de258636bbc8485fe633c57f4d0da3a20a
+  data.tar.gz: 2c3dd46ebccb057efd996a6c13c287f8a216509ae9037e46d19c37b0ee57026d
+SHA512:
+  metadata.gz: f4c62f91e2837875c537c3b2f3fc51fb7f9a7c2855da99e4cd41fd61f4ca6392166da376ddd0b3294a18a39b856fa7cfb6a7ec95f6eb3d520422ce5b7f91cac6
+  data.tar.gz: ff07da6df5d2cc3d719019cf309916ac29627c3f974058bf12ea9bdb29de8be6ae4a945ea35111dfa4694b06bcdc7661e8a2006209e958e243fd05b673a8be36

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-01-11
+
+### Added
+
+- Initial release
+- `timeago` - Convert timestamps to relative time strings ("3 hours ago", "in 2 days")
+- `duration` - Format seconds to human-readable duration ("2 hours, 30 minutes")
+- `parse_duration` - Parse duration strings to seconds ("2h30m" → 9000)
+- `human_date` - Contextual date formatting ("Yesterday", "Last Friday", "March 15")
+- `date_range` - Smart date range formatting ("January 15–22, 2024")
+- CLI executable `whenwords` with all commands
+- Support for multiple timestamp input types (Integer, Float, Time, DateTime, Date, String)

data/README.md

@@ -0,0 +1,282 @@
+# Whenwords
+
+[![Gem Version](https://badge.fury.io/rb/whenwords.svg)](https://badge.fury.io/rb/whenwords)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-red.svg)](https://www.ruby-lang.org/)
+
+Human-friendly time formatting and parsing for Ruby. Convert timestamps to readable strings like "3 hours ago" and parse duration strings like "2h 30m" into seconds.
+
+## Features
+
+- **timeago** - Convert timestamps to relative time ("3 hours ago", "in 2 days")
+- **duration** - Format seconds to human-readable duration ("2 hours, 30 minutes")
+- **parse_duration** - Parse duration strings to seconds ("2h30m" → 9000)
+- **human_date** - Contextual dates ("Yesterday", "Last Friday", "March 15")
+- **date_range** - Smart date range formatting ("January 15–22, 2024")
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'whenwords'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install whenwords
+```
+
+## Quick Start
+
+```ruby
+require 'whenwords'  # Not needed in Rails (Bundler auto-requires)
+
+# Relative time
+Whenwords.timeago(Time.now - 3600, reference: Time.now)
+# => "1 hour ago"
+
+# Format duration
+Whenwords.duration(9000)
+# => "2 hours, 30 minutes"
+
+# Parse duration
+Whenwords.parse_duration("2h 30m")
+# => 9000
+
+# Human-readable date
+Whenwords.human_date(Date.today - 1, reference: Date.today)
+# => "Yesterday"
+
+# Date range
+Whenwords.date_range(Date.new(2024, 1, 15), Date.new(2024, 1, 22))
+# => "January 15–22, 2024"
+```
+
+## Command Line Usage
+
+After installing the gem:
+
+```bash
+# Relative time
+whenwords timeago 1704067110 --reference 1704067200
+# => 2 minutes ago
+
+# Duration formatting
+whenwords duration 9000 --compact
+# => 2h 30m
+
+# Parse duration string
+whenwords parse "2 hours 30 minutes"
+# => 9000
+
+# Human-readable date
+whenwords human_date 1705190400 --reference 1705276800
+# => Yesterday
+
+# Date range
+whenwords date_range 1705276800 1705881600
+# => January 15–22, 2024
+```
+
+## API Reference
+
+### timeago(timestamp, reference: nil) → String
+
+Returns a human-readable relative time string.
+
+```ruby
+Whenwords.timeago(1704067110, reference: 1704067200)
+# => "2 minutes ago"
+
+Whenwords.timeago(Time.now + 3600, reference: Time.now)
+# => "in 1 hour"
+```
+
+**Parameters:**
+- `timestamp` - Unix timestamp (Integer/Float), Time, DateTime, Date, or ISO 8601 String
+- `reference:` - Optional reference timestamp (defaults to same as timestamp)
+
+**Thresholds:**
+| Condition | Output |
+|-----------|--------|
+| 0–44 seconds | "just now" |
+| 45–89 seconds | "1 minute ago" |
+| 90 seconds – 44 minutes | "{n} minutes ago" |
+| 45–89 minutes | "1 hour ago" |
+| 90 minutes – 21 hours | "{n} hours ago" |
+| 22–35 hours | "1 day ago" |
+| 36 hours – 25 days | "{n} days ago" |
+| 26–45 days | "1 month ago" |
+| 46–319 days | "{n} months ago" |
+| 320–547 days | "1 year ago" |
+| 548+ days | "{n} years ago" |
+
+Future times use "in {n} {units}" format.
+
+### duration(seconds, compact: false, max_units: 2) → String
+
+Formats a duration in seconds to a human-readable string.
+
+```ruby
+Whenwords.duration(3661)
+# => "1 hour, 1 minute"
+
+Whenwords.duration(3661, compact: true)
+# => "1h 1m"
+
+Whenwords.duration(93661, max_units: 3)
+# => "1 day, 2 hours, 1 minute"
+```
+
+**Parameters:**
+- `seconds` - Non-negative number of seconds
+- `compact:` - Use compact format ("2h 30m" vs "2 hours, 30 minutes")
+- `max_units:` - Maximum number of units to display (default: 2)
+
+### parse_duration(string) → Integer
+
+Parses a human-written duration string into seconds.
+
+```ruby
+Whenwords.parse_duration("2h30m")               # => 9000
+Whenwords.parse_duration("2 hours 30 minutes")  # => 9000
+Whenwords.parse_duration("2.5 hours")           # => 9000
+Whenwords.parse_duration("2:30")                # => 9000 (h:mm)
+Whenwords.parse_duration("1 week")              # => 604800
+```
+
+**Accepted formats:**
+- Compact: "2h30m", "2h 30m", "2h, 30m"
+- Verbose: "2 hours 30 minutes", "2 hours and 30 minutes"
+- Decimal: "2.5 hours", "1.5h"
+- Colon: "2:30" (h:mm), "2:30:00" (h:mm:ss)
+
+**Unit aliases:**
+- seconds: s, sec, secs, second, seconds
+- minutes: m, min, mins, minute, minutes
+- hours: h, hr, hrs, hour, hours
+- days: d, day, days
+- weeks: w, wk, wks, week, weeks
+
+### human_date(timestamp, reference: nil) → String
+
+Returns a contextual date string.
+
+```ruby
+Whenwords.human_date(Date.today, reference: Date.today)
+# => "Today"
+
+Whenwords.human_date(Date.today - 3, reference: Date.today)
+# => "Last Friday" (if today is Monday)
+```
+
+**Outputs:**
+- Same day → "Today"
+- Previous day → "Yesterday"
+- Next day → "Tomorrow"
+- Within past 7 days → "Last {weekday}"
+- Within next 7 days → "This {weekday}"
+- Same year → "Month Day"
+- Different year → "Month Day, Year"
+
+### date_range(start, end) → String
+
+Formats a date range with smart abbreviation.
+
+```ruby
+Whenwords.date_range(1705276800, 1705363200)
+# => "January 15–16, 2024"
+
+Whenwords.date_range(1705276800, 1707955200)
+# => "January 15 – February 15, 2024"
+```
+
+**Behavior:**
+- Same day: "March 5, 2024"
+- Same month: "March 5–7, 2024"
+- Same year: "March 5 – April 7, 2024"
+- Different years: "December 28, 2024 – January 3, 2025"
+- Swapped inputs are auto-corrected
+
+## Rails Integration
+
+After adding `gem 'whenwords'` to your Gemfile and running `bundle install`, `Whenwords` is automatically available throughout your Rails app.
+
+### View Helper
+
+```ruby
+# app/helpers/application_helper.rb
+module ApplicationHelper
+  def time_ago_in_words(time)
+    Whenwords.timeago(time, reference: Time.now)
+  end
+
+  def format_duration(seconds, compact: false)
+    Whenwords.duration(seconds, compact: compact)
+  end
+end
+```
+
+### Model
+
+```ruby
+class Video < ApplicationRecord
+  def duration_formatted(compact: false)
+    Whenwords.duration(duration_seconds, compact: compact)
+  end
+
+  def duration_seconds=(value)
+    if value.is_a?(String) && value.match?(/[a-z]/i)
+      super(Whenwords.parse_duration(value))
+    else
+      super
+    end
+  end
+end
+```
+
+## Error Handling
+
+```ruby
+begin
+  Whenwords.parse_duration("invalid string")
+rescue Whenwords::ParseError => e
+  puts "Parse error: #{e.message}"
+end
+
+begin
+  Whenwords.duration(-100)
+rescue Whenwords::Error => e
+  puts "Error: #{e.message}"
+end
+```
+
+## Accepted Input Types
+
+All timestamp parameters accept:
+- `Integer` / `Float` - Unix timestamp (seconds)
+- `Time` - Ruby Time object
+- `DateTime` - Ruby DateTime object
+- `Date` - Ruby Date object
+- `String` - ISO 8601 formatted string
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dbreunig/whenwords.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/whenwords

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "whenwords"
+require "optparse"
+
+def main
+  if ARGV.empty?
+    puts usage
+    exit 1
+  end
+
+  command = ARGV.shift
+
+  case command
+  when "timeago"
+    handle_timeago
+  when "duration"
+    handle_duration
+  when "parse", "parse_duration"
+    handle_parse_duration
+  when "human_date"
+    handle_human_date
+  when "date_range"
+    handle_date_range
+  when "help", "-h", "--help"
+    puts usage
+  when "version", "-v", "--version"
+    puts "whenwords #{Whenwords::VERSION}"
+  else
+    puts "Unknown command: #{command}"
+    puts usage
+    exit 1
+  end
+rescue Whenwords::Error => e
+  puts "Error: #{e.message}"
+  exit 1
+end
+
+def usage
+  <<~USAGE
+    whenwords - Human-friendly time formatting and parsing
+
+    Usage:
+      whenwords <command> [options]
+
+    Commands:
+      timeago <timestamp> [--reference <ref>]     Convert timestamp to relative time
+      duration <seconds> [--compact] [--max-units N]  Format duration
+      parse "<duration string>"                   Parse duration string to seconds
+      human_date <timestamp> [--reference <ref>]  Format date contextually
+      date_range <start> <end>                    Format date range
+
+    Examples:
+      whenwords timeago 1704067110 --reference 1704067200
+      whenwords duration 9000 --compact
+      whenwords parse "2 hours 30 minutes"
+      whenwords human_date 1705190400 --reference 1705276800
+      whenwords date_range 1705276800 1705881600
+
+    Options:
+      -h, --help      Show this help message
+      -v, --version   Show version
+  USAGE
+end
+
+def handle_timeago
+  options = {}
+  parser = OptionParser.new do |opts|
+    opts.on("--reference REF", "-r REF", Integer, "Reference timestamp") do |r|
+      options[:reference] = r
+    end
+  end
+  parser.parse!
+
+  timestamp = ARGV.shift&.to_i
+  unless timestamp
+    puts "Error: timestamp required"
+    exit 1
+  end
+
+  result = if options[:reference]
+             Whenwords.timeago(timestamp, reference: options[:reference])
+           else
+             Whenwords.timeago(timestamp, reference: Time.now.to_i)
+           end
+  puts result
+end
+
+def handle_duration
+  options = { compact: false, max_units: 2 }
+  parser = OptionParser.new do |opts|
+    opts.on("--compact", "-c", "Use compact format") do
+      options[:compact] = true
+    end
+    opts.on("--max-units N", "-m N", Integer, "Maximum units to display") do |n|
+      options[:max_units] = n
+    end
+  end
+  parser.parse!
+
+  seconds = ARGV.shift&.to_i
+  unless seconds
+    puts "Error: seconds required"
+    exit 1
+  end
+
+  puts Whenwords.duration(seconds, **options)
+end
+
+def handle_parse_duration
+  input = ARGV.join(" ")
+  if input.empty?
+    puts "Error: duration string required"
+    exit 1
+  end
+
+  puts Whenwords.parse_duration(input)
+end
+
+def handle_human_date
+  options = {}
+  parser = OptionParser.new do |opts|
+    opts.on("--reference REF", "-r REF", Integer, "Reference timestamp") do |r|
+      options[:reference] = r
+    end
+  end
+  parser.parse!
+
+  timestamp = ARGV.shift&.to_i
+  unless timestamp
+    puts "Error: timestamp required"
+    exit 1
+  end
+
+  result = if options[:reference]
+             Whenwords.human_date(timestamp, reference: options[:reference])
+           else
+             Whenwords.human_date(timestamp, reference: Time.now.to_i)
+           end
+  puts result
+end
+
+def handle_date_range
+  start_ts = ARGV.shift&.to_i
+  end_ts = ARGV.shift&.to_i
+
+  unless start_ts && end_ts
+    puts "Error: start and end timestamps required"
+    exit 1
+  end
+
+  puts Whenwords.date_range(start_ts, end_ts)
+end
+
+main

data/lib/whenwords/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Whenwords
+  VERSION = "0.1.0"
+end

data/lib/whenwords.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "whenwords/version"
+
+module Whenwords
+  class Error < StandardError; end
+  class ParseError < Error; end
+
+  SECONDS_PER_MINUTE = 60
+  SECONDS_PER_HOUR = 3600
+  SECONDS_PER_DAY = 86400
+  SECONDS_PER_WEEK = 604800
+  SECONDS_PER_MONTH = 2592000  # 30 days
+  SECONDS_PER_YEAR = 31536000  # 365 days
+
+  WEEKDAY_NAMES = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].freeze
+  MONTH_NAMES = %w[January February March April May June July August September October November December].freeze
+
+  class << self
+    # Convert various timestamp formats to Unix seconds
+    def normalize_timestamp(timestamp)
+      case timestamp
+      when Integer, Float
+        timestamp.to_f
+      when Time
+        timestamp.to_f
+      when DateTime
+        timestamp.to_time.to_f
+      when Date
+        Time.utc(timestamp.year, timestamp.month, timestamp.day).to_f
+      when String
+        Time.parse(timestamp).to_f
+      else
+        raise Error, "Invalid timestamp format: #{timestamp.class}"
+      end
+    end
+
+    # Returns a human-readable relative time string.
+    # @param timestamp [Integer, Float, Time, String] The timestamp to format
+    # @param reference [Integer, Float, Time, String, nil] The reference timestamp (defaults to same as timestamp)
+    # @return [String] Human-readable relative time
+    def timeago(timestamp, reference: nil)
+      ts = normalize_timestamp(timestamp)
+      ref = reference.nil? ? ts : normalize_timestamp(reference)
+
+      diff = ref - ts
+      future = diff < 0
+      diff = diff.abs
+
+      text = calculate_timeago_text(diff)
+
+      if text == "just now"
+        text
+      elsif future
+        "in #{text.sub(/ ago$/, '')}"
+      else
+        text
+      end
+    end
+
+    # Formats a duration in seconds to human-readable string.
+    # @param seconds [Numeric] Non-negative number of seconds
+    # @param compact [Boolean] Use compact format (e.g., "2h 30m")
+    # @param max_units [Integer] Maximum number of units to display
+    # @return [String] Human-readable duration
+    def duration(seconds, compact: false, max_units: 2)
+      raise Error, "Duration cannot be negative" if seconds.negative?
+      raise Error, "Duration cannot be NaN" if seconds.respond_to?(:nan?) && seconds.nan?
+      raise Error, "Duration cannot be infinite" if seconds.respond_to?(:infinite?) && seconds.infinite?
+
+      seconds = seconds.to_f
+
+      return compact ? "0s" : "0 seconds" if seconds.zero?
+
+      units = calculate_duration_units(seconds)
+      non_zero_units = units.select { |_, v| v.positive? }
+
+      # Take only max_units
+      display_units = non_zero_units.first(max_units)
+
+      if compact
+        format_compact_duration(display_units)
+      else
+        format_verbose_duration(display_units)
+      end
+    end
+
+    # Parses a human-written duration string into seconds.
+    # @param string [String] The duration string to parse
+    # @return [Numeric] Duration in seconds
+    def parse_duration(string)
+      raise ParseError, "Duration string cannot be empty" if string.nil? || string.strip.empty?
+
+      input = string.strip.downcase
+
+      # Check for negative values
+      raise ParseError, "Negative durations are not allowed" if input.include?("-")
+
+      # Try colon notation first
+      if input.match?(/^\d+:\d{1,2}(:\d{1,2})?$/)
+        return parse_colon_notation(input)
+      end
+
+      total = parse_duration_parts(input)
+      raise ParseError, "No parseable duration units found" if total.zero? && !input.match?(/\b0\s*[a-z]/)
+
+      total
+    end
+
+    # Returns a contextual date string.
+    # @param timestamp [Integer, Float, Time, String] The date to format
+    # @param reference [Integer, Float, Time, String, nil] The reference date
+    # @return [String] Human-readable date
+    def human_date(timestamp, reference: nil)
+      ts = normalize_timestamp(timestamp)
+      ref = reference.nil? ? ts : normalize_timestamp(reference)
+
+      ts_date = Time.at(ts).utc.to_date
+      ref_date = Time.at(ref).utc.to_date
+
+      diff_days = (ts_date - ref_date).to_i
+
+      case diff_days
+      when 0
+        "Today"
+      when -1
+        "Yesterday"
+      when 1
+        "Tomorrow"
+      when -6..-2
+        "Last #{WEEKDAY_NAMES[ts_date.wday]}"
+      when 2..6
+        "This #{WEEKDAY_NAMES[ts_date.wday]}"
+      else
+        format_date(ts_date, ref_date)
+      end
+    end
+
+    # Formats a date range with smart abbreviation.
+    # @param start_ts [Integer, Float, Time, String] Start timestamp
+    # @param end_ts [Integer, Float, Time, String] End timestamp
+    # @return [String] Formatted date range
+    def date_range(start_ts, end_ts)
+      start_time = normalize_timestamp(start_ts)
+      end_time = normalize_timestamp(end_ts)
+
+      # Swap if start > end
+      start_time, end_time = end_time, start_time if start_time > end_time
+
+      start_date = Time.at(start_time).utc.to_date
+      end_date = Time.at(end_time).utc.to_date
+
+      format_date_range(start_date, end_date)
+    end
+
+    private
+
+    def calculate_timeago_text(diff)
+      case diff
+      when 0...45
+        "just now"
+      when 45...90
+        "1 minute ago"
+      when 90...(45 * 60)
+        "#{(diff / 60.0).round} minutes ago"
+      when (45 * 60)...(90 * 60)
+        "1 hour ago"
+      when (90 * 60)...(22 * 3600)
+        "#{(diff / 3600.0).round} hours ago"
+      when (22 * 3600)...(36 * 3600)
+        "1 day ago"
+      when (36 * 3600)...(26 * 86400)
+        "#{(diff / 86400.0).round} days ago"
+      when (26 * 86400)...(46 * 86400)
+        "1 month ago"
+      when (46 * 86400)...(320 * 86400)
+        "#{(diff / (30.44 * 86400)).round} months ago"
+      when (320 * 86400)...(548 * 86400)
+        "1 year ago"
+      else
+        "#{(diff / (365.0 * 86400)).round} years ago"
+      end
+    end
+
+    def calculate_duration_units(seconds)
+      remaining = seconds.to_i
+
+      years = remaining / SECONDS_PER_YEAR
+      remaining %= SECONDS_PER_YEAR
+
+      months = remaining / SECONDS_PER_MONTH
+      remaining %= SECONDS_PER_MONTH
+
+      days = remaining / SECONDS_PER_DAY
+      remaining %= SECONDS_PER_DAY
+
+      hours = remaining / SECONDS_PER_HOUR
+      remaining %= SECONDS_PER_HOUR
+
+      minutes = remaining / SECONDS_PER_MINUTE
+      secs = remaining % SECONDS_PER_MINUTE
+
+      {
+        years: years,
+        months: months,
+        days: days,
+        hours: hours,
+        minutes: minutes,
+        seconds: secs
+      }
+    end
+
+    def format_compact_duration(units)
+      abbreviations = {
+        years: "y",
+        months: "mo",
+        days: "d",
+        hours: "h",
+        minutes: "m",
+        seconds: "s"
+      }
+
+      units.map { |unit, value| "#{value}#{abbreviations[unit]}" }.join(" ")
+    end
+
+    def format_verbose_duration(units)
+      units.map do |unit, value|
+        unit_name = unit.to_s
+        unit_name = unit_name.chomp("s") if value == 1
+        "#{value} #{unit_name}"
+      end.join(", ")
+    end
+
+    def parse_colon_notation(input)
+      parts = input.split(":").map(&:to_i)
+
+      if parts.length == 2
+        # h:mm
+        parts[0] * SECONDS_PER_HOUR + parts[1] * SECONDS_PER_MINUTE
+      else
+        # h:mm:ss
+        parts[0] * SECONDS_PER_HOUR + parts[1] * SECONDS_PER_MINUTE + parts[2]
+      end
+    end
+
+    def parse_duration_parts(input)
+      unit_patterns = {
+        /(\d+(?:\.\d+)?)\s*(?:seconds?|secs?|s(?![a-z]))/i => 1,
+        /(\d+(?:\.\d+)?)\s*(?:minutes?|mins?|m(?![a-z]))/i => SECONDS_PER_MINUTE,
+        /(\d+(?:\.\d+)?)\s*(?:hours?|hrs?|h(?![a-z]))/i => SECONDS_PER_HOUR,
+        /(\d+(?:\.\d+)?)\s*(?:days?|d(?![a-z]))/i => SECONDS_PER_DAY,
+        /(\d+(?:\.\d+)?)\s*(?:weeks?|wks?|w(?![a-z]))/i => SECONDS_PER_WEEK
+      }
+
+      total = 0.0
+      found_any = false
+
+      unit_patterns.each do |pattern, multiplier|
+        input.scan(pattern) do |match|
+          total += match[0].to_f * multiplier
+          found_any = true
+        end
+      end
+
+      raise ParseError, "No parseable duration units found" unless found_any
+
+      total.round
+    end
+
+    def format_date(date, ref_date)
+      if date.year == ref_date.year
+        "#{MONTH_NAMES[date.month - 1]} #{date.day}"
+      else
+        "#{MONTH_NAMES[date.month - 1]} #{date.day}, #{date.year}"
+      end
+    end
+
+    def format_date_range(start_date, end_date)
+      if start_date == end_date
+        "#{MONTH_NAMES[start_date.month - 1]} #{start_date.day}, #{start_date.year}"
+      elsif start_date.year == end_date.year && start_date.month == end_date.month
+        "#{MONTH_NAMES[start_date.month - 1]} #{start_date.day}–#{end_date.day}, #{start_date.year}"
+      elsif start_date.year == end_date.year
+        "#{MONTH_NAMES[start_date.month - 1]} #{start_date.day} – #{MONTH_NAMES[end_date.month - 1]} #{end_date.day}, #{end_date.year}"
+      else
+        "#{MONTH_NAMES[start_date.month - 1]} #{start_date.day}, #{start_date.year} – #{MONTH_NAMES[end_date.month - 1]} #{end_date.day}, #{end_date.year}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: whenwords
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Drew Breunig
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Convert timestamps to readable strings like '3 hours ago' and parse duration
+  strings like '2h 30m' into seconds. Includes timeago, duration formatting, duration
+  parsing, contextual dates, and date range formatting.
+email:
+- drew@breunig.com
+executables:
+- whenwords
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- exe/whenwords
+- lib/whenwords.rb
+- lib/whenwords/version.rb
+homepage: https://github.com/dbreunig/whenwords
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dbreunig/whenwords
+  source_code_uri: https://github.com/dbreunig/whenwords
+  changelog_uri: https://github.com/dbreunig/whenwords/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/dbreunig/whenwords#readme
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Human-friendly time formatting and parsing
+test_files: []