diff_gem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 73ae8c129ddec8ddc5fb106a8d34d9bf7bdc42cabf49a076e70918d006cf4e72
+  data.tar.gz: ceb5f41c3b67cfd6d3f7b58f5bdf9ed599e7cdc1ed122eb8536819cb395a7dc5
+SHA512:
+  metadata.gz: ff5a6fe8679e51eacb93bf8de2d9a8de23101c4bc13963b171d8fd0bdbff0c9fab8b4e131a71cae08bfd07ed5128ff595286000456bf0cd9c39f89a2cf0efa2b
+  data.tar.gz: d6162df393f490ec848d6f80a67432bb11ee5d203ae4ebf0655f6aa5df866a31642297703a3d098513e1c27f608059b05b89e09cdb229706eb7683b2ee2108ab

data/.claude/settings.local.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mkdir:*)",
+      "Bash(chmod:*)",
+      "Bash(bundle install:*)",
+      "Bash(bundle exec ruby:*)",
+      "Bash(curl:*)",
+      "Bash(gem build:*)",
+      "Bash(git init:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git rm:*)",
+      "Bash(gem install:*)",
+      "Bash(gemcompare minitest:*)",
+      "Bash(gemcompare --help:*)",
+      "Bash(gemcompare cache info:*)",
+      "Bash(git mv:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    diff_gem (0.1.0)
+      thor (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    diff-lcs (1.6.2)
+    method_source (1.1.0)
+    pry (0.15.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.7)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    thor (1.4.0)
+
+PLATFORMS
+  arm64-darwin-22
+  ruby
+
+DEPENDENCIES
+  diff_gem!
+  pry (~> 0.14)
+  rspec (~> 3.12)
+
+BUNDLED WITH
+   2.7.1

data/README.md

@@ -0,0 +1,112 @@
+# DiffGem
+
+Compare the source code and metadata between two versions of a Ruby gem.
+
+## Installation
+
+```bash
+gem install diff_gem
+```
+
+Or install locally:
+
+```bash
+gem build diff_gem.gemspec
+gem install diff_gem-0.1.0.gem
+```
+
+## Usage
+
+### Compare Source Code
+
+Compare two versions of a gem:
+
+```bash
+diff_gem GEM_NAME OLD_VERSION NEW_VERSION
+```
+
+Example:
+
+```bash
+diff_gem rails 7.0.0 7.0.1
+```
+
+Or use the explicit command:
+
+```bash
+diff_gem compare rails 7.0.0 7.0.1
+```
+
+### Compare Metadata
+
+Compare gem metadata (dependencies, version info, file counts, etc.) without comparing source:
+
+```bash
+diff_gem metadata rails 7.0.0 7.0.1
+```
+
+### Compare Both
+
+Compare metadata and source code together:
+
+```bash
+diff_gem compare --metadata rails 7.0.0 7.0.1
+```
+
+### Cache Management
+
+View cache information:
+
+```bash
+diff_gem cache info
+```
+
+Clear the cache:
+
+```bash
+diff_gem cache clear
+```
+
+### Custom Cache Directory
+
+You can specify a custom cache directory:
+
+```bash
+diff_gem --cache-dir /tmp/gem_cache rails 7.0.0 7.0.1
+```
+
+Or set the environment variable:
+
+```bash
+export DIFF_GEM_CACHE_DIR=/tmp/gem_cache
+diff_gem rails 7.0.0 7.0.1
+```
+
+## How It Works
+
+**Source Comparison:**
+1. Downloads both gem versions from rubygems.org
+2. Extracts the gem source code to a cache directory
+3. Runs `diff -r -u -N` to compare the source trees
+4. Displays the unified diff output
+
+**Metadata Comparison:**
+1. Downloads gem metadata from rubygems.org
+2. Extracts and parses the gemspec information
+3. Compares dependencies, file counts, version requirements, and other metadata
+4. Displays a structured comparison showing added, removed, and changed fields
+
+Downloaded gems are cached in `~/.diff_gem_cache` by default, so subsequent comparisons are faster.
+
+## Similar Tools
+
+If `diff_gem` doesn't meet your needs, you might want to check out these alternatives:
+
+- **[gemdiff](https://github.com/teeparham/gemdiff)** - Compare gem versions with GitHub integration, showing commits between releases and opening diffs in the browser
+- **[gem-compare](https://github.com/sj26/gem-compare)** - Another tool for comparing gem versions with a focus on simplicity
+
+`diff_gem` focuses on providing both detailed source code diffs and comprehensive metadata comparisons in a command-line interface.
+
+## License
+
+MIT

data/exe/diff_gem

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/diff_gem'
+
+# If first argument is not a known command, assume it's a gem name and prepend 'compare'
+KNOWN_COMMANDS = %w[compare metadata version cache help]
+if ARGV.length >= 3 && !KNOWN_COMMANDS.include?(ARGV[0])
+  ARGV.unshift('compare')
+end
+
+DiffGem::CLI.start(ARGV)

data/lib/diff_gem/cli.rb

@@ -0,0 +1,150 @@
+require 'thor'
+require 'fileutils'
+
+module DiffGem
+  class CacheCommands < Thor
+    desc "clear", "Clear the cache directory"
+    def clear
+      cache_dir = ENV['DIFF_GEM_CACHE_DIR'] || File.expand_path('~/.diff_gem_cache')
+
+      if File.exist?(cache_dir)
+        FileUtils.rm_rf(cache_dir)
+        puts "Cache cleared: #{cache_dir}"
+      else
+        puts "Cache directory does not exist: #{cache_dir}"
+      end
+    end
+
+    desc "info", "Show cache directory information"
+    def info
+      cache_dir = ENV['DIFF_GEM_CACHE_DIR'] || File.expand_path('~/.diff_gem_cache')
+
+      puts "Cache directory: #{cache_dir}"
+
+      if File.exist?(cache_dir)
+        gem_dirs = Dir.glob(File.join(cache_dir, '*', '*')).select { |f| File.directory?(f) }
+
+        size = `du -sh "#{cache_dir}" 2>/dev/null`.split.first rescue "unknown"
+
+        puts "Status: exists"
+        puts "Size: #{size}"
+        puts "Cached gem versions: #{gem_dirs.length}"
+
+        if gem_dirs.any?
+          puts "\nCached gems:"
+          gem_dirs.each do |dir|
+            parts = dir.split('/')
+            version = parts[-1]
+            name = parts[-2]
+            puts "  #{name} #{version}"
+          end
+        end
+      else
+        puts "Status: does not exist"
+      end
+    end
+  end
+
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "compare GEM_NAME OLD_VERSION NEW_VERSION", "Compare two versions of a Ruby gem"
+    long_desc <<-LONGDESC
+      Compare the source trees of two different versions of a Ruby gem.
+
+      Downloads both gem versions, extracts their source code, and displays
+      the differences in unified diff format.
+
+      Example:
+      $ diff_gem rails 7.0.0 7.1.0
+
+      $ diff_gem compare rails 7.0.0 7.1.0
+
+      With metadata comparison:
+      $ diff_gem compare --metadata rails 7.0.0 7.1.0
+    LONGDESC
+    option :cache_dir,
+           type: :string,
+           desc: "Custom cache directory for downloaded gems"
+    option :metadata,
+           type: :boolean,
+           default: false,
+           desc: "Also compare gem metadata before showing source diff"
+
+    def compare(gem_name, old_version, new_version)
+      begin
+        # Show metadata comparison if requested
+        if options[:metadata]
+          metadata_comparer = MetadataComparer.new(
+            gem_name: gem_name,
+            old_version: old_version,
+            new_version: new_version
+          )
+          metadata_comparer.compare
+          puts "\n" + "=" * 80
+          puts "Source Code Comparison"
+          puts "=" * 80 + "\n\n"
+        end
+
+        # Show source comparison
+        comparer = Comparer.new(
+          gem_name: gem_name,
+          old_version: old_version,
+          new_version: new_version,
+          cache_dir: options[:cache_dir]
+        )
+
+        comparer.compare
+
+      rescue DiffGem::Error => e
+        puts "Error: #{e.message}"
+        exit 1
+      rescue => e
+        puts "Unexpected error: #{e.message}"
+        puts e.backtrace
+        exit 1
+      end
+    end
+
+    desc "metadata GEM_NAME OLD_VERSION NEW_VERSION", "Compare metadata of two gem versions"
+    long_desc <<-LONGDESC
+      Compare the metadata (dependencies, version info, etc.) of two different
+      versions of a Ruby gem without comparing source code.
+
+      Example:
+      $ diff_gem metadata rails 7.0.0 7.1.0
+    LONGDESC
+
+    def metadata(gem_name, old_version, new_version)
+      begin
+        metadata_comparer = MetadataComparer.new(
+          gem_name: gem_name,
+          old_version: old_version,
+          new_version: new_version
+        )
+        metadata_comparer.compare
+
+      rescue DiffGem::Error => e
+        puts "Error: #{e.message}"
+        exit 1
+      rescue => e
+        puts "Unexpected error: #{e.message}"
+        puts e.backtrace
+        exit 1
+      end
+    end
+
+    desc "version", "Show version"
+    def version
+      puts DiffGem::VERSION
+    end
+
+    desc "cache", "Manage cache directory"
+    subcommand "cache", CacheCommands
+
+    # Set compare as the default command
+    default_task :compare
+  end
+end

data/lib/diff_gem/comparer.rb

@@ -0,0 +1,50 @@
+require 'fileutils'
+
+module DiffGem
+  class Comparer
+    attr_reader :gem_name, :old_version, :new_version, :cache_dir
+
+    def initialize(gem_name:, old_version:, new_version:, cache_dir: nil)
+      @gem_name = gem_name
+      @old_version = old_version
+      @new_version = new_version
+      @cache_dir = cache_dir || default_cache_dir
+    end
+
+    def compare
+      puts "Comparing #{gem_name}: #{old_version} -> #{new_version}\n\n"
+
+      extractor = GemExtractor.new(cache_dir)
+
+      # Extract both versions
+      old_path = extractor.extract_gem(gem_name, old_version)
+      new_path = extractor.extract_gem(gem_name, new_version)
+
+      puts "\nGenerating diff...\n\n"
+
+      # Generate and display diff
+      generate_diff(old_path, new_path)
+    end
+
+    private
+
+    def generate_diff(old_path, new_path)
+      # Use system diff command to generate comprehensive diff
+      # The diff command will:
+      # - Compare directories recursively (-r)
+      # - Use unified format (-u) for better readability
+      # - Show files that exist in only one directory (-N)
+      system("diff -r -u -N '#{old_path}' '#{new_path}'")
+
+      # diff returns non-zero exit status when there are differences,
+      # which is expected behavior
+      if $?.exitstatus > 1
+        raise Error, "Failed to generate diff (exit status: #{$?.exitstatus})"
+      end
+    end
+
+    def default_cache_dir
+      ENV['DIFF_GEM_CACHE_DIR'] || File.expand_path('~/.diff_gem_cache')
+    end
+  end
+end

data/lib/diff_gem/gem_extractor.rb

@@ -0,0 +1,140 @@
+require 'fileutils'
+require 'rubygems/package'
+require 'zlib'
+require 'stringio'
+require 'open-uri'
+require 'net/http'
+
+module DiffGem
+  class GemExtractor
+    attr_reader :cache_dir
+
+    def initialize(cache_dir)
+      @cache_dir = cache_dir
+      ensure_cache_dir_exists
+    end
+
+    def extract_gem(gem_name, version)
+      gem_cache_dir = File.join(cache_dir, gem_name, version)
+
+      # Return existing path if already downloaded and extracted
+      if File.exist?(gem_cache_dir) && !Dir.empty?(gem_cache_dir)
+        puts "  Using cached: #{gem_name} #{version}"
+        return gem_cache_dir
+      end
+
+      puts "  Downloading: #{gem_name} #{version}"
+
+      # Ensure directory exists
+      FileUtils.mkdir_p(gem_cache_dir)
+
+      # Download gem file
+      gem_file_path = download_gem(gem_name, version)
+
+      # Extract gem contents
+      extract_gem_archive(gem_file_path, gem_cache_dir)
+
+      # Clean up downloaded gem file
+      File.delete(gem_file_path) if File.exist?(gem_file_path)
+
+      gem_cache_dir
+    end
+
+    private
+
+    def download_gem(gem_name, version)
+      gem_filename = "#{gem_name}-#{version}.gem"
+      gem_file_path = File.join(cache_dir, gem_filename)
+
+      # Try to download from rubygems.org
+      gem_url = "https://rubygems.org/downloads/#{gem_filename}"
+
+      begin
+        uri = URI(gem_url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          if response.code == '200'
+            File.open(gem_file_path, 'wb') do |file|
+              file.write(response.body)
+            end
+          else
+            raise Error, "Failed to download #{gem_name} #{version}: HTTP #{response.code}"
+          end
+        end
+
+        gem_file_path
+      rescue => e
+        raise Error, "Failed to download #{gem_name} #{version}: #{e.message}"
+      end
+    end
+
+    def extract_gem_archive(gem_file_path, extract_dir)
+      begin
+        # Modern gems can be either gzipped tar or plain tar
+        File.open(gem_file_path, 'rb') do |gem_file|
+          # Try to read as gzipped first
+          tar_reader = begin
+            Gem::Package::TarReader.new(Zlib::GzipReader.new(gem_file))
+          rescue Zlib::GzipFile::Error
+            # If not gzipped, rewind and read as plain tar
+            gem_file.rewind
+            Gem::Package::TarReader.new(gem_file)
+          end
+
+          tar_reader.each do |entry|
+            next unless entry.file?
+
+            # Extract data.tar.gz which contains the actual gem files
+            if entry.full_name == 'data.tar.gz'
+              extract_data_tar(entry, extract_dir, compressed: true)
+              break
+            # Some gems might have uncompressed data.tar
+            elsif entry.full_name == 'data.tar'
+              extract_data_tar(entry, extract_dir, compressed: false)
+              break
+            end
+          end
+
+          tar_reader.close
+        end
+      rescue => e
+        raise Error, "Failed to extract #{gem_file_path}: #{e.message}"
+      end
+    end
+
+    def extract_data_tar(data_tar_entry, extract_dir, compressed:)
+      data = data_tar_entry.read
+
+      tar_reader = if compressed
+        Gem::Package::TarReader.new(Zlib::GzipReader.new(StringIO.new(data)))
+      else
+        Gem::Package::TarReader.new(StringIO.new(data))
+      end
+
+      tar_reader.each do |entry|
+        next if entry.directory?
+
+        file_path = File.join(extract_dir, entry.full_name)
+
+        # Ensure directory exists
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        # Write file contents
+        File.open(file_path, 'wb') do |file|
+          file.write(entry.read)
+        end
+
+        # Preserve file permissions
+        File.chmod(entry.header.mode, file_path) if entry.header.mode
+      end
+
+      tar_reader.close
+    end
+
+    def ensure_cache_dir_exists
+      FileUtils.mkdir_p(cache_dir)
+    end
+  end
+end

data/lib/diff_gem/metadata_comparer.rb

@@ -0,0 +1,240 @@
+require 'yaml'
+require 'json'
+require 'rubygems/package'
+require 'zlib'
+require 'net/http'
+
+module DiffGem
+  class MetadataComparer
+    attr_reader :gem_name, :old_version, :new_version
+
+    def initialize(gem_name:, old_version:, new_version:)
+      @gem_name = gem_name
+      @old_version = old_version
+      @new_version = new_version
+    end
+
+    def compare
+      puts "Fetching metadata for #{gem_name}..."
+
+      old_spec = fetch_gem_spec(gem_name, old_version)
+      new_spec = fetch_gem_spec(gem_name, new_version)
+
+      puts "\n" + "=" * 80
+      puts "Metadata Comparison: #{gem_name} #{old_version} → #{new_version}"
+      puts "=" * 80 + "\n"
+
+      compare_basic_info(old_spec, new_spec)
+      compare_dependencies(old_spec, new_spec)
+      compare_files(old_spec, new_spec)
+      compare_metadata(old_spec, new_spec)
+    end
+
+    private
+
+    def fetch_gem_spec(gem_name, version)
+      gem_filename = "#{gem_name}-#{version}.gem"
+      gem_url = "https://rubygems.org/downloads/#{gem_filename}"
+
+      begin
+        uri = URI(gem_url)
+
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+          request['User-Agent'] = 'DiffGem Ruby Gem Comparator'
+          gem_data = http.request(request)
+
+          if gem_data.code != '200'
+            raise Error, "Failed to download #{gem_name} #{version}: HTTP #{gem_data.code}"
+          end
+
+          # Parse the gem file to extract metadata
+          io = StringIO.new(gem_data.body)
+
+          tar_reader = begin
+            Gem::Package::TarReader.new(Zlib::GzipReader.new(io))
+          rescue Zlib::GzipFile::Error
+            io.rewind
+            Gem::Package::TarReader.new(io)
+          end
+
+          metadata = nil
+          tar_reader.each do |entry|
+            if entry.full_name == 'metadata.gz'
+              metadata = Zlib::GzipReader.new(StringIO.new(entry.read)).read
+              break
+            elsif entry.full_name == 'metadata'
+              metadata = entry.read
+              break
+            end
+          end
+          tar_reader.close
+
+          raise Error, "No metadata found in gem" unless metadata
+
+          # Use safe_load with permitted classes for security
+          permitted_classes = [
+            Gem::Specification,
+            Gem::Version,
+            Gem::Requirement,
+            Gem::Dependency,
+            Time,
+            Symbol,
+            Date,
+            DateTime
+          ]
+
+          YAML.safe_load(metadata, permitted_classes: permitted_classes, aliases: true)
+        end
+
+      rescue => e
+        raise Error, "Failed to fetch metadata for #{gem_name} #{version}: #{e.message}"
+      end
+    end
+
+    def compare_basic_info(old_spec, new_spec)
+      puts "Basic Information:"
+      puts "-" * 80
+
+      compare_field("Name", old_spec.name, new_spec.name)
+      compare_field("Version", old_spec.version.to_s, new_spec.version.to_s)
+      compare_field("Authors", old_spec.authors.join(', '), new_spec.authors.join(', '))
+      compare_field("Email", old_spec.email, new_spec.email)
+      compare_field("Homepage", old_spec.homepage, new_spec.homepage)
+      compare_field("License", old_spec.license || old_spec.licenses.join(', '),
+                              new_spec.license || new_spec.licenses.join(', '))
+      compare_field("Summary", old_spec.summary, new_spec.summary)
+      compare_field("Description", old_spec.description, new_spec.description)
+      compare_field("Ruby Version Required", old_spec.required_ruby_version.to_s,
+                                           new_spec.required_ruby_version.to_s)
+      compare_field("RubyGems Version Required", old_spec.required_rubygems_version.to_s,
+                                                new_spec.required_rubygems_version.to_s)
+
+      puts
+    end
+
+    def compare_dependencies(old_spec, new_spec)
+      puts "Runtime Dependencies:"
+      puts "-" * 80
+
+      old_deps = old_spec.dependencies.select { |d| d.type == :runtime }
+      new_deps = new_spec.dependencies.select { |d| d.type == :runtime }
+
+      compare_dependency_list(old_deps, new_deps)
+
+      puts "\nDevelopment Dependencies:"
+      puts "-" * 80
+
+      old_dev_deps = old_spec.dependencies.select { |d| d.type == :development }
+      new_dev_deps = new_spec.dependencies.select { |d| d.type == :development }
+
+      compare_dependency_list(old_dev_deps, new_dev_deps)
+
+      puts
+    end
+
+    def compare_dependency_list(old_deps, new_deps)
+      old_dep_hash = old_deps.each_with_object({}) { |d, h| h[d.name] = d }
+      new_dep_hash = new_deps.each_with_object({}) { |d, h| h[d.name] = d }
+
+      all_dep_names = (old_dep_hash.keys + new_dep_hash.keys).uniq.sort
+
+      if all_dep_names.empty?
+        puts "  (none)"
+        return
+      end
+
+      all_dep_names.each do |name|
+        old_dep = old_dep_hash[name]
+        new_dep = new_dep_hash[name]
+
+        if old_dep && !new_dep
+          puts "  - #{name} #{old_dep.requirement} (REMOVED)"
+        elsif !old_dep && new_dep
+          puts "  + #{name} #{new_dep.requirement} (ADDED)"
+        elsif old_dep.requirement.to_s != new_dep.requirement.to_s
+          puts "  ~ #{name}: #{old_dep.requirement} → #{new_dep.requirement}"
+        else
+          puts "    #{name} #{new_dep.requirement}"
+        end
+      end
+    end
+
+    def compare_files(old_spec, new_spec)
+      puts "Files:"
+      puts "-" * 80
+
+      old_files = old_spec.files.sort
+      new_files = new_spec.files.sort
+
+      removed = old_files - new_files
+      added = new_files - old_files
+      unchanged = old_files & new_files
+
+      puts "  Total files: #{old_files.length} → #{new_files.length}"
+
+      if added.any?
+        puts "\n  Added (#{added.length}):"
+        added.first(10).each { |f| puts "    + #{f}" }
+        puts "    ... and #{added.length - 10} more" if added.length > 10
+      end
+
+      if removed.any?
+        puts "\n  Removed (#{removed.length}):"
+        removed.first(10).each { |f| puts "    - #{f}" }
+        puts "    ... and #{removed.length - 10} more" if removed.length > 10
+      end
+
+      puts "\n  Unchanged: #{unchanged.length} files"
+      puts
+    end
+
+    def compare_metadata(old_spec, new_spec)
+      puts "Additional Metadata:"
+      puts "-" * 80
+
+      old_metadata = old_spec.metadata || {}
+      new_metadata = new_spec.metadata || {}
+
+      all_keys = (old_metadata.keys + new_metadata.keys).uniq.sort
+
+      if all_keys.empty?
+        puts "  (none)"
+        puts
+        return
+      end
+
+      all_keys.each do |key|
+        old_value = old_metadata[key]
+        new_value = new_metadata[key]
+
+        if old_value && !new_value
+          puts "  - #{key}: #{old_value}"
+        elsif !old_value && new_value
+          puts "  + #{key}: #{new_value}"
+        elsif old_value != new_value
+          puts "  ~ #{key}:"
+          puts "      #{old_value}"
+          puts "    → #{new_value}"
+        else
+          puts "    #{key}: #{new_value}"
+        end
+      end
+
+      puts
+    end
+
+    def compare_field(label, old_value, new_value)
+      old_value = old_value.to_s.strip
+      new_value = new_value.to_s.strip
+
+      if old_value != new_value && !old_value.empty?
+        puts "  ~ #{label}:"
+        puts "      #{old_value}"
+        puts "    → #{new_value}"
+      else
+        puts "    #{label}: #{new_value}"
+      end
+    end
+  end
+end

data/lib/diff_gem/version.rb

@@ -0,0 +1,3 @@
+module DiffGem
+  VERSION = "0.1.0"
+end

data/lib/diff_gem.rb

@@ -0,0 +1,9 @@
+require_relative "diff_gem/version"
+require_relative "diff_gem/gem_extractor"
+require_relative "diff_gem/comparer"
+require_relative "diff_gem/metadata_comparer"
+require_relative "diff_gem/cli"
+
+module DiffGem
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: diff_gem
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Developer
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+description: A tool to download and compare the source trees of two different versions
+  of a Ruby gem, displaying differences in diff format
+email:
+- developer@example.com
+executables:
+- diff_gem
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/settings.local.json"
+- Gemfile
+- Gemfile.lock
+- README.md
+- exe/diff_gem
+- lib/diff_gem.rb
+- lib/diff_gem/cli.rb
+- lib/diff_gem/comparer.rb
+- lib/diff_gem/gem_extractor.rb
+- lib/diff_gem/metadata_comparer.rb
+- lib/diff_gem/version.rb
+homepage: https://github.com/example/diff_gem
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/example/diff_gem
+  source_code_uri: https://github.com/example/diff_gem
+  changelog_uri: https://github.com/example/diff_gem/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: Compare source code between two versions of a Ruby gem
+test_files: []