fastlane 2.40.0.beta.20170622010014 → 2.40.0

data/precheck/lib/assets/PrecheckfileTemplate

@@ -0,0 +1,28 @@
+# For more information about this configuration visit
+# https://github.com/fastlane/fastlane/tree/master/precheck#precheckfile
+
+# In general, you can use the options available
+# fastlane precheck --help
+
+# Remove the # in front of the line to enable the option
+
+# You have three possible values for each rule options
+# :skip
+# indicates that your metadata will not be checked by this rule
+
+# :warn
+# when triggered, this rule will warn you of a potential problem
+
+# :fail
+# when triggered, this rule will cause an error to be displayed and it will prevent any further fastlane commands from running after precheck finishes
+
+# Examples:
+# negative_apple_sentiment(level: :skip)
+# curse_words(level: :warn)
+# future_functionality(level: :error)
+# other_platforms(level: :error)
+# placeholder_text(level: :error)
+# test_words(level: :error)
+# unreachable_urls(level: :error)
+# custom_text(data: ["fabric"], level: :warn)
+

data/precheck/lib/precheck.rb

@@ -0,0 +1,22 @@
+require 'fastlane_core'
+require 'precheck/runner'
+require 'precheck/options'
+
+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/commands_generator.rb

@@ -0,0 +1,56 @@
+require "commander"
+require "fastlane_core"
+require "fastlane/version"
+
+HighLine.track_eof = false
+
+module Precheck
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      new.run
+    end
+
+    def run
+      program :name, 'precheck'
+      program :version, Fastlane::VERSION
+      program :description, Precheck::DESCRIPTION
+      program :help, "Author", "Joshua Liebowitz <taquitos@gmail.com>, @taquitos"
+      program :help, "Website", "https://fastlane.tools"
+      program :help, "GitHub", "https://github.com/fastlane/fastlane/tree/master/precheck"
+      program :help_formatter, :compact
+
+      global_option("--verbose") { FastlaneCore::Globals.verbose = true }
+
+      command :check_metadata do |c|
+        c.syntax = "fastlane precheck"
+        c.description = Precheck::DESCRIPTION
+
+        FastlaneCore::CommanderGenerator.new.generate(Precheck::Options.available_options, command: c)
+
+        c.action do |_args, options|
+          Precheck.config = FastlaneCore::Configuration.create(Precheck::Options.available_options, options.__hash__)
+          Precheck::Runner.new.run
+        end
+      end
+
+      command :init do |c|
+        c.syntax = "fastlane precheck init"
+        c.description = "Creates a new Precheckfile for you"
+        c.action do |_args, options|
+          containing = FastlaneCore::Helper.fastlane_enabled_folder_path
+          path = File.join(containing, Precheck.precheckfile_name)
+          UI.user_error! "Precheckfile already exists" if File.exist?(path)
+          template = File.read("#{Precheck::ROOT}/lib/assets/PrecheckfileTemplate")
+          File.write(path, template)
+          UI.success "Successfully created '#{path}'. Open the file using a code editor."
+        end
+      end
+
+      default_command :check_metadata
+
+      run!
+    end
+  end
+end

data/precheck/lib/precheck/item_to_check.rb

@@ -0,0 +1,58 @@
+module Precheck
+  # each attribute on a app version is a single item.
+  # for example: .name, .keywords, .description, will all have a single item to represent them
+  # which includes their name and a more user-friendly name we can use to print out information
+  class ItemToCheck
+    attr_accessor :item_name
+    attr_accessor :friendly_name
+    attr_accessor :is_optional
+
+    def initialize(item_name, friendly_name, is_optional = false)
+      @item_name = item_name
+      @friendly_name = friendly_name
+      @is_optional = is_optional
+    end
+
+    def item_data
+      not_implemented(__method__)
+    end
+
+    def inspect
+      "#{self.class}(friendly_name: #{@friendly_name}, data: #{@item_data})"
+    end
+
+    def to_s
+      "#{self.class}: #{item_name}: #{friendly_name}"
+    end
+  end
+
+  # if the data point we want to check is a text field (like 'description'), we'll use this object to encapsulate it
+  # this includes the text, the property name, and what that name maps to in plain english so that we can print out nice, friendly messages.
+  class TextItemToCheck < ItemToCheck
+    attr_accessor :text
+
+    def initialize(text, item_name, friendly_name, is_optional = false)
+      @text = text
+      super(item_name, friendly_name, is_optional)
+    end
+
+    def item_data
+      return text
+    end
+  end
+
+  # if the data point we want to check is a URL field (like 'marketing_url'), we'll use this object to encapsulate it
+  # this includes the url, the property name, and what that name maps to in plain english so that we can print out nice, friendly messages.
+  class URLItemToCheck < ItemToCheck
+    attr_accessor :url
+
+    def initialize(url, item_name, friendly_name, is_optional = false)
+      @url = url
+      super(item_name, friendly_name, is_optional)
+    end
+
+    def item_data
+      return url
+    end
+  end
+end

data/precheck/lib/precheck/options.rb

@@ -0,0 +1,63 @@
+require 'fastlane_core'
+require 'credentials_manager'
+Dir[File.dirname(__FILE__) + '/rules/*.rb'].each { |file| require file }
+
+module Precheck
+  class Options
+    def self.rules
+      [
+        NegativeAppleSentimentRule,
+        PlaceholderWordsRule,
+        OtherPlatformsRule,
+        FutureFunctionalityRule,
+        TestWordsRule,
+        CurseWordsRule,
+        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",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)),
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "PRECHECK_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "PRECHECK_TEAM_ID",
+                                     description: "The ID of your iTunes Connect team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     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 iTunes Connect 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_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])
+      ] + rules
+    end
+  end
+end

data/precheck/lib/precheck/rule.rb

@@ -0,0 +1,169 @@
+require 'fastlane_core'
+require 'precheck/item_to_check'
+require 'precheck/rule_check_result'
+
+module Precheck
+  VALIDATION_STATES = {
+    passed: "passed",
+    failed: "failed",
+    skipped: "skipped"
+  }
+
+  # 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: Precheck::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,199 @@
+require 'spaceship'
+require 'fastlane/markdown_table_formatter'
+require 'precheck/item_to_check'
+
+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
+    end
+
+    def items_not_checked?
+      return true if items_not_checked.length > 0
+    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]
+
+        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]
+          add_new_result_to_rule_hash(rule_hash: error_results, result: result) if rule_level == RULE_LEVELS[:error]
+          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
+          UI.error "😵  Failed: #{rule.class.friendly_name}-> #{rule.description}"
+        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)
+      result_array = rule_hash[result.rule] ||= []
+      result_array << result
+      rule_hash[result.rule] = result_array
+    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 << TextItemToCheck.new(app_version.review_first_name, :review_first_name, "review first name")
+      items << TextItemToCheck.new(app_version.review_last_name, :review_last_name, "review last name")
+      items << TextItemToCheck.new(app_version.review_phone_number, :review_phone_number, "review phone number")
+      items << TextItemToCheck.new(app_version.review_email, :review_email, "review email")
+      items << TextItemToCheck.new(app_version.review_demo_user, :review_demo_user, "review demo user")
+      items << TextItemToCheck.new(app_version.review_notes, :review_notes, "review notes")
+
+      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)
+      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