reissue 0.4.18 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2d81243492d9418167e8a70f6f9b36525db84fb631751f3a592e0197e30c106
-  data.tar.gz: ef91ae54abde7a9ad9936405f0f2a16d1d1b77896c5abb52613c60b55a7fe1fb
+  metadata.gz: 8c46dadfd4d0a4dcaacebe8bc3520bb390632354008a869dd89d89bd052dc51f
+  data.tar.gz: ef50ffe309580748f40293da43f9d8475def2fae718a1d487e1714c77132bb09
 SHA512:
-  metadata.gz: dd54fb9cbe9012fa1629526e146a913d468bbe7e56cfd39281c23d740f6178e847a03d9add2e71430a56580fa0a28187e30385bbc8f71a6a38c8b703c3866b2d
-  data.tar.gz: d023c5ab1a84d4789b4373c0810c6ee96973c27290a3df6e1357aa808e87ceb78d1b82c7313c095bcca3d9735f30e6ad5828b320d41a938f43db57c38ebe0c5f
+  metadata.gz: 381cd331c021a6ba92eae1fa976dc411922b9f9b1c963eb43ff31fe63e58b6bad6153f2915ed76bd6ca92185ef20233aa4606cf5205a24363dcb2857da204f57
+  data.tar.gz: 37ce464c665abc6521c1defec054ee88dc56e50ee6779473849af00176a0428b9e6f2f4bd259d5deaca0f4d84f986ad4c4029cd60462fbc02df465fefbe72542

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.4.19] - 2026-03-09
+
+### Added
+
+- Support parsing changelog version entries without a date field (e.g. ## [Unreleased]) (75c5d6c)
+- Print ## [Unreleased] without trailing date suffix when version is Unreleased (aed6011)
+- ChangelogUpdater handles Unreleased version strings without crashing (d5f4e3e)
+- ChangelogUpdater#finalize accepts resolved_version parameter to replace Unreleased (d5f4e3e)
+- VersionUpdater#set_version for writing arbitrary version strings like Unreleased (33b3d76)
+- Reissue.deferred_call sets VERSION to Unreleased and adds ## [Unreleased] changelog entry (76e3d61)
+- Reissue.deferred_finalize resolves version from segment, explicit version, or git trailers at release time (1bdf36f)
+- deferred_versioning flag for Reissue::Task to defer version bumping until finalize (aac3ade)
+- Rake reissue task sets VERSION to Unreleased in deferred mode (aac3ade)
+- Rake reissue:finalize task accepts version or segment argument in deferred mode (aac3ade)
+- reissue_deferred_versioning attribute in Hoe plugin (e5a78d4)
+- End-to-end integration tests for the deferred versioning workflow (77a313e)
+
+### Changed
+
+- set_version uses RELEASE_VERSION_MATCH paralleling RELEASE_DATE_MATCH pattern (efec0e5)
+
 ## [0.4.18] - 2026-02-25
 
 ### Added
@@ -17,9 +38,3 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 
 - Pass version_file to Reissue.finalize from rake task (83682ff)
-
-## [0.4.17] - 2026-02-24
-
-### Fixed
-
-- Forward tag_pattern to git fragment handler in call and finalize (dd35249)

data/lib/hoe/reissue.rb

@@ -10,7 +10,7 @@ module Hoe::Reissue
     :reissue_changelog_sections,
     :reissue_commit, :reissue_commit_finalize,
     :reissue_push_finalize, :reissue_push_reissue,
-    :reissue_updated_paths
+    :reissue_updated_paths, :reissue_deferred_versioning
 
   def initialize_reissue
     self.reissue_version_file = "lib/#{name}/version.rb"
@@ -27,6 +27,7 @@ module Hoe::Reissue
     self.reissue_push_finalize = false
     self.reissue_push_reissue = :branch
     self.reissue_updated_paths = []
+    self.reissue_deferred_versioning = false
   end
 
   def define_reissue_tasks
@@ -44,7 +45,8 @@ module Hoe::Reissue
       commit_finalize: reissue_commit_finalize,
       push_finalize: reissue_push_finalize,
       push_reissue: reissue_push_reissue,
-      updated_paths: reissue_updated_paths
+      updated_paths: reissue_updated_paths,
+      deferred_versioning: reissue_deferred_versioning
     }
 
     Reissue::Task.create :reissue do

data/lib/reissue/changelog_updater.rb

@@ -34,12 +34,19 @@ module Reissue
       changelog
     end
 
-    def finalize(date: Date.today, changelog_file: @changelog_file, retain_changelogs: false)
+    def finalize(date: Date.today, changelog_file: @changelog_file, retain_changelogs: false, resolved_version: nil)
       @changelog = Parser.parse(File.read(changelog_file))
 
       # find the highest version number and if it is unreleased, update the date
       version = latest_version
+      version_value = version["version"]
       version_date = version["date"]
+
+      # In deferred mode, resolved_version replaces "Unreleased" version string
+      if resolved_version && version_value == "Unreleased"
+        version["version"] = resolved_version
+      end
+
       if version_date.nil? || version_date == "Unreleased"
         changelog["versions"].find do |v|
           v["version"] == version["version"]
@@ -124,7 +131,9 @@ module Reissue
     private
 
     def latest_version
-      changelog["versions"].max_by { |v| ::Gem::Version.new(v["version"]) }
+      versioned, unversioned = changelog["versions"].partition { |v| v["version"] != "Unreleased" }
+      return unversioned.first if unversioned.any?
+      versioned.max_by { |v| ::Gem::Version.new(v["version"]) }
     end
   end
 end

data/lib/reissue/markdown.rb

@@ -63,9 +63,13 @@ module Reissue
         return unless @version.nil? && @date.nil? && @changes.empty?
         # the first line contains the version and date
         scanner = StringScanner.new(@chunk) << "\n"
-        scanner.scan(/\[?(.[^\]]+)\]? - (.+)$/)
-        @version = scanner[1].to_s.strip
-        @date = scanner[2].to_s.strip || "Unreleased"
+        if scanner.scan(/\[?(.[^\]]+)\]? - (.+)$/)
+          @version = scanner[1].to_s.strip
+          @date = scanner[2].to_s.strip
+        elsif scanner.scan(/\[?([^\]\s]+)\]?\s*$/)
+          @version = scanner[1].to_s.strip
+          @date = nil
+        end
 
         # the rest of the text is the changes
         @changes = scanner.rest.strip.split("### ").reject(&:empty?).map { |change| Change.new(change) }

data/lib/reissue/printer.rb

@@ -24,7 +24,11 @@ module Reissue
         changes = data.fetch("changes") do
           {}
         end
-        version_string = "## [#{version}] - #{date}"
+        version_string = if version == "Unreleased" && date.nil?
+          "## [Unreleased]"
+        else
+          "## [#{version}] - #{date}"
+        end
         changes_string = changes.map do |section, section_changes|
           format_section(section, section_changes)
         end.join("\n\n")

data/lib/reissue/rake.rb

@@ -107,6 +107,11 @@ module Reissue
     # Default: nil (uses default pattern matching "v1.2.3")
     attr_accessor :tag_pattern
 
+    # Whether to defer version bumping until finalize time. Default: false.
+    # When true, the reissue task sets VERSION to "Unreleased" instead of bumping,
+    # and the finalize task resolves the version from git tags + segment argument.
+    attr_accessor :deferred_versioning
+
     # The ordered list of valid changelog sections.
     # Controls both validation (which sections are accepted) and ordering (how they appear).
     # Default: nil (uses Reissue.changelog_sections)
@@ -132,6 +137,7 @@ module Reissue
       @push_reissue = :branch
       @tag_pattern = nil
       @changelog_sections = nil
+      @deferred_versioning = false
     end
 
     attr_reader :formatter, :tasker
@@ -194,16 +200,26 @@ module Reissue
 
       desc description
       task name, [:segment] do |task, args|
-        segment = args[:segment] || "patch"
-        new_version = formatter.call(
-          segment:,
-          version_file:,
-          changelog_file:,
-          version_limit:,
-          version_redo_proc:,
-          fragment: fragment,
-          tag_pattern:
-        )
+        if deferred_versioning
+          new_version = formatter.deferred_call(
+            version_file:,
+            changelog_file:,
+            version_limit:,
+            fragment: fragment,
+            tag_pattern:
+          )
+        else
+          segment = args[:segment] || "patch"
+          new_version = formatter.call(
+            segment:,
+            version_file:,
+            changelog_file:,
+            version_limit:,
+            version_redo_proc:,
+            fragment: fragment,
+            tag_pattern:
+          )
+        end
         bundle
 
         tasker["#{name}:clear_fragments"].invoke
@@ -211,11 +227,20 @@ module Reissue
         run_command("git add -u", "Failed to stage updated files")
         stage_updated_paths
 
-        bump_message = "Bump version to #{new_version}"
+        bump_message = if deferred_versioning
+          "Prepare for next development version"
+        else
+          "Bump version to #{new_version}"
+        end
         if commit
           if reissue_version_with_branch?
             tasker["#{name}:branch"].reenable
-            tasker["#{name}:branch"].invoke("reissue/#{new_version}")
+            branch_name = if deferred_versioning
+              "reissue/next"
+            else
+              "reissue/#{new_version}"
+            end
+            tasker["#{name}:branch"].invoke(branch_name)
           end
           run_command("git commit -m '#{bump_message}'", "Failed to commit version bump")
           tasker["#{name}:push"].invoke if push_reissue?
@@ -240,20 +265,45 @@ module Reissue
       end
 
       desc "Finalize the changelog for an unreleased version to set the release date."
-      task "#{name}:finalize", [:date] do |task, args|
-        date = args[:date] || Time.now.strftime("%Y-%m-%d")
-        version, date = formatter.finalize(
-          date,
-          changelog_file:,
-          retain_changelogs:,
-          fragment: fragment,
-          tag_pattern:,
-          version_file:
-        )
+      task "#{name}:finalize", [:version_or_segment, :date] do |task, args|
+        if deferred_versioning
+          version_or_segment = args[:version_or_segment]
+          date = args[:date] || Time.now.strftime("%Y-%m-%d")
+
+          version_arg = nil
+          segment_arg = nil
+          if version_or_segment&.match?(/^\d/)
+            version_arg = version_or_segment
+          elsif version_or_segment
+            segment_arg = version_or_segment
+          end
+
+          version, date = formatter.deferred_finalize(
+            date,
+            version: version_arg,
+            segment: segment_arg,
+            changelog_file:,
+            retain_changelogs:,
+            fragment: fragment,
+            tag_pattern:,
+            version_file:,
+            version_redo_proc:
+          )
+        else
+          date = args[:version_or_segment] || Time.now.strftime("%Y-%m-%d")
+          version, date = formatter.finalize(
+            date,
+            changelog_file:,
+            retain_changelogs:,
+            fragment: fragment,
+            tag_pattern:,
+            version_file:
+          )
+        end
+
         finalize_message = "Finalize the changelog for version #{version} on #{date}"
         if commit_finalize
           if finalize_with_branch?
-            # Use "finalize/" prefix for the version being released
             tasker["#{name}:branch"].invoke("finalize/#{version}")
           end
           run_command("git add -u", "Failed to stage finalized changelog")
@@ -361,6 +411,7 @@ module Reissue
 
       desc "Bump version based on git trailers"
       task "#{name}:bump" do
+        next if deferred_versioning
         # Only check for version trailers when using git fragments
         next unless fragment == :git
 

data/lib/reissue/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Reissue
-  VERSION = "0.4.18"
-  RELEASE_DATE = "2026-02-25"
+  VERSION = "0.4.19"
+  RELEASE_DATE = "2026-03-09"
 end

data/lib/reissue/version_updater.rb

@@ -77,6 +77,15 @@ module Reissue
       @new_version
     end
 
+    def set_version(version_string, version_file: @version_file)
+      body = File.read(@version_file)
+      updated = body.gsub(release_version_regex) do |match|
+        match.sub(/=\s*"[^"]*"/, "= \"#{version_string}\"")
+      end
+      File.write(version_file, updated)
+      version_string
+    end
+
     # A proc that can be used to redo the version string.
     attr_accessor :version_redo_proc
 
@@ -108,8 +117,10 @@ module Reissue
     VERSION_MATCH = /(?<major>\d+)\.(?<minor>[a-zA-Z\d]+)\.(?<patch>[a-zA-Z\d]+)(?<add>\.(?<pre>[a-zA-Z\d]+))?/
     def version_regex = VERSION_MATCH
 
+    RELEASE_VERSION_MATCH = /VERSION\s*=\s*"([^"]*)"/
     RELEASE_DATE_MATCH = /RELEASE_DATE\s*=\s*"([^"]*)"/
 
+    def release_version_regex = RELEASE_VERSION_MATCH
     def release_date_regex = RELEASE_DATE_MATCH
 
     def update_release_date(date, version_file: @version_file)

data/lib/reissue.rb

@@ -58,6 +58,101 @@ module Reissue
     new_version
   end
 
+  def self.deferred_call(version_file:, changelog_file: "CHANGELOG.md", version_limit: 2, retain_changelogs: false, fragment: nil, tag_pattern: nil)
+    version_updater = VersionUpdater.new(version_file)
+    version_updater.set_version("Unreleased", version_file:)
+    version_updater.update_release_date("Unreleased", version_file:)
+
+    if changelog_file
+      changelog_updater = ChangelogUpdater.new(changelog_file)
+      changelog_updater.call("Unreleased", date: nil, changes: {}, changelog_file:, version_limit:, retain_changelogs:, fragment:, tag_pattern:)
+    end
+
+    "Unreleased"
+  end
+
+  def self.deferred_finalize(date = Date.today, version: nil, segment: nil, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, tag_pattern: nil, version_file: nil, version_redo_proc: nil)
+    resolved_version = if version&.match?(/^\d/)
+      version
+    elsif segment || version
+      seg = segment || version
+      resolved = resolve_version_from_tag(seg.to_s, tag_pattern: tag_pattern, version_redo_proc: version_redo_proc)
+      unless resolved
+        raise "Cannot determine next version. No git tags found and no explicit version provided. " \
+              "Usage: rake reissue:finalize[patch] or rake reissue:finalize[1.2.0]"
+      end
+      resolved
+    elsif fragment == :git
+      handler = FragmentHandler.for(:git, tag_pattern: tag_pattern)
+      bump = handler.read_version_bump
+      if bump
+        resolved = resolve_version_from_tag(bump.to_s, tag_pattern: tag_pattern, version_redo_proc: version_redo_proc)
+        unless resolved
+          raise "Cannot determine next version. No git tags found and no explicit version provided. " \
+                "Usage: rake reissue:finalize[patch] or rake reissue:finalize[1.2.0]"
+        end
+        resolved
+      else
+        raise "Cannot determine next version. No git tags found and no version argument provided. " \
+              "Usage: rake reissue:finalize[patch] or rake reissue:finalize[1.2.0]"
+      end
+    else
+      raise "Cannot determine next version. No version argument provided. " \
+            "Usage: rake reissue:finalize[patch] or rake reissue:finalize[1.2.0]"
+    end
+
+    if version_file
+      version_updater = VersionUpdater.new(version_file)
+      version_updater.set_version(resolved_version, version_file: version_file)
+      version_updater.update_release_date(date.to_s, version_file: version_file)
+    end
+
+    changelog_updater = ChangelogUpdater.new(changelog_file)
+
+    if fragment
+      changelog = Parser.parse(File.read(changelog_file))
+      unreleased = changelog["versions"].find { |v| v["version"] == "Unreleased" }
+
+      if unreleased
+        changelog["versions"].delete(unreleased)
+        changelog_updater.instance_variable_set(:@changelog, changelog)
+        changelog_updater.write(changelog_file, retain_changelogs: false)
+
+        handler = FragmentHandler.for(fragment, tag_pattern: tag_pattern)
+        fragment_changes = handler.read
+
+        merged_changes = (unreleased["changes"] || {}).dup
+        fragment_changes.each do |section, entries|
+          merged_changes[section] ||= []
+          entries.each do |entry|
+            merged_changes[section] << entry unless merged_changes[section].include?(entry)
+          end
+        end
+
+        changelog_updater.update(
+          "Unreleased",
+          date: nil,
+          changes: merged_changes,
+          fragment: nil,
+          version_limit: changelog["versions"].size + 1
+        )
+        changelog_updater.write(changelog_file, retain_changelogs: false)
+      end
+    end
+
+    changelog = changelog_updater.finalize(date: date, changelog_file: changelog_file, retain_changelogs: retain_changelogs, resolved_version: resolved_version)
+    changelog["versions"].first.slice("version", "date").values
+  end
+
+  private_class_method def self.resolve_version_from_tag(segment, tag_pattern: nil, version_redo_proc: nil)
+    handler = FragmentHandler.for(:git, tag_pattern: tag_pattern)
+    last_version = handler.last_tag_version
+    return nil unless last_version
+
+    updater = VersionUpdater.new(File::NULL, version_redo_proc: version_redo_proc)
+    updater.redo(last_version, segment).to_s
+  end
+
   # Finalizes the changelog for an unreleased version to set the release date.
   #
   # @param date [String] The release date.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reissue
 version: !ruby/object:Gem::Version
-  version: 0.4.18
+  version: 0.4.19
 platform: ruby
 authors:
 - Jim Gay