fastlane-plugin-wpmreleasetoolkit 1.0.0

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/README.md

@@ -0,0 +1,20 @@
+# release-toolkit
+
+The Actions in this library are organized in 4 folders:
+
+### Android
+
+Actions in this folder automate some tasks of the WordPress for Android release process. 
+
+### Common
+
+Actions in this folder automate tasks that are common to both the iOS and Android release processes.
+These actions are cross-platforms and usually related to integrating with GitHub, GlotPress and other services.  
+
+### Configure
+
+Actions in this folder support the creation, update and validation of the credentials file. 
+
+### iOS
+
+Actions in this folder automate some tasks of the WordPress for iOS release process. 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/an_localize_libs_action.rb

@@ -0,0 +1,53 @@
+require 'fastlane/action'
+require_relative '../../helper/android/android_localize_helper'
+
+module Fastlane
+  module Actions
+    class AnLocalizeLibsAction < Action
+      def self.run(params)
+        main_strings_path = params[:app_strings_path]
+        libraries_strings_path = params[:libs_strings_path]
+
+        any_changes = false
+        libraries_strings_path.each do |lib|
+          (any_changes = Fastlane::Helper::Android::LocalizeHelper.merge_lib(main_strings_path, lib)) || any_changes
+        end
+
+        UI.message("Changes have been applied to #{main_strings_path}. Please, verify it!") if any_changes
+      end
+
+      def self.description
+        'Merges the strings to be localised from the libs into the main application file'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+      end
+
+      def self.details
+        'Merges the strings to be localised from the libs into the main application file'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app_strings_path,
+                                       description: 'The path of the main strings file',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :libs_strings_path,
+                                       env_name: 'LOCALIZE_LIBS_STRINGS_PATH',
+                                       description: 'The list of libs to merge',
+                                       optional: false,
+                                       is_string: false),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        return platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/an_update_metadata_source_action.rb

@@ -0,0 +1,171 @@
+require 'fastlane/action'
+require_relative '../../helper/an_metadata_update_helper.rb'
+
+module Fastlane
+  module Actions
+    class AnUpdateMetadataSourceAction < Action
+      def self.run(params)
+        # fastlane will take care of reading in the parameter and fetching the environment variable:
+        UI.message "Parameter .po file path: #{params[:po_file_path]}"
+        UI.message "Release version: #{params[:release_version]}"
+
+        # Init
+        create_block_parsers(params[:release_version], params[:source_files])
+
+        # Do
+        check_source_files(params[:source_files])
+        temp_po_name = create_temp_po(params)
+        swap_po(params[:po_file_path], temp_po_name)
+
+        UI.message "File #{params[:po_file_path]} updated!"
+      end
+
+      # Verifies that all the source files are available
+      # to this action
+      def self.check_source_files(source_files)
+        source_files.values.each do |file_path|
+          UI.user_error!("Couldn't find file at path '#{file_path}'") unless File.exist?(file_path)
+        end
+      end
+
+      # Creates a temp po file merging
+      # new data for known tags
+      # and the data already in the original
+      # .po fo the others.
+      def self.create_temp_po(params)
+        orig = params[:po_file_path]
+        target = self.create_target_file_path(orig)
+
+        # Clear if older exists
+        File.delete(target) if File.exist? target
+
+        # Create the new one
+        begin
+          File.open(target, 'a') do |fw|
+            File.open(orig, 'r').each do |fr|
+              write_target_block(fw, fr)
+            end
+          end
+        rescue
+          File.delete(target) if File.exist? target
+          raise
+        end
+
+        target
+      end
+
+      # Deletes the old po and moves the temp one
+      # to the final location
+      def self.swap_po(orig_file_path, temp_file_path)
+        File.delete(orig_file_path) if File.exist? orig_file_path
+        File.rename(temp_file_path, orig_file_path)
+      end
+
+      # Generates the temp file path
+      def self.create_target_file_path(orig_file_path)
+        "#{File.dirname(orig_file_path)}/#{File.basename(orig_file_path, '.*')}.tmp"
+      end
+
+      # Creates the block instances
+      def self.create_block_parsers(release_version, block_files)
+        @blocks = []
+
+        # Inits default handler
+        @blocks.push Fastlane::Helper::UnknownMetadataBlock.new
+
+        # Init special handlers
+        block_files.each do |key, file_path|
+          case key
+          when :release_note
+            @blocks.push Fastlane::Helper::ReleaseNoteMetadataBlock.new(key, file_path, release_version)
+          when :release_note_short
+            @blocks.push Fastlane::Helper::ReleaseNoteShortMetadataBlock.new(key, file_path, release_version)
+          else
+            @blocks.push Fastlane::Helper::StandardMetadataBlock.new(key, file_path)
+          end
+        end
+
+        # Sets the default
+        @current_block = @blocks[0]
+      end
+
+      # Manages tags depending on the type
+      def self.write_target_block(fw, line)
+        if is_block_id(line)
+          key = line.split(' ')[1].tr('\"', '')
+          @blocks.each do |block|
+            @current_block = block if block.is_handler_for(key)
+          end
+        end
+
+        @current_block = @blocks.first if is_comment(line)
+
+        @current_block.handle_line(fw, line)
+      end
+
+      def self.is_block_id(line)
+        line.start_with?('msgctxt')
+      end
+
+      def self.is_comment(line)
+        line.start_with?('#')
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Updates a .po file with new data from .txt files'
+      end
+
+      def self.details
+        'You can use this action to update the .po file that contains the string to load to GlotPress for localization.'
+      end
+
+      def self.available_options
+        # Define all options your action supports.
+
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(key: :po_file_path,
+                                       env_name: 'FL_UPDATE_METADATA_SOURCE_PO_FILE_PATH',
+                                       description: 'The path of the .po file to update',
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No .po file path for UpdateMetadataSourceAction given, pass using `po_file_path: 'file path'`") unless value && (!value.empty?)
+                                         UI.user_error!("Couldn't find file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :release_version,
+                                       env_name: 'FL_UPDATE_METADATA_SOURCE_RELEASE_VERSION',
+                                       description: 'The release version of the app (to use to mark the release notes)',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No relase version for UpdateMetadataSourceAction given, pass using `release_version: 'version'`") unless value && (!value.empty?)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :source_files,
+                                       env_name: 'FL_UPDATE_METADATA_SOURCE_SOURCE_FILES',
+                                       description: 'The hash with the path to the source files and the key to use to include their content',
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No source file hash for UpdateMetadataSourceAction given, pass using `source_files: 'source file hash'`") unless value && (!value.empty?)
+                                       end),
+        ]
+      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)
+        [:android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/an_validate_lib_strings_action.rb

@@ -0,0 +1,63 @@
+require 'fastlane/action'
+require_relative '../../helper/android/android_localize_helper'
+
+module Fastlane
+  module Actions
+    class AnValidateLibStringsAction < Action
+      def self.run(params)
+        main_strings_path = params[:app_strings_path]
+        libraries_strings_path = params[:libs_strings_path]
+        diff_url = params[:diff_url]
+
+        source_diff = nil
+        if diff_url.nil? == false
+          data = open(params[:diff_url])
+          source_diff = data.read()
+        end
+
+        any_error = false
+        libraries_strings_path.each do |lib|
+          Fastlane::Helper::Android::LocalizeHelper.verify_lib(main_strings_path, lib, source_diff)
+        end
+      end
+
+      def self.description
+        'Checks that the strings to be localised are updated from the libs into the main application file'
+      end
+
+      def self.authors
+        ['Lorenzo Mattei']
+      end
+
+      def self.return_value
+      end
+
+      def self.details
+        'Checks that the strings to be localised are updated from the libs into the main application file'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app_strings_path,
+                                       description: 'The path of the main strings file',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :libs_strings_path,
+                                       env_name: 'CHECK_LIBS_STRINGS_PATH',
+                                       description: 'The list of libs to merge',
+                                       optional: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :diff_url,
+                                       env_name: 'CHECK_LIBS_DIFF_URL',
+                                       description: 'The url of the diff to check',
+                                       optional: true,
+                                       is_string: true),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        return platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_betabuild_prechecks.rb

@@ -0,0 +1,103 @@
+module Fastlane
+  module Actions
+    class AndroidBetabuildPrechecksAction < Action
+      def self.run(params)
+        UI.message "Skip confirm: #{params[:skip_confirm]}"
+        UI.message "Work on version: #{params[:base_version]}" unless params[:base_version].nil?
+
+        require_relative '../../helper/android/android_version_helper.rb'
+        require_relative '../../helper/android/android_git_helper.rb'
+
+        # Checkout develop and update
+        Fastlane::Helper::GitHelper.checkout_and_pull('develop')
+
+        # Check versions
+        release_version = Fastlane::Helper::Android::VersionHelper.get_release_version
+        message = "The following current version has been detected: #{release_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}\n"
+        alpha_release_version = Fastlane::Helper::Android::VersionHelper.get_alpha_version
+        message << "The following Alpha version has been detected: #{alpha_release_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}\n" unless alpha_release_version.nil?
+
+        # Check branch
+        app_version = Fastlane::Helper::Android::VersionHelper.get_public_version
+        UI.user_error!("#{message}Release branch for version #{app_version} doesn't exist. Abort.") unless !params[:base_version].nil? || Fastlane::Helper::GitHelper.checkout_and_pull(release: app_version)
+
+        # Check user overwrite
+        unless params[:base_version].nil?
+          overwrite_version = get_user_build_version(params[:base_version], message)
+          release_version = overwrite_version[0]
+          alpha_release_version = overwrite_version[1]
+        end
+
+        next_beta_version = Fastlane::Helper::Android::VersionHelper.calc_next_beta_version(release_version, alpha_release_version)
+        next_alpha_version = Fastlane::Helper::Android::VersionHelper.calc_next_alpha_version(next_beta_version, alpha_release_version) unless alpha_release_version.nil?
+
+        # Verify
+        message << "Updating branch to version: #{next_beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}(#{next_beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_CODE]}) "
+        message << "and #{next_alpha_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}(#{next_alpha_version[Fastlane::Helper::Android::VersionHelper::VERSION_CODE]}).\n" unless alpha_release_version.nil?
+        if !params[:skip_confirm]
+          UI.user_error!('Aborted by user request') unless UI.confirm("#{message}Do you want to continue?")
+        else
+          UI.message(message)
+        end
+
+        # Check local repo status
+        other_action.ensure_git_status_clean()
+
+        # Return the current version
+        [next_beta_version, next_alpha_version]
+      end
+
+      def self.get_user_build_version(version, message)
+        UI.user_error!("Release branch for version #{version} doesn't exist. Abort.") unless Fastlane::Helper::GitHelper.checkout_and_pull(release: version)
+        release_version = Fastlane::Helper::Android::VersionHelper.get_release_version
+        message << "Looking at branch release/#{version} as requested by user. Detected version: #{release_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}.\n"
+        alpha_release_version = Fastlane::Helper::Android::VersionHelper.get_alpha_version
+        message << "and Alpha Version: #{alpha_release_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}\n" unless alpha_release_version.nil?
+        [release_version, alpha_release_version]
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Runs some prechecks before preparing for a new test build'
+      end
+
+      def self.details
+        'Updates the relevant release branch, checks the app version and ensure the branch is clean'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :base_version,
+                                       env_name: 'FL_ANDROID_BETABUILD_PRECHECKS_BASE_VERSION',
+                                       description: 'The version to work on', # a short description of this parameter
+                                       is_string: true,
+                                       optional: true), # true: verifies the input is a string, false: every kind of value),
+          FastlaneCore::ConfigItem.new(key: :skip_confirm,
+                                       env_name: 'FL_ANDROID_BETABUILD_PRECHECKS_SKIPCONFIRM',
+                                       description: 'Skips confirmation',
+                                       is_string: false, # true: verifies the input is a string, false: every kind of value
+                                       default_value: false), # the default value if the user didn't provide one
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        # If you method provides a return value, you can describe here what it does
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ['loremattei']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_build_prechecks.rb

@@ -0,0 +1,83 @@
+module Fastlane
+  module Actions
+    class AndroidBuildPrechecksAction < Action
+      def self.run(params)
+        require_relative '../../helper/android/android_version_helper.rb'
+
+        UI.user_error!("Can't build beta and final at the same time!") if params[:final] && params[:beta]
+
+        Fastlane::Helper::GitHelper.ensure_on_branch!('release') unless other_action.is_ci()
+
+        message = ''
+        beta_version = Fastlane::Helper::Android::VersionHelper.get_release_version() unless !params[:beta] && !params[:final]
+        alpha_version = Fastlane::Helper::Android::VersionHelper.get_alpha_version() if params[:alpha]
+
+        UI.user_error!("Can't build a final release out of this branch because it's configured as a beta release!") if params[:final] && Fastlane::Helper::Android::VersionHelper.is_beta_version?(beta_version)
+
+        message << "Building version #{beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}(#{beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_CODE]}) (for upload to Release Channel)\n" if params[:final]
+        message << "Building version #{beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}(#{beta_version[Fastlane::Helper::Android::VersionHelper::VERSION_CODE]}) (for upload to Beta Channel)\n" if params[:beta]
+        message << "Building version #{alpha_version[Fastlane::Helper::Android::VersionHelper::VERSION_NAME]}(#{alpha_version[Fastlane::Helper::Android::VersionHelper::VERSION_CODE]}) (for upload to Alpha Channel)\n" if params[:alpha]
+
+        if !params[:skip_confirm]
+          UI.user_error!('Aborted by user request') unless UI.confirm("#{message}Do you want to continue?")
+        else
+          UI.message(message)
+        end
+
+        # Check local repo status
+        other_action.ensure_git_status_clean() unless other_action.is_ci()
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Runs some prechecks before the build'
+      end
+
+      def self.details
+        'Runs some prechecks before the build'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :skip_confirm,
+                                       env_name: 'FL_ANDROID_BUILD_PRECHECKS_SKIP_CONFIRM',
+                                       description: 'True to avoid the system ask for confirmation',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :alpha,
+                                       env_name: 'FL_ANDROID_BUILD_PRECHECKS_ALPHA_BUILD',
+                                       description: 'True if this is for an alpha build',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :beta,
+                                       env_name: 'FL_ANDROID_BUILD_PRECHECKS_BETA_BUILD',
+                                       description: 'True if this is for a beta build',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :final,
+                                       env_name: 'FL_ANDROID_BUILD_PRECHECKS_FINAL_BUILD',
+                                       description: 'True if this is for a final build',
+                                       is_string: false,
+                                       default_value: false),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ['loremattei']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end