gem_kit-release 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c85c52c48c2f4ef893784a7e3f5cd6f1dd35fbf6e74e46de4eef4bc7c205821
-  data.tar.gz: 994048430d10430d4d3f47ca3a57a214200459a75205685adc921cc63e6d58cf
+  metadata.gz: d9d6b16c56ad134e56b75cb00642a0a5f01ba96c6d7b620854736b871444b5aa
+  data.tar.gz: c3b718404bb08947a3df23e822a3edb5dc9ae7470da3605272b9d3e6f87b1dda
 SHA512:
-  metadata.gz: 58349a775e00a64b0e023f6cd53016527bcc3ed440c9143ef53321da8dd03a8e5b2009ad90cf8d8d84827e7158f639943a544cf15446095c59b0407bc00dabe6
-  data.tar.gz: 5014510b87f87df7047b62f288182586fae3278133fd92d1f50a24f93b6294ed986e92a67c3fb3da15c9bb86c47b8d1ef6231b886edcd4d422df7885aba7cdc6
+  metadata.gz: ff045009cdcf213639c10607dfc0bffbc3e03f49e00ae2c34d2e2e50f26b13ffdcd2910d2a00f0b1311ea73ddfcf7318fc75196ff3b5a0960be9be63d3484bf9
+  data.tar.gz: 4a16c794925df5faaa54e1a0fe3b2429ba3ceddc578e3da8b45fadbbdead1b947eb29c308d50ae27db1a5e0ef9fb7a7e281dbde3762ef8d923df649bf92636a3

data/lib/gem_kit/release/cli.rb

@@ -38,6 +38,23 @@ module GemKit
     # Each command here is a thin front for a plain object under CLI::; the
     # work itself is in Gate, VersionFile, Changelog and Deprecate.
     class CLI < Thor
+      # The order the commands go in — printed above the command listing so
+      # nobody has to guess when to commit or when to write the changelog. The
+      # question the process is easy to get wrong on is exactly the one this
+      # answers: the changelog is written *after* the bump, then the two are
+      # committed together, and only then does release run.
+      WORKFLOW = <<~TXT
+        Release, in order:
+
+          1. bin/test                        # green suite
+          2. gem kit bump [SEGMENT]          # move the version, relock the Gemfile
+          3. gem kit changelog --write       # AI CLI drafts this version's entry
+          4. gem kit changelog [VERSION]     # lint the entry, confirm ready to release
+          5. git commit -am "Release ..."    # bump + lockfile + entry, one commit
+          6. gem kit release                 # gate, build, push, tag (also pushes the tag)
+          7. git push                        # publish the release commit
+      TXT
+
       class_option :gem, type: :string,
                          desc: "Which gem, in a repository holding more than one gemspec"
 
@@ -49,6 +66,15 @@ module GemKit
         "gem kit #{command.usage}"
       end
 
+      # Prepend the workflow to the top-level `gem kit` help. `gem kit help
+      # <command>` sets subcommand=true and lands here too; that page already
+      # has its own long_desc, so leave it alone.
+      def self.help(shell, subcommand = false)
+        shell.say(WORKFLOW) unless subcommand
+        shell.say unless subcommand
+        super
+      end
+
       # Short forms for the three typed most often.
       map "log"  => :changelog,
           "deps" => :deprecations,
@@ -210,6 +236,33 @@ describe "gem_kit/release/cli" do
     end
   end
 
+  # The order between `bump` and `release` — when to write the changelog and
+  # when to commit — is exactly the question the numbered list answers, so
+  # the top-level help has to print it.
+  it "prints the numbered workflow above the command listing" do
+    with_gem do |dir|
+      _status, out, _err = invoke([], dir)
+
+      out.should.match(/Release, in order:/)
+      out.should.match(/1\. bin\/test/)
+      out.should.match(/2\. gem kit bump/)
+      out.should.match(/5\. git commit/)
+      out.should.match(/6\. gem kit release/)
+      out.should.match(/7\. git push/)
+      # The workflow lands above "Commands:", not swallowed by it.
+      out.index("Release, in order:").should < out.index("Commands:")
+    end
+  end
+
+  # `gem kit help <command>` already has its own long_desc; the workflow
+  # belongs on the top-level page only.
+  it "does not repeat the workflow on a per-command help page" do
+    with_gem do |dir|
+      _status, out, _err = invoke(["help", "bump"], dir)
+      out.should.not.match(/Release, in order:/)
+    end
+  end
+
   it "names the commands `gem kit <command>`, not the running program" do
     with_gem do |dir|
       _status, out, _err = invoke([], dir)

data/lib/gem_kit/release/commands/bump.rb

@@ -35,6 +35,8 @@ module GemKit
           version_file.write(target)
           say("#{current} -> #{target}")
 
+          relock(target)
+
           upcoming = gate.upcoming_deprecations(target)
           unless upcoming.empty?
             say("#{upcoming.size} deprecation(s) still outstanding (none due in #{target}).")
@@ -45,6 +47,35 @@ module GemKit
           say
           say("#{RED}now run: gem kit changelog --write#{RESET}")
         end
+
+        private
+
+          # A Gemfile that says `gemspec` or `path: "."` records this gem's own
+          # version in Gemfile.lock, so a bump that only rewrites the version
+          # file leaves the two disagreeing — and bundler refuses outright
+          # under frozen mode, which is what bundlerEnv sets. Relock, so the
+          # bump is one coherent change rather than a trap for the next
+          # command anyone runs.
+          #
+          # `bundle lock` rather than `bundle install`: nothing needs
+          # installing, only the lockfile needs to agree.
+          def relock(target)
+            return unless project.self_locked?
+
+            say("Relocking #{File.basename(project.lockfile_path)}…")
+
+            ok = Dir.chdir(project.root) do
+              # BUNDLE_FROZEN is exactly what stops this, and inheriting it
+              # from an ambient devshell would defeat the point.
+              system({"BUNDLE_FROZEN" => "false", "BUNDLE_GEMFILE" => nil},
+                     "bundle", "lock", out: File::NULL, err: File::NULL)
+            end
+
+            return if ok
+
+            say("#{RED}could not relock — run `bundle lock` before committing " \
+                "#{target}#{RESET}")
+          end
       end
     end
   end
@@ -95,6 +126,44 @@ describe "gem_kit/release/commands/bump" do
     end
   end
 
+  # The version lives in two files when a gem is in its own bundle, and a bump
+  # that moves one of them leaves bundler refusing to do anything.
+  it "relocks a lockfile that records this gem's own version" do
+    with_gem do |dir|
+      File.write(File.join(dir, "Gemfile"), %(source "https://rubygems.org"\ngemspec\n))
+      File.write(File.join(dir, "Gemfile.lock"), <<~LOCK)
+        PATH
+          remote: .
+          specs:
+            demo (1.2.3)
+
+        GEM
+          remote: https://rubygems.org/
+
+        PLATFORMS
+          ruby
+
+        DEPENDENCIES
+          demo!
+
+        BUNDLED WITH
+           2.7.2
+      LOCK
+
+      _status, out, _err = invoke(["bump", "minor"], dir)
+
+      out.should.match(/Relocking Gemfile\.lock/)
+      File.read(File.join(dir, "Gemfile.lock")).should.match(/demo \(1\.3\.0\)/)
+    end
+  end
+
+  it "says nothing about a lockfile that does not record this gem" do
+    with_gem do |dir|
+      _status, out, _err = invoke(["bump", "minor"], dir)
+      out.should.not.match(/Relocking/)
+    end
+  end
+
   it "mentions deprecations outstanding but not yet due" do
     with_gem do |dir|
       _status, out, _err = invoke(["bump", "minor"], dir, deprecations: [["Old", "New", "9.0"]])

data/lib/gem_kit/release/gate.rb

@@ -98,6 +98,9 @@ __END__
 
 describe "gem_kit/release/gate" do
   require "tmpdir"
+  # These specs ask the gate whether a temp directory is a repository, so the
+  # walk up out of Dir.tmpdir has to be stopped or the answer is the machine's.
+  require_relative "../../../spec/support/git_isolation"
 
   # A Project stub: the Gate only asks it for a changelog path and a version,
   # and to load the library (a no-op here — the specs drive the registry).

data/lib/gem_kit/release/project.rb

@@ -105,6 +105,21 @@ module GemKit
         multi_gem? ? "CHANGELOG-#{name}.md" : "CHANGELOG.md"
       end
 
+      def lockfile_path
+        File.join(root, "Gemfile.lock")
+      end
+
+      # A Gemfile that says `gemspec` or `path: "."` puts this gem in its own
+      # bundle, and the lockfile then records this gem's version. Bumping
+      # without relocking leaves the two disagreeing — which bundler reports as
+      # "the gemspecs for path gems changed", and refuses outright under
+      # frozen mode, as bundlerEnv sets.
+      def self_locked?
+        return false unless File.exist?(lockfile_path)
+
+        File.read(lockfile_path).match?(/^\s{4}#{Regexp.escape(name)} \(\d/)
+      end
+
       # `v1.2.3` says which version but not which gem, which is fine until a
       # repository holds two of them at the same version.
       def tag_prefix
@@ -114,7 +129,10 @@ module GemKit
       # lib/gem_kit/release/version.rb for "gem_kit-release", lib/brute/version.rb
       # for "brute" — the convention every `bundle gem` project follows.
       def version_file
-        File.expand_path(config.version_file || File.join("lib", *name.split("-"), "version.rb"), root)
+        File.expand_path(
+          config.version_file || File.join("lib", *library_segments, "version.rb"),
+          root,
+        )
       end
 
       # An ERB template beside the version file, if the project generates it.
@@ -126,7 +144,36 @@ module GemKit
       # What to require so that deprecation declarations register themselves.
       # "gem_kit-release" -> "gem_kit/release".
       def require_path
-        config.require_path || name.tr("-", "/")
+        config.require_path || library_segments.join("/")
+      end
+
+      # Where the library sits under lib/, as path segments.
+      #
+      # `bundle gem gem_kit-release` NESTS, treating the hyphen as a directory
+      # separator: lib/gem_kit/release.rb, module GemKit::Release. That is the
+      # common case and the one assumed here first.
+      #
+      # But a hyphenated name whose library is a SINGLE module does not nest.
+      # `ag-ui` is lib/ag_ui.rb holding `module AgUi` — hyphen as underscore —
+      # and the nested form names lib/ag/ui.rb, a file that was never there.
+      # Both layouts are conventional and the name alone cannot tell them
+      # apart, so ask the tree: whichever exists is what this project is.
+      #
+      # When neither exists the nested form wins, because that is what
+      # `bundle gem` would have produced and a project with no library yet is
+      # about to become one.
+      def library_segments
+        nested = name.split("-")
+        if exists_under_lib?(nested)
+          nested
+        else
+          flat = [name.tr("-", "_")]
+          if exists_under_lib?(flat)
+            flat
+          else
+            nested
+          end
+        end
       end
 
       # Load the library, so Deprecate's registry reflects this project.
@@ -143,6 +190,15 @@ module GemKit
       def test_command = config.test_command || "bin/test"
 
       def changelog_writer = config.changelog_writer || "claude"
+
+      private
+
+        # A layout is present if the entry file is there, or the directory it
+        # would hold — a gem is free to ship lib/foo/ without lib/foo.rb.
+        def exists_under_lib?(segments)
+          base = File.join(root, "lib", *segments)
+          File.exist?("#{base}.rb") || File.directory?(base)
+        end
     end
   end
 end
@@ -152,10 +208,16 @@ __END__
 describe "gem_kit/release/project" do
   require "tmpdir"
 
-  # A throwaway gem laid out the conventional way.
-  with_project = lambda do |name: "demo", version: "1.2.3", &block|
+  # A throwaway gem. `layout:` picks between the two conventions a hyphenated
+  # name can follow: :nested is `bundle gem`'s lib/gem_kit/release, :flat is a
+  # single-module gem's lib/ag_ui.
+  with_project = lambda do |name: "demo", version: "1.2.3", layout: :nested, &block|
     Dir.mktmpdir do |dir|
-      path = name.split("-")
+      if layout == :flat
+        path = [name.tr("-", "_")]
+      else
+        path = name.split("-")
+      end
       FileUtils.mkdir_p(File.join(dir, "lib", *path))
       File.write(File.join(dir, "lib", *path, "version.rb"), <<~RUBY)
         module #{path.map { |p| p.split("_").map(&:capitalize).join }.join("::")}
@@ -203,6 +265,48 @@ describe "gem_kit/release/project" do
     end
   end
 
+  # A hyphenated name whose library is one module: lib/ag_ui.rb, not
+  # lib/ag/ui.rb. Deriving the path from the name alone named a file that was
+  # never there, so `gem kit bump` could not find the version and deprecations
+  # went undetected.
+  it "reads an underscored single-module layout off the tree" do
+    with_project.call(name: "ag-ui", layout: :flat) do |dir|
+      project = GemKit::Release::Project.detect(dir)
+      project.require_path.should == "ag_ui"
+      project.version_file.should == File.join(dir, "lib/ag_ui/version.rb")
+    end
+  end
+
+  # Nesting stays the default: it is what `bundle gem` produces, so it is what
+  # a project with no library yet is about to become.
+  it "falls back to the nested layout when neither is on disk" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "ag-ui.gemspec"), <<~RUBY)
+        Gem::Specification.new do |spec|
+          spec.name = "ag-ui"
+          spec.version = "0.1.0"
+          spec.authors = ["x"]
+          spec.summary = "x"
+          spec.files = []
+        end
+      RUBY
+      GemKit::Release::Project.detect(dir).require_path.should == "ag/ui"
+    end
+  end
+
+  # An explicit setting still wins over anything read off the tree.
+  it "prefers a configured require path and version file" do
+    with_project.call(name: "ag-ui", layout: :flat) do |dir|
+      config = GemKit::Release::Project::Config.new(
+        require_path: "somewhere/else",
+        version_file: "lib/custom.rb",
+      )
+      project = GemKit::Release::Project.detect(dir, config: config)
+      project.require_path.should == "somewhere/else"
+      project.version_file.should == File.join(dir, "lib/custom.rb")
+    end
+  end
+
   it "defaults the changelog to CHANGELOG.md in the project root" do
     with_project.call do |dir|
       project = GemKit::Release::Project.detect(dir)
@@ -252,6 +356,38 @@ describe "gem_kit/release/project" do
     end
   end
 
+  # A gem whose own Gemfile pulls it in has its version written in the lockfile
+  # as well as the version file, and both have to move together.
+  it "knows whether the lockfile records this gem's own version" do
+    with_project.call do |dir|
+      GemKit::Release::Project.detect(dir).self_locked?.should.be.false
+
+      File.write(File.join(dir, "Gemfile.lock"), <<~LOCK)
+        PATH
+          remote: .
+          specs:
+            demo (1.2.3)
+
+        GEM
+          remote: https://rubygems.org/
+      LOCK
+      GemKit::Release::Project.detect(dir).self_locked?.should.be.true
+    end
+  end
+
+  it "does not mistake another gem's line in the lockfile for its own" do
+    with_project.call do |dir|
+      File.write(File.join(dir, "Gemfile.lock"), <<~LOCK)
+        GEM
+          remote: https://rubygems.org/
+          specs:
+            other-demo (1.0.0)
+            demo-helper (2.0.0)
+      LOCK
+      GemKit::Release::Project.detect(dir).self_locked?.should.be.false
+    end
+  end
+
   it "finds an ERB version template when the project generates its version file" do
     with_project.call do |dir|
       GemKit::Release::Project.detect(dir).version_template.should.be.nil

data/lib/gem_kit/release/version.rb

@@ -2,6 +2,6 @@
 
 module GemKit
   module Release
-    VERSION = "0.3.0"
+    VERSION = "0.3.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gem_kit-release
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Nathan Kidd