zone 0.1.1 → 0.1.2

data/lib/zone/pattern.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'timestamp_patterns'
+
+module Zone
+  module Pattern
+    module_function
+
+    def process(input, output, transformation, logger)
+      input.each_line do |line|
+        process_line(line, input.from_arguments?, output, transformation, logger)
+      end
+    end
+
+    def process_line(line, from_arguments, output, transformation, logger)
+      case line
+      in ""
+        logger.warn("Could not parse time from empty line") if from_arguments
+        output.puts(line) unless from_arguments
+      else
+        result = replace_timestamps(line, output, transformation, logger)
+
+        case [result == line, from_arguments]
+        in [true, true]
+          parse_as_argument(line, output, transformation)
+        in [true, false]
+          output.puts(line)
+        in [false, _]
+          output.puts(result)
+        end
+      end
+    end
+    private_class_method :process_line
+
+    def replace_timestamps(line, output, transformation, logger)
+      TimestampPatterns.replace_all(line, logger: logger) do |match, _pattern|
+        transform_timestamp(match, output, transformation, logger)
+      end
+    end
+    private_class_method :replace_timestamps
+
+    def transform_timestamp(match, output, transformation, logger)
+      formatted = transformation.call(match)
+      output.colorize_timestamp(formatted)
+    rescue StandardError => e
+      logger.warn("Could not parse time: #{e.message}")
+      match
+    end
+    private_class_method :transform_timestamp
+
+    def parse_as_argument(text, output, transformation)
+      formatted = transformation.call(text)
+      raise ArgumentError, "Could not parse time '#{text}'" if formatted.nil?
+
+      output.puts(output.colorize_timestamp(formatted))
+    end
+    private_class_method :parse_as_argument
+  end
+end

data/lib/zone/timestamp.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+module Zone
+  class Timestamp
+    attr_reader :time, :zone
+
+    def self.parse(input)
+      time = case input
+      in Time
+        input
+      in DateTime
+        input.to_time
+      in Date
+        input.to_time
+      in /^[0-9\.]+$/
+        parse_unix(input)
+      in /^(?<amount>[0-9\.]+) (?<unit>second|minute|hour|day|week|month|year|decade)s? (?<direction>ago|from now)$/
+        parse_relative($~)
+      in /^(?<dow>[A-Z][a-z]{2}) (?<mon>[A-Z][a-z]{2}) (?<day>\d{1,2}) (?<time>\d{2}:\d{2}:\d{2}) (?<year>\d{4}) (?<offset>[+-]\d{4})$/
+        # Git log format: "Fri Nov 14 14:54:35 2025 -0500" or "Wed Nov 5 11:24:19 2025 -0500"
+        # Reorder to: "Fri Nov 14 14:54:35 -0500 2025" for DateTime.parse
+        parse_git_log($~)
+      else
+        DateTime.parse(input).to_time
+      end
+
+      new(time)
+    rescue StandardError
+      raise ArgumentError, "Could not parse time '#{input}'"
+    end
+
+    def initialize(time, zone: nil)
+      @time = time
+      @zone = zone
+    end
+
+    def in_zone(zone_name)
+      tz = Zone.find(zone_name)
+
+      raise ArgumentError, "Could not find timezone '#{zone_name}'" if tz.nil?
+
+      converted = tz.to_local(@time)
+
+      self.class.new(
+        converted,
+        zone: zone_name
+      )
+    end
+
+    def in_utc
+      self.class.new(
+        @time.utc,
+        zone: 'UTC'
+      )
+    end
+
+    def in_local
+      self.class.new(
+        @time.localtime,
+        zone: 'local'
+      )
+    end
+
+    def to_iso8601
+      @time.utc_offset.zero? ? @time.strftime('%Y-%m-%dT%H:%M:%SZ') : @time.iso8601
+    end
+
+    def to_unix
+      @time.to_i
+    end
+
+    def to_pretty(style = 1)
+      case style
+      when 1
+        @time.strftime('%b %d, %Y - %l:%M %p %Z')
+      when 2
+        @time.strftime('%b %d, %Y - %H:%M %Z')
+      when 3
+        @time.strftime('%Y-%m-%d %H:%M %Z')
+      else
+        raise ArgumentError, "Invalid pretty style '#{style}' (must be 1, 2, or 3)"
+      end
+    end
+
+    def strftime(format)
+      @time.strftime(format)
+    end
+
+    private
+
+    def self.parse_unix(str)
+      precision = str.length - 10
+      time_float = str.to_f / 10**precision
+      Time.at(time_float)
+    end
+
+    def self.parse_relative(match_data)
+      match_data => { amount:, unit:, direction: }
+
+      seconds = case unit
+      in 'second'
+        amount.to_i
+      in 'minute'
+        amount.to_i * 60
+      in 'hour'
+        amount.to_i * 3600
+      in 'day'
+        amount.to_i * 86400
+      in 'week'
+        amount.to_i * 604800
+      in 'month'
+        amount.to_i * 2592000
+      in 'year'
+        amount.to_i * 31536000
+      in 'decade'
+        amount.to_i * 315360000
+      end
+
+      case direction
+      in 'ago'
+        Time.now - seconds
+      in 'from now'
+        Time.now + seconds
+      end
+    end
+
+    def self.parse_git_log(match_data)
+      # Git log format: "Fri Nov 14 14:54:35 2025 -0500"
+      # Reorder to parseable format: "Fri Nov 14 14:54:35 -0500 2025"
+      match_data => { dow:, mon:, day:, time:, year:, offset: }
+      reordered = "#{dow} #{mon} #{day} #{time} #{offset} #{year}"
+      DateTime.parse(reordered).to_time
+    end
+  end
+end

data/lib/zone/timestamp_patterns.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Zone
+  #
+  # Pattern matching for timestamps in arbitrary text.
+  #
+  # Provides regex patterns and utilities for finding and replacing
+  # timestamps embedded in unstructured text.
+  #
+  module TimestampPatterns
+    # Patterns are prefixed with P## to define priority order (most specific first).
+    # To add a new pattern, simply define a new Regexp constant with appropriate priority number.
+    # It will be automatically included in pattern matching.
+
+    # ISO 8601 with timezone offset (e.g., 2025-01-15T10:30:00+09:00)
+    P01_ISO8601_WITH_TZ = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?[+-]\d{2}:\d{2}\b/
+
+    # ISO 8601 with Zulu (UTC) timezone (e.g., 2025-01-15T10:30:00Z)
+    P02_ISO8601_ZULU = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/
+
+    # ISO 8601 with space separator and offset (e.g., 2025-01-15 10:30:00 -0500) - Ruby Time.now.to_s format
+    P03_ISO8601_SPACE_WITH_OFFSET = /\b\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}\b/
+
+    # ISO 8601 with space separator, no timezone (e.g., 2025-01-15 10:30:00) - common SQL/database format
+    # Use negative lookahead to ensure not followed by timezone offset
+    P04_ISO8601_SPACE = /\b\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?(?! [+-]\d)/
+
+    # Zone pretty1 format: 12hr with AM/PM (e.g., "Jan 15, 2025 - 10:30 AM UTC" or "Jan 15, 2025 -  1:30 AM UTC")
+    P05_PRETTY1_12HR = /\b[A-Z][a-z]{2} \d{2}, \d{4} - \s?\d{1,2}:\d{2} [AP]M [A-Z]{3,4}\b/
+
+    # Zone pretty2 format: 24hr without AM/PM (e.g., "Jan 15, 2025 - 10:30 UTC")
+    P06_PRETTY2_24HR = /\b[A-Z][a-z]{2} \d{2}, \d{4} - \d{2}:\d{2} [A-Z]{3,4}\b/
+
+    # Zone pretty3 format: ISO-style compact (e.g., "2025-01-15 10:30 UTC")
+    P07_PRETTY3_ISO = /\b\d{4}-\d{2}-\d{2} \d{2}:\d{2} [A-Z]{3,4}\b/
+
+    # Unix timestamp (10 digits, 2001-2036, e.g., 1736937000)
+    # Matches timestamps starting with 1 (2001-2033) or 20-21 (2033-2039)
+    # Avoids false positives from phone numbers, order IDs, hex strings (commit hashes), etc.
+    # Uses hex boundary check to prevent matching within commit hashes
+    P08_UNIX_TIMESTAMP = /(?<![0-9a-fA-F])(?:1\d{9}|2[0-1]\d{8})(?![0-9a-fA-F])/
+
+    # Relative time expressions (e.g., "5 hours ago", "3 days from now")
+    P09_RELATIVE_TIME = /\b\d+\s+(?:second|minute|hour|day|week|month|year)s?\s+(?:ago|from now)\b/i
+
+    # Git log format (e.g., "Fri Nov 14 23:48:24 2025 +0000", "Wed Nov 5 11:24:19 2025 -0500")
+    P10_GIT_LOG = /\b[A-Z][a-z]{2} [A-Z][a-z]{2} \d{1,2} \d{2}:\d{2}:\d{2} \d{4} [+-]\d{4}\b/
+
+    # Date command output format (e.g., "Wed Nov 12 19:13:17 UTC 2025")
+    P11_DATE_COMMAND = /\b[A-Z][a-z]{2} [A-Z][a-z]{2} \d{1,2} \d{2}:\d{2}:\d{2} [A-Z]{3,4} \d{4}\b/
+
+    module_function
+
+    #
+    # Returns all timestamp patterns in priority order.
+    #
+    # @return [Array<Regexp>]
+    #   All Regexp constants defined in this module, sorted by P## prefix
+    #
+    def patterns
+      constants
+        .select { |c| c.to_s.match?(/^P\d+_/) }
+        .sort_by { |c| c.to_s[/^P(\d+)_/, 1].to_i }
+        .map { |c| const_get(c) }
+    end
+
+    #
+    # Check if text contains any timestamp patterns.
+    #
+    # @param [String] text
+    #   The text to check
+    #
+    # @return [Boolean]
+    #   true if text matches any timestamp pattern
+    #
+    def match?(text)
+      patterns.any? { |pattern| pattern.match?(text) }
+    end
+
+    #
+    # Replace all timestamp patterns in text.
+    #
+    # @param [String] text
+    #   The text to search for timestamps
+    #
+    # @param [Logger, nil] logger
+    #   Optional logger for debug output
+    #
+    # @yield [match, pattern]
+    #   Block receives each matched timestamp string and its pattern
+    #
+    # @yieldparam [String] match
+    #   The matched timestamp string
+    #
+    # @yieldparam [Regexp] pattern
+    #   The pattern that matched
+    #
+    # @yieldreturn [String]
+    #   The replacement string
+    #
+    # @return [String]
+    #   Text with all timestamps replaced
+    #
+    # @example
+    #   text = "Logged in at 2025-01-15T10:30:00Z"
+    #   result = replace_all(text) do |match, pattern|
+    #     timestamp = Timestamp.parse(match)
+    #     timestamp.to_pretty
+    #   end
+    #   # => "Logged in at Jan 15, 2025 - 10:30 AM UTC"
+    #
+    def replace_all(text, logger: nil)
+      result = text.dup
+      matches = 0
+
+      patterns.each do |pattern|
+        result.gsub!(pattern) do |match|
+          next match unless valid_timestamp?(match, pattern)
+
+          matches += 1
+
+          begin
+            yield(match, pattern)
+          rescue StandardError => e
+            logger&.debug("Failed to transform '#{match}': #{e.message}")
+            match # Keep original if transformation fails
+          end
+        end
+      end
+
+      logger&.debug("Matched #{matches} timestamp(s)") if logger && matches > 0
+
+      result
+    end
+
+    #
+    # Validate that a matched string is actually a timestamp.
+    #
+    # @param [String] str
+    #   The matched string
+    #
+    # @param [Regexp] pattern
+    #   The pattern that matched
+    #
+    # @return [Boolean]
+    #   true if valid timestamp
+    #
+    def valid_timestamp?(str, pattern)
+      return valid_unix?(str) if pattern == P08_UNIX_TIMESTAMP
+      true
+    end
+
+    #
+    # Validate unix timestamp is in reasonable range.
+    #
+    # @param [String] str
+    #   The matched string
+    #
+    # @return [Boolean]
+    #   true if valid unix timestamp (2001-2036)
+    #
+    def valid_unix?(str)
+      int = str.to_i
+      # Range: 2001-09-09 (first 10-digit) to 2036-07-11 (11 years ahead)
+      # This avoids false positives from phone numbers, order IDs, etc.
+      int >= 1_000_000_000 && int <= 2_100_000_000
+    end
+  end
+end

data/lib/zone/transform.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'timestamp'
+
+module Zone
+  module Transform
+    module_function
+
+    #
+    # Build a transformation lambda.
+    #
+    # @param [String, Symbol] zone
+    #   Zone name to convert to
+    #
+    # @param [Symbol, Hash] format
+    #   Format specification (:to_iso8601, :to_unix, {pretty: 1}, {strftime: "..."})
+    #
+    # @return [Proc]
+    #   Lambda that transforms a timestamp string
+    #
+    def build(zone:, format:)
+      ->(value) do
+        timestamp = Timestamp.parse(value)
+        converted = convert_zone(timestamp, zone)
+        format_timestamp(converted, format)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    #
+    # Convert timestamp to specified zone.
+    #
+    # @param [Timestamp] timestamp
+    # @param [String, Symbol] zone_name
+    #
+    # @return [Timestamp]
+    #
+    def convert_zone(timestamp, zone_name)
+      case zone_name
+      in 'utc' | 'UTC'
+        timestamp.in_utc
+      in 'local'
+        timestamp.in_local
+      else
+        timestamp.in_zone(zone_name)
+      end
+    end
+
+    #
+    # Format timestamp according to format specification.
+    #
+    # @param [Timestamp] timestamp
+    # @param [Symbol, Hash] format_spec
+    #
+    # @return [String, Integer]
+    #
+    def format_timestamp(timestamp, format_spec)
+      case format_spec
+      in :to_iso8601 | :to_unix
+        timestamp.send(format_spec)
+      in { pretty: Integer => style }
+        timestamp.to_pretty(style)
+      in { strftime: String => fmt }
+        timestamp.strftime(fmt)
+      end
+    end
+  end
+end

data/lib/zone/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zone
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/zone.rb

@@ -1,8 +1,52 @@
 # frozen_string_literal: true
 
+require 'tzinfo'
 require_relative "zone/version"
+require_relative "zone/field_mapping"
+require_relative "zone/field_line"
+require_relative "zone/timestamp"
+require_relative "zone/cli"
 
 module Zone
   class Error < StandardError; end
-  # Your code goes here...
+
+  def self.find(keyword)
+    TZInfo::Timezone.get(keyword)
+  rescue TZInfo::InvalidTimezoneIdentifier
+    search_fuzzy(keyword)
+  end
+
+  def self.search_fuzzy(keyword)
+    all_zones = TZInfo::Timezone.all_identifiers
+
+    # Normalize keyword: replace spaces with wildcards for matching
+    normalized_keyword = keyword.gsub(/\s+/, '.*')
+
+    # Try US wildcard pattern first
+    us_pattern = Regexp.new(
+      normalized_keyword.gsub(/^(?:US)?\/?/, 'US/').gsub(/$/,'.*'),
+      Regexp::IGNORECASE
+    )
+
+    # Then try global pattern
+    global_pattern = Regexp.new(
+      ".*#{normalized_keyword}.*",
+      Regexp::IGNORECASE
+    )
+
+    found = case all_zones
+    in [*, ^(us_pattern) => zone, *]
+      zone
+    in [*, ^(global_pattern) => zone, *]
+      zone
+    else
+      nil
+    end
+
+    return nil unless found
+
+    TZInfo::Timezone.get(found)
+  end
+
+  private_class_method :search_fuzzy
 end

data/todo.md

@@ -0,0 +1,85 @@
+## Rules
+1. VERY IMPORTANT .Before using ANY Ruby class, method, builtin, expression, you are to read the latest docs on it. This can be found by executing `ri --no-pager <subject>`.  For example:
+
+```
+ri --no-pager 'Array#zip'
+```
+
+Additionally, more comprehensive documentation can be found by accessing these documents, using the syntax:
+
+```
+ri --no-pager 'syntax/pattern_matching:'
+```
+which renders the document syntax/pattern_matching.rdoc. All other advanced documentation can be found below:
+
+
+bsearch.rdoc
+bug_triaging.rdoc
+case_mapping.rdoc
+character_selectors.rdoc
+command_injection.rdoc
+contributing.md
+contributing/building_ruby.md
+contributing/documentation_guide.md
+contributing/glossary.md
+contributing/making_changes_to_ruby.md
+contributing/making_changes_to_stdlibs.md
+contributing/reporting_issues.md
+contributing/testing_ruby.md
+date/calendars.rdoc
+dig_methods.rdoc
+distribution.md
+dtrace_probes.rdoc
+encodings.rdoc
+exceptions.md
+extension.ja.rdoc
+extension.rdoc
+fiber.md
+format_specifications.rdoc
+globals.rdoc
+implicit_conversion.rdoc
+index.md
+maintainers.md
+marshal.rdoc
+memory_view.md
+optparse/argument_converters.rdoc
+optparse/creates_option.rdoc
+optparse/option_params.rdoc
+optparse/tutorial.rdoc
+packed_data.rdoc
+ractor.md
+regexp/methods.rdoc
+regexp/unicode_properties.rdoc
+rjit/rjit.md
+ruby/option_dump.md
+ruby/options.md
+security.rdoc
+signals.rdoc
+standard_library.md
+strftime_formatting.rdoc
+syntax.rdoc
+syntax/assignment.rdoc
+syntax/calling_methods.rdoc
+syntax/comments.rdoc
+syntax/control_expressions.rdoc
+syntax/exceptions.rdoc
+syntax/keywords.rdoc
+syntax/literals.rdoc
+syntax/methods.rdoc
+syntax/miscellaneous.rdoc
+syntax/modules_and_classes.rdoc
+syntax/operators.rdoc
+syntax/pattern_matching.rdoc
+syntax/precedence.rdoc
+syntax/refinements.rdoc
+windows.md
+yjit/yjit.md
+
+
+You must do this for EVERY method, class, etc when you use it in this session for the first time
+
+2. Prefer "in" to "when". See `ri --no-pager syntax/pattern_matching:`
+
+3. When using OptionParser, prefer the implict, blockless declarations that utilize `OptionParser#parse!(into: options)`
+
+4. Prefer a functional chaining style when doing consecutive operations on enumerables 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zone
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - David Gillis
@@ -76,9 +76,27 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TEST_PLAN.md
+- completions/README.md
+- completions/_zone
+- docs/user-experience-review.md
 - exe/zone
 - lib/zone.rb
+- lib/zone/cli.rb
+- lib/zone/colors.rb
+- lib/zone/field.rb
+- lib/zone/field_line.rb
+- lib/zone/field_mapping.rb
+- lib/zone/input.rb
+- lib/zone/logging.rb
+- lib/zone/options.rb
+- lib/zone/output.rb
+- lib/zone/pattern.rb
+- lib/zone/timestamp.rb
+- lib/zone/timestamp_patterns.rb
+- lib/zone/transform.rb
 - lib/zone/version.rb
+- todo.md
 homepage: https://github.com/gillisd/zone
 licenses:
 - MIT