gemkeeper 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a541f4777f6bff36eab8be7c1c7382e6e8354dd20dbe8b0e47c1d2a2d168fd
-  data.tar.gz: 112afe0590f5582455935123ec0e35bd52e7faaf8f6811ba7ef5924df0732e73
+  metadata.gz: a97b09f4efb6325d8efdb7f33130bdf0f2e999c647b68838cb0db370d837d5b0
+  data.tar.gz: 55269457dce1d236e620b1f6a1f71b017ee724363363af2fb24e63f7bd583ad7
 SHA512:
-  metadata.gz: 3607617a5dc756210591b2ab71bb2ebe435e63ba458cd91ab112f6d98e4f1cf429939fc6261719a3ad5496ce98372ad668341418c5578add309d9e9f5d87201d
-  data.tar.gz: 9021ae8ed7015325522bb616b36e3729f6d4dd307a6017a226e48bf328f765d1134a92171b1ceacad33a582d5c0e1fd61c6269e89f32d4612703561cb45daeb2
+  metadata.gz: 630727692a8c0ec33456f0a3438a64b1aac25e14f4385803744b9ae992f97ca32ac3a914aead6b3901a102f9a4d7ad53c758cbd9e5a53baa314f9634a07799c5
+  data.tar.gz: e50b7fef90457e4a1941d8f96879775226a7b999cb90b579db36f82a98fb3dbd96e4cc367029b431c1d021f44b44c9521bd94ef32060a31ccb89682ed1f6be18

data/.reek.yml

@@ -17,7 +17,8 @@ detectors:
     - Gemkeeper::ConfigurationError
     - Gemkeeper::ConfigFileNotFoundError
     - Gemkeeper::InvalidConfigError
-    - Gemkeeper::ManifestNotFoundError
+    - Gemkeeper::UnresolvableGemError
+    - Gemkeeper::ManifestConflictError
     - Gemkeeper::GitError
     - Gemkeeper::CloneError
     - Gemkeeper::CheckoutError

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-05-27
+
+### Added
+
+- `gemkeeper setup` no longer requires a pre-existing manifest.
+  When given a Gemfile.lock, it discovers internal gems by source type and builds or updates `~/.config/gemkeeper/manifest.yml` automatically.
+  GIT-sourced gems (declared with `git:` in the Gemfile) are added directly — the repo URL comes from the lockfile.
+  Gems from private registries (e.g. GitHub Packages) have their repo URL inferred where possible or prompted for interactively; running non-interactively without a resolvable URL exits with a clear error.
+- `gemkeeper setup` accepts either a Gemfile.lock or an existing `gemkeeper.yml` as its argument.
+  Passing a `gemkeeper.yml` updates the manifest with its repo mappings and, with `--global`, installs it to the global config path.
+- The `--manifest` option controls the path used for both reading and writing the manifest, defaulting to `~/.config/gemkeeper/manifest.yml`.
+- `gemkeeper setup` now automatically configures Bundler mirror settings for each private gem registry found in the lockfile, pointing them at the local Geminabox.
+  Uses `--local` scope by default; `--global` setup uses `--global` scope.
+  Pass `--skip-bundler-config` to opt out.
+
+### Fixed
+
+- GIT-sourced gems (pinned in the `GIT` section of the lockfile) are now included in the generated `gemkeeper.yml`.
+  Previously they were silently omitted because the lockfile parser only read `GEM` sections.
+
 ## [0.3.0] - 2026-05-27
 
 ### Added
@@ -35,7 +55,8 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/danhorst/gemkeeper/compare/0.3.0...0.4.0
 [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/lib/gemkeeper/cli/commands/setup.rb

@@ -4,10 +4,10 @@ module Gemkeeper
   module CLI
     module Commands
       class Setup < Dry::CLI::Command
-        desc "Generate gemkeeper.yml from a Gemfile.lock and org manifest"
+        desc "Generate gemkeeper.yml from a Gemfile.lock or existing gemkeeper.yml"
 
-        argument :lockfile_path, type: :string, required: true,
-                                 desc: "Path to the project's Gemfile.lock"
+        argument :source_path, type: :string, required: true,
+                               desc: "Path to a Gemfile.lock or gemkeeper.yml"
         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)"
@@ -15,27 +15,108 @@ module Gemkeeper
                         desc: "Write to the global service config (for use with brew services)"
         option :force, type: :boolean, default: false,
                        desc: "Overwrite existing gemkeeper.yml entirely"
+        option :skip_bundler_config, type: :boolean, default: false,
+                                     desc: "Skip configuring Bundler mirrors for private gem sources"
 
-        def call(lockfile_path:, **options)
+        def call(source_path:, **options)
           validate_options!(options)
-
           output_path = resolve_output_path(options)
-          manifest = ManifestReader.load(options[:manifest] || ManifestReader::DEFAULT_PATH)
+
+          if lockfile?(source_path)
+            setup_from_lockfile(source_path, output_path, options)
+          else
+            setup_from_config(source_path, output_path, options)
+          end
+        rescue UnresolvableGemError, ManifestConflictError => error
+          warn "Error: #{error.message}"
+          exit 1
+        end
+
+        private
+
+        def lockfile?(path)
+          File.extname(path) == ".lock" || File.basename(path) == "Gemfile.lock"
+        end
+
+        def setup_from_lockfile(lockfile_path, output_path, options)
+          manifest = load_manifest(options)
+          candidates = LockfileParser.internal_sources(lockfile_path)
+
+          unless candidates.empty?
+            GemRepoResolver.new(candidates:, manifest:).resolve!
+            manifest.save(manifest_path(options))
+          end
+
           lockfile_versions = LockfileParser.parse(lockfile_path)
           global_output_path = options[:global] ? output_path : nil
-
           config = ConfigGenerator.new(manifest:, lockfile_versions:)
                                   .build(output_path, force: options[:force], global_output_path:)
 
           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
+          configure_bundler(candidates, config, options) unless options[:skip_bundler_config]
         end
 
-        private
+        def configure_bundler(candidates, config, options)
+          remotes = candidates.filter_map { |c| c[:remote] if c[:source_type] == :private_gem }.uniq
+          return if remotes.empty?
+
+          port = config.fetch("port", Configuration::DEFAULT_PORT)
+          local_url = "http://localhost:#{port}"
+          scope = options[:global] ? "--global" : "--local"
+
+          puts ""
+          remotes.each do |remote|
+            if system("bundle", "config", "set", scope, "mirror.#{remote}", local_url, out: File::NULL)
+              puts "Configured: bundle config set #{scope} mirror.#{remote} #{local_url}"
+            else
+              warn "Warning: failed to configure bundler mirror for #{remote}"
+              warn "  Run manually: bundle config set #{scope} mirror.#{remote} #{local_url}"
+            end
+          end
+        end
+
+        def setup_from_config(source_path, output_path, options)
+          source = YAML.safe_load_file(source_path, permitted_classes: [], symbolize_names: false) || {}
+          manifest = load_manifest(options)
+          update_manifest_from_config(source, manifest, options)
+          install_global_config(source, output_path) if options[:global]
+        end
+
+        def update_manifest_from_config(source, manifest, options)
+          (source["gems"] || []).each do |entry|
+            repo = entry["repo"].to_s
+            next if repo.empty?
+
+            name = File.basename(repo, ".git").sub(/^ruby-/, "")
+            manifest.add_mapping(name:, repo:)
+          end
+          manifest.save(manifest_path(options))
+        end
+
+        def install_global_config(source, output_path)
+          existing = File.exist?(output_path) ? (YAML.safe_load_file(output_path) || {}) : {}
+          merged = existing.merge(source.except("gems")).merge("gems" => merge_gem_lists(existing, source))
+          File.write(output_path, merged.to_yaml)
+          puts "Wrote #{output_path}"
+        end
+
+        def merge_gem_lists(existing, source)
+          existing_gems = existing["gems"] || []
+          source_gems = source["gems"] || []
+          existing_repos = existing_gems.to_set { |g| g["repo"] }
+          merged = existing_gems.dup
+          source_gems.each { |g| merged << g unless existing_repos.include?(g["repo"]) }
+          merged
+        end
+
+        def load_manifest(options)
+          ManifestReader.load(manifest_path(options))
+        end
+
+        def manifest_path(options)
+          options[:manifest] || ManifestReader::DEFAULT_PATH
+        end
 
         def validate_options!(options)
           return unless options[:global] && options[:config]
@@ -54,20 +135,6 @@ module Gemkeeper
           warn "Error: no writable global config path found — install Homebrew or create ~/.config/gemkeeper/"
           exit 1
         end
-
-        def print_bundler_instructions(config, manifest)
-          port = config.fetch("port", Configuration::DEFAULT_PORT)
-          local_url = "http://localhost:#{port}"
-          source_url = manifest.source_url
-          puts ""
-          puts "To point Bundler at your local Geminabox, run:"
-          if source_url
-            puts "  bundle config set --local mirror.#{source_url} #{local_url}"
-          else
-            puts "  bundle config set --local mirror.<your-private-gem-source-url> #{local_url}"
-            puts "  (Replace <your-private-gem-source-url> with the gem source URL from your Gemfile)"
-          end
-        end
       end
     end
 

data/lib/gemkeeper/errors.rb

@@ -6,7 +6,8 @@ module Gemkeeper
   class ConfigurationError < Error; end
   class ConfigFileNotFoundError < ConfigurationError; end
   class InvalidConfigError < ConfigurationError; end
-  class ManifestNotFoundError < ConfigurationError; end
+  class UnresolvableGemError < ConfigurationError; end
+  class ManifestConflictError < ConfigurationError; end
 
   class GitError < Error; end
   class CloneError < GitError; end

data/lib/gemkeeper/gem_repo_resolver.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  # Resolves gem candidates (from lockfile sources) to git repo URLs.
+  # GIT-sourced gems are added automatically; private gem registry entries
+  # are inferred where possible (GitHub Packages) or prompted interactively.
+  class GemRepoResolver
+    def initialize(candidates:, manifest:, input: $stdin, output: $stdout)
+      @candidates = candidates
+      @manifest = manifest
+      @input = input
+      @output = output
+    end
+
+    def resolve!
+      unresolvable = []
+
+      @candidates.each do |candidate|
+        name = candidate[:name]
+        next if @manifest.repo_for(name)
+
+        if candidate[:source_type] == :git
+          @manifest.add_mapping(name:, repo: candidate[:repo])
+        else
+          repo = resolve_private_gem(candidate)
+          if repo
+            @manifest.add_mapping(name:, repo:)
+          else
+            unresolvable << candidate
+          end
+        end
+      end
+
+      raise_unresolvable(unresolvable) if unresolvable.any?
+      @manifest
+    end
+
+    private
+
+    def resolve_private_gem(candidate)
+      inferred = infer_repo(candidate)
+
+      if interactive?
+        prompt(candidate, inferred)
+      elsif inferred
+        warn "Note: auto-inferred repo for #{candidate[:name]}: #{inferred}"
+        inferred
+      end
+    end
+
+    def infer_repo(candidate)
+      remote = candidate[:remote].to_s
+      if (match = remote.match(%r{rubygems\.pkg\.github\.com/([^/]+)}))
+        "git@github.com:#{match[1]}/#{candidate[:name]}.git"
+      end
+    end
+
+    def prompt(candidate, inferred)
+      @output.print "\n  #{candidate[:name]} (from #{candidate[:remote]})"
+      @output.print "\n  Repo URL"
+      @output.print " [#{inferred}]" if inferred
+      @output.print ": "
+      input = @input.gets&.strip
+      input = inferred if input.nil? || input.empty?
+      input
+    end
+
+    def interactive?
+      @input.respond_to?(:isatty) && @input.isatty
+    end
+
+    def raise_unresolvable(candidates)
+      lines = candidates.map { |c| "  - #{c[:name]} (from #{c[:remote]})" }.join("\n")
+      raise UnresolvableGemError,
+            "Cannot resolve repo URLs non-interactively for:\n#{lines}\n\n" \
+            "Run this command in a terminal to map these interactively, " \
+            "or add them to your manifest manually."
+    end
+  end
+end

data/lib/gemkeeper/lockfile_parser.rb

@@ -4,6 +4,7 @@ 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"
+    VERSION_SECTION_TYPES = %w[GEM GIT].freeze
 
     def self.find(start_dir = Dir.pwd)
       dir = File.expand_path(start_dir)
@@ -23,38 +24,94 @@ module Gemkeeper
       new(lockfile_path).gem_versions
     end
 
+    def self.internal_sources(lockfile_path)
+      new(lockfile_path).internal_sources
+    end
+
     def initialize(lockfile_path)
       @lockfile_path = lockfile_path
     end
 
+    # Returns name => version for all GEM and GIT section gems (excludes dependency lines).
     def gem_versions
-      content = File.read(@lockfile_path)
-      extract_gem_section(content)
+      sections = parsed_sections
+      sections.select { |s| VERSION_SECTION_TYPES.include?(s[:type]) }
+              .each_with_object({}) { |section, versions| versions.merge!(versions_from_section(section)) }
+    end
+
+    # Returns an array of hashes describing gems from non-rubygems.org sources.
+    # Each hash has :name, :source_type (:git or :private_gem), and either
+    # :repo (for :git) or :remote (the private gem registry URL, for :private_gem).
+    def internal_sources
+      sections = parsed_sections
+      extract_git_sources(sections) + extract_private_gem_sources(sections)
     end
 
     private
 
-    def extract_gem_section(content)
-      versions = {}
-      in_gem_specs = false
+    def parsed_sections
+      sections = []
+      current = nil
+      File.foreach(@lockfile_path) do |line|
+        if line.match?(/\A[A-Z]/)
+          sections << current if current
+          current = { type: line.strip, lines: [] }
+        elsif current
+          current[:lines] << line
+        end
+      end
+      sections << current if current
+      sections
+    end
 
-      content.each_line do |line|
-        stripped = line.strip
-        if stripped == "GEM"
-          in_gem_specs = true
-          next
+    def versions_from_section(section)
+      in_specs = false
+      section[:lines].each_with_object({}) do |line, versions|
+        if line.strip == "specs:"
+          in_specs = true
+        elsif in_specs && (match = line.chomp.match(/\A    ([a-zA-Z0-9_-]+) \(([^)]+)\)\z/))
+          versions[match[1]] = match[2]
         end
+      end
+    end
+
+    def extract_git_sources(sections)
+      sections.select { |s| s[:type] == "GIT" }.flat_map do |section|
+        remote = section_remote(section)
+        specs_from_section(section).map { |name| { name:, repo: remote, source_type: :git } }
+      end
+    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]/ && stripped != "GEM"
+    def extract_private_gem_sources(sections)
+      sections.select { |s| s[:type] == "GEM" }.flat_map do |section|
+        remote = section_remote(section)
+        next [] if rubygems_org?(remote)
 
-        next unless in_gem_specs
+        specs_from_section(section).map { |name| { name:, remote:, source_type: :private_gem } }
+      end
+    end
 
-        # Spec lines look like: "    gem_name (version)" — exactly 4 spaces, no deeper indent
-        versions[Regexp.last_match(1)] = Regexp.last_match(2) if line.chomp =~ /\A    ([a-zA-Z0-9_-]+) \(([^)]+)\)\z/
+    def section_remote(section)
+      section[:lines].each do |line|
+        stripped = line.strip
+        return stripped.delete_prefix("remote:").strip if stripped.start_with?("remote:")
       end
+      nil
+    end
+
+    def specs_from_section(section)
+      in_specs = false
+      section[:lines].each_with_object([]) do |line, names|
+        if line.strip == "specs:"
+          in_specs = true
+        elsif in_specs && (match = line.match(/\A    ([a-zA-Z0-9_-]+) \(/))
+          names << match[1]
+        end
+      end
+    end
 
-      versions
+    def rubygems_org?(remote)
+      remote.to_s.include?("rubygems.org")
     end
   end
 end

data/lib/gemkeeper/manifest_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "fileutils"
 
 module Gemkeeper
   # Decouples manifest format from sync/setup commands that need the eligible gem list.
@@ -15,9 +16,9 @@ module Gemkeeper
 
     def initialize(path)
       @path = path
-      raise ManifestNotFoundError, manifest_not_found_message unless File.exist?(@path)
-
-      parse_manifest
+      @gems = []
+      @source_url = nil
+      parse_manifest if File.exist?(@path)
     end
 
     def gem_names
@@ -28,6 +29,30 @@ module Gemkeeper
       @gems.find { |gem_entry| gem_entry[:name] == name }
     end
 
+    def repo_for(name)
+      find_by_name(name)&.fetch(:repo)
+    end
+
+    # Adds a name→repo mapping. Idempotent for identical entries.
+    # Raises ManifestConflictError if the name exists with a different repo.
+    def add_mapping(name:, repo:)
+      existing = find_by_name(name)
+      if existing
+        raise ManifestConflictError, conflict_message(name, existing[:repo], repo) if existing[:repo] != repo
+      else
+        @gems << { name:, repo: }
+      end
+      self
+    end
+
+    def save(path = @path)
+      FileUtils.mkdir_p(File.dirname(path))
+      data = {}
+      data["source_url"] = @source_url if @source_url
+      data["gems"] = @gems.map { |g| { "name" => g[:name], "repo" => g[:repo] } }
+      File.write(path, data.to_yaml)
+    end
+
     private
 
     def parse_manifest
@@ -38,9 +63,9 @@ module Gemkeeper
       end
     end
 
-    def manifest_not_found_message
-      "Manifest not found at #{@path}. " \
-        "Install your org's gem manifest, then re-run setup."
+    def conflict_message(name, existing_repo, new_repo)
+      "Manifest conflict for #{name.inspect}: " \
+        "existing repo #{existing_repo.inspect} differs from #{new_repo.inspect}"
     end
   end
 end

data/lib/gemkeeper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gemkeeper
-  VERSION = "0.3.0"
+  VERSION = "0.4.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/gem_repo_resolver"
 require_relative "gemkeeper/config_generator"
 require_relative "gemkeeper/git_repository"
 require_relative "gemkeeper/gem_builder"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gemkeeper
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Dan Brubaker Horst
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-cli
@@ -107,6 +107,7 @@ files:
 - lib/gemkeeper/configuration.rb
 - lib/gemkeeper/errors.rb
 - lib/gemkeeper/gem_builder.rb
+- lib/gemkeeper/gem_repo_resolver.rb
 - lib/gemkeeper/gem_uploader.rb
 - lib/gemkeeper/git_repository.rb
 - lib/gemkeeper/lockfile_parser.rb