fastlane-plugin-wpmreleasetoolkit 9.0.0 → 9.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 423e3fa0c8f65af81619e52a547d87a491b532bbab62680b5b5cba1ccfd72d10
-  data.tar.gz: 94974b14aba25d84ffd22d5a6139bf9a0354cd4b61087acd9b8feef28a104fe4
+  metadata.gz: e26f9a48b802c79f4ac19eafc0f3da18b717202ab42d01ca2b2735df4b4abd5d
+  data.tar.gz: ee567a664e7831629f4a0886fc574eec192ef214c47468211a99aa679e98685b
 SHA512:
-  metadata.gz: c340386d587df81c06aa77158d6e37ceb7f9959953f3c853c9766e77ba4d1054e6304615e4625611374bd11591e4b53437413b694c93a4315721c2b6cd74727b
-  data.tar.gz: b9f1fc5e641b5f6d67fc42a803f035fdc1ebd93bd36f376f6da09b74d8282d42c233d8c7d87636837a5e5d3122188083367695e30a8ee8ae01623ef2c379fabe
+  metadata.gz: 993ef98974907a12d687e1558f9134038bf9e746a24c98e35dec4d230c87971e3342cd485d398b80076a20d03626ae4bf3b4c8b09f8f4fed316fc4ec7dcd0f8c
+  data.tar.gz: 3c6bebdb6b77966315088ea774e9a9275035b35abf87fcbf53b3ddfdadcdbd604c59a3ea2fe0d63082a6e572ead59e96cef851c0ec3c8d6187ed6f36326fb6e4

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

@@ -1,5 +1,7 @@
 require 'fastlane/action'
-require_relative '../../helper/an_metadata_update_helper'
+require_relative '../../helper/metadata/release_note_metadata_block'
+require_relative '../../helper/metadata/release_note_short_metadata_block'
+require_relative '../../helper/metadata/whats_new_metadata_block'
 
 module Fastlane
   module Actions
@@ -71,17 +73,17 @@ module Fastlane
         @blocks = []
 
         # Inits default handler
-        @blocks.push Fastlane::Helper::AnUnknownMetadataBlock.new
+        @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::AnReleaseNoteMetadataBlock.new(key, file_path, release_version)
+            @blocks.push Fastlane::Helper::ReleaseNoteMetadataBlock.new(key, file_path, release_version)
           when :release_note_short
-            @blocks.push Fastlane::Helper::AnReleaseNoteShortMetadataBlock.new(key, file_path, release_version)
+            @blocks.push Fastlane::Helper::ReleaseNoteShortMetadataBlock.new(key, file_path, release_version)
           else
-            @blocks.push Fastlane::Helper::AnStandardMetadataBlock.new(key, file_path)
+            @blocks.push Fastlane::Helper::StandardMetadataBlock.new(key, file_path)
           end
         end
 

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

@@ -0,0 +1,80 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class CopyBranchProtectionAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        from_branch = params[:from_branch]
+        to_branch = params[:to_branch]
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        response = begin
+          github_helper.get_branch_protection(
+            repository: repository,
+            branch: from_branch
+          )
+        rescue Octokit::NotFound
+          UI.user_error!("Branch `#{from_branch}` of repository `#{repository}` was not found.")
+        end
+        UI.user_error!("Branch `#{from_branch}` does not have any branch protection set up.") if response.nil?
+        settings = Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+
+        response = begin
+          github_helper.set_branch_protection(
+            repository: repository,
+            branch: to_branch,
+            **settings
+          )
+        rescue Octokit::NotFound
+          UI.user_error!("Branch `#{to_branch}` of repository `#{repository}` was not found.")
+        end
+
+        Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+      end
+
+      def self.description
+        'Copies the branch protection settings of one branch onto another branch'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.return_value
+        'The hash corresponding to the response returned by the API request, and containing the applied protection settings'
+      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: :from_branch,
+                                       env_name: 'GHHELPER_FROM_BRANCH',
+                                       description: 'The branch to copy the protection settings from',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :to_branch,
+                                       env_name: 'GHHELPER_TO_BRANCH',
+                                       description: 'The branch to copy the protection settings to',
+                                       optional: false,
+                                       type: String),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -1,4 +1,6 @@
-require_relative '../../helper/metadata_update_helper'
+require_relative '../../helper/metadata/release_note_metadata_block'
+require_relative '../../helper/metadata/release_note_short_metadata_block'
+require_relative '../../helper/metadata/whats_new_metadata_block'
 
 module Fastlane
   module Actions

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/{removebranchprotection_action.rb → remove_branch_protection_action.rb}

@@ -3,42 +3,34 @@ require_relative '../../helper/github_helper'
 
 module Fastlane
   module Actions
-    class RemovebranchprotectionAction < Action
+    class RemoveBranchProtectionAction < Action
       def self.run(params)
         repository = params[:repository]
         branch_name = params[:branch]
 
-        branch_url = "https://api.github.com/repos/#{repository}/branches/#{branch_name}"
-        restrictions = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
-        required_pull_request_reviews = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
-
         github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
         github_helper.remove_branch_protection(
           repository: repository,
-          branch: branch_name,
-          restrictions: restrictions,
-          enforce_admins: nil,
-          required_pull_request_reviews: required_pull_request_reviews
+          branch: branch_name
         )
+      rescue Octokit::NotFound
+        UI.user_error!("Branch `#{branch_name}` of repository `#{repository}` was not found.")
+      rescue Octokit::BranchNotProtected
+        UI.message("Note: Branch `#{branch_name}` was not protected in the first place.")
       end
 
       def self.description
-        "Removes the 'release branch' protection state for the specified branch"
+        'Removes the protection settings for the specified branch'
       end
 
-      def self.authors
-        ['Automattic']
+      def self.details
+        description
       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,
@@ -55,9 +47,24 @@ module Fastlane
         ]
       end
 
+      def self.authors
+        ['Automattic']
+      end
+
       def self.is_supported?(platform)
         true
       end
     end
+
+    # For backwards compatibility
+    class RemovebranchprotectionAction < RemoveBranchProtectionAction
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "This action has been renamed `#{superclass.action_name}`"
+      end
+    end
   end
 end

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

@@ -0,0 +1,153 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class SetBranchProtectionAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        branch_name = params[:branch]
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        settings = if params[:keep_existing_settings_unchanged]
+                     Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(
+                       github_helper.get_branch_protection(repository: repository, branch: branch_name)
+                     )
+                   else
+                     {}
+                   end
+
+        # `required_status_checks` field — only override existing `checks` subfield if param provided
+        unless params[:required_ci_checks].nil?
+          if params[:required_ci_checks].empty?
+            settings[:required_status_checks] = nil # explicitly completely delete existing check requirement
+          else
+            settings[:required_status_checks] ||= { strict: false }
+            settings[:required_status_checks][:checks] = params[:required_ci_checks].map { |ctx| { context: ctx } }
+          end
+        end
+
+        # `enforce_admins` field — only override existing value if param provided
+        if params[:enforce_admins].nil?
+          settings[:enforce_admins] ||= nil # parameter is required to be provided, even if nil (aka false) value
+        else
+          settings[:enforce_admins] = params[:enforce_admins]
+        end
+
+        # `required_pull_request_reviews` field — only override `required_approving_review_count` subfield if param provided
+        settings[:required_pull_request_reviews] ||= {
+          dismiss_stale_reviews: false,
+          require_code_owner_reviews: false
+        }
+        unless params[:required_approving_review_count].nil?
+          settings[:required_pull_request_reviews][:required_approving_review_count] = params[:required_approving_review_count]
+        end
+
+        # `restrictions` field
+        settings[:restrictions] ||= { users: [], teams: [] }
+
+        # `allow_force_pushes` field — only override existing value if param provided
+        unless params[:allow_force_pushes].nil?
+          settings[:allow_force_pushes] = params[:allow_force_pushes]
+        end
+
+        # `lock_branch` field — only override existing value if param provided
+        unless params[:lock_branch].nil?
+          settings[:lock_branch] = params[:lock_branch]
+        end
+
+        # API Call - See https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+        response = github_helper.set_branch_protection(
+          repository: repository,
+          branch: branch_name,
+          **settings
+        )
+
+        Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+      rescue Octokit::NotFound => e
+        UI.user_error!("Branch `#{branch_name}` of repository `#{repository}` was not found.\n#{e.message}")
+      end
+
+      def self.description
+        'Sets the protection state for the specified branch'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.return_value
+        'The hash corresponding to the response returned by the API request, and containing the applied protection settings'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The slug of the GH repository on which we work',
+                                       optional: false,
+                                       type: String),
+          # NOTE: GitHub branch protection API doesn't allow wildcard characters for the branch parameter
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: 'GHHELPER_BRANCH',
+                                       description: 'The branch to protect',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :keep_existing_settings_unchanged,
+                                       description: 'If set to true, will only change the settings that are explicitly provided to the action, ' \
+                                       + 'while keeping the values of other existing protection settings (if any) unchanged. If false, it will ' \
+                                       + 'discard any existing branch protection setting if any before setting just the ones provided ' \
+                                       + '(and leaving the rest with default GitHub values)',
+                                       default_value: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :required_ci_checks,
+                                       description: 'If provided, specifies the list of CI status checks to mark as required. If not provided (nil), will keep existing ones',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :required_approving_review_count,
+                                       description: 'If not nil, change the number of approving reviews required to merge the PR. ' \
+                                       + 'Acceptable values are `nil` (do not change), 0 (disable) or a number between 1–6',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :enforce_admins,
+                                       description: 'If provided, will update the setting of whether admins can bypass restrictions (false) or not (true)',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :allow_force_pushes,
+                                       description: 'If provided, will update the setting of whether to allow force pushes on the branch',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :lock_branch,
+                                       description: 'If provided, will update the locked (aka readonly) state of the branch',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+
+    # For backwards compatibility
+    class SetbranchprotectionAction < SetBranchProtectionAction
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "This action has been renamed `#{superclass.action_name}`"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/github_helper.rb

@@ -244,11 +244,20 @@ module Fastlane
       #
       # @param [String] repository The repository name (including the organization)
       # @param [String] branch The branch name
-      # @param [Hash] options A customizable set of options.
-      # @see https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+      # @see https://docs.github.com/en/rest/branches/branch-protection#delete-branch-protection
+      #
+      def remove_branch_protection(repository:, branch:)
+        client.unprotect_branch(repository, branch)
+      end
+
+      # Get the list of branch protection settings for a given branch of a repository
       #
-      def remove_branch_protection(repository:, branch:, **options)
-        client.unprotect_branch(repository, branch, options)
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] branch The branch name
+      # @see https://docs.github.com/en/rest/branches/branch-protection#get-branch-protection
+      #
+      def get_branch_protection(repository:, branch:, **options)
+        client.branch_protection(repository, branch)
       end
 
       # Protects a single branch from a repository
@@ -262,6 +271,42 @@ module Fastlane
         client.protect_branch(repository, branch, options)
       end
 
+      # Convert a response from the `/branch-protection` API endpoint into a Hash
+      # suitable to be returned and/or reused to pass to a subsequent `/branch-protection` API request
+      # @param [Sawyer::Resource] response The API response returned by `#get_branch_protection` or `#set_branch_protection`
+      # @return [Hash] A hash representation of the API response—or an empty Hash if `response` was `nil`—
+      #                with Boolean values normalized to true/false, and any extra values that would be refused
+      #                if used in a subsequent API request (like legacy vs new key) removed.
+      # @see https://docs.github.com/en/rest/branches/branch-protection
+      #
+      def self.branch_protection_api_response_to_normalized_hash(response)
+        return {} if response.nil?
+
+        normalize_values = lambda do |hash|
+          hash.each do |k, v|
+            # Boolean values appear as { "enabled" => true/false } in the Response, while they must appear as true/false in Request
+            hash[k] = v[:enabled] if v.is_a?(Hash) && v.key?(:enabled)
+            # References to :users, :teams and :apps are expanded as Objects in the Response, while they must just be the login or slug in Request
+            hash[k] = v.map { |item| item[:login] } if k == :users && v.is_a?(Array)
+            hash[k] = v.map { |item| item[:slug] } if %i[teams apps].include?(k) && v.is_a?(Array)
+            # Response contains lots of `*url` keys that are useless in practice and makes the returned hash harder to parse visually
+            hash.delete(k) if k.to_s == 'url' || k.to_s.end_with?('_url')
+
+            # Recurse into Hashes and Array of Hashes
+            normalize_values.call(v) if v.is_a?(Hash)
+            v.each { |item| normalize_values.call(item) if item.is_a?(Hash) } if v.is_a?(Array)
+          end
+        end
+
+        hash = response.to_hash
+        normalize_values.call(hash)
+
+        # Response contains both (legacy) `:contexts` key and new `:checks` key, but only one of the two should be passed in Request
+        hash[:required_status_checks].delete(:contexts) unless hash.dig(:required_status_checks, :checks).nil?
+
+        hash
+      end
+
       # Creates a GithubToken Fastlane ConfigItem
       #
       # @return [FastlaneCore::ConfigItem] The Fastlane ConfigItem for GitHub OAuth access token

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/metadata_block.rb

@@ -0,0 +1,20 @@
+module Fastlane
+  module Helper
+    # Basic line handler
+    class MetadataBlock
+      attr_reader :block_key
+
+      def initialize(block_key)
+        @block_key = block_key
+      end
+
+      def handle_line(file, line)
+        file.puts(line) # Standard line handling: just copy
+      end
+
+      def is_handler_for(key)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/release_note_metadata_block.rb

@@ -0,0 +1,72 @@
+require_relative 'metadata_block'
+require_relative 'standard_metadata_block'
+
+module Fastlane
+  module Helper
+    class ReleaseNoteMetadataBlock < StandardMetadataBlock
+      attr_reader :new_key, :keep_key, :rel_note_key, :release_version
+
+      def initialize(block_key, content_file_path, release_version)
+        super(block_key, content_file_path)
+        @rel_note_key = 'release_note'
+        @release_version = release_version
+        generate_keys(release_version)
+      end
+
+      def generate_keys(release_version)
+        values = release_version.split('.')
+        version_major = Integer(values[0])
+        version_minor = Integer(values[1])
+        @new_key = "#{@rel_note_key}_#{version_major.to_s.rjust(2, '0')}#{version_minor}"
+
+        version_major -= 1 if version_minor.zero?
+        version_minor = version_minor.zero? ? 9 : version_minor - 1
+
+        @keep_key = "#{@rel_note_key}_#{version_major.to_s.rjust(2, '0')}#{version_minor}"
+      end
+
+      def is_handler_for(key)
+        values = key.split('_')
+        key.start_with?(@rel_note_key) && values.length == 3 && is_int?(values[2].sub(/^0*/, ''))
+      end
+
+      def handle_line(file, line)
+        # put content on block start or if copying the latest one
+        # and skip all the other content
+        if line.start_with?('msgctxt')
+          key = extract_key(line)
+          @is_copying = (key == @keep_key)
+          generate_block(file) if @is_copying
+        end
+
+        file.puts(line) if @is_copying
+      end
+
+      def generate_block(file)
+        # init
+        file.puts("msgctxt \"#{@new_key}\"")
+        file.puts('msgid ""')
+        file.puts("\"#{@release_version}:\\n\"")
+
+        # insert content
+        File.open(@content_file_path, 'r').each do |line|
+          file.puts("\"#{line.strip}\\n\"")
+        end
+
+        # close
+        file.puts('msgstr ""')
+        file.puts('')
+      end
+
+      def extract_key(line)
+        line.split[1].tr('\"', '')
+      end
+
+      def is_int?(value)
+        true if Integer(value)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/release_note_short_metadata_block.rb

@@ -0,0 +1,23 @@
+require_relative 'release_note_metadata_block'
+
+module Fastlane
+  module Helper
+    class ReleaseNoteShortMetadataBlock < ReleaseNoteMetadataBlock
+      def initialize(block_key, content_file_path, release_version)
+        super(block_key, content_file_path, release_version)
+        @rel_note_key = 'release_note_short'
+        @release_version = release_version
+        generate_keys(release_version)
+      end
+
+      def is_handler_for(key)
+        values = key.split('_')
+        key.start_with?(@rel_note_key) && values.length == 4 && is_int?(values[3].sub(/^0*/, ''))
+      end
+
+      def generate_block(file)
+        super(file) unless File.empty?(@content_file_path)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/standard_metadata_block.rb

@@ -0,0 +1,47 @@
+require_relative 'metadata_block'
+
+module Fastlane
+  module Helper
+    class StandardMetadataBlock < MetadataBlock
+      attr_reader :content_file_path
+
+      def initialize(block_key, content_file_path)
+        super(block_key)
+        @content_file_path = content_file_path
+      end
+
+      def is_handler_for(key)
+        key == @block_key.to_s
+      end
+
+      def handle_line(file, line)
+        # put the new content on block start
+        # and skip all the other content
+        generate_block(file) if line.start_with?('msgctxt')
+      end
+
+      def generate_block(file)
+        # init
+        file.puts("msgctxt \"#{@block_key}\"")
+        line_count = File.foreach(@content_file_path).inject(0) { |c, _line| c + 1 }
+
+        if line_count <= 1
+          # Single line output
+          file.puts("msgid \"#{File.read(@content_file_path).rstrip}\"")
+        else
+          # Multiple line output
+          file.puts('msgid ""')
+
+          # insert content
+          File.open(@content_file_path, 'r').each do |line|
+            file.puts("\"#{line.strip}\\n\"")
+          end
+        end
+
+        # close
+        file.puts('msgstr ""')
+        file.puts('')
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/unknown_metadata_block.rb

@@ -0,0 +1,13 @@
+require_relative 'metadata_block'
+
+module Fastlane
+  module Helper
+    class UnknownMetadataBlock < MetadataBlock
+      attr_reader :content_file_path
+
+      def initialize
+        super(nil)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata/whats_new_metadata_block.rb

@@ -0,0 +1,53 @@
+require_relative 'standard_metadata_block'
+
+module Fastlane
+  module Helper
+    class WhatsNewMetadataBlock < StandardMetadataBlock
+      attr_reader :new_key, :old_key, :rel_note_key, :release_version
+
+      def initialize(block_key, content_file_path, release_version)
+        super(block_key, content_file_path)
+        @rel_note_key = 'whats_new'
+        @release_version = release_version
+        generate_keys(release_version)
+      end
+
+      def generate_keys(release_version)
+        values = release_version.split('.')
+        version_major = Integer(values[0])
+        version_minor = Integer(values[1])
+        @new_key = "v#{release_version}-whats-new"
+
+        version_major -= 1 if version_minor.zero?
+        version_minor = version_minor.zero? ? 9 : version_minor - 1
+
+        @old_key = "v#{version_major}.#{version_minor}-whats-new"
+      end
+
+      def is_handler_for(key)
+        key.start_with?('v') && key.end_with?('-whats-new')
+      end
+
+      def handle_line(file, line)
+        # put content on block start or if copying the latest one
+        # and skip all the other content
+        generate_block(file) if line.start_with?('msgctxt')
+      end
+
+      def generate_block(file)
+        # init
+        file.puts("msgctxt \"#{@new_key}\"")
+        file.puts('msgid ""')
+
+        # insert content
+        File.open(@content_file_path, 'r').each do |line|
+          file.puts("\"#{line.strip}\\n\"")
+        end
+
+        # close
+        file.puts('msgstr ""')
+        file.puts('')
+      end
+    end
+  end
+end