fastlane-plugin-semantic_versioning 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85cd9cae201bc1df61f042591928d143e3be6b16f2118af031d8277872bb2602
-  data.tar.gz: a1bc72d14b4866bf874ff0f1ad0b47e965baa895bcfed5ded778120e17a66ec8
+  metadata.gz: 1205dbf528eadda53b7561ee36d93418c9f12fd7e5b8baa1f93f3f338411baa8
+  data.tar.gz: e083a5c015ecd318254c853589dc9233aa3e86b3da96699ebeaeecf95c2630f7
 SHA512:
-  metadata.gz: 51ea808a889665240814d26ce939f1c006c9bd03b6544a3a289e38afb460668dc51e4f723a4507b6a8f3a3112b71bb1bd407bfd2da5df513a22b085b3053337e
-  data.tar.gz: 0227ac5c1726f2e9954f9d272bb36e99fbf83af5280e7831ffb823ccd44ed32f1b5528c57188a4bd927956e9cdcbd7940183604369fcbcf6c95e830c1e9cd85c
+  metadata.gz: 03b8bd862f3f5ef41791fd214864ac6d15c3928fe6e1fbf27acdb817619c6d3acae71b98c66b342a34d978795172e429fa7b0849e22313273fdbeac27a2fc4b5
+  data.tar.gz: c5efd5ec4a7f1e73150f105d6f82a0c54aa52926d694224286ce64fb38f5614abb916b25fb2c2933ad099bc843bad6e01f5ead837a9cacf980a3a321c811e6c9

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fastlane/action"
 require "fastlane_core/configuration/config_item"
 require_relative "../helper/semantic_versioning_helper"
@@ -13,11 +15,13 @@ module Fastlane
       SEMVER_BUMPABLE = :SEMVER_BUMPABLE
     end
 
+    # Action to retrieve semantic versioning information from commit history.
     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)
+        params[:force_type] = params[:force_type]&.to_sym
 
         UI.message("The semantic_versioning plugin is working!")
 
@@ -26,12 +30,15 @@ module Fastlane
 
         commits = Helper::SemanticVersioningHelper.git_commits(
           from: Helper::SemanticVersioningHelper.git_tag_exists?(formatted_tag) ? formatted_tag : nil,
-          allowed_types: params[:allowed_types]
+          allowed_types: params[:allowed_types],
+          bump_map: params[:bump_map]
         )
 
-        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])
+        bump_type = Helper::SemanticVersioningHelper.bump_type(commits: commits, force_type: params[:force_type])
+        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
@@ -41,9 +48,10 @@ module Fastlane
         Actions.lane_context[SharedValues::SEMVER_NEW_CHANGELOG] = new_changelog
         Actions.lane_context[SharedValues::SEMVER_BUMPABLE] = bumpable
 
-        return bumpable
+        bumpable
       end
 
+      # :nocov:
       def self.description
         "Retrieve semantic versioning information from commit history."
       end
@@ -73,6 +81,7 @@ module Fastlane
         # Optional:
         "Reads commits from last version and determines next version and changelog."
       end
+      # :nocov:
 
       def self.available_options
         [
@@ -80,7 +89,8 @@ module Fastlane
                                        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],
+                                       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)",
@@ -88,6 +98,12 @@ module Fastlane
                                        default_value: { breaking: :major, feat: :minor, fix: :patch },
                                        is_string: false,
                                        verify_block: ->(value) { verify_bump_map(value) }),
+          FastlaneCore::ConfigItem.new(key: :force_type,
+                                       env_name: "SEMANTIC_VERSIONING_FORCE_TYPE",
+                                       description: "Force a minimum bump type",
+                                       optional: true,
+                                       default_value: nil,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :tag_format,
                                        env_name: "SEMANTIC_VERSIONING_TAG_FORMAT",
                                        description: "The format for the git tag",
@@ -99,29 +115,30 @@ module Fastlane
                                        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" },
+                                       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?
+        UI.user_error!("Parameter 'type_map' must be a Hash.") unless value.is_a?(Hash)
       end
 
       def self.verify_bump_map(value)
-        UI.user_error!("Parameter 'bump_map' must be a Hash.") unless value.kind_of?(Hash)
+        UI.user_error!("Parameter 'bump_map' must be a Hash.") unless value.is_a?(Hash)
       end
 
-      def self.is_supported?(platform)
+      # :nocov:
+      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
+      # :nocov:
     end
   end
 end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "fastlane/action"
+require_relative "../helper/semantic_versioning_helper"
+
+module Fastlane
+  module Actions
+    # Action to prepare the Xcode project for automatic versioning
+    class PrepareVersioningAction < Action
+      def self.run(params)
+        xcodeproj_path = params[:xcodeproj] || Dir.glob("*.xcodeproj").first
+
+        Fastlane::UI.user_error!("Unable to determine *.xcodeproj and no :xcodeproj specified") if xcodeproj_path.nil?
+
+        project = Helper::SemanticVersioningHelper.project(xcodeproj_path)
+        target = Helper::SemanticVersioningHelper.main_target
+        main_group = Helper::SemanticVersioningHelper.main_group
+
+        info_plist_file = File.join(main_group.path, "Info.plist")
+        info_plist_path = File.join(project.path.dirname, info_plist_file)
+
+        target.build_configurations.each do |config|
+          config.build_settings["VERSIONING_SYSTEM"] = "apple-generic"
+          config.build_settings.delete("MARKETING_VERSION")
+          config.build_settings.delete("GENERATE_INFOPLIST_FILE")
+
+          config.build_settings["INFOPLIST_FILE"] = info_plist_file unless config.build_settings["INFOPLIST_FILE"]
+
+          Helper::SemanticVersioningHelper.ensure_info_plist(info_plist_path)
+        end
+        project.save
+        true
+      end
+
+      # :nocov:
+      def self.description
+        "Prepares the Xcodeproject to be used with automatic versioning by tools."
+      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
+        "Truthy value when everything worked out well."
+      end
+
+      def self.details
+        # Optional:
+        "Changes the versioning style and makes sure that version information is extracted into Info.plist " \
+          "to be used with agvtool"
+      end
+      # :nocov:
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :main_group,
+                                       env_name: "SEMANTIC_VERSIONING_MAIN_GROUP",
+                                       description: "The name of the main group of the xcode project",
+                                       optional: true,
+                                       default_value: nil,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "SEMANTIC_VERSIONING_PROJECT",
+                                       description: "The path to your project file (Not the workspace). Optional if you have only one",
+                                       optional: true,
+                                       default_value: nil,
+                                       verify_block: proc do |value|
+                                         if value.end_with?(".xcworkspace")
+                                           UI.user_error!("Please pass the path to the project, not the workspace")
+                                         end
+                                         UI.user_error!("Could not find Xcode project") unless File.exist?(value)
+                                       end)
+        ]
+      end
+
+      # :nocov:
+      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
+        #
+        %i[ios mac].include?(platform)
+      end
+      # :nocov:
+    end
+  end
+end

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

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "fastlane/action"
 require_relative "../helper/semantic_versioning_helper"
 
 module Fastlane
   module Actions
+    # Action to bumps the version according to semantic versioning and writes a changelog.
     class SemanticBumpAction < Action
       def self.run(params)
         unless Actions.lane_context.key?(SharedValues::SEMVER_BUMPABLE)
@@ -32,9 +35,10 @@ module Fastlane
           include: [params[:changelog_file]].compact
         )
 
-        return true
+        true
       end
 
+      # :nocov:
       def self.description
         "Bumps the version according to semantic versioning and writes a changelog."
       end
@@ -56,6 +60,7 @@ module Fastlane
         # Optional:
         "Reads commits from last version and determines next version and changelog."
       end
+      # :nocov:
 
       def self.available_options
         [
@@ -74,13 +79,15 @@ module Fastlane
         ]
       end
 
-      def self.is_supported?(platform)
+      # :nocov:
+      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
+      # :nocov:
     end
   end
 end

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

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "fastlane_core/ui/ui"
 require "fastlane/actions/get_version_number"
 require "git"
+require "xcodeproj"
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
@@ -22,41 +25,54 @@ module Fastlane
         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:)
+      def self.git_commits(from:, allowed_types:, bump_map:)
         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
+        logs.reverse_each.filter_map { |commit|
+          parse_conventional_commit(commit: commit, allowed_types: allowed_types, bump_map: bump_map)
+        }
       end
 
-      def self.group_commits(commits:, allowed_types:)
-        result = allowed_types.to_h { |type| [type, []] }
+      def self.parse_conventional_commit(commit:, allowed_types:, bump_map:)
+        types = allowed_types.join("|")
+        commit.message.match(/^(?<type>#{types})(\((?<scope>\S+)\))?(?<major>!)?:\s+(?<subject>[^\n\r]+)(\z|\n\n(?<body>.*\z))/m) do |match|
+          cc = {
+            type: match[:type].to_sym,
+            major: !match[:major].nil?,
+            scope: match[:scope],
+            subject: match[:subject],
+            body: match[:body],
+            breaking: nil,
+            original_message: commit.message
+          }
 
-        commits.each do |commit|
-          if commit[:breaking] && allowed_types.include?(:breaking)
-            result[:breaking] << commit
+          match[:body]&.match(/^BREAKING CHANGE?: (.+)\z/) do |breaking|
+            cc[:breaking] = breaking[1]
           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]
+          cc[:bump] = commit_bump_type(commit: cc, bump_map: bump_map)
 
-          result[commit[:type]] << commit
+          return cc
         end
+      end
+
+      def self.commit_bump_type(commit:, bump_map:)
+        return :major if commit[:major]
+
+        return bump_map[:breaking] if commit[:breaking]
 
-        return result
+        bump_map[commit[:type]]
       end
 
-      def self.bump_type(commits:, bump_map:)
-        result = nil
+      def self.bump_type(commits:, force_type: nil)
+        return force_type if force_type == :major # can't go any higher
+
+        result = force_type
 
         commits.each do |commit|
-          bump_type = commit[:breaking] ? bump_map[:breaking] : bump_map[commit[:type]]
+          return :major if commit[:major]
+
+          bump_type = commit[:bump]
           if bump_type == :major
             return :major
           elsif bump_type == :minor
@@ -66,32 +82,27 @@ module Fastlane
           end
         end
 
-        return result
+        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
+      def self.group_commits(commits:, allowed_types:)
+        result = allowed_types.to_h { |type| [type, []] }
+        result[:none] = []
 
-          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
-          }
+        commits.each do |commit|
+          result[:breaking] << commit if commit[:breaking] && allowed_types.include?(:breaking)
 
-          match[:body]&.match(/^BREAKING CHANGE?: (.+)\z/) do |breaking|
-            cc[:breaking] = breaking[1]
+          if commit[:major] && !allowed_types.include?(commit[:type])
+            result[:none] << commit
+            next
           end
 
-          return cc
+          next unless allowed_types.include?(commit[:type])
+
+          result[commit[:type]] << commit
         end
+
+        result
       end
 
       def self.increase_version(current_version:, bump_type:)
@@ -108,7 +119,7 @@ module Fastlane
           version_array[2] += 1
         end
 
-        return version_array.join(".")
+        version_array.join(".")
       end
 
       # Builds and returns th changelog for the upcoming release.
@@ -123,7 +134,7 @@ module Fastlane
         grouped_commits.each do |key, section_commits|
           next unless section_commits.any?
 
-          lines << "### #{type_map[key]}:"
+          lines << "### #{type_map[key]}:" if key != :none
           lines << ""
 
           section_commits.each do |commit|
@@ -133,7 +144,7 @@ module Fastlane
           lines << ""
         end
 
-        return "#{lines.join("\n")}\n"
+        "#{lines.join("\n")}\n"
       end
 
       def self.write_changelog(path:, changelog:)
@@ -154,15 +165,54 @@ module Fastlane
           .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
+
+      def self.git_tag_exists?(tag)
+        git.tags.include?(tag)
+      end
+
+      def self.project(path = nil)
+        # rubocop:disable Style/ClassVars
+        @@project ||= Xcodeproj::Project.open(path)
+        # rubocop:enable Style/ClassVars
+      end
+
+      def self.main_target
+        project.targets.first
+      end
+
+      def self.current_version
+        @current_version ||= main_target.build_configurations.first.build_settings["MARKETING_VERSION"] || "1.0"
+      end
+
+      def self.main_group(name = nil)
+        project.main_group[name || main_target.name]
+      end
+
+      def self.ensure_info_plist(path)
+        return if File.exist?(path)
+
+        File.write(path, <<-"PLIST")
+              <?xml version="1.0" encoding="UTF-8"?>
+              <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+              <plist version="1.0">
+              <dict>
+                <key>CFBundleVersion</key>
+                <string>#{current_version}</string>
+                <key>CFBundleShortVersionString</key>
+                <string>#{current_version}</string>
+              </dict>
+              </plist>
+        PLIST
+
+        info_plist = main_group.new_file("Info.plist")
+        main_target.add_file_references([info_plist])
+        Fastlane::UI.success("Successfully created the file '#{path}' for agvtool")
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Fastlane
   module SemanticVersioning
-    VERSION = "1.0.0"
+    VERSION = "2.1.0"
   end
 end

data/lib/fastlane/plugin/semantic_versioning.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "fastlane/plugin/semantic_versioning/version"
 
 module Fastlane
+  # Provides actions for dealing with semantic versions and conventional commits
   module SemanticVersioning
     # Return all .rb files inside the "actions" and "helper" directory
     def self.all_classes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-semantic_versioning
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Karsten Silkenbäumer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 2024-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: xcodeproj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
 description: 
 email: 993392+kassi@users.noreply.github.com
 executables: []
@@ -34,6 +48,7 @@ files:
 - 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/prepare_versioning_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