gemkeeper 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97154d493b89cc264c9de34cd0c15f3712d2e23a9757ec9fc749c436dee126d5
-  data.tar.gz: 4dba3a688a98ea40994b5979f5ef16df68ecad0cbc6fb5a8f2581abab40b0537
+  metadata.gz: f8a541f4777f6bff36eab8be7c1c7382e6e8354dd20dbe8b0e47c1d2a2d168fd
+  data.tar.gz: 112afe0590f5582455935123ec0e35bd52e7faaf8f6811ba7ef5924df0732e73
 SHA512:
-  metadata.gz: 4531fa55ac8d2f512ba602bee71752299b22e0243313ed1c3489bf6d5b9723f8d94d7a23da77a2fa2de8cd9587fac243f34fb899c3c11d43d5c6a77a05d99818
-  data.tar.gz: 85e9e466db67728d70ca25be6fec81a98717325021e5a8e38257e1b4d51fde54c91e9486e2284f0a81cd68f6bc74a9ba87d319e3c994e8567574e1de86c17c4d
+  metadata.gz: 3607617a5dc756210591b2ab71bb2ebe435e63ba458cd91ab112f6d98e4f1cf429939fc6261719a3ad5496ce98372ad668341418c5578add309d9e9f5d87201d
+  data.tar.gz: 9021ae8ed7015325522bb616b36e3729f6d4dd307a6017a226e48bf328f765d1134a92171b1ceacad33a582d5c0e1fd61c6269e89f32d4612703561cb45daeb2

data/.reek.yml

@@ -0,0 +1,37 @@
+---
+# Reek skips test files — Minitest patterns (setup instance vars, accumulating test methods,
+# calling the same method before/after) are idiomatic there, not smells.
+exclude_paths:
+  - test
+
+detectors:
+  IrresponsibleModule:
+    exclude:
+    # Pure namespace modules — no behaviour to document
+    - Gemkeeper
+    - Gemkeeper::CLI
+    - Gemkeeper::CLI::Commands
+    - Gemkeeper::CLI::Commands::Server
+    # One-liner exception subclasses — their names are the documentation
+    - Gemkeeper::Error
+    - Gemkeeper::ConfigurationError
+    - Gemkeeper::ConfigFileNotFoundError
+    - Gemkeeper::InvalidConfigError
+    - Gemkeeper::ManifestNotFoundError
+    - Gemkeeper::GitError
+    - Gemkeeper::CloneError
+    - Gemkeeper::CheckoutError
+    - Gemkeeper::BuildError
+    - Gemkeeper::GemspecNotFoundError
+    - Gemkeeper::UploadError
+    - Gemkeeper::ServerError
+    - Gemkeeper::ServerAlreadyRunningError
+    - Gemkeeper::ServerNotRunningError
+    # CLI command classes carry a dry-cli `desc` as their documentation
+    - Gemkeeper::CLI::Commands::List
+    - Gemkeeper::CLI::Commands::Setup
+    - Gemkeeper::CLI::Commands::Sync
+    - Gemkeeper::CLI::Commands::Version
+    - Gemkeeper::CLI::Commands::Server::Start
+    - Gemkeeper::CLI::Commands::Server::Stop
+    - Gemkeeper::CLI::Commands::Server::Status

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-05-27
+
+### Added
+
+- `gemkeeper setup --global` writes the config to the system-wide location used by the Homebrew service (`/opt/homebrew/etc/gemkeeper.yml` on Apple Silicon, `/usr/local/etc/gemkeeper.yml` on Intel, `~/.config/gemkeeper/config.yml` as a fallback) rather than the current project directory.
+  Data paths (`repos_path`, `gems_path`) are written as absolute paths under the corresponding `var` directory so the daemon finds them regardless of working directory.
+  Use this flag when running gemkeeper as a shared `brew services` daemon instead of a per-project process.
+- `--global` and `--config` are mutually exclusive; passing both exits with an error.
+
 ## [0.2.1] - 2026-05-19
 
 ### Fixed
@@ -26,6 +35,7 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/danhorst/gemkeeper/compare/0.2.1...0.3.0
 [0.2.1]: https://github.com/danhorst/gemkeeper/compare/0.2.0...0.2.1
 [0.2.0]: https://github.com/danhorst/gemkeeper/compare/0.1.0...0.2.0

data/README.md

@@ -174,8 +174,15 @@ gemkeeper setup path/to/Gemfile.lock --manifest ~/.config/myorg/manifest.yml
 
 # Overwrite existing gemkeeper.yml entirely
 gemkeeper setup path/to/Gemfile.lock --force
+
+# Write to the global Homebrew service config instead of the current directory
+gemkeeper setup path/to/Gemfile.lock --global
 ```
 
+`--global` targets the system-wide config used by `brew services` — `/opt/homebrew/etc/gemkeeper.yml` on Apple Silicon or `/usr/local/etc/gemkeeper.yml` on Intel.
+It sets `repos_path` and `gems_path` as absolute paths under the corresponding `var` directory so the daemon finds them regardless of which directory you run commands from.
+`--global` and `--config` are mutually exclusive.
+
 ### Gem Synchronization
 
 ```bash
@@ -208,7 +215,18 @@ All commands support:
 
 ### Homebrew Services (macOS)
 
-If installed via Homebrew:
+If installed via Homebrew, gemkeeper can run as a shared system daemon — one server, all projects.
+
+**Configure the service** from any project that has a `Gemfile.lock`:
+
+```bash
+gemkeeper setup path/to/Gemfile.lock --global
+```
+
+This writes `/opt/homebrew/etc/gemkeeper.yml` (Apple Silicon) or `/usr/local/etc/gemkeeper.yml` (Intel) with absolute data paths.
+Run it again from any other project to merge its gems into the shared config.
+
+**Manage the daemon:**
 
 ```bash
 # Start and enable at login

data/lib/gemkeeper/cli/commands/list.rb

@@ -11,11 +11,12 @@ module Gemkeeper
         def call(**options)
           config = Configuration.load(options[:config])
 
-          gem_files = Dir.glob(File.join(config.gems_path, "gems", "*.gem"))
+          gems_path = config.gems_path
+          gem_files = Dir.glob(File.join(gems_path, "gems", "*.gem"))
 
           if gem_files.empty?
             puts "No gems cached in Geminabox"
-            puts "  Gems directory: #{config.gems_path}"
+            puts "  Gems directory: #{gems_path}"
             return
           end
 

data/lib/gemkeeper/cli/commands/server/start.rb

@@ -13,25 +13,27 @@ module Gemkeeper
                               desc: "Run in foreground (don't daemonize)"
 
           def call(**options)
+            port = options[:port]
             config = Configuration.load(options[:config])
-            config = override_port(config, options[:port]) if options[:port]
+            config = override_port(config, port) if port
 
             manager = ServerManager.new(config)
+            url = config.geminabox_url
 
             if options[:foreground]
-              puts "Starting Geminabox server at #{config.geminabox_url}"
+              puts "Starting Geminabox server at #{url}"
               puts "Press Ctrl+C to stop"
               manager.start_foreground
             else
               manager.start
-              puts "Geminabox server started at #{config.geminabox_url}"
+              puts "Geminabox server started at #{url}"
               puts "PID: #{File.read(config.pid_file).strip}"
             end
-          rescue ServerAlreadyRunningError => e
-            warn "Error: #{e.message}"
+          rescue ServerAlreadyRunningError => error
+            warn "Error: #{error.message}"
             exit 1
-          rescue ServerError => e
-            warn "Error starting server: #{e.message}"
+          rescue ServerError => error
+            warn "Error starting server: #{error.message}"
             exit 1
           rescue Interrupt
             puts "\nShutting down..."

data/lib/gemkeeper/cli/commands/server/stop.rb

@@ -15,11 +15,11 @@ module Gemkeeper
             manager.stop
 
             puts "Geminabox server stopped"
-          rescue ServerNotRunningError => e
-            warn "Error: #{e.message}"
+          rescue ServerNotRunningError => error
+            warn "Error: #{error.message}"
             exit 1
-          rescue ServerError => e
-            warn "Error stopping server: #{e.message}"
+          rescue ServerError => error
+            warn "Error stopping server: #{error.message}"
             exit 1
           end
         end

data/lib/gemkeeper/cli/commands/setup.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module Gemkeeper
   module CLI
     module Commands
@@ -13,110 +11,51 @@ module Gemkeeper
         option :manifest, type: :string,
                           desc: "Path to gem manifest (default: ~/.config/gemkeeper/manifest.yml)"
         option :config, type: :string, desc: "Path to write gemkeeper.yml (default: ./gemkeeper.yml)"
+        option :global, type: :boolean, default: false,
+                        desc: "Write to the global service config (for use with brew services)"
         option :force, type: :boolean, default: false,
                        desc: "Overwrite existing gemkeeper.yml entirely"
 
         def call(lockfile_path:, **options)
-          manifest_path = options[:manifest] || ManifestReader::DEFAULT_PATH
-          output_path = options[:config] || File.join(Dir.pwd, Configuration::DEFAULT_CONFIG_FILENAME)
+          validate_options!(options)
 
-          manifest = ManifestReader.load(manifest_path)
+          output_path = resolve_output_path(options)
+          manifest = ManifestReader.load(options[:manifest] || ManifestReader::DEFAULT_PATH)
           lockfile_versions = LockfileParser.parse(lockfile_path)
+          global_output_path = options[:global] ? output_path : nil
 
-          matched = match_gems(manifest, lockfile_versions)
+          config = ConfigGenerator.new(manifest:, lockfile_versions:)
+                                  .build(output_path, force: options[:force], global_output_path:)
 
-          write_config(matched, output_path, force: options[:force])
-          print_bundler_instructions(output_path, manifest)
-        rescue ManifestNotFoundError => e
-          warn "Error: #{e.message}"
+          File.write(output_path, config.to_yaml)
+          puts "Wrote #{output_path}"
+          print_bundler_instructions(config, manifest)
+        rescue ManifestNotFoundError => error
+          warn "Error: #{error.message}"
           exit 1
         end
 
         private
 
-        def match_gems(manifest, lockfile_versions)
-          matched = manifest.gems.filter_map do |gem_entry|
-            name = gem_entry[:name]
-            { name: name, repo: gem_entry[:repo] } if lockfile_versions.key?(name)
-          end
-
-          warn_unmatched_internals(manifest, lockfile_versions)
-          matched
-        end
-
-        def warn_unmatched_internals(manifest, lockfile_versions)
-          lockfile_versions.each_key do |gem_name|
-            next if manifest.find_by_name(gem_name)
-
-            gem_prefix = gem_name.split("-").first
-            next unless manifest.gem_names.any? { |manifest_name| manifest_name.split("-").first == gem_prefix }
-
-            warn "Warning: #{gem_name} matches an internal name pattern but is not in the manifest — skipping"
-          end
-        end
-
-        def write_config(matched_gems, output_path, force:)
-          existing = load_existing_config(output_path) unless force
-          existing ||= {}
-
-          gem_entries = matched_gems.map do |gem_entry|
-            { "repo" => gem_entry[:repo], "version" => "from_lockfile" }
-          end
+        def validate_options!(options)
+          return unless options[:global] && options[:config]
 
-          config = if force || existing.empty?
-                     build_fresh_config(gem_entries)
-                   else
-                     merge_config(existing, gem_entries, matched_gems)
-                   end
-
-          File.write(output_path, config.to_yaml)
-          puts "Wrote #{output_path}"
+          warn "Error: --global and --config are mutually exclusive"
+          exit 1
         end
 
-        def load_existing_config(path)
-          return nil unless File.exist?(path)
+        def resolve_output_path(options)
+          return options[:config] || File.join(Dir.pwd, Configuration::DEFAULT_CONFIG_FILENAME) unless options[:global]
 
-          YAML.safe_load_file(path, permitted_classes: [], symbolize_names: false) || {}
+          Configuration.resolve_global_path || no_global_path!
         end
 
-        def build_fresh_config(gem_entries)
-          {
-            "port" => Configuration::DEFAULT_PORT,
-            "repos_path" => "./cache/repos",
-            "gems_path" => "./cache/gems",
-            "gems" => gem_entries
-          }
-        end
-
-        def merge_config(existing, _new_gem_entries, matched_gems)
-          existing_gems = existing["gems"] || []
-          matched_names = matched_gems.map { |gem_entry| gem_entry[:name] }
-
-          # Build a lookup for new entries by repo
-          new_by_name = matched_gems.to_h do |gem_entry|
-            entry_name = gem_entry[:name]
-            [entry_name, { "repo" => gem_entry[:repo], "version" => "from_lockfile" }]
-          end
-
-          # Update existing entries for matched gems, keep others untouched
-          updated = existing_gems.map do |entry|
-            repo = entry["repo"].to_s
-            name = File.basename(repo, ".git").sub(/^ruby-/, "")
-            if matched_names.include?(name)
-              new_by_name.delete(name).merge(entry.except("version")).merge("version" => "from_lockfile")
-            else
-              entry
-            end
-          end
-
-          # Append any matched gems not already in the config
-          updated += new_by_name.values
-
-          existing.merge("gems" => updated)
+        def no_global_path!
+          warn "Error: no writable global config path found — install Homebrew or create ~/.config/gemkeeper/"
+          exit 1
         end
 
-        def print_bundler_instructions(config_path, manifest)
-          config = load_existing_config(config_path) || {}
+        def print_bundler_instructions(config, manifest)
           port = config.fetch("port", Configuration::DEFAULT_PORT)
           local_url = "http://localhost:#{port}"
           source_url = manifest.source_url

data/lib/gemkeeper/cli/commands/sync.rb

@@ -42,22 +42,25 @@ module Gemkeeper
           gems_to_sync.each do |gem_def|
             result = sync_gem(gem_def, config, uploader)
             counts[result] += 1
-          rescue Error => e
-            failures << { name: gem_def.name, message: e.message }
+          rescue Error => error
+            failures << { name: gem_def.name, message: error.message }
           end
           [counts, failures]
         end
 
         def report_results(counts, failures, total)
+          synced  = counts[:synced]
+          skipped = counts[:skipped]
+          failure_count = failures.size
           parts = []
-          parts << Output.colorize("#{counts[:synced]} synced", :green) if counts[:synced].positive?
-          parts << Output.colorize("#{counts[:skipped]} skipped", :yellow) if counts[:skipped].positive?
-          parts << Output.colorize("#{failures.size} failed", :red) if failures.any?
+          parts << Output.colorize("#{synced} synced", :green) if synced.positive?
+          parts << Output.colorize("#{skipped} skipped", :yellow) if skipped.positive?
+          parts << Output.colorize("#{failure_count} failed", :red) if failures.any?
           puts "\nSync complete: #{parts.join(", ")} (#{total} total)"
 
           return if failures.empty?
 
-          warn "\nSync completed with #{failures.size} failure(s):"
+          warn "\nSync completed with #{failure_count} failure(s):"
           failures.each { |f| warn "  #{f[:name]}: #{f[:message]}" }
           exit 1
         end
@@ -68,7 +71,8 @@ module Gemkeeper
           gems_path = config.gems_path
           version = resolve_version(gem_def)
 
-          return :skipped if !gem_def.latest? && cached?(name, version, gems_path)
+          latest = gem_def.latest?
+          return :skipped if !latest && cached?(name, version, gems_path)
 
           puts "Syncing #{name} @ #{version}..."
 
@@ -80,14 +84,14 @@ module Gemkeeper
 
           checkout_gem_version(repo, version)
 
-          if gem_def.latest?
+          if latest
             version = repo.current_version or
               raise BuildError, "Could not read version from gemspec in #{repo_url}"
             return :skipped if cached?(name, version, gems_path)
           end
 
           Output.step("Building gem...")
-          gem_path = GemBuilder.new(local_path, config.gems_path).build
+          gem_path = GemBuilder.new(local_path, gems_path).build
 
           Output.step("Uploading to Geminabox...")
           result = uploader.upload(gem_path)
@@ -127,8 +131,8 @@ module Gemkeeper
 
         def fetch_repo(repo, repo_url)
           repo.clone_or_pull
-        rescue GitError => e
-          raise auth_error?(e) ? auth_failure_error(repo_url, e) : e
+        rescue GitError => git_error
+          raise auth_error?(git_error) ? auth_failure_error(repo_url, git_error) : git_error
         end
 
         def checkout_gem_version(repo, version)

data/lib/gemkeeper/config_generator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Gemkeeper
+  # Isolates merge/build logic from CLI commands so setup-adjacent features share a single path.
+  class ConfigGenerator
+    def initialize(manifest:, lockfile_versions:)
+      @manifest = manifest
+      @lockfile_versions = lockfile_versions
+    end
+
+    def build(output_path, force:, global_output_path: nil)
+      existing = force ? {} : (load_existing(output_path) || {})
+      matched = matched_gems
+
+      existing.empty? ? build_fresh(matched, global_output_path:) : merge(existing, matched)
+    end
+
+    private
+
+    def matched_gems
+      matched = @manifest.gems.filter_map do |gem_entry|
+        name = gem_entry[:name]
+        { name:, repo: gem_entry[:repo] } if @lockfile_versions.key?(name)
+      end
+      warn_unmatched
+      matched
+    end
+
+    def warn_unmatched
+      @lockfile_versions.each_key do |gem_name|
+        next if @manifest.find_by_name(gem_name)
+
+        prefix = gem_name.split("-").first
+        next unless @manifest.gem_names.any? { |n| n.split("-").first == prefix }
+
+        warn "Warning: #{gem_name} matches an internal name pattern but is not in the manifest — skipping"
+      end
+    end
+
+    def load_existing(path)
+      return nil unless File.exist?(path)
+
+      YAML.safe_load_file(path, permitted_classes: [], symbolize_names: false) || {}
+    end
+
+    def build_fresh(matched, global_output_path: nil)
+      repos_path, gems_path = data_paths_for(global_output_path)
+      gem_entries = matched.map { |g| { "repo" => g[:repo], "version" => "from_lockfile" } }
+      { "port" => Configuration::DEFAULT_PORT, "repos_path" => repos_path,
+        "gems_path" => gems_path, "gems" => gem_entries }
+    end
+
+    def data_paths_for(global_output_path)
+      return ["./cache/repos", "./cache/gems"] unless global_output_path
+
+      data_dir = Configuration.global_data_dir(global_output_path)
+      [File.join(data_dir, "repos"), File.join(data_dir, "gems")]
+    end
+
+    def merge(existing, matched)
+      existing_gems = existing["gems"] || []
+      new_by_name = matched.to_h { |g| [g[:name], { "repo" => g[:repo], "version" => "from_lockfile" }] }
+
+      updated = existing_gems.map do |entry|
+        name = File.basename(entry["repo"].to_s, ".git").sub(/^ruby-/, "")
+        if new_by_name.key?(name)
+          new_by_name.delete(name).merge(entry.except("version")).merge("version" => "from_lockfile")
+        else
+          entry
+        end
+      end
+
+      updated += new_by_name.values
+      existing.merge("gems" => updated)
+    end
+  end
+end

data/lib/gemkeeper/configuration.rb

@@ -4,6 +4,7 @@ require "yaml"
 require "fileutils"
 
 module Gemkeeper
+  # Single source of truth for resolved paths and settings; callers never touch raw YAML keys.
   class Configuration
     DEFAULT_PORT = 9292
     DEFAULT_CONFIG_FILENAME = "gemkeeper.yml"
@@ -17,6 +18,33 @@ module Gemkeeper
       -> { "/opt/homebrew/etc/gemkeeper.yml" }                         # Homebrew (Apple Silicon)
     ].freeze
 
+    # Candidate paths for the global service config, in priority order
+    GLOBAL_CONFIG_PATHS = [
+      -> { "/opt/homebrew/etc/gemkeeper.yml" },
+      -> { "/usr/local/etc/gemkeeper.yml" },
+      -> { File.expand_path("~/.config/gemkeeper/config.yml") }
+    ].freeze
+
+    def self.global_config_paths
+      override = ENV.fetch("GEMKEEPER_GLOBAL_CONFIG", nil)
+      return [override] if override
+
+      GLOBAL_CONFIG_PATHS.map(&:call)
+    end
+
+    def self.resolve_global_path
+      global_config_paths.find { |path| File.directory?(File.dirname(path)) }
+    end
+
+    def self.global_data_dir(config_path)
+      config_dir = File.dirname(File.expand_path(config_path))
+      if config_dir.end_with?("/etc")
+        File.join(File.dirname(config_dir), "var", "gemkeeper")
+      else
+        config_dir
+      end
+    end
+
     attr_reader :port, :repos_path, :gems_path, :pid_file, :gems
 
     def self.load(config_path = nil)
@@ -67,8 +95,8 @@ module Gemkeeper
 
       begin
         YAML.safe_load_file(@config_path, permitted_classes: [], symbolize_names: true) || {}
-      rescue Psych::SyntaxError => e
-        raise InvalidConfigError, "Invalid YAML in #{@config_path}: #{e.message}"
+      rescue Psych::SyntaxError => yaml_error
+        raise InvalidConfigError, "Invalid YAML in #{@config_path}: #{yaml_error.message}"
       end
     end
 
@@ -84,6 +112,7 @@ module Gemkeeper
       FileUtils.mkdir_p(@gems_path)
     end
 
+    # Keeps per-gem config strongly typed so callers get validated attributes instead of raw hash access.
     class GemDefinition
       VALID_VERSION_PATTERN = /\A[a-zA-Z0-9._-]+\z/
       RESERVED_VERSIONS = %w[latest from_lockfile].freeze

data/lib/gemkeeper/gem_builder.rb

@@ -4,6 +4,7 @@ require "open3"
 require "fileutils"
 
 module Gemkeeper
+  # Shells out to `gem build` in an isolated working directory; decoupled so tests can stub it.
   class GemBuilder
     attr_reader :repo_path, :output_dir
 

data/lib/gemkeeper/gem_uploader.rb

@@ -4,6 +4,7 @@ require "faraday"
 require "faraday/multipart"
 
 module Gemkeeper
+  # Encapsulates Geminabox's HTTP API so callers never construct multipart requests directly.
   class GemUploader
     attr_reader :geminabox_url
 
@@ -30,13 +31,14 @@ module Gemkeeper
     def list_gems
       response = connection.get("/api/v1/gems.json")
 
-      raise UploadError, "Failed to list gems: #{response.status} #{response.body}" unless response.success?
+      body = response.body
+      raise UploadError, "Failed to list gems: #{response.status} #{body}" unless response.success?
 
-      JSON.parse(response.body)
-    rescue JSON::ParserError => e
-      raise UploadError, "Invalid JSON response: #{e.message}"
-    rescue Faraday::Error => e
-      raise UploadError, "Connection error: #{e.message}"
+      JSON.parse(body)
+    rescue JSON::ParserError => parse_error
+      raise UploadError, "Invalid JSON response: #{parse_error.message}"
+    rescue Faraday::Error => connection_error
+      raise UploadError, "Connection error: #{connection_error.message}"
     end
 
     private
@@ -50,16 +52,18 @@ module Gemkeeper
     end
 
     def handle_response(response, gem_path)
-      case response.status
+      status   = response.status
+      gem_name = File.basename(gem_path)
+      case status
       when 200, 201, 302
-        { success: true, message: "Uploaded #{File.basename(gem_path)}" }
+        { success: true, message: "Uploaded #{gem_name}" }
       when 409
-        { success: true, message: "#{File.basename(gem_path)} already exists", skipped: true }
+        { success: true, message: "#{gem_name} already exists", skipped: true }
       else
-        raise UploadError, "Upload failed (#{response.status}): #{response.body}"
+        raise UploadError, "Upload failed (#{status}): #{response.body}"
       end
-    rescue Faraday::Error => e
-      raise UploadError, "Connection error: #{e.message}"
+    rescue Faraday::Error => connection_error
+      raise UploadError, "Connection error: #{connection_error.message}"
     end
   end
 end

data/lib/gemkeeper/git_repository.rb

@@ -4,6 +4,7 @@ require "open3"
 require "fileutils"
 
 module Gemkeeper
+  # Centralizes safe ref validation; prevents command injection via untrusted version strings.
   class GitRepository
     attr_reader :repo_url, :local_path
 

data/lib/gemkeeper/lockfile_parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Gemkeeper
+  # Locates the nearest Gemfile.lock by walking up; callers don't need to know the search algorithm.
   class LockfileParser
     LOCKFILE_NAME = "Gemfile.lock"
 
@@ -38,13 +39,14 @@ module Gemkeeper
       in_gem_specs = false
 
       content.each_line do |line|
-        if line.strip == "GEM"
+        stripped = line.strip
+        if stripped == "GEM"
           in_gem_specs = true
           next
         end
 
         # A new top-level section (no leading spaces) ends the GEM block
-        in_gem_specs = false if in_gem_specs && line =~ /\A[A-Z]/ && line.strip != "GEM"
+        in_gem_specs = false if in_gem_specs && line =~ /\A[A-Z]/ && stripped != "GEM"
 
         next unless in_gem_specs
 

data/lib/gemkeeper/manifest_reader.rb

@@ -3,6 +3,7 @@
 require "yaml"
 
 module Gemkeeper
+  # Decouples manifest format from sync/setup commands that need the eligible gem list.
   class ManifestReader
     DEFAULT_PATH = File.expand_path("~/.config/gemkeeper/manifest.yml")
 

data/lib/gemkeeper/output.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Gemkeeper
+  # Centralizes ANSI gating so color codes never appear in test output or pipes.
   module Output
     COLORS = {
       green: "\e[32m",

data/lib/gemkeeper/server_manager.rb

@@ -4,6 +4,7 @@ require "open3"
 require "fileutils"
 
 module Gemkeeper
+  # Owns the rackup/puma lifecycle so CLI commands delegate process management here.
   class ServerManager
     attr_reader :config
 

data/lib/gemkeeper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gemkeeper
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/gemkeeper.rb

@@ -6,6 +6,7 @@ require_relative "gemkeeper/output"
 require_relative "gemkeeper/configuration"
 require_relative "gemkeeper/lockfile_parser"
 require_relative "gemkeeper/manifest_reader"
+require_relative "gemkeeper/config_generator"
 require_relative "gemkeeper/git_repository"
 require_relative "gemkeeper/gem_builder"
 require_relative "gemkeeper/gem_uploader"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gemkeeper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Dan Brubaker Horst
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-19 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-cli
@@ -89,6 +89,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".reek.yml"
 - CHANGELOG.md
 - LICENSE
 - README.md
@@ -102,6 +103,7 @@ files:
 - lib/gemkeeper/cli/commands/setup.rb
 - lib/gemkeeper/cli/commands/sync.rb
 - lib/gemkeeper/cli/commands/version.rb
+- lib/gemkeeper/config_generator.rb
 - lib/gemkeeper/configuration.rb
 - lib/gemkeeper/errors.rb
 - lib/gemkeeper/gem_builder.rb