round14tech-fastlane-plugin-semantic_release 1.18.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a44dd8584a29a30b4a37f07f3944770a63fc3e1989154e2301a62c41b197c1c2
+  data.tar.gz: cf3b381c668ebf33d008b21e7d7901d27940ec86c63a791b285d6cf4024e1c2c
+SHA512:
+  metadata.gz: f0a338632f66dba8757712b96e047402bbfff9a1f3ea432d11112246633255bf3c3fc5e29d1a560fbf1c4d774a59f0bc7d1b9b960fed8d0c2e2bbdcadc49cd05
+  data.tar.gz: 2d32cb1e2edc850575b5e14d96bef24e227ad2f009fbf52384ca1d21687e8cee220bf0fb3ae4dc80070313aceff8fe864309ed4fc9ffeb01a56ee46b47ba5bb5

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Jiří Otáhal <xotahal@gmail.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,92 @@
+# semantic_release plugin for `fastlane`
+
+[![CircleCI](https://circleci.com/gh/xotahal/fastlane-plugin-semantic_release.svg?style=svg)](https://circleci.com/gh/xotahal/fastlane-plugin-semantic_release) [![License](https://img.shields.io/github/license/SiarheiFedartsou/fastlane-plugin-versioning.svg)](https://github.com/SiarheiFedartsou/fastlane-plugin-versioning/blob/master/LICENSE) [![Gem Version](https://badge.fury.io/rb/fastlane-plugin-semantic_release.svg)](https://badge.fury.io/rb/fastlane-plugin-semantic_release) [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-versioning)
+
+## Getting Started
+
+```
+fastlane add_plugin semantic_release
+```
+
+## About
+
+Automated version managment and generator of release notes. Inspired by [semantic-release](https://github.com/semantic-release/semantic-release) for npm packages. Based on [conventional commits](https://www.conventionalcommits.org/).
+
+### Articles
+
+[Semantic Release for Fastlane](https://medium.com/@xotahal/semantic-release-for-fastlane-781df4cf5888?source=friends_link&sk=5c02e32daca7a68539e27e0e1bac1092) @ Medium - By Jiri Otahal
+
+## Available Actions
+
+### `conventional_changelog`
+
+- parses all commits since last version
+- groups those commits by their type (fix, feat, docs, refactor, chore, etc)
+- and creates formated release notes either in markdown or in slack format
+
+Available parameters:
+
+- `format: 'slack|markdown|plain'` (defaults to `markdown`). This formats the changelog for the destination you need. If you're using this for TestFlight changelogs, we suggest using the `plain` option
+- `title: 'My Title'` - is appended to the release notes title, "1.1.8 My Title (YYYY-MM-DD)"
+- `display_title: true|false` (defaults to true) - allows you to hide the entire first line of the changelog
+- `display_links: true|false` (defaults to true) - allows you to hide links to commits from your changelog
+- `commit_url: 'https://github.com/username/repository/commit'` - prepended to the commit ID to build usable links
+- View other options by searching for `available_options` in `conventional_changelog.rb`
+
+Example:
+
+```
+notes = conventional_changelog(format: 'slack', title: 'Android Alpha')
+```
+
+<img src="https://raw.githubusercontent.com/xotahal/fastlane-plugin-semantic_release/master/docs/Changelog.png" />
+
+### `analyze_commits`
+
+- analyzes your git history
+- finds last tag on current branch (for example ios/beta/1.3.2)
+- parses the last version from tag (1.3.2)
+- gets all commits since this tag
+- analyzes subject of every single commit and increases version number if there is a need (check conventional commit rules)
+- if next version number is higher then last version number it will recommend you to release this version
+
+Options:
+
+- `ignore_scopes: ['android','windows']`: allows you to ignore any commits which include a given scope, like this one: `feat(android): add functionality not relevant to the release we are producing`
+
+Example usage:
+
+```
+isReleasable = analyze_commits(match: 'ios/beta*')
+```
+
+It provides these variables in `lane_context`.
+
+```
+['RELEASE_ANALYZED', 'True if commits were analyzed.'],
+['RELEASE_IS_NEXT_VERSION_HIGHER', 'True if next version is higher then last version'],
+['RELEASE_LAST_TAG_HASH', 'Hash of commit that is tagged as a last version'],
+['RELEASE_LAST_VERSION', 'Last version number - parsed from last tag.'],
+['RELEASE_NEXT_MAJOR_VERSION', 'Major number of the next version'],
+['RELEASE_NEXT_MINOR_VERSION', 'Minor number of the next version'],
+['RELEASE_NEXT_PATCH_VERSION', 'Patch number of the next version'],
+['RELEASE_NEXT_VERSION', 'Next version string in format (major.minor.patch)'],
+```
+
+And you can access these like this:
+
+`next_version = lane_context[SharedValues::RELEASE_NEXT_VERSION]`
+
+<img src="https://raw.githubusercontent.com/xotahal/fastlane-plugin-semantic_release/master/docs/Analyze.png" />
+
+## Tests
+
+To run the test suite (contained in `./spec`), call `bundle exec rake`
+
+## Questions
+
+If you need anything ping us on [twitter](http://bit.ly/t-xotahal).
+
+| Jiri Otahal                                                                                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------- |
+| [<img src="https://avatars3.githubusercontent.com/u/3531955?v=4" width="100px;" style="border-radius:50px"/>](http://bit.ly/t-xotahal) |

data/lib/fastlane/plugin/semantic_release/actions/analyze_commits.rb

@@ -0,0 +1,400 @@
+require 'fastlane/action'
+require_relative '../helper/semantic_release_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      RELEASE_ANALYZED = :RELEASE_ANALYZED
+      RELEASE_IS_NEXT_VERSION_HIGHER = :RELEASE_IS_NEXT_VERSION_HIGHER
+      RELEASE_IS_NEXT_VERSION_COMPATIBLE_WITH_CODEPUSH = :RELEASE_IS_NEXT_VERSION_COMPATIBLE_WITH_CODEPUSH
+      RELEASE_LAST_TAG_HASH = :RELEASE_LAST_TAG_HASH
+      RELEASE_LAST_VERSION = :RELEASE_LAST_VERSION
+      RELEASE_NEXT_MAJOR_VERSION = :RELEASE_NEXT_MAJOR_VERSION
+      RELEASE_NEXT_MINOR_VERSION = :RELEASE_NEXT_MINOR_VERSION
+      RELEASE_NEXT_PATCH_VERSION = :RELEASE_NEXT_PATCH_VERSION
+      RELEASE_NEXT_VERSION = :RELEASE_NEXT_VERSION
+      RELEASE_LAST_INCOMPATIBLE_CODEPUSH_VERSION = :RELEASE_LAST_INCOMPATIBLE_CODEPUSH_VERSION
+      CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN = :CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN
+    end
+
+    class AnalyzeCommitsAction < Action
+      def self.get_last_tag(params)
+        # Try to find the tag
+        command = "git describe --tags --match=#{params[:match]}"
+        Actions.sh(command, log: params[:debug])
+      rescue
+        UI.message("Tag was not found for match pattern - #{params[:match]}")
+        ''
+      end
+
+      def self.get_last_tag_hash(params)
+        command = "git rev-list -n 1 refs/tags/#{params[:tag_name]}"
+        Actions.sh(command, log: params[:debug]).chomp
+      end
+
+      def self.get_commits_from_hash(params)
+        commits = Helper::SemanticReleaseHelper.git_log(
+          pretty: '%s|%b|>',
+          start: params[:hash],
+          debug: params[:debug]
+        )
+        commits.split("|>")
+      end
+
+      def self.get_beginning_of_next_sprint(params)
+        # command to get first commit
+        git_command = "git rev-list --max-parents=0 HEAD"
+
+        tag = get_last_tag(match: params[:match], debug: params[:debug])
+
+        # if tag doesn't exist it get's first commit or fallback tag (v*.*.*)
+        if tag.empty?
+          UI.message("It couldn't match tag for #{params[:match]}. Check if first commit can be taken as a beginning of next release")
+          # If there is no tag found we taking the first commit of current branch
+          hash_lines = Actions.sh("#{git_command} | wc -l", log: params[:debug]).chomp
+
+          if hash_lines.to_i == 1
+            UI.message("First commit of the branch is taken as a begining of next release")
+            return {
+              # here we know this command will return 1 line
+              hash: Actions.sh(git_command, log: params[:debug]).chomp
+            }
+          end
+
+          unless params[:prevent_tag_fallback]
+            # neither matched tag and first hash could be used - as fallback we try vX.Y.Z
+            UI.message("It couldn't match tag for #{params[:match]} and couldn't use first commit. Check if tag vX.Y.Z can be taken as a begining of next release")
+            tag = get_last_tag(match: "v*", debug: params[:debug])
+          end
+
+          # even fallback tag doesn't work
+          if tag.empty?
+            return false
+          end
+        end
+
+        # Tag's format is v2.3.4-5-g7685948
+        # See git describe man page for more info
+        # It can be also v2.3.4-5 if there is no commit after tag
+        tag_name = tag
+        if tag.split('-').length >= 3
+          tag_name = tag.split('-')[0...-2].join('-').strip
+        end
+        parsed_version = tag_name.match(params[:tag_version_match])
+
+        if parsed_version.nil?
+          UI.user_error!("Error while parsing version from tag #{tag_name} by using tag_version_match - #{params[:tag_version_match]}. Please check if the tag contains version as you expect and if you are using single brackets for tag_version_match parameter.")
+        end
+
+        version = parsed_version[0]
+        # Get a hash of last version tag
+        hash = get_last_tag_hash(
+          tag_name: tag_name,
+          debug: params[:debug]
+        )
+
+        UI.message("Found a tag #{tag_name} associated with version #{version}")
+
+        return {
+          hash: hash,
+          version: version
+        }
+      end
+
+      def self.is_releasable(params)
+        # Hash of the commit where is the last version
+        beginning = get_beginning_of_next_sprint(params)
+
+        unless beginning
+          UI.error('It could not find a begining of this sprint. How to fix this:')
+          UI.error('-- ensure there is only one commit with --max-parents=0 (this command should return one line: "git rev-list --max-parents=0 HEAD")')
+          UI.error('-- tell us explicitely where the release starts by adding tag like this: vX.Y.Z (where X.Y.Z is version from which it starts computing next version number)')
+          return false
+        end
+
+        # Default last version
+        version = beginning[:version] || '0.0.0'
+        # If the tag is not found we are taking HEAD as reference
+        hash = beginning[:hash] || 'HEAD'
+
+        # converts last version string to the int numbers
+        next_major = (version.split('.')[0] || 0).to_i
+        next_minor = (version.split('.')[1] || 0).to_i
+        next_patch = (version.split('.')[2] || 0).to_i
+
+        is_next_version_compatible_with_codepush = true
+
+        # Get commits log between last version and head
+        splitted = get_commits_from_hash(
+          hash: hash,
+          debug: params[:debug]
+        )
+
+        UI.message("Found #{splitted.length} commits since last release")
+        releases = params[:releases]
+
+        format_pattern = lane_context[SharedValues::CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN]
+        splitted.each do |line|
+          parts = line.split("|")
+          subject = parts[0].to_s.strip
+          # conventional commits are in format
+          # type: subject (fix: app crash - for example)
+          commit = Helper::SemanticReleaseHelper.parse_commit(
+            commit_subject: subject,
+            commit_body: parts[1],
+            releases: releases,
+            pattern: format_pattern
+          )
+
+          next if Helper::SemanticReleaseHelper.should_exclude_commit(
+            commit_scope: commit[:scope],
+            include_scopes: params[:include_scopes],
+            ignore_scopes: params[:ignore_scopes]
+          )
+
+          if commit[:release] == "major" || commit[:is_breaking_change]
+            next_major += 1
+            next_minor = 0
+            next_patch = 0
+          elsif commit[:release] == "minor"
+            next_minor += 1
+            next_patch = 0
+          elsif commit[:release] == "patch"
+            next_patch += 1
+          end
+
+          unless commit[:is_codepush_friendly]
+            is_next_version_compatible_with_codepush = false
+          end
+
+          next_version = "#{next_major}.#{next_minor}.#{next_patch}"
+          UI.message("#{next_version}: #{subject}") if params[:show_version_path]
+        end
+
+        next_version = "#{next_major}.#{next_minor}.#{next_patch}"
+
+        is_next_version_releasable = Helper::SemanticReleaseHelper.semver_gt(next_version, version)
+
+        Actions.lane_context[SharedValues::RELEASE_ANALYZED] = true
+        Actions.lane_context[SharedValues::RELEASE_IS_NEXT_VERSION_HIGHER] = is_next_version_releasable
+        Actions.lane_context[SharedValues::RELEASE_IS_NEXT_VERSION_COMPATIBLE_WITH_CODEPUSH] = is_next_version_compatible_with_codepush
+        # Last release analysis
+        Actions.lane_context[SharedValues::RELEASE_LAST_TAG_HASH] = hash
+        Actions.lane_context[SharedValues::RELEASE_LAST_VERSION] = version
+        # Next release analysis
+        Actions.lane_context[SharedValues::RELEASE_NEXT_MAJOR_VERSION] = next_major
+        Actions.lane_context[SharedValues::RELEASE_NEXT_MINOR_VERSION] = next_minor
+        Actions.lane_context[SharedValues::RELEASE_NEXT_PATCH_VERSION] = next_patch
+        Actions.lane_context[SharedValues::RELEASE_NEXT_VERSION] = next_version
+
+        success_message = "Next version (#{next_version}) is higher than last version (#{version}). This version should be released."
+        UI.success(success_message) if is_next_version_releasable
+
+        is_next_version_releasable
+      end
+
+      def self.is_codepush_friendly(params)
+        git_command = "git rev-list --max-parents=0 HEAD"
+        # Begining of the branch is taken for codepush analysis
+        hash_lines = Actions.sh("#{git_command} | wc -l", log: params[:debug]).chomp
+        hash = Actions.sh(git_command, log: params[:debug]).chomp
+        next_major = 0
+        next_minor = 0
+        next_patch = 0
+        last_incompatible_codepush_version = '0.0.0'
+
+        if hash_lines.to_i > 1
+          UI.error("#{git_command} resulted to more than 1 hash")
+          UI.error('This usualy happens when you pull only part of a git history. Check out how you pull the repo! "git fetch" should be enough.')
+          Actions.sh(git_command, log: true).chomp
+          return false
+        end
+
+        # Get commits log between last version and head
+        splitted = get_commits_from_hash(
+          hash: hash,
+          debug: params[:debug]
+        )
+        releases = params[:releases]
+        codepush_friendly = params[:codepush_friendly]
+
+        format_pattern = lane_context[SharedValues::CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN]
+        splitted.each do |line|
+          # conventional commits are in format
+          # type: subject (fix: app crash - for example)
+          commit = Helper::SemanticReleaseHelper.parse_commit(
+            commit_subject: line.split("|")[0],
+            commit_body: line.split("|")[1],
+            releases: releases,
+            pattern: format_pattern,
+            codepush_friendly: codepush_friendly
+          )
+
+          next if Helper::SemanticReleaseHelper.should_exclude_commit(
+            commit_scope: commit[:scope],
+            include_scopes: params[:include_scopes],
+            ignore_scopes: params[:ignore_scopes]
+          )
+
+          if commit[:release] == "major" || commit[:is_breaking_change]
+            next_major += 1
+            next_minor = 0
+            next_patch = 0
+          elsif commit[:release] == "minor"
+            next_minor += 1
+            next_patch = 0
+          elsif commit[:release] == "patch"
+            next_patch += 1
+          end
+
+          unless commit[:is_codepush_friendly]
+            last_incompatible_codepush_version = "#{next_major}.#{next_minor}.#{next_patch}"
+          end
+        end
+
+        Actions.lane_context[SharedValues::RELEASE_LAST_INCOMPATIBLE_CODEPUSH_VERSION] = last_incompatible_codepush_version
+      end
+
+      def self.run(params)
+        is_next_version_releasable = is_releasable(params)
+        is_codepush_friendly(params)
+
+        is_next_version_releasable
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Finds a tag of last release and determinates version of next release"
+      end
+
+      def self.details
+        "This action will find a last release tag and analyze all commits since the tag. It uses conventional commits. Every time when commit is marked as fix or feat it will increase patch or minor number (you can setup this default behaviour). After all it will suggest if the version should be released or not."
+      end
+
+      def self.available_options
+        # Define all options your action supports.
+
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :match,
+            description: "Match parameter of git describe. See man page of git describe for more info",
+            verify_block: proc do |value|
+              UI.user_error!("No match for analyze_commits action given, pass using `match: 'expr'`") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :commit_format,
+            description: "The commit format to apply. Presets are 'default' or 'angular', or you can provide your own Regexp. Note: the supplied regex _must_ have 4 capture groups, in order: type, scope, has_exclamation_mark, and subject",
+            default_value: "default",
+            is_string: false,
+            verify_block: proc do |value|
+              case value
+              when String
+                unless Helper::SemanticReleaseHelper.format_patterns.key?(value)
+                  UI.user_error!("Invalid format preset: #{value}")
+                end
+
+                pattern = Helper::SemanticReleaseHelper.format_patterns[value]
+              when Regexp
+                pattern = value
+              else
+                UI.user_error!("Invalid option type: #{value.inspect}")
+              end
+              Actions.lane_context[SharedValues::CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN] = pattern
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :releases,
+            description: "Map types of commit to release (major, minor, patch)",
+            default_value: { fix: "patch", feat: "minor" },
+            type: Hash
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :codepush_friendly,
+            description: "These types are consider as codepush friendly automatically",
+            default_value: ["chore", "test", "docs"],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :tag_version_match,
+            description: "To parse version number from tag name",
+            default_value: '\d+\.\d+\.\d+'
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :prevent_tag_fallback,
+            description: "Prevent tag from falling back to vX.Y.Z when there is no match",
+            default_value: false,
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :include_scopes,
+            description: "To only include certain scopes when calculating releases",
+            default_value: [],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :ignore_scopes,
+            description: "To ignore certain scopes when calculating releases",
+            default_value: [],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :show_version_path,
+            description: "True if you want to print out the version calculated for each commit",
+            default_value: true,
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :debug,
+            description: "True if you want to log out a debug info",
+            default_value: false,
+            type: Boolean,
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+        # Define the shared values you are going to provide
+        # Example
+        [
+          ['RELEASE_ANALYZED', 'True if commits were analyzed.'],
+          ['RELEASE_IS_NEXT_VERSION_HIGHER', 'True if next version is higher then last version'],
+          ['RELEASE_IS_NEXT_VERSION_COMPATIBLE_WITH_CODEPUSH', 'True if next version is compatible with codepush'],
+          ['RELEASE_LAST_TAG_HASH', 'Hash of commit that is tagged as a last version'],
+          ['RELEASE_LAST_VERSION', 'Last version number - parsed from last tag.'],
+          ['RELEASE_NEXT_MAJOR_VERSION', 'Major number of the next version'],
+          ['RELEASE_NEXT_MINOR_VERSION', 'Minor number of the next version'],
+          ['RELEASE_NEXT_PATCH_VERSION', 'Patch number of the next version'],
+          ['RELEASE_NEXT_VERSION', 'Next version string in format (major.minor.patch)'],
+          ['RELEASE_LAST_INCOMPATIBLE_CODEPUSH_VERSION', 'Last commit without codepush'],
+          ['CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN', 'The format pattern Regexp used to match commits (mainly for internal use)']
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        "Returns true if the next version is higher then the last version"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["xotahal"]
+      end
+
+      def self.is_supported?(platform)
+        # you can do things like
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/semantic_release/actions/conventional_changelog.rb

@@ -0,0 +1,328 @@
+require 'fastlane/action'
+require_relative '../helper/semantic_release_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class ConventionalChangelogAction < Action
+      def self.get_commits_from_hash(params)
+        commits = Helper::SemanticReleaseHelper.git_log(
+          pretty: '%s|%b|%H|%h|%an|%at|>',
+          start: params[:hash],
+          debug: params[:debug]
+        )
+        commits.split("|>")
+      end
+
+      def self.run(params)
+        # Get next version number from shared values
+        analyzed = lane_context[SharedValues::RELEASE_ANALYZED]
+
+        # If analyze commits action was not run there will be no version in shared
+        # values. We need to run the action to get next version number
+        unless analyzed
+          UI.user_error!("Release hasn't been analyzed yet. Run analyze_commits action first please.")
+          # version = other_action.analyze_commits(match: params[:match])
+        end
+
+        last_tag_hash = lane_context[SharedValues::RELEASE_LAST_TAG_HASH]
+        version = lane_context[SharedValues::RELEASE_NEXT_VERSION]
+
+        # Get commits log between last version and head
+        commits = get_commits_from_hash(
+          hash: last_tag_hash,
+          debug: params[:debug]
+        )
+        parsed = parse_commits(commits, params)
+
+        commit_url = params[:commit_url]
+        format = params[:format]
+
+        result = note_builder(format, parsed, version, commit_url, params)
+
+        result
+      end
+
+      def self.note_builder(format, commits, version, commit_url, params)
+        sections = params[:sections]
+
+        result = ""
+
+        # Begining of release notes
+        if params[:display_title] == true
+          title = version
+          title += " #{params[:title]}" if params[:title]
+          title += " (#{Date.today})"
+
+          result = style_text(title, format, "title").to_s
+          result += "\n\n"
+        end
+
+        params[:order].each do |type|
+          # write section only if there is at least one commit
+          next if commits.none? { |commit| commit[:type] == type }
+
+          result += style_text(sections[type.to_sym], format, "heading").to_s
+          result += "\n"
+
+          commits.each do |commit|
+            next if commit[:type] != type || commit[:is_merge]
+
+            result += "-"
+
+            unless commit[:scope].nil?
+              formatted_text = style_text("#{commit[:scope]}:", format, "bold").to_s
+              result += " #{formatted_text}"
+            end
+
+            result += " #{commit[:subject]}"
+
+            if params[:display_links] == true
+              styled_link = build_commit_link(commit, commit_url, format).to_s
+              result += " (#{styled_link})"
+            end
+
+            if params[:display_author]
+              result += " - #{commit[:author_name]}"
+            end
+
+            result += "\n"
+          end
+          result += "\n"
+        end
+
+        if commits.any? { |commit| commit[:is_breaking_change] == true }
+          result += style_text("BREAKING CHANGES", format, "heading").to_s
+          result += "\n"
+
+          commits.each do |commit|
+            next unless commit[:is_breaking_change]
+            result += "- #{commit[:breaking_change]}" # This is the only unique part of this loop
+
+            if params[:display_links] == true
+              styled_link = build_commit_link(commit, commit_url, format).to_s
+              result += " (#{styled_link})"
+            end
+
+            if params[:display_author]
+              result += " - #{commit[:author_name]}"
+            end
+
+            result += "\n"
+          end
+
+          result += "\n"
+        end
+
+        # Trim any trailing newlines
+        result = result.rstrip!
+
+        result
+      end
+
+      def self.style_text(text, format, style)
+        # formats the text according to the style we're looking to use
+
+        # Skips all styling
+        case style
+        when "title"
+          if format == "markdown"
+            "# #{text}"
+          elsif format == "slack"
+            "*#{text}*"
+          else
+            text
+          end
+        when "heading"
+          if format == "markdown"
+            "### #{text}"
+          elsif format == "slack"
+            "*#{text}*"
+          else
+            "#{text}:"
+          end
+        when "bold"
+          if format == "markdown"
+            "**#{text}**"
+          elsif format == "slack"
+            "*#{text}*"
+          else
+            text
+          end
+        else
+          text # catchall, shouldn't be needed
+        end
+      end
+
+      def self.build_commit_link(commit, commit_url, format)
+        # formats the link according to the output format we need
+        short_hash = commit[:short_hash]
+        hash = commit[:hash]
+        url = "#{commit_url}/#{hash}"
+
+        case format
+        when "slack"
+          "<#{url}|#{short_hash}>"
+        when "markdown"
+          "[#{short_hash}](#{url})"
+        else
+          url
+        end
+      end
+
+      def self.parse_commits(commits, params)
+        parsed = []
+        # %s|%b|%H|%h|%an|%at
+        format_pattern = lane_context[SharedValues::CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN]
+        commits.each do |line|
+          splitted = line.split("|")
+
+          commit = Helper::SemanticReleaseHelper.parse_commit(
+            commit_subject: splitted[0],
+            commit_body: splitted[1],
+            pattern: format_pattern
+          )
+
+          next if Helper::SemanticReleaseHelper.should_exclude_commit(
+            commit_scope: commit[:scope],
+            include_scopes: params[:include_scopes],
+            ignore_scopes: params[:ignore_scopes]
+          )
+
+          commit[:hash] = splitted[2]
+          commit[:short_hash] = splitted[3]
+          commit[:author_name] = splitted[4]
+          commit[:commit_date] = splitted[5]
+
+          parsed.push(commit)
+        end
+
+        parsed
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Get commits since last version and generates release notes"
+      end
+
+      def self.details
+        "Uses conventional commits. It groups commits by their types and generates release notes in markdown or slack format."
+      end
+
+      def self.available_options
+        # Define all options your action supports.
+
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :format,
+            description: "You can use either markdown, slack or plain",
+            default_value: "markdown",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :title,
+            description: "Title for release notes",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :commit_url,
+            description: "Uses as a link to the commit",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :order,
+            description: "You can change the order of groups in release notes",
+            default_value: ["feat", "fix", "refactor", "perf", "chore", "test", "docs", "no_type"],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :sections,
+            description: "Map type to section title",
+            default_value: {
+              feat: "Features",
+              fix: "Bug fixes",
+              refactor: "Code refactoring",
+              perf: "Performance improvements",
+              chore: "Building system",
+              test: "Testing",
+              docs: "Documentation",
+              no_type: "Other work"
+            },
+            type: Hash,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :display_author,
+            description: "Whether you want to show the author of the commit",
+            default_value: false,
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :display_title,
+            description: "Whether you want to hide the title/header with the version details at the top of the changelog",
+            default_value: true,
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :display_links,
+            description: "Whether you want to display the links to commit IDs",
+            default_value: true,
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :include_scopes,
+            description: "To only include certain scopes when calculating releases",
+            default_value: [],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :ignore_scopes,
+            description: "To ignore certain scopes when calculating releases",
+            default_value: [],
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :debug,
+            description: "True if you want to log out a debug info",
+            default_value: false,
+            type: Boolean,
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+        # Define the shared values you are going to provide
+        # Example
+        []
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        "Returns generated release notes as a string"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["xotahal"]
+      end
+
+      def self.is_supported?(platform)
+        # you can do things like
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/semantic_release/helper/semantic_release_helper.rb

@@ -0,0 +1,118 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class SemanticReleaseHelper
+      def self.format_patterns
+        return {
+          "default" => /^(docs|fix|feat|chore|style|refactor|perf|test)(?:\((.*)\))?(!?)\: (.*)/,
+          "angular" => /^(\w*)(?:\((.*)\))?(): (.*)/
+        }
+      end
+
+      # class methods that you define here become available in your action
+      # as `Helper::SemanticReleaseHelper.your_method`
+      #
+      def self.git_log(params)
+        command = "git log --pretty='#{params[:pretty]}' --reverse #{params[:start]}..HEAD"
+        Actions.sh(command, log: params[:debug]).chomp
+      end
+
+      def self.should_exclude_commit(params)
+        commit_scope = params[:commit_scope]
+        scopes_to_include = params[:include_scopes]
+        scopes_to_ignore = params[:ignore_scopes]
+
+        unless scopes_to_include.empty?
+          return !scopes_to_include.include?(commit_scope)
+        end
+
+        unless commit_scope.nil?
+          return scopes_to_ignore.include?(commit_scope)
+        end
+      end
+
+      def self.parse_commit(params)
+        commit_subject = params[:commit_subject].to_s.strip
+        commit_body = params[:commit_body]
+        releases = params[:releases]
+        codepush_friendly = params[:codepush_friendly]
+        pattern = params[:pattern]
+        breaking_change_pattern = /BREAKING CHANGES?: (.*)/
+        codepush_pattern = /codepush?: (.*)/
+
+        matched = commit_subject.match(pattern)
+        result = {
+          is_valid: false,
+          subject: commit_subject,
+          is_merge: !(commit_subject =~ /^Merge/).nil?,
+          type: 'no_type'
+        }
+
+        unless matched.nil?
+          type = matched[1]
+          scope = matched[2]
+
+          result[:is_valid] = true
+          result[:type] = type
+          result[:scope] = scope
+          result[:has_exclamation_mark] = matched[3] == '!'
+          result[:subject] = matched[4]
+
+          unless releases.nil?
+            result[:release] = releases[type.to_sym]
+          end
+          unless codepush_friendly.nil?
+            result[:is_codepush_friendly] = codepush_friendly.include?(type)
+          end
+
+          unless commit_body.nil?
+            breaking_change_matched = commit_body.match(breaking_change_pattern)
+            codepush_matched = commit_body.match(codepush_pattern)
+
+            unless breaking_change_matched.nil?
+              result[:is_breaking_change] = true
+              result[:breaking_change] = breaking_change_matched[1]
+            end
+            unless codepush_matched.nil?
+              result[:is_codepush_friendly] = codepush_matched[1] == 'ok'
+            end
+          end
+        end
+
+        result
+      end
+
+      def self.semver_gt(first, second)
+        first_major = (first.split('.')[0] || 0).to_i
+        first_minor = (first.split('.')[1] || 0).to_i
+        first_patch = (first.split('.')[2] || 0).to_i
+
+        second_major = (second.split('.')[0] || 0).to_i
+        second_minor = (second.split('.')[1] || 0).to_i
+        second_patch = (second.split('.')[2] || 0).to_i
+
+        # Check if next version is higher then last version
+        if first_major > second_major
+          return true
+        elsif first_major == second_major
+          if first_minor > second_minor
+            return true
+          elsif first_minor == second_minor
+            if first_patch > second_patch
+              return true
+            end
+          end
+        end
+
+        return false
+      end
+
+      def self.semver_lt(first, second)
+        return !semver_gt(first, second)
+      end
+    end
+  end
+end

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

@@ -0,0 +1 @@
+module Fastlane module SemanticRelease VERSION = "1.18.3" end end

data/lib/fastlane/plugin/semantic_release.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/semantic_release/version'
+
+module Fastlane
+  module SemanticRelease
+    # 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::SemanticRelease.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: round14tech-fastlane-plugin-semantic_release
+version: !ruby/object:Gem::Version
+  version: 1.18.3
+platform: ruby
+authors:
+- Jiří Otáhal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.117.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.117.1
+description: 
+email: xotahal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/semantic_release.rb
+- lib/fastlane/plugin/semantic_release/actions/analyze_commits.rb
+- lib/fastlane/plugin/semantic_release/actions/conventional_changelog.rb
+- lib/fastlane/plugin/semantic_release/helper/semantic_release_helper.rb
+- lib/fastlane/plugin/semantic_release/version.rb
+homepage: https://github.com/xotahal/fastlane-plugin-semantic_release
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: Automated version managment and generator of release notes.
+test_files: []