toilet_tracker 0.1.0

data/exe/toilet_tracker

@@ -0,0 +1,419 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add lib directory to load path for development (when running from source)
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+# Only use bundler/setup when running from source directory (has Gemfile)
+gemfile_path = File.expand_path('../Gemfile', __dir__)
+if File.exist?(gemfile_path)
+  begin
+    require 'bundler/setup'
+  rescue LoadError
+    # If bundler is not available, just continue
+  end
+end
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'toilet_tracker'
+require 'thor'
+require 'tty-prompt'
+require 'json'
+require 'csv'
+
+module ToiletTracker
+  class CLI < Thor
+    class_option :timezone, aliases: '-t', type: :string, default: 'UTC',
+                            desc: 'Default timezone (default: UTC)'
+    class_option :errors, aliases: '-e', type: :boolean, default: false,
+                          desc: 'Include error results in output'
+    class_option :retroactive, aliases: '-r', type: :boolean, default: true,
+                               desc: 'Apply retroactive timezone shifts'
+
+    desc 'parse FILE', 'Parse WhatsApp messages from a file'
+    method_option :format, aliases: '-f', type: :string, default: 'table',
+                           enum: %w[table json csv], desc: 'Output format'
+    def parse(file_path = nil)
+      setup_configuration
+
+      unless file_path
+        error 'FILE argument is required'
+        puts 'Usage: toilet_tracker parse FILE'
+        exit 1
+      end
+
+      unless File.exist?(file_path)
+        error "File not found: #{file_path}"
+        exit 1
+      end
+
+      lines = read_input_file(file_path)
+      results = ToiletTracker.parse_lines(lines)
+
+      output_results(results)
+    end
+
+    desc 'interactive', 'Interactive mode for parsing messages'
+    def interactive
+      setup_configuration
+      prompt = TTY::Prompt.new
+
+      loop do
+        action = prompt.select('What would you like to do?') do |menu|
+          menu.choice 'Parse a file', :parse_file
+          menu.choice 'Parse from clipboard', :parse_clipboard
+          menu.choice 'Enter message manually', :manual_entry
+          menu.choice 'Exit', :exit
+        end
+
+        case action
+        when :parse_file
+          file_path = prompt.ask('Enter file path:')
+          if File.exist?(file_path)
+            begin
+              lines = read_input_file(file_path)
+              results = ToiletTracker.parse_lines(lines)
+
+              handle_interactive_results(results, prompt)
+            rescue ToiletTracker::Utils::ZipHandler::ZipError => e
+              prompt.error("Zip file error: #{e.message}")
+            rescue StandardError => e
+              prompt.error("File reading error: #{e.message}")
+            end
+          else
+            prompt.error("File not found: #{file_path}")
+          end
+
+        when :parse_clipboard
+          prompt.say('Please paste your WhatsApp messages (press Ctrl+D when done):')
+          lines = $stdin.readlines(chomp: true)
+          results = ToiletTracker.parse_lines(lines)
+
+          handle_interactive_results(results, prompt)
+
+        when :manual_entry
+          message = prompt.ask('Enter WhatsApp message:')
+          results = ToiletTracker.parse_lines([message])
+          handle_interactive_results(results, prompt)
+
+        when :exit
+          prompt.say('Goodbye! 💩')
+          break
+        end
+
+        prompt.keypress('Press any key to continue...', keys: [:return])
+      end
+    end
+
+    desc 'version', 'Show version'
+    def version
+      puts "ToiletTracker #{ToiletTracker::VERSION}"
+    end
+
+    desc 'stats FILE', 'Show parsing statistics for a file'
+    def stats(file_path = nil)
+      setup_configuration
+
+      unless file_path
+        error 'FILE argument is required'
+        puts 'Usage: toilet_tracker stats FILE'
+        exit 1
+      end
+
+      unless File.exist?(file_path)
+        error "File not found: #{file_path}"
+        exit 1
+      end
+
+      lines = read_input_file(file_path)
+      results = ToiletTracker.parse_lines(lines)
+
+      show_statistics(results, lines.size)
+    end
+
+    private
+
+    def setup_configuration
+      ToiletTracker.configure do |config|
+        config.default_timezone = options[:timezone]
+      end
+    end
+
+    def read_input_file(file_path)
+      if ToiletTracker::Utils::ZipHandler.zip_file?(file_path)
+        temp_chat_file = ToiletTracker::Utils::ZipHandler.extract_chat_file(file_path)
+
+        # Ensure temp file is cleaned up after reading
+        begin
+          File.readlines(temp_chat_file, chomp: true)
+        ensure
+          FileUtils.rm_f(temp_chat_file)
+        end
+      else
+        File.readlines(file_path, chomp: true)
+      end
+    end
+
+    def handle_interactive_results(results, prompt)
+      # First, show the results
+      format = prompt.select('Output format?', %w[table json csv])
+      output_results(results, format: format)
+
+      # Ask if they want to save to file
+      return unless prompt.yes?('Save results to file?')
+
+      default_filename = "toilet_tracker_results_#{Time.now.strftime('%Y%m%d_%H%M%S')}.#{format == 'table' ? 'txt' : format}"
+      filename = prompt.ask('Enter filename:', default: default_filename)
+
+      save_results_to_file(results, filename, format, prompt)
+    end
+
+    def save_results_to_file(results, filename, format, prompt)
+      case format
+      when 'json'
+        File.write(filename, JSON.pretty_generate(serialize_results(filter_results(results))))
+      when 'csv'
+        require 'csv'
+        CSV.open(filename, 'w') do |csv|
+          csv << ['Type', 'Status', 'Sender', 'Message Time', 'Event Time', 'Shift', 'Content']
+          filter_results(results).each do |result|
+            next unless result
+
+            row = [
+              result.type,
+              result.status,
+              result.message&.sender,
+              result.message&.timestamp&.iso8601,
+              extract_event_time(result)&.iso8601,
+              extract_shift(result),
+              result.message&.content
+            ]
+            csv << row
+          end
+        end
+      when 'table'
+        File.open(filename, 'w') do |file|
+          filtered_results = filter_results(results)
+          if filtered_results.empty?
+            file.puts 'No results found.'
+          else
+            headers = ['Type', 'Status', 'Sender', 'Message Time', 'Event Time', 'Shift', 'Content']
+            rows = filtered_results.filter_map do |result|
+              next unless result
+
+              [
+                result.type || 'unknown',
+                result.status || 'unknown',
+                result.message&.sender || 'unknown',
+                result.message&.timestamp&.strftime('%Y-%m-%d %H:%M:%S') || 'unknown',
+                extract_event_time(result)&.strftime('%Y-%m-%d %H:%M:%S') || 'unknown',
+                extract_shift(result) || '0',
+                (result.message&.content || '')[0..50]
+              ]
+            end
+
+            # Calculate column widths
+            widths = headers.map.with_index do |header, i|
+              [header.length, *rows.map { |row| row[i].to_s.length }].max
+            end
+
+            # Write header
+            header_line = headers.map.with_index { |h, i| h.ljust(widths[i]) }.join('  ')
+            file.puts header_line
+            file.puts '-' * header_line.length
+
+            # Write rows
+            rows.each do |row|
+              file.puts row.map.with_index { |cell, i| cell.to_s.ljust(widths[i]) }.join('  ')
+            end
+          end
+        end
+      end
+
+      prompt.ok("Results saved to: #{filename}")
+    rescue StandardError => e
+      prompt.error("Failed to save file: #{e.message}")
+    end
+
+    def output_results(results, format: nil)
+      format ||= options[:format] || 'table'
+      filtered_results = filter_results(results)
+
+      case format
+      when 'json'
+        puts JSON.pretty_generate(serialize_results(filtered_results))
+      when 'csv'
+        output_csv(filtered_results)
+      when 'table'
+        output_table(filtered_results)
+      end
+    end
+
+    def filter_results(results)
+      return results if options[:errors]
+
+      results.reject { |result| result&.status == :error }
+    end
+
+    def serialize_results(results)
+      results.map do |result|
+        case result
+        when Core::PoopEventResult
+          {
+            type: result.type,
+            status: result.status,
+            sender: result.message.sender,
+            message_timestamp: result.message.timestamp.iso8601,
+            poop_time: result.poop_time&.iso8601,
+            shift: result.shift,
+            timezone: result.timezone,
+            content: result.message.content,
+            error_details: result.error_details
+          }
+        when Core::ToiletShiftResult
+          {
+            type: result.type,
+            status: result.status,
+            sender: result.message.sender,
+            message_timestamp: result.message.timestamp.iso8601,
+            shift: result.shift,
+            effective_time: result.effective_time&.iso8601,
+            content: result.message.content,
+            error_details: result.error_details
+          }
+        else
+          {
+            type: result&.type,
+            status: result&.status,
+            content: result&.original_content || result&.message&.content,
+            error_details: result&.error_details
+          }
+        end
+      end
+    end
+
+    def output_csv(results)
+      CSV($stdout) do |csv|
+        csv << ['Type', 'Status', 'Sender', 'Message Time', 'Event Time', 'Shift', 'Content']
+
+        results.each do |result|
+          next unless result
+
+          row = [
+            result.type,
+            result.status,
+            result.message&.sender,
+            result.message&.timestamp&.iso8601,
+            extract_event_time(result)&.iso8601,
+            extract_shift(result),
+            result.message&.content
+          ]
+          csv << row
+        end
+      end
+    end
+
+    def output_table(results)
+      return puts 'No results found.' if results.empty?
+
+      headers = ['Type', 'Status', 'Sender', 'Message Time', 'Event Time', 'Shift', 'Content']
+      rows = results.filter_map do |result|
+        next unless result
+
+        [
+          result.type || 'unknown',
+          result.status || 'unknown',
+          result.message&.sender || 'unknown',
+          result.message&.timestamp&.strftime('%Y-%m-%d %H:%M:%S') || 'unknown',
+          extract_event_time(result)&.strftime('%Y-%m-%d %H:%M:%S') || 'unknown',
+          extract_shift(result) || '0',
+          (result.message&.content || '')[0..50]
+        ]
+      end
+
+      # Calculate column widths
+      widths = headers.map.with_index do |header, i|
+        [header.length, *rows.map { |row| row[i].to_s.length }].max
+      end
+
+      # Print header
+      header_line = headers.map.with_index { |h, i| h.ljust(widths[i]) }.join('  ')
+      puts header_line
+      puts '-' * header_line.length
+
+      # Print rows
+      rows.each do |row|
+        puts row.map.with_index { |cell, i| cell.to_s.ljust(widths[i]) }.join('  ')
+      end
+    end
+
+    def extract_event_time(result)
+      case result
+      when Core::PoopEventResult
+        result.poop_time
+      when Core::ToiletShiftResult
+        result.effective_time
+      else
+        result.message&.timestamp
+      end
+    end
+
+    def extract_shift(result)
+      case result
+      when Core::PoopEventResult, Core::ToiletShiftResult
+        result.shift
+      end
+    end
+
+    def show_statistics(results, total_lines)
+      filtered_results = filter_results(results)
+      error_results = results.select { |r| r&.status == :error }
+
+      # Calculate toilet-tracking relevant lines (successful + errors)
+      toilet_relevant_lines = filtered_results.size + error_results.size
+
+      puts '📊 Parsing Statistics'
+      puts '=' * 50
+      puts "Total chat lines: #{total_lines}"
+      puts "Toilet-tracking messages: #{toilet_relevant_lines}"
+      puts "Successfully parsed: #{filtered_results.size}"
+      puts "Parse errors: #{error_results.size}"
+      puts "Toilet tracking success rate: #{((filtered_results.size.to_f / toilet_relevant_lines) * 100).round(2)}%" if toilet_relevant_lines.positive?
+      puts "Overall relevance: #{((toilet_relevant_lines.to_f / total_lines) * 100).round(2)}%"
+      puts
+
+      if filtered_results.any?
+        types = filtered_results.group_by(&:type)
+        puts 'Message types:'
+        types.each do |type, messages|
+          puts "  #{type}: #{messages.size}"
+        end
+        puts
+
+        senders = filtered_results.filter_map { |r| r.message&.sender }.tally
+        puts 'Top senders:'
+        senders.sort_by { |_, count| -count }.first(5).each do |sender, count|
+          puts "  #{sender}: #{count}"
+        end
+      end
+
+      return unless error_results.any?
+
+      puts
+      puts 'Common toilet-tracking errors:'
+      error_types = error_results.filter_map(&:error_details).tally
+      error_types.sort_by { |_, count| -count }.first(3).each do |error, count|
+        puts "  #{error[0..80]}...: #{count}"
+      end
+    end
+
+    def error(message)
+      warn "Error: #{message}"
+    end
+  end
+end
+
+# Run CLI if this file is executed directly
+ToiletTracker::CLI.start(ARGV) if __FILE__ == $PROGRAM_NAME || File.basename($PROGRAM_NAME) == 'toilet_tracker'

data/lib/toilet_tracker/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module ToiletTracker
+  class Configuration
+    attr_accessor :default_timezone, :max_shift_hours, :message_patterns, :date_formats
+
+    def initialize
+      @default_timezone = 'UTC'
+      @max_shift_hours = 12
+      @message_patterns = {
+        shift_set: /🚽\s*([+-]?\d+)$/,
+        shift_set_at_time: /🚽\s*([+-]?\d+)\s+(.+)$/,
+        timezone_set: %r{🚽\s*([A-Za-z_/][A-Za-z0-9_/+-]*)$},
+        event_now: /💩$/,
+        event_now_shifted: /💩\s*([+-]?\d+)$/,
+        event_at_time: %r{💩\s*(\d{4}[-/]\d{1,2}[-/]\d{1,2}\s+\d{1,2}:\d{1,2}(?::\d{1,2})?)$},
+        event_at_time_shifted: %r{💩\s*([+-]?\d+)\s+(\d{4}[-/]\d{1,2}[-/]\d{1,2}\s+\d{1,2}:\d{1,2}(?::\d{1,2})?)},
+        event_in_timezone: %r{💩\s*([A-Za-z_/][A-Za-z0-9_/+-]*)\s*$},
+        event_in_timezone_at_time: %r{💩\s*([A-Za-z_/][A-Za-z0-9_/+-]*)\s+(\d{4}[-/]\d{1,2}[-/]\d{1,2}\s+\d{1,2}:\d{1,2}(?::\d{1,2})?)$}
+      }
+      @date_formats = [
+        '%Y-%m-%d %H:%M:%S',
+        '%Y-%m-%d %H:%M',
+        '%Y/%m/%d %H:%M:%S',
+        '%Y/%m/%d %H:%M'
+      ]
+    end
+
+    def default_timezone_object
+      ActiveSupport::TimeZone[@default_timezone] ||
+        (raise Core::InvalidTimezone, @default_timezone)
+    end
+
+    def valid_shift?(shift)
+      shift.is_a?(Integer) && shift.abs <= max_shift_hours
+    end
+
+    def whatsapp_message_pattern
+      @whatsapp_message_pattern ||= %r{\[(?<day>\d{2})/(?<month>\d{2})/(?<year>\d{2}),\s*(?<time>\d{2}:\d{2}:\d{2})\]\s*(?<sender>[^:]+):\s*(?<content>.+?)(?:\s*‎<This message was edited>)?$}
+    end
+
+    def edited_message_suffix
+      '‎<This message was edited>'
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/toilet_tracker/core/errors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Core
+    class Error < StandardError; end
+
+    class ParseError < Error; end
+
+    class InvalidMessageFormat < ParseError
+      attr_reader :message_content, :expected_format
+
+      def initialize(message_content, expected_format = nil)
+        @message_content = message_content
+        @expected_format = expected_format
+        super(build_error_message)
+      end
+
+      private
+
+      def build_error_message
+        msg = "Invalid message format: #{message_content.inspect}"
+        msg += " (expected: #{expected_format})" if expected_format
+        msg
+      end
+    end
+
+    class InvalidTimezone < ParseError
+      attr_reader :timezone_string
+
+      def initialize(timezone_string)
+        @timezone_string = timezone_string
+        super("Invalid timezone: #{timezone_string.inspect}")
+      end
+    end
+
+    class InvalidShift < ParseError
+      attr_reader :shift_value
+
+      def initialize(shift_value)
+        @shift_value = shift_value
+        super("Invalid shift value: #{shift_value.inspect} (must be between -12 and +12)")
+      end
+    end
+
+    class InvalidDateTime < ParseError
+      attr_reader :datetime_string
+
+      def initialize(datetime_string)
+        @datetime_string = datetime_string
+        super("Invalid date/time format: #{datetime_string.inspect}")
+      end
+    end
+
+    class ConfigurationError < Error; end
+  end
+end

data/lib/toilet_tracker/core/message.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/time'
+
+module ToiletTracker
+  module Core
+    Message = Data.define(:timestamp, :sender, :content) do
+      def initialize(timestamp:, sender:, content:)
+        parsed_timestamp = case timestamp
+                           when Time, ActiveSupport::TimeWithZone
+                             timestamp
+                           when String
+                             Time.parse(timestamp)
+                           else
+                             raise ArgumentError, "Invalid timestamp type: #{timestamp.class}"
+                           end
+
+        super(
+          timestamp: parsed_timestamp,
+          sender: sender.to_s.strip,
+          content: content.to_s
+        )
+      end
+
+      def valid?
+        timestamp.is_a?(Time) &&
+          !sender.empty? &&
+          !content.empty?
+      end
+
+      def age_in_days
+        (Time.current - timestamp) / 1.day
+      end
+
+      def recent?(days: 30)
+        age_in_days <= days
+      end
+    end
+  end
+end

data/lib/toilet_tracker/core/parse_result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Core
+    # Base class for all parse results
+    ParseResult = Data.define(:type, :status, :message, :error_details, :original_content) do
+      def initialize(type:, status:, message:, error_details: nil, original_content: nil)
+        super
+      end
+
+      def success?
+        status == :ok
+      end
+
+      def error?
+        status == :error
+      end
+
+      def alert?
+        status == :alert
+      end
+    end
+
+    # Result for toilet shift settings
+    ToiletShiftResult = Data.define(:type, :status, :message, :shift, :effective_time, :error_details) do
+      def initialize(type:, status:, message:, shift: nil, effective_time: nil, error_details: nil)
+        super
+      end
+    end
+
+    # Result for poop events
+    PoopEventResult = Data.define(:type, :status, :message, :shift, :poop_time, :timezone, :error_details) do
+      def initialize(type:, status:, message:, shift: nil, poop_time: nil, timezone: nil, error_details: nil)
+        super
+      end
+    end
+
+    # Result for timezone settings
+    TimezoneResult = Data.define(:type, :status, :message, :timezone, :shift_hours, :error_details) do
+      def initialize(type:, status:, message:, timezone: nil, shift_hours: nil, error_details: nil)
+        super
+      end
+    end
+  end
+end

data/lib/toilet_tracker/core/result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Core
+    Result = Data.define(:success?, :value, :error) do
+      def self.success(value)
+        new(success?: true, value: value, error: nil)
+      end
+
+      def self.failure(error)
+        new(success?: false, value: nil, error: error)
+      end
+
+      def failure?
+        !success?
+      end
+
+      def then
+        return self if failure?
+
+        begin
+          result = yield(value)
+          result.is_a?(Result) ? result : Result.success(result)
+        rescue StandardError => e
+          Result.failure(e)
+        end
+      end
+
+      def map
+        return self if failure?
+
+        begin
+          Result.success(yield(value))
+        rescue StandardError => e
+          Result.failure(e)
+        end
+      end
+
+      def value!
+        raise error if failure?
+
+        value
+      end
+    end
+  end
+end