toys-release 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573b7d3f7188a3f500acad829f4a1ff7b638659a7ab599d2aee0ec5f2658eec7
-  data.tar.gz: a704f1f772e03130705f2ce6d508936fbd1158a1b8d18c30f6f9e2ce2091d403
+  metadata.gz: 4b45ad6653e6cf95dc462d60917fec18dc4cab282eb44fa6ea28952aa982bf5d
+  data.tar.gz: 8d00cbe1a53a9c6f31b982919660e04d1d10559e579293fe32f0ecd963d7e696
 SHA512:
-  metadata.gz: ed1092a3679da88cc40525e692100388578f9433c38e21863dcbcbb2ecacffc7cc7b24ff7fbb7531d4a49ba115399d66c2a517c8e9de14b26e9fa759414e2256
-  data.tar.gz: e0c3aa955c45e64676e1f516f885b8f8bc4adb4ca147109b98ee805908c17593813bc51df3dc9bce844740fce1d76b2070b27e17bba8b0e64f0ef9d70dec35e3
+  metadata.gz: '0583c614ebdba3ac5cf9e0988dbab656cfd49e437e5543ec3dafab95fc0cd1506cbfb42c85f72627da3895561957e40b6f07d1f22c1cd28eb3944971f3f064b0'
+  data.tar.gz: 0e53dbb9821ea6b5e9df0f33814fc18d0da48ba6a0330b5e941e7c9b0b5cf93c8778527b5bd9b90ea32ea36183f2f594c852f37b76a6a5d436c070b8217fca13

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release History
 
+### v0.9.0 / 2026-03-23
+
+* ADDED: Provided a `version_from_code` setting that allows the current VERSION constant to determine the release version
+* FIXED: The gen-gh-pages and gen-workflows tools no longer ask for confirmation if a file to generate is unchanged
+* FIXED: Release versions can now omit version fields beyond major, e.g. version "1" is now legal
+* FIXED: Minor UI improvements for the gen-gh-pages tool
+* DOCS: Minor fixes to the toys-release guide
+
 ### v0.8.2 / 2026-03-18
 
 * FIXED: Tighten version constant regex

data/docs/guide.md

@@ -70,14 +70,14 @@ If you do not have Ruby or Toys installed locally, do so first. Install
 Ruby 2.7 or later, and then install the Toys RubyGem using:
 
 ```sh
-gem install toys
+$ gem install toys
 ```
 
 Toys-Release requires Toys 0.20 or later. If you have an older version of Toys,
 update it using:
 
 ```sh
-toys system update
+$ toys system update
 ```
 
 Finally, you also need the GitHub command line tool, `gh`. Find installation
@@ -85,28 +85,37 @@ instructions at https://cli.github.com/. If you are running on MacOS, for
 example, the easiest way to install it is via homebrew:
 
 ```sh
-brew install gh
+$ brew install gh
 ```
 
 ### Install the release tool
 
-The Toys-Release tool needs to be installed in your repository, as a Toys tool
-loaded from the [toys-release](https://rubygems.org/gems/toys-release) gem.
+The Toys-Release tool needs to be installed in your repository. This means
+creating a Toys tool whose implementation is provided by the
+[toys-release](https://rubygems.org/gems/toys-release) gem.
 
 Create `.toys/release.rb` (note the leading period in the directory name) in
 your git repository. Use the following content:
 
 ```ruby
+# frozen_string_literal: true
 load_gem "toys-release"
 ```
 
-This will cause Toys-Release to use the latest version of Toys-Release. You can
-also pin to a specific version of Toys-Release by specifying version
-requirements similar to how those requirements are specified in RubyGems or
-Bundler:
+Test the install by displaying the online help for toys-release:
+
+```sh
+$ toys release --help
+```
+
+If you do not already have the toys-release gem installed, this will install it
+for you (after asking for permission.) By default, it will install the latest
+version, but you can pin to a specific version of the gem by specifying version
+requirements similar to how you would in RubyGems or Bundler:
 
 ```ruby
-load_gem "toys-release", "~> 0.3"
+# frozen_string_literal: true
+load_gem "toys-release", "~> 0.8"
 ```
 
 Commit and push this change to your repository.
@@ -124,7 +133,7 @@ release tool is installed as described above, you can run this from your local
 repository clone directory:
 
 ```sh
-toys release gen-config
+$ toys release gen-config
 ```
 
 This will analyze your repository and generate an initial configuration file
@@ -146,13 +155,13 @@ line using the release tool.
 To create the GitHub repo labels, run this from your local repo clone directory:
 
 ```sh
-toys release create-labels
+$ toys release create-labels
 ```
 
 Then, to generate the GitHub Actions workflows, run:
 
 ```sh
-toys release gen-workflows
+$ toys release gen-workflows
 ```
 
 This will generate files in a `.github/workflows` directory in your repository.
@@ -287,15 +296,15 @@ appending the version to the component name, separated by a colon.
 For example, to request releases of the `toys` and `toys-release` components,
 you can enter the following text into "Components to release":
 
-```sh
+```
 toys toys-release
 ```
 
-To make the above request but specifically request version 0.3.0 of the
+To make the above request but specifically request version 1.0.0 of the
 `toys-release` component:
 
-```sh
-toys toys-release:0.3.0
+```
+toys toys-release:1.0.0
 ```
 
 ### Managing release pull requests
@@ -444,7 +453,7 @@ To set up documentation, do the following:
  *  Create a starting gh-pages branch by running:
 
     ```sh
-    toys release gen-gh-pages
+    $ toys release gen-gh-pages
     ```
 
     This will generate the gh-pages branch and push some key files to it,
@@ -536,6 +545,49 @@ and affect the behavior of that and other commits.
     no-touch-component: my_gem
     ```
 
+### Using code-specified versions
+
+By default, Toys-Release determines the version to release by analyzing the
+conventional commit history since the last release. For each component, it
+selects the semver bump implied by the commits and applies it to the last
+released version.
+
+As an alternative, you can configure a component to use the version specified
+directly in the code — specifically, the `VERSION` constant in the `version.rb`
+file (as identified by the **version_rb_path** setting) — as the target release
+version. This is useful when you prefer to control the version number manually
+or when your workflow requires the version to be set in the code before a
+release is requested.
+
+To enable this, set `version_from_code: true` in the component's configuration:
+
+```yaml
+components:
+  - name: my_gem
+    version_from_code: true
+```
+
+With this setting, when a release is requested, Toys-Release reads the version
+constant from the code at the tip of the release branch. If this version is
+newer than the last released version, it is used as the release version.
+
+If the code version is not newer than the last released version (for example,
+if you forgot to update it before requesting the release), the release request
+will fail with an error by default. You can configure the optional `bump`
+sub-setting to specify a fallback semver bump level to apply to the last
+released version instead:
+
+```yaml
+components:
+  - name: my_gem
+    version_from_code:
+      bump: patch2
+```
+
+With `bump: patch2` (or `patch`, `minor`, or `major`), if the code version is
+not newer than the last release, the last released version is bumped by the
+given level to produce a releasable version.
+
 ### Running on the command line
 
 The implementation of Toys-Release is done via Toys (i.e. command line) tools.
@@ -1177,6 +1229,41 @@ The **name** key is required. The others are optional.
     libraries up to date. If this setting is not present, automatic updating is
     not performed for this component.
 
+ *  **version_from_code**: *boolean or dictionary* (optional) --
+    When set, uses the version constant in the component's code (as identified
+    by the **version_rb_path** setting) as the version to release, rather than
+    computing it automatically from the conventional commit history.
+
+    Set this to `true` to enable the feature with default settings:
+
+    ```yaml
+    components:
+      - name: my_gem
+        version_from_code: true
+    ```
+
+    Or set it to a dictionary to provide additional configuration:
+
+    ```yaml
+    components:
+      - name: my_gem
+        version_from_code:
+          bump: patch
+    ```
+
+    The dictionary supports the following optional key:
+
+     *  **bump**: *string* (optional) --
+        What to do if the version specified in the code has already been
+        released (i.e. the code version is not newer than the most recently
+        released version). Possible values are `patch2`, `patch`, `minor`,
+        `major`, and `none`. If `none` (the default), the release request will
+        fail with an error. If a semver bump level is given, the last released
+        version is bumped by that level to produce a releasable version.
+
+    See also [Using code-specified versions](#using-code-specified-versions)
+    for a conceptual overview.
+
  *  **version_rb_path**: *string* (optional) --
     The path to a Ruby file that contains the current version of the component.
     This file *must* include Ruby code that looks like this:
@@ -1200,20 +1287,20 @@ released with updated dependency versions, due to one or more of those
 dependencies being released. It is typically used to keep "kitchen sink"
 libraries up to date.
 
-For example, consider two components "foo_a" and "foo_b", and a "kitchen sink"
-component "foo_all" that depends on both the others. Suppose whenever a patch
-or greater release of either "foo_a" or "foo_b" happens, we also want "foo_all"
+For example, consider two components "gem_a" and "gem_b", and a "kitchen sink"
+component "gem_all" that depends on both the others. Suppose whenever a patch
+or greater release of either "gem_a" or "gem_b" happens, we also want "gem_all"
 to be released with its corresponding dependency bumped to the same version. We
 might set up the configuration like so:
 
 ```yaml
 components:
-  - name: foo_a
-  - name: foo_b
-  - name: foo_all
+  - name: gem_a
+  - name: gem_b
+  - name: gem_all
     update_dependencies:
       dependency_semver_threshold: patch
-      dependencies: [foo_a, foo_b]
+      dependencies: [gem_a, gem_b]
 ```
 
 The update-dependencies configuration for a kitchen sink component can include

data/lib/toys/release/version.rb

@@ -6,6 +6,6 @@ module Toys
     # Current version of the Toys release system.
     # @return [String]
     #
-    VERSION = "0.8.2"
+    VERSION = "0.9.0"
   end
 end

data/toys/.lib/toys/release/change_set.rb

@@ -162,7 +162,7 @@ module Toys
       def suggested_version(last)
         raise "ChangeSet not finished" unless finished?
         return nil unless semver.significant?
-        semver.bump(last)
+        semver.bump(last, minimum_fill: Semver::PATCH, prevent_bump_to_v1: true)
       end
 
       ##

data/toys/.lib/toys/release/gh_pages_logic.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+
+module Toys
+  module Release
+    ##
+    # Logic for generating and updating gh-pages documentation site files.
+    #
+    class GhPagesLogic
+      ##
+      # Create a GhPagesLogic instance.
+      #
+      # @param repo_settings [Toys::Release::RepoSettings] Repository settings
+      #
+      def initialize(repo_settings)
+        @enabled_component_settings = repo_settings.all_component_settings.select(&:gh_pages_enabled)
+        raise ::ArgumentError, "No components have gh-pages enabled" if @enabled_component_settings.empty?
+        @url_base_path = "#{repo_settings.repo_owner}.github.io/#{repo_settings.repo_name}"
+        @default_redirect_url = "https://#{component_base_path(@enabled_component_settings.first)}/latest"
+      end
+
+      ##
+      # Clean up non-index files from the v0 subdirectory of each gh-pages-
+      # enabled component. The given block is called for each component whose
+      # v0 directory contains files other than index.html, and receives the
+      # directory path and the list of files to remove. The block should return
+      # true to remove the files, or false to skip. If no block is given, files
+      # are removed unconditionally.
+      #
+      # @param gh_pages_dir [String] Path to the gh-pages working tree
+      # @yieldparam directory [String] Path relative to gh_pages_dir of the v0 dir
+      # @yieldparam children [Array<String>] Non-index filenames to remove
+      # @yieldreturn [boolean] Whether to remove the files
+      # @return [Array<Hash>] Results, one per enabled component, each with
+      #     keys :directory (relative path), :children, and :removed
+      #
+      def cleanup_v0_directories(gh_pages_dir, &confirm)
+        @enabled_component_settings.map do |comp_settings|
+          cleanup_component_v0(gh_pages_dir, comp_settings, &confirm)
+        end
+      end
+
+      ##
+      # Generate all gh-pages scaffold files into the given directory.
+      # The given block is called for each file that needs to be created or
+      # overwritten (but NOT for unchanged files), and receives the destination
+      # path, the status (:new or :overwrite), and the existing file type
+      # (only meaningful for :overwrite). The block should return true to
+      # write the file, or false to skip.
+      #
+      # @param gh_pages_dir [String] Path to the gh-pages working tree
+      # @param template_dir [String] Path to the directory containing ERB
+      #     templates for gh-pages files
+      # @yieldparam destination [String] Path relative to gh_pages_dir of the destination file
+      # @yieldparam status [Symbol] :new or :overwrite
+      # @yieldparam existing_ftype [String,nil] The ftype of the existing entry
+      # @yieldreturn [boolean] Whether to write the file
+      # @return [Array<Hash>] Results, one per file considered, each with
+      #     keys :destination (relative path) and :outcome (:wrote, :skipped, or :unchanged)
+      #
+      def generate_files(gh_pages_dir, template_dir, &confirm)
+        results = []
+        @enabled_component_settings.each do |comp_settings|
+          generate_component_files(gh_pages_dir, template_dir, comp_settings, results, &confirm)
+        end
+        generate_toplevel_files(gh_pages_dir, template_dir, results, &confirm)
+        generate_html404(gh_pages_dir, template_dir, results, &confirm)
+        results
+      end
+
+      ##
+      # Update the 404 page and redirect index pages for a new component
+      # release. The optional block is called with a warning message when a
+      # required file is not found.
+      #
+      # @param gh_pages_dir [String] Path to the gh-pages working tree
+      # @param component_settings [Toys::Release::ComponentSettings] Settings
+      #     for the component being released
+      # @param version [Gem::Version] The new version being released
+      # @yieldparam warning [String] A warning message for a missing file
+      #
+      def update_version_pages(gh_pages_dir, component_settings, version, &on_warning)
+        update_404_page(gh_pages_dir, component_settings, version, &on_warning)
+        update_index_pages(gh_pages_dir, component_settings, version, &on_warning)
+      end
+
+      private
+
+      # Context object for ERB template rendering
+      class ErbContext
+        def initialize(data)
+          data.each { |name, value| instance_variable_set("@#{name}", value) }
+          freeze
+        end
+
+        # @private
+        def self.get(data)
+          new(data).instance_eval { binding }
+        end
+      end
+      private_constant :ErbContext
+
+      # Struct carrying info about a component for the 404 template
+      CompInfo = ::Struct.new(:base_path, :regexp_source, :version_var)
+      private_constant :CompInfo
+
+      # Cleans up a single component's v0 directory, yielding to the caller for confirmation.
+      def cleanup_component_v0(gh_pages_dir, comp_settings)
+        relative_dir = simplifying_join(comp_settings.gh_pages_directory, "v0")
+        directory = ::File.expand_path(relative_dir, gh_pages_dir)
+        ::FileUtils.mkdir_p(directory)
+        children = ::Dir.children(directory) - ["index.html"]
+        removed = false
+        if !children.empty? && (!block_given? || yield(relative_dir, children))
+          children.each { |child| ::FileUtils.remove_entry(::File.join(directory, child), true) }
+          removed = true
+        end
+        {directory: relative_dir, children: children, removed: removed}
+      end
+
+      # Returns the URL base path for a component, incorporating its gh_pages_directory if set.
+      def component_base_path(comp_settings)
+        simplifying_join(@url_base_path, comp_settings.gh_pages_directory)
+      end
+
+      # Scans the component's gh-pages directory and returns the highest existing released version,
+      # or "0" if no versioned subdirectories exist yet.
+      def current_component_version(gh_pages_dir, comp_settings)
+        base_dir = ::File.expand_path(comp_settings.gh_pages_directory, gh_pages_dir)
+        latest = ::Gem::Version.new("0")
+        return latest unless ::File.directory?(base_dir)
+        ::Dir.children(base_dir).each do |child|
+          next unless /^v\d+(\.\d+)*$/.match?(child)
+          next unless ::File.directory?(::File.join(base_dir, child))
+          version = ::Gem::Version.new(child[1..])
+          latest = version if version > latest
+        end
+        latest
+      end
+
+      # Renders an ERB template from template_dir with the given data hash and returns the result.
+      def render_template(template_dir, template_name, data)
+        template_path = ::File.join(template_dir, template_name)
+        raise "Unable to find template #{template_name}" unless ::File.file?(template_path)
+        erb = ::ERB.new(::File.read(template_path))
+        erb.result(ErbContext.get(data))
+      end
+
+      # Updates the version variable assignment in 404.html for the given component.
+      def update_404_page(gh_pages_dir, component_settings, version)
+        path = ::File.join(gh_pages_dir, "404.html")
+        unless ::File.file?(path)
+          yield "404.html not found. Skipping." if block_given?
+          return
+        end
+        content = ::File.read(path)
+        version_var = component_settings.gh_pages_version_var
+        content.sub!(/#{::Regexp.escape(version_var)} = "[\w.]+";/,
+                     "#{version_var} = \"#{version}\";")
+        ::File.write(path, content)
+      end
+
+      # Updates the redirect URLs in index.html and latest/index.html to point at the new version.
+      def update_index_pages(gh_pages_dir, component_settings, version)
+        redirect_url = "https://#{component_base_path(component_settings)}/v#{version}"
+        ["index.html", "latest/index.html"].each do |filename|
+          relative_path = simplifying_join(component_settings.gh_pages_directory, filename)
+          absolute_path = ::File.expand_path(relative_path, gh_pages_dir)
+          unless ::File.file?(absolute_path)
+            yield "#{relative_path} not found. Skipping." if block_given?
+            next
+          end
+          content = ::File.read(absolute_path)
+          content.gsub!(/ href="[^"]+"/, " href=\"#{redirect_url}\"")
+          content.gsub!(/ content="0; url=[^"]+"/, " content=\"0; url=#{redirect_url}\"")
+          content.gsub!(/window\.location\.replace\("[^"]+"\)/, "window.location.replace(\"#{redirect_url}\")")
+          ::File.write(absolute_path, content)
+        end
+      end
+
+      # Returns File.lstat for path, or nil if the path does not exist.
+      def safe_lstat(path)
+        ::File.lstat(path)
+      rescue ::SystemCallError
+        nil
+      end
+
+      # Returns the contents of path as a string, or nil if the file cannot be read.
+      def safe_read(path)
+        ::File.read(path)
+      rescue ::SystemCallError
+        nil
+      end
+
+      # Joins paths, simplifying if either argument is "."
+      def simplifying_join(path1, path2)
+        if path1 == "."
+          path2
+        elsif path2 == "."
+          path1
+        else
+          "#{path1}/#{path2}"
+        end
+      end
+
+      # Writes content to a relative destination, appending to results. Skips unchanged files
+      # without calling the block; calls the block for new or overwrite cases to confirm.
+      def write_file(gh_pages_dir, relative_destination, content, results, &confirm)
+        destination = ::File.expand_path(relative_destination, gh_pages_dir)
+        stat = safe_lstat(destination)
+        if stat
+          if stat.file? && safe_read(destination) == content
+            results << {destination: relative_destination, outcome: :unchanged}
+            return
+          end
+          status = :overwrite
+          ftype = stat.ftype
+        else
+          status = :new
+          ftype = nil
+        end
+        proceed = confirm ? confirm.call(relative_destination, status, ftype) : true
+        if proceed
+          ::FileUtils.mkdir_p(::File.dirname(destination))
+          ::FileUtils.remove_entry(destination, true) if stat
+          ::File.write(destination, content)
+          results << {destination: relative_destination, outcome: :wrote}
+        else
+          results << {destination: relative_destination, outcome: :skipped}
+        end
+      end
+
+      # Generates the v0 placeholder, component index, and latest/index redirect for one component.
+      def generate_component_files(gh_pages_dir, template_dir, comp_settings, results, &confirm)
+        version = current_component_version(gh_pages_dir, comp_settings)
+        redirect_url = "https://#{component_base_path(comp_settings)}/v#{version}"
+        subdir = comp_settings.gh_pages_directory
+
+        write_file(gh_pages_dir, simplifying_join(subdir, "v0/index.html"),
+                   render_template(template_dir, "empty.html.erb", {name: comp_settings.name}),
+                   results, &confirm)
+        write_file(gh_pages_dir, simplifying_join(subdir, "index.html"),
+                   render_template(template_dir, "redirect.html.erb", {redirect_url: redirect_url}),
+                   results, &confirm)
+        write_file(gh_pages_dir, simplifying_join(subdir, "latest/index.html"),
+                   render_template(template_dir, "redirect.html.erb", {redirect_url: redirect_url}),
+                   results, &confirm)
+      end
+
+      # Generates .nojekyll, .gitignore, and (when no root component exists) the root index redirect.
+      def generate_toplevel_files(gh_pages_dir, template_dir, results, &confirm)
+        write_file(gh_pages_dir, ".nojekyll", "", results, &confirm)
+        write_file(gh_pages_dir, ".gitignore", render_template(template_dir, "gitignore.erb", {}), results, &confirm)
+
+        return if @enabled_component_settings.any? { |s| s.gh_pages_directory == "." }
+
+        write_file(gh_pages_dir, "index.html",
+                   render_template(template_dir, "redirect.html.erb", {redirect_url: @default_redirect_url}),
+                   results, &confirm)
+      end
+
+      # Generates 404.html with version variables and redirect-replacement regexps for all components.
+      def generate_html404(gh_pages_dir, template_dir, results, &confirm)
+        version_vars = {}
+        replacement_info = @enabled_component_settings.map do |comp_settings|
+          version_vars[comp_settings.gh_pages_version_var] =
+            current_component_version(gh_pages_dir, comp_settings)
+          base_path = component_base_path(comp_settings)
+          regexp_source = "//#{::Regexp.escape(base_path)}/latest(/|$)"
+          CompInfo.new(base_path, regexp_source, comp_settings.gh_pages_version_var)
+        end
+        template_params = {
+          default_redirect_url: @default_redirect_url,
+          version_vars: version_vars,
+          replacement_info: replacement_info,
+        }
+        write_file(gh_pages_dir, "404.html", render_template(template_dir, "404.html.erb", template_params),
+                   results, &confirm)
+      end
+    end
+  end
+end

data/toys/.lib/toys/release/repo_settings.rb

@@ -170,6 +170,36 @@ module Toys
       end
     end
 
+    ##
+    # This configuration is present for a component if version_from_code is
+    # requested, i.e. the version to release is the version in the code.
+    #
+    class VersionFromCodeSettings
+      # @private
+      def initialize(info, errors)
+        unless info.is_a?(::Hash)
+          errors << "version_from_code expected to be true or a dictionary" unless info == true
+          info = {}
+        end
+        bump_name = info.delete("bump") || "none"
+        @bump = Semver.for_name(bump_name)
+        unless @bump
+          errors << "Unrecognized semver bump value: #{bump_name.inspect}"
+          @bump = Semver::NONE
+        end
+        info.each_key do |key|
+          errors << "Unknown key #{key.inspect} for version_from_code"
+        end
+      end
+
+      ##
+      # @return [Semver] What semver field to bump if the requested version has
+      #     already been released. If this is {Semver::NONE} and the requested
+      #     version is already released, the release request will error out.
+      #
+      attr_reader :bump
+    end
+
     ##
     # Configuration of a single component
     #
@@ -191,6 +221,7 @@ module Toys
         read_steps_info(info, repo_settings)
         read_commit_tag_info(info, repo_settings)
         read_update_deps(info, repo_settings)
+        read_version_from_code(info, repo_settings)
         check_problems(info, repo_settings)
       end
 
@@ -292,6 +323,13 @@ module Toys
       #
       attr_reader :update_dependencies
 
+      ##
+      # @return [VersionFromCodeSettings,nil] Configuration for using
+      #     the version in code as the version to release instead of
+      #     interpreting conventional commit tags.
+      #
+      attr_reader :version_from_code
+
       ##
       # @return [StepSettings,nil] The unique step with the given name
       #
@@ -376,6 +414,14 @@ module Toys
           end
       end
 
+      def read_version_from_code(info, repo_settings)
+        vfc_info = info.delete("version_from_code")
+        @version_from_code =
+          if vfc_info
+            VersionFromCodeSettings.new(vfc_info, repo_settings.errors)
+          end
+      end
+
       def camelize(str)
         str.to_s
            .sub(/^_/, "")

data/toys/.lib/toys/release/request_spec.rb

@@ -249,13 +249,38 @@ module Toys
         @utils.log("Creating #{component.name} changeset from #{latest_tag || 'start'} to #{@release_sha}")
         changeset = component.make_change_set(from: latest_tag, to: @release_sha)
         unless requested_version
-          cur_suggested_version = requested_bump&.bump(last_version) || changeset.suggested_version(last_version)
+          cur_suggested_version = determine_suggested_version(component, changeset, requested_bump, last_version)
           if !best_suggested_version || (cur_suggested_version && cur_suggested_version > best_suggested_version)
             best_suggested_version = cur_suggested_version
           end
         end
         [ResolvedComponent.new(component.name, changeset, last_version, nil), best_suggested_version]
       end
+
+      def determine_suggested_version(component, changeset, requested_bump, last_version)
+        vfc_settings = component.settings.version_from_code
+        if vfc_settings
+          requested_version = component.current_constant_version(at: @release_sha)
+          if requested_version.nil?
+            @utils.error("Unable to read code-specified version for #{component.name}")
+          elsif last_version.nil? || requested_version > last_version
+            @utils.log("Using code-specified version for #{component.name}")
+            requested_version
+          elsif vfc_settings.bump == Semver::NONE
+            @utils.error("Requested #{component.name} #{requested_version} but #{last_version} is the latest.")
+          else
+            @utils.log("Requested #{component.name} #{requested_version} but #{last_version} is the latest. " \
+                       "Bumping to get a releasable version.")
+            vfc_settings.bump.bump(last_version, minimum_fill: Semver::PATCH, prevent_bump_to_v1: true)
+          end
+        elsif requested_bump
+          @utils.log("Using requested semver bump of #{requested_bump} for #{component.name}")
+          requested_bump.bump(last_version, minimum_fill: Semver::PATCH, prevent_bump_to_v1: true)
+        else
+          @utils.log("Using changeset-suggested version for #{component.name}")
+          changeset.suggested_version(last_version)
+        end
+      end
     end
   end
 end

data/toys/.lib/toys/release/semver.rb

@@ -74,19 +74,30 @@ module Toys
       #
       # @param version [::Gem::Version] The original version. If nil is passed
       #     in, it is treated as synonymous with `0.0.0`.
+      # @param minimum_fill [Semver] Remove zeros down to this length. Default
+      #     is NONE, indicating to leave the length the same as the input.
+      # @param prevent_bump_to_v1 [boolean] If set to true, major version bumps
+      #     prior to 1.0 will actually bump the minor version, preventing a
+      #     normal bump to version 1.0.
       # @return [::Gem::Version] The new version
       #
-      def bump(version)
+      def bump(version, minimum_fill: Semver::NONE, prevent_bump_to_v1: false)
         version ||= ::Gem::Version.new("0.0.0")
         return version if segment.nil?
         bump_seg = segment
-        version_segs = version.segments
-        max_seg = bump_seg
-        max_seg = 2 if max_seg < 2
-        version_segs = version_segs[0..max_seg]
-        bump_seg = 1 if bump_seg.zero? && version_segs[0].zero?
-        version_segs[bump_seg] += 1
-        ::Gem::Version.new(version_segs.fill(0, bump_seg + 1).join("."))
+        version_segs = version.segments.dup
+        bump_seg = 1 if prevent_bump_to_v1 && bump_seg.zero? && version_segs[0].zero?
+        if version_segs.size > bump_seg
+          fill_seg = minimum_fill.segment || (version_segs.size - 1)
+          fill_seg = bump_seg if fill_seg < bump_seg
+          version_segs.slice!((fill_seg + 1)..)
+          version_segs[bump_seg] += 1
+          version_segs.fill(0, bump_seg + 1)
+        else
+          version_segs.concat(::Array.new(bump_seg - version_segs.size, 0))
+          version_segs << 1
+        end
+        ::Gem::Version.new(version_segs.join("."))
       end
 
       ##

data/toys/.lib/toys/release/steps.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "toys/release/gh_pages_logic"
 require "toys/utils/gems"
 
 module Toys
@@ -300,8 +301,12 @@ module Toys
           dest_dir = ::File.join(component_dir, "v#{step_context.release_version}")
           check_existence(step_context, dest_dir)
           copy_docs_dir(step_context, dest_dir)
-          update_404_page(step_context, gh_pages_dir)
-          update_index_pages(step_context, gh_pages_dir)
+          logic = ::Toys::Release::GhPagesLogic.new(step_context.repository.settings)
+          logic.update_version_pages(
+            gh_pages_dir,
+            step_context.component.settings,
+            step_context.release_version
+          ) { |msg| step_context.warning(msg) }
           push_docs_to_git(step_context, gh_pages_dir)
         end
 
@@ -341,39 +346,6 @@ module Toys
           ::FileUtils.cp_r(source_dir, dest_dir)
         end
 
-        def update_404_page(step_context, gh_pages_dir)
-          path = ::File.join(gh_pages_dir, "404.html")
-          unless ::File.file?(path)
-            step_context.warning("404.html not found. Skipping.")
-            return
-          end
-          content = ::File.read(path)
-          version_var = step_context.component.settings.gh_pages_version_var
-          content.sub!(/#{Regexp.escape(version_var)} = "[\w.]+";/,
-                       "#{version_var} = \"#{step_context.release_version}\";")
-          ::File.write(path, content)
-        end
-
-        def update_index_pages(step_context, gh_pages_dir)
-          subdir = step_context.component.settings.gh_pages_directory
-          dir_suffix = subdir == "." ? "" : "/#{subdir}"
-          settings = step_context.repository.settings
-          version = step_context.release_version
-          redirect_url = "https://#{settings.repo_owner}.github.io/#{settings.repo_name}#{dir_suffix}/v#{version}"
-          ["index.html", "latest/index.html"].each do |filename|
-            path = "#{gh_pages_dir}#{dir_suffix}/#{filename}"
-            unless ::File.file?(path)
-              step_context.warning("#{path} not found. Skipping.")
-              next
-            end
-            content = ::File.read(path)
-            content.gsub!(/ href="[^"]+"/, " href=\"#{redirect_url}\"")
-            content.gsub!(/ content="0; url=[^"]+"/, " content=\"0; url=#{redirect_url}\"")
-            content.gsub!(/window\.location\.replace\("[^"]+"\)/, "window.location.replace(\"#{redirect_url}\")")
-            ::File.write(path, content)
-          end
-        end
-
         def push_docs_to_git(step_context, gh_pages_dir)
           ::Dir.chdir(gh_pages_dir) do
             step_context.repository.git_commit("Generated docs for #{step_context.release_description}",

data/toys/.lib/toys/release/version_rb_file.rb

@@ -50,7 +50,7 @@ module Toys
       #
       def update_version(version)
         @utils.log("Updating #{path} to set VERSION=#{version}")
-        new_content = content.sub(/(?<=\W)VERSION\s*=\s*(["'])(\d+(?:\.[a-zA-Z0-9]+)+)\1/,
+        new_content = content.sub(/(?<=\W)VERSION\s*=\s*(["'])(\d+(?:\.[a-zA-Z0-9]+)*)\1/,
                                   "VERSION = \\1#{version}\\1")
         ::File.write(path, new_content)
         self
@@ -64,7 +64,7 @@ module Toys
       # @return [nil] if no version was found
       #
       def self.current_version_from_content(content)
-        match = /(?<=\W)VERSION\s*=\s*(["'])(\d+(?:\.[a-zA-Z0-9]+)+)\1/.match(content)
+        match = /(?<=\W)VERSION\s*=\s*(["'])(\d+(?:\.[a-zA-Z0-9]+)*)\1/.match(content)
         match ? ::Gem::Version.new(match[2]) : nil
       end
     end

data/toys/gen-gh-pages.rb

@@ -21,18 +21,6 @@ flag :dry_run
 include :exec
 include :terminal, styled: true
 
-# Context for ERB templates
-class ErbContext
-  def initialize(data)
-    data.each { |name, value| instance_variable_set("@#{name}", value) }
-    freeze
-  end
-
-  def self.get(data)
-    new(data).instance_eval { binding }
-  end
-end
-
 def run
   setup
   generate_gh_pages
@@ -41,10 +29,9 @@ def run
 end
 
 def setup
-  require "erb"
-  require "fileutils"
   require "toys/release/artifact_dir"
   require "toys/release/environment_utils"
+  require "toys/release/gh_pages_logic"
   require "toys/release/repo_settings"
   require "toys/release/repository"
 
@@ -57,129 +44,47 @@ def setup
     branch: "gh-pages", remote: git_remote, dir: @artifact_dir.get("gh-pages"),
     gh_token: ::ENV["GITHUB_TOKEN"], create: true
   )
-  @relevant_component_settings = @settings.all_component_settings.find_all(&:gh_pages_enabled)
-  if @relevant_component_settings.empty?
+  if @settings.all_component_settings.none?(&:gh_pages_enabled)
     puts "No components have gh-pages enabled", :red, :bold
     exit(1)
   end
+  @template_dir = find_data("gh-pages", type: :directory)
+  raise "Fatal: Unable to find gh-pages template data directory" unless @template_dir
+  @logic = Toys::Release::GhPagesLogic.new(@settings)
 end
 
 def cleanup
   @artifact_dir.cleanup
 end
 
-CompInfo = ::Struct.new(:base_path, :regexp_source, :version_var)
-
 def generate_gh_pages
-  ::Dir.chdir(@gh_pages_dir) do
-    @relevant_component_settings.each do |component_settings|
-      generate_component_files(component_settings)
-    end
-    generate_toplevel_files
-    generate_html404
+  @logic.cleanup_v0_directories(@gh_pages_dir) do |directory, _children|
+    puts "Non-index files exist in #{directory}.", :yellow, :bold
+    yes || confirm("Remove? ", default: true)
   end
-  puts "Files generated into #{@gh_pages_dir}", :bold
-end
-
-def generate_component_files(comp_settings)
-  prepare_v0_directory("#{comp_settings.gh_pages_directory}/v0")
-  generate_file("#{comp_settings.gh_pages_directory}/v0/index.html",
-                "empty.html.erb", {name: comp_settings.name})
-  component_redirect_url = "https://#{component_base_path(comp_settings)}/v#{current_component_version(comp_settings)}"
-  generate_file("#{comp_settings.gh_pages_directory}/index.html",
-                "redirect.html.erb", {redirect_url: component_redirect_url})
-  generate_file("#{comp_settings.gh_pages_directory}/latest/index.html",
-                "redirect.html.erb", {redirect_url: component_redirect_url})
-end
-
-def prepare_v0_directory(directory)
-  ::FileUtils.mkdir_p(directory)
-  children = ::Dir.children(directory) - ["index.html"]
-  return if children.empty?
-  puts "Non-index files exist in #{directory}.", :yellow, :bold
-  return unless yes || confirm("Remove? ", default: true)
-  children.each do |child|
-    ::FileUtils.remove_entry(::File.join(directory, child), true)
-  end
-end
-
-def current_component_version(comp_settings)
-  base_dir = comp_settings.gh_pages_directory
-  latest = ::Gem::Version.new("0")
-  return latest unless ::File.directory?(base_dir)
-  ::Dir.children(base_dir).each do |child|
-    next unless /^v\d+(\.\d+)*$/.match?(child)
-    next unless ::File.directory?(::File.join(base_dir, child))
-    version = ::Gem::Version.new(child[1..])
-    latest = version if version > latest
-  end
-  latest
-end
-
-def generate_toplevel_files
-  ::File.write(".nojekyll", "")
-  generate_file(".gitignore", "gitignore.erb", {})
-  unless @relevant_component_settings.any? { |settings| settings.gh_pages_directory == "." }
-    generate_file("index.html", "redirect.html.erb", {redirect_url: default_redirect_url})
-  end
-end
-
-def generate_html404
-  version_vars = {}
-  replacement_info = @relevant_component_settings.map do |comp_settings|
-    version_vars[comp_settings.gh_pages_version_var] = current_component_version(comp_settings)
-    base_path = component_base_path(comp_settings)
-    regexp_source = "//#{::Regexp.escape(base_path)}/latest(/|$)"
-    CompInfo.new(base_path, regexp_source, comp_settings.gh_pages_version_var)
-  end
-  template_params = {
-    default_redirect_url: default_redirect_url,
-    version_vars: version_vars,
-    replacement_info: replacement_info,
-  }
-  generate_file("404.html", "404.html.erb", template_params)
-end
-
-def url_base_path
-  @url_base_path ||= "#{@settings.repo_owner}.github.io/#{@settings.repo_name}"
-end
-
-def component_base_path(component_settings)
-  if component_settings.gh_pages_directory == "."
-    url_base_path
-  else
-    "#{url_base_path}/#{component_settings.gh_pages_directory}"
-  end
-end
-
-def default_redirect_url
-  @default_redirect_url ||= "https://#{component_base_path(@relevant_component_settings.first)}/latest"
-end
-
-def generate_file(destination, template, data)
-  return unless file_generation_confirmations(destination)
-  template_path = find_data("gh-pages/#{template}")
-  raise "Unable to find template #{template}" unless template_path
-  erb = ::ERB.new(::File.read(template_path))
-  content = erb.result(ErbContext.get(data))
-  ::FileUtils.mkdir_p(::File.dirname(destination))
-  ::File.write(destination, content)
-  puts "Wrote #{destination}.", :green
-end
-
-def file_generation_confirmations(destination)
-  if ::File.exist?(destination)
-    if ::File.directory?(destination)
-      puts "Destination #{destination} exists and is a DIRECTORY.", :yellow, :bold
+  results = @logic.generate_files(@gh_pages_dir, @template_dir) do |destination, status, existing_ftype|
+    if status == :overwrite
+      puts "Destination #{destination} exists (type: #{existing_ftype})", :yellow, :bold
+      yes || confirm("Overwrite? ", default: true)
     else
-      puts "Destination file #{destination} exists.", :yellow, :bold
+      yes || confirm("Create file #{destination}? ", default: true)
+    end
+  end
+  output_results(results)
+end
+
+def output_results(results)
+  results.each do |r|
+    case r[:outcome]
+    when :wrote
+      puts "Wrote #{r[:destination]}.", :green
+    when :unchanged
+      puts "Unchanged: #{r[:destination]}.", :green
+    when :skipped
+      puts "Skipped: #{r[:destination]}.", :yellow
     end
-    return false unless yes || confirm("Overwrite? ", default: true)
-    ::FileUtils.remove_entry(destination)
-  else
-    return false unless yes || confirm("Create file #{destination}? ", default: true)
   end
-  true
+  puts "Files generated into #{@gh_pages_dir}", :bold
 end
 
 def push_gh_pages

data/toys/gen-workflows.rb

@@ -69,20 +69,37 @@ def generate_all_files
 end
 
 def generate_file(name)
+  template_path = find_data("templates/#{name}.erb")
+  raise "Unable to find template #{name}.erb" unless template_path
+  erb = ::ERB.new(::File.read(template_path))
+  content = erb.result(ErbContext.get(@settings))
+
   destination = ::File.join(workflows_dir, name)
-  if ::File.readable?(destination)
-    puts "Destination file #{destination} exists.", :yellow
+  stat = safe_lstat(destination)
+  if stat
+    if stat.file? && safe_read(destination) == content
+      puts "Unchanged: #{destination}.", :green
+      return
+    end
+    puts "Destination #{destination} exists (type: #{stat.ftype})", :yellow, :bold
     return unless yes || confirm("Overwrite? ", default: true)
   else
     return unless yes || confirm("Create file #{destination}? ", default: true)
   end
 
-  template_path = find_data("templates/#{name}.erb")
-  raise "Unable to find template #{name}.erb" unless template_path
-  erb = ::ERB.new(::File.read(template_path))
+  ::FileUtils.remove_entry(destination, true)
+  ::File.write(destination, content)
+  puts "Wrote #{destination}.", :green
+end
 
-  ::File.open(destination, "w") do |file|
-    file.write(erb.result(ErbContext.get(@settings)))
-    puts "Wrote #{destination}.", :green
-  end
+def safe_lstat(path)
+  ::File.lstat(path)
+rescue ::SystemCallError
+  nil
+end
+
+def safe_read(path)
+  ::File.read(path)
+rescue ::SystemCallError
+  nil
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toys-release
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Daniel Azuma
@@ -76,6 +76,7 @@ files:
 - toys/.lib/toys/release/component.rb
 - toys/.lib/toys/release/environment_utils.rb
 - toys/.lib/toys/release/gemspec_file.rb
+- toys/.lib/toys/release/gh_pages_logic.rb
 - toys/.lib/toys/release/performer.rb
 - toys/.lib/toys/release/pipeline.rb
 - toys/.lib/toys/release/pull_request.rb
@@ -101,10 +102,10 @@ homepage: https://github.com/dazuma/toys
 licenses:
 - MIT
 metadata:
-  changelog_uri: https://dazuma.github.io/toys/gems/toys-release/v0.8.2/file.CHANGELOG.html
-  source_code_uri: https://github.com/dazuma/toys/tree/toys-release/v0.8.2/toys-release
+  changelog_uri: https://dazuma.github.io/toys/gems/toys-release/v0.9.0/file.CHANGELOG.html
+  source_code_uri: https://github.com/dazuma/toys/tree/toys-release/v0.9.0/toys-release
   bug_tracker_uri: https://github.com/dazuma/toys/issues
-  documentation_uri: https://dazuma.github.io/toys/gems/toys-release/v0.8.2
+  documentation_uri: https://dazuma.github.io/toys/gems/toys-release/v0.9.0
 rdoc_options: []
 require_paths:
 - lib