fastlane_iac_publish 0.1.0

data/precheck/lib/precheck/module.rb

@@ -0,0 +1,21 @@
+require 'fastlane_core/helper'
+require 'fastlane_core/ui/ui'
+
+module Precheck
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+
+    def precheckfile_name
+      "Precheckfile"
+    end
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  ENV['APP_IDENTIFIER'] ||= ENV["PRECHECK_APP_IDENTIFIER"]
+
+  DESCRIPTION = 'Check your app using a community driven set of App Store review rules to avoid being rejected'
+end

data/precheck/lib/precheck/options.rb

@@ -0,0 +1,79 @@
+require 'fastlane_core/configuration/config_item'
+require 'credentials_manager/appfile_config'
+
+require_relative 'rules/all'
+
+module Precheck
+  class Options
+    def self.rules
+      [
+        NegativeAppleSentimentRule,
+        PlaceholderWordsRule,
+        OtherPlatformsRule,
+        FutureFunctionalityRule,
+        TestWordsRule,
+        CurseWordsRule,
+        FreeStuffIAPRule,
+        CustomTextRule,
+        CopyrightDateRule,
+        UnreachableURLRule
+      ].map(&:new)
+    end
+
+    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: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "PRECHECK_APP_IDENTIFIER",
+                                     description: "The bundle identifier of your app",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "PRECHECK_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user,
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "PRECHECK_TEAM_ID",
+                                     description: "The ID of your App Store Connect team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-l",
+                                     env_name: "PRECHECK_TEAM_NAME",
+                                     description: "The name of your App Store Connect team if you're in multiple teams",
+                                     optional: true,
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :default_rule_level,
+                                     short_option: "-r",
+                                     env_name: "PRECHECK_DEFAULT_RULE_LEVEL",
+                                     description: "The default rule level unless otherwise configured",
+                                     is_string: false,
+                                     default_value: RULE_LEVELS[:error]),
+        FastlaneCore::ConfigItem.new(key: :include_in_app_purchases,
+                                     short_option: "-i",
+                                     env_name: "PRECHECK_INCLUDE_IN_APP_PURCHASES",
+                                     description: "Should check in-app purchases?",
+                                     is_string: false,
+                                     optional: true,
+                                     default_value: true)
+      ] + rules
+    end
+  end
+end

data/precheck/lib/precheck/rule.rb

@@ -0,0 +1,171 @@
+require 'credentials_manager/appfile_config'
+require 'fastlane_core/configuration/config_item'
+
+require_relative 'module'
+require_relative 'item_to_check'
+require_relative 'rule_check_result'
+
+module Precheck
+  VALIDATION_STATES = {
+    passed: "passed",
+    failed: "failed"
+  }
+
+  # rules can cause warnings, errors, or be skipped all together
+  # by default they are set to indicate a RULE_LEVELS[:error]
+  RULE_LEVELS = {
+    warn: :warn,
+    error: :error,
+    skip: :skip
+  }
+
+  # Abstract super class
+  attr_accessor :rule_block
+
+  class Rule < FastlaneCore::ConfigItem
+    # when a rule evaluates a single item, it has a validation state
+    # if it fails, it has some data like what text failed to pass, or maybe a bad url
+    # this class encapsulates that return value and state
+    # it is the return value from each evaluated @rule_block
+    class RuleReturn
+      attr_accessor :validation_state
+      attr_accessor :failure_data
+
+      def initialize(validation_state: nil, failure_data: nil)
+        @validation_state = validation_state
+        @failure_data = failure_data
+      end
+    end
+
+    def initialize(short_option: nil,
+                   verify_block: nil,
+                   is_string: nil,
+                   type: nil,
+                   conflicting_options: nil,
+                   conflict_block: nil,
+                   deprecated: nil,
+                   sensitive: nil,
+                   display_in_shell: nil)
+
+      super(key: self.class.key,
+            env_name: self.class.env_name,
+            description: self.class.description,
+            short_option: short_option,
+            default_value: self.class.default_value,
+            verify_block: verify_block,
+            is_string: is_string,
+            type: type,
+            optional: true,
+            conflicting_options: conflicting_options,
+            conflict_block: conflict_block,
+            deprecated: deprecated,
+            sensitive: sensitive,
+            display_in_shell: display_in_shell)
+    end
+
+    def to_s
+      @key
+    end
+
+    def self.env_name
+      not_implemented(__method__)
+    end
+
+    def self.key
+      not_implemented(__method__)
+    end
+
+    def self.description
+      not_implemented(__method__)
+    end
+
+    def self.friendly_name
+      not_implemented(__method__)
+    end
+
+    def self.default_value
+      CredentialsManager::AppfileConfig.try_fetch_value(self.key)
+    end
+
+    def friendly_name
+      return self.class.friendly_name
+    end
+
+    def inspect
+      "#{self.class}(description: #{@description}, key: #{@key})"
+    end
+
+    # some rules can be customized with extra data at runtime, see CustomTextRule as an example
+    def needs_customization?
+      return false
+    end
+
+    # some rules can be customized with extra data at runtime, see CustomTextRule as an example
+    def customize_with_data(data: nil)
+      not_implemented(__method__)
+    end
+
+    # some rules only support specific fields, by default, all fields are supported unless restricted by
+    # providing a list of symbols matching the item_name as defined as the ItemToCheck is generated
+    def supported_fields_symbol_set
+      return nil
+    end
+
+    def rule_block
+      not_implemented(__method__)
+    end
+
+    def check_item(item)
+      # validate the item we have was properly matched to this rule: TextItem -> TextRule, URLItem -> URLRule
+      return skip_item_not_meant_for_this_rule(item) unless handle_item?(item)
+      return skip_item_not_meant_for_this_rule(item) unless item_field_supported?(item_name: item.item_name)
+
+      # do the actual checking now
+      return perform_check(item: item)
+    end
+
+    def skip_item_not_meant_for_this_rule(item)
+      # item isn't mean for this rule, which is fine, we can just keep passing it along
+      return nil
+    end
+
+    # each rule can define what type of ItemToCheck subclass they support
+    # override this method and return true or false
+    def handle_item?(item)
+      not_implemented(__method__)
+    end
+
+    def item_field_supported?(item_name: nil)
+      return true if supported_fields_symbol_set.nil?
+      return true if supported_fields_symbol_set.include?(item_name)
+      return false
+    end
+
+    def perform_check(item: nil)
+      if item.item_data.to_s == "" && item.is_optional
+        # item is optional, and empty, so that's totally fine
+        check_result = RuleReturn.new(validation_state: VALIDATION_STATES[:passed])
+        return RuleCheckResult.new(item, check_result, self)
+      end
+
+      check_result = self.rule_block.call(item.item_data)
+      return RuleCheckResult.new(item, check_result, self)
+    end
+  end
+
+  # Rule types are more or less just marker classes that are intended to communicate what types of things each rule
+  # expects to deal with. TextRules deal with checking text values, URLRules will check url specific things like connectivity
+  # TextRules expect that text values will be passed to the rule_block, likewise, URLs are expected to be passed to the
+  # URLRule rule_block
+  class TextRule < Rule
+    def handle_item?(item)
+      item.kind_of?(TextItemToCheck) ? true : false
+    end
+  end
+
+  class URLRule < Rule
+    def handle_item?(item)
+      item.kind_of?(URLItemToCheck) ? true : false
+    end
+  end
+end

data/precheck/lib/precheck/rule_check_result.rb

@@ -0,0 +1,19 @@
+module Precheck
+  # after each item is checked for rule conformance to a single rule, a result is generated
+  # a result can have a status of success or fail for a given rule/item
+  class RuleCheckResult
+    attr_accessor :item
+    attr_accessor :rule_return # RuleReturn
+    attr_accessor :rule
+
+    def initialize(item, rule_return, rule)
+      @item = item
+      @rule_return = rule_return
+      @rule = rule
+    end
+
+    def status
+      rule_return.validation_state
+    end
+  end
+end

data/precheck/lib/precheck/rule_processor.rb

@@ -0,0 +1,231 @@
+require 'spaceship/tunes/language_item'
+require 'fastlane/markdown_table_formatter'
+
+require_relative 'module'
+require_relative 'item_to_check'
+require_relative 'rule'
+
+module Precheck
+  # encapsulated the results of the rule processing, needed to return not just an array of the results of our
+  # checks, but also an array of items we didn't check, just in-case we were expecting to check everything
+  class RuleProcessResult
+    attr_accessor :error_results # { rule: [result, result, ...] }
+    attr_accessor :warning_results # { rule: [result, result, ...] }
+    attr_accessor :skipped_rules
+    attr_accessor :items_not_checked
+
+    def initialize(error_results: nil,
+                   warning_results: nil,
+                   skipped_rules: nil,
+                   items_not_checked: nil)
+      @error_results = error_results
+      @warning_results = warning_results
+      @skipped_rules = skipped_rules
+      @items_not_checked = items_not_checked
+    end
+
+    def should_trigger_user_error?
+      return true if error_results.length > 0
+      return false
+    end
+
+    def has_errors_or_warnings?
+      return true if error_results.length > 0 || warning_results.length > 0
+      return false
+    end
+
+    def items_not_checked?
+      return true if items_not_checked.length > 0
+      return false
+    end
+  end
+
+  class RuleProcessor
+    def self.process_app_and_version(app: nil, app_version: nil, rules: nil)
+      items_to_check = []
+      items_to_check += generate_text_items_to_check(app: app, app_version: app_version)
+      items_to_check += generate_url_items_to_check(app: app, app_version: app_version)
+
+      return process_rules(items_to_check: items_to_check, rules: rules)
+    end
+
+    def self.process_rules(items_to_check: nil, rules: nil)
+      items_not_checked = items_to_check.to_set # items we haven't checked by at least one rule
+      error_results = {} # rule to fields map
+      warning_results = {} # rule to fields map
+      skipped_rules = []
+
+      rules.each do |rule|
+        rule_config = Precheck.config[rule.key]
+        rule_level = rule_config[:level].to_sym unless rule_config.nil?
+        rule_level ||= Precheck.config[:default_rule_level].to_sym
+
+        if rule_level == RULE_LEVELS[:skip]
+          skipped_rules << rule
+          UI.message("Skipped: #{rule.class.friendly_name}-> #{rule.description}".yellow)
+          next
+        end
+
+        if rule.needs_customization?
+          if rule_config.nil? || rule_config[:data].nil?
+            UI.verbose("#{rule.key} excluded because no data was passed to it e.g.: #{rule.key}(data: <data here>)")
+            next
+          end
+
+          custom_data = rule_config[:data]
+          rule.customize_with_data(data: custom_data)
+        end
+
+        # if the rule failed at least once, we won't print a success message
+        rule_failed_at_least_once = false
+
+        items_to_check.each do |item|
+          result = rule.check_item(item)
+
+          # each rule will determine if it can handle this item, if not, it will just pass nil back
+          next if result.nil?
+
+          # we've checked this item, remove it from list of items not checked
+          items_not_checked.delete(item)
+
+          # if we passed, then go to the next item, otherwise, recode the failure
+          next unless result.status == VALIDATION_STATES[:failed]
+          error_results = add_new_result_to_rule_hash(rule_hash: error_results, result: result) if rule_level == RULE_LEVELS[:error]
+          warning_results = add_new_result_to_rule_hash(rule_hash: warning_results, result: result) if rule_level == RULE_LEVELS[:warn]
+          rule_failed_at_least_once = true
+        end
+
+        if rule_failed_at_least_once
+          message = "😵  Failed: #{rule.class.friendly_name}-> #{rule.description}"
+          if rule_level == RULE_LEVELS[:error]
+            UI.error(message)
+          else
+            UI.important(message)
+          end
+        else
+          UI.message("✅  Passed: #{rule.class.friendly_name}")
+        end
+      end
+
+      return RuleProcessResult.new(
+        error_results: error_results,
+        warning_results: warning_results,
+        skipped_rules: skipped_rules,
+        items_not_checked: items_not_checked.to_a
+      )
+    end
+
+    # hash will be { rule: [result, result, result] }
+    def self.add_new_result_to_rule_hash(rule_hash: nil, result: nil)
+      unless rule_hash.include?(result.rule)
+        rule_hash[result.rule] = []
+      end
+      rule_results = rule_hash[result.rule]
+      rule_results << result
+      return rule_hash
+    end
+
+    def self.generate_url_items_to_check(app: nil, app_version: nil)
+      items = []
+      items += collect_urls_from_hash(hash: app_version.support_url,
+                                 item_name: :support_url,
+                     friendly_name_postfix: "support URL")
+      items += collect_urls_from_hash(hash: app_version.marketing_url,
+                                 item_name: :marketing_url,
+                     friendly_name_postfix: "marketing URL",
+                               is_optional: true)
+
+      items += collect_urls_from_hash(hash: app.details.privacy_url,
+                                 item_name: :privacy_url,
+                     friendly_name_postfix: "privacy URL",
+                               is_optional: true)
+      return items
+    end
+
+    def self.collect_urls_from_hash(hash: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
+      items = []
+      hash.each do |key, value|
+        items << URLItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{key})", is_optional)
+      end
+      return items
+    end
+
+    def self.generate_text_items_to_check(app: nil, app_version: nil)
+      items = []
+
+      items << TextItemToCheck.new(app_version.copyright, :copyright, "copyright")
+
+      items += collect_text_items_from_language_item(hash: app_version.keywords,
+                                                item_name: :keywords,
+                                    friendly_name_postfix: "keywords")
+
+      items += collect_text_items_from_language_item(hash: app_version.description,
+                                                item_name: :description,
+                                    friendly_name_postfix: "description")
+
+      items += collect_text_items_from_language_item(hash: app_version.release_notes,
+                                                item_name: :release_notes,
+                                    friendly_name_postfix: "release notes")
+
+      items += collect_text_items_from_language_item(hash: app.details.name,
+                                                item_name: :app_name,
+                                    friendly_name_postfix: "app name")
+
+      items += collect_text_items_from_language_item(hash: app.details.apple_tv_privacy_policy,
+                                                item_name: :app_subtitle,
+                                    friendly_name_postfix: " tv privacy policy")
+
+      items += collect_text_items_from_language_item(hash: app.details.subtitle,
+                                                item_name: :app_subtitle,
+                                    friendly_name_postfix: "app name subtitle",
+                                              is_optional: true)
+
+      should_include_iap = Precheck.config[:include_in_app_purchases]
+      if should_include_iap
+        UI.message("Reading in-app purchases. If you have a lot, this might take a while")
+        UI.message("You can disable IAP checking by setting the `include_in_app_purchases` flag to `false`")
+        in_app_purchases = app.in_app_purchases.all
+        in_app_purchases ||= []
+        in_app_purchases.each do |purchase|
+          items += collect_iap_language_items(purchase_edit_versions: purchase.edit.versions)
+        end
+        UI.message("Done reading in-app purchases")
+      end
+
+      return items
+    end
+
+    def self.collect_iap_language_items(purchase_edit_versions: nil, is_optional: false)
+      items = []
+      purchase_edit_versions.each do |language_key, hash|
+        name = hash[:name]
+        description = hash[:description]
+        items << TextItemToCheck.new(name, :in_app_purchase, "in-app purchase name: #{name}: (#{language_key})", is_optional)
+        items << TextItemToCheck.new(description, :in_app_purchase, "in-app purchase desc: #{description}: (#{language_key})", is_optional)
+      end
+      return items
+    end
+
+    # a few attributes are LanguageItem this method creates a TextItemToCheck for each pair
+    def self.collect_text_items_from_language_item(hash: nil, item_name: nil, friendly_name_postfix: nil, is_optional: false)
+      items = []
+      hash.each do |key, value|
+        items << TextItemToCheck.new(value, item_name, "#{friendly_name_postfix}: (#{key})", is_optional)
+      end
+      return items
+    end
+  end
+end
+
+# we want to get some of the same behavior hashes has, so use this mixin specifically designed for Spaceship::Tunes::LanguageItem
+# because we use .each
+module LanguageItemHashBehavior
+  # this is used to create a hash-like .each method.
+  def each(&block)
+    keys.each { |key| yield(key, get_value(key: key)) }
+  end
+end
+
+class Spaceship::Tunes::LanguageItem
+  include LanguageItemHashBehavior
+end