fastlane-plugin-semantic_release 1.19.1 → 1.19.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28a273aa51b74e1a6013f2dd035a6db0d83cabec6f3f07c3bd59c92f426d2f67
-  data.tar.gz: 5c7e9fc6c6bbb295b1689334c94f2e41ac0010ab53292516380b41fae3a9fc40
+  metadata.gz: 01b27d55095447fde70e3e0d4c0ca215b7473cb123723e01e6022d5a55e065a0
+  data.tar.gz: 6d7b82296bad8e5d3655f8d428df731f3aaae1aa89ba12bd3e23b2183cafbeaa
 SHA512:
-  metadata.gz: 1ad7a7cc60d18602ae2bf76923fe1ab4a44435be39b4ba9db8845e47c7f7a10cb072104cbf5fda822268bd555bb75d9f0d09353b3dfded009bf7a92029f3b4d7
-  data.tar.gz: a6be6f39ded93ba158942e5e301c17b0c9873995be2f0ad0f69e0fd7e980e07212972fa86c33c0f1ca42328c1f751a5dbe1ba98cbbc4485a56b656a95e9880aa
+  metadata.gz: c031c797fd3b19df15f029dd09e17913b2d001b10ef1cd1ac89ccc12ac3b624d43139d3dba7a9a0cea8e35e3d883086c20332d78b8a255109ac1d90e2d1a3fe7
+  data.tar.gz: 33ceab41c2c7a0a192402c0dcd019fcf25346d3b65c3bf30f4f1f0cb5269da889c5be4a28b137cb5e646d60420890713dc4a258286d5e466f1d3797fdef3aa71

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

@@ -19,7 +19,6 @@ module Fastlane
 
     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 StandardError
@@ -42,29 +41,23 @@ module Fastlane
       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
           # Use tail -n 1 to handle repos with multiple root commits (e.g. merged histories)
-          UI.message("First commit of the branch is taken as a begining of next release")
+          UI.message("First commit of the branch is taken as a beginning of next release")
           return {
             hash: Actions.sh("#{git_command} | tail -n 1", log: params[:debug]).chomp
           }
         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
+        # git describe appends -<N>-g<hash> when HEAD is ahead of a tag.
+        # Use a regex to strip this specific suffix rather than splitting on
+        # dashes, which breaks when the tag itself contains dashes (e.g. v1.0.0-beta).
+        tag_name = tag.strip
+        tag_name = tag_name.sub(/-\d+-g[0-9a-f]+$/, '')
         parsed_version = tag_name.match(params[:tag_version_match])
 
         if parsed_version.nil?
@@ -72,18 +65,23 @@ module Fastlane
         end
 
         version = parsed_version[0]
-        # Get a hash of last version tag
-        hash = get_last_tag_hash(
-          tag_name: tag_name,
-          debug: params[:debug]
-        )
+        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
-        }
+        { hash: hash, version: version }
+      end
+
+      def self.bump_version(major, minor, patch, commit)
+        if commit[:release] == "major" || commit[:is_breaking_change]
+          [major + 1, 0, 0]
+        elsif commit[:release] == "minor"
+          [major, minor + 1, 0]
+        elsif commit[:release] == "patch"
+          [major, minor, patch + 1]
+        else
+          [major, minor, patch]
+        end
       end
 
       def self.clamp_version(next_major, next_minor, next_patch, base_major, base_minor, base_patch)
@@ -99,52 +97,37 @@ module Fastlane
       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('It could not find a beginning 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)')
+          UI.error('-- tell us explicitly 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
-
-        # Save base version for potential clamping
+        next_major, next_minor, next_patch = Helper::SemanticReleaseHelper.parse_semver(version)
         base_major = next_major
         base_minor = next_minor
         base_patch = next_patch
 
         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]
+        commits = get_commits_from_hash(hash: hash, debug: params[:debug])
+        UI.message("Found #{commits.length} commits since last release")
 
         format_pattern = lane_context[SharedValues::CONVENTIONAL_CHANGELOG_ACTION_FORMAT_PATTERN]
-        splitted.each do |line|
+        commits.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,
+            releases: params[:releases],
             pattern: format_pattern
           )
 
@@ -154,41 +137,25 @@ module Fastlane
             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_major, next_minor, next_patch = bump_version(next_major, next_minor, next_patch, commit)
+          is_next_version_compatible_with_codepush = false unless commit[:is_codepush_friendly]
 
           next_version = "#{next_major}.#{next_minor}.#{next_patch}"
           UI.message("#{next_version}: #{subject}") if params[:show_version_path]
         end
 
-        # When bump_per_commit is false, clamp to single increment
         unless params[:bump_per_commit]
           next_major, next_minor, next_patch = clamp_version(next_major, next_minor, next_patch, base_major, base_minor, base_patch)
         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
@@ -202,47 +169,30 @@ module Fastlane
 
       def self.is_codepush_friendly(params)
         git_command = "git rev-list --max-parents=0 HEAD"
-        # Begining of the branch is taken for codepush analysis
         # Use tail -n 1 to handle repos with multiple root commits (e.g. merged histories)
         hash = Actions.sh("#{git_command} | tail -n 1", log: params[:debug]).chomp
         next_major = 0
         next_minor = 0
         next_patch = 0
-        base_major = next_major
-        base_minor = next_minor
-        base_patch = next_patch
+        base_major = 0
+        base_minor = 0
+        base_patch = 0
         last_incompatible_codepush_version = '0.0.0'
 
-        # 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]
+        commits = get_commits_from_hash(hash: hash, debug: params[:debug])
 
         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)
+        commits.each do |line|
+          parts = line.split("|")
           commit = Helper::SemanticReleaseHelper.parse_commit(
-            commit_subject: line.split("|")[0],
-            commit_body: line.split("|")[1],
-            releases: releases,
+            commit_subject: parts[0],
+            commit_body: parts[1],
+            releases: params[:releases],
             pattern: format_pattern,
-            codepush_friendly: codepush_friendly
+            codepush_friendly: params[:codepush_friendly]
           )
 
-          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
+          next_major, next_minor, next_patch = bump_version(next_major, next_minor, next_patch, commit)
 
           unless commit[:is_codepush_friendly]
             last_incompatible_codepush_version = "#{next_major}.#{next_minor}.#{next_patch}"
@@ -268,7 +218,7 @@ module Fastlane
       #####################################################
 
       def self.description
-        "Finds a tag of last release and determinates version of next release"
+        "Finds a tag of last release and determines version of next release"
       end
 
       def self.details
@@ -276,9 +226,6 @@ module Fastlane
       end
 
       def self.available_options
-        # Define all options your action supports.
-
-        # Below a few examples
         [
           FastlaneCore::ConfigItem.new(
             key: :match,
@@ -372,11 +319,9 @@ module Fastlane
       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_HIGHER', 'True if next version is higher than 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.'],
@@ -390,17 +335,14 @@ module Fastlane
       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"
+        "Returns true if the next version is higher than 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

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

@@ -17,168 +17,115 @@ module Fastlane
       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]
-        )
+        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]
-
-        note_builder(format, parsed, version, commit_url, params)
+        note_builder(params[:format], parsed, version, params[:commit_url], params)
       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"
+          result = "#{style_text(title, format, 'title')}\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"
+          result += "#{style_text(sections[type.to_sym], format, 'heading')}\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 += " #{style_text("#{commit[:scope]}:", format, 'bold')}" unless commit[:scope].nil?
             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 += " (#{build_commit_link(commit, commit_url, format)})" if params[:display_links] == true
+            result += " - #{commit[:author_name]}" if params[:display_author]
             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"
+          result += "#{style_text('BREAKING CHANGES', format, 'heading')}\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 += "- #{commit[:breaking_change]}"
+            result += " (#{build_commit_link(commit, commit_url, format)})" if params[:display_links] == true
+            result += " - #{commit[:author_name]}" if params[:display_author]
             result += "\n"
           end
 
           result += "\n"
         end
 
-        # Trim any trailing newlines
         result.rstrip!
       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
+          case format
+          when "markdown" then "# #{text}"
+          when "slack" then "*#{text}*"
+          else text
           end
         when "heading"
-          if format == "markdown"
-            "### #{text}"
-          elsif format == "slack"
-            "*#{text}*"
-          else
-            "#{text}:"
+          case format
+          when "markdown" then "### #{text}"
+          when "slack" then "*#{text}*"
+          else "#{text}:"
           end
         when "bold"
-          if format == "markdown"
-            "**#{text}**"
-          elsif format == "slack"
-            "*#{text}*"
-          else
-            text
+          case format
+          when "markdown" then "**#{text}**"
+          when "slack" then "*#{text}*"
+          else text
           end
         else
-          text # catchall, shouldn't be needed
+          text
         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}"
+        url = "#{commit_url}/#{commit[:hash]}"
 
         case format
-        when "slack"
-          "<#{url}|#{short_hash}>"
-        when "markdown"
-          "[#{short_hash}](#{url})"
-        else
-          url
+        when "slack" then "<#{url}|#{short_hash}>"
+        when "markdown" then "[#{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("|")
+          parts = line.split("|")
 
           commit = Helper::SemanticReleaseHelper.parse_commit(
-            commit_subject: splitted[0],
-            commit_body: splitted[1],
+            commit_subject: parts[0],
+            commit_body: parts[1],
             pattern: format_pattern
           )
 
@@ -188,10 +135,10 @@ module Fastlane
             ignore_scopes: params[:ignore_scopes]
           )
 
-          commit[:hash] = splitted[2]
-          commit[:short_hash] = splitted[3]
-          commit[:author_name] = splitted[4]
-          commit[:commit_date] = splitted[5]
+          commit[:hash] = parts[2]
+          commit[:short_hash] = parts[3]
+          commit[:author_name] = parts[4]
+          commit[:commit_date] = parts[5]
 
           parsed.push(commit)
         end
@@ -212,9 +159,6 @@ module Fastlane
       end
 
       def self.available_options
-        # Define all options your action supports.
-
-        # Below a few examples
         [
           FastlaneCore::ConfigItem.new(
             key: :format,
@@ -301,23 +245,18 @@ module Fastlane
       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

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

@@ -5,16 +5,20 @@ module Fastlane
 
   module Helper
     class SemanticReleaseHelper
+      FORMAT_PATTERNS = {
+        "default" => /^(docs|fix|feat|chore|style|refactor|perf|test)(?:\((.*)\))?(!?): (.*)/i,
+        "angular" => /^(\w*)(?:\((.*)\))?(): (.*)/
+      }.freeze
+
       def self.format_patterns
-        return {
-          "default" => /^(docs|fix|feat|chore|style|refactor|perf|test)(?:\((.*)\))?(!?): (.*)/i,
-          "angular" => /^(\w*)(?:\((.*)\))?(): (.*)/
-        }
+        FORMAT_PATTERNS
+      end
+
+      def self.parse_semver(version_string)
+        parts = version_string.split('.')
+        [(parts[0] || 0).to_i, (parts[1] || 0).to_i, (parts[2] || 0).to_i]
       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
@@ -25,13 +29,10 @@ module Fastlane
         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
+        return !scopes_to_include.include?(commit_scope) unless scopes_to_include.empty?
+        return scopes_to_ignore.include?(commit_scope) unless commit_scope.nil?
 
-        unless commit_scope.nil?
-          return scopes_to_ignore.include?(commit_scope)
-        end
+        false
       end
 
       def self.parse_commit(params)
@@ -40,8 +41,6 @@ module Fastlane
         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 = {
@@ -51,67 +50,39 @@ module Fastlane
           type: 'no_type'
         }
 
-        unless matched.nil?
-          type = matched[1].downcase
-          scope = matched[2]
+        return result if matched.nil?
 
-          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
+        type = matched[1].downcase
+        result[:is_valid] = true
+        result[:type] = type
+        result[:scope] = matched[2]
+        result[:has_exclamation_mark] = matched[3] == '!'
+        result[:subject] = matched[4]
 
-          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
+        if result[:has_exclamation_mark]
+          result[:is_breaking_change] = true
+          result[:breaking_change] = matched[4]
         end
 
-        result
-      end
+        result[:release] = releases[type.to_sym] unless releases.nil?
+        result[:is_codepush_friendly] = codepush_friendly.include?(type) unless codepush_friendly.nil?
 
-      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
+        unless commit_body.nil?
+          breaking_match = commit_body.match(/BREAKING CHANGES?: (.*)/)
+          codepush_match = commit_body.match(/codepush?: (.*)/)
+
+          if breaking_match
+            result[:is_breaking_change] = true
+            result[:breaking_change] = breaking_match[1]
           end
+          result[:is_codepush_friendly] = (codepush_match[1] == 'ok') if codepush_match
         end
 
-        return false
+        result
       end
 
-      def self.semver_lt(first, second)
-        return !semver_gt(first, second)
+      def self.semver_gt(first, second)
+        (parse_semver(first) <=> parse_semver(second)) == 1
       end
     end
   end

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

@@ -1 +1 @@
-module Fastlane module SemanticRelease VERSION = "1.19.1" end end
+module Fastlane module SemanticRelease VERSION = "1.19.4" end end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-semantic_release
 version: !ruby/object:Gem::Version
-  version: 1.19.1
+  version: 1.19.4
 platform: ruby
 authors:
 - Jiří Otáhal