zone 0.1.1 → 0.1.2

data/lib/zone/colors.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# Extracted from command_kit gem (https://github.com/postmodern/command_kit.rb)
+# Copyright (c) 2021-2024 Hal Brodigan
+# Licensed under the MIT License
+#
+# This is a simplified version containing only the ANSI color functionality.
+# The full command_kit gem provides many additional features.
+
+module Zone
+  #
+  # ANSI color codes for terminal output.
+  #
+  # @see https://en.wikipedia.org/wiki/ANSI_escape_code
+  #
+  module Colors
+    #
+    # Applies ANSI formatting to text.
+    #
+    module ANSI
+      # ANSI reset code
+      RESET = "\e[0m"
+
+      # ANSI code for bold text
+      BOLD = "\e[1m"
+
+      # ANSI code to disable boldness
+      RESET_INTENSITY = "\e[22m"
+
+      # ANSI color code for red text
+      RED = "\e[31m"
+
+      # ANSI color code for yellow text
+      YELLOW = "\e[33m"
+
+      # ANSI color code for green text
+      GREEN = "\e[32m"
+
+      # ANSI color code for cyan text
+      CYAN = "\e[36m"
+
+      # ANSI color for the default foreground color
+      RESET_FG = "\e[39m"
+
+      module_function
+
+      #
+      # Bolds the text.
+      #
+      # @param [String, nil] string
+      #   An optional string.
+      #
+      # @return [String, BOLD]
+      #   The bolded string or just {BOLD} if no arguments were given.
+      #
+      def bold(string=nil)
+        if string then "#{BOLD}#{string}#{RESET_INTENSITY}"
+        else           BOLD
+        end
+      end
+
+      #
+      # Sets the text color to red.
+      #
+      # @param [String, nil] string
+      #   An optional string.
+      #
+      # @return [String, RED]
+      #   The colorized string or just {RED} if no arguments were given.
+      #
+      def red(string=nil)
+        if string then "#{RED}#{string}#{RESET_FG}"
+        else           RED
+        end
+      end
+
+      #
+      # Sets the text color to yellow.
+      #
+      # @param [String, nil] string
+      #   An optional string.
+      #
+      # @return [String, YELLOW]
+      #   The colorized string or just {YELLOW} if no arguments were given.
+      #
+      def yellow(string=nil)
+        if string then "#{YELLOW}#{string}#{RESET_FG}"
+        else           YELLOW
+        end
+      end
+
+      #
+      # Sets the text color to green.
+      #
+      # @param [String, nil] string
+      #   An optional string.
+      #
+      # @return [String, GREEN]
+      #   The colorized string or just {GREEN} if no arguments were given.
+      #
+      def green(string=nil)
+        if string then "#{GREEN}#{string}#{RESET_FG}"
+        else           GREEN
+        end
+      end
+
+      #
+      # Sets the text color to cyan.
+      #
+      # @param [String, nil] string
+      #   An optional string.
+      #
+      # @return [String, CYAN]
+      #   The colorized string or just {CYAN} if no arguments were given.
+      #
+      def cyan(string=nil)
+        if string then "#{CYAN}#{string}#{RESET_FG}"
+        else           CYAN
+        end
+      end
+    end
+
+    #
+    # Dummy module with the same interface as {ANSI}, but for when ANSI is not
+    # supported.
+    #
+    module PlainText
+      ANSI.constants(false).each do |name|
+        const_set(name,'')
+      end
+
+      module_function
+
+      [:bold, :red, :yellow, :green, :cyan].each do |name|
+        define_method(name) do |string=nil|
+          string || ''
+        end
+      end
+    end
+
+    module_function
+
+    #
+    # Checks if the stream supports ANSI output.
+    #
+    # @param [IO] stream
+    #
+    # @return [Boolean]
+    #
+    # @note
+    #   When the env variable `TERM` is set to `dumb` or when the `NO_COLOR`
+    #   env variable is set, it will disable color output. Color output will
+    #   also be disabled if the given stream is not a TTY.
+    #
+    def ansi?(stream=$stdout)
+      ENV['TERM'] != 'dumb' && !ENV['NO_COLOR'] && stream.tty?
+    end
+
+    #
+    # Returns the colors available for the given stream.
+    #
+    # @param [IO] stream
+    #
+    # @return [ANSI, PlainText]
+    #   The ANSI module or PlainText dummy module.
+    #
+    # @example
+    #   puts colors.green("Hello world")
+    #
+    # @example Using colors with stderr output:
+    #   stderr.puts colors(stderr).green("Hello world")
+    #
+    def colors(stream=$stdout)
+      if ansi?(stream) then ANSI
+      else                  PlainText
+      end
+    end
+  end
+end

data/lib/zone/field.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'field_line'
+require_relative 'field_mapping'
+
+module Zone
+  module Field
+    module_function
+
+    def process(input, output, transformation, options, logger)
+      mapping, header_line = build_mapping(input, options)
+
+      # Output header line if present
+      output.puts(header_line) if header_line
+
+      input.each_line do |line|
+        process_line(line, input.skip_headers?, output, transformation, options, mapping, logger)
+      end
+    end
+
+    def process_line(line, skip, output, transformation, options, mapping, logger)
+      return if skip
+
+      field_line = FieldLine.parse(line, delimiter: options.delimiter, mapping: mapping, logger: logger)
+
+      # Check if field exists before transforming
+      original_value = field_line[options.field]
+      if original_value.nil?
+        logger.warn("Field '#{options.field}' not found or out of bounds in line: #{line}")
+        return
+      end
+
+      # Transform the field
+      field_line.transform(options.field, &transformation)
+
+      # Get transformed value
+      transformed_value = field_line[options.field]
+      if transformed_value.nil?
+        logger.warn("Could not parse timestamp in field '#{options.field}': #{original_value.inspect}")
+        return
+      end
+
+      output.puts_highlighted(field_line.to_s, highlight: transformed_value)
+    end
+    private_class_method :process_line
+
+    def build_mapping(input, options)
+      return [FieldMapping.numeric, nil] unless options.headers
+
+      input.mark_skip_headers!
+      header_line = input.each_line.first
+
+      parsed = FieldLine.parse_delimiter(options.delimiter)
+      fields = FieldLine.split_line(header_line, parsed)
+
+      # Format header line the same way as data lines
+      formatted_header = FieldLine.new(
+        fields: fields,
+        delimiter: parsed,
+        mapping: FieldMapping.numeric
+      ).to_s
+
+      [FieldMapping.from_fields(fields.map(&:strip)), formatted_header]
+    end
+    private_class_method :build_mapping
+  end
+end

data/lib/zone/field_line.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative 'field_mapping'
+
+module Zone
+  class FieldLine
+    def self.parse(text, delimiter:, mapping: nil, logger: nil)
+      parsed_delimiter = parse_delimiter(delimiter)
+
+      fields = split_line(text, parsed_delimiter)
+
+      new(
+        fields: fields,
+        delimiter: parsed_delimiter,
+        mapping: mapping
+      )
+    end
+
+    def self.parse_delimiter(delimiter_string)
+      case delimiter_string
+      in /^\/(.*)\/$/
+        # Regex delimiter wrapped in slashes: "/\s+/" -> /\s+/
+        Regexp.new($1)
+      in String => d
+        # String delimiter: "," -> ","
+        d
+      else
+        raise ArgumentError, "Invalid delimiter: #{delimiter_string.inspect}"
+      end
+    end
+
+    def self.split_line(line, delimiter)
+      case [line, delimiter]
+      in [String, ""]
+        [line]
+      in [String, String | Regexp]
+        line.split(delimiter)
+      else
+        raise ArgumentError, "Invalid delimiter type: #{delimiter.class}"
+      end
+    end
+
+    def initialize(fields:, delimiter:, mapping: nil)
+      @fields = fields.map(&:strip)
+      @delimiter = delimiter
+      @mapping = mapping || FieldMapping.numeric
+    end
+
+    def [](key)
+      index = @mapping.resolve(key)
+      @fields[index]
+    end
+
+    def transform(key, &block)
+      index = @mapping.resolve(key)
+      @fields[index] = block.call(@fields[index])
+      self
+    end
+
+    def transform_all(&block)
+      @fields.map!(&block)
+      self
+    end
+
+    def to_s
+      output_delim = case @delimiter
+      when Regexp
+        "\t"
+      when ","
+        "\t"
+      else
+        @delimiter
+      end
+
+      case @fields.count
+      in 1
+        @fields[0].to_s
+      else
+        @fields.join(output_delim)
+      end
+    end
+
+    def to_a
+      @fields.dup
+    end
+
+    def to_h
+      return {} unless @mapping.has_names?
+
+      @mapping.names.zip(@fields).to_h
+    end
+
+    def fields
+      @fields.dup
+    end
+  end
+end

data/lib/zone/field_mapping.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Zone
+  class FieldMapping
+    def self.from_fields(fields)
+      name_to_index = fields.each_with_index.to_h
+      new(name_to_index: name_to_index)
+    end
+
+    def self.numeric
+      new(name_to_index: nil)
+    end
+
+    def initialize(name_to_index:)
+      @name_to_index = name_to_index
+    end
+
+    def resolve(key)
+      case key
+      in String => name if name.match?(/^\d+$/)
+        # Numeric string - convert to integer and resolve
+        name.to_i - 1
+      in String => name
+        if @name_to_index
+          @name_to_index.fetch(name) do
+            raise KeyError, "Field '#{name}' not found in mapping"
+          end
+        else
+          raise KeyError, "Cannot access field by name without headers. Use --headers or numeric field index."
+        end
+      in Integer => index
+        # Convert 1-based user input to 0-based array index
+        index - 1
+      else
+        raise ArgumentError, "Key must be String or Integer, got #{key.class}"
+      end
+    end
+
+    def [](key)
+      resolve(key)
+    end
+
+    def names
+      @name_to_index&.keys || []
+    end
+
+    def has_names?
+      !@name_to_index.nil?
+    end
+  end
+end

data/lib/zone/input.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'timestamp_patterns'
+
+module Zone
+  class Input
+    def initialize(argv, stdin: $stdin)
+      @argv = argv
+      @stdin = stdin
+    end
+
+    def each_line(&block)
+      source.each(&block)
+    end
+
+    def skip_headers?
+      @skip_first ||= false
+      if @skip_first
+        @skip_first = false
+        true
+      else
+        false
+      end
+    end
+
+    def mark_skip_headers!
+      @skip_first = true
+    end
+
+    def from_arguments?
+      @argv.any?
+    end
+
+    private
+
+    def source
+      @source ||= begin
+        if @argv.any?
+          # Arguments provided - use them as timestamps
+          @argv
+        elsif !@stdin.tty?
+          # No arguments but stdin is piped - read from stdin
+          # Convert to array so it can be iterated multiple times (e.g., for headers)
+          @stdin.each_line(chomp: true).to_a
+        else
+          # Interactive mode with no arguments - use current time
+          [Time.now.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/zone/logging.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'colors'
+
+module Zone
+  module Logging
+    module_function
+
+    def build(verbose:)
+      Logger.new($stderr).tap do |l|
+        l.formatter = formatter
+        l.level = verbose ? Logger::DEBUG : Logger::WARN
+      end
+    end
+
+    def formatter
+      ->(severity, _datetime, _progname, message) {
+        prefix, color = log_style(severity)
+        formatted = "#{prefix} #{message}"
+        colored = color ? Colors.colors($stderr).send(color, formatted) : formatted
+        "#{colored}\n"
+      }
+    end
+    private_class_method :formatter
+
+    def log_style(severity)
+      case severity
+      in "INFO"  then ["→", :cyan]
+      in "WARN"  then ["⚠", :yellow]
+      in "ERROR" then ["✗", :red]
+      in "DEBUG" then ["DEBUG:", nil]
+      else ["?", nil]
+      end
+    end
+    private_class_method :log_style
+  end
+end

data/lib/zone/options.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Zone
+  class Options < OptionParser
+    attr_reader :field, :delimiter, :zone, :format, :color, :headers
+    attr_accessor :verbose
+
+    def initialize
+      super
+
+      @field = nil
+      @delimiter = nil
+      @zone = 'local'
+      @format = { pretty: 1 }
+      @color = 'auto'
+      @headers = false
+      @verbose = false
+
+      setup_options
+    end
+
+    #
+    # Validate options and their combinations.
+    #
+    # @return [self]
+    #   Returns self for method chaining
+    #
+    # @raise [ArgumentError]
+    #   If validation fails
+    #
+    def validate!
+      validate_timezone!
+      validate_field_mode!
+      self
+    end
+
+    private
+
+    def validate_timezone!
+      case @zone
+      in 'utc' | 'UTC' | 'local'
+        # Valid special timezone keywords
+      else
+        tz = Zone.find(@zone)
+        raise ArgumentError, "Could not find timezone '#{@zone}'" if tz.nil?
+      end
+    end
+
+    def validate_field_mode!
+      if @field && !@delimiter
+        raise ArgumentError, "--field requires --delimiter\nExample: zone --field 2 --delimiter ','"
+      end
+
+      if @headers && !@field
+        raise ArgumentError, "--headers requires --field"
+      end
+    end
+
+    def setup_options
+      self.banner = "Usage: zone [options] [timestamps...]"
+
+      separator ""
+      separator "Modes:"
+      separator "  Pattern Mode (default): Finds and converts timestamps in arbitrary text"
+      separator "    Example: echo 'Event at 2025-01-15T10:30:00Z' | zone"
+      separator ""
+      separator "  Field Mode: Converts specific field in delimited data (requires --field and --delimiter)"
+      separator "    Example: echo 'alice,1736937000,active' | zone --field 2 --delimiter ','"
+
+      separator ""
+      separator "Output Formats:"
+      on '--iso8601', 'Output in ISO 8601' do
+        @format = :to_iso8601
+      end
+
+      on '-f', '--strftime FORMAT', 'Output format using strftime' do |fmt|
+        @format = { strftime: fmt }
+      end
+
+      on '-p', '--pretty [STYLE]', Integer, 'Pretty format (1=12hr, 2=24hr, 3=ISO-compact, default: 1)' do |style|
+        style ||= 1
+        unless [1, 2, 3].include?(style)
+          raise ArgumentError, "Invalid pretty format -p#{style} (must be 1, 2, or 3)"
+        end
+        @format = { pretty: style }
+      end
+
+      on '--unix', 'Output as Unix timestamp' do
+        @format = :to_unix
+      end
+
+      separator ""
+      separator "Timezones:"
+      on '--require STRING', 'Require external library like "active_support" for more powerful parsing' do |requirement|
+        require requirement
+      end
+
+      on '--zone TZ', '-z', 'Convert to time zone (default: local)' do |tz|
+        @zone = tz
+      end
+
+      on '--local', 'Convert to local time zone (alias for --zone local)' do
+        @zone = 'local'
+      end
+
+      on '--utc', 'Convert to UTC time zone (alias for --zone UTC)' do
+        @zone = 'utc'
+      end
+
+      separator ""
+      separator "Field Mode Options:"
+      on '--field FIELD', String, 'Field index or name to convert (requires --delimiter)' do |field|
+        @field = field
+      end
+
+      on '-d', '--delimiter PATTERN', 'Field separator (string or /regex/, required for --field)' do |delim|
+        @delimiter = delim
+      end
+
+      on '--headers', 'Skip first line as headers (requires --field)' do
+        @headers = true
+      end
+
+      separator ""
+      separator "Other:"
+      on '--color MODE', ['auto', 'always', 'never'], 'Colorize output (auto, always, never, default: auto)' do |mode|
+        @color = mode
+      end
+
+      on '--verbose', '-v', 'Enable verbose/debug output' do
+        @verbose = true
+      end
+
+      on '--help', '-h', 'Show this help message' do
+        puts self
+        exit
+      end
+    end
+  end
+end

data/lib/zone/output.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'colors'
+
+module Zone
+  class Output
+    def initialize(color_mode: 'auto', stream: $stdout)
+      @stream = stream
+      @colors = colorize(color_mode)
+    end
+
+    def puts(text)
+      @stream.puts(text)
+    end
+
+    def puts_highlighted(text, highlight:)
+      highlight_str = highlight.to_s
+      output = text.sub(highlight_str, @colors.cyan(highlight_str))
+      @stream.puts(output)
+    end
+
+    def colorize_timestamp(timestamp)
+      @colors.cyan(timestamp)
+    end
+
+    private
+
+    def colorize(mode)
+      case mode
+      when 'always'
+        Colors::ANSI
+      when 'never'
+        Colors::PlainText
+      when 'auto'
+        Colors.colors(@stream)
+      end
+    end
+  end
+end