conventional_commits 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f94b502d6513ea200421a55aa11f6b4256fba4f97ca7151377102628b6c697a
-  data.tar.gz: d1e38a90cbbdafbd4225896a03a510511726587367184bfa2130e8327ce5e6c6
+  metadata.gz: 8ef389be49918b12a03941a89178003c8b6ba9962583516728948bb1c61d5557
+  data.tar.gz: e4e5c3dd45bb0e3c140b9519dcd76f432fc7812012402dde8a4a643da8318c9a
 SHA512:
-  metadata.gz: 687b3c6cffc0a5df6df27d8b872bb518fd893fc168210d4c59aee70eca79cdcf696efaf643635de37010b04535b0183d4f546e6accbc5772e7ef7ca0b759437e
-  data.tar.gz: a29267a2aae48205181b7e4553ada4577abc2927317a78bdbe44319460d3d5b582f81ba8224a695a299cdb922384486dbe5db6f106d2e1900016916d1815dc12
+  metadata.gz: d8435aa0ae03a4ab74880debbec1f7a925b39a972337a17432234f64907e97388b82d48692f58ac16f2d7566dd0f0d96e365ef2ef86940e5ea6372fd59eb5ad8
+  data.tar.gz: 5cc8f961cc6ce9296f0348fe6d200c53edbfb10996320065d3b3ae045125177204aa3a01a1be062b861c95561dc828e0c19236a1400bd0015f8d15f353df2971

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/cli/branch_name_cli.rb

@@ -70,6 +70,18 @@ module ConventionalCommits
       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
+
     desc "install_hooks", "install all git hooks"
     def install_hooks
       installer = ConventionalCommits::Configuration::HooksInstaller.new

data/lib/conventional_commits/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConventionalCommits
-  VERSION = "0.3.0"
+  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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conventional_commits
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Swift-Gurus
@@ -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