fastlane-plugin-wpmreleasetoolkit 1.0.0

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

@@ -0,0 +1,170 @@
+require 'fastlane/action'
+require_relative '../../helper/metadata_update_helper.rb'
+
+module Fastlane
+  module Actions
+    class GpUpdateMetadataSourceAction < 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|
+          if key == :release_note
+            @blocks.push Fastlane::Helper::ReleaseNoteMetadataBlock.new(key, file_path, release_version)
+          elsif key == :whats_new
+            @blocks.push Fastlane::Helper::WhatsNewMetadataBlock.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)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+require 'fileutils'
+require 'fastlane/action'
+require 'active_support/all'
+require_relative '../../helper/promo_screenshots_helper.rb'
+
+module Fastlane
+  module Actions
+    class PromoScreenshotsAction < Action
+      def self.run(params)
+        UI.message 'Creating Promo Screenshots'
+        UI.message "#{self.check_path(params[:orig_folder])} Original Screenshot Source: #{params[:orig_folder]}"
+        UI.message "#{self.check_path(params[:metadata_folder])} Translation source: #{params[:metadata_folder]}"
+
+        config = helper.read_json(params[:config_file])
+
+        translationDirectories = subdirectories_for_path(params[:metadata_folder])
+        imageDirectories = subdirectories_for_path(params[:orig_folder])
+
+        unless helper.can_resolve_path(params[:output_folder])
+          UI.message "✅ Created Output Folder: #{params[:output_folder]}"
+          FileUtils.mkdir_p(params[:output_folder])
+        else
+          UI.message "#{self.check_path(params[:output_folder])} Output Folder: #{params[:output_folder]}"
+        end
+
+        outputDirectory = helper.resolve_path(params[:output_folder])
+
+        ## If there are no translated screenshot images (whether it's because they haven't been generated yet,
+        ##   or because we aren't using them), just use the translated directories.
+        languages = if imageDirectories == []
+                      translationDirectories
+                    ## And vice-versa.
+                    elsif translationDirectories == []
+                      imageDirectories
+                    ## If there are original screenshots and translations available, use only locales that exist in both.
+                    else
+                      imageDirectories & translationDirectories
+                    end
+
+        UI.message("💙 Creating Promo Screenshots for: #{languages.join(', ')}")
+
+        confirm_directory_overwrite(params[:output_folder], 'the existing promo screenshots') unless params[:force]
+
+        # Create a hash of devices, keyed by device name
+        devices = config['devices']
+        devices = Hash[devices.map { |device| device['name'] }.zip(devices)]
+
+        stylesheet_path = config['stylesheet']
+
+        entries = build_entries(config['entries'], languages, outputDirectory, params)
+
+        bar = ProgressBar.new(entries.count, :bar, :counter, :eta, :rate)
+
+        Parallel.map(entries, finish: lambda { |_item, _i, _result|
+          bar.increment!
+        }) do |entry|
+          device = devices[entry['device']]
+
+          UI.message("Unable to find device #{entry['device']}.") if device.nil?
+
+          width = device['canvas_size'][0]
+          height = device['canvas_size'][1]
+
+          canvas = helper.create_image(width, height)
+          canvas = helper.draw_background_to_canvas(canvas, entry)
+
+          canvas = helper.draw_device_frame_to_canvas(device, canvas)
+          canvas = helper.draw_caption_to_canvas(entry, canvas, device, stylesheet_path)
+          canvas = helper.draw_screenshot_to_canvas(entry, canvas, device)
+          canvas = helper.draw_attachments_to_canvas(entry, canvas)
+
+          # Automatically create intermediate directories for output
+          output_filename = entry['filename']
+          dirname = File.dirname(output_filename)
+
+          FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+
+          canvas.write(output_filename)
+          canvas.destroy!
+
+          # Run the GC in the same thread to clean up after RMagick
+          GC.start
+        end
+      end
+
+      def self.confirm_directory_overwrite(path, description)
+        if File.exist?(path)
+          if UI.confirm("Do you want to overwrite #{description}?")
+            FileUtils.rm_rf(path)
+            Dir.mkdir(path)
+          else
+            UI.user_error!("Exiting to avoid overwriting #{description}.")
+          end
+        else
+          Dir.mkdir(path)
+        end
+      end
+
+      def self.subdirectories_for_path(path)
+        subdirectories = []
+
+        return [] unless helper.can_resolve_path(path)
+
+        resolved_path = helper.resolve_path(path)
+
+        Dir.chdir(resolved_path) do
+          subdirectories = Dir['*'].select { |o| File.directory?(o) }.sort
+        end
+
+        subdirectories
+      end
+
+      def self.check_path(path)
+        self.helper.can_resolve_path(path) ? '✅' : '🚫'
+      end
+
+      def self.helper
+        return Fastlane::Helper::PromoScreenshots.new
+      end
+
+      def self.description
+        'Generate promo screenshots'
+      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 promo screenshots starting from standard ones'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :orig_folder,
+                                       env_name: 'PROMOSS_ORIG',
+                                       description: 'The directory containing the original screenshots',
+                                       optional: false,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :output_folder,
+                                       env_name: 'PROMOSS_OUTPUT',
+                                       description: 'The path of the folder to save the promo screenshots',
+                                       optional: false,
+                                       is_string: true),
+
+          FastlaneCore::ConfigItem.new(key: :metadata_folder,
+                                       env_name: 'PROMOSS_METADATA_FOLDER',
+                                       description: 'The directory containing the translation data',
+                                       optional: false,
+                                       is_string: true),
+
+          FastlaneCore::ConfigItem.new(key: :config_file,
+                                       env_name: 'PROMOSS_CONFIG_FILE',
+                                       description: 'The path to the file containing the promo screenshot configuration',
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: 'screenshots.json'),
+
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: 'PROMOSS_FORCE_CREATION',
+                                       description: 'Overwrite existing promo screenshots without asking first?',
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.build_entries(config_entries, languages, output_directory, params)
+        config_entries
+          .flat_map do |entry|
+          languages.map do |language|
+            newEntry = entry.deep_dup
+
+            # Not every output file will have a screenshot, so handle cases where no
+            # screenshot file is defined
+            if !entry['screenshot'].nil? && !entry['filename'].nil?
+              newEntry['screenshot'] = helper.resolve_path(params[:orig_folder]) + language + entry['screenshot']
+              newEntry['filename'] = output_directory + language + entry['filename']
+            elsif !entry['screenshot'].nil? && entry['filename'].nil?
+              newEntry['screenshot'] = helper.resolve_path(params[:orig_folder]) + language + entry['screenshot']
+              newEntry['filename'] = output_directory + language + entry['screenshot']
+            elsif entry['screenshot'].nil? && !entry['filename'].nil?
+              newEntry['filename'] = output_directory + language + entry['filename']
+            else
+              puts newEntry
+              abort 'Unable to find output file names'
+            end
+
+            newEntry['locale'] = language
+
+            # Localize file paths for text
+            newEntry['text'].sub!('{locale}', language.dup) unless entry['text'].nil?
+
+            # Map attachments paths to their localized versions
+            newEntry['attachments'] = [] if newEntry['attachments'].nil?
+
+            newEntry['attachments'].each do |attachment|
+              ## If there are no translated screenshot images (whether it's because they haven't been generated yet,
+              ##   or because we aren't using them), just use the translated directories.
+              ## And vice-versa.
+              ## If there are original screenshots and translations available, use only locales that exist in both.
+              # Create a hash of devices, keyed by device name
+              # Not every output file will have a screenshot, so handle cases where no
+              # screenshot file is defined
+              # Localize file paths for text
+              # Map attachments paths to their localized versions
+              # Automatically create intermediate directories for output
+              # Run the GC in the same thread to clean up after RMagick
+              # If your method provides a return value, you can describe here what it does
+              # Optional:
+              attachment['file']&.sub!('{locale}', language.dup)
+
+              ## If there are no translated screenshot images (whether it's because they haven't been generated yet,
+              ##   or because we aren't using them), just use the translated directories.
+              ## And vice-versa.
+              ## If there are original screenshots and translations available, use only locales that exist in both.
+              # Create a hash of devices, keyed by device name
+              # Not every output file will have a screenshot, so handle cases where no
+              # screenshot file is defined
+              # Localize file paths for text
+              # Map attachments paths to their localized versions
+              # Automatically create intermediate directories for output
+              # Run the GC in the same thread to clean up after RMagick
+              # If your method provides a return value, you can describe here what it does
+              # Optional:
+              attachment['text']&.sub!('{locale}', language.dup)
+            end
+
+            newEntry
+          end
+        end
+          .sort do |x, y|
+          x['filename'] <=> y['filename']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class RemovebranchprotectionAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        branch_name = params[:branch]
+        branch_prot = {}
+
+        branch_url = "https://api.github.com/repos/#{repository}/branches/" + branch_name
+        branch_prot[:restrictions] = { url: branch_url + '/protection/restrictions', users_url: branch_url + '/protection/restrictions/users', teams_url: branch_url + '/protection/restrictions/teams', users: [], teams: [] }
+        branch_prot[:enforce_admins] = nil
+        branch_prot[:required_pull_request_reviews] = { url: branch_url + '/protection/required_pull_request_reviews', dismiss_stale_reviews: false, require_code_owner_reviews: false }
+
+        Fastlane::Helper::GithubHelper.github_client().unprotect_branch(repository, branch_name, branch_prot)
+      end
+
+      def self.description
+        "Removes the 'release branch' protection state for the specified branch"
+      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:
+        "Sets the 'release branch' protection state for the specified branch"
+      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: :branch,
+                                       env_name: 'GHHELPER_BRANCH',
+                                       description: 'The branch to unprotect',
+                                       optional: false,
+                                       type: String),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end