fastlane 1.111.0 → 2.0.1

data/deliver/lib/deliver/commands_generator.rb

@@ -0,0 +1,150 @@
+require 'commander'
+require 'deliver/download_screenshots'
+
+HighLine.track_eof = false
+
+module Deliver
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def deliverfile_options(skip_verification: false)
+      available_options = Deliver::Options.available_options
+      return available_options unless skip_verification
+
+      # These don't matter for downloading metadata, so verification can be skipped
+      irrelevant_options_keys = [:ipa, :pkg, :app_rating_config_path]
+
+      available_options.each do |opt|
+        next unless irrelevant_options_keys.include?(opt.key)
+        opt.verify_block = nil
+        opt.conflicting_options = nil
+      end
+
+      return available_options
+    end
+
+    def run
+      program :name, 'deliver'
+      program :version, Fastlane::VERSION
+      program :description, Deliver::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <deliver@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/fastlane/tree/master/deliver'
+      program :help_formatter, :compact
+
+      FastlaneCore::CommanderGenerator.new.generate(deliverfile_options)
+
+      global_option('--verbose') { $verbose = true }
+
+      always_trace!
+
+      command :run do |c|
+        c.syntax = 'deliver'
+        c.description = 'Upload metadata and binary to iTunes Connect'
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          loaded = options.load_configuration_file("Deliverfile")
+          loaded = true if options[:description] || options[:ipa] || options[:pkg] # do we have *anything* here?
+          unless loaded
+            if UI.confirm("No deliver configuration found in the current directory. Do you want to setup deliver?")
+              require 'deliver/setup'
+              Deliver::Runner.new(options) # to login...
+              Deliver::Setup.new.run(options)
+              return 0
+            end
+          end
+
+          Deliver::Runner.new(options).run
+        end
+      end
+      command :submit_build do |c|
+        c.syntax = 'deliver submit_build'
+        c.description = 'Submit a specific build-nr for review, use latest for the latest build'
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          options[:submit_for_review] = true
+          options[:build_number] = "latest" unless options[:build_number]
+          Deliver::Runner.new(options).run
+        end
+      end
+      command :init do |c|
+        c.syntax = 'deliver init'
+        c.description = 'Create the initial `deliver` configuration based on an existing app'
+        c.action do |args, options|
+          if File.exist?("Deliverfile") or File.exist?("fastlane/Deliverfile")
+            UI.important("You already have a running deliver setup in this directory")
+            return 0
+          end
+
+          require 'deliver/setup'
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          Deliver::Runner.new(options) # to login...
+          Deliver::Setup.new.run(options)
+        end
+      end
+
+      command :generate_summary do |c|
+        c.syntax = 'deliver generate_summary'
+        c.description = 'Generate HTML Summary without uploading/downloading anything'
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options)
+          html_path = Deliver::GenerateSummary.new.run(options)
+          UI.success "Successfully generated HTML report at '#{html_path}'"
+          system("open '#{html_path}'") unless options[:force]
+        end
+      end
+
+      command :download_screenshots do |c|
+        c.syntax = 'deliver download_screenshots'
+        c.description = "Downloads all existing screenshots from iTunes Connect and stores them in the screenshots folder"
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options(skip_verification: true), options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options, skip_version: true) # to login...
+          containing = FastlaneCore::Helper.fastlane_enabled? ? './fastlane' : '.'
+          path = options[:screenshots_path] || File.join(containing, 'screenshots')
+          Deliver::DownloadScreenshots.run(options, path)
+        end
+      end
+
+      command :download_metadata do |c|
+        c.syntax = 'deliver download_metadata'
+        c.description = "Downloads existing metadata and stores it locally. This overwrites the local files."
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options(skip_verification: true), options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options) # to login...
+          containing = FastlaneCore::Helper.fastlane_enabled? ? './fastlane' : '.'
+          path = options[:metadata_path] || File.join(containing, 'metadata')
+          res = ENV["DELIVER_FORCE_OVERWRITE"]
+          res ||= UI.confirm("Do you want to overwrite existing metadata on path '#{File.expand_path(path)}'?")
+          return 0 unless res
+
+          require 'deliver/setup'
+          v = options[:app].latest_version
+          if options[:app_version].to_s.length > 0
+            v = options[:app].live_version if v.version != options[:app_version]
+            if v.version != options[:app_version]
+              raise "Neither the current nor live version match specified app_version \"#{options[:app_version]}\""
+            end
+          end
+
+          Deliver::Setup.new.generate_metadata_files(v, path)
+        end
+      end
+
+      default_command :run
+
+      run!
+    end
+  end
+end

data/deliver/lib/deliver/detect_values.rb

@@ -0,0 +1,69 @@
+module Deliver
+  class DetectValues
+    def run!(options, skip_params = {})
+      find_app_identifier(options)
+      find_app(options)
+      find_folders(options)
+      ensure_folders_created(options)
+      find_version(options) unless skip_params[:skip_version]
+      find_platform(options)
+    end
+
+    def find_app_identifier(options)
+      return if options[:app_identifier]
+
+      if options[:ipa]
+        identifier = FastlaneCore::IpaFileAnalyser.fetch_app_identifier(options[:ipa])
+      elsif options[:pkg]
+        identifier = FastlaneCore::PkgFileAnalyser.fetch_app_identifier(options[:pkg])
+      end
+
+      options[:app_identifier] = identifier if identifier.to_s.length > 0
+      options[:app_identifier] ||= UI.input("The Bundle Identifier of your App: ")
+    rescue
+      UI.user_error!("Could not infer your App's Bundle Identifier")
+    end
+
+    def find_app(options)
+      search_by = options[:app_identifier]
+      search_by = options[:app] if search_by.to_s.length == 0
+      app = Spaceship::Application.find(search_by)
+      if app
+        options[:app] = app
+      else
+        UI.user_error!("Could not find app with app identifier '#{options[:app_identifier]}' in your iTunes Connect account (#{options[:username]} - Team: #{Spaceship::Tunes.client.team_id})")
+      end
+    end
+
+    def find_folders(options)
+      containing = Helper.fastlane_enabled? ? FastlaneCore::FastlaneFolder.path : '.'
+      options[:screenshots_path] ||= File.join(containing, 'screenshots')
+      options[:metadata_path] ||= File.join(containing, 'metadata')
+    end
+
+    def ensure_folders_created(options)
+      FileUtils.mkdir_p(options[:screenshots_path])
+      FileUtils.mkdir_p(options[:metadata_path])
+    end
+
+    def find_version(options)
+      return if options[:app_version]
+
+      if options[:ipa]
+        options[:app_version] ||= FastlaneCore::IpaFileAnalyser.fetch_app_version(options[:ipa])
+      elsif options[:pkg]
+        options[:app_version] ||= FastlaneCore::PkgFileAnalyser.fetch_app_version(options[:pkg])
+      end
+    rescue
+      UI.user_error!("Could not infer your app's version")
+    end
+
+    def find_platform(options)
+      if options[:ipa]
+        options[:platform] ||= FastlaneCore::IpaFileAnalyser.fetch_app_platform(options[:ipa])
+      elsif options[:pkg]
+        options[:platform] = 'osx'
+      end
+    end
+  end
+end

data/deliver/lib/deliver/download_screenshots.rb

@@ -0,0 +1,46 @@
+module Deliver
+  class DownloadScreenshots
+    def self.run(options, path)
+      UI.message("Downloading all existing screenshots...")
+      download(options, path)
+      UI.success("Successfully downloaded all existing screenshots")
+    rescue => ex
+      UI.error(ex)
+      UI.error("Couldn't download already existing screenshots from iTunes Connect.")
+    end
+
+    def self.download(options, folder_path)
+      v = options[:app].latest_version
+
+      v.screenshots.each do |language, screenshots|
+        screenshots.each do |screenshot|
+          file_name = [screenshot.sort_order, screenshot.device_type, screenshot.sort_order].join("_")
+          original_file_extension = File.basename(screenshot.original_file_name)
+          file_name += "." + original_file_extension
+
+          UI.message("Downloading existing screenshot '#{file_name}' for language '#{language}'")
+
+          # If the screen shot is for an appleTV we need to store it in a way that we'll know it's an appleTV
+          # screen shot later as the screen size is the same as an iPhone 6 Plus in landscape.
+          if screenshot.device_type == "appleTV"
+            containing_folder = File.join(folder_path, "appleTV", screenshot.language)
+          else
+            containing_folder = File.join(folder_path, screenshot.language)
+          end
+
+          if screenshot.is_imessage
+            containing_folder = File.join(folder_path, "iMessage", screenshot.language)
+          end
+
+          begin
+            FileUtils.mkdir_p(containing_folder)
+          rescue
+            # if it's already there
+          end
+          path = File.join(containing_folder, file_name)
+          File.write(path, open(screenshot.url).read)
+        end
+      end
+    end
+  end
+end

data/deliver/lib/deliver/generate_summary.rb

@@ -0,0 +1,9 @@
+module Deliver
+  class GenerateSummary
+    def run(options)
+      screenshots = UploadScreenshots.new.collect_screenshots(options)
+      UploadMetadata.new.load_from_filesystem(options)
+      HtmlGenerator.new.render(options, screenshots, '.')
+    end
+  end
+end

data/deliver/lib/deliver/html_generator.rb

@@ -0,0 +1,58 @@
+module Deliver
+  class HtmlGenerator
+    # Splits keywords supporting:
+    # * separated by commas (with optional whitespace)
+    # * separated by newlines
+    KEYWORD_SPLITTER = /(?:,\s?|\r?\n)/
+
+    def run(options, screenshots)
+      begin
+        html_path = self.render(options, screenshots, '.')
+      rescue => ex
+        UI.error(ex.inspect)
+        UI.error(ex.backtrace.join("\n"))
+        okay = UI.input("Could not render HTML preview. Do you still want to continue?")
+        return if okay
+        UI.crash!("Could not render HTML page")
+      end
+      UI.important("Verifying the upload via the HTML file can be disabled by either adding")
+      UI.important("`force true` to your Deliverfile or using `deliver --force`")
+
+      system("open '#{html_path}'")
+      okay = UI.confirm("Does the Preview on path '#{html_path}' look okay for you?")
+
+      if okay
+        UI.success("HTML file confirmed...") # print this to give feedback to the user immediately
+      else
+        UI.user_error!("Did not upload the metadata, because the HTML file was rejected by the user")
+      end
+    end
+
+    # Renders all data available to quickly see if everything was correctly generated.
+    # @param export_path (String) The path to a folder where the resulting HTML file should be stored.
+    def render(options, screenshots, export_path = nil)
+      @screenshots = screenshots || []
+      @options = options
+
+      @app_name = (options[:name]['en-US'] || options[:name].values.first) if options[:name]
+      @app_name ||= options[:app].name
+
+      @languages = options[:description].keys if options[:description]
+      @languages ||= options[:app].latest_version.description.languages
+
+      html_path = File.join(Deliver::ROOT, "lib/assets/summary.html.erb")
+      html = ERB.new(File.read(html_path)).result(binding) # http://www.rrn.dk/rubys-erb-templating-system
+
+      export_path = File.join(export_path, "Preview.html")
+      File.write(export_path, html)
+
+      return export_path
+    end
+
+    # Splits a string of keywords separated by comma or newlines into a presentable list
+    # @param keywords (String)
+    def split_keywords(keywords)
+      keywords.split(KEYWORD_SPLITTER)
+    end
+  end
+end

data/deliver/lib/deliver/loader.rb

@@ -0,0 +1,18 @@
+require 'fastlane_core/languages'
+
+module Deliver
+  module Loader
+    # The directory 'appleTV' and `iMessage` are special folders that will cause our screenshot gathering code to iterate
+    # through it as well searching for language folders.
+    APPLE_TV_DIR_NAME = "appleTV".freeze
+    IMESSAGE_DIR_NAME = "iMessage".freeze
+    DEFAULT_DIR_NAME = "default".freeze
+    ALL_LANGUAGES = (FastlaneCore::Languages::ALL_LANGUAGES + [APPLE_TV_DIR_NAME, APPLE_TV_DIR_NAME, IMESSAGE_DIR_NAME, DEFAULT_DIR_NAME]).map(&:downcase).freeze
+
+    def self.language_folders(root)
+      Dir.glob(File.join(root, '*')).select do |path|
+        File.directory?(path) && ALL_LANGUAGES.include?(File.basename(path).downcase)
+      end.sort
+    end
+  end
+end

data/deliver/lib/deliver/options.rb

@@ -0,0 +1,269 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Deliver
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "DELIVER_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "DELIVER_APP_IDENTIFIER",
+                                     description: "The bundle identifier of your app",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)),
+        FastlaneCore::ConfigItem.new(key: :app,
+                                     short_option: "-p",
+                                     env_name: "DELIVER_APP_ID",
+                                     description: "The app ID of the app you want to use/modify",
+                                     is_string: false), # don't add any verification here, as it's used to store a spaceship ref
+        FastlaneCore::ConfigItem.new(key: :ipa,
+                                     short_option: "-i",
+                                     optional: true,
+                                     env_name: "DELIVER_IPA_PATH",
+                                     description: "Path to your ipa file",
+                                     default_value: Dir["*.ipa"].first,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find ipa file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be an ipa file") unless value.end_with?(".ipa")
+                                     end,
+                                     conflicting_options: [:pkg],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'ipa' and '#{value.key}' options in one run.")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :pkg,
+                                     short_option: "-c",
+                                     optional: true,
+                                     env_name: "DELIVER_PKG_PATH",
+                                     description: "Path to your pkg file",
+                                     default_value: Dir["*.pkg"].first,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find pkg file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a pkg file") unless value.end_with?(".pkg")
+                                     end,
+                                     conflicting_options: [:ipa],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'pkg' and '#{value.key}' options in one run.")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :platform,
+                                     short_option: "-j",
+                                     env_name: "DELIVER_PLATFORM",
+                                     description: "The platform to use (optional)",
+                                     optional: true,
+                                     default_value: "ios",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("The platform can only be ios, appletvos, or osx") unless %('ios', 'appletvos', 'osx').include? value
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :metadata_path,
+                                     short_option: '-m',
+                                     description: "Path to the folder containing the metadata files",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :screenshots_path,
+                                     short_option: '-w',
+                                     description: "Path to the folder containing the screenshots",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_binary_upload,
+                                     description: "Skip uploading an ipa or pkg to iTunes Connect",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_screenshots,
+                                     description: "Don't upload the screenshots",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :app_version,
+                                     short_option: '-z',
+                                     description: "The version that should be edited or created",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_metadata,
+                                     description: "Don't upload the metadata (e.g. title, description), this will still upload screenshots",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :force,
+                                     short_option: "-f",
+                                     description: "Skip the HTML report file verification",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :submit_for_review,
+                                     env_name: "DELIVER_SUBMIT_FOR_REVIEW",
+                                     description: "Submit the new version for Review after uploading everything",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :automatic_release,
+                                     description: "Should the app be automatically released once it's approved?",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :price_tier,
+                                     short_option: "-r",
+                                     description: "The price tier of this application",
+                                     is_string: false,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :build_number,
+                                     short_option: "-n",
+                                     description: "If set the given build number (already uploaded to iTC) will be used instead of the current built one",
+                                     optional: true,
+                                     conflicting_options: [:ipa, :pkg],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'build_number' and '#{value.key}' options in one run.")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :app_rating_config_path,
+                                     short_option: "-g",
+                                     description: "Path to the app rating's config",
+                                     is_string: true,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find config file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a JSON file") unless value.end_with?(".json")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :submission_information,
+                                     short_option: "-b",
+                                     description: "Extra information for the submission (e.g. third party content)",
+                                     is_string: false,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-k",
+                                     env_name: "DELIVER_TEAM_ID",
+                                     description: "The ID of your iTunes Connect team if you're in multiple teams",
+                                     optional: true,
+                                     is_string: false, # as we also allow integers, which we convert to strings anyway
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-e",
+                                     env_name: "DELIVER_TEAM_NAME",
+                                     description: "The name of your iTunes Connect team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :dev_portal_team_id,
+                                     short_option: "-s",
+                                     env_name: "DELIVER_DEV_PORTAL_TEAM_ID",
+                                     description: "The short ID of your Developer Portal team, if you're in multiple teams. Different from your iTC team ID!",
+                                     optional: true,
+                                     is_string: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :dev_portal_team_name,
+                                     short_option: "-y",
+                                     env_name: "DELIVER_DEV_PORTAL_TEAM_NAME",
+                                     description: "The name of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :itc_provider,
+                                     env_name: "DELIVER_ITC_PROVIDER",
+                                     description: "The provider short name to be used with the iTMSTransporter to identify your team",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :overwrite_screenshots,
+                                     env_name: "DELIVER_OVERWRITE_SCREENSHOTS",
+                                     description: "Clear all previously uploaded screenshots before uploading the new ones",
+                                     is_string: false,
+                                     default_value: false),
+
+        # App Metadata
+        # Non Localised
+        FastlaneCore::ConfigItem.new(key: :app_icon,
+                                     description: "Metadata: The path to the app icon",
+                                     optional: true,
+                                     short_option: "-l",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find png file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a png file") unless value.end_with?(".png")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :apple_watch_app_icon,
+                                     description: "Metadata: The path to the Apple Watch app icon",
+                                     optional: true,
+                                     short_option: "-q",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find png file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a png file") unless value.end_with?(".png")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :copyright,
+                                     description: "Metadata: The copyright notice",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :primary_category,
+                                     description: "Metadata: The english name of the primary category(e.g. `Business`, `Books`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :secondary_category,
+                                     description: "Metadata: The english name of the secondary category(e.g. `Business`, `Books`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :primary_first_sub_category,
+                                     description: "Metadata: The english name of the primary first sub category(e.g. `Educational`, `Puzzle`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :primary_second_sub_category,
+                                     description: "Metadata: The english name of the primary second sub category(e.g. `Educational`, `Puzzle`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :secondary_first_sub_category,
+                                     description: "Metadata: The english name of the secondary first sub category(e.g. `Educational`, `Puzzle`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :secondary_second_sub_category,
+                                     description: "Metadata: The english name of the secondary second sub category(e.g. `Educational`, `Puzzle`)",
+                                     optional: true,
+                                     is_string: true),
+        FastlaneCore::ConfigItem.new(key: :app_review_information,
+                                     description: "Metadata: A hash containing the review information",
+                                     optional: true,
+                                     is_string: false),
+        # Localised
+        FastlaneCore::ConfigItem.new(key: :description,
+                                     description: "Metadata: The localised app description",
+                                     optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :name,
+                                     description: "Metadata: The localised app name",
+                                     optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :keywords,
+                                     description: "Metadata: An array of localised keywords",
+                                     optional: true,
+                                     is_string: false,
+                                     verify_block: proc do |value|
+                                       UI.user_error!(":keywords must be a Hash, with the language being the key") unless value.kind_of?(Hash)
+                                       value.each do |language, keywords|
+                                         # Auto-convert array to string
+                                         keywords = keywords.join(", ") if keywords.kind_of?(Array)
+                                         value[language] = keywords
+
+                                         UI.user_error!(":keywords must be a hash with all values being strings") unless keywords.kind_of?(String)
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :release_notes,
+                                     description: "Metadata: Localised release notes for this version",
+                                     optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :privacy_url,
+                                     description: "Metadata: Localised privacy url",
+                                     optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :support_url,
+                                     description: "Metadata: Localised support url",
+                                     optional: true,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :marketing_url,
+                                     description: "Metadata: Localised marketing url",
+                                     optional: true,
+                                     is_string: false)
+      ]
+    end
+  end
+end