fastlane-plugin-jira_issues_release_notes 0.4.0 → 1.0.0

data/lib/fastlane/plugin/jira_issues_release_notes/actions/jira_versions_action.rb

@@ -0,0 +1,162 @@
+require 'fastlane/action'
+require_relative '../helper/jira_issues_release_notes_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      FL_JIRA_LAST_TAG ||= :S3_APK_OUTPUT_PATH
+      FL_JIRA_LAST_TAG_HASH ||= :FL_JIRA_LAST_TAG_HASH
+      FL_JIRA_COMMITS_FROM_HASH ||= :FL_JIRA_COMMITS_FROM_HASH
+      FL_JIRA_LAST_KEYS_FROM_COMMITS ||= :FL_JIRA_LAST_KEYS_FROM_COMMITS
+      FL_JIRA_LAST_ISSUES_FROM_COMMITS ||= :FL_JIRA_LAST_ISSUES_FROM_COMMITS
+    end
+
+    class JiraVersionsAction < Action
+      def self.run(params)
+        @jira_helper = Helper::JiraIssuesReleaseNotesHelper.initialize_jira(
+          host: params[:host],
+          api_version: params[:api_version],
+          username: params[:username],
+          password: params[:password],
+          context_path: params[:context_path],
+          disable_ssl_verification: params[:disable_ssl_verification]
+        )
+
+        versions = @jira_helper.list_versions(
+          project_id_or_key: params[:project_id],
+          query: params[:query],
+          order_by: params[:order_by],
+          status: params[:status]
+        )
+
+        versions.map { |version|
+          {
+            :id => version.self,
+            :name => version.name,
+            :archived => version.archived,
+            :released => version.released,
+            :user_release_date => defined? version.userReleaseDate ? version.userReleaseDate : nil,
+            :overdue => defined? version.overdue ? version.overdue : false,
+            :projectId => version.projectId,
+          }
+        }
+      end
+
+      def self.description
+        "It generates a release note based on the issues keys found in branch name and descriptions found in the commits"
+      end
+
+      def self.authors
+        ["Erick Martins"]
+      end
+
+      def self.return_value
+        "boolean value"
+      end
+
+      def self.details
+        # Optional:
+        "It generates a release note based on the issues keys found in branch name and descriptions found in the commits"
+      end
+
+      def self.available_options
+        conflict_extraction_method = Proc.new do |other|
+          UI.user_error! "Unexpected conflict with option #{other}" unless [:extract_from_branch, :tag_prefix].include?(other)
+        end
+
+        conflict_comment = Proc.new do |other|
+          UI.user_error! "Unexpected conflict with option #{other}" unless [:comment_block, :comment].include?(other)
+        end
+
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :project_id,
+            env_name: 'FL_JIRA_PROJECT_ID',
+            description: 'The project ID or project key',
+            optional: false,
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :query,
+            description: 'Filter the results using a literal string. Versions with matching name or description are returned (case insensitive).',
+            optional: true,
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :order_by,
+            description: 'Order the results by a field. Valid values: description, -description, +description, name, -name, +name, releaseDate, -releaseDate, +releaseDate, sequence, -sequence, +sequence, startDate, -startDate, +startDate',
+            optional: true,
+            verify_block: proc do |value|
+              valid_order = ["description", "-description", "+description", "name", "-name", "+name", "releaseDate", "-releaseDate", "+releaseDate", "sequence", "-sequence", "+sequence", "startDate", "-startDate", "+startDate"]
+              UI.user_error!("Invalid :order_by value! Valid values: #{valid_order.join(", ")}") unless valid_order.include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :status,
+            description: 'A list of status values used to filter the results by version status. This parameter accepts a comma-separated list. The status values are released, unreleased, and archived',
+            optional: true,
+            verify_block: proc do |value|
+              valid_values = ["released", "unreleased", "archived"]
+              UI.user_error!("Invalid :status value! Valid values: #{valid_values.join(", ")}") unless valid_values.include?(value)
+            end
+          ),
+
+          # Jira Client options
+          FastlaneCore::ConfigItem.new(
+            key: :username,
+            env_name: 'FL_JIRA_USERNAME',
+            description:  'Jira user',
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :password,
+            env_name: 'FL_JIRA_PASSWORD',
+            description:  'Jira user',
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :host,
+            env_name: 'FL_JIRA_HOST',
+            description:  'Jira location',
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :api_version,
+            env_name: 'FL_JIRA_API_VERSION',
+            description:  'Jira api version',
+            default_value: '3',
+            optional: true,
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :context_path,
+            env_name: 'FL_JIRA_CONTEXT_PATH',
+            description:  'Jira context path',
+            optional: true,
+            default_value: ''
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :disable_ssl_verification,
+            env_name: 'FL_JIRA_DISABLE_SSL_VERIFICATION',
+            description:  'Jira SSL Verification mode',
+            optional: true,
+            default_value: false,
+            type: Boolean
+          ),
+          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.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/jira_issues_release_notes/helper/jira_issues_release_notes_helper.rb

@@ -1,29 +1,213 @@
 require 'fastlane_core/ui/ui'
-require 'jira-ruby'
+require 'zk-jira-ruby'
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
 
   module Helper
     class JiraIssuesReleaseNotesHelper
-      # class methods that you define here become available in your action
-      # as `Helper::JiraIssuesReleaseNotesHelper.your_method`
-      #
-      def self.show_message
-        UI.message("Hello from the jira_issues_release_notes plugin helper!")
+
+      def self.format_issue_link(issue:)
+        # formats the link according to the output format we need
+        link = @jira_helper.url(issue: issue)
+        case @format
+        when "slack"
+          "*<#{link}|#{issue.key}>*: #{issue.summary}"
+        when "markdown"
+          "- **[#{issue.key}](#{link})**: #{issue.summary}"
+        when "html"
+          "&nbsp;&nbsp;- <strong><a href=\"#{link}\" target=\"_blank\">#{issue.key}</a><strong>: #{issue.summary}"
+        else
+          "- #{issue.key}: #{issue.summary} (#{link})"
+        end
+      end
+
+      def self.style_text(text:, style:)
+        # formats the text according to the style we're looking to use
+
+        # Skips all styling
+        case style
+        when "title"
+          case @format
+          when "markdown"
+            "# #{text}"
+          when "slack"
+            "*#{text}*"
+          when "html"
+            "<h1>#{text}</h1>"
+          else
+            text
+          end
+        when "heading"
+          case @format
+          when "markdown"
+            "### #{text}"
+          when "slack"
+            "*#{text}*"
+          when "html"
+            "<h3>#{text}</h3>"
+          else
+            "#{text}:"
+          end
+        when "bold"
+          case @format
+          when "markdown"
+            "**#{text}**"
+          when "slack"
+            "*#{text}*"
+          when "html"
+            "<strong>#{text}</strong>"
+          else
+            text
+          end
+        else
+          text # catchall, shouldn't be needed
+        end
+      end
+
+      def self.get_commit_after_latest_tag(tag_regex:, tag_version_match:, debug:)
+        unless Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_COMMITS_FROM_HASH] then
+          
+          # Try to find the tag
+          command = "git describe --tags --match=#{tag_regex}"
+          tag = Actions.sh(command, log: debug)
+
+          if tag.empty?
+            UI.message("First commit of the branch is taken as a begining of next release")
+            # If there is no tag found we taking the first commit of current branch
+            hash = Actions.sh('git rev-list --max-parents=0 HEAD', log: debug).chomp
+          else
+            # Tag's format is v2.3.4-5-g7685948
+            # Get a hash of last version tag
+            tag_name = tag.split('-')[0...-2].join('-').strip
+            parsed_version = tag_name.match(tag_version_match)
+
+            if parsed_version.nil?
+              UI.user_error!("Error while parsing version from tag #{tag_name} by using tag_version_match - #{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
+            command = "git rev-list -n 1 refs/tags/#{tag_name}"
+            hash = Actions.sh(command, log: debug).chomp
+
+            UI.message("Found a tag #{tag_name} associated with version #{version}")
+          end
+
+          # Get commits log between last version and head
+          commits = git_log(
+            pretty: '%s|%b|>',
+            start: hash,
+            debug: debug
+          )
+
+          Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_TAG] = tag
+          Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_TAG_HASH] = hash
+          Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_COMMITS_FROM_HASH] = commits
+        end
+
+        Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_COMMITS_FROM_HASH]
+      rescue StandardError => error
+        UI.error error.message
+        UI.message("Tag was not found for match pattern - #{tag_regex}")
+        nil
       end
 
-      # class methods that you define here become available in your action
-      # as `Helper::SemanticConventionReleaseHelper.your_method`
-      #
+      def self.get_key_from_commit_after_latest_tag(tag_regex:, tag_version_match:, issue_key_regex:, debug:)
+        unless Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_KEYS_FROM_COMMITS] then
+          commits = get_commit_after_latest_tag(
+            tag_regex: tag_regex, 
+            tag_version_match: tag_version_match, 
+            debug: debug,
+          )
+
+          return nil unless commits
+
+          last_keys_from_commits = commits
+            .to_enum(:scan, issue_key_regex)
+            .map { $& }
+            .reject(&:empty?)
+            .uniq
+
+          Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_KEYS_FROM_COMMITS] = last_keys_from_commits
+        end
+
+        Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_KEYS_FROM_COMMITS]
+      end
+      
+      def self.get_issues_from_commit_after_latest_tag(tag_regex:, tag_version_match:, issue_key_regex:, debug:)
+        unless Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_ISSUES_FROM_COMMITS] then
+          unless @jira_helper then
+            UI.user_error! "Uninitialized jira client"
+          end
+
+          keys = get_key_from_commit_after_latest_tag(
+            tag_regex: tag_regex, 
+            tag_version_match: tag_version_match, 
+            issue_key_regex: issue_key_regex, 
+            debug: debug
+          )
+
+          issues = @jira_helper.get(keys: keys)
+          Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_ISSUES_FROM_COMMITS] = issues
+        end
+
+        Actions.lane_context[Fastlane::Actions::SharedValues::FL_JIRA_LAST_ISSUES_FROM_COMMITS]
+      end
+      
       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.jira_helper(host:, username:, password:, context_path:, disable_ssl_verification:)
+      def self.generate_changelog(groups:, line_break_format:)
+        changelog = []
+
+        groups.each do |label, issues|
+          changelog.concat(['']) unless changelog.to_s.empty?
+          changelog.concat(format_issues(label: label, issues: issues)) unless issues.empty?
+        end
+        # changes = format_issues(issues: issues)
+
+        changelog.join(line_break_format)
+      end
+
+      def self.format_issues(label:, issues:)
+        [
+          style_text(text: "► #{label}", style: 'heading'),
+          issues.map { |issue| format_issue_link(issue: issue) }
+        ].flatten!
+      end
+
+      def self.extract_key_from_branch(branch:, ticket_prefix:)
+        regex = Regexp.new("(#{ticket_prefix}-\\d+)")
+        
+        ticket_code = regex.match branch
+
+        ticket_code
+      end
+
+
+      def self.initialize_jira(host:, api_version:, username:, password:, context_path:, disable_ssl_verification:)
+        unless @jira_helper then
+          @jira_helper = jira_helper(
+            host: host,
+            api_version: api_version,
+            username: username,
+            password: password,
+            context_path: context_path,
+            disable_ssl_verification: disable_ssl_verification
+          ) 
+        end
+
+        @jira_helper
+      end
+
+      def self.jira_helper(host:, api_version:, username:, password:, context_path:, disable_ssl_verification:)
         JiraHelper.new(
           host: host,
+          api_version: api_version,
           username: username,
           password: password,
           context_path: context_path,
@@ -32,13 +216,14 @@ module Fastlane
       end
 
       class JiraClientHelper
-        def self.client(host:, username:, password:, context_path:, disable_ssl_verification:)
+        def self.client(host:, api_version:, username:, password:, context_path:, disable_ssl_verification:)
           options = {
            site: host,
            context_path: context_path,
            auth_type: :basic,
            username: username,
            password: password,
+           rest_base_path: "/rest/api/#{api_version}",
            ssl_verify_mode: disable_ssl_verification ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
           }
 
@@ -47,28 +232,28 @@ module Fastlane
       end
 
       class JiraHelper
-        def initialize(host:, username:, password:, context_path:, disable_ssl_verification:, jira_client_helper: nil)
+        def initialize(host:, api_version:, username:, password:, context_path:, disable_ssl_verification:, jira_client_helper: nil)
           @host = host
           @context_path = context_path
 
-          jira_client_helper ||= JiraClientHelper.client(
+          @client ||= JiraClientHelper.client(
             host: host,
+            api_version: api_version,
             username: username,
             password: password,
             context_path: context_path,
             disable_ssl_verification: disable_ssl_verification
           )
-          @client = jira_client_helper
         end
 
-        def get(issues:, extra_fields: [])
-          return [] if issues.to_a.empty?
+        def get(keys:, extra_fields: [])
+          return [] if keys.to_a.empty?
 
           fields = [:key, :summary, :status, :issuetype, :description]
           fields.concat extra_fields
 
           begin
-            @client.Issue.jql("KEY IN (#{issues.join(',')})", fields: fields, validate_query: false)
+            @client.Issue.jql("KEY IN (#{keys.join(',')})", fields: fields, validate_query: false)
           rescue StandardError => e
             UI.important('Jira Client: Failed to get issue.')
             UI.important("Jira Client: Reason - #{e.message}")
@@ -76,6 +261,16 @@ module Fastlane
           end
         end
 
+        def list_versions(project_id_or_key:, query: nil, order_by: nil, status: nil)
+          @client.Version.find(
+            project_id_or_key: project_id_or_key,
+            query: query, 
+            orderBy: order_by, 
+            status: status
+          )
+        end
+      
+
         def add_comment(comment:, issues:)
           return if issues.to_a.empty?