fastlane 1.111.0 → 2.0.1

data/fastlane_core/lib/fastlane_core/cert_checker.rb

@@ -0,0 +1,94 @@
+module FastlaneCore
+  # This class checks if a specific certificate is installed on the current mac
+  class CertChecker
+    def self.installed?(path)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      ids = installed_identies
+      finger_print = sha1_fingerprint(path)
+
+      return ids.include? finger_print
+    end
+
+    # Legacy Method, use `installed?` instead
+    def self.is_installed?(path)
+      installed?(path)
+    end
+
+    def self.installed_identies
+      install_wwdr_certificate unless wwdr_certificate_installed?
+
+      available = list_available_identities
+      # Match for this text against word boundaries to avoid edge cases around multiples of 10 identities!
+      if /\b0 valid identities found\b/ =~ available
+        UI.error([
+          "There are no local code signing identities found.",
+          "You can run `security find-identity -v -p codesigning` to get this output.",
+          "This Stack Overflow thread has more information: http://stackoverflow.com/q/35390072/774.",
+          "(Check in Keychain Access for an expired WWDR certificate: http://stackoverflow.com/a/35409835/774 has more info.)"
+        ].join(' '))
+      end
+
+      ids = []
+      available.split("\n").each do |current|
+        next if current.include? "REVOKED"
+        begin
+          (ids << current.match(/.*\) ([[:xdigit:]]*) \".*/)[1])
+        rescue
+          # the last line does not match
+        end
+      end
+
+      return ids
+    end
+
+    def self.list_available_identities
+      `security find-identity -v -p codesigning`
+    end
+
+    def self.wwdr_certificate_installed?
+      certificate_name = "Apple Worldwide Developer Relations Certification Authority"
+      keychain = wwdr_keychain
+      response = Helper.backticks("security find-certificate -c '#{certificate_name}' #{keychain.shellescape}", print: $verbose)
+      return response.include?("attributes:")
+    end
+
+    def self.install_wwdr_certificate
+      Dir.chdir('/tmp') do
+        url = 'https://developer.apple.com/certificationauthority/AppleWWDRCA.cer'
+        filename = File.basename(url)
+        keychain = wwdr_keychain
+        keychain = "-k #{keychain.shellescape}" unless keychain.empty?
+        Helper.backticks("curl -O #{url} && security import #{filename} #{keychain}", print: $verbose)
+        UI.user_error!("Could not install WWDR certificate") unless $?.success?
+      end
+    end
+
+    def self.wwdr_keychain
+      priority = [
+        "security list-keychains -d user",
+        "security default-keychain -d user"
+      ]
+      priority.each do |command|
+        keychains = Helper.backticks(command, print: $verbose).split("\n")
+        unless keychains.empty?
+          # Select first keychain name from returned keychains list
+          return keychains[0].strip.tr('"', '')
+        end
+      end
+      return ""
+    end
+
+    def self.sha1_fingerprint(path)
+      result = `openssl x509 -in "#{path}" -inform der -noout -sha1 -fingerprint`
+      begin
+        result = result.match(/SHA1 Fingerprint=(.*)/)[1]
+        result.delete!(':')
+        return result
+      rescue
+        UI.message(result)
+        UI.user_error!("Error parsing certificate '#{path}'")
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/command_executor.rb

@@ -0,0 +1,98 @@
+module FastlaneCore
+  # Executes commands and takes care of error handling and more
+  class CommandExecutor
+    class << self
+      # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+      # valid file extensions for executables on Windows.
+      #
+      #    which('ruby') #=> /usr/bin/ruby
+      #
+      # Derived from http://stackoverflow.com/a/5471032/3005
+      def which(cmd)
+        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+        # e.g. ".COM;.EXE;.BAT;.CMD"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            cmd_path = File.join(path, "#{cmd}#{ext}")
+            return cmd_path if File.executable?(cmd_path) && !File.directory?(cmd_path)
+          end
+        end
+
+        return nil
+      end
+
+      # @param command [String] The command to be executed
+      # @param print_all [Boolean] Do we want to print out the command output while running?
+      # @param print_command [Boolean] Should we print the command that's being executed
+      # @param error [Block] A block that's called if an error occurs
+      # @param prefix [Array] An array containg a prefix + block which might get applied to the output
+      # @param loading [String] A loading string that is shown before the first output
+      # @return [String] All the output as string
+      def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil)
+        print_all = true if $verbose
+        prefix ||= {}
+
+        output = []
+        command = command.join(" ") if command.kind_of?(Array)
+        UI.command(command) if print_command
+
+        if print_all and loading # this is only used to show the "Loading text"...
+          UI.command_output(loading)
+        end
+
+        begin
+          PTY.spawn(command) do |stdin, stdout, pid|
+            begin
+              stdin.each do |l|
+                line = l.strip # strip so that \n gets removed
+                output << line
+
+                next unless print_all
+
+                # Prefix the current line with a string
+                prefix.each do |element|
+                  line = element[:prefix] + line if element[:block] && element[:block].call(line)
+                end
+
+                UI.command_output(line)
+              end
+            rescue Errno::EIO
+              # This is expected on some linux systems, that indicates that the subcommand finished
+              # and we kept trying to read, ignore it
+            ensure
+              Process.wait(pid)
+            end
+          end
+        rescue => ex
+          # This could happen when the environment is wrong:
+          # > invalid byte sequence in US-ASCII (ArgumentError)
+          output << ex.to_s
+          o = output.join("\n")
+          puts o
+          if error
+            error.call(o, nil)
+          else
+            raise ex
+          end
+        end
+
+        # Exit status for build command, should be 0 if build succeeded
+        status = $?.exitstatus
+        if status != 0
+          o = output.join("\n")
+          puts o # the user has the right to see the raw output
+          UI.error "Exit status: #{status}"
+          if error
+            error.call(o, status)
+          else
+            UI.user_error!("Exit status: #{status}")
+          end
+        end
+
+        return output.join("\n")
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -0,0 +1,82 @@
+require 'commander'
+
+module FastlaneCore
+  class CommanderGenerator
+    include Commander::Methods
+
+    # Calls the appropriate methods for commander to show the available parameters
+    def generate(options)
+      # First, enable `always_trace`, to show the stack trace
+      always_trace!
+
+      used_switches = []
+      options.each do |option|
+        next if option.description.to_s.empty? # "private" options
+
+        short_switch = option.short_option
+        key = option.key
+        validate_short_switch(used_switches, short_switch, key)
+
+        type = option.data_type
+
+        # This is an important bit of trickery to solve the boolean option situation.
+        #
+        # Typically, boolean command line flags do not accept trailing values. If the flag
+        # is present, the value is true, if it is missing, the value is false. fastlane
+        # supports this style of flag. For example, you can specify a flag like `--clean`,
+        # and the :clean option will be true.
+        #
+        # However, fastlane also supports another boolean flag style that accepts trailing
+        # values much like options for Strings and other value types. That looks like
+        # `--include_bitcode false` The problem is that this does not work out of the box
+        # for Commander and OptionsParser. So, we need to get tricky.
+        #
+        # The value_appendix below acts as a placeholder in the switch definition that
+        # states that we expect to have a trailing value for our options. When an option
+        # declares a data type, we use the name of that data type in all caps like:
+        # "--devices ARRAY". When the data type is nil, this implies that we're going
+        # to be doing some special handling on that value. One special thing we do
+        # automatically in Configuration is to coerce special Strings into boolean values.
+        #
+        # If the data type is nil, the trick we do is to specify a value placeholder, but
+        # we wrap it in [] brackets to mark it as optional. That means that the trailing
+        # value may or may not be present for this flag. If the flag is present, but the
+        # value is not, we get a value of `true`. Perfect for the boolean flag base-case!
+        # If the value is there, we'll actually get it back as a String, which we can
+        # later coerce into a boolean.
+        #
+        # In this way we support handling boolean flags with or without trailing values.
+        value_appendix = (type || '[VALUE]').to_s.upcase
+        long_switch = "--#{option.key} #{value_appendix}"
+
+        description = option.description
+        description += " (#{option.env_name})" unless option.env_name.to_s.empty?
+
+        # We compact this array here to remove the short_switch variable if it is nil.
+        # Passing a nil value to global_option has been shown to create problems with
+        # option parsing!
+        #
+        # See: https://github.com/fastlane/fastlane_core/pull/89
+        #
+        # If we don't have a data type for this option, we tell it to act like a String.
+        # This allows us to get a reasonable value for boolean options that can be
+        # automatically coerced or otherwise handled by the ConfigItem for others.
+        args = [short_switch, long_switch, (type || String), description].compact
+
+        # This is the call to Commander to set up the option we've been building.
+        global_option(*args)
+      end
+    end
+
+    def validate_short_switch(used_switches, short_switch, key)
+      return if short_switch.nil?
+
+      UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
+      UI.user_error!("-v is already used for the version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the trace screen (key #{key})") if short_switch == "-t"
+
+      used_switches << short_switch
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/config_item.rb

@@ -0,0 +1,133 @@
+module FastlaneCore
+  class ConfigItem
+    attr_accessor :key, :env_name, :description, :short_option, :default_value, :verify_block, :optional, :conflicting_options, :conflict_block, :deprecated, :sensitive
+
+    # Creates a new option
+    # @param key (Symbol) the key which is used as command paramters or key in the fastlane tools
+    # @param env_name (String) the name of the environment variable, which is only used if no other values were found
+    # @param description (String) A description shown to the user
+    # @param short_option (String) A string of length 1 which is used for the command parameters (e.g. -f)
+    # @param default_value the value which is used if there was no given values and no environment values
+    # @param verify_block an optional block which is called when a new value is set.
+    #   Check value is valid. This could be type checks or if a folder/file exists
+    #   You have to raise a specific exception if something goes wrong. Append .red after the string
+    # @param is_string *DEPRECATED: Use `type` instead* (Boolean) is that parameter a string? Defaults to true. If it's true, the type string will be verified.
+    # @param type (Class) the data type of this config item. Takes precedence over `is_string`
+    # @param optional (Boolean) is false by default. If set to true, also string values will not be asked to the user
+    # @param conflicting_options ([]) array of conflicting option keys(@param key). This allows to resolve conflicts intelligently
+    # @param conflict_block an optional block which is called when options conflict happens
+    # @param deprecated (String) Set if the option is deprecated. A deprecated option should be optional and is made optional if the parameter isn't set, and fails otherwise
+    # @param sensitive (Boolean) Set if the variable is sensitive, such as a password or API token, to prevent echoing when prompted for the parameter
+    def initialize(key: nil, env_name: nil, description: nil, short_option: nil, default_value: nil, verify_block: nil, is_string: true, type: nil, optional: nil, conflicting_options: nil, conflict_block: nil, deprecated: nil, sensitive: nil)
+      UI.user_error!("key must be a symbol") unless key.kind_of? Symbol
+      UI.user_error!("env_name must be a String") unless (env_name || '').kind_of? String
+
+      if short_option
+        UI.user_error!("short_option must be a String of length 1") unless short_option.kind_of? String and short_option.delete('-').length == 1
+      end
+      if description
+        UI.user_error!("Do not let descriptions end with a '.', since it's used for user inputs as well") if description[-1] == '.'
+      end
+
+      if conflicting_options
+        conflicting_options.each do |conflicting_option_key|
+          UI.user_error!("Conflicting option key must be a symbol") unless conflicting_option_key.kind_of? Symbol
+        end
+      end
+      if deprecated
+        # deprecated options are automatically optional
+        optional = true if optional.nil?
+        UI.crash!("Deprecated option must be optional") unless optional
+        # deprecated options are marked deprecated in their description
+        description = "[DEPRECATED!] #{deprecated} - #{description}"
+      end
+      optional = false if optional.nil?
+
+      sensitive = false if sensitive.nil?
+
+      @key = key
+      @env_name = env_name
+      @description = description
+      @short_option = short_option
+      @default_value = default_value
+      @verify_block = verify_block
+      @is_string = is_string
+      @data_type = type
+      @optional = optional
+      @conflicting_options = conflicting_options
+      @conflict_block = conflict_block
+      @deprecated = deprecated
+      @sensitive = sensitive
+    end
+
+    # This will raise an exception if the value is not valid
+    def verify!(value)
+      UI.user_error!("Invalid value '#{value}' for option '#{self}'") unless valid?(value)
+      true
+    end
+
+    # Make sure, the value is valid (based on the verify block)
+    # Returns false if that's not the case
+    def valid?(value)
+      # we also allow nil values, which do not have to be verified.
+      if value
+        # Verify that value is the type that we're expecting, if we are expecting a type
+        if data_type && !value.kind_of?(data_type)
+          UI.user_error!("'#{self.key}' value must be a #{data_type}! Found #{value.class} instead.")
+        end
+
+        if @verify_block
+          begin
+            @verify_block.call(value)
+          rescue => ex
+            UI.error "Error setting value '#{value}' for option '#{@key}'"
+            raise Interface::FastlaneError.new, ex.to_s
+          end
+        end
+      end
+
+      true
+    end
+
+    # Returns an updated value type (if necessary)
+    def auto_convert_value(value)
+      return nil if value.nil?
+
+      if data_type == Array
+        return value.split(',') if value.kind_of?(String)
+      elsif data_type == Integer
+        return value.to_i if value.to_i.to_s == value.to_s
+      elsif data_type == Float
+        return value.to_f if value.to_f.to_s == value.to_s
+      else
+        # Special treatment if the user specified true, false or YES, NO
+        # There is no boolean type, so we just do it here
+        if %w(YES yes true TRUE).include?(value)
+          return true
+        elsif %w(NO no false FALSE).include?(value)
+          return false
+        end
+      end
+
+      return value # fallback to not doing anything
+    end
+
+    # Determines the defined data type of this ConfigItem
+    def data_type
+      if @data_type
+        @data_type
+      else
+        (@is_string ? String : nil)
+      end
+    end
+
+    # Replaces the attr_accessor, but maintains the same interface
+    def string?
+      data_type == String
+    end
+
+    def to_s
+      [@key, @description].join(": ")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/configuration.rb

@@ -0,0 +1,266 @@
+require 'fastlane_core/configuration/config_item'
+require 'fastlane_core/configuration/commander_generator'
+require 'fastlane_core/configuration/configuration_file'
+
+module FastlaneCore
+  class Configuration
+    attr_accessor :available_options
+
+    attr_accessor :values
+
+    # @return [Array] An array of symbols which are all available keys
+    attr_reader :all_keys
+
+    # @return [String] The name of the configuration file (not the path). Optional!
+    attr_accessor :config_file_name
+
+    def self.create(available_options, values)
+      UI.user_error!("values parameter must be a hash") unless values.kind_of?(Hash)
+      v = values.dup
+      v.each do |key, val|
+        v[key] = val.dup if val.kind_of?(String) # this is necessary when fetching a value from an environment variable
+      end
+
+      if v.kind_of?(Hash) && available_options.kind_of?(Array) # we only want to deal with the new configuration system
+        # Now see if --verbose would be a valid input
+        # If not, it might be because it's an action and not a tool
+        unless available_options.find { |a| a.kind_of?(ConfigItem) && a.key == :verbose }
+          v.delete(:verbose) # as this is being processed by commander
+        end
+      end
+      Configuration.new(available_options, v)
+    end
+
+    #####################################################
+    # @!group Setting up the configuration
+    #####################################################
+
+    def initialize(available_options, values)
+      self.available_options = available_options || []
+      self.values = values || {}
+
+      verify_input_types
+      verify_value_exists
+      verify_no_duplicates
+      verify_conflicts
+      verify_default_value_matches_verify_block
+    end
+
+    def verify_input_types
+      UI.user_error!("available_options parameter must be an array of ConfigItems but is #{@available_options.class}") unless @available_options.kind_of? Array
+      @available_options.each do |item|
+        UI.user_error!("available_options parameter must be an array of ConfigItems. Found #{item.class}.") unless item.kind_of? ConfigItem
+      end
+      UI.user_error!("values parameter must be a hash") unless @values.kind_of?(Hash)
+    end
+
+    def verify_value_exists
+      # Make sure the given value keys exist
+      @values.each do |key, value|
+        next if key == :trace # special treatment
+        option = option_for_key(key)
+        if option
+          @values[key] = option.auto_convert_value(value)
+          UI.deprecated("Using deprecated option: '--#{key}' (#{option.deprecated})") if option.deprecated
+          option.verify!(@values[key]) # Call the verify block for it too
+        else
+          UI.user_error!("Could not find option '#{key}' in the list of available options: #{@available_options.collect(&:key).join(', ')}")
+        end
+      end
+    end
+
+    def verify_no_duplicates
+      # Make sure a key was not used multiple times
+      @available_options.each do |current|
+        count = @available_options.count { |option| option.key == current.key }
+        UI.user_error!("Multiple entries for configuration key '#{current.key}' found!") if count > 1
+
+        unless current.short_option.to_s.empty?
+          count = @available_options.count { |option| option.short_option == current.short_option }
+          UI.user_error!("Multiple entries for short_option '#{current.short_option}' found!") if count > 1
+        end
+      end
+    end
+
+    def verify_conflicts
+      option_keys = @values.keys
+
+      option_keys.each do |current|
+        index = @available_options.find_index { |item| item.key == current }
+        current = @available_options[index]
+
+        # ignore conflicts because option value is nil
+        next if @values[current.key].nil?
+
+        next if current.conflicting_options.nil?
+
+        conflicts = current.conflicting_options & option_keys
+        next if conflicts.nil?
+
+        conflicts.each do |conflicting_option_key|
+          index = @available_options.find_index { |item| item.key == conflicting_option_key }
+          conflicting_option = @available_options[index]
+
+          # ignore conflicts because because value of conflict option is nil
+          next if @values[conflicting_option.key].nil?
+
+          if current.conflict_block
+            begin
+              current.conflict_block.call(conflicting_option)
+            rescue => ex
+              UI.error("Error resolving conflict between options: '#{current.key}' and '#{conflicting_option.key}'")
+              raise ex
+            end
+          else
+            UI.user_error!("Unresolved conflict between options: '#{current.key}' and '#{conflicting_option.key}'")
+          end
+        end
+      end
+    end
+
+    # Verifies the default value is also valid
+    def verify_default_value_matches_verify_block
+      @available_options.each do |item|
+        next unless item.verify_block && item.default_value
+
+        begin
+          unless @values[item.key] # this is important to not verify if there already is a value there
+            item.verify_block.call(item.default_value)
+          end
+        rescue => ex
+          UI.error(ex)
+          UI.user_error!("Invalid default value for #{item.key}, doesn't match verify_block")
+        end
+      end
+    end
+
+    # This method takes care of parsing and using the configuration file as values
+    # Call this once you know where the config file might be located
+    # Take a look at how `gym` uses this method
+    #
+    # @param config_file_name [String] The name of the configuration file to use (optional)
+    # @param block_for_missing [Block] A ruby block that is called when there is an unkonwn method
+    #   in the configuration file
+    def load_configuration_file(config_file_name = nil, block_for_missing = nil)
+      return unless config_file_name
+
+      self.config_file_name = config_file_name
+
+      paths = []
+      paths += Dir["./fastlane/#{self.config_file_name}"]
+      paths += Dir["./.fastlane/#{self.config_file_name}"]
+      paths += Dir["./#{self.config_file_name}"]
+      paths += Dir["./fastlane_core/spec/fixtures/#{self.config_file_name}"] if Helper.is_test?
+      return if paths.count == 0
+
+      path = paths.first
+      configuration_file = ConfigurationFile.new(self, path, block_for_missing)
+      verify_conflicts # important, since user can set conflicting options in configuration file
+      configuration_file
+    end
+
+    #####################################################
+    # @!group Actually using the class
+    #####################################################
+
+    # Returns the value for a certain key. fastlane_core tries to fetch the value from different sources
+    # if 'ask' is true and the value is not present, the user will be prompted to provide a value
+    def fetch(key, ask: true)
+      UI.user_error!("Key '#{key}' must be a symbol. Example :app_id.") unless key.kind_of?(Symbol)
+
+      option = option_for_key(key)
+      UI.user_error!("Could not find option for key :#{key}. Available keys: #{@available_options.collect(&:key).join(', ')}") unless option
+
+      value = @values[key]
+
+      value = option.auto_convert_value(value)
+
+      # `if value == nil` instead of ||= because false is also a valid value
+      if value.nil? and option.env_name and ENV[option.env_name]
+
+        # We want to inform the user that we took the value
+        # from an environment variable
+        # however we don't print the actual value, as it may contain sensitive information
+        # The user can easily find the actual value by print out the environment
+        UI.verbose("Taking value for '#{key}' from environment variable '#{option.env_name}'")
+
+        value = option.auto_convert_value(ENV[option.env_name].dup)
+        option.verify!(value) if value
+      end
+
+      value = option.default_value if value.nil?
+      value = nil if value.nil? and !option.string? # by default boolean flags are false
+
+      return value unless value.nil? # we already have a value
+      return value if option.optional # as this value is not required, just return what we have
+
+      return value unless ask
+
+      # fallback to asking
+      if Helper.is_test? or !UI.interactive?
+        # Since we don't want to be asked on tests, we'll just call the verify block with no value
+        # to raise the exception that is shown when the user passes an invalid value
+        set(key, '')
+        # If this didn't raise an exception, just raise a default one
+        UI.user_error!("No value found for '#{key}'")
+      end
+
+      while value.nil?
+        UI.important("To not be asked about this value, you can specify it using '#{option.key}'")
+        value = option.sensitive ? UI.password("#{option.description}: ") : UI.input("#{option.description}: ")
+        # Also store this value to use it from now on
+        begin
+          set(key, value)
+        rescue => ex
+          puts ex
+          value = nil
+        end
+      end
+
+      value
+    end
+
+    # Overwrites or sets a new value for a given key
+    # @param key [Symbol] Must be a symbol
+    def set(key, value)
+      UI.user_error!("Key '#{key}' must be a symbol. Example :#{key}.") unless key.kind_of? Symbol
+      option = option_for_key(key)
+
+      unless option
+        UI.user_error!("Could not find option '#{key}' in the list of available options: #{@available_options.collect(&:key).join(', ')}")
+      end
+
+      option.verify!(value)
+
+      @values[key] = value
+      true
+    end
+
+    # see fetch
+    def values(ask: true)
+      # As the user accesses all values, we need to iterate through them to receive all the values
+      @available_options.each do |option|
+        @values[option.key] = fetch(option.key, ask: ask) unless @values[option.key]
+      end
+      @values
+    end
+
+    # Direct access to the values, without iterating through all items
+    def _values
+      @values
+    end
+
+    def all_keys
+      @available_options.collect(&:key)
+    end
+
+    # Returns the config_item object for a given key
+    def option_for_key(key)
+      @available_options.find { |o| o.key == key }
+    end
+
+    # Aliases `[key]` to `fetch(key)` because Ruby can do it.
+    alias [] fetch
+    alias []= set
+  end
+end