fastlane 1.111.0 → 2.0.1

data/deliver/lib/deliver/runner.rb

@@ -0,0 +1,99 @@
+module Deliver
+  class Runner
+    attr_accessor :options
+
+    def initialize(options, skip_auto_detection = {})
+      self.options = options
+      login
+      Deliver::DetectValues.new.run!(self.options, skip_auto_detection)
+      FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:app], mask_keys: ['app_review_information.demo_password'], title: "deliver #{Fastlane::VERSION} Summary")
+    end
+
+    def login
+      UI.message("Login to iTunes Connect (#{options[:username]})")
+      Spaceship::Tunes.login(options[:username])
+      Spaceship::Tunes.select_team
+      UI.message("Login successful")
+    end
+
+    def run
+      verify_version if options[:app_version].to_s.length > 0
+      upload_metadata
+
+      has_binary = (options[:ipa] || options[:pkg])
+      if !options[:skip_binary_upload] && !options[:build_number] && has_binary
+        upload_binary
+      end
+
+      UI.success("Finished the upload to iTunes Connect")
+
+      submit_for_review if options[:submit_for_review]
+    end
+
+    # Make sure the version on iTunes Connect matches the one in the ipa
+    # If not, the new version will automatically be created
+    def verify_version
+      app_version = options[:app_version]
+      UI.message("Making sure the latest version on iTunes Connect matches '#{app_version}' from the ipa file...")
+
+      changed = options[:app].ensure_version!(app_version, platform: options[:pkg] ? 'osx' : 'ios')
+
+      if changed
+        UI.success("Successfully set the version to '#{app_version}'")
+      else
+        UI.success("'#{app_version}' is the latest version on iTunes Connect")
+      end
+    end
+
+    # Upload all metadata, screenshots, pricing information, etc. to iTunes Connect
+    def upload_metadata
+      # First, collect all the things for the HTML Report
+      screenshots = UploadScreenshots.new.collect_screenshots(options)
+      UploadMetadata.new.load_from_filesystem(options)
+      UploadMetadata.new.assign_defaults(options)
+
+      # Validate
+      validate_html(screenshots)
+
+      # Commit
+      UploadMetadata.new.upload(options)
+      UploadScreenshots.new.upload(options, screenshots)
+      UploadPriceTier.new.upload(options)
+      UploadAssets.new.upload(options) # e.g. app icon
+    end
+
+    # Upload the binary to iTunes Connect
+    def upload_binary
+      UI.message("Uploading binary to iTunes Connect")
+      if options[:ipa]
+        package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(
+          app_id: options[:app].apple_id,
+          ipa_path: options[:ipa],
+          package_path: "/tmp"
+        )
+      elsif options[:pkg]
+        package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(
+          app_id: options[:app].apple_id,
+          pkg_path: options[:pkg],
+          package_path: "/tmp"
+        )
+      end
+
+      transporter = FastlaneCore::ItunesTransporter.new(options[:username], nil, false, options[:itc_provider])
+      result = transporter.upload(options[:app].apple_id, package_path)
+      UI.user_error!("Could not upload binary to iTunes Connect. Check out the error above", show_github_issues: true) unless result
+    end
+
+    def submit_for_review
+      SubmitForReview.new.submit!(options)
+    end
+
+    private
+
+    def validate_html(screenshots)
+      return if options[:force]
+      return if options[:skip_metadata] && options[:skip_screenshots]
+      HtmlGenerator.new.run(options, screenshots)
+    end
+  end
+end

data/deliver/lib/deliver/setup.rb

@@ -0,0 +1,78 @@
+module Deliver
+  class Setup
+    def run(options)
+      containing = (File.directory?("fastlane") ? 'fastlane' : '.')
+      file_path = File.join(containing, 'Deliverfile')
+      data = generate_deliver_file(containing, options)
+      setup_deliver(file_path, data, containing, options)
+    end
+
+    def setup_deliver(file_path, data, deliver_path, options)
+      File.write(file_path, data)
+
+      unless options[:skip_screenshots]
+        download_screenshots(deliver_path, options)
+
+        # Add a README to the screenshots folder
+        FileUtils.mkdir_p File.join(deliver_path, 'screenshots') # just in case the fetching didn't work
+        File.write(File.join(deliver_path, 'screenshots', 'README.txt'), File.read("#{Deliver::ROOT}/lib/assets/ScreenshotsHelp"))
+      end
+
+      UI.success("Successfully created new Deliverfile at path '#{file_path}'")
+    end
+
+    # This method takes care of creating a new 'deliver' folder, containg the app metadata
+    # and screenshots folders
+    def generate_deliver_file(deliver_path, options)
+      v = options[:app].latest_version
+      generate_metadata_files(v, File.join(deliver_path, 'metadata'))
+
+      # Generate the final Deliverfile here
+      deliver = File.read("#{Deliver::ROOT}/lib/assets/DeliverfileDefault")
+      deliver.gsub!("[[APP_IDENTIFIER]]", options[:app].bundle_id)
+      deliver.gsub!("[[USERNAME]]", Spaceship::Tunes.client.user)
+      return deliver
+    end
+
+    def generate_metadata_files(v, path)
+      app_details = v.application.details
+
+      # All the localised metadata
+      (UploadMetadata::LOCALISED_VERSION_VALUES + UploadMetadata::LOCALISED_APP_VALUES).each do |key|
+        v.description.languages.each do |language|
+          if UploadMetadata::LOCALISED_VERSION_VALUES.include?(key)
+            content = v.send(key)[language].to_s
+          else
+            content = app_details.send(key)[language].to_s
+          end
+          content << "\n"
+          resulting_path = File.join(path, language, "#{key}.txt")
+          FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+          File.write(resulting_path, content)
+          UI.message("Writing to '#{resulting_path}'")
+        end
+      end
+
+      # All non-localised metadata
+      (UploadMetadata::NON_LOCALISED_VERSION_VALUES + UploadMetadata::NON_LOCALISED_APP_VALUES).each do |key|
+        if UploadMetadata::NON_LOCALISED_VERSION_VALUES.include?(key)
+          content = v.send(key).to_s
+        else
+          content = app_details.send(key).to_s
+        end
+        content << "\n"
+        resulting_path = File.join(path, "#{key}.txt")
+        File.write(resulting_path, content)
+        UI.message("Writing to '#{resulting_path}'")
+      end
+
+      UI.success("Successfully created new configuration files.")
+    end
+
+    def download_screenshots(deliver_path, options)
+      path = File.join(deliver_path, 'screenshots')
+      FileUtils.mkdir_p(path)
+      Deliver::DownloadScreenshots.run(options, path)
+    end
+  end
+end

data/deliver/lib/deliver/submit_for_review.rb

@@ -0,0 +1,87 @@
+module Deliver
+  class SubmitForReview
+    def submit!(options)
+      app = options[:app]
+      select_build(options)
+
+      UI.message("Submitting the app for review...")
+      submission = app.create_submission
+
+      # Set app submission information
+      # Default Values
+      submission.content_rights_contains_third_party_content = false
+      submission.content_rights_has_rights = true
+      submission.add_id_info_uses_idfa = false
+
+      # User Values
+      if options[:submission_information]
+        options[:submission_information].each do |key, value|
+          UI.message("Setting '#{key}' to '#{value}'...")
+          submission.send("#{key}=", value)
+        end
+      end
+
+      # Finalize app submission
+      submission.complete!
+
+      UI.success("Successfully submitted the app for review!")
+    end
+
+    def select_build(options)
+      app = options[:app]
+      v = app.edit_version
+
+      if options[:build_number] and options[:build_number] != "latest"
+        UI.message("Selecting existing build-number: #{options[:build_number]}")
+        build = v.candidate_builds.detect { |a| a.build_version == options[:build_number] }
+        unless build
+          UI.user_error!("Build number: #{options[:build_number]} does not exist")
+        end
+      else
+        UI.message("Selecting the latest build...")
+        build = wait_for_build(app)
+      end
+      UI.message("Selecting build #{build.train_version} (#{build.build_version})...")
+
+      v.select_build(build)
+      v.save!
+
+      UI.success("Successfully selected build")
+    end
+
+    def wait_for_build(app)
+      UI.user_error!("Could not find app with app identifier") unless app
+
+      start = Time.now
+
+      loop do
+        build = find_build(app.latest_version.candidate_builds)
+        return build if build.processing == false
+
+        UI.message("Waiting iTunes Connect processing for build #{build.train_version} (#{build.build_version})... this might take a while...")
+        if (Time.now - start) > (60 * 5)
+          UI.message("")
+          UI.message("You can tweet: \"iTunes Connect #iosprocessingtime #{((Time.now - start) / 60).round} minutes\"")
+        end
+        sleep 30
+      end
+      nil
+    end
+
+    def find_build(candidate_builds)
+      build = nil
+      candidate_builds.each do |b|
+        if !build or b.upload_date > build.upload_date
+          build = b
+        end
+      end
+
+      unless build
+        UI.error(candidate_builds)
+        UI.crash!("Could not find build")
+      end
+
+      return build
+    end
+  end
+end

data/deliver/lib/deliver/upload_assets.rb

@@ -0,0 +1,22 @@
+module Deliver
+  class UploadAssets
+    def upload(options)
+      app = options[:app]
+
+      v = app.edit_version(platform: options[:platform])
+      UI.user_error!("Could not find a version to edit for app '#{app.name}'") unless v
+
+      if options[:app_icon]
+        UI.message("Uploading app icon...")
+        v.upload_large_icon!(options[:app_icon])
+      end
+
+      if options[:apple_watch_app_icon]
+        UI.message("Uploading apple watchapp icon...")
+        v.upload_watch_icon!(options[:apple_watch_app_icon])
+      end
+
+      v.save!
+    end
+  end
+end

data/deliver/lib/deliver/upload_metadata.rb

@@ -0,0 +1,191 @@
+module Deliver
+  # upload description, rating, etc.
+  class UploadMetadata
+    # All the localised values attached to the version
+    LOCALISED_VERSION_VALUES = [:description, :keywords, :release_notes, :support_url, :marketing_url]
+
+    # Everything attached to the version but not being localised
+    NON_LOCALISED_VERSION_VALUES = [:copyright]
+
+    # Localised app details values
+    LOCALISED_APP_VALUES = [:name, :privacy_url]
+
+    # Non localized app details values
+    NON_LOCALISED_APP_VALUES = [:primary_category, :secondary_category,
+                                :primary_first_sub_category, :primary_second_sub_category,
+                                :secondary_first_sub_category, :secondary_second_sub_category]
+
+    # Make sure to call `load_from_filesystem` before calling upload
+    def upload(options)
+      return if options[:skip_metadata]
+      verify_available_languages!(options)
+
+      app = options[:app]
+
+      details = app.details
+      v = app.edit_version(platform: options[:platform])
+
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current
+
+        unless current.kind_of?(Hash)
+          UI.error("Error with provided '#{key}'. Must be a hash, the key being the language.")
+          next
+        end
+
+        current.each do |language, value|
+          next unless value.to_s.length > 0
+          strip_value = value.to_s.strip
+          v.send(key)[language] = strip_value if LOCALISED_VERSION_VALUES.include?(key)
+          details.send(key)[language] = strip_value if LOCALISED_APP_VALUES.include?(key)
+        end
+      end
+
+      (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
+        current = options[key].to_s.strip
+        next unless current.to_s.length > 0
+        v.send("#{key}=", current) if NON_LOCALISED_VERSION_VALUES.include?(key)
+        details.send("#{key}=", current) if NON_LOCALISED_APP_VALUES.include?(key)
+      end
+
+      v.release_on_approval = options[:automatic_release]
+
+      set_review_information(v, options)
+      set_app_rating(v, options)
+
+      UI.message("Uploading metadata to iTunes Connect")
+      v.save!
+      details.save!
+      UI.success("Successfully uploaded initial set of metadata to iTunes Connect")
+    end
+
+    # If the user is using the 'default' language, then assign values where they are needed
+    def assign_defaults(options)
+      # Build a complete list of the required languages
+      enabled_languages = []
+
+      # Get all languages used in existing settings
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current && current.kind_of?(Hash)
+        current.each do |language, value|
+          enabled_languages << language unless enabled_languages.include?(language)
+        end
+      end
+
+      # Check folder list (an empty folder signifies a language is required)
+      Dir.glob(File.join(options[:metadata_path], "*")).each do |lng_folder|
+        next unless File.directory?(lng_folder) # We don't want to read txt as they are non localised
+
+        language = File.basename(lng_folder)
+        enabled_languages << language unless enabled_languages.include?(language)
+      end
+
+      return unless enabled_languages.include?("default")
+      UI.message("Detected languages: " + enabled_languages.to_s)
+
+      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        current = options[key]
+        next unless current && current.kind_of?(Hash)
+
+        default = current["default"]
+        next if default.nil?
+
+        enabled_languages.each do |language|
+          value = current[language]
+          next unless value.nil?
+
+          current[language] = default
+        end
+        current.delete("default")
+      end
+    end
+
+    # Makes sure all languages we need are actually created
+    def verify_available_languages!(options)
+      return if options[:skip_metadata]
+
+      # Collect all languages we need
+      # We only care about languages from user provided values
+      # as the other languages are on iTC already anyway
+      v = options[:app].edit_version
+      UI.user_error!("Could not find a version to edit for app '#{options[:app].name}', the app metadata is read-only currently") unless v
+
+      enabled_languages = []
+      LOCALISED_VERSION_VALUES.each do |key|
+        current = options[key]
+        next unless current && current.kind_of?(Hash)
+        current.each do |language, value|
+          enabled_languages << language unless enabled_languages.include?(language)
+        end
+      end
+
+      if enabled_languages.count > 0
+        v.create_languages(enabled_languages)
+        lng_text = "language"
+        lng_text += "s" if enabled_languages.count != 1
+        UI.message("Activating #{lng_text} #{enabled_languages.join(', ')}...")
+        v.save!
+      end
+      true
+    end
+
+    # Loads the metadata files and stores them into the options object
+    def load_from_filesystem(options)
+      return if options[:skip_metadata]
+
+      # Load localised data
+      Loader.language_folders(options[:metadata_path]).each do |lng_folder|
+        language = File.basename(lng_folder)
+        (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+          path = File.join(lng_folder, "#{key}.txt")
+          next unless File.exist?(path)
+
+          UI.message("Loading '#{path}'...")
+          options[key] ||= {}
+          options[key][language] ||= File.read(path)
+        end
+      end
+
+      # Load non localised data
+      (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
+        path = File.join(options[:metadata_path], "#{key}.txt")
+        next unless File.exist?(path)
+
+        UI.message("Loading '#{path}'...")
+        options[key] ||= File.read(path)
+      end
+    end
+
+    private
+
+    def set_review_information(v, options)
+      return unless options[:app_review_information]
+      info = options[:app_review_information]
+      UI.user_error!("`app_review_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
+
+      v.review_first_name = info[:first_name] if info[:first_name]
+      v.review_last_name = info[:last_name] if info[:last_name]
+      v.review_phone_number = info[:phone_number] if info[:phone_number]
+      v.review_email = info[:email_address] if info[:email_address]
+      v.review_demo_user = info[:demo_user] if info[:demo_user]
+      v.review_demo_password = info[:demo_password] if info[:demo_password]
+      v.review_user_needed = (v.review_demo_user.to_s + v.review_demo_password.to_s).length > 0
+      v.review_notes = info[:notes] if info[:notes]
+    end
+
+    def set_app_rating(v, options)
+      return unless options[:app_rating_config_path]
+
+      require 'json'
+      begin
+        json = JSON.parse(File.read(options[:app_rating_config_path]))
+      rescue => ex
+        UI.error(ex.to_s)
+        UI.user_error!("Error parsing JSON file at path '#{options[:app_rating_config_path]}'")
+      end
+      v.update_rating(json)
+    end
+  end
+end