fastlane_iac_publish 0.1.0

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

@@ -0,0 +1,182 @@
+require_relative '../print_table'
+require_relative '../ui/ui'
+
+module FastlaneCore
+  # Responsible for loading configuration files
+  class ConfigurationFile
+    class ExceptionWhileParsingError < RuntimeError
+      attr_reader :wrapped_exception
+      attr_reader :recovered_options
+
+      def initialize(wrapped_ex, options)
+        @wrapped_exception = wrapped_ex
+        @recovered_options = options
+      end
+    end
+
+    # Available keys from the config file
+    attr_accessor :available_keys
+
+    # After loading, contains all the found options
+    attr_accessor :options
+
+    # Path to the config file represented by the current object
+    attr_accessor :configfile_path
+
+    # @param config [FastlaneCore::Configuration] is used to gather required information about the configuration
+    # @param path [String] The path to the configuration file to use
+    def initialize(config, path, block_for_missing, skip_printing_values = false)
+      self.available_keys = config.all_keys
+      self.configfile_path = path
+      self.options = {}
+
+      @block_for_missing = block_for_missing
+      content = File.read(path, encoding: "utf-8")
+
+      # 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 Security/Eval
+        eval(content) # this is okay in this case
+        # rubocop:enable Security/Eval
+
+        print_resulting_config_values unless skip_printing_values # only on success
+      rescue SyntaxError => ex
+        line = ex.to_s.match(/\(eval\):(\d+)/)[1]
+        UI.error("Error in your #{File.basename(path)} at line #{line}")
+        UI.content_error(content, line)
+        UI.user_error!("Syntax error in your configuration file '#{path}' on line #{line}: #{ex}")
+      rescue => ex
+        raise ExceptionWhileParsingError.new(ex, self.options), "Error while parsing config file at #{path}"
+      end
+    end
+
+    def print_resulting_config_values
+      require 'terminal-table'
+      UI.success("Successfully loaded '#{File.expand_path(self.configfile_path)}' 📄")
+
+      # Show message when self.modified_values is empty
+      if self.modified_values.empty?
+        UI.important("No values defined in '#{self.configfile_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: FastlaneCore::PrintTable.transform_output(rows),
+                              title: "Detected Values from '#{self.configfile_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
+      return if self.options.key?(method_sym)
+
+      if self.available_keys.include?(method_sym)
+
+        value = arguments.first
+        value = yield if value.nil? && block_given?
+
+        if value.nil?
+          unless block_given?
+            # The config file has something like this:
+            #
+            #   clean
+            #
+            # without specifying a value for the method call
+            # or a block. This is most likely a user error
+            # So we tell the user that they can provide a value
+            warning = ["In the config file '#{self.configfile_path}'"]
+            warning << "you have the line #{method_sym}, but didn't provide"
+            warning << "any value. Make sure to append a value right after the"
+            warning << "option name. Make sure to check the docs for more information"
+            UI.important(warning.join(" "))
+          end
+          return
+        end
+
+        self.modified_values[method_sym] = value
+
+        # to support frozen strings (e.g. ENV variables) too
+        # we have to dupe the value
+        # in < Ruby 2.4.0 `.dup` is not support by boolean values
+        # and there is no good way to check if a class actually
+        # responds to `dup`, so we have to rescue the exception
+        begin
+          value = value.dup
+        rescue TypeError
+          # Nothing specific to do here, if we can't dupe, we just
+          # deal with it (boolean values can't be from env variables anyway)
+        end
+        self.options[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.options[method_sym] = '' # important, since this will raise a good exception for free
+        end
+      end
+    end
+
+    # Override configuration for a specific lane. If received lane name does not
+    # match the lane name available as environment variable, no changes will
+    # be applied.
+    #
+    # @param lane_name Symbol representing a lane name.
+    # @yield Block to run for overriding configuration values.
+    #
+    def for_lane(lane_name)
+      if ENV["FASTLANE_LANE_NAME"] == lane_name.to_s
+        with_a_clean_config_merged_when_complete do
+          yield
+        end
+      end
+    end
+
+    # Override configuration for a specific platform. If received platform name
+    # does not match the platform name available as environment variable, no
+    # changes will be applied.
+    #
+    # @param platform_name Symbol representing a platform name.
+    # @yield Block to run for overriding configuration values.
+    #
+    def for_platform(platform_name)
+      if ENV["FASTLANE_PLATFORM_NAME"] == platform_name.to_s
+        with_a_clean_config_merged_when_complete do
+          yield
+        end
+      end
+    end
+
+    # Allows a configuration block (for_lane, for_platform) to get a clean
+    # configuration for applying values, so that values can be overridden
+    # (once) again. Those values are then merged into the surrounding
+    # configuration as the block completes
+    def with_a_clean_config_merged_when_complete
+      previous_config = self.options.dup
+      self.options = {}
+      begin
+        yield
+      ensure
+        self.options = previous_config.merge(self.options)
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/core_ext/cfpropertylist.rb

@@ -0,0 +1,23 @@
+# To be used instead of require "cfpropertylist". Restores extensions from
+# Plist overwritten by CFPropertyList.
+
+require "cfpropertylist"
+require "plist"
+
+# Brute-force solution to conflict between #to_plist introduced by
+# CFPropertyList and plist. Remove the method added by CFPropertyList
+# and restore the method from Plist::Emit. Each class gains a
+# #to_binary_plist method equivalent to #to_plist from CFPropertyList.
+#
+# CFPropertyList also adds Enumerator#to_plist, but there is no such
+# method from Plist, so leave it.
+[Array, Hash].each do |c|
+  if c.method_defined?(:to_plist)
+    begin
+      c.send(:alias_method, :to_binary_plist, :to_plist)
+      c.send(:remove_method, :to_plist)
+    rescue NameError
+    end
+  end
+  c.module_eval("include Plist::Emit")
+end

data/fastlane_core/lib/fastlane_core/core_ext/shellwords.rb

@@ -0,0 +1,63 @@
+require_relative '../helper'
+require 'shellwords'
+
+# Here be monkey patches
+
+class String
+  # CrossplatformShellwords
+  def shellescape
+    CrossplatformShellwords.shellescape(self)
+  end
+end
+
+class Array
+  def shelljoin
+    CrossplatformShellwords.shelljoin(self)
+  end
+end
+
+# Here be helper
+
+module CrossplatformShellwords
+  # handle switching between implementations of shellescape
+  def shellescape(str)
+    if FastlaneCore::Helper.windows?
+      WindowsShellwords.shellescape(str)
+    else
+      # using `escape` instead of expected `shellescape` here
+      # which corresponds to Shellword's `String.shellescape` implementation
+      # https://github.com/ruby/ruby/blob/1cf2bb4b2085758112503e7da7414d1ef52d4f48/lib/shellwords.rb#L216
+      Shellwords.escape(str)
+    end
+  end
+  module_function :shellescape
+
+  # make sure local implementation is also used in shelljoin
+  def shelljoin(array)
+    array.map { |arg| shellescape(arg) }.join(' ')
+  end
+  module_function :shelljoin
+end
+
+# Windows implementation
+module WindowsShellwords
+  def shellescape(str)
+    str = str.to_s
+
+    # An empty argument will be skipped, so return empty quotes.
+    # https://github.com/ruby/ruby/blob/a6413848153e6c37f6b0fea64e3e871460732e34/lib/shellwords.rb#L142-L143
+    return '""'.dup if str.empty?
+
+    str = str.dup
+
+    # wrap in double quotes if contains space
+    if str =~ /\s/
+      # double quotes have to be doubled if will be quoted
+      str.gsub!('"', '""')
+      return '"' + str + '"'
+    else
+      return str
+    end
+  end
+  module_function :shellescape
+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,331 @@
+require 'open3'
+require 'plist'
+
+require_relative 'command_executor'
+require_relative 'helper'
+
+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
+
+        runtime_info = ''
+        Open3.popen3('xcrun simctl list runtimes') do |stdin, stdout, stderr, wait_thr|
+          # This regex outputs the version info in the format "<platform> <version><exact version>"
+          runtime_info = stdout.read.lines.map { |v| v.sub(/(\w+ \S+)\s*\((\S+)\s[\S\s]*/, "\\1 \\2") }.drop(1)
+        end
+        exact_versions = Hash.new({})
+        runtime_info.each do |r|
+          platform, general, exact = r.split
+          exact_versions[platform] = {} unless exact_versions.include?(platform)
+          exact_versions[platform][general] = exact
+        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 =~ /unavailable/
+          next if line =~ /^== /
+          if line =~ /^-- /
+            (os_type, os_version) = line.gsub(/-- (.*) --/, '\1').split
+          else
+            next if os_type =~ /^Unavailable/
+
+            # "    iPad (5th generation) (852A5796-63C3-4641-9825-65EBDC5C4259) (Shutdown)"
+            # This line will turn the above string into
+            # ["iPad", "(5th generation)", "(852A5796-63C3-4641-9825-65EBDC5C4259)", "(Shutdown)"]
+            matches = line.strip.scan(/(.*?) (\(.*?\))/).flatten.reject(&:empty?)
+            state = matches.pop.to_s.delete('(').delete(')')
+            udid = matches.pop.to_s.delete('(').delete(')')
+            name = matches.join(' ')
+
+            if matches.count && (os_type == requested_os_type || requested_os_type == "")
+              # This is disabled here because the Device is defined later in the file, and that's a problem for the cop
+              @devices << Device.new(name: name, os_type: os_type, os_version: (exact_versions[os_type][os_version] || os_version), udid: udid, state: state, 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)
+
+        discover_devices(result[0], device_types, device_uuids) if result[0]
+
+        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.]+)\) \[(\h{40}|\h{8}-\h{16})\]?/)
+              if match && match[3].delete("-") == 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
+
+      # Recursively handle all USB items, discovering devices that match the
+      # desired types.
+      def discover_devices(usb_item, device_types, discovered_device_udids)
+        (usb_item['_items'] || []).each do |child_item|
+          discover_devices(child_item, device_types, discovered_device_udids)
+        end
+
+        is_supported_device = device_types.any? { |device_type| usb_item['_name'] == device_type }
+        serial_num = usb_item['serial_num'] || ''
+        has_serial_number = serial_num.length == 40 || serial_num.length == 24
+
+        if is_supported_device && has_serial_number
+          discovered_device_udids << serial_num
+        end
+      end
+
+      def latest_simulator_version_for_device(device)
+        simulators.select { |s| s.name == device }
+                  .sort_by { |s| Gem::Version.create(s.os_version) }
+                  .last
+                  .os_version
+      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
+
+      def delete
+        UI.message("Deleting #{self}")
+        `xcrun simctl shutdown #{self.udid}` unless self.state == "Shutdown"
+        `xcrun simctl delete #{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
+
+      # Delete all simulators of this type
+      def delete_all
+        all.each(&:delete)
+      end
+
+      def delete_all_by_version(os_version: nil)
+        return false unless os_version
+        all.select { |device| device.os_version == os_version }.each(&:delete)
+      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: FastlaneCore::Globals.verbose?)
+      end
+
+      def copy_logs(device, log_identity, logs_destination_dir)
+        logs_destination_dir = File.expand_path(logs_destination_dir)
+        os_version = FastlaneCore::CommandExecutor.execute(command: 'sw_vers -productVersion', print_all: false, print_command: false)
+
+        host_computer_supports_logarchives = Gem::Version.new(os_version) >= Gem::Version.new('10.12.0')
+        device_supports_logarchives = Gem::Version.new(device.os_version) >= Gem::Version.new('10.0')
+
+        are_logarchives_supported = device_supports_logarchives && host_computer_supports_logarchives
+        if are_logarchives_supported
+          copy_logarchive(device, log_identity, logs_destination_dir)
+        else
+          copy_logfile(device, log_identity, logs_destination_dir)
+        end
+      end
+
+      def uninstall_app(app_identifier, device_type, device_udid)
+        UI.verbose("Uninstalling app '#{app_identifier}' from #{device_type}...")
+
+        UI.message("Launch Simulator #{device_type}")
+        Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+        UI.message("Uninstall application #{app_identifier}")
+        Helper.backticks("xcrun simctl uninstall #{device_udid} #{app_identifier} &> /dev/null")
+      end
+
+      private
+
+      def copy_logfile(device, log_identity, logs_destination_dir)
+        logfile_src = File.expand_path("~/Library/Logs/CoreSimulator/#{device.udid}/system.log")
+        return unless File.exist?(logfile_src)
+
+        FileUtils.mkdir_p(logs_destination_dir)
+        logfile_dst = File.join(logs_destination_dir, "system-#{log_identity}.log")
+
+        FileUtils.rm_f(logfile_dst)
+        FileUtils.cp(logfile_src, logfile_dst)
+        UI.success("Copying file '#{logfile_src}' to '#{logfile_dst}'...")
+      end
+
+      def copy_logarchive(device, log_identity, logs_destination_dir)
+        require 'shellwords'
+
+        logarchive_dst = File.join(logs_destination_dir, "system_logs-#{log_identity}.logarchive").shellescape
+        FileUtils.rm_rf(logarchive_dst)
+        FileUtils.mkdir_p(File.expand_path("..", logarchive_dst))
+        command = "xcrun simctl spawn #{device.udid} log collect --output #{logarchive_dst} 2>/dev/null"
+        FastlaneCore::CommandExecutor.execute(command: command, print_all: false, print_command: true)
+      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