fastlane-plugin-semantic_versioning 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 85cd9cae201bc1df61f042591928d143e3be6b16f2118af031d8277872bb2602
+  data.tar.gz: a1bc72d14b4866bf874ff0f1ad0b47e965baa895bcfed5ded778120e17a66ec8
+SHA512:
+  metadata.gz: 51ea808a889665240814d26ce939f1c006c9bd03b6544a3a289e38afb460668dc51e4f723a4507b6a8f3a3112b71bb1bd407bfd2da5df513a22b085b3053337e
+  data.tar.gz: 0227ac5c1726f2e9954f9d272bb36e99fbf83af5280e7831ffb823ccd44ed32f1b5528c57188a4bd927956e9cdcbd7940183604369fcbcf6c95e830c1e9cd85c

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Karsten Silkenbäumer <993392+kassi@users.noreply.github.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# semantic_versioning plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-semantic_versioning)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-semantic_versioning`, add it to your project by running:
+
+```bash
+fastlane add_plugin semantic_versioning
+```
+
+## About semantic_versioning
+
+Version and changelog management following semantic versioning and conventional commits.
+
+The plugin provides two actions that have to be called in sequence, but therefore allow
+additional interaction with the results before an actual commit is being made.
+
+One example could be to get the version info for the upcoming release, and when this is
+successful, i.e. a version bump is possible, create a release branch with that version number and
+change to that branch before making any changes. Then call the `semantic_bump` action to create the commit on the release branch, before you may want to create a pull request for the new release.
+
+Hint: You can also use the context to upload the changelog to AppStoreConnect afterwards. See the example `Fastfile` for more info.
+
+### get_versioning_info
+
+Call this in your lane to prepare a bump according to the rules. It will
+- Determine next version number
+- Build the changelog for the upcoming version bump
+
+and provide this information in shared variables that are used in the second action.
+
+### semantic_bump
+
+Call this to actually bump the version, write the changelog and commit everything.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+bundle exec rake
+```
+
+To automatically fix many of the styling issues, use
+```
+bundle exec rubocop -a
+```
+
+Or to start fast feedback development cycle:
+```
+bundle exec guard
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/semantic_versioning/actions/get_versioning_info_action.rb

@@ -0,0 +1,127 @@
+require "fastlane/action"
+require "fastlane_core/configuration/config_item"
+require_relative "../helper/semantic_versioning_helper"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SEMVER_CURRENT_VERSION = :SEMVER_CURRENT_VERSION
+      SEMVER_CURRENT_TAG = :SEMVER_CURRENT_TAG
+      SEMVER_BUMP_TYPE = :SEMVER_BUMP_TYPE
+      SEMVER_NEW_VERSION = :SEMVER_NEW_VERSION
+      SEMVER_NEW_CHANGELOG = :SEMVER_NEW_CHANGELOG
+      SEMVER_BUMPABLE = :SEMVER_BUMPABLE
+    end
+
+    class GetVersioningInfoAction < Action
+      def self.run(params)
+        params[:allowed_types].map!(&:to_sym)
+        params[:bump_map].transform_keys!(&:to_sym)
+        params[:bump_map].transform_values!(&:to_sym)
+
+        UI.message("The semantic_versioning plugin is working!")
+
+        current_version = Helper::SemanticVersioningHelper.version_number
+        formatted_tag = Helper::SemanticVersioningHelper.formatted_tag(current_version, params[:tag_format])
+
+        commits = Helper::SemanticVersioningHelper.git_commits(
+          from: Helper::SemanticVersioningHelper.git_tag_exists?(formatted_tag) ? formatted_tag : nil,
+          allowed_types: params[:allowed_types]
+        )
+
+        bump_type = Helper::SemanticVersioningHelper.bump_type(commits: commits, bump_map: params[:bump_map])
+        new_version = Helper::SemanticVersioningHelper.increase_version(current_version: current_version, bump_type: bump_type)
+        new_changelog = Helper::SemanticVersioningHelper.build_changelog(version: new_version, commits: commits, type_map: params[:type_map])
+        bumpable = current_version != new_version
+
+        Actions.lane_context[SharedValues::SEMVER_CURRENT_VERSION] = current_version
+        Actions.lane_context[SharedValues::SEMVER_CURRENT_TAG] = formatted_tag
+        Actions.lane_context[SharedValues::SEMVER_BUMP_TYPE] = bump_type
+        Actions.lane_context[SharedValues::SEMVER_NEW_VERSION] = new_version
+        Actions.lane_context[SharedValues::SEMVER_NEW_CHANGELOG] = new_changelog
+        Actions.lane_context[SharedValues::SEMVER_BUMPABLE] = bumpable
+
+        return bumpable
+      end
+
+      def self.description
+        "Retrieve semantic versioning information from commit history."
+      end
+
+      def self.authors
+        ["kassi"]
+      end
+
+      def self.output
+        # Define the shared values you are going to provide
+        [
+          ["SEMVER_CURRENT_VERSION", "Current version of the project as provided"],
+          ["SEMVER_CURRENT_TAG", "Current tag for the current version number"],
+          ["SEMVER_BUMP_TYPE", "Type of version bump. One of major, minor, or patch"],
+          ["SEMVER_NEW_VERSION", "New version that would have to be set from current version and commits"],
+          ["SEMVER_NEW_CHANGELOG", "New changelog section for the new bump"],
+          ["SEMVER_BUMPABLE", "True if a version bump is possible"]
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        "Returns true, if the determined next version is higher than the current one."
+      end
+
+      def self.details
+        # Optional:
+        "Reads commits from last version and determines next version and changelog."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :allowed_types,
+                                       env_name: "SEMANTIC_VERSIONING_ALLOWED_TYPES",
+                                       description: "List of allowed commit types",
+                                       optional: true,
+                                       default_value: %w[build ci docs feat fix perf refactor style test chore revert bump init],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :bump_map,
+                                       description: "Map of commit types to their bump level (major, minor, patch)",
+                                       optional: true,
+                                       default_value: { breaking: :major, feat: :minor, fix: :patch },
+                                       is_string: false,
+                                       verify_block: ->(value) { verify_bump_map(value) }),
+          FastlaneCore::ConfigItem.new(key: :tag_format,
+                                       env_name: "SEMANTIC_VERSIONING_TAG_FORMAT",
+                                       description: "The format for the git tag",
+                                       optional: true,
+                                       default_value: "$version",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :type_map,
+                                       env_name: "SEMANTIC_VERSIONING_TYPE_MAP",
+                                       description: "Map of types to section titles for the changelog." \
+                                                    "Only the specified types will be used for the changelog",
+                                       optional: true,
+                                       default_value: { breaking: "BREAKING CHANGES", feat: "Features", fix: "Bug Fixes" },
+                                       is_string: false,
+                                       verify_block: ->(value) { verify_type_map(value) })
+        ]
+      end
+
+      def self.verify_type_map(value)
+        UI.user_error!("Parameter 'type_map' must be a Hash.") unless value.kind_of?(Hash)
+        # It could be helpful to also test for valid keys, which must all be part of ConfigItem :allowed_types plus breaking.
+        # How to check this?
+      end
+
+      def self.verify_bump_map(value)
+        UI.user_error!("Parameter 'bump_map' must be a Hash.") unless value.kind_of?(Hash)
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/semantic_versioning/actions/semantic_bump_action.rb

@@ -0,0 +1,86 @@
+require "fastlane/action"
+require_relative "../helper/semantic_versioning_helper"
+
+module Fastlane
+  module Actions
+    class SemanticBumpAction < Action
+      def self.run(params)
+        unless Actions.lane_context.key?(SharedValues::SEMVER_BUMPABLE)
+          UI.user_error!("No semver information found. Please run get_versioning_info beforehand.")
+        end
+
+        unless Actions.lane_context[SharedValues::SEMVER_BUMPABLE]
+          UI.message("No version bump detected.")
+          return false
+        end
+
+        version_number = Actions.lane_context[SharedValues::SEMVER_NEW_VERSION]
+        next_changelog = Actions.lane_context[SharedValues::SEMVER_NEW_CHANGELOG]
+
+        Fastlane::Actions::IncrementVersionNumberAction.run(version_number: version_number)
+
+        if params[:changelog_file]
+          Helper::SemanticVersioningHelper.write_changelog(
+            path: params[:changelog_file],
+            changelog: next_changelog
+          )
+        end
+
+        Fastlane::Actions::CommitVersionBumpAction.run(
+          message: Helper::SemanticVersioningHelper.bump_message(params[:bump_message]),
+          force: true,
+          include: [params[:changelog_file]].compact
+        )
+
+        return true
+      end
+
+      def self.description
+        "Bumps the version according to semantic versioning and writes a changelog."
+      end
+
+      def self.authors
+        ["kassi"]
+      end
+
+      def self.output
+        # Define the shared values you are going to provide
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        "Returns true when the bump was successful, false otherwise."
+      end
+
+      def self.details
+        # Optional:
+        "Reads commits from last version and determines next version and changelog."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :bump_message,
+                                       env_name: "SEMANTIC_VERSIONING_BUMP_MESSAGE",
+                                       description: "The commit mesage to use for the bump commit",
+                                       optional: true,
+                                       default_value: "version $current_version → $new_version",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :changelog_file,
+                                       env_name: "SEMANTIC_VERSIONING_CHANGELOG_FILE",
+                                       description: "Filename for the changelog",
+                                       optional: true,
+                                       default_value: "CHANGELOG.md",
+                                       type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/semantic_versioning/helper/semantic_versioning_helper.rb

@@ -0,0 +1,168 @@
+require "fastlane_core/ui/ui"
+require "fastlane/actions/get_version_number"
+require "git"
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class SemanticVersioningHelper
+      # class methods that you define here become available in your action
+      # as `Helper::SemanticVersioningHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the semantic_versioning plugin helper!")
+      end
+
+      def self.version_number
+        Actions::GetVersionNumberAction.run({})
+      end
+
+      def self.formatted_tag(tag, format)
+        format.sub("$version", tag)
+      end
+
+      def self.git_tag_exists?(tag)
+        git.tags.include?(tag)
+      end
+
+      # Retrieves git commits and returns them grouped by type
+      def self.git_commits(from:, allowed_types:)
+        logs = from ? git.log(-1).between(from) : git.log(-1)
+        logs.reverse_each.map do |commit|
+          parse_conventional_commit(commit: commit, allowed_types: allowed_types)
+        end.compact
+      end
+
+      def self.group_commits(commits:, allowed_types:)
+        result = allowed_types.to_h { |type| [type, []] }
+
+        commits.each do |commit|
+          if commit[:breaking] && allowed_types.include?(:breaking)
+            result[:breaking] << commit
+          end
+          next unless allowed_types.include?(commit[:type])
+
+          # If the breaking change is made from the actual feature subject, don't repeat it.
+          next if commit[:breaking] == commit[:subject]
+
+          result[commit[:type]] << commit
+        end
+
+        return result
+      end
+
+      def self.bump_type(commits:, bump_map:)
+        result = nil
+
+        commits.each do |commit|
+          bump_type = commit[:breaking] ? bump_map[:breaking] : bump_map[commit[:type]]
+          if bump_type == :major
+            return :major
+          elsif bump_type == :minor
+            result = :minor
+          elsif bump_type == :patch && result.nil?
+            result = :patch
+          end
+        end
+
+        return result
+      end
+
+      def self.parse_conventional_commit(commit:, allowed_types:)
+        types = allowed_types.join("|")
+        commit.message.match(/^(?<type>#{types})(\((?<scope>\S+)\))?(?<breaking>!)?:\s+(?<subject>[^\n\r]+)(\z|\n\n(?<body>.*\z))/m) do |match|
+          unless allowed_types.include?(match[:type].to_sym)
+            UI.important("Commit #{commit.sha} has invalid type: #{match[:type]}. Ignoring")
+            break
+          end
+
+          cc = {
+            type: match[:type].to_sym,
+            scope: match[:scope],
+            subject: match[:subject],
+            body: match[:body],
+            breaking: match[:breaking] ? match[:subject] : nil,
+            original_message: commit.message
+          }
+
+          match[:body]&.match(/^BREAKING CHANGE?: (.+)\z/) do |breaking|
+            cc[:breaking] = breaking[1]
+          end
+
+          return cc
+        end
+      end
+
+      def self.increase_version(current_version:, bump_type:)
+        version_array = current_version.split(".").map(&:to_i)
+
+        case bump_type
+        when :major
+          version_array[0] += 1
+          version_array[1] = version_array[2] = 0
+        when :minor
+          version_array[1] += 1
+          version_array[2] = 0
+        when :patch
+          version_array[2] += 1
+        end
+
+        return version_array.join(".")
+      end
+
+      # Builds and returns th changelog for the upcoming release.
+      def self.build_changelog(version:, commits:, type_map:, name: nil)
+        lines = []
+
+        title = [version, name, Time.now.strftime("(%F)")].compact.join(" ")
+        lines << "## #{title}"
+        lines << ""
+
+        grouped_commits = group_commits(commits: commits, allowed_types: type_map.keys)
+        grouped_commits.each do |key, section_commits|
+          next unless section_commits.any?
+
+          lines << "### #{type_map[key]}:"
+          lines << ""
+
+          section_commits.each do |commit|
+            lines << "- #{key == :breaking ? commit[:breaking] : commit[:subject]}"
+          end
+
+          lines << ""
+        end
+
+        return "#{lines.join("\n")}\n"
+      end
+
+      def self.write_changelog(path:, changelog:)
+        old_changelog = File.new(path).read if File.exist?(path)
+
+        File.open(path, "w") do |file|
+          file.write(changelog)
+          if old_changelog
+            file.write("\n")
+            file.write(old_changelog)
+          end
+        end
+      end
+
+      def self.bump_message(format)
+        format("bump: %s", format
+          .sub("$current_version", Actions.lane_context[Actions::SharedValues::SEMVER_CURRENT_VERSION])
+          .sub("$new_version", Actions.lane_context[Actions::SharedValues::SEMVER_NEW_VERSION]))
+      end
+
+      def self.git_command(args)
+        Actions.sh("git #{args.join(' ')}").chomp
+      end
+
+      def self.git
+        # rubocop:disable Style/ClassVars
+        @@git ||= Git.open(".")
+        # rubocop:enable Style/ClassVars
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/semantic_versioning/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module SemanticVersioning
+    VERSION = "1.0.0"
+  end
+end

data/lib/fastlane/plugin/semantic_versioning.rb

@@ -0,0 +1,16 @@
+require "fastlane/plugin/semantic_versioning/version"
+
+module Fastlane
+  module SemanticVersioning
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path("**/{actions,helper}/*.rb", File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::SemanticVersioning.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-semantic_versioning
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Karsten Silkenbäumer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email: 993392+kassi@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/semantic_versioning.rb
+- lib/fastlane/plugin/semantic_versioning/actions/get_versioning_info_action.rb
+- lib/fastlane/plugin/semantic_versioning/actions/semantic_bump_action.rb
+- lib/fastlane/plugin/semantic_versioning/helper/semantic_versioning_helper.rb
+- lib/fastlane/plugin/semantic_versioning/version.rb
+homepage: https://github.com/kassi/fastlane-plugin-semantic_versioning
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Version and changelog management following semver and conventional commits.
+test_files: []