whatsapp-chat-parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c63551e684919c385110d12bcbbe8e15bae0eef6e4ffe31a0617970f45f24bd6
+  data.tar.gz: a510d3a34c51154faae21a8f69d7629e6f0f0ca103a4cfddfbb7571013cc8d3c
+SHA512:
+  metadata.gz: c35b864edcaef50faed6aff4c32d80c8d12e7a624819165766a3e935052b7148aff429dfb674c714dae32b938b2f0e3a654e0fbf8628f2147ead5c46e46dfaa6
+  data.tar.gz: 16c197ee4c6ffc1f1e5ecfc94aadabde22a2b5329ab0b7059ffc2897b18afeb3f6b879a799649b98ac162506162d9a965a0ecfcd6e9423c0f11192a2f9880d48

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 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-02-18
+
+### Added
+- Initial release of `whatsapp-chat-parser`.
+- Support for parsing exported WhatsApp chat `.txt` files from both **Android and iOS** platforms.
+- Capability to parse both file streams and raw message strings.
+- Automatic encoding normalization for cross-platform file compatibility.
+- Support for multi-line messages.
+- High-precision timestamp parsing (including second-level precision for iOS).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Emmanuel Akachukwu
+
+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,146 @@
+# WhatsApp Chat Parser
+
+A Ruby library that parses exported WhatsApp chat `.txt` files and converts them into structured, machine-readable data. Designed for downstream processing such as analytics, ETL pipelines, storage, and transformation - not for rendering UI or interacting with the WhatsApp API.
+
+## Features
+
+- **Platform support**: Handles both Android and iOS WhatsApp chat exports
+- **Structured output**: Normalized message records suitable for JSON, databases, or further transformation
+- **Robust parsing**: Detects platform-specific formats, normalizes timestamps, and groups multi-line messages
+- **Deterministic**: No dependencies, explicit platform handling, predictable output structure
+- **Fail-safe**: Skips or handles malformed lines when possible instead of aborting
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'whatsapp-chat-parser'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install whatsapp-chat-parser
+```
+
+## Usage
+
+**Parse a single message string** (returns a `Message` or `nil` if malformed):
+
+```ruby
+require 'whatsapp-chat-parser'
+
+line = '12/15/25, 10:30:00 AM - John Doe: Hello World'
+msg = WhatsappChatParser.parse_line(line)
+puts "#{msg.timestamp} | #{msg.author}: #{msg.body}" if msg
+```
+
+**Parse a file by path or io** (returns an enumerable of `Message`; malformed lines are skipped):
+
+```ruby
+messages = WhatsappChatParser.parse_file('path/to/chat.txt')
+messages.each { |msg| puts "#{msg.timestamp} | #{msg.author}: #{msg.body}" }
+```
+
+```ruby
+File.open('path/to/chat.txt') do |f|
+  WhatsappChatParser.parse_file(f).each { |msg| puts "#{msg.timestamp} | #{msg.author}: #{msg.body}" }
+end
+```
+
+Each message has `timestamp`, `author`, `body`, `platform` and `type`. The result is suitable for JSON, databases, or pipelines.
+
+For a more comprehensive example, see [samples/example.rb](samples/example.rb).
+
+## Output format
+
+Each parsed record includes:
+
+| Field       | Description                                        |
+|-------------|----------------------------------------------------|
+| `timestamp` | Normalized date/time (consistent across platforms) |
+| `author`    | Sender name or identifier (when present)           |
+| `body`      | Full message content (multi-line messages grouped) |
+| `platform`  | Platform where chat was exported from (Anroid/iOS) |
+| `type`      | e.g. user message, system message                  |
+
+## Design principles
+
+- **Deterministic parsing** - Same input yields same output
+- **No dependencies** - Self-contained Ruby
+- **Explicit platform handling** - Android vs iOS format differences are handled explicitly
+- **Predictable structure** - Stable, documented output schema
+
+## Use cases
+
+- Chat analytics and reporting
+- Data migration or archival
+- ETL pipelines into databases or spreadsheets
+- Automated processing of exported WhatsApp conversations
+
+## Non-goals
+
+This library does **not**:
+
+- Interact with WhatsApp APIs
+- Require network access
+- Perform message interpretation, sentiment analysis, or NLP
+- Handle encrypted or proprietary WhatsApp data formats
+
+Input must be unmodified exports from WhatsApp’s “Export Chat” feature.
+
+## How to export WhatsApp chats
+
+To use this library you need a plain-text export of a WhatsApp conversation. Use WhatsApp’s built-in **Export Chat** and choose **Without media** so you get a single `.txt` file.
+
+- [Android](https://faq.whatsapp.com/1180414079177245?cms_platform=android)
+- [iOS](https://faq.whatsapp.com/1180414079177245/?cms_platform=iphone)
+
+Use the exported `.txt` file as-is; do not edit the format. This library supports both Android and iOS export formats.
+
+## Development
+
+### Setup
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://github.com/emmaakachukwu/whatsapp-chat-parser-rb
+cd whatsapp-chat-parser-rb
+bundle install
+```
+
+### Running Tests
+
+We use RSpec for testing. Ensure all tests pass before submitting changes:
+
+```bash
+bundle exec rspec
+```
+
+### Linting
+
+We use RuboCop to maintain code quality:
+
+```bash
+bundle exec rubocop
+```
+
+## Contributing
+
+Contributions are welcome. Please open an issue or pull request on the project repository.
+
+1. **Fork** the repository and create a feature branch.
+2. Ensure your code follows the **Development** steps above (tests and linting pass).
+3. **Submit a Pull Request** with a detailed description of your work.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

data/lib/whatsapp-chat-parser/encoding.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  # Handles encoding detection and normalization for chat exports.
+  module Encoding
+    UTF8_BOM    = "\xEF\xBB\xBF".b.freeze
+    UTF16LE_BOM = "\xFF\xFE".b.freeze
+    UTF16BE_BOM = "\xFE\xFF".b.freeze
+    FALLBACK_ENCODING = 'UTF-8'
+
+    class << self
+      # Normalizes a string to UTF-8, handling BOM and common encodings.
+      # @param line [String] The raw input string.
+      # @return [String] The normalized UTF-8 string.
+      def normalize_to_utf8(line)
+        enc = encoding_for(line)
+        str = line.dup.force_encoding(enc)
+        str = strip_bom(str, enc)
+        unless enc == ::Encoding::UTF_8
+          str = str.encode(
+            ::Encoding::UTF_8, invalid: :replace, undef: :replace
+          )
+        end
+
+        str
+      end
+
+      private
+
+      def encoding_for(line)
+        raw = line.dup.force_encoding(::Encoding::BINARY)
+        if raw.start_with?(UTF8_BOM)
+          ::Encoding::UTF_8
+        elsif raw.start_with?(UTF16LE_BOM)
+          ::Encoding::UTF_16LE
+        elsif raw.start_with?(UTF16BE_BOM)
+          ::Encoding::UTF_16BE
+        else
+          ::Encoding.find(FALLBACK_ENCODING)
+        end
+      end
+
+      def strip_bom(str, encoding)
+        case encoding
+        when ::Encoding::UTF_8
+          str.start_with?("\uFEFF") ? str.delete_prefix("\uFEFF") : str
+        when ::Encoding::UTF_16LE, ::Encoding::UTF_16BE
+          str.bytesize >= 2 ? str.byteslice(2..).force_encoding(encoding) : str
+        else
+          str
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/file_processor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module WhatsappChatParser
+  # Handles reading and processing chat export files.
+  module FileProcessor
+    class << self
+      # Iterates through the source and yields parsed messages.
+      # @param source [String, IO] The file path or IO object.
+      # @yield [message] Yields each parsed message.
+      # @yieldparam message [WhatsappChatParser::Models::Message]
+      # @return [Enumerator] if no block is given.
+      def parse(source, &block)
+        return enum_for(__method__, source) unless block_given?
+
+        file = source.is_a?(StringIO) ? source : File.open(source)
+        parse_io(file, &block)
+      end
+
+      private
+
+      # Processes an IO object.
+      # @param io [IO] The input source.
+      # @yield [message]
+      def parse_io(io, &block)
+        return enum_for(__method__, io) unless block_given?
+
+        accumulate_messages(io, &block)
+      end
+
+      def accumulate_messages(io, &block)
+        message = ''
+
+        io.each_line do |line|
+          if message_starts_here?(line)
+            yield_message(message, &block) unless message.empty?
+            message = line
+          else
+            message << line
+          end
+        end
+
+        yield_message(message, &block) unless message.empty?
+      end
+
+      def yield_message(message)
+        yield(Platforms.parse(message))
+      end
+
+      def message_starts_here?(line)
+        !Platforms.parse(line).nil?
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/models/message.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Models
+    # Represents a single WhatsApp message.
+    class Message
+      # @return [String] The date and time the message was sent (standardized SQL format).
+      attr_accessor :timestamp
+      # @return [String, nil] The name or phone number of the message author, or nil for system messages.
+      attr_accessor :author
+      # @return [String] The content of the message.
+      attr_accessor :body
+      # @return [Symbol] The type of message (:user or :system).
+      attr_accessor :type
+      # @return [Symbol] The platform the message was exported from (:android or :ios).
+      attr_accessor :platform
+
+      # Initializes a new Message object.
+      # @param timestamp [String] The standardized timestamp.
+      # @param author [String, nil] The author of the message.
+      # @param body [String] The message body.
+      # @param platform [Symbol] The export platform.
+      def initialize(timestamp:, author:, body:, platform:)
+        @timestamp = timestamp
+        @author = author
+        @body = body
+        @platform = platform
+        @type = message_type
+      end
+
+      private
+
+      def message_type
+        @author.nil? ? :system : :user
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms/android/pattern.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Platforms
+    module Android
+      # Regex patterns and builders for Android WhatsApp exports.
+      module Pattern
+        # rubocop:disable Layout/HashAlignment
+        PATTERNS = {
+          month:    /(\d{1,2})/,
+          day:      /(\d{1,2})/,
+          year:     /(\d{2})/,
+          hour:     /(\d{1,2})/,
+          minute:   /(\d{2})/,
+          meridiem: /\p{Space}*([AP]M)/,
+          author:   /(?:([^:]+): )?/,
+          body:     /(.*)/
+        }.freeze
+        # rubocop:enable Layout/HashAlignment
+
+        class << self
+          # Returns the compiled regex for Android chat exports.
+          # @return [Regexp]
+          def regex
+            Regexp.new(
+              "#{date_pattern}, #{time_pattern} " \
+              "- #{PatternHelpers.source(PATTERNS, :author)}#{PatternHelpers.source(PATTERNS, :body)}",
+              Regexp::MULTILINE
+            )
+          end
+
+          private
+
+          def date_pattern
+            PATTERNS.fetch_values(:month, :day, :year)
+                    .map(&:source)
+                    .join('/')
+          end
+
+          def time_pattern
+            PatternHelpers.format_sources(PATTERNS, %i[hour minute meridiem], '%s:%s%s')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms/android.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Platforms
+    # Parser for Android WhatsApp chat exports.
+    module Android
+      class << self
+        # Parses a line from an Android export.
+        # @param line [String] The exported line.
+        # @return [Models::Message, nil]
+        def parse(line)
+          match = line.match(Pattern.regex)
+          return unless match
+
+          timestamp = extract_timestamp(match)
+          author = extract(match, :author)
+          body = extract(match, :body)
+
+          Models::Message.new(timestamp: timestamp, author: author, body: body, platform: :android)
+        end
+
+        # Checks if a line matches the Android format.
+        # @param line [String]
+        # @return [Boolean]
+        def matches?(line)
+          Pattern.regex.match?(line)
+        end
+
+        private
+
+        def extract(match, key)
+          index = Pattern::PATTERNS.keys.index(key)
+          match[index + 1]
+        end
+
+        def extract_timestamp(match)
+          date_components = extract_date_components(match)
+          time_components = extract_time_components(match)
+
+          format_sql_timestamp(date_components, time_components)
+        end
+
+        def extract_date_components(match)
+          month = extract(match, :month)
+          day = extract(match, :day)
+          year = extract(match, :year).to_i + 2000
+
+          { month: month, day: day, year: year }
+        end
+
+        def extract_time_components(match)
+          hour = extract(match, :hour).to_i
+          minute = extract(match, :minute).to_i
+          meridiem = extract(match, :meridiem)
+          hour = convert_to_24_hour(hour, meridiem)
+
+          { hour: hour, minute: minute }
+        end
+
+        def convert_to_24_hour(hour, meridiem)
+          meridiem = meridiem.upcase
+          if meridiem == 'PM' && hour < 12
+            hour + 12
+          elsif meridiem == 'AM' && hour == 12
+            0
+          else
+            hour
+          end
+        end
+
+        def format_sql_timestamp(date, time)
+          # rubocop:disable Layout/HashAlignment
+          format(
+            '%<year>04d-%<month>02d-%<day>02d %<hour>02d:%<minute>02d:00',
+            year:   date[:year],
+            month:  date[:month],
+            day:    date[:day],
+            hour:   time[:hour],
+            minute: time[:minute]
+          )
+          # rubocop:enable Layout/HashAlignment
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms/ios/pattern.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Platforms
+    module Ios
+      # Regex patterns and builders for iOS WhatsApp exports.
+      module Pattern
+        # rubocop:disable Layout/HashAlignment
+        PATTERNS = {
+          day:      /(\d{1,2})/,
+          month:    /(\d{1,2})/,
+          year:     /(\d{4})/,
+          hour:     /(\d{1,2})/,
+          minute:   /(\d{2})/,
+          second:   /(?::(\d{2}))?/,
+          meridiem: /\p{Space}*([AP]M)?/,
+          author:   /(?:([^:]+?)\p{Space}*:\p{Space}*)?/,
+          body:     /(.*)/
+        }.freeze
+        # rubocop:enable Layout/HashAlignment
+
+        class << self
+          # Returns the compiled regex for iOS chat exports.
+          # @return [Regexp]
+          def regex
+            Regexp.new(
+              "#{square_bracket_open_pattern}" \
+              "#{date_pattern},#{space_pattern}" \
+              "#{time_pattern}" \
+              "#{square_bracket_close_pattern}" \
+              "#{space_pattern}#{/[-~]?/.source}#{space_pattern}" \
+              "#{PatternHelpers.source(PATTERNS, :author)}#{PatternHelpers.source(PATTERNS, :body)}",
+              Regexp::MULTILINE
+            )
+          end
+
+          private
+
+          def date_pattern
+            PatternHelpers.join_sources(PATTERNS, %i[day month year], '/')
+          end
+
+          def time_pattern
+            PatternHelpers.format_sources(
+              PATTERNS, %i[hour minute second meridiem], '%s:%s%s%s'
+            )
+          end
+
+          def space_pattern
+            /\p{Space}*/.source
+          end
+
+          def square_bracket_open_pattern
+            /\[?/.source
+          end
+
+          def square_bracket_close_pattern
+            /\]?/.source
+          end
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms/ios.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Platforms
+    # Parser for iOS WhatsApp chat exports.
+    module Ios
+      class << self
+        # Parses a line from an iOS export.
+        # @param line [String] The exported line.
+        # @return [Models::Message, nil]
+        def parse(line)
+          match = line.match(Pattern.regex)
+          return unless match
+
+          timestamp = extract_timestamp(match)
+          author = extract(match, :author)
+          body = extract(match, :body)
+
+          Models::Message.new(timestamp: timestamp, author: author, body: body, platform: :ios)
+        end
+
+        # Checks if a line matches the iOS format.
+        # @param line [String]
+        # @return [Boolean]
+        def matches?(line)
+          Pattern.regex.match?(line)
+        end
+
+        private
+
+        def extract(match, key)
+          index = Pattern::PATTERNS.keys.index(key)
+          match[index + 1]
+        end
+
+        def extract_timestamp(match)
+          date_components = extract_date_components(match)
+          time_components = extract_time_components(match)
+
+          format_sql_timestamp(date_components, time_components)
+        end
+
+        def extract_date_components(match)
+          month = extract(match, :month)
+          day = extract(match, :day)
+          year = extract(match, :year)
+
+          { month: month, day: day, year: year }
+        end
+
+        def extract_time_components(match)
+          hour = extract(match, :hour).to_i
+          minute = extract(match, :minute).to_i
+          second = extract(match, :second)
+          meridiem = extract(match, :meridiem)
+          hour = convert_to_24_hour(hour, meridiem)
+
+          { hour: hour, minute: minute, second: second }
+        end
+
+        def convert_to_24_hour(hour, meridiem)
+          if meridiem == 'PM' && hour < 12
+            hour + 12
+          elsif meridiem == 'AM' && hour == 12
+            0
+          else
+            hour
+          end
+        end
+
+        def format_sql_timestamp(date, time)
+          # rubocop:disable Layout/HashAlignment
+          format(
+            '%<year>04d-%<month>02d-%<day>02d %<hour>02d:%<minute>02d:%<second>02d',
+            year:   date[:year],
+            month:  date[:month],
+            day:    date[:day],
+            hour:   time[:hour],
+            minute: time[:minute],
+            second: time[:second]
+          )
+          # rubocop:enable Layout/HashAlignment
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms/pattern_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WhatsappChatParser
+  module Platforms
+    # Shared utilities for building regex patterns.
+    module PatternHelpers
+      class << self
+        def join_sources(patterns, keys, separator)
+          patterns.fetch_values(*keys).map(&:source).join(separator)
+        end
+
+        def source(patterns, key)
+          patterns[key].source
+        end
+
+        def format_sources(patterns, keys, format_string)
+          values = patterns.fetch_values(*keys).map(&:source)
+          format_string % values
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/platforms.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'encoding'
+require_relative 'platforms/android'
+require_relative 'platforms/ios'
+require_relative 'platforms/android/pattern'
+require_relative 'platforms/ios/pattern'
+require_relative 'platforms/pattern_helpers'
+
+module WhatsappChatParser
+  # Registry and dispatcher for platform-specific chat parsers.
+  module Platforms
+    PLATFORMS = [Android, Ios].freeze
+
+    class << self
+      # Attempts to parse a message line by identifying its platform.
+      # @param line [String] The raw message line.
+      # @return [WhatsappChatParser::Models::Message, nil] The parsed message or nil.
+      def parse(line)
+        sanitized = sanitize(line)
+        platform = platform_for(sanitized)
+        return nil unless platform
+
+        platform.parse(sanitized)
+      end
+
+      private
+
+      def platform_for(line)
+        PLATFORMS.find { |platform| platform.matches?(line) }
+      end
+
+      def sanitize(line)
+        Encoding.normalize_to_utf8(line).strip.scrub(' ').squeeze(' ')
+      end
+    end
+  end
+end

data/lib/whatsapp-chat-parser/version.rb

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

data/lib/whatsapp-chat-parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'whatsapp-chat-parser/platforms'
+require_relative 'whatsapp-chat-parser/models/message'
+require_relative 'whatsapp-chat-parser/file_processor'
+
+# Main entry point for the WhatsApp Chat Parser library.
+module WhatsappChatParser
+  class << self
+    # Parses a single message line of a WhatsApp chat export.
+    # @param line [String] The line to parse.
+    # @return [WhatsappChatParser::Models::Message, nil] The parsed message or nil if message is malformed.
+    def parse_line(line)
+      Platforms.parse(line)
+    end
+
+    # Parses a WhatsApp chat export .txt file path or IO.
+    # @param source [String, IO] The path to the file or an IO object.
+    # @return [Enumerator<WhatsappChatParser::Models::Message>] Enumerator of parsed messages.
+    def parse_file(source)
+      FileProcessor.parse(source)
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: whatsapp-chat-parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emmanuel Akachukwu
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.84'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.84'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: |
+  WhatsappChatParser parses exported WhatsApp chat .txt files (Android and iOS)
+  and converts them into structured, machine-readable message objects.
+  It supports both file inputs and raw message strings.
+email:
+- emmanuelakachukwu1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/whatsapp-chat-parser.rb
+- lib/whatsapp-chat-parser/encoding.rb
+- lib/whatsapp-chat-parser/file_processor.rb
+- lib/whatsapp-chat-parser/models/message.rb
+- lib/whatsapp-chat-parser/platforms.rb
+- lib/whatsapp-chat-parser/platforms/android.rb
+- lib/whatsapp-chat-parser/platforms/android/pattern.rb
+- lib/whatsapp-chat-parser/platforms/ios.rb
+- lib/whatsapp-chat-parser/platforms/ios/pattern.rb
+- lib/whatsapp-chat-parser/platforms/pattern_helpers.rb
+- lib/whatsapp-chat-parser/version.rb
+homepage: https://github.com/emmaakachukwu/whatsapp-chat-parser-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/emmaakachukwu/whatsapp-chat-parser-rb
+  bug_tracker_uri: https://github.com/emmaakachukwu/whatsapp-chat-parser-rb/issues
+  changelog_uri: https://github.com/emmaakachukwu/whatsapp-chat-parser-rb/blob/v0.1.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/whatsapp-chat-parser/0.1.0
+  source_code_uri: https://github.com/emmaakachukwu/whatsapp-chat-parser-rb/tree/v0.1.0
+  keywords: whatsapp chat parser whatsapp-chat-parser text export android ios
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A Ruby library for parsing exported WhatsApp chat .txt files or message strings.
+test_files: []