compare_logs 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1231dd6a6387dab1b7f230036742c38c0315296d2f278679b0c6d973590bea37
+  data.tar.gz: '06117930de01a60aa13ae67ea7e735eafe50e8bfe5bf488af6dfb64a6896db5d'
+SHA512:
+  metadata.gz: c0830e159fc5516a68ed8fc73ef787b5b800c4d4b50a896ac4de0f5faea40abdc8962d5e18a3704e06a84a99581a65d1fec884e464fd4b1ddda2ab8c19f917ea
+  data.tar.gz: da1a0521ac0e78dc9b8592a052de95ffcda02f947d2d2ac1aa99de18dba3c5cd3630db80d50783735dd22c0daea6adc29d4b239f1d18293dd62ccc80b30b2d66

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [0.1.0] - 2025-11-14
+
+### Added
+- Initial release
+- Log file comparison with timestamp normalization
+- Support for multiple timestamp formats
+- GUID normalization
+- Command-line interface
+- Library API for programmatic use

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/IMPLEMENTATION.md

@@ -0,0 +1,114 @@
+# Implementation Summary
+
+All tasks from `tasks.md` have been completed:
+
+## ✅ 1. Move substitutions to .env
+
+- Added `dotenv` gem dependency to `compare_logs.gemspec`
+- Refactored `lib/compare_logs.rb` to:
+  - Define `DEFAULT_SUBSTITUTIONS` constant with all hardcoded patterns
+  - Load custom substitutions from `.env` file via `COMPARE_LOGS_SUBSTITUTIONS`
+  - Support multiple custom patterns (comma-separated)
+  - Format: `pattern|||replacement`
+- Created `.env.example` with documentation
+
+**Usage:**
+```bash
+# In .env file
+COMPARE_LOGS_SUBSTITUTIONS=C:\\Users\\buildkite-agent.*source.wxs|||BUILDKITEPATH,custom_pattern|||REPLACEMENT
+```
+
+## ✅ 2. Add auto version bumping to Rakefile
+
+Added rake tasks to `Rakefile`:
+- `rake version:bump_patch` - Bumps x.y.Z version
+- `rake version:bump_minor` - Bumps x.Y.0 version
+- `rake version:bump_major` - Bumps X.0.0 version
+
+Each task updates `lib/compare_logs/version.rb` automatically.
+
+## ✅ 3. Add changelog generation to Rakefile
+
+Added `rake changelog:generate` task to `Rakefile`:
+- Reads git commits since last tag
+- Categorizes commits by type (Added, Changed, Fixed)
+- Updates `CHANGELOG.md` with new version entry
+- Preserves existing changelog entries
+
+## ✅ 4. Add GitHub Actions for auto-release
+
+Created two workflow files:
+
+### `.github/workflows/ci.yml`
+- Runs on PRs and pushes to main
+- Tests on Ruby 2.7, 3.0, 3.1, 3.2
+- Builds gem artifact
+
+### `.github/workflows/release.yml`
+- Triggers on push to main branch
+- Reads PR labels to determine version bump:
+  - `major` label → major version bump
+  - `minor` label → minor version bump
+  - No label → patch version bump (default)
+- Automatically:
+  - Bumps version using rake task
+  - Generates changelog
+  - Commits changes with `[skip ci]`
+  - Creates GitHub release with gem file
+  - Publishes to RubyGems (requires `RUBYGEMS_API_KEY` secret)
+
+## Next Steps
+
+To use the GitHub Actions workflows:
+
+1. Initialize git repository if not already done:
+   ```bash
+   git init
+   git add .
+   git commit -m "Initial commit"
+   ```
+
+2. Create GitHub repository and push:
+   ```bash
+   git remote add origin https://github.com/stringsn88keys/compare_logs.git
+   git push -u origin main
+   ```
+
+3. Add RubyGems API key as GitHub secret:
+   - Go to https://rubygems.org/profile/edit
+   - Create API key
+   - Add to GitHub repository secrets as `RUBYGEMS_API_KEY`
+
+4. Create PRs with labels `minor` or `major` to control version bumps
+
+## Testing Locally
+
+1. Install dependencies:
+   ```bash
+   bundle install
+   ```
+
+2. Test version bumping:
+   ```bash
+   rake version:bump_patch
+   ```
+
+3. Test changelog generation (requires git repository):
+   ```bash
+   git init
+   git add .
+   git commit -m "feat: initial version"
+   rake changelog:generate
+   ```
+
+4. Create `.env` file to test custom substitutions:
+   ```bash
+   cp .env.example .env
+   # Edit .env and add custom patterns
+   ```
+
+5. Rebuild and reinstall gem:
+   ```bash
+   gem build compare_logs.gemspec
+   gem install compare_logs-0.1.0.gem
+   ```

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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,135 @@
+# CompareLogs
+
+A Ruby gem to compare log files with intelligent normalization of timestamps, GUIDs, and other variable data.
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install compare_logs
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'compare_logs'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Command Line
+
+Compare the two most recent log files in your Downloads folder:
+
+```bash
+compare_logs
+```
+
+Compare action logs for a specific platform:
+
+```bash
+compare_logs actions ubuntu-2004
+```
+
+Compare specific files:
+
+```bash
+compare_logs file1.log file2.log
+```
+
+Show help:
+
+```bash
+compare_logs help
+```
+
+### As a Library
+
+```ruby
+require 'compare_logs'
+
+comparator = CompareLogs::Comparator.new(['file1.log', 'file2.log'])
+comparator.run
+```
+
+## What it Does
+
+CompareLogs normalizes variable data in log files to make meaningful comparisons easier:
+
+- Timestamps (various formats)
+- GUIDs and GUID-like identifiers
+- Build paths
+- Timing measurements
+- Directory names with timestamps
+
+After normalization, it opens the files in `gvimdiff` for visual comparison.
+
+## Custom Substitutions
+
+You can add your own custom substitutions using a `.env` file:
+
+1. Create a `.env` file in your current directory or the gem directory
+2. Add custom patterns using the `COMPARE_LOGS_SUBSTITUTIONS` variable
+
+```bash
+# Format: pattern|||replacement (use ||| as separator)
+COMPARE_LOGS_SUBSTITUTIONS=C:\\Users\\buildkite-agent.*source.wxs|||BUILDKITEPATH
+
+# Multiple substitutions (comma-separated)
+COMPARE_LOGS_SUBSTITUTIONS=pattern1|||replacement1,pattern2|||replacement2
+```
+
+Custom substitutions are applied in addition to the default patterns.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Version Management
+
+Bump versions using rake tasks:
+
+```bash
+rake version:bump_patch  # x.y.Z
+rake version:bump_minor  # x.Y.0
+rake version:bump_major  # X.0.0
+```
+
+Generate changelog from git commits:
+
+```bash
+rake changelog:generate
+```
+
+### GitHub Actions
+
+This gem uses GitHub Actions for:
+
+- **CI**: Tests on multiple Ruby versions (2.7, 3.0, 3.1, 3.2)
+- **Auto Release**: On merge to `main`, automatically:
+  - Bumps version (patch by default, minor/major via PR labels)
+  - Updates changelog
+  - Creates GitHub release
+  - Publishes to RubyGems
+
+To control version bumps, add labels to your PRs:
+- `minor` - Bump minor version
+- `major` - Bump major version
+- No label - Bump patch version (default)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## 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,137 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+namespace :version do
+  desc "Bump patch version (x.y.Z)"
+  task :bump_patch do
+    bump_version(:patch)
+  end
+
+  desc "Bump minor version (x.Y.0)"
+  task :bump_minor do
+    bump_version(:minor)
+  end
+
+  desc "Bump major version (X.0.0)"
+  task :bump_major do
+    bump_version(:major)
+  end
+
+  def bump_version(level)
+    version_file = "lib/compare_logs/version.rb"
+    content = File.read(version_file)
+    
+    current_version = content.match(/VERSION = "(\d+)\.(\d+)\.(\d+)"/)[1..3].map(&:to_i)
+    major, minor, patch = current_version
+    
+    new_version = case level
+                  when :major
+                    "#{major + 1}.0.0"
+                  when :minor
+                    "#{major}.#{minor + 1}.0"
+                  when :patch
+                    "#{major}.#{minor}.#{patch + 1}"
+                  end
+    
+    new_content = content.gsub(/VERSION = "\d+\.\d+\.\d+"/, "VERSION = \"#{new_version}\"")
+    File.write(version_file, new_content)
+    
+    puts "Version bumped from #{current_version.join('.')} to #{new_version}"
+    puts "Don't forget to update CHANGELOG.md and commit the changes!"
+  end
+end
+
+namespace :changelog do
+  desc "Generate changelog from git commits"
+  task :generate do
+    generate_changelog
+  end
+
+  def generate_changelog
+    require 'time'
+    require_relative 'lib/compare_logs/version'
+    
+    version = CompareLogs::VERSION
+    date = Time.now.strftime("%Y-%m-%d")
+    
+    changelog_file = "CHANGELOG.md"
+    
+    # Get commits since last tag (or all commits if no tags)
+    last_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
+    commit_range = last_tag.empty? ? "" : "#{last_tag}..HEAD"
+    
+    commits = `git log #{commit_range} --pretty=format:"%s" --reverse`.split("\n")
+    
+    if commits.empty?
+      puts "No commits found to add to changelog"
+      return
+    end
+    
+    # Categorize commits
+    added = []
+    changed = []
+    fixed = []
+    other = []
+    
+    commits.each do |commit|
+      case commit
+      when /^(feat|add)/i
+        added << commit.gsub(/^(feat|add):?\s*/i, '')
+      when /^(fix|bugfix)/i
+        fixed << commit.gsub(/^(fix|bugfix):?\s*/i, '')
+      when /^(change|update|refactor)/i
+        changed << commit.gsub(/^(change|update|refactor):?\s*/i, '')
+      else
+        other << commit
+      end
+    end
+    
+    # Build new entry
+    new_entry = "\n## [#{version}] - #{date}\n\n"
+    
+    if added.any?
+      new_entry += "### Added\n"
+      added.each { |item| new_entry += "- #{item}\n" }
+      new_entry += "\n"
+    end
+    
+    if changed.any?
+      new_entry += "### Changed\n"
+      changed.each { |item| new_entry += "- #{item}\n" }
+      new_entry += "\n"
+    end
+    
+    if fixed.any?
+      new_entry += "### Fixed\n"
+      fixed.each { |item| new_entry += "- #{item}\n" }
+      new_entry += "\n"
+    end
+    
+    if other.any?
+      new_entry += "### Other\n"
+      other.each { |item| new_entry += "- #{item}\n" }
+      new_entry += "\n"
+    end
+    
+    # Read existing changelog
+    if File.exist?(changelog_file)
+      existing = File.read(changelog_file)
+      # Insert new entry after the # Changelog header
+      if existing =~ /^# Changelog\s*\n/
+        updated = existing.sub(/^# Changelog\s*\n/, "# Changelog\n#{new_entry}")
+      else
+        updated = "# Changelog\n#{new_entry}#{existing}"
+      end
+    else
+      updated = "# Changelog\n#{new_entry}"
+    end
+    
+    File.write(changelog_file, updated)
+    puts "Changelog updated with version #{version}"
+    puts "Review CHANGELOG.md and commit the changes"
+  end
+end

data/compare_logs.gemspec

@@ -0,0 +1,33 @@
+require_relative 'lib/compare_logs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "compare_logs"
+  spec.version       = CompareLogs::VERSION
+  spec.authors       = ["Thomas Powell"]
+  spec.email         = ["twilliampowell@gmail.com"]
+
+  spec.summary       = "A tool to compare log files with timestamp normalization"
+  spec.description   = "CompareLogs helps you compare log files by normalizing timestamps, GUIDs, and other variable data, then opening them in a diff viewer."
+  spec.homepage      = "https://github.com/stringsn88keys/compare_logs"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/yourusername/compare_logs"
+  spec.metadata["changelog_uri"] = "https://github.com/yourusername/compare_logs/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir["{lib,exe}/**/*", "*.md", "*.txt", "*.gemspec", "Gemfile", "Rakefile"]
+  
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "dotenv", "~> 2.8"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/exe/compare_logs

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/compare_logs'
+
+comparator = CompareLogs::Comparator.new(ARGV)
+comparator.run

data/lib/compare_logs/version.rb

@@ -0,0 +1,3 @@
+module CompareLogs
+  VERSION = "0.4.0"
+end

data/lib/compare_logs.rb

@@ -0,0 +1,222 @@
+require_relative "compare_logs/version"
+require "dotenv"
+
+module CompareLogs
+  class Error < StandardError; end
+
+  class Comparator
+    attr_reader :files
+
+    # Default substitutions that are always applied
+    DEFAULT_SUBSTITUTIONS = [
+      [/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{7}/, 'BUILD_TIMESTAMP'],
+      [/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{9} [-+]\d{4}/, 'INTERNAL_TIMESTAMP'],
+      [/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[-+]\d{2}:\d{2}/, 'INTERNAL_TIMESTAMP2'],
+      [/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/, 'INTERNAL_TIMESTAMP3'],
+      [/\d{14}/, 'INTEGER_TIMESTAMP'],
+      [/\d{2}\/\d{2}\/\d{4} \d{1,2}:\d{2}:\d{2} [AP]M/, 'WINDOWS_TIMESTAMP'],
+      [/\d{14}\.\d{4}/, 'BUILDLOG_TIMESTAMP'],
+      [/ \d+\.\d+s/, ' SOME_TIMING'],
+      [/\h{8}-\h{4}-\h{4}-\h{4}-\h{12}/, 'GUID'],
+      [/\h{8}-\h{4}-\h{4}-\h{12}/, 'GUIDLIKE'],
+      [/\d{8}-\d{5}-[[:alnum:]]{5,6}\./, 'DIRNAME.']
+    ].freeze
+
+    def initialize(args = [])
+      @args = args
+      @files = []
+      @aggressive = false
+      @ignore_versions = false
+      @ignore_timings = false
+      load_custom_substitutions
+    end
+
+    def run
+      parse_arguments
+      normalize_files
+      if @aggressive
+        remove_common_lines
+      end
+      launch_diff_viewer
+    end
+
+    private
+
+    def parse_arguments
+      # Check for --aggressive flag
+      if @args.include?('--aggressive')
+        @aggressive = true
+        @args.delete('--aggressive')
+      end
+
+      # Check for --ignore-versions flag
+      if @args.include?('--ignore-versions')
+        @ignore_versions = true
+        @args.delete('--ignore-versions')
+      end
+
+      # Check for --ignore-timings flag
+      if @args.include?('--ignore-timings')
+        @ignore_timings = true
+        @args.delete('--ignore-timings')
+      end
+
+      if @args.empty? || @args.length > 2
+        print_usage
+        exit
+      end
+
+      if @args.first == "help"
+        print_usage
+        exit
+      end
+
+      @files = if @args.length <= 1
+                 find_files_from_pattern
+               else
+                 @args
+               end
+
+      if @files.empty?
+        puts "No files found to compare"
+        exit 1
+      end
+    end
+
+    def find_files_from_pattern
+      glob_string = case @args[0]
+                    when /\*/
+                      @args[0]
+                    when /actions/
+                      "#{ENV['HOME']}/Downloads/logs_*/*#{@args[1]}*.txt"
+                    else
+                      "#{ENV['HOME']}/Downloads/*.log"
+                    end
+
+      Dir.glob(glob_string).sort { |a, b| File.ctime(a) <=> File.ctime(b) }.last(2).reverse
+    end
+
+    def normalize_files
+      @files.each do |file|
+        normalized_content = normalize_content(file)
+        File.open("#{file}.modified", 'wt') do |f|
+          f.puts normalized_content
+        end
+      end
+    end
+
+    def normalize_content(file)
+      # Try reading with UTF-8 first, fall back to UTF-16LE if that fails
+      content = begin
+        File.read(file, encoding: 'UTF-8')
+      rescue ArgumentError, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        begin
+          File.read(file, encoding: 'UTF-16LE:UTF-8')
+        rescue ArgumentError, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+          # Last resort: read as binary and force UTF-8, replacing invalid bytes
+          File.read(file, encoding: 'binary').force_encoding('UTF-8').scrub('?')
+        end
+      end
+      
+      # Ensure the content is valid UTF-8 before applying substitutions
+      content = content.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+      
+      # Apply version substitution if --ignore-versions flag is set
+      if @ignore_versions
+        content = content.gsub(/\b\d+\.\d+\.\d+\b/, 'VERSION')
+      end
+      
+      # Apply timing substitution if --ignore-timings flag is set
+      if @ignore_timings
+        # Match patterns like "1.234 seconds", "3.231322 minutes", "5 hours", etc.
+        content = content.gsub(/\b\d+\.?\d*\s+(seconds?|minutes?|hours?|milliseconds?|ms)\b/i, 'TIMING')
+      end
+      
+      # Apply all substitutions (default + custom)
+      all_substitutions.each do |pattern, replacement|
+        content = content.gsub(pattern, replacement)
+      end
+      
+      content
+    end
+
+    def all_substitutions
+      DEFAULT_SUBSTITUTIONS + @custom_substitutions
+    end
+
+    def load_custom_substitutions
+      @custom_substitutions = []
+      
+      # Try to load .env file from current directory or gem root
+      [Dir.pwd, File.expand_path('../..', __dir__)].each do |dir|
+        env_file = File.join(dir, '.env')
+        if File.exist?(env_file)
+          Dotenv.load(env_file)
+          break
+        end
+      end
+
+      # Parse COMPARE_LOGS_SUBSTITUTIONS if present
+      if ENV['COMPARE_LOGS_SUBSTITUTIONS'] && !ENV['COMPARE_LOGS_SUBSTITUTIONS'].empty?
+        ENV['COMPARE_LOGS_SUBSTITUTIONS'].split(',').each do |sub|
+          pattern_str, replacement = sub.split('|||', 2)
+          next unless pattern_str && replacement
+          
+          begin
+            pattern = Regexp.new(pattern_str.strip)
+            @custom_substitutions << [pattern, replacement.strip]
+          rescue RegexpError => e
+            warn "Invalid regex pattern '#{pattern_str}': #{e.message}"
+          end
+        end
+      end
+    end
+
+    def remove_common_lines
+      return unless @files.length == 2
+      
+      # Read both modified files
+      file1_path = "#{@files[0]}.modified"
+      file2_path = "#{@files[1]}.modified"
+      
+      lines1 = File.readlines(file1_path)
+      lines2 = File.readlines(file2_path)
+      
+      # Find common lines (lines that exist in both files)
+      common_lines = lines1 & lines2
+      
+      if common_lines.empty?
+        puts "No common lines found to remove"
+        return
+      end
+      
+      # Remove common lines from both files
+      unique_lines1 = lines1 - common_lines
+      unique_lines2 = lines2 - common_lines
+      
+      # Write back the filtered content
+      File.write(file1_path, unique_lines1.join)
+      File.write(file2_path, unique_lines2.join)
+      
+      puts "Aggressive mode: Removed #{common_lines.length} common lines"
+    end
+
+    def launch_diff_viewer
+      modified_files = @files.map { |f| "\"#{f}.modified\"" }.join(' ')
+      system("gvimdiff #{modified_files}")
+    end
+
+    def print_usage
+      puts "Usage:"
+      puts "  compare_logs [OPTIONS] actions ubuntu-2004"
+      puts "  compare_logs [OPTIONS] file1.log file2.log"
+      puts "  compare_logs [OPTIONS]                      # for Downloads/*.log"
+      puts "  compare_logs help                           # show this help"
+      puts ""
+      puts "Options:"
+      puts "  --aggressive       Remove all lines that are identical in both files after normalization"
+      puts "  --ignore-versions  Normalize x.y.z version strings to VERSION"
+      puts "  --ignore-timings   Normalize timing strings (e.g., '1.234 seconds') to TIMING"
+    end
+  end
+end

data/tasks.md

@@ -0,0 +1,4 @@
+- [ ] move substitutions like .gsub(/C:\\Users\\buildkite-agent.*source.wxs/, 'BUILDKITEPATH') to COMPARE_LOGS_SUBSTITUTIONS in .env
+- [ ] add auto version bumping to Rakefile
+- [ ] add changelog generation to Rakefile
+- [ ] add version bumping to github actions on merge to main, optional minor and major bumps based on labels

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: compare_logs
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Thomas Powell
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: CompareLogs helps you compare log files by normalizing timestamps, GUIDs,
+  and other variable data, then opening them in a diff viewer.
+email:
+- twilliampowell@gmail.com
+executables:
+- compare_logs
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- IMPLEMENTATION.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- compare_logs.gemspec
+- exe/compare_logs
+- lib/compare_logs.rb
+- lib/compare_logs/version.rb
+- tasks.md
+homepage: https://github.com/stringsn88keys/compare_logs
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/stringsn88keys/compare_logs
+  source_code_uri: https://github.com/yourusername/compare_logs
+  changelog_uri: https://github.com/yourusername/compare_logs/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A tool to compare log files with timestamp normalization
+test_files: []