fastlane_pricing_fix 2.212.1

data/deliver/lib/deliver/upload_price_tier.rb

@@ -0,0 +1,42 @@
+require_relative 'module'
+require 'spaceship'
+
+module Deliver
+  # Set the app's pricing
+  class UploadPriceTier
+    def upload(options)
+      return unless options[:price_tier]
+
+      price_tier = options[:price_tier].to_s
+
+      app = Deliver.cache[:app]
+
+      attributes = {}
+
+      # Check App update method to understand how to use territory_ids.
+      territory_ids = nil # nil won't update app's territory_ids, empty array would remove app from sale.
+
+      # As of 2020-09-14:
+      # Official App Store Connect does not have an endpoint to get app prices for an app
+      # Need to get prices from the app's relationships
+      # Prices from app's relationship doess not have price tier so need to fetch app price with price tier relationship
+      app_prices = app.prices
+      if app_prices.first
+        app_price = Spaceship::ConnectAPI.get_app_price(app_price_id: app_prices.first.id, includes: "priceTier").first
+        old_price = app_price.price_tier.id
+      else
+        UI.message("App has no prices yet... Enabling all countries in App Store Connect")
+        territory_ids = Spaceship::ConnectAPI::Territory.all.map(&:id)
+        attributes[:availableInNewTerritories] = true
+      end
+
+      if price_tier == old_price
+        UI.success("Price Tier unchanged (tier #{old_price})")
+        return
+      end
+
+      app.update(attributes: attributes, app_price_tier_id: price_tier, territory_ids: territory_ids)
+      UI.success("Successfully updated the pricing from #{old_price} to #{price_tier}")
+    end
+  end
+end

data/deliver/lib/deliver/upload_screenshots.rb

@@ -0,0 +1,271 @@
+require 'fastlane_core'
+require 'spaceship/tunes/tunes'
+require 'digest/md5'
+
+require_relative 'app_screenshot'
+require_relative 'module'
+require_relative 'loader'
+require_relative 'app_screenshot_iterator'
+
+module Deliver
+  # upload screenshots to App Store Connect
+  class UploadScreenshots
+    DeleteScreenshotSetJob = Struct.new(:app_screenshot_set, :localization)
+    UploadScreenshotJob = Struct.new(:app_screenshot_set, :path)
+
+    def upload(options, screenshots)
+      return if options[:skip_screenshots]
+      return if options[:edit_live]
+
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = app.get_edit_app_store_version(platform: platform)
+      UI.user_error!("Could not find a version to edit for app '#{app.name}' for '#{platform}'") unless version
+
+      UI.important("Will begin uploading snapshots for '#{version.version_string}' on App Store Connect")
+
+      UI.message("Starting with the upload of screenshots...")
+      screenshots_per_language = screenshots.group_by(&:language)
+
+      localizations = version.get_app_store_version_localizations
+
+      if options[:overwrite_screenshots]
+        delete_screenshots(localizations, screenshots_per_language)
+      end
+
+      # Finding languages to enable
+      languages = screenshots_per_language.keys
+      locales_to_enable = languages - localizations.map(&:locale)
+
+      if locales_to_enable.count > 0
+        lng_text = "language"
+        lng_text += "s" if locales_to_enable.count != 1
+        Helper.show_loading_indicator("Activating #{lng_text} #{locales_to_enable.join(', ')}...")
+
+        locales_to_enable.each do |locale|
+          version.create_app_store_version_localization(attributes: {
+            locale: locale
+          })
+        end
+
+        Helper.hide_loading_indicator
+
+        # Refresh version localizations
+        localizations = version.get_app_store_version_localizations
+      end
+
+      upload_screenshots(localizations, screenshots_per_language)
+
+      Helper.show_loading_indicator("Sorting screenshots uploaded...")
+      sort_screenshots(localizations)
+      Helper.hide_loading_indicator
+
+      UI.success("Successfully uploaded screenshots to App Store Connect")
+    end
+
+    def delete_screenshots(localizations, screenshots_per_language, tries: 5)
+      tries -= 1
+
+      worker = FastlaneCore::QueueWorker.new do |job|
+        start_time = Time.now
+        target = "#{job.localization.locale} #{job.app_screenshot_set.screenshot_display_type}"
+        begin
+          UI.verbose("Deleting '#{target}'")
+          job.app_screenshot_set.delete!
+          UI.message("Deleted '#{target}' -  (#{Time.now - start_time} secs)")
+        rescue => error
+          UI.error("Failed to delete screenshot #{target} - (#{Time.now - start_time} secs)")
+          UI.error(error.message)
+        end
+      end
+
+      iterator = AppScreenshotIterator.new(localizations)
+      iterator.each_app_screenshot_set do |localization, app_screenshot_set|
+        # Only delete screenshots if trying to upload
+        next unless screenshots_per_language.keys.include?(localization.locale)
+
+        UI.verbose("Queued delete sceeenshot set job for #{localization.locale} #{app_screenshot_set.screenshot_display_type}")
+        worker.enqueue(DeleteScreenshotSetJob.new(app_screenshot_set, localization))
+      end
+
+      worker.start
+
+      # Verify all screenshots have been deleted
+      # Sometimes API requests will fail but screenshots will still be deleted
+      count = iterator.each_app_screenshot_set.map { |_, app_screenshot_set| app_screenshot_set }
+                      .reduce(0) { |sum, app_screenshot_set| sum + app_screenshot_set.app_screenshots.size }
+
+      UI.important("Number of screenshots not deleted: #{count}")
+      if count > 0
+        if tries.zero?
+          UI.user_error!("Failed verification of all screenshots deleted... #{count} screenshot(s) still exist")
+        else
+          UI.error("Failed to delete all screenshots... Tries remaining: #{tries}")
+          delete_screenshots(localizations, screenshots_per_language, tries: tries)
+        end
+      else
+        UI.message("Successfully deleted all screenshots")
+      end
+    end
+
+    def upload_screenshots(localizations, screenshots_per_language, tries: 5)
+      tries -= 1
+
+      # Upload screenshots
+      worker = FastlaneCore::QueueWorker.new do |job|
+        begin
+          UI.verbose("Uploading '#{job.path}'...")
+          start_time = Time.now
+          job.app_screenshot_set.upload_screenshot(path: job.path, wait_for_processing: false)
+          UI.message("Uploaded '#{job.path}'... (#{Time.now - start_time} secs)")
+        rescue => error
+          UI.error(error)
+        end
+      end
+
+      # Each app_screenshot_set can have only 10 images
+      number_of_screenshots_per_set = {}
+      total_number_of_screenshots = 0
+
+      iterator = AppScreenshotIterator.new(localizations)
+      iterator.each_local_screenshot(screenshots_per_language) do |localization, app_screenshot_set, screenshot|
+        # Initialize counter on each app screenshot set
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
+
+        if number_of_screenshots_per_set[app_screenshot_set] >= 10
+          UI.error("Too many screenshots found for device '#{screenshot.device_type}' in '#{screenshot.language}', skipping this one (#{screenshot.path})")
+          next
+        end
+
+        checksum = UploadScreenshots.calculate_checksum(screenshot.path)
+        duplicate = (app_screenshot_set.app_screenshots || []).any? { |s| s.source_file_checksum == checksum }
+
+        # Enqueue uploading job if it's not duplicated otherwise screenshot will be skipped
+        if duplicate
+          UI.message("Previous uploaded. Skipping '#{screenshot.path}'...")
+        else
+          UI.verbose("Queued upload sceeenshot job for #{localization.locale} #{app_screenshot_set.screenshot_display_type} #{screenshot.path}")
+          worker.enqueue(UploadScreenshotJob.new(app_screenshot_set, screenshot.path))
+          number_of_screenshots_per_set[app_screenshot_set] += 1
+        end
+
+        total_number_of_screenshots += 1
+      end
+
+      worker.start
+
+      UI.verbose('Uploading jobs are completed')
+
+      Helper.show_loading_indicator("Waiting for all the screenshots to finish being processed...")
+      states = wait_for_complete(iterator)
+      Helper.hide_loading_indicator
+      retry_upload_screenshots_if_needed(iterator, states, total_number_of_screenshots, tries, localizations, screenshots_per_language)
+
+      UI.message("Successfully uploaded all screenshots")
+    end
+
+    # Verify all screenshots have been processed
+    def wait_for_complete(iterator)
+      loop do
+        states = iterator.each_app_screenshot.map { |_, _, app_screenshot| app_screenshot }.each_with_object({}) do |app_screenshot, hash|
+          state = app_screenshot.asset_delivery_state['state']
+          hash[state] ||= 0
+          hash[state] += 1
+        end
+
+        is_processing = states.fetch('UPLOAD_COMPLETE', 0) > 0
+        return states unless is_processing
+
+        UI.verbose("There are still incomplete screenshots - #{states}")
+        sleep(5)
+      end
+    end
+
+    # Verify all screenshots states on App Store Connect are okay
+    def retry_upload_screenshots_if_needed(iterator, states, number_of_screenshots, tries, localizations, screenshots_per_language)
+      is_failure = states.fetch("FAILED", 0) > 0
+      is_missing_screenshot = !screenshots_per_language.empty? && !verify_local_screenshots_are_uploaded(iterator, screenshots_per_language)
+      return unless is_failure || is_missing_screenshot
+
+      if tries.zero?
+        iterator.each_app_screenshot.select { |_, _, app_screenshot| app_screenshot.error? }.each do |localization, _, app_screenshot|
+          UI.error("#{app_screenshot.file_name} for #{localization.locale} has error(s) - #{app_screenshot.error_messages.join(', ')}")
+        end
+        incomplete_screenshot_count = states.reject { |k, v| k == 'COMPLETE' }.reduce(0) { |sum, (k, v)| sum + v }
+        UI.user_error!("Failed verification of all screenshots uploaded... #{incomplete_screenshot_count} incomplete screenshot(s) still exist")
+      else
+        UI.error("Failed to upload all screenshots... Tries remaining: #{tries}")
+        # Delete bad entries before retry
+        iterator.each_app_screenshot do |_, _, app_screenshot|
+          app_screenshot.delete! unless app_screenshot.complete?
+        end
+        upload_screenshots(localizations, screenshots_per_language, tries: tries)
+      end
+    end
+
+    # Return `true` if all the local screenshots are uploaded to App Store Connect
+    def verify_local_screenshots_are_uploaded(iterator, screenshots_per_language)
+      # Check if local screenshots' checksum exist on App Store Connect
+      checksum_to_app_screenshot = iterator.each_app_screenshot.map { |_, _, app_screenshot| [app_screenshot.source_file_checksum, app_screenshot] }.to_h
+
+      number_of_screenshots_per_set = {}
+      missing_local_screenshots = iterator.each_local_screenshot(screenshots_per_language).select do |_, app_screenshot_set, local_screenshot|
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
+        checksum = UploadScreenshots.calculate_checksum(local_screenshot.path)
+
+        if checksum_to_app_screenshot[checksum]
+          next(false)
+        else
+          is_missing = number_of_screenshots_per_set[app_screenshot_set] < 10 # if it's more than 10, it's skipped
+          number_of_screenshots_per_set[app_screenshot_set] += 1
+          next(is_missing)
+        end
+      end
+
+      missing_local_screenshots.each do |_, _, screenshot|
+        UI.error("#{screenshot.path} is missing on App Store Connect.")
+      end
+
+      missing_local_screenshots.empty?
+    end
+
+    def sort_screenshots(localizations)
+      require 'naturally'
+      iterator = AppScreenshotIterator.new(localizations)
+
+      # Re-order screenshots within app_screenshot_set
+      worker = FastlaneCore::QueueWorker.new do |app_screenshot_set|
+        original_ids = app_screenshot_set.app_screenshots.map(&:id)
+        sorted_ids = Naturally.sort(app_screenshot_set.app_screenshots, by: :file_name).map(&:id)
+        if original_ids != sorted_ids
+          app_screenshot_set.reorder_screenshots(app_screenshot_ids: sorted_ids)
+        end
+      end
+
+      iterator.each_app_screenshot_set do |_, app_screenshot_set|
+        worker.enqueue(app_screenshot_set)
+      end
+
+      worker.start
+    end
+
+    def collect_screenshots(options)
+      return [] if options[:skip_screenshots]
+      return Loader.load_app_screenshots(options[:screenshots_path], options[:ignore_language_directory_validation])
+    end
+
+    # helper method so Spaceship::Tunes.client.available_languages is easier to test
+    def self.available_languages
+      # 2020-08-24 - Available locales are not available as an endpoint in App Store Connect
+      # Update with Spaceship::Tunes.client.available_languages.sort (as long as endpoint is avilable)
+      Deliver::Languages::ALL_LANGUAGES
+    end
+
+    # helper method to mock this step in tests
+    def self.calculate_checksum(path)
+      bytes = File.binread(path)
+      Digest::MD5.hexdigest(bytes)
+    end
+  end
+end

data/deliver/lib/deliver.rb

@@ -0,0 +1,15 @@
+require_relative 'deliver/languages'
+require_relative 'deliver/loader'
+require_relative 'deliver/options'
+require_relative 'deliver/commands_generator'
+require_relative 'deliver/detect_values'
+require_relative 'deliver/runner'
+require_relative 'deliver/upload_metadata'
+require_relative 'deliver/upload_screenshots'
+require_relative 'deliver/upload_price_tier'
+require_relative 'deliver/submit_for_review'
+require_relative 'deliver/app_screenshot'
+require_relative 'deliver/html_generator'
+require_relative 'deliver/generate_summary'
+
+require_relative 'deliver/module'

data/fastlane/README.md

@@ -0,0 +1,11 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<h3 align="center">The <i>fastlane</i> docs were moved to <a href='https://docs.fastlane.tools/'>docs.fastlane.tools</a></h3>

data/fastlane/lib/assets/ActionDetails.md.erb

@@ -0,0 +1,106 @@
+<!--
+This file is auto-generated and will be re-generated every time the docs are updated.
+To modify it, go to its source at https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/actions/<%= @action_filename %>
+-->
+
+# <%= @action.action_name %>
+
+<% action = @action %>
+<%= action.description %>
+
+<%= "> #{action.deprecated_notes.gsub("\n", "<br>")}" unless action.deprecated_notes.to_s.empty? %>
+
+<% if @custom_content %>
+<%= @custom_content %>
+<hr />
+<% else %>
+<%= "> #{action.details.gsub(/(?<!\|)\n/, "<br>").gsub(/\|(?=\n|$)/, "")}" unless action.details.to_s.empty? %>
+<% end %>
+
+<%= action.action_name %> ||
+---|---
+Supported platforms | <%= [:ios, :android, :mac].find_all { |a| action.is_supported?(a) }.join(", ") %>
+Author | @<%= Array(action.author || action.authors).join(", @") %>
+<%- unless action.return_value.to_s.empty? -%>
+Returns | <%= action.return_value.gsub("\n", "<br>") %>
+<%- end -%>
+
+<% if (action.example_code || []).count > 0 %>
+
+## <%= action.example_code.count %> Example<%= (action.example_code.count > 1) ? "s" : "" %>
+<% action.example_code.each do |current_sample| %>
+```ruby
+<%= current_sample.gsub("          ", "") %>
+```
+<% end %><%# End of action.example_code... %>
+<% end %><%# End of if %>
+
+<% if action.available_options && action.available_options.first.kind_of?(FastlaneCore::ConfigItem) %>
+
+## Parameters
+
+Key | Description | Default
+----|-------------|--------
+<%- (action.available_options || []).each do |config_item| -%>
+  <%- next unless config_item.kind_of?(FastlaneCore::ConfigItem) -%>
+  <%- next if config_item.description.to_s.length == 0 -%>
+  `<%= config_item.key %>` | <%= config_item.description.gsub(/(?<!\\)\|/, "\\|") %> | <%= config_item.doc_default_value %>
+<%- end %>
+<em id="parameters-legend-dynamic">* = default value is dependent on the user's system</em>
+<% end %><%# End of action.available_options... %>
+
+<hr />
+
+<% if action.output && action.output.kind_of?(Array) && action.output.length > 0 %>
+
+## Lane Variables
+
+Actions can communicate with each other using a shared hash `lane_context`, that can be accessed in other actions, plugins or your lanes: `lane_context[SharedValues:XYZ]`. The `<%= @action.action_name %>` action generates the following Lane Variables:
+
+SharedValue | Description 
+------------|-------------
+<%- (action.output || []).each do |array_item| -%>
+  <%- next unless array_item.kind_of?(Array) -%>
+  <%- next if array_item.length != 2 -%>
+  `SharedValues::<%= array_item[0] %>` | <%= array_item[1] %>
+<%- end %>
+To get more information check the [Lanes documentation](https://docs.fastlane.tools/advanced/lanes/#lane-context).
+<hr />
+<% end %><%# End of action.output... %>
+
+## Documentation
+
+To show the documentation in your terminal, run
+```no-highlight
+fastlane action <%= action.action_name %>
+```
+
+<hr />
+
+## CLI
+
+It is recommended to add the above action into your `Fastfile`, however sometimes you might want to run one-offs. To do so, you can run the following command from your terminal
+
+```no-highlight
+fastlane run <%= @action.action_name %>
+```
+
+To pass parameters, make use of the `:` symbol, for example
+
+```no-highlight
+fastlane run <%= @action.action_name %> parameter1:"value1" parameter2:"value2"
+```
+
+It's important to note that the CLI supports primitive types like integers, floats, booleans, and strings. Arrays can be passed as a comma delimited string (e.g. `param:"1,2,3"`). Hashes are not currently supported.
+
+It is recommended to add all _fastlane_ actions you use to your `Fastfile`.
+
+<hr />
+
+## Source code
+
+This action, just like the rest of _fastlane_, is fully open source, <a href="https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/actions/<%= @action_filename %>" target="_blank">view the source code on GitHub</a>
+
+<hr />
+
+<a href="/actions/"><b>Back to actions</b></a>

data/fastlane/lib/assets/Actions.md.erb

@@ -0,0 +1,43 @@
+<!--
+This file is auto-generated and will be re-generated every time the docs are updated.
+To modify it, go to its source at https://github.com/fastlane/fastlane/blob/master/fastlane/lib/assets/Actions.md.erb
+-->
+
+{!docs/includes/setup-fastlane-header.md!}
+
+# fastlane actions
+
+This page contains a list of all built-in fastlane actions and their available options.
+
+To get the most up-to-date information from the command line on your current version you can also run
+
+```sh
+fastlane actions # list all available fastlane actions
+fastlane action [action_name] # more information for a specific action
+```
+
+You can import another `Fastfile` by using the `import` action. This is useful if you have shared lanes across multiple apps and you want to store a `Fastfile` in a separate folder. The path must be relative to the `Fastfile` this is called from.
+
+```ruby
+import './path/to/other/Fastfile'
+```
+
+For _fastlane_ plugins, check out the [available plugins](/plugins/available-plugins/) page.
+If you want to create your own action, check out the [local actions](/create-action/#local-actions) page.
+
+<%- @categories.each do |category, actions| -%>
+- [<%= category %>](#<%= category.gsub(" ", "-").downcase %>)
+<%- end -%>
+- [Plugins](/plugins/available-plugins/)
+
+<%- @categories.each do |category, actions| %>
+# <%= category %>
+
+Action | Description | Supported Platforms
+---|---|---
+<%- actions.sort.to_h.each do |_number_of_launches, action| -%>
+<%- link = "/actions/#{action.action_name}/" -%>
+<a href="<%= link %>"><%= action.action_name %></a> | <%= action.description %> | <%= [:ios, :android, :mac].find_all { |a| action.is_supported?(a) }.join(", ") %>
+<%- end %><%# End of actions.sort... %>
+
+<%- end %><%# End of categories.each %>

data/fastlane/lib/assets/AppfileTemplate

@@ -0,0 +1,6 @@
+# app_identifier("[[APP_IDENTIFIER]]") # The bundle identifier of your app
+# apple_id("[[APPLE_ID]]") # Your Apple Developer Portal username
+
+[[TEAMS]]
+# For more information about the Appfile, see:
+#     https://docs.fastlane.tools/advanced/#appfile

data/fastlane/lib/assets/AppfileTemplate.swift

@@ -0,0 +1,7 @@
+var appIdentifier: String { return "[[APP_IDENTIFIER]]" } // The bundle identifier of your app
+var appleID: String { return "[[APPLE_ID]]" } // Your Apple Developer Portal username
+
+[[TEAMS]]
+
+// For more information about the Appfile, see:
+//     https://docs.fastlane.tools/advanced/#appfile

data/fastlane/lib/assets/AppfileTemplateAndroid

@@ -0,0 +1,2 @@
+json_key_file("[[JSON_KEY_FILE]]") # Path to the json secret file - Follow https://docs.fastlane.tools/actions/supply/#setup to get one
+package_name("[[PACKAGE_NAME]]") # e.g. com.krausefx.app

data/fastlane/lib/assets/DefaultFastfileTemplate

@@ -0,0 +1,20 @@
+# This file contains the fastlane.tools configuration
+# You can find the documentation at https://docs.fastlane.tools
+#
+# For a list of all available actions, check out
+#
+#     https://docs.fastlane.tools/actions
+#
+# For a list of all available plugins, check out
+#
+#     https://docs.fastlane.tools/plugins/available-plugins
+#
+
+# Uncomment the line if you want fastlane to automatically update itself
+# update_fastlane
+
+default_platform(:ios)
+
+platform :ios do
+[[LANES]]
+end

data/fastlane/lib/assets/DefaultFastfileTemplate.swift

@@ -0,0 +1,13 @@
+// This file contains the fastlane.tools configuration
+// You can find the documentation at https://docs.fastlane.tools
+//
+// For a list of all available actions, check out
+//
+//     https://docs.fastlane.tools/actions
+//
+
+import Foundation
+
+class Fastfile: LaneFile {
+[[LANES]]
+}

data/fastlane/lib/assets/completions/completion.bash

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+_fastlane_complete() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local completions=""
+  local file
+
+  # look for Fastfile either in this directory or fastlane/ then grab the lane names
+  if [[ -e "Fastfile" ]]; then
+    file="Fastfile"
+  elif [[ -e "fastlane/Fastfile" ]]; then
+    file="fastlane/Fastfile"
+  elif [[ -e ".fastlane/Fastfile" ]]; then
+    file=".fastlane/Fastfile"
+  else
+    return 1
+  fi
+
+  # parse 'beta' out of 'lane :beta do', etc
+  completions="$(sed -En 's/^[ 	]*lane +:([^ 	]+).*$/\1/p' "$file")"
+  completions="$completions update_fastlane"
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$word") )
+}
+

data/fastlane/lib/assets/completions/completion.fish

@@ -0,0 +1,39 @@
+# This function was taken from https://github.com/Carthage/Carthage/blob/master/Source/Scripts/carthage-fish-completion
+function __fish_fastlane_needs_subcommand
+  set cmd (commandline -opc)
+  if [ (count $cmd) -eq 1 -a $cmd[1] = 'fastlane' ]
+    return 0
+  end
+    return 1
+end
+
+if test -e "Fastfile"
+  set file "Fastfile"
+else if test -e "fastlane/Fastfile"
+  set file "fastlane/Fastfile"
+else if test -e ".fastlane/Fastfile"
+  set file ".fastlane/Fastfile"
+else
+  exit 1
+end
+
+set commands (string match --regex '.*lane\ \:(?!private_)([^\s]*)\ do' (cat $file))
+
+set commands_string
+
+# Fish returns the fully matched string, plus the capture group. The actual captured value
+# is every other line, starting at line 2.
+set use_command false
+
+for line in $commands
+  if [ $use_command = true ]
+    set commands_string "$commands_string $line"
+    set use_command false
+  else
+    set use_command true
+  end
+end
+
+set commands_string "$commands_string update_fastlane"
+
+complete -c fastlane -n '__fish_fastlane_needs_subcommand' -a (string trim $commands_string) -f

data/fastlane/lib/assets/completions/completion.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# shellcheck disable=SC2155
+# shellcheck disable=SC1090
+# shellcheck disable=SC2039
+
+if [ -n "$BASH_VERSION" ]; then
+  source ~/.fastlane/completions/completion.bash
+elif [ -n "$ZSH_VERSION" ]; then
+  source ~/.fastlane/completions/completion.zsh
+fi
+
+# Do not remove v0.0.1

data/fastlane/lib/assets/completions/completion.zsh

@@ -0,0 +1,24 @@
+#!/bin/zsh
+
+_fastlane_complete() {
+  local word completions file
+  word="$1"
+
+  # look for Fastfile either in this directory or fastlane/ then grab the lane names
+  if [[ -e "Fastfile" ]] then
+    file="Fastfile"
+  elif [[ -e "fastlane/Fastfile" ]] then
+    file="fastlane/Fastfile"
+  elif [[ -e ".fastlane/Fastfile" ]] then
+    file=".fastlane/Fastfile"
+  else
+    return 1
+  fi
+
+  # parse 'beta' out of 'lane :beta do', etc
+  completions="$(sed -En 's/^[ 	]*lane +:([^ 	]+).*$/\1/p' "$file")"
+  completions="$completions update_fastlane"
+
+  reply=( "${=completions}" )
+}
+