fastlane_hotfix 2.165.0

data/precheck/lib/precheck/rules/test_words_rule.rb

@@ -0,0 +1,30 @@
+require_relative 'abstract_text_match_rule'
+
+module Precheck
+  class TestWordsRule < AbstractTextMatchRule
+    def self.key
+      :test_words
+    end
+
+    def self.env_name
+      "RULE_TEST_WORDS"
+    end
+
+    def self.friendly_name
+      "No words indicating test content"
+    end
+
+    def self.description
+      "using text indicating this release is a test"
+    end
+
+    def lowercased_words_to_look_for
+      [
+        "testing",
+        "just a test",
+        "alpha test",
+        "beta test"
+      ].map(&:downcase)
+    end
+  end
+end

data/precheck/lib/precheck/rules/unreachable_urls_rule.rb

@@ -0,0 +1,47 @@
+require 'addressable'
+require 'faraday_middleware'
+
+require_relative '../rule'
+
+module Precheck
+  class UnreachableURLRule < URLRule
+    def self.key
+      :unreachable_urls
+    end
+
+    def self.env_name
+      "RULE_UNREACHABLE_URLS"
+    end
+
+    def self.friendly_name
+      "No broken urls"
+    end
+
+    def self.description
+      "unreachable URLs in app metadata"
+    end
+
+    def rule_block
+      return lambda { |url|
+        url = url.to_s.strip
+        return RuleReturn.new(validation_state: Precheck::VALIDATION_STATES[:failed], failure_data: "empty url") if url.empty?
+
+        begin
+          uri = Addressable::URI.parse(url)
+          uri.fragment = nil
+          request = Faraday.new(uri.normalize.to_s) do |connection|
+            connection.use(FaradayMiddleware::FollowRedirects)
+            connection.adapter(:net_http)
+          end
+          return RuleReturn.new(validation_state: Precheck::VALIDATION_STATES[:failed], failure_data: url) unless request.head.status == 200
+        rescue StandardError => e
+          UI.verbose("URL #{url} not reachable 😵: #{e.message}")
+          # I can only return :fail here, but I also want to return #{url}
+          return RuleReturn.new(validation_state: VALIDATION_STATES[:failed], failure_data: "unreachable: #{url}")
+        end
+
+        return RuleReturn.new(validation_state: VALIDATION_STATES[:passed])
+      }
+    end
+  end
+end

data/precheck/lib/precheck/runner.rb

@@ -0,0 +1,197 @@
+require 'terminal-table'
+require 'fastlane_core/print_table'
+require 'spaceship/tunes/tunes'
+require 'spaceship/tunes/application'
+
+require_relative 'rule_processor'
+require_relative 'options'
+
+module Precheck
+  class Runner
+    attr_accessor :spaceship
+
+    # Uses the spaceship to download app metadata and then run all rule checkers
+    def run
+      Precheck.config.load_configuration_file(Precheck.precheckfile_name)
+
+      FastlaneCore::PrintTable.print_values(config: Precheck.config,
+                                         hide_keys: [:output_path],
+                                             title: "Summary for precheck #{Fastlane::VERSION}")
+
+      if api_token
+
+        # As of 2020-09-15, App Store Connect API does not have support for IAPs yet
+        # This means that API Key will fail if checking for IAPs.
+        #
+        # There is also a check in Deliver::Runner for this.
+        # Please remove check in Deliver when the API support IAPs.
+        if Precheck.config[:include_in_app_purchases]
+          UI.user_error!("Precheck cannot check In-app purchases with the App Store Connect API Key (yet). Exclude In-app purchases from precheck or use Apple ID login")
+        end
+
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      elsif Spaceship::Tunes.client.nil?
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
+        UI.message("Starting login with user '#{Precheck.config[:username]}'")
+        Spaceship::ConnectAPI.login(Precheck.config[:username], use_portal: false, use_tunes: true)
+
+        UI.message("Successfully logged in")
+      end
+
+      UI.message("Checking app for precheck rule violations")
+
+      ensure_app_exists!
+
+      processor_result = check_for_rule_violations(app: app, app_version: latest_app_version)
+
+      if processor_result.items_not_checked?
+        print_items_not_checked(processor_result: processor_result)
+      end
+
+      if processor_result.has_errors_or_warnings?
+        summary_table = build_potential_problems_table(processor_result: processor_result)
+        puts(summary_table)
+      end
+
+      if processor_result.should_trigger_user_error?
+        UI.user_error!("precheck 👮‍♀️ 👮  found one or more potential problems that must be addressed before submitting to review")
+        return false
+      end
+
+      if processor_result.has_errors_or_warnings?
+        UI.important("precheck 👮‍♀️ 👮  found one or more potential metadata problems, but this won't prevent fastlane from completing 👍".yellow)
+      end
+
+      if !processor_result.has_errors_or_warnings? && !processor_result.items_not_checked?
+        UI.message("precheck 👮‍♀️ 👮  finished without detecting any potential problems 🛫".green)
+      end
+
+      return true
+    end
+
+    def api_token
+      @api_token ||= Spaceship::ConnectAPI::Token.create(Precheck.config[:api_key]) if Precheck.config[:api_key]
+      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(Precheck.config[:api_key_path]) if Precheck.config[:api_key_path]
+      return @api_token
+    end
+
+    def print_items_not_checked(processor_result: nil)
+      names = processor_result.items_not_checked.map(&:friendly_name)
+      UI.message("😶  Metadata fields not checked by any rule: #{names.join(', ')}".yellow) if names.length > 0
+    end
+
+    def build_potential_problems_table(processor_result: nil)
+      error_results = processor_result.error_results
+      warning_results = processor_result.warning_results
+
+      rows = []
+
+      warning_results.each do |rule, results|
+        results.each do |result|
+          rows << [result.item.friendly_name, result.rule_return.failure_data.yellow]
+        end
+      end
+
+      error_results.each do |rule, results|
+        results.each do |result|
+          rows << [result.item.friendly_name, result.rule_return.failure_data.red]
+        end
+      end
+
+      if rows.length == 0
+        return nil
+      else
+        title_text = "Potential problems"
+        if error_results.length > 0
+          title_text = title_text.red
+        else
+          title_text = title_text.yellow
+        end
+        return Terminal::Table.new(
+          title: title_text,
+          headings: ["Field", "Failure reason"],
+          rows: FastlaneCore::PrintTable.transform_output(rows)
+        ).to_s
+      end
+    end
+
+    def check_for_rule_violations(app: nil, app_version: nil)
+      Precheck::RuleProcessor.process_app_and_version(
+        app: app,
+        app_version: app_version,
+        rules: Precheck::Options.rules
+      )
+    end
+
+    def rendered_failed_results_table(failed_results: nil)
+      rows = []
+      failed_results.each do |failed_result|
+        rows << [failed_result.rule.key, failed_result.item.friendly_name]
+      end
+
+      return Terminal::Table.new(
+        title: "Failed rules".red,
+        headings: ["Name", "App metadata field: (language code)"],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      ).to_s
+    end
+
+    def rendered_rules_checked_table(rules_checked: nil)
+      rows = []
+      rules_checked.each do |rule|
+        rows << [rule.key, rule.description]
+      end
+
+      return Terminal::Table.new(
+        title: "Enabled rules".green,
+        headings: ["Name", "Description"],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      ).to_s
+    end
+
+    def rendered_skipped_rules_table(skipped_rules: nil)
+      return nil if skipped_rules.empty?
+
+      rows = []
+      skipped_rules.each do |rule|
+        rows << [rule.key, rule.description]
+      end
+
+      return Terminal::Table.new(
+        title: "Skipped rules".yellow,
+        headings: ["Name", "Description"],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      ).to_s
+    end
+
+    def build_items_not_checked_table(items_not_checked: nil)
+      rows = []
+      items_not_checked.each do |item|
+        rows << [item.item_name, item.friendly_name]
+      end
+
+      return Terminal::Table.new(
+        title: "Not analyzed".yellow,
+        headings: ["Name", "Friendly name"],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      ).to_s
+    end
+
+    def app
+      Spaceship::ConnectAPI::App.find(Precheck.config[:app_identifier])
+    end
+
+    def latest_app_version
+      platform = Spaceship::ConnectAPI::Platform.map(Precheck.config[:platform])
+      @latest_version ||= app.get_edit_app_store_version(platform: platform)
+    end
+
+    # Makes sure the current App ID exists. If not, it will show an appropriate error message
+    def ensure_app_exists!
+      return if app
+      UI.user_error!("Could not find app with App Identifier '#{Precheck.config[:app_identifier]}'")
+    end
+  end
+end

data/produce/README.md

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

data/produce/lib/produce.rb

@@ -0,0 +1,6 @@
+require_relative 'produce/manager'
+require_relative 'produce/options'
+require_relative 'produce/developer_center'
+require_relative 'produce/itunes_connect'
+require_relative 'produce/available_default_languages'
+require_relative 'produce/module'

data/produce/lib/produce/available_default_languages.rb

@@ -0,0 +1,51 @@
+module Produce
+  class AvailableDefaultLanguages
+    # If you update this list, you probably also have to update these files:
+    # - fastlane_core/lib/fastlane_core/languages.rb
+    # - spaceship/lib/assets/languageMapping.json
+    # See this pull request for example: https://github.com/fastlane/fastlane/pull/14110
+    def self.all_languages
+      [
+        "Arabic",
+        "Catalan",
+        "Croatian",
+        "Czech",
+        "Brazilian Portuguese",
+        "Danish",
+        "Dutch",
+        "English",
+        "English_Australian",
+        "English_CA",
+        "English_UK",
+        "Finnish",
+        "French",
+        "French_CA",
+        "German",
+        "Greek",
+        "Hebrew",
+        "Hindi",
+        "Hungarian",
+        "Indonesian",
+        "Italian",
+        "Japanese",
+        "Korean",
+        "Malay",
+        "Norwegian",
+        "Polish",
+        "Portuguese",
+        "Romanian",
+        "Russian",
+        "Simplified Chinese",
+        "Slovak",
+        "Spanish",
+        "Spanish_MX",
+        "Swedish",
+        "Ukrainian",
+        "Thai",
+        "Traditional Chinese",
+        "Turkish",
+        "Vietnamese"
+      ]
+    end
+  end
+end

data/produce/lib/produce/cloud_container.rb

@@ -0,0 +1,82 @@
+require 'spaceship'
+require_relative 'module'
+
+module Produce
+  class CloudContainer
+    def create(options, _args)
+      login
+
+      container_identifier = options.container_identifier || UI.input("iCloud Container identifier: ")
+
+      if container_exists?(container_identifier)
+        UI.success("[DevCenter] iCloud Container '#{options.container_name} (#{options.container_identifier})' already exists, nothing to do on the Dev Center")
+        # Nothing to do here
+      else
+        container_name = options.container_name || container_identifier.gsub('.', ' ')
+
+        UI.success("Creating new iCloud Container '#{container_name}' with identifier '#{container_identifier}' on the Apple Dev Center")
+
+        container = Spaceship.cloud_container.create!(identifier: container_identifier, name: container_name)
+
+        if container.name != container_name
+          UI.important("Your container name includes non-ASCII characters, which are not supported by the Apple Developer Portal.")
+          UI.important("To fix this a unique (internal) name '#{container.name}' has been created for you.")
+        end
+
+        UI.message("Created iCloud Container #{container.cloud_container}")
+        UI.user_error!("Something went wrong when creating the new iCloud Container - it's not listed in the iCloud Container list") unless container_exists?(container_identifier)
+        UI.success("Finished creating new iCloud Container '#{container_name}' on the Dev Center")
+      end
+
+      return true
+    end
+
+    def associate(_options, args)
+      login
+
+      if !app_exists?
+        UI.message("[DevCenter] App '#{Produce.config[:app_identifier]}' does not exist, nothing to associate with the containers")
+      else
+        app = Spaceship.app.find(app_identifier)
+        UI.user_error!("Something went wrong when fetching the app - it's not listed in the apps list") if app.nil?
+
+        new_containers = []
+
+        UI.message("Validating containers before association")
+
+        args.each do |container_identifier|
+          if !container_exists?(container_identifier)
+            UI.message("[DevCenter] iCloud Container '#{container_identifier}' does not exist, please create it first, skipping for now")
+          else
+            new_containers.push(Spaceship.cloud_container.find(container_identifier))
+          end
+        end
+
+        UI.message("Finalising association with #{new_containers.count} containers")
+        app.associate_cloud_containers(new_containers)
+        UI.success("Done!")
+      end
+
+      return true
+    end
+
+    def login
+      UI.message("Starting login with user '#{Produce.config[:username]}'")
+      Spaceship.login(Produce.config[:username], nil)
+      Spaceship.select_team
+      UI.message("Successfully logged in")
+    end
+
+    def app_identifier
+      Produce.config[:app_identifier].to_s
+    end
+
+    def container_exists?(identifier)
+      Spaceship.cloud_container.find(identifier) != nil
+    end
+
+    def app_exists?
+      Spaceship.app.find(app_identifier) != nil
+    end
+  end
+end

data/produce/lib/produce/commands_generator.rb

@@ -0,0 +1,236 @@
+require 'commander'
+
+require 'fastlane/version'
+require 'fastlane_core/configuration/config_item'
+require_relative 'module'
+require_relative 'manager'
+require_relative 'options'
+
+HighLine.track_eof = false
+
+module Produce
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'produce'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'produce\''
+      program :help, 'Author', 'Felix Krause <produce@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'Documentation', 'https://docs.fastlane.tools/actions/produce/'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+      global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+
+      command :create do |c|
+        c.syntax = 'fastlane produce create'
+        c.description = 'Creates a new app on App Store Connect and the Apple Developer Portal'
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__)
+
+          puts(Produce::Manager.start_producing)
+        end
+      end
+
+      command :enable_services do |c|
+        c.syntax = 'fastlane produce enable_services -a APP_IDENTIFIER SERVICE1, SERVICE2, ...'
+        c.description = 'Enable specific Application Services for a specific app on the Apple Developer Portal'
+        c.example('Enable HealthKit, HomeKit and Passbook', 'fastlane produce enable_services -a com.example.app --healthkit --homekit --passbook')
+
+        c.option('--access-wifi', 'Enable Access WiFi')
+        c.option('--app-group', 'Enable App Groups')
+        c.option('--apple-pay', 'Enable Apple Pay')
+        c.option('--auto-fill-credential', 'Enable AutoFill Credential')
+        c.option('--associated-domains', 'Enable Associated Domains')
+        c.option('--data-protection STRING', String, 'Enable Data Protection, suitable values are "complete", "unlessopen" and "untilfirstauth"')
+        c.option('--game-center', 'Enable Game Center')
+        c.option('--healthkit', 'Enable HealthKit')
+        c.option('--homekit', 'Enable HomeKit')
+        c.option('--hotspot', 'Enable Hotspot')
+        c.option('--icloud STRING', String, 'Enable iCloud, suitable values are "legacy" and "cloudkit"')
+        c.option('--in-app-purchase', 'Enable In-App Purchase')
+        c.option('--inter-app-audio', 'Enable Inter-App-Audio')
+        c.option('--multipath', 'Enable Multipath')
+        c.option('--network-extension', 'Enable Network Extensions')
+        c.option('--nfc-tag-reading', 'Enable NFC Tag Reading')
+        c.option('--personal-vpn', 'Enable Personal VPN')
+        c.option('--passbook', 'Enable Passbook (deprecated)')
+        c.option('--push-notification', 'Enable Push notification (only enables the service, does not configure certificates)')
+        c.option('--sirikit', 'Enable SiriKit')
+        c.option('--vpn-conf', 'Enable VPN Configuration (deprecated)')
+        c.option('--wallet', 'Enable Wallet')
+        c.option('--wireless-conf', 'Enable Wireless Accessory Configuration')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          # Filter the options so that we can still build the configuration
+          allowed_keys = Produce::Options.available_options.collect(&:key)
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/service'
+          Produce::Service.enable(options, args)
+        end
+      end
+
+      command :disable_services do |c|
+        c.syntax = 'fastlane produce disable_services -a APP_IDENTIFIER SERVICE1, SERVICE2, ...'
+        c.description = 'Disable specific Application Services for a specific app on the Apple Developer Portal'
+        c.example('Disable HealthKit', 'fastlane produce disable_services -a com.example.app --healthkit')
+
+        c.option('--access-wifi', 'Disable Access WiFi')
+        c.option('--app-group', 'Disable App Groups')
+        c.option('--apple-pay', 'Disable Apple Pay')
+        c.option('--auto-fill-credential', 'Disable AutoFill Credential')
+        c.option('--associated-domains', 'Disable Associated Domains')
+        c.option('--data-protection', 'Disable Data Protection')
+        c.option('--game-center', 'Disable Game Center')
+        c.option('--healthkit', 'Disable HealthKit')
+        c.option('--homekit', 'Disable HomeKit')
+        c.option('--hotspot', 'Disable Hotspot')
+        c.option('--icloud', 'Disable iCloud')
+        c.option('--in-app-purchase', 'Disable In-App Purchase')
+        c.option('--inter-app-audio', 'Disable Inter-App-Audio')
+        c.option('--multipath', 'Disable Multipath')
+        c.option('--network-extension', 'Disable Network Extensions')
+        c.option('--nfc-tag-reading', 'Disable NFC Tag Reading')
+        c.option('--personal-vpn', 'Disable Personal VPN')
+        c.option('--passbook', 'Disable Passbook (deprecated)')
+        c.option('--push-notification', 'Disable Push notifications')
+        c.option('--sirikit', 'Disable SiriKit')
+        c.option('--vpn-conf', 'Disable VPN Configuration (deprecated)')
+        c.option('--wallet', 'Disable Wallet')
+        c.option('--wireless-conf', 'Disable Wireless Accessory Configuration')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          # Filter the options so that we can still build the configuration
+          allowed_keys = Produce::Options.available_options.collect(&:key)
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/service'
+          Produce::Service.disable(options, args)
+        end
+      end
+
+      command :group do |c|
+        c.syntax = 'fastlane produce group'
+        c.description = 'Ensure that a specific App Group exists'
+        c.example('Create group', 'fastlane produce group -g group.example.app -n "Example App Group"')
+
+        c.option('-n', '--group_name STRING', String, 'Name for the group that is created (PRODUCE_GROUP_NAME)')
+        c.option('-g', '--group_identifier STRING', String, 'Group identifier for the group (PRODUCE_GROUP_IDENTIFIER)')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          allowed_keys = Produce::Options.available_options.collect(&:key)
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/group'
+          Produce::Group.new.create(options, args)
+        end
+      end
+
+      command :associate_group do |c|
+        c.syntax = 'fastlane produce associate_group -a APP_IDENTIFIER GROUP_IDENTIFIER1, GROUP_IDENTIFIER2, ...'
+        c.description = 'Associate with a group, which is created if needed or simply located otherwise'
+        c.example('Associate with group', 'fastlane produce associate-group -a com.example.app group.example.com')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__)
+
+          require 'produce/group'
+          Produce::Group.new.associate(options, args)
+        end
+      end
+
+      command :cloud_container do |c|
+        c.syntax = 'fastlane produce cloud_container'
+        c.description = 'Ensure that a specific iCloud Container exists'
+        c.example('Create iCloud Container', 'fastlane produce cloud_container -g iCloud.com.example.app -n "Example iCloud Container"')
+
+        c.option('-n', '--container_name STRING', String, 'Name for the iCloud Container that is created (PRODUCE_CLOUD_CONTAINER_NAME)')
+        c.option('-g', '--container_identifier STRING', String, 'Identifier for the iCloud Container (PRODUCE_CLOUD_CONTAINER_IDENTIFIER')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          allowed_keys = Produce::Options.available_options.collect(&:key)
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/cloud_container'
+          Produce::CloudContainer.new.create(options, args)
+        end
+      end
+
+      command :associate_cloud_container do |c|
+        c.syntax = 'fastlane produce associate_cloud_container -a APP_IDENTIFIER CONTAINER_IDENTIFIER1, CONTAINER_IDENTIFIER2, ...'
+        c.description = 'Associate with a iCloud Container, which is created if needed or simply located otherwise'
+        c.example('Associate with iCloud Container', 'fastlane produce associate_cloud_container -a com.example.app iCloud.com.example.com')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__)
+
+          require 'produce/cloud_container'
+          Produce::CloudContainer.new.associate(options, args)
+        end
+      end
+
+      command :merchant do |c|
+        c.syntax = 'fastlane produce merchant'
+        c.description = 'Ensure that a specific Merchant exists'
+        c.example('Create merchant', 'fastlane produce merchant -o merchant.com.example.production -r "Example Merchant Production"')
+
+        c.option('-r', '--merchant_name STRING', String, 'Name for the merchant that is created (PRODUCE_MERCHANT_NAME)')
+        c.option('-o', '--merchant_identifier STRING', String, 'Merchant identifier for the merchant (PRODUCE_MERCHANT_IDENTIFIER)')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          extra_options = [FastlaneCore::ConfigItem.new(key: :merchant_name, optional: true), FastlaneCore::ConfigItem.new(key: :merchant_identifier)]
+          all_options = Produce::Options.available_options + extra_options
+          allowed_keys = all_options.collect(&:key)
+
+          Produce.config = FastlaneCore::Configuration.create(all_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/merchant'
+          Produce::Merchant.new.create(options, args)
+        end
+      end
+
+      command :associate_merchant do |c|
+        c.syntax = 'fastlane produce associate_merchant -a APP_IDENTIFIER MERCHANT_IDENTIFIER1, MERCHANT_IDENTIFIER2, ...'
+        c.description = 'Associate with a merchant for use with Apple Pay. Apple Pay will be enabled for this app.'
+        c.example('Associate with merchant', 'fastlane produce associate_merchant -a com.example.app merchant.com.example.production')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__)
+
+          require 'produce/merchant'
+          Produce::Merchant.new.associate(options, args)
+        end
+      end
+
+      default_command(:create)
+
+      run!
+    end
+  end
+end