conventional_commits 0.2.23 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47ee970c18a0739f838c1de2019974654bd6f4698e364d864a807bebd579c442
-  data.tar.gz: d75c131ba2000b7aebdcc6b9c8164a5fb17a8c7b7c238c1863ec560a2f8fa693
+  metadata.gz: 8ef389be49918b12a03941a89178003c8b6ba9962583516728948bb1c61d5557
+  data.tar.gz: e4e5c3dd45bb0e3c140b9519dcd76f432fc7812012402dde8a4a643da8318c9a
 SHA512:
-  metadata.gz: 9ce7cfee46f6f0954543e056b346c68c3a9fd0428ed9a89cd8241df9e04873a39428b3214274fdd2880d4ba71ef6b08d58b7387dfc96d31bf7a22c2c26886c77
-  data.tar.gz: f29c2b32b96c9d6cf1a9d3121f4ca993956ca410c53d5e0f453dce35a917e71e48db95d9b779dd4baad87c5c57fd78359b074260e96fcc9fbd85bbaccaf4fb0c
+  metadata.gz: d8435aa0ae03a4ab74880debbec1f7a925b39a972337a17432234f64907e97388b82d48692f58ac16f2d7566dd0f0d96e365ef2ef86940e5ea6372fd59eb5ad8
+  data.tar.gz: 5cc8f961cc6ce9296f0348fe6d200c53edbfb10996320065d3b3ae045125177204aa3a01a1be062b861c95561dc828e0c19236a1400bd0015f8d15f353df2971

data/.pre-commit-hooks.yaml

@@ -5,4 +5,23 @@
   language: ruby
   language_version: 3.2.2
   always_run: true
-  pass_filenames: false
+  pass_filenames: false
+
+- id: validate_message
+  name: Message Validation
+  description: "Validate commit message"
+  entry: "conventional_commits validate_commit_msg"
+  language: ruby
+  language_version: 3.2.2
+  pass_filenames: false
+  always_run: true
+
+- id: prepare_message
+  name: Prepare Commit Message
+  description: "Preparing commit message"
+  entry: "conventional_commits prepare_commit_msg"
+  language: ruby
+  language_version: 3.2.2
+  pass_filenames: false
+  args: [--source=$PRE_COMMIT_COMMIT_MSG_SOURCE]
+  always_run: true

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    conventional_commits (0.2.21)
+    conventional_commits (0.3.0)
       open3
       thor
       yaml
@@ -104,6 +104,8 @@ GEM
 PLATFORMS
   arm64-darwin-23
   arm64-darwin-24
+  arm64-darwin-25
+  x86_64-linux
 
 DEPENDENCIES
   aruba

data/README.md

@@ -55,8 +55,29 @@ to create a new branch
 - `pattern` - is used to define the separators between in future it will be used to define the order as well
 - `type` - is used for mapping combination of short names for the type of request. Helps to avoid inconsistency.
 
+### Validating in CI
+The hooks validate the current branch and `.git/COMMIT_EDITMSG`. In CI, pass them explicitly:
+
+    $ conventional_commits validate_branch --branch "$GITHUB_HEAD_REF"
+    $ conventional_commits validate_commit_msg --msg "$(git log -1 --format=%B "$SHA")"
+
+With a detached `HEAD` and no `--branch`, `validate_branch` falls back to `$GITHUB_HEAD_REF`.
+
 ### Release
-Not implemented yet. It will contain tools to increment version number based on the rules
+`next_version` prints the next version from the commits since the latest version tag
+(`X.Y.Z` or `vX.Y.Z`), following `release.rules`:
+
+    $ conventional_commits next_version
+    0.3.1
+
+- Each commit's type is matched against the rules' types; aliases from `type` count as their
+  main type, so a `ref:` commit matches a rule listing `refactor`.
+- A breaking change — `type!:` in the subject or a `BREAKING CHANGE:` footer — uses the rule
+  for `breaking`.
+- The biggest bump of all the commits wins (`major` > `minor` > `patch`); `version: none`, or a
+  type without a rule, produces no release.
+- It prints nothing when no commit calls for a release, and `--initial` (default `0.1.0`) when
+  there is no version tag yet.
 
 
 ## Development

data/exe/conventional_commits

@@ -17,4 +17,5 @@ require "helpers/file_extension"
 require "commit/commit_message_parser"
 require "commit/commit_message_validator"
 require "hooks/hooks_installer"
+require "release/next_version_calculator"
 ConventionalCommits::BranchNameCLI.start(ARGV)

data/lib/branch/branch_name_generator.rb

@@ -2,10 +2,12 @@
 
 module ConventionalCommits
   class BranchNameGenerator
-    attr_reader :reader
+    attr_reader :reader, :main_reader
 
-    def initialize(reader: reader = Configuration::BranchConfigurationReader.new)
+    def initialize(reader: reader = Configuration::BranchConfigurationReader.new,
+                   main_reader: Configuration::MainConfigurationReader.new)
       @reader = reader
+      @main_reader = main_reader
     end
 
     def generate_name_for(_input, path: Configuration::DEFAULT_CONFIGURATION_PATH)
@@ -34,12 +36,31 @@ module ConventionalCommits
       components
     end
 
+    # A branch is valid when the commit message generator can build a subject from it: the
+    # type must be one the configuration allows, and the description must not be empty.
     def is_valid_branch(_input, path: Configuration::DEFAULT_CONFIGURATION_PATH)
-      !branch_name_components(_input, path:).empty?
+      components = branch_name_components(_input, path:)
+      validate_description(components[:description], branch: _input)
+      validate_type(components[:type], path:)
+      true
     end
 
     private
 
+    def validate_description(description, branch:)
+      return unless description.to_s.strip.empty?
+
+      raise GenericError, "The branch #{branch} has no description"
+    end
+
+    def validate_type(type, path:)
+      type_configuration = main_reader.get_configuration(path:).type
+      return if type_configuration.is_allowed(type.to_s.downcase)
+
+      raise GenericError,
+            "The type #{type} is not allowed. Allowed types #{type_configuration.all_types}"
+    end
+
     def find_delimiters_from_pattern(pattern: string)
       delimiters = pattern.gsub(/<scope>/, "<replace>")
                           .gsub(/<type>/, "<replace>")

data/lib/cli/branch_name_cli.rb

@@ -24,44 +24,60 @@ module ConventionalCommits
     option :source, type: :string, required: false
     option :cfg_path, type: :string, required: false
     def prepare_commit_msg
-      source = options["source"] || ""
-      puts source
+      source = options["source"] || ENV["PRE_COMMIT_COMMIT_MSG_SOURCE"] || ""
       msg_path = options["msg_path"] || Configuration::DEFAULT_COMMIT_MSG_PATH
       cfg_path = options["cfg_path"] || Configuration::DEFAULT_CONFIGURATION_PATH
 
+      return if Configuration.git_generated_message?(msg_path)
+
       generator = ConventionalCommits::CommitMessageGenerator.new
       unless generator.should_preserve_original_message(source:)
         puts "Generating message"
         name = generator.prepare_message_template_for_type(type: source, cfg_path:, msg_file_path: msg_path)
         File.write_to_file(msg_path, name)
       end
-      
     rescue StandardError => e
       raise Thor::Error, e.message
     end
 
     desc "validate_branch", "validates if the branch conforms to the rules"
     option :cfg_path, type: :string, required: false
+    option :branch, type: :string, required: false,
+                    desc: "Branch to validate; defaults to the current branch, then $GITHUB_HEAD_REF"
     def validate_branch_name
       cfg_path = options["cfg_path"] || Configuration::DEFAULT_CONFIGURATION_PATH
       generator = ConventionalCommits::BranchNameGenerator.new
-      name = ConventionalCommits::Git.new.current_branch_name
-      generator.is_valid_branch(name.strip, path: cfg_path.strip)
+      generator.is_valid_branch(branch_name_to_validate, path: cfg_path.strip)
     rescue StandardError => e
       raise Thor::Error, e.message
     end
 
-    desc "validate_commit_msg", "validates if the branch conforms to the rules"
+    desc "validate_commit_msg", "validates if the commit message conforms to the rules"
     option :msg_path, type: :string, required: false
-    option :msg, type: :string, required: false
+    option :msg, type: :string, required: false, desc: "Message text to validate instead of a file"
     option :cfg_path, type: :string, required: false
     def validate_commit_msg
-
       msg_path = options["msg_path"] || Configuration::DEFAULT_COMMIT_MSG_PATH
       cfg_path = options["cfg_path"] || Configuration::DEFAULT_CONFIGURATION_PATH
       validator = ConventionalCommits::CommitMessageValidator.new
 
-      validator.validate_commit_msg_from_file(commit_msg_path: msg_path, cfg_path:)
+      if options["msg"]
+        validator.validate_commit_msg(message: options["msg"], cfg_path:)
+      else
+        validator.validate_commit_msg_from_file(commit_msg_path: msg_path, cfg_path:)
+      end
+    rescue StandardError => e
+      raise Thor::Error, e.message
+    end
+
+    desc "next_version", "prints the next release version from the commits since the latest version tag"
+    option :cfg_path, type: :string, required: false
+    option :initial, type: :string, required: false, desc: "Version to print when there is no version tag yet (default 0.1.0)"
+    def next_version
+      cfg_path = options["cfg_path"] || Configuration::DEFAULT_CONFIGURATION_PATH
+      version = ConventionalCommits::NextVersionCalculator.new
+                                                         .next_version(cfg_path:, initial: options["initial"] || "0.1.0")
+      puts version if version
     rescue StandardError => e
       raise Thor::Error, e.message
     end
@@ -73,5 +89,18 @@ module ConventionalCommits
     rescue StandardError => e
       raise Thor::Error, e.message
     end
+
+    no_commands do
+      # A detached HEAD (e.g. a CI checkout of a pull request) has no current branch, so fall
+      # back to the pull request's head branch that GitHub Actions provides.
+      def branch_name_to_validate
+        name = [options["branch"], ConventionalCommits::Git.new.current_branch_name, ENV["GITHUB_HEAD_REF"]]
+               .map { |candidate| candidate.to_s.strip }
+               .find { |candidate| !candidate.empty? }
+        raise GenericError, "Cannot determine the branch name (HEAD is detached); pass --branch" if name.nil?
+
+        name
+      end
+    end
   end
 end

data/lib/commit/commit_message_validator.rb

@@ -4,10 +4,20 @@ module ConventionalCommits
   class CommitMessageValidator
     def validate_commit_msg_from_file(commit_msg_path: Configuration::DEFAULT_COMMIT_MSG_PATH,
                                       cfg_path: Configuration::DEFAULT_CONFIGURATION_PATH)
-      return if commit_msg_path != Configuration::DEFAULT_COMMIT_MSG_PATH
+      return if Configuration.git_generated_message?(commit_msg_path)
+
+      parser = CommitMessageParser.new
+      validate(parser.message_components(commit_msg_path:, cfg_path:))
+    end
+
+    def validate_commit_msg(message:, cfg_path: Configuration::DEFAULT_CONFIGURATION_PATH)
       parser = CommitMessageParser.new
-      components = parser.message_components(commit_msg_path:, cfg_path:)
+      validate(parser.message_components_from_string(commit_msg: message, cfg_path:))
+    end
+
+    private
 
+    def validate(components)
       raise GenericError, "The Message is Invalid" if components.empty?
 
       if components[:body].include?(Configuration::DEFAULT_COMMIT_BODY_TEMPLATE)

data/lib/configuration.rb

@@ -6,5 +6,11 @@ module ConventionalCommits
     DEFAULT_COMMIT_MSG_PATH = ".git/COMMIT_EDITMSG"
     DEFAULT_COMMIT_BODY_TEMPLATE = "[Describe your work, and put an empty string after]"
     MAX_ELEMENTS_IN_PATTERN = 4
+    # Messages git writes itself for merges and squashes; hooks receive them and leave them as is.
+    GIT_GENERATED_MESSAGE_FILES = %w[MERGE_MSG SQUASH_MSG].freeze
+
+    def self.git_generated_message?(path)
+      GIT_GENERATED_MESSAGE_FILES.include?(File.basename(path.to_s))
+    end
   end
 end

data/lib/conventional_commits/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConventionalCommits
-  VERSION = "0.2.23"
+  VERSION = "0.4.0"
 end

data/lib/git/git.rb

@@ -10,6 +10,16 @@ module ConventionalCommits
       run_system_command "git symbolic-ref --short HEAD"
     end
 
+    def tags
+      run_system_command("git tag --list").split("\n").map(&:strip).reject(&:empty?)
+    end
+
+    # Full messages of the commits reachable from HEAD but not from `ref`, newest first.
+    def commit_messages_since(ref)
+      run_system_command("git log --format=%B%x00 #{ref}..HEAD")
+        .split("\x00").map(&:strip).reject(&:empty?)
+    end
+
     def run_system_command(_cmd)
       Open3.popen3(_cmd) { |_stdin, stdout, _stderr, _wait_thr| stdout.read }
     end

data/lib/models/release_rule.rb

@@ -2,12 +2,13 @@
 
 module ConventionalCommits
   module Configuration
-    # Configuration for branch name policies
+    # A release rule: which commit types produce which version bump
     class ReleaseRule
       attr_reader :types, :version
 
+      # Accepts both `types: [..]` and the singular `type: ..` used for the breaking rule.
       def initialize(options = {})
-        @types = options["types"] || []
+        @types = Array(options["types"] || options["type"])
         @version = options["version"] || "none"
       end
     end

data/lib/release/next_version_calculator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ConventionalCommits
+  # Works out the next release version from the commits since the latest version tag, using the
+  # `release.rules` of the configuration: each commit's type (aliases included) maps to a bump,
+  # and the biggest bump wins. A breaking change (`type!:` or a `BREAKING CHANGE:` footer) uses
+  # the rule for the `breaking` type.
+  class NextVersionCalculator
+    VERSION_TAG = /\Av?\d+\.\d+\.\d+\z/
+    SUBJECT = /\A(?<type>[A-Za-z]+)(?:\([^)]*\))?(?<breaking>!)?:/
+    BREAKING_FOOTER = /^BREAKING[ -]CHANGE:/
+    BREAKING_TYPE = "breaking"
+    BUMPS = %w[none patch minor major].freeze
+
+    attr_reader :git, :reader
+
+    def initialize(git: Git.new, reader: Configuration::MainConfigurationReader.new)
+      @git = git
+      @reader = reader
+    end
+
+    # The next version as "X.Y.Z", `initial` when there is no version tag yet, or nil when no
+    # commit since the latest tag calls for a release.
+    def next_version(cfg_path: Configuration::DEFAULT_CONFIGURATION_PATH, initial: "0.1.0")
+      tag = latest_version_tag
+      return initial if tag.nil?
+
+      config = reader.get_configuration(path: cfg_path)
+      bumps = git.commit_messages_since(tag).map { |message| bump_for(message, config) }
+      bumped(tag, bumps.max_by { |bump| BUMPS.index(bump) } || "none")
+    end
+
+    private
+
+    def latest_version_tag
+      git.tags.grep(VERSION_TAG).max_by { |tag| Gem::Version.new(tag.delete_prefix("v")) }
+    end
+
+    def bump_for(message, config)
+      subject = SUBJECT.match(message.lines.first.to_s.strip)
+      return "none" if subject.nil?
+
+      if subject[:breaking] || message.match?(BREAKING_FOOTER)
+        rule_bump(BREAKING_TYPE, config) || type_bump(subject[:type], config)
+      else
+        type_bump(subject[:type], config)
+      end
+    end
+
+    def type_bump(type, config)
+      rule_bump(main_type(type.downcase, config), config) || "none"
+    end
+
+    def rule_bump(type, config)
+      rule = config.release.rules.find do |candidate|
+        candidate.types.map { |rule_type| main_type(rule_type.to_s, config) }.include?(type)
+      end
+      rule && validated(rule.version)
+    end
+
+    # Rule types and commit types may be aliases ("feature", "ref"); both sides compare as the
+    # configured main type. `breaking` and unknown types stay as they are.
+    def main_type(type, config)
+      main = config.type.main_type(type)
+      main.to_s.empty? ? type : main
+    end
+
+    def validated(bump)
+      raise GenericError, "Unknown release version '#{bump}', expected one of #{BUMPS}" unless BUMPS.include?(bump)
+
+      bump
+    end
+
+    def bumped(tag, bump)
+      return nil if bump == "none"
+
+      major, minor, patch = tag.delete_prefix("v").split(".").map(&:to_i)
+      case bump
+      when "major" then "#{major + 1}.0.0"
+      when "minor" then "#{major}.#{minor + 1}.0"
+      else "#{major}.#{minor}.#{patch + 1}"
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conventional_commits
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.4.0
 platform: ruby
 authors:
 - Swift-Gurus
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-04 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: open3
@@ -129,6 +129,7 @@ files:
 - lib/models/release_configuration.rb
 - lib/models/release_rule.rb
 - lib/models/type_configuration.rb
+- lib/release/next_version_calculator.rb
 - sig/conventional_commit/branch_name_generator.rbs
 - sig/conventional_commits.rbs
 - sig/conventional_commits/branch_name_cli.rbs