gem_changelog_diff 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47e69603bad8c0641ed060fc572632c76d014dcc09f98d75322cafceefa4a1a2
-  data.tar.gz: beb52279aac1a12e5da0e19ce981d5b7bfa497a385130de9a7503cc4ac871742
+  metadata.gz: 5fff27b4446b9283fde0a59b3df642289748c7551988836dfea4260f75798d2d
+  data.tar.gz: cd72d26b57447d9fb24e70274adeadf3955637aaf2f24c3f74d8f2d92c962eec
 SHA512:
-  metadata.gz: e5fa45dae9504354720cafa62e7e05768b58de06d1b0376496ba3e38b74b05dc7a23b10b3ca00338acca5e38ce2f29f17495d040d508fe6f14e03515cdf33a02
-  data.tar.gz: 537bea10e8961bff3b2d2c55530afcbe0de4fd0ab422c224b4d7b821edfe264821cb683e3d2a242d29cd551779d15a6c480e4269795347a25f190b59e56e886d
+  metadata.gz: 0ec391d55ff38fefd88ad0f9c18de86d7867b74357e2eeff19b0d84f160365faff36ce70ef329fac3dca75e0adf119dcb385efad884daae630e7108715b77c64
+  data.tar.gz: 78f6be459bd426c79c3ccc6c485a917fa5e09b6d122d08dc4f72566b49e13654d17183536f795f1a22481aede43bcaa9ae324ee6dbc25665179381105efd1377

data/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-06-18
+
+### Added
+
+- Disk cache at `~/.cache/gem_changelog_diff/` with configurable TTL (default 24h)
+- ETag conditional requests to avoid consuming rate limit on revalidation
+- `cache clear` subcommand
+- `--no-cache` and `--cache-ttl` flags
+- Concurrent fetching via thread pool (default 4, configurable via `--concurrency`)
+- Progress indicator via `tty-spinner` when running in a terminal
+
 ## [0.4.0] - 2026-06-18
 
 ### Added
@@ -53,7 +64,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Plain text formatter for changelog output
 - Full end-to-end pipeline: detect → lookup → fetch → format
 
-[Unreleased]: https://github.com/eclectic-coding/gem_changelog_diff/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/eclectic-coding/gem_changelog_diff/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/eclectic-coding/gem_changelog_diff/releases/tag/v0.5.0
 [0.4.0]: https://github.com/eclectic-coding/gem_changelog_diff/releases/tag/v0.4.0
 [0.3.0]: https://github.com/eclectic-coding/gem_changelog_diff/releases/tag/v0.3.0
 [0.2.0]: https://github.com/eclectic-coding/gem_changelog_diff/releases/tag/v0.2.0

data/README.md

@@ -16,6 +16,7 @@ CLI that shows you the changelog diff for each gem before you `bundle update`, p
   - [Output Control](#output-control)
   - [Detection Strategy](#detection-strategy)
   - [Filtering](#filtering)
+  - [Caching](#caching)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -87,6 +88,16 @@ gem_changelog_diff --group development   # Filter by Bundler group
 gem_changelog_diff --ignore rails rake   # Exclude specific gems
 ```
 
+### Caching
+
+API responses are cached to `~/.cache/gem_changelog_diff/` with a 24-hour TTL. Subsequent runs reuse cached data and use ETag conditional requests to avoid consuming rate limit.
+
+```bash
+gem_changelog_diff --no-cache             # Bypass the cache
+gem_changelog_diff --cache-ttl 3600       # Set TTL to 1 hour
+gem_changelog_diff cache clear            # Clear all cached data
+```
+
 [Back to top](#gemchangelogdiff)
 
 ## Development

data/ROADMAP.md

@@ -2,21 +2,6 @@
 
 Feature roadmap for gem_changelog_diff. Each section is auto-pruned by `bin/release` when that version ships.
 
-## 0.5.0 -- Caching & Performance
-
-Avoid redundant API calls. Make repeated runs fast on large dependency trees.
-
-- Disk cache at `~/.cache/gem_changelog_diff/` with configurable TTL (default 24h)
-- ETag conditional requests to avoid consuming rate limit on revalidation
-- Concurrent fetching via Ruby threads (default concurrency: 4, configurable via `--concurrency`)
-- Progress indicator via `tty-spinner`
-- `cache clear` subcommand, `--no-cache` and `--cache-ttl` flags
-
-**New files:** `cache.rb`, `concurrent_fetcher.rb`
-**Dependencies:** `tty-spinner` (runtime)
-
----
-
 ## 0.6.0 -- Interactive Mode & Output Formats
 
 Let users selectively browse changelogs. Support machine-readable output for CI and scripting.

data/lib/gem_changelog_diff/cache.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "net/http"
+
+module GemChangelogDiff
+  class Cache
+    DEFAULT_DIR = File.join(Dir.home, ".cache", "gem_changelog_diff")
+    DEFAULT_TTL = 86_400
+
+    def initialize(cache_dir: DEFAULT_DIR, ttl: DEFAULT_TTL, enabled: true)
+      @cache_dir = cache_dir
+      @ttl = ttl
+      @enabled = enabled
+    end
+
+    def get(uri, headers: {})
+      return fetch_from_network(uri, headers) unless @enabled
+
+      key = cache_key(uri)
+      entry = read_entry(key)
+
+      if entry && fresh?(entry)
+        build_response(entry)
+      elsif entry && entry["etag"]
+        revalidate(uri, headers, entry, key)
+      else
+        fetch_and_store(uri, headers, key)
+      end
+    end
+
+    def clear
+      FileUtils.rm_rf(@cache_dir)
+    end
+
+    private
+
+    def cache_key(uri)
+      Digest::SHA256.hexdigest(uri.to_s)
+    end
+
+    def entry_path(key)
+      File.join(@cache_dir, "#{key}.json")
+    end
+
+    def read_entry(key)
+      path = entry_path(key)
+      return nil unless File.exist?(path)
+
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    def write_entry(key, body:, code:, etag:)
+      FileUtils.mkdir_p(@cache_dir)
+      data = { "body" => body, "code" => code, "etag" => etag, "timestamp" => Time.now.to_i }
+      File.write(entry_path(key), JSON.generate(data))
+    end
+
+    def fresh?(entry)
+      Time.now.to_i - entry["timestamp"] < @ttl
+    end
+
+    def revalidate(uri, headers, entry, key)
+      headers = headers.merge("If-None-Match" => entry["etag"])
+      response = fetch_from_network(uri, headers)
+
+      if response.code == "304"
+        write_entry(key, body: entry["body"], code: entry["code"], etag: entry["etag"])
+        build_response(entry)
+      else
+        store_response(key, response)
+        response
+      end
+    end
+
+    def fetch_and_store(uri, headers, key)
+      response = fetch_from_network(uri, headers)
+      store_response(key, response) if response.is_a?(Net::HTTPSuccess)
+      response
+    end
+
+    def fetch_from_network(uri, headers)
+      request = Net::HTTP::Get.new(uri)
+      headers.each { |k, v| request[k] = v }
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+    end
+
+    def store_response(key, response)
+      write_entry(key, body: response.body, code: response.code, etag: response["ETag"])
+    end
+
+    def build_response(entry)
+      CachedResponse.new(entry["body"], entry["code"])
+    end
+  end
+
+  class CachedResponse
+    attr_reader :body, :code
+
+    def initialize(body, code)
+      @body = body
+      @code = code
+    end
+
+    def is_a?(klass)
+      return true if klass == Net::HTTPSuccess && @code.start_with?("2")
+
+      super
+    end
+
+    def [](_header)
+      nil
+    end
+  end
+end

data/lib/gem_changelog_diff/changelog_parser.rb

@@ -9,6 +9,10 @@ module GemChangelogDiff
     FILENAMES = %w[CHANGELOG.md CHANGES.md History.md NEWS.md].freeze
     VERSION_HEADING = /^##\s+\[?v?(\d+[^\]\s]+)/
 
+    def initialize(cache: nil)
+      @cache = cache
+    end
+
     def entries_between(repo, current_version, newest_version)
       content = fetch_changelog(repo)
       return [] unless content
@@ -40,14 +44,22 @@ module GemChangelogDiff
     end
 
     def execute_request(uri)
+      headers = request_headers
+      return @cache.get(uri, headers: headers) if @cache
+
       request = Net::HTTP::Get.new(uri)
-      request["Accept"] = "application/vnd.github.v3+json"
-      request["User-Agent"] = "gem_changelog_diff/#{VERSION}"
+      headers.each { |k, v| request[k] = v }
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+    end
 
+    def request_headers
+      headers = {
+        "Accept" => "application/vnd.github.v3+json",
+        "User-Agent" => "gem_changelog_diff/#{VERSION}"
+      }
       token = GemChangelogDiff.configuration.github_token
-      request["Authorization"] = "token #{token}" if token
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+      headers["Authorization"] = "token #{token}" if token
+      headers
     end
 
     def parse_entries(content, current_version, newest_version)

data/lib/gem_changelog_diff/cli.rb

@@ -18,6 +18,9 @@ module GemChangelogDiff
     class_option :strategy, type: :string, default: "auto", desc: "Detection strategy (auto, outdated, lockfile)"
     class_option :group, type: :string, desc: "Filter by Bundler group"
     class_option :ignore, type: :array, desc: "Gems to skip"
+    class_option :no_cache, type: :boolean, default: false, desc: "Disable caching"
+    class_option :cache_ttl, type: :numeric, desc: "Cache TTL in seconds"
+    class_option :concurrency, type: :numeric, default: 4, desc: "Number of concurrent fetches"
 
     desc "check [GEM...]", "Show changelog diffs for outdated gems"
     def check(*gem_names)
@@ -30,11 +33,22 @@ module GemChangelogDiff
         return
       end
 
-      reports = build_reports(gems)
+      reports = with_spinner { build_reports(gems) }
       formatter = Formatter.new(color: color_enabled?)
       say formatter.format(reports)
     end
 
+    desc "cache SUBCOMMAND", "Manage the cache"
+    def cache(subcommand = nil)
+      case subcommand
+      when "clear"
+        Cache.new.clear
+        say "Cache cleared."
+      else
+        say "Usage: gem_changelog_diff cache clear"
+      end
+    end
+
     desc "version", "Print version"
     def version
       say "gem_changelog_diff #{VERSION}"
@@ -49,6 +63,12 @@ module GemChangelogDiff
       GemChangelogDiff.configuration.github_token = token if token
     end
 
+    def build_cache
+      ttl = options[:cache_ttl] || GemChangelogDiff.configuration.cache_ttl
+      enabled = !options[:no_cache] && GemChangelogDiff.configuration.cache_enabled
+      Cache.new(ttl: ttl, enabled: enabled)
+    end
+
     def detect_gems
       case options[:strategy]
       when "lockfile"
@@ -83,10 +103,15 @@ module GemChangelogDiff
     end
 
     def build_reports(gems)
-      rubygems_client = RubygemsClient.new
-      source_resolver = SourceResolver.new
-
-      gems.map { |gem| build_gem_report(gem, rubygems_client, source_resolver) }
+      cache = build_cache
+      rubygems_client = RubygemsClient.new(cache: cache)
+      source_resolver = SourceResolver.new(
+        github_client: GithubClient.new(cache: cache),
+        changelog_parser: ChangelogParser.new(cache: cache)
+      )
+      fetcher = ConcurrentFetcher.new(concurrency: options[:concurrency])
+
+      fetcher.fetch_all(gems) { |gem| build_gem_report(gem, rubygems_client, source_resolver) }
     end
 
     def build_gem_report(gem, rubygems_client, source_resolver)
@@ -102,6 +127,18 @@ module GemChangelogDiff
       { gem: gem, releases: [], error: "  #{e.message}" }
     end
 
+    def with_spinner
+      unless options[:quiet] || !$stderr.tty?
+        require "tty-spinner"
+        spinner = TTY::Spinner.new("[:spinner] Fetching changelogs...", format: :dots, output: $stderr)
+        spinner.auto_spin
+      end
+
+      result = yield
+      spinner&.stop("Done!")
+      result
+    end
+
     def color_enabled?
       !options[:no_color]
     end

data/lib/gem_changelog_diff/concurrent_fetcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GemChangelogDiff
+  class ConcurrentFetcher
+    def initialize(concurrency: 4)
+      @concurrency = concurrency
+    end
+
+    def fetch_all(items, &)
+      return items.map(&) if @concurrency <= 1
+
+      results = Array.new(items.size)
+      queue = Queue.new
+      items.each_with_index { |item, i| queue << [item, i] }
+
+      threads = spawn_workers(queue, results, &)
+      threads.each(&:join)
+      results
+    end
+
+    private
+
+    def spawn_workers(queue, results, &block)
+      worker_count = [@concurrency, queue.size].min
+      worker_count.times.map do
+        Thread.new { process_queue(queue, results, &block) }
+      end
+    end
+
+    def process_queue(queue, results, &block)
+      while (item, index = queue.pop(true))
+        results[index] = block.call(item)
+      end
+    rescue ThreadError
+      # Queue is empty
+    end
+  end
+end

data/lib/gem_changelog_diff/configuration.rb

@@ -2,7 +2,12 @@
 
 module GemChangelogDiff
   class Configuration
-    attr_accessor :github_token
+    attr_accessor :github_token, :cache_enabled, :cache_ttl
+
+    def initialize
+      @cache_enabled = true
+      @cache_ttl = 86_400
+    end
   end
 
   def self.configuration

data/lib/gem_changelog_diff/github_client.rb

@@ -9,6 +9,10 @@ module GemChangelogDiff
     TAG_VERSION_REGEX = /\Av?(\d+\..+)\z/
     RATE_LIMIT_WARNING_THRESHOLD = 10
 
+    def initialize(cache: nil)
+      @cache = cache
+    end
+
     def releases_between(repo, current_version, newest_version)
       releases = fetch_releases(repo)
       filter_releases(releases, current_version, newest_version)
@@ -29,17 +33,22 @@ module GemChangelogDiff
     end
 
     def execute_request(uri)
-      request = Net::HTTP::Get.new(uri)
-      request["Accept"] = "application/vnd.github.v3+json"
-      request["User-Agent"] = "gem_changelog_diff/#{VERSION}"
-      apply_auth(request)
+      headers = request_headers
+      return @cache.get(uri, headers: headers) if @cache
 
+      request = Net::HTTP::Get.new(uri)
+      headers.each { |k, v| request[k] = v }
       Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
     end
 
-    def apply_auth(request)
+    def request_headers
+      headers = {
+        "Accept" => "application/vnd.github.v3+json",
+        "User-Agent" => "gem_changelog_diff/#{VERSION}"
+      }
       token = GemChangelogDiff.configuration.github_token
-      request["Authorization"] = "token #{token}" if token
+      headers["Authorization"] = "token #{token}" if token
+      headers
     end
 
     def handle_response(response)

data/lib/gem_changelog_diff/rubygems_client.rb

@@ -8,6 +8,10 @@ module GemChangelogDiff
     RUBYGEMS_API = "https://rubygems.org/api/v1/gems/%<name>s.json"
     GITHUB_REPO_REGEX = %r{github\.com/([^/]+)/([^/]+)}
 
+    def initialize(cache: nil)
+      @cache = cache
+    end
+
     def repo_url(gem_name)
       data = fetch_gem_data(gem_name)
       return nil unless data
@@ -24,7 +28,7 @@ module GemChangelogDiff
 
     def fetch_gem_data(gem_name)
       uri = URI(format(RUBYGEMS_API, name: gem_name))
-      response = Net::HTTP.get_response(uri)
+      response = @cache ? @cache.get(uri) : Net::HTTP.get_response(uri)
       return nil unless response.is_a?(Net::HTTPSuccess)
 
       JSON.parse(response.body)

data/lib/gem_changelog_diff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GemChangelogDiff
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/gem_changelog_diff.rb

@@ -8,6 +8,7 @@ module GemChangelogDiff
 end
 
 require_relative "gem_changelog_diff/errors"
+require_relative "gem_changelog_diff/cache"
 require_relative "gem_changelog_diff/outdated_gem"
 require_relative "gem_changelog_diff/detector"
 require_relative "gem_changelog_diff/rubygems_client"
@@ -15,5 +16,6 @@ require_relative "gem_changelog_diff/lockfile_parser"
 require_relative "gem_changelog_diff/github_client"
 require_relative "gem_changelog_diff/changelog_parser"
 require_relative "gem_changelog_diff/source_resolver"
+require_relative "gem_changelog_diff/concurrent_fetcher"
 require_relative "gem_changelog_diff/formatter"
 require_relative "gem_changelog_diff/cli"

data/sig/gem_changelog_diff.rbs

@@ -24,6 +24,41 @@ module GemChangelogDiff
 
   class Configuration
     attr_accessor github_token: String?
+    attr_accessor cache_enabled: bool
+    attr_accessor cache_ttl: Integer
+
+    def initialize: () -> void
+  end
+
+  class Cache
+    DEFAULT_DIR: String
+    DEFAULT_TTL: Integer
+
+    def initialize: (?cache_dir: String, ?ttl: Integer, ?enabled: bool) -> void
+    def get: (URI::Generic uri, ?headers: Hash[String, String]) -> (Net::HTTPResponse | CachedResponse)
+    def clear: () -> void
+
+    private
+
+    def cache_key: (URI::Generic uri) -> String
+    def entry_path: (String key) -> String
+    def read_entry: (String key) -> Hash[String, untyped]?
+    def write_entry: (String key, body: String, code: String, etag: String?) -> void
+    def fresh?: (Hash[String, untyped] entry) -> bool
+    def revalidate: (URI::Generic uri, Hash[String, String] headers, Hash[String, untyped] entry, String key) -> (Net::HTTPResponse | CachedResponse)
+    def fetch_and_store: (URI::Generic uri, Hash[String, String] headers, String key) -> Net::HTTPResponse
+    def fetch_from_network: (URI::Generic uri, Hash[String, String] headers) -> Net::HTTPResponse
+    def store_response: (String key, Net::HTTPResponse response) -> void
+    def build_response: (Hash[String, untyped] entry) -> CachedResponse
+  end
+
+  class CachedResponse
+    attr_reader body: String
+    attr_reader code: String
+
+    def initialize: (String body, String code) -> void
+    def is_a?: (Class klass) -> bool
+    def []: (String _header) -> nil
   end
 
   class OutdatedGem
@@ -50,6 +85,7 @@ module GemChangelogDiff
     RUBYGEMS_API: String
     GITHUB_REPO_REGEX: Regexp
 
+    def initialize: (?cache: Cache?) -> void
     def repo_url: (String gem_name) -> String?
     def latest_version: (String gem_name) -> String?
 
@@ -81,13 +117,15 @@ module GemChangelogDiff
     FILENAMES: Array[String]
     VERSION_HEADING: Regexp
 
+    def initialize: (?cache: Cache?) -> void
     def entries_between: (String repo, String current_version, String newest_version) -> Array[release_hash]
 
     private
 
     def fetch_changelog: (String repo) -> String?
     def fetch_file: (String repo, String path) -> String?
-    def execute_request: (URI::Generic uri) -> Net::HTTPResponse
+    def execute_request: (URI::Generic uri) -> (Net::HTTPResponse | CachedResponse)
+    def request_headers: () -> Hash[String, String]
     def parse_entries: (String content, String current_version, String newest_version) -> Array[release_hash]
     def build_entry: (String version_str, String body, Gem::Version current, Gem::Version newest) -> release_hash?
     def split_sections: (String content) -> Array[[String, String]]
@@ -104,22 +142,34 @@ module GemChangelogDiff
   class GithubClient
     RELEASES_URL: String
     TAG_VERSION_REGEX: Regexp
+    RATE_LIMIT_WARNING_THRESHOLD: Integer
 
+    def initialize: (?cache: Cache?) -> void
     def releases_between: (String repo, String current_version, String newest_version) -> Array[release_hash]
 
     private
 
     def fetch_releases: (String repo) -> Array[Hash[String, untyped]]
-    def execute_request: (URI::Generic uri) -> Net::HTTPResponse
-    def apply_auth: (Net::HTTPRequest request) -> void
-    def handle_response: (Net::HTTPResponse response) -> Array[Hash[String, untyped]]
-    def check_rate_limit: (Net::HTTPResponse response) -> void
+    def execute_request: (URI::Generic uri) -> (Net::HTTPResponse | CachedResponse)
+    def request_headers: () -> Hash[String, String]
+    def handle_response: (Net::HTTPResponse | CachedResponse response) -> Array[Hash[String, untyped]]
+    def check_rate_limit: (Net::HTTPResponse | CachedResponse response) -> void
     def filter_releases: (Array[Hash[String, untyped]] releases, String current_version, String newest_version) -> Array[release_hash]
     def build_release: (Hash[String, untyped] release, Gem::Version current, Gem::Version newest) -> release_hash?
     def sort_releases: (Array[release_hash] releases) -> Array[release_hash]
     def extract_version: (String? tag) -> String?
   end
 
+  class ConcurrentFetcher
+    def initialize: (?concurrency: Integer) -> void
+    def fetch_all: [T, U] (Array[T], &) -> Array[U]
+
+    private
+
+    def spawn_workers: (Queue[untyped], Array[untyped], &) -> Array[Thread]
+    def process_queue: (Queue[untyped], Array[untyped], &) -> void
+  end
+
   type gem_report = {
     gem: OutdatedGem,
     releases: Array[release_hash],
@@ -149,13 +199,16 @@ module GemChangelogDiff
   class CLI < Thor
     def self.exit_on_failure?: () -> bool
 
-    def check: () -> void
+    def check: (*String gem_names) -> void
+    def cache: (?String? subcommand) -> void
     def version: () -> void
 
     private
 
+    def with_spinner: [T] () { () -> T } -> T
     def color_enabled?: () -> bool
     def configure_token: () -> void
+    def build_cache: () -> Cache
     def detect_gems: () -> Array[OutdatedGem]
     def detect_with_fallback: () -> Array[OutdatedGem]
     def detect_via_lockfile: () -> Array[OutdatedGem]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gem_changelog_diff
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: CLI that shows you the changelog diff for each gem before you bundle
   update, pulled from GitHub releases.
 email:
@@ -57,8 +71,10 @@ files:
 - codecov.yml
 - exe/gem_changelog_diff
 - lib/gem_changelog_diff.rb
+- lib/gem_changelog_diff/cache.rb
 - lib/gem_changelog_diff/changelog_parser.rb
 - lib/gem_changelog_diff/cli.rb
+- lib/gem_changelog_diff/concurrent_fetcher.rb
 - lib/gem_changelog_diff/configuration.rb
 - lib/gem_changelog_diff/detector.rb
 - lib/gem_changelog_diff/errors.rb