reissue 0.4.17 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5665bd9b120f74096ef018dcb84b1976a3778158601b037f73f5c5b2529e0a5
-  data.tar.gz: 1bd41e2eb052e9e64f04b2142b990b9c90f4812f7419db4aba0b88f89ab19c50
+  metadata.gz: 8c46dadfd4d0a4dcaacebe8bc3520bb390632354008a869dd89d89bd052dc51f
+  data.tar.gz: ef50ffe309580748f40293da43f9d8475def2fae718a1d487e1714c77132bb09
 SHA512:
-  metadata.gz: d016635c53c1b5df5bf12fb89b7015e001a0d47338a806f3a4826fa7dd728cf49df6e6b92008a7ec8d48b1d3a2690c37cf2220893882560f7e4d36c164bd6691
-  data.tar.gz: 230f4b4f1d62978286290fd58865242fb630a0b6efc198f4e3061d84c922dffc96c7319043b4af3cbb8522e38bb75a8aec428c8394761833951b252cfd9636ef
+  metadata.gz: 381cd331c021a6ba92eae1fa976dc411922b9f9b1c963eb43ff31fe63e58b6bad6153f2915ed76bd6ca92185ef20233aa4606cf5205a24363dcb2857da204f57
+  data.tar.gz: 37ce464c665abc6521c1defec054ee88dc56e50ee6779473849af00176a0428b9e6f2f4bd259d5deaca0f4d84f986ad4c4029cd60462fbc02df465fefbe72542

data/CHANGELOG.md

@@ -5,14 +5,36 @@ 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.17] - 2026-02-24
+## [0.4.19] - 2026-03-09
 
-### Fixed
+### Added
 
-- Forward tag_pattern to git fragment handler in call and finalize (dd35249)
+- 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)
 
-## [0.4.16] - 2026-02-24
+### Changed
 
-### Fixed
+- set_version uses RELEASE_VERSION_MATCH paralleling RELEASE_DATE_MATCH pattern (efec0e5)
 
-- Run bundle install after reissue:bump changes the version (104bfd8)
+## [0.4.18] - 2026-02-25
+
+### Added
+
+- RELEASE_DATE constant tracking in VersionUpdater (496ec6b)
+- Reset RELEASE_DATE to Unreleased when bumping version via Reissue.call (a7894cc)
+- Update RELEASE_DATE to actual date during Reissue.finalize (8253796)
+- RELEASE_DATE to the version.rb (6e08782)
+
+### Changed
+
+- Pass version_file to Reissue.finalize from rake task (83682ff)

data/README.md

@@ -170,6 +170,28 @@ Reissue::Task.create :reissue do |task|
 end
 ```
 
+## Tracking Release Dates
+
+Reissue can automatically manage a `RELEASE_DATE` constant in your version file alongside `VERSION`. This is completely optional — if no `RELEASE_DATE` is present, nothing changes.
+
+### Opting In
+
+Add a `RELEASE_DATE` constant to your version file:
+
+```ruby
+module MyGem
+  VERSION = "0.1.0"
+  RELEASE_DATE = "Unreleased"
+end
+```
+
+### What Happens Automatically
+
+- **On finalize** (`rake build` / `rake reissue:finalize`): `RELEASE_DATE` is set to the actual release date (e.g., `"2024-06-15"`)
+- **On bump** (`rake reissue` / post-release): `RELEASE_DATE` is reset to `"Unreleased"`
+
+No configuration is needed — Reissue detects the constant and updates it automatically.
+
 ## Using Git Trailers for Changelog Entries
 
 Reissue can extract changelog entries directly from git commit messages using trailers. This keeps your changelog data close to the code changes.

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,19 +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:
-        )
+      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")
@@ -360,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,5 +1,6 @@
 # frozen_string_literal: true
 
 module Reissue
-  VERSION = "0.4.17"
+  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,6 +117,21 @@ 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)
+      body = File.read(@version_file)
+      return unless body.match?(release_date_regex)
+      updated = body.gsub(release_date_regex) do |match|
+        match.sub(/=\s*"[^"]*"/, "= \"#{date}\"")
+      end
+      File.write(version_file, updated)
+    end
+
     # Writes the updated version to the specified file.
     #
     # @param version_file [String] The version_file to the version file (optional, defaults to @version_file).

data/lib/reissue.rb

@@ -50,6 +50,7 @@ module Reissue
 
     version_updater = VersionUpdater.new(version_file, version_redo_proc:)
     new_version = version_updater.call(segment, version_file:)
+    version_updater.update_release_date("Unreleased", version_file:)
     if changelog_file
       changelog_updater = ChangelogUpdater.new(changelog_file)
       changelog_updater.call(new_version, date:, changes:, changelog_file:, version_limit:, retain_changelogs:, fragment:, tag_pattern:)
@@ -57,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.
@@ -65,7 +161,7 @@ module Reissue
   # @param fragment_directory [String] @deprecated Use fragment parameter instead
   #
   # @return [Array] The version number and release date.
-  def self.finalize(date = Date.today, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, fragment_directory: nil, tag_pattern: nil)
+  def self.finalize(date = Date.today, changelog_file: "CHANGELOG.md", retain_changelogs: false, fragment: nil, fragment_directory: nil, tag_pattern: nil, version_file: nil)
     # Handle deprecation
     if fragment_directory && !fragment
       warn "[DEPRECATION] `fragment_directory` parameter is deprecated. Please use `fragment` instead."
@@ -119,6 +215,11 @@ module Reissue
     # Now finalize with the date
     changelog = changelog_updater.finalize(date:, changelog_file:, retain_changelogs:)
 
+    if version_file
+      version_updater = VersionUpdater.new(version_file)
+      version_updater.update_release_date(date.to_s, version_file:)
+    end
+
     changelog["versions"].first.slice("version", "date").values
   end
 

metadata

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