fastlane-plugin-wpmreleasetoolkit 1.0.0

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/close_milestone_action.rb

@@ -0,0 +1,56 @@
+require 'fastlane/action'
+require 'date'
+require_relative '../../helper/github_helper'
+require_relative '../../helper/ios/ios_version_helper'
+require_relative '../../helper/android/android_version_helper'
+module Fastlane
+  module Actions
+    class CloseMilestoneAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        milestone_title = params[:milestone]
+
+        milestone = Fastlane::Helper::GithubHelper.get_milestone(repository, milestone_title)
+        UI.user_error!("Milestone #{milestone_title} not found.") if milestone.nil?
+
+        Fastlane::Helper::GithubHelper.github_client().update_milestone(repository, milestone[:number], state: 'closed')
+      end
+
+      def self.description
+        'Closes an existing milestone in the project'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        'Closes an existing milestone in the project'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The remote path of the GH repository on which we work',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :milestone,
+                                       env_name: 'GHHELPER_MILESTONE',
+                                       description: 'The GitHub milestone',
+                                       optional: false,
+                                       type: String),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_new_milestone_action.rb

@@ -0,0 +1,59 @@
+require 'fastlane/action'
+require 'date'
+require_relative '../../helper/github_helper'
+require_relative '../../helper/ios/ios_version_helper'
+require_relative '../../helper/android/android_version_helper'
+module Fastlane
+  module Actions
+    class CreateNewMilestoneAction < Action
+      def self.run(params)
+        repository = params[:repository]
+
+        last_stone = Fastlane::Helper::GithubHelper.get_last_milestone(repository)
+        UI.message("Last detected milestone: #{last_stone[:title]} due on #{last_stone[:due_on]}.")
+        milestone_duedate = last_stone[:due_on]
+        newmilestone_duedate = (milestone_duedate.to_datetime.next_day(14).to_time).utc
+        newmilestone_number = Fastlane::Helper::Ios::VersionHelper.calc_next_release_version(last_stone[:title])
+        UI.message("Next milestone: #{newmilestone_number} due on #{newmilestone_duedate}.")
+        Fastlane::Helper::GithubHelper.create_milestone(repository, newmilestone_number, newmilestone_duedate, params[:need_appstore_submission])
+      end
+
+      def self.description
+        'Creates a new milestone for the project'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        'Creates a new milestone for the project'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The remote path of the GH repository on which we work',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :need_appstore_submission,
+                                       env_name: 'GHHELPER_NEED_APPSTORE_SUBMISSION',
+                                       description: 'True if the app needs to be submitted',
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_action.rb

@@ -0,0 +1,91 @@
+require 'fastlane/action'
+require 'date'
+require_relative '../../helper/github_helper'
+require_relative '../../helper/ios/ios_version_helper'
+require_relative '../../helper/android/android_version_helper'
+module Fastlane
+  module Actions
+    class CreateReleaseAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        version = params[:version]
+        assets = params[:release_assets]
+        release_notes = params[:release_notes_file_path].nil? ? '' : IO.read(params[:release_notes_file_path])
+        prerelease = params[:prerelease]
+
+        UI.message("Creating draft release #{version} in #{repository}.")
+        # Verify assets
+        assets.each do |file_path|
+          UI.user_error!("Can't find file #{file_path}!") unless File.exist?(file_path)
+        end
+
+        Fastlane::Helper::GithubHelper.create_release(
+          repository: repository,
+          version: version,
+          target: params[:target],
+          description: release_notes,
+          assets: assets,
+          prerelease: prerelease
+        )
+        UI.message('Done')
+      end
+
+      def self.description
+        'Creates a release and uploads the provided assets'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        'Creates a release and uploads the provided assets'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The slug (`<org>/<repo>`) of the GitHub repository we want to create the release on',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: 'GHHELPER_CREATE_RELEASE_VERSION',
+                                       description: 'The version of the release',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :target,
+                                       env_name: 'GHHELPER_TARGET_COMMITISH',
+                                       description: 'The branch name or commit SHA the new tag should point to - if that tag does not exist yet when publishing the release. If omitted, will default to the current HEAD commit at the time of this call',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :release_notes_file_path,
+                                       env_name: 'GHHELPER_CREATE_RELEASE_NOTES',
+                                       description: 'The path to the file that contains the release notes',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :release_assets,
+                                       env_name: 'GHHELPER_CREATE_RELEASE_ASSETS',
+                                       description: 'Assets to upload',
+                                       type: Array,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :prerelease,
+                                       env_name: 'GHHELPER_CREATE_RELEASE_PRERELEASE',
+                                       description: 'True if this is a pre-release',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/extract_release_notes_for_version_action.rb

@@ -0,0 +1,89 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    class ExtractReleaseNotesForVersionAction < Action
+      def self.run(params)
+        version = params[:version]
+        release_notes_file_path = params[:release_notes_file_path]
+        extracted_notes_file_path = params[:extracted_notes_file_path]
+
+        extracted_notes_file = File.open(extracted_notes_file_path, 'w') unless extracted_notes_file_path.blank?
+
+        extract_notes(release_notes_file_path, version) do |line|
+          extracted_notes_file.nil? ? puts(line) : extracted_notes_file.write(line)
+        end
+
+        unless extracted_notes_file.nil?
+          extracted_notes_file.close()
+          check_and_commit_extracted_notes_file(extracted_notes_file_path, version)
+        end
+      end
+
+      def self.extract_notes(release_notes_file_path, version)
+        state = :discarding
+        File.open(release_notes_file_path).each do |line|
+          case state
+          when :discarding
+            state = :evaluating if (line.match(/^(\d+\.)?(\d+\.)?(\*|\d+)$/)) && (line.strip() == version)
+          when :evaluating
+            state = (line.match(/-/)) ? :extracting : :discarding
+          when :extracting
+            if line.match(/^(\d+\.)?(\d+\.)?(\*|\d+)$/)
+              state = :discarding
+              return
+            else
+              yield(line)
+            end
+          end
+        end
+      end
+
+      def self.check_and_commit_extracted_notes_file(file_path, version)
+        Action.sh("git add #{file_path}")
+        Action.sh("git diff-index --quiet HEAD || git commit -m \"Update draft release notes for #{version}.\"")
+      end
+
+      def self.description
+        'Extract the release notes for a specific version'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        'Creates a release and uploads the provided assets'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: 'GHHELPER_EXTRACT_NOTES_VERSION',
+                                       description: 'The version of the release',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :release_notes_file_path,
+                                       env_name: 'GHHELPER_EXTRACT_NOTES_FILE_PATH',
+                                       description: 'The path to the file that contains the release notes',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :extracted_notes_file_path,
+                                       env_name: 'GHHELPER_EXTRACT_NOTES_EXTRACTED_FILE_PATH',
+                                       description: 'The path to the file that will contain the extracted release notes',
+                                       optional: true,
+                                       is_string: true),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/get_prs_list_action.rb

@@ -0,0 +1,64 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class GetPrsListAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        report_path = File.expand_path(params[:report_path])
+        milestone = params[:milestone]
+
+        # Get commit list
+        pr_list = Fastlane::Helper::GithubHelper.get_prs_for_milestone(repository, milestone)
+
+        File.open(report_path, 'w') do |file|
+          pr_list.each do |data|
+            file.puts("##{data[:number]}: #{data[:title]} @#{data[:user][:login]} #{data[:html_url]}")
+          end
+        end
+
+        UI.success("Found #{pr_list.count} PRs in #{milestone} – saved to #{report_path}")
+      end
+
+      def self.description
+        'Generate the list of the PRs in the given `repository` for the given `milestone` at the given `report_path`'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        description
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The repository name, including the organization (e.g. `wordpress-mobile/wordpress-ios`)',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :report_path,
+                                       description: 'The path where the list of PRs should be written to',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :milestone,
+                                       description: 'The name of the milestone we want to fetch the list of PRs for (e.g.: `16.9`)',
+                                       optional: false,
+                                       is_string: true),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/gp_downloadmetadata_action.rb

@@ -0,0 +1,90 @@
+require 'fastlane/action'
+require_relative '../../helper/metadata_download_helper.rb'
+
+module Fastlane
+  module Actions
+    class GpDownloadmetadataAction < Action
+      def self.run(params)
+        # fastlane will take care of reading in the parameter and fetching the environment variable:
+        UI.message "Project URL: #{params[:project_url]}"
+        UI.message "Locales: #{params[:locales].inspect}"
+        UI.message "Source locale: #{params[:source_locale].nil? ? '-' : params[:source_locale]}"
+        UI.message "Path: #{params[:download_path]}"
+
+        # Check download path
+        Dir.mkdir(params[:download_path]) unless File.exist?(params[:download_path])
+
+        # Download
+        downloader = Fastlane::Helper::MetadataDownloader.new(params[:download_path], params[:target_files])
+
+        params[:locales].each do |loc|
+          if loc.is_a?(Array)
+            puts "Downloading language: #{loc[1]}"
+            complete_url = "#{params[:project_url]}#{loc[0]}/default/export-translations?filters[status]=current&format=json"
+            downloader.download(loc[1], complete_url, loc[1] == params[:source_locale])
+          end
+
+          if loc.is_a?(String)
+            puts "Downloading language: #{loc}"
+            complete_url = "#{params[:project_url]}#{loc}/default/export-translations?filters[status]=current&format=json"
+            downloader.download(loc, complete_url, loc == params[:source_locale])
+          end
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Download translated metadata'
+      end
+
+      def self.details
+        'Downloads tranlated metadata from GlotPress and updates local files'
+      end
+
+      def self.available_options
+        # Define all options your action supports.
+
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(key: :project_url,
+                                       env_name: 'FL_DOWNLOAD_METADATA_PROJECT_URL', # The name of the environment variable
+                                       description: 'GlotPress project URL'),
+          FastlaneCore::ConfigItem.new(key: :target_files,
+                                       env_name: 'FL_DOWNLOAD_METADATA_TARGET_FILES',
+                                       description: 'The hash with the path to the target files and the key to use to extract their content',
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :locales,
+                                       env_name: 'FL_DOWNLOAD_METADATA_LOCALES',
+                                       description: 'The hash with the GLotPress locale and the project locale association',
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :source_locale,
+                                       env_name: 'FL_DOWNLOAD_METADATA_SOURCE_LOCALE',
+                                       description: 'The source locale code',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :download_path,
+                                       env_name: 'FL_DOWNLOAD_METADATA_DOWNLOAD_PATH',
+                                       description: 'The path of the target files',
+                                       is_string: true),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.authors
+        ['loremattei']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end