fastlane 1.111.0 → 2.0.1

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

@@ -0,0 +1,82 @@
+module FastlaneCore
+  # Responsible for loading configuration files
+  class ConfigurationFile
+    # A reference to the actual configuration
+    attr_accessor :config
+
+    # @param config [FastlaneCore::Configuration] is stored to save the resulting values
+    # @param path [String] The path to the configuration file to use
+    def initialize(config, path, block_for_missing)
+      self.config = config
+      @block_for_missing = block_for_missing
+      content = File.read(path)
+
+      # From https://github.com/orta/danger/blob/master/lib/danger/Dangerfile.rb
+      if content.tr!('“”‘’‛', %(""'''))
+        UI.error("Your #{File.basename(path)} has had smart quotes sanitised. " \
+                  'To avoid issues in the future, you should not use ' \
+                  'TextEdit for editing it. If you are not using TextEdit, ' \
+                  'you should turn off smart quotes in your editor of choice.')
+      end
+
+      begin
+        # rubocop:disable Lint/Eval
+        eval(content) # this is okay in this case
+        # rubocop:enable Lint/Eval
+
+        print_resulting_config_values(path) # only on success
+      rescue SyntaxError => ex
+        line = ex.to_s.match(/\(eval\):(\d+)/)[1]
+        UI.user_error!("Syntax error in your configuration file '#{path}' on line #{line}: #{ex}")
+      end
+    end
+
+    def print_resulting_config_values(path)
+      require 'terminal-table'
+      UI.success("Successfully loaded '#{File.expand_path(path)}' 📄")
+
+      # Show message when self.modified_values is empty
+      if self.modified_values.empty?
+        UI.important("No values defined in '#{path}'")
+        return
+      end
+
+      rows = self.modified_values.collect do |key, value|
+        [key, value] if value.to_s.length > 0
+      end.compact
+
+      puts ""
+      puts Terminal::Table.new(rows: rows, title: "Detected Values from '#{path}'")
+      puts ""
+    end
+
+    # This is used to display only the values that have changed in the summary table
+    def modified_values
+      @modified_values ||= {}
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      # First, check if the key is actually available
+      if self.config.all_keys.include?(method_sym)
+        # This silently prevents a value from having its value set more than once.
+        return unless self.config._values[method_sym].to_s.empty?
+
+        value = arguments.first
+        value = yield if value.nil? && block_given?
+
+        return if value.nil?
+        self.modified_values[method_sym] = value
+        self.config[method_sym] = value
+      else
+        # We can't set this value, maybe the tool using this configuration system has its own
+        # way of handling this block, as this might be a special block (e.g. ipa block) that's only
+        # executed on demand
+        if @block_for_missing
+          @block_for_missing.call(method_sym, arguments, block)
+        else
+          self.config[method_sym] = '' # important, since this will raise a good exception for free
+        end
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/core_ext/string.rb

@@ -0,0 +1,17 @@
+class String
+  def fastlane_class
+    split('_').collect!(&:capitalize).join
+  end
+
+  def fastlane_module
+    self == "pem" ? 'PEM' : self.fastlane_class
+  end
+
+  def fastlane_underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+      gsub(/([a-z\d])([A-Z])/, '\1_\2').
+      tr("-", "_").
+      downcase
+  end
+end

data/fastlane_core/lib/fastlane_core/device_manager.rb

@@ -0,0 +1,231 @@
+require 'open3'
+require 'plist'
+
+module FastlaneCore
+  class DeviceManager
+    class << self
+      def all(requested_os_type = "")
+        return connected_devices(requested_os_type) + simulators(requested_os_type)
+      end
+
+      def simulators(requested_os_type = "")
+        UI.verbose("Fetching available simulator devices")
+
+        @devices = []
+        os_type = 'unknown'
+        os_version = 'unknown'
+        output = ''
+        Open3.popen3('xcrun simctl list devices') do |stdin, stdout, stderr, wait_thr|
+          output = stdout.read
+        end
+
+        unless output.include?("== Devices ==")
+          UI.error("xcrun simctl CLI broken, run `xcrun simctl list devices` and make sure it works")
+          UI.user_error!("xcrun simctl not working.")
+        end
+
+        output.split(/\n/).each do |line|
+          next if line =~ /^== /
+          if line =~ /^-- /
+            (os_type, os_version) = line.gsub(/-- (.*) --/, '\1').split
+          else
+            # iPad 2 (0EDE6AFC-3767-425A-9658-AAA30A60F212) (Shutdown)
+            # iPad Air 2 (4F3B8059-03FD-4D72-99C0-6E9BBEE2A9CE) (Shutdown) (unavailable, device type profile not found)
+            if line.include?("inch)")
+              # For Xcode 8, where sometimes we have the # of inches in ()
+              # iPad Pro (12.9 inch) (CEF11EB3-79DF-43CB-896A-0F33916C8BDE) (Shutdown)
+              match = line.match(/\s+([^\(]+ \(.*inch\)) \(([-0-9A-F]+)\) \(([^\(]+)\)(.*unavailable.*)?/)
+            else
+              match = line.match(/\s+([^\(]+) \(([-0-9A-F]+)\) \(([^\(]+)\)(.*unavailable.*)?/)
+            end
+
+            if match && !match[4] && (os_type == requested_os_type || requested_os_type == "")
+              @devices << Device.new(name: match[1], os_type: os_type, os_version: os_version, udid: match[2], state: match[3], is_simulator: true)
+            end
+          end
+        end
+
+        return @devices
+      end
+
+      def connected_devices(requested_os_type)
+        UI.verbose("Fetching available connected devices")
+
+        device_types = if requested_os_type == "tvOS"
+                         ["AppleTV"]
+                       elsif requested_os_type == "iOS"
+                         ["iPhone", "iPad", "iPod"]
+                       else
+                         []
+                       end
+
+        devices = [] # Return early if no supported devices are being searched for
+        if device_types.count == 0
+          return devices
+        end
+
+        usb_devices_output = ''
+        Open3.popen3("system_profiler SPUSBDataType -xml") do |stdin, stdout, stderr, wait_thr|
+          usb_devices_output = stdout.read
+        end
+
+        device_uuids = []
+        result = Plist.parse_xml(usb_devices_output)
+        result[0]['_items'].each do |host_controller| # loop just incase the host system has more then 1 controller
+          host_controller['_items'].each do |usb_device|
+            is_supported_device = device_types.any? { |device_type| usb_device['_name'] == device_type }
+            if is_supported_device && usb_device['serial_num'].length == 40
+              device_uuids.push(usb_device['serial_num'])
+            end
+          end
+        end
+
+        if device_uuids.count > 0 # instruments takes a little while to return so skip it if we have no devices
+          instruments_devices_output = ''
+          Open3.popen3("instruments -s devices") do |stdin, stdout, stderr, wait_thr|
+            instruments_devices_output = stdout.read
+          end
+
+          instruments_devices_output.split(/\n/).each do |instruments_device|
+            device_uuids.each do |device_uuid|
+              match = instruments_device.match(/(.+) \(([0-9.]+)\) \[([0-9a-f]+)\]?/)
+              if match && match[3] == device_uuid
+                devices << Device.new(name: match[1], udid: match[3], os_type: requested_os_type, os_version: match[2], state: "Booted", is_simulator: false)
+                UI.verbose("USB Device Found - \"" + match[1] + "\" (" + match[2] + ") UUID:" + match[3])
+              end
+            end
+          end
+        end
+
+        return devices
+      end
+
+      # The code below works from Xcode 7 on
+      # def all
+      #   UI.verbose("Fetching available devices")
+
+      #   @devices = []
+      #   output = ''
+      #   Open3.popen3('xcrun simctl list devices --json') do |stdin, stdout, stderr, wait_thr|
+      #     output = stdout.read
+      #   end
+
+      #   begin
+      #     data = JSON.parse(output)
+      #   rescue => ex
+      #     UI.error(ex)
+      #     UI.error("xcrun simctl CLI broken, run `xcrun simctl list devices` and make sure it works")
+      #     UI.user_error!("xcrun simctl not working.")
+      #   end
+
+      #   data["devices"].each do |os_version, l|
+      #     l.each do |device|
+      #       next if device['availability'].include?("unavailable")
+      #       next unless os_version.include?(requested_os_type)
+
+      #       os = os_version.gsub(requested_os_type + " ", "").strip
+      #       @devices << Device.new(name: device['name'], os_type: requested_os_type, os_version: os, udid: device['udid'])
+      #     end
+      #   end
+
+      #   return @devices
+      # end
+    end
+
+    # Use the UDID for the given device when setting the destination
+    # Why? Because we might get this error message
+    # > The requested device could not be found because multiple devices matched the request.
+    #
+    # This happens when you have multiple simulators for a given device type / iOS combination
+    #   { platform:iOS Simulator, id:1685B071-AFB2-4DC1-BE29-8370BA4A6EBD, OS:9.0, name:iPhone 5 }
+    #   { platform:iOS Simulator, id:A141F23B-96B3-491A-8949-813B376C28A7, OS:9.0, name:iPhone 5 }
+    #
+    # We don't want to deal with that, so we just use the UDID
+
+    class Device
+      attr_accessor :name
+      attr_accessor :udid
+      attr_accessor :os_type
+      attr_accessor :os_version
+      attr_accessor :ios_version # Preserved for backwards compatibility
+      attr_accessor :state
+      attr_accessor :is_simulator
+
+      def initialize(name: nil, udid: nil, os_type: nil, os_version: nil, state: nil, is_simulator: nil)
+        self.name = name
+        self.udid = udid
+        self.os_type = os_type
+        self.os_version = os_version
+        self.ios_version = os_version
+        self.state = state
+        self.is_simulator = is_simulator
+      end
+
+      def to_s
+        self.name
+      end
+
+      def reset
+        UI.message("Resetting #{self}")
+        `xcrun simctl shutdown #{self.udid}` if self.state == "Booted"
+        `xcrun simctl erase #{self.udid}`
+        return
+      end
+    end
+  end
+
+  class Simulator
+    class << self
+      def all
+        return DeviceManager.simulators('iOS')
+      end
+
+      # Reset all simulators of this type
+      def reset_all
+        all.each(&:reset)
+      end
+
+      def reset_all_by_version(os_version: nil)
+        return false unless os_version
+        all.select { |device| device.os_version == os_version }.each(&:reset)
+      end
+
+      # Reset simulator by UDID or name and OS version
+      # Latter is useful when combined with -destination option of xcodebuild
+      def reset(udid: nil, name: nil, os_version: nil)
+        match = all.detect { |device| device.udid == udid || device.name == name && device.os_version == os_version }
+        match.reset if match
+      end
+
+      def clear_cache
+        @devices = nil
+      end
+
+      def launch(device)
+        return unless device.is_simulator
+
+        simulator_path = File.join(Helper.xcode_path, 'Applications', 'Simulator.app')
+
+        UI.verbose "Launching #{simulator_path} for device: #{device.name} (#{device.udid})"
+
+        Helper.backticks("open -a #{simulator_path} --args -CurrentDeviceUDID #{device.udid}", print: $verbose)
+      end
+    end
+  end
+
+  class SimulatorTV < Simulator
+    class << self
+      def all
+        return DeviceManager.simulators('tvOS')
+      end
+    end
+  end
+
+  class SimulatorWatch < Simulator
+    class << self
+      def all
+        return DeviceManager.simulators('watchOS')
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/env.rb

@@ -0,0 +1,9 @@
+module FastlaneCore
+  class Env
+    def self.truthy?(env)
+      return false unless ENV[env]
+      return false if ["no", "false", "off", "0"].include?(ENV[env].to_s)
+      return true
+    end
+  end
+end

data/{lib/fastlane → fastlane_core/lib/fastlane_core}/fastlane_folder.rb

@@ -1,4 +1,4 @@
-module Fastlane
+module FastlaneCore
   class FastlaneFolder
     FOLDER_NAME = 'fastlane'
 
@@ -33,15 +33,5 @@ module Fastlane
       FileUtils.mkdir_p(path)
       UI.success "Created new folder '#{path}'."
     end
-
-    # Returns an array of symbols for the available lanes for the Fastfile
-    # This doesn't actually use the Fastfile parser, but only
-    # the available lanes. This way it's much faster
-    # Use this only if performance is :key:
-    def self.available_lanes
-      return [] if fastfile_path.nil?
-      output = `cat #{fastfile_path.shellescape} | grep \"^\s*lane \:\" | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}'`
-      return output.strip.split(" ").collect(&:to_sym)
-    end
   end
 end

data/fastlane_core/lib/fastlane_core/feature/feature.rb

@@ -0,0 +1,49 @@
+module FastlaneCore
+  class Feature
+    class << self
+      attr_reader :features
+
+      def register(env_var: nil, description: nil)
+        feature = self.new(description: description, env_var: env_var)
+        @features[feature.env_var] = feature
+      end
+
+      def enabled?(env_var)
+        feature = @features[env_var]
+        return false if feature.nil?
+        return FastlaneCore::Env.truthy?(feature.env_var)
+      end
+
+      def register_class_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.define_singleton_method(symbol) do |*args|
+          if Feature.enabled?(env_var)
+            klass.send(enabled_symbol, *args)
+          else
+            klass.send(disabled_symbol, *args)
+          end
+        end
+      end
+
+      def register_instance_method(klass: nil, symbol: nil, disabled_symbol: nil, enabled_symbol: nil, env_var: nil)
+        return if klass.nil? || symbol.nil? || disabled_symbol.nil? || enabled_symbol.nil? || env_var.nil?
+        klass.send(:define_method, symbol.to_s) do |*args|
+          if Feature.enabled?(env_var)
+            send(enabled_symbol, *args)
+          else
+            send(disabled_symbol, *args)
+          end
+        end
+      end
+    end
+
+    @features = {}
+
+    attr_reader :env_var, :description
+    def initialize(env_var: nil, description: nil)
+      raise "Invalid Feature" if env_var.nil? || description.nil?
+      @env_var = env_var
+      @description = description
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/features.rb

@@ -0,0 +1,2 @@
+FastlaneCore::Feature.register(env_var: 'FASTLANE_ITUNES_TRANSPORTER_USE_SHELL_SCRIPT',
+                           description: 'Use iTunes Transporter shell script')

data/fastlane_core/lib/fastlane_core/helper.rb

@@ -0,0 +1,240 @@
+require 'logger'
+require 'colored'
+
+module FastlaneCore
+  # rubocop:disable Metrics/ModuleLength
+  module Helper
+    # This method is deprecated, use the `UI` class
+    # https://github.com/fastlane/fastlane/blob/master/fastlane/docs/UI.md
+    def self.log
+      UI.deprecated "Helper.log is deprecated. Use `UI` class instead"
+      UI.current.log
+    end
+
+    # Runs a given command using backticks (`)
+    # and prints them out using the UI.command method
+    def self.backticks(command, print: true)
+      UI.command(command) if print
+      result = `#{command}`
+      UI.command_output(result) if print
+      return result
+    end
+
+    # @return true if the currently running program is a unit test
+    def self.test?
+      defined? SpecHelper
+    end
+
+    # removes ANSI colors from string
+    def self.strip_ansi_colors(str)
+      str.gsub(/\e\[([;\d]+)?m/, '')
+    end
+
+    # @return [boolean] true if executing with bundler (like 'bundle exec fastlane [action]')
+    def self.bundler?
+      # Bundler environment variable
+      ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    # Do we run from a bundled fastlane, which contains Ruby and OpenSSL?
+    # Usually this means the fastlane directory is ~/.fastlane/bin/
+    # We set this value via the environment variable `FASTLANE_SELF_CONTAINED`
+    def self.contained_fastlane?
+      ENV["FASTLANE_SELF_CONTAINED"].to_s == "true" && !self.homebrew?
+    end
+
+    # returns true if fastlane was installed from the Fabric Mac app
+    def self.mac_app?
+      ENV["FASTLANE_SELF_CONTAINED"].to_s == "false"
+    end
+
+    # returns true if fastlane was installed via Homebrew
+    def self.homebrew?
+      ENV["FASTLANE_INSTALLED_VIA_HOMEBREW"].to_s == "true"
+    end
+
+    # returns true if fastlane was installed via RubyGems
+    def self.rubygems?
+      !self.bundler? && !self.contained_fastlane? && !self.homebrew? && !self.mac_app?
+    end
+
+    # @return [boolean] true if building in a known CI environment
+    def self.ci?
+      # Check for Jenkins, Travis CI, ... environment variables
+      ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'CI', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS'].each do |current|
+        return true if ENV.key?(current)
+      end
+      return false
+    end
+
+    def self.windows?
+      # taken from: http://stackoverflow.com/a/171011/1945875
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def self.linux?
+      (/linux/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Is the currently running computer a Mac?
+    def self.mac?
+      (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # Use Helper.test? and Helper.ci? instead (legacy calls)
+    def self.is_test?
+      self.test?
+    end
+
+    def self.is_ci?
+      ci?
+    end
+
+    def self.is_mac?
+      self.mac?
+    end
+
+    # Do we want to disable the colored output?
+    def self.colors_disabled?
+      FastlaneCore::Env.truthy?("FASTLANE_DISABLE_COLORS")
+    end
+
+    # Does the user use the Mac stock terminal
+    def self.mac_stock_terminal?
+      FastlaneCore::Env.truthy?("TERM_PROGRAM_VERSION")
+    end
+
+    # Does the user use iTerm?
+    def self.iterm?
+      FastlaneCore::Env.truthy?("ITERM_SESSION_ID")
+    end
+
+    # Logs base directory
+    def self.buildlog_path
+      return ENV["FL_BUILDLOG_PATH"] || "~/Library/Logs"
+    end
+
+    # All Xcode Related things
+    #
+
+    # @return the full path to the Xcode developer tools of the currently
+    #  running system
+    def self.xcode_path
+      return "" if self.is_test? and !self.is_mac?
+      `xcode-select -p`.delete("\n") + "/"
+    end
+
+    # @return The version of the currently used Xcode installation (e.g. "7.0")
+    def self.xcode_version
+      return @xcode_version if @xcode_version
+
+      begin
+        output = `DEVELOPER_DIR='' "#{xcode_path}/usr/bin/xcodebuild" -version`
+        @xcode_version = output.split("\n").first.split(' ')[1]
+      rescue => ex
+        UI.error(ex)
+        UI.error("Error detecting currently used Xcode installation")
+      end
+      @xcode_version
+    end
+
+    def self.transporter_java_executable_path
+      return File.join(self.transporter_java_path, 'bin', 'java')
+    end
+
+    def self.transporter_java_ext_dir
+      return File.join(self.transporter_java_path, 'lib', 'ext')
+    end
+
+    def self.transporter_java_jar_path
+      return File.join(self.itms_path, 'lib', 'itmstransporter-launcher.jar')
+    end
+
+    def self.transporter_user_dir
+      return File.join(self.itms_path, 'bin')
+    end
+
+    def self.transporter_java_path
+      return File.join(self.itms_path, 'java')
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.transporter_path
+      return File.join(self.itms_path, 'bin', 'iTMSTransporter')
+    end
+
+    def self.keychain_path(name)
+      # Existing code expects that a keychain name will be expanded into a default path to Libary/Keychains
+      # in the user's home directory. However, this will not allow the user to pass an absolute path
+      # for the keychain value
+      #
+      # So, if the passed value can't be resolved as a file in Library/Keychains, just use it as-is
+      # as the keychain path.
+      #
+      # We need to expand each path because File.exist? won't handle directories including ~ properly
+      #
+      # We also try to append `-db` at the end of the file path, as with Sierra the default Keychain name
+      # has changed for some users: https://github.com/fastlane/fastlane/issues/5649
+      #
+
+      # Remove the ".keychain" at the end of the name
+      name.sub!(/\.keychain$/, "")
+
+      possible_locations = [
+        File.join(Dir.home, 'Library', 'Keychains', name),
+        name
+      ].map { |path| File.expand_path(path) }
+
+      # Transforms ["thing"] to ["thing", "thing-db", "thing.keychain", "thing.keychain-db"]
+      keychain_paths = []
+      possible_locations.each do |location|
+        keychain_paths << location
+        keychain_paths << "#{location}-db"
+        keychain_paths << "#{location}.keychain"
+        keychain_paths << "#{location}.keychain-db"
+      end
+
+      keychain_path = keychain_paths.find { |path| File.exist?(path) }
+      UI.user_error!("Could not locate the provided keychain. Tried:\n\t#{keychain_paths.join("\n\t")}") unless keychain_path
+      keychain_path
+    end
+
+    # @return the full path to the iTMSTransporter executable
+    def self.itms_path
+      return ENV["FASTLANE_ITUNES_TRANSPORTER_PATH"] if FastlaneCore::Env.truthy?("FASTLANE_ITUNES_TRANSPORTER_PATH")
+      return '' unless self.is_mac? # so tests work on Linx too
+
+      [
+        "../Applications/Application Loader.app/Contents/MacOS/itms",
+        "../Applications/Application Loader.app/Contents/itms"
+      ].each do |path|
+        result = File.expand_path(File.join(self.xcode_path, path))
+        return result if File.exist?(result)
+      end
+      UI.user_error!("Could not find transporter at #{self.xcode_path}. Please make sure you set the correct path to your Xcode installation.")
+    end
+
+    def self.fastlane_enabled?
+      # This is called from the root context on the first start
+      @enabled ||= (File.directory?("./fastlane") || File.directory?("./.fastlane"))
+    end
+
+    # <b>DEPRECATED:</b> Use the `ROOT` constant from the appropriate tool module instead
+    # e.g. File.join(Sigh::ROOT, 'lib', 'assets', 'resign.sh')
+    #
+    # Path to the installed gem to load resources (e.g. resign.sh)
+    def self.gem_path(gem_name)
+      UI.deprecated('`Helper.gem_path` is deprecated. Use the `ROOT` constant from the appropriate tool module instead.')
+
+      if !Helper.is_test? and Gem::Specification.find_all_by_name(gem_name).any?
+        return Gem::Specification.find_by_name(gem_name).gem_dir
+      else
+        return './'
+      end
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end