loo_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0ca9ec11cfc3a15201c750a61ff90c5b2714a111ea80140808db40893c944590
+  data.tar.gz: 21cf0438fea415a1c22dd87530ebb9e9c3cdd0e0b96e9e7a377e98c08cd3e1b4
+SHA512:
+  metadata.gz: e98585a18fdb60421e3bb5df9116362490c7324aa8394d73663e13b62b86ca88dbcc7ac1034cae6a4913a07f0c9b8ce19e5a17ce007e7ee9f69f593c9bb26a76
+  data.tar.gz: 4d0499226d6c1f860a6ff10ed78dab5202a374f3482521af4c33aa08a13f97f23d334d83d3e31338268ac7eb680b39080030926515f2c1e01221153be92f3d10

data/.overcommit.yml

@@ -0,0 +1,14 @@
+CommandContext:
+  bundle_exec: true
+
+PreCommit:
+  RuboCop:
+    enabled: true
+    command: [ 'bundle', 'exec', 'rubocop' ]
+
+  BundleCheck:
+    enabled: true # Check if Gemfile.lock is up-to-date
+
+  Brakeman:
+    enabled: true
+    command: [ 'bundle', 'exec', 'brakeman', '-A', '--force' ] # -A scans current dir, --force ignores missing Rails structure

data/.rspec_status

@@ -0,0 +1,36 @@
+example_id                                | status | run_time        |
+----------------------------------------- | ------ | --------------- |
+./spec/loo_parser/parser_spec.rb[1:1:1]   | passed | 0.00085 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:2]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:3]   | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:4]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:5]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:6]   | passed | 0.00025 seconds |
+./spec/loo_parser/parser_spec.rb[1:1:7]   | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:2:1]   | passed | 0.00011 seconds |
+./spec/loo_parser/parser_spec.rb[1:2:2]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:2:3]   | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:2:4]   | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:1]   | passed | 0.00012 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:1] | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:2] | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:3] | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:4] | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:5] | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:2:6] | passed | 0.00002 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:3]   | passed | 0.00005 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:4]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:5]   | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:6]   | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:7]   | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:8]   | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:9]   | passed | 0.00005 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:10]  | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:11]  | passed | 0.00005 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:12]  | passed | 0.00005 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:13]  | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:14]  | passed | 0.00004 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:15]  | passed | 0.00003 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:16]  | passed | 0.00029 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:17]  | passed | 0.00005 seconds |
+./spec/loo_parser/parser_spec.rb[1:3:18]  | passed | 0.00004 seconds |

data/.rubocop.yml

@@ -0,0 +1,92 @@
+plugins:
+- rubocop-performance
+- rubocop-rake
+- rubocop-rspec
+
+AllCops:
+  # Use the Ruby version from your .ruby-version file or specify explicitly
+  TargetRubyVersion: 3.1 # Or determine dynamically if possible
+  NewCops: enable
+  Exclude:
+  - 'bin/console'
+  - 'db/schema.rb'
+  - 'tmp/**/*'
+  - 'vendor/**/*'
+  - 'node_modules/**/*'
+  - 'spec/fixtures/**/*'
+  - 'config/initializers/*' # Common for Rails
+  - 'config/environments/*' # Common for Rails
+
+# Common Style Preferences
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Layout/LineLength:
+  Enabled: false # Disabled as requested
+  # Max: 100
+  # AllowHeredoc: true
+  # AllowURI: true
+  IgnoreCopDirectives: true
+  Exclude:
+  - '*.gemspec' # Gemspec files often have long lines
+
+# Often noisy in tests
+Metrics/BlockLength:
+  Max: 55 # Increased further to accommodate parser block
+  Exclude:
+  - 'spec/**/*.rb'
+  - 'Rakefile'
+  - '*.gemspec'
+  # - 'lib/loo_parser/parser.rb' # Remove exclusion, rely on higher Max
+
+Metrics/ClassLength:
+  Max: 150 # Increased from 100
+
+Metrics/MethodLength:
+  Max: 25 # Increased from 15
+  Exclude:
+  - 'spec/**/*.rb'
+  - 'lib/loo_parser/parser.rb' # Exclude the main parser methods
+
+Metrics/AbcSize:
+  Max: 25 # Increased from 20
+  Exclude:
+  - 'spec/**/*.rb'
+  - 'lib/loo_parser/parser.rb' # Exclude the main parser methods
+
+Metrics/CyclomaticComplexity:
+  Max: 10 # Increased from 7
+  Exclude:
+  - 'lib/loo_parser/parser.rb'
+
+Metrics/PerceivedComplexity:
+  Max: 11 # Increased from 8
+  Exclude:
+  - 'lib/loo_parser/parser.rb'
+
+Metrics/ParameterLists:
+  Max: 6 # Allow one more param
+
+# RSpec Specific configuration
+# Note: The RSpec namespace here is just for grouping settings visually;
+# individual cops are configured directly (e.g., RSpec/MultipleExpectations)
+# RSpec:
+#   Enabled: true # Example if you needed to disable all RSpec cops
+
+RSpec/ExampleLength:
+  Max: 15 # Increased from 5
+
+RSpec/MultipleExpectations:
+  Max: 5 # Allow a few expectations per test
+
+RSpec/NestedGroups:
+  Max: 4 # Allow slightly deeper nesting

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.1.0] - 2024-06-23
+
+- Initial release of Loo Parser gem
+- Added core functionality for parsing WhatsApp chat logs
+- Support for tracking 💩 and 🚽 emoji messages
+- Command-line interface for processing export files

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 BrownOps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# Loo Parser (Ruby Gem)
+
+[![Test & Lint](https://github.com/BrownOps/loo_parser.rb/actions/workflows/test.yml/badge.svg)](https://github.com/BrownOps/loo_parser.rb/actions/workflows/test.yml)
+
+A Ruby tool for parsing WhatsApp chat exports to track and analyze bathroom usage patterns through specific emoji-based messages.
+
+## Overview
+
+Loo Parser processes WhatsApp chat logs to extract, track, and analyze messages containing 💩 and 🚽 emojis according to a specific syntax. It helps keep track of bathroom usage over time by different chat participants, including timing and frequency analysis.
+
+## Features
+
+- Parse WhatsApp chat exports (.txt format)
+- Recognize multiple message formats for tracking events:
+  - Live events (happening now): `💩`
+  - Past events (specific time): `💩 YYYY-MM-DD HH:MM`
+  - Events with time shift: `💩 +N` or `💩 -N`
+  - Setting default time shift: `🚽 +N` or `🚽 -N`
+- Track per-user bathroom usage patterns (via default shift)
+- Detect and alert on unusual timing patterns (>30 days between event and message)
+- Export structured data as JSON for further analysis
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'loo_parser'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install loo_parser
+```
+
+## Usage
+
+After installation, you can run the parser from your command line:
+
+```bash
+loo-parser parse [INPUT_FILE] [OUTPUT_FILE]
+```
+
+For example, using a sample file:
+
+```bash
+loo-parser parse whatsapp_chat_example.txt example_results.json
+```
+
+This will parse the `whatsapp_chat_example.txt` file and save the extracted events to `example_results.json`.
+
+If no files are specified, it will default to `whatsapp_chat.txt` for input and `poop_results.json` for output.
+
+### Message Format Examples
+
+The parser recognizes the following message formats within the WhatsApp export:
+
+```
+[DD/MM/YY, HH:MM:SS] Alice: 💩                         # Current poop event
+[DD/MM/YY, HH:MM:SS] Bob: 💩 2023-04-15 08:30          # Past poop event
+[DD/MM/YY, HH:MM:SS] Charlie: 💩 +2                    # Current poop with +2 shift
+[DD/MM/YY, HH:MM:SS] Dave: 💩 -1 2023-04-10 19:45      # Past poop with -1 shift
+[DD/MM/YY, HH:MM:SS] Eve: 🚽 +3                        # Set default shift to +3 for Eve
+```
+
+### Output Format
+
+The parser outputs JSON data in the following format (datetimes are ISO8601 strings, statuses/types are strings):
+
+```json
+[
+  {
+    "sender": "Alice",
+    "message_timestamp": "2023-05-01T10:05:00+00:00",
+    "original_message": "💩",
+    "type": "poop_live",
+    "shift": 0,
+    "poop_time": "2023-05-01T10:05:00+00:00",
+    "status": "ok"
+  },
+  {
+    "sender": "Bob",
+    "message_timestamp": "2023-05-01T10:07:00+00:00",
+    "original_message": "💩 2023-04-30 09:00",
+    "type": "poop_past",
+    "shift": 0,
+    "poop_time": "2023-04-30T09:00:00+00:00",
+    "status": "ok"
+  },
+  {
+    "sender": "Dave",
+    "message_timestamp": "2023-06-15T10:00:00+00:00",
+    "original_message": "💩 2023-04-10 09:00",
+    "type": "poop_past",
+    "shift": 0,
+    "poop_time": "2023-04-10T09:00:00+00:00",
+    "status": "alert"
+  }
+]
+```
+
+Status values can be:
+
+- `ok`: Normal event (reported within 30 days of occurrence)
+- `alert`: Event reported more than 30 days after occurrence
+- `error`: Invalid format or parsing error (includes specific error types)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Running Tests
+
+```bash
+bundle exec rake spec
+# or
+bundle exec rspec
+```
+
+### Linting
+
+```bash
+bundle exec rake rubocop
+# or
+bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/BrownOps/loo_parser.rb](https://github.com/BrownOps/loo_parser.rb).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--format documentation" # Or your preferred format
+end
+
+RuboCop::RakeTask.new(:rubocop)
+
+# Default task
+task default: %i[spec rubocop]

data/exe/loo-parser

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/loo_parser"
+
+# Run the CLI command defined in LooParser::CLI
+LooParser::CLI.start(ARGV)

data/lib/loo_parser/cli.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "parser"
+
+module LooParser
+  # Defines the command-line interface commands
+  class CLI < Thor
+    package_name "LooParser"
+
+    desc "parse [INPUT_FILE] [OUTPUT_FILE]", "Parse WhatsApp chat export and save results."
+    long_desc <<-LONGDESC
+      Parses a WhatsApp chat export file (.txt) to find 💩 and 🚽 messages,
+      analyzing bathroom usage patterns.
+
+      Defaults:
+        INPUT_FILE: whatsapp_chat.txt
+        OUTPUT_FILE: poop_results.json
+    LONGDESC
+    def parse(input_file = "whatsapp_chat.txt", output_file = "poop_results.json")
+      puts "Starting analysis of #{input_file}..."
+      exit_code = LooParser::Parser.run(input_file, output_file)
+      exit(exit_code)
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit(1)
+    end
+
+    desc "version", "Show LooParser version"
+    def version
+      puts LooParser::VERSION
+    end
+  end
+end

data/lib/loo_parser/parser.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+
+module LooParser
+  # Core logic for parsing WhatsApp chat logs
+  module Parser
+    # Represents a parsed WhatsApp message
+    WhatsAppMessage = Struct.new(:timestamp, :sender, :content, keyword_init: true)
+
+    # Regex patterns for message types (order matters)
+    PATTERNS = {
+      toilet_set_shift: /^🚽\s*([+-]?\d+)(?:\s+.*)?$/,
+      poop_live_shift: /^💩\s*([+-]\d+)$/,
+      poop_past_shift: /^💩\s*([+-]\d+)\s+(\d{4}-\d{1,2}-\d{1,2})\s+(\d{1,2}:\d{2})(?:\s+.*)?$/,
+      poop_past: /^💩\s*(\d{4}-\d{1,2}-\d{1,2})\s+(\d{1,2}:\d{2})(?:\s+.*)?$/,
+      poop_live: /^💩/
+    }.freeze
+
+    # Parse date and time strings into a DateTime object
+    def self.parse_datetime(date_str, time_str)
+      # Basic sanity check: ensure input strings contain digits before parsing
+      return nil unless date_str&.match?(/\d/) && time_str&.match?(/\d/)
+
+      DateTime.parse("#{date_str} #{time_str}")
+    rescue Date::Error
+      nil
+    end
+
+    # Parse a single WhatsApp export line
+    # Example input: "[02/05/25, 14:30:15] Alice: Hello"
+    def self.parse_whatsapp_line(line)
+      pattern = %r{\[(\d{2})/(\d{2})/(\d{2}), (\d{2}):(\d{2}):(\d{2})\] (.*?): (.+)}
+      match = pattern.match(line)
+      return nil unless match
+
+      day, month, year_short, hh, mm, ss, sender, content = match.captures
+      year = "20#{year_short}"
+      timestamp = DateTime.parse("#{year}-#{month}-#{day}T#{hh}:#{mm}:#{ss}")
+      WhatsAppMessage.new(timestamp: timestamp, sender: sender.strip, content: content.strip)
+    rescue ArgumentError
+      nil
+    end
+
+    # Analyzer class to process messages
+    class Analyzer
+      attr_reader :sender_shift
+
+      def initialize
+        @sender_shift = Hash.new(0)
+      end
+
+      def analyze_messages(messages)
+        messages.filter_map { |msg| process_message(msg) }
+      end
+
+      private
+
+      def process_message(msg)
+        text = msg.content
+        PATTERNS.each do |type, regex|
+          match = regex.match(text)
+          next unless match
+
+          groups = match.captures
+
+          # Handle toilet shift setting
+          if type == :toilet_set_shift
+            begin
+              shift = Integer(groups[0])
+              @sender_shift[msg.sender] = shift
+              return {
+                sender: msg.sender,
+                message_timestamp: msg.timestamp,
+                type: type,
+                shift: shift,
+                status: :ok
+              }
+            rescue ArgumentError
+              return {
+                sender: msg.sender,
+                message_timestamp: msg.timestamp,
+                original_message: text,
+                type: :toilet_set_shift_invalid_number,
+                status: :error
+              }
+            end
+          end
+
+          # Handle poop events
+          begin
+            shift, poop_time = extract_poop_info(type, groups, msg)
+
+            if poop_time.nil?
+              status = :error
+              details = :invalid_datetime_format
+            else
+              status = compute_status(poop_time, msg.timestamp)
+              details = nil
+            end
+
+            result = {
+              sender: msg.sender,
+              message_timestamp: msg.timestamp,
+              original_message: text,
+              type: type,
+              shift: shift,
+              poop_time: poop_time,
+              status: status
+            }
+            result[:error_details] = details if details
+            return result
+          rescue ArgumentError, TypeError
+            return {
+              sender: msg.sender,
+              message_timestamp: msg.timestamp,
+              original_message: text,
+              type: :"#{type}_processing_error",
+              status: :error
+            }
+          end
+        end
+
+        # Handle messages with emojis but not matching patterns
+        if text.include?("💩")
+          return {
+            sender: msg.sender,
+            message_timestamp: msg.timestamp,
+            original_message: text,
+            type: :unrecognized_poop_emoji,
+            status: :error
+          }
+        end
+
+        if text.include?("🚽")
+          return {
+            sender: msg.sender,
+            message_timestamp: msg.timestamp,
+            original_message: text,
+            type: :unrecognized_toilet_emoji,
+            status: :error
+          }
+        end
+
+        nil
+      end
+
+      def extract_poop_info(type, groups, msg)
+        current_sender_shift = @sender_shift[msg.sender]
+
+        case type
+        when :poop_live
+          [current_sender_shift, msg.timestamp]
+        when :poop_live_shift
+          shift = Integer(groups[0])
+          [shift, msg.timestamp]
+        when :poop_past
+          poop_dt = Parser.parse_datetime(groups[0], groups[1])
+          [current_sender_shift, poop_dt]
+        when :poop_past_shift
+          shift = Integer(groups[0])
+          poop_dt = Parser.parse_datetime(groups[1], groups[2])
+          [shift, poop_dt]
+        else
+          [0, nil]
+        end
+      end
+
+      def compute_status(poop_time, message_timestamp)
+        return :error unless poop_time.is_a?(DateTime)
+
+        # Calculate difference in days
+        time_difference_days = message_timestamp - poop_time
+
+        time_difference_days > 30 ? :alert : :ok
+      end
+    end
+
+    # Main execution logic called by CLI
+    def self.run(input_file, output_file)
+      # Read input file
+      lines = File.readlines(input_file, chomp: true, encoding: "UTF-8")
+
+      # Parse messages
+      messages = lines.filter_map { |line| parse_whatsapp_line(line) }
+
+      # Analyze messages
+      analyzer = Analyzer.new
+      results = analyzer.analyze_messages(messages)
+
+      # Print summary
+      puts "Processed #{messages.count} valid messages, found #{results.count} relevant records."
+
+      # Custom JSON conversion for DateTime and Symbols
+      json_results = results.map do |record|
+        record.transform_values do |value|
+          case value
+          when DateTime
+            value.strftime("%Y-%m-%dT%H:%M:%S")
+          when Symbol
+            value.to_s
+          else
+            value
+          end
+        end
+      end
+
+      # Store results as JSON
+      File.write(output_file, JSON.pretty_generate(json_results))
+
+      puts "Results saved to #{output_file}"
+      0
+    rescue Errno::ENOENT
+      warn "Error: Input file not found: #{input_file}"
+      1
+    rescue StandardError => e
+      warn "An unexpected error occurred: #{e.message}"
+      warn e.backtrace.join("\n")
+      1
+    end
+  end
+end

data/lib/loo_parser/version.rb

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

data/lib/loo_parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+require_relative "loo_parser/version"
+require_relative "loo_parser/parser"
+require_relative "loo_parser/cli"
+
+# Main module for the LooParser gem
+module LooParser
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+# Optional: if using Zeitwerk
+# loader.eager_load # Optional: If you want to load everything upfront

data/sig/loo_parser.rbs

@@ -0,0 +1,4 @@
+module LooParser
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: loo_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BrownOps
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: "Loo Parser processes WhatsApp chat logs to extract, track, and analyze
+  messages containing \U0001F4A9 and \U0001F6BD emojis according to a specific syntax.\nIt
+  helps keep track of bathroom usage over time by different chat participants, including
+  timing and frequency analysis.\n"
+email:
+- nethersoul.dev@gmail.com
+executables:
+- loo-parser
+extensions: []
+extra_rdoc_files: []
+files:
+- ".overcommit.yml"
+- ".rspec_status"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/loo-parser
+- lib/loo_parser.rb
+- lib/loo_parser/cli.rb
+- lib/loo_parser/parser.rb
+- lib/loo_parser/version.rb
+- sig/loo_parser.rbs
+homepage: https://github.com/BrownOps/loo_parser.rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/BrownOps/loo_parser.rb
+  source_code_uri: https://github.com/BrownOps/loo_parser.rb
+  changelog_uri: https://github.com/BrownOps/loo_parser.rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A Ruby tool for parsing WhatsApp chat exports to track bathroom usage patterns.
+test_files: []