fastlane_hotfix 2.165.0

data/frameit/lib/frameit/strings_parser.rb

@@ -0,0 +1,46 @@
+require_relative 'module'
+
+module Frameit
+  # This class will parse the .string files
+  class StringsParser
+    def self.parse(path)
+      UI.user_error!("Couldn't find strings file at path '#{path}'") unless File.exist?(path)
+      UI.user_error!("Must be .strings file, only got '#{path}'") unless path.end_with?(".strings")
+
+      result = {}
+
+      # A .strings file is UTF-16 encoded. We only want to deal with UTF-8
+      encoding = encoding_type(path)
+      if encoding.include?('utf-8') || encoding.include?('us-ascii')
+        content = File.read(path)
+      else
+        content = `iconv -f UTF-16 -t UTF-8 "#{path}" 2>&1` # note: double quotes around path so command also works on Windows
+      end
+
+      content.split("\n").each_with_index do |line, index|
+        begin
+          # We don't care about comments and empty lines
+          if line.start_with?('"')
+            key = line.match(/"(.*)" \= /)[1]
+            value = line.match(/ \= "(.*)"/)[1]
+
+            result[key] = value
+          end
+        rescue => ex
+          UI.error("Error parsing #{path} line #{index + 1}: '#{line}'")
+          UI.verbose("#{ex.message}\n#{ex.backtrace.join('\n')}")
+        end
+      end
+
+      if result.empty?
+        UI.error("Empty parsing result for #{path}. Please make sure the file is valid and UTF16 Big-endian encoded")
+      end
+
+      result
+    end
+
+    def self.encoding_type(path)
+      Helper.backticks("file --mime-encoding #{path.shellescape}", print: false).downcase
+    end
+  end
+end

data/frameit/lib/frameit/template_finder.rb

@@ -0,0 +1,45 @@
+require 'deliver/app_screenshot'
+require_relative 'module'
+require_relative 'device_types'
+require_relative 'frame_downloader'
+
+module Frameit
+  # Responsible for finding the correct device
+  class TemplateFinder
+    # This will detect the screen size and choose the correct template
+    def self.get_template(screenshot)
+      return nil if screenshot.mac?
+
+      filename = create_file_name(screenshot.device_name, screenshot.color.nil? ? screenshot.default_color : screenshot.color)
+      templates = Dir["#{FrameDownloader.templates_path}/#{filename}.{png,jpg}"] # ~/.frameit folder
+
+      UI.verbose("Looking for #{filename} and found #{templates.count} template(s)")
+
+      return filename if Helper.test?
+      if templates.count == 0 && !screenshot.color.nil? && screenshot.color != screenshot.default_color
+        filename = create_file_name(screenshot.device_name, screenshot.default_color)
+        UI.important("Unfortunately device type '#{screenshot.device_name}' is not available in #{screenshot.color}, falling back to " + (screenshot.default_color.nil? ? "default" : screenshot.default_color) + "...")
+        templates = Dir["#{FrameDownloader.templates_path}/#{filename}.{png,jpg}"] # ~/.frameit folder
+        UI.verbose("Looking for #{filename} and found #{templates.count} template(s)")
+      end
+
+      if templates.count == 0
+        if screenshot.deliver_screen_id == Deliver::AppScreenshot::ScreenSize::IOS_35
+          UI.important("Unfortunately 3.5\" device frames were discontinued. Skipping screen '#{screenshot.path}'")
+          UI.error("Looked for: '#{filename}.png'")
+        else
+          UI.error("Couldn't find template for screenshot type '#{filename}'")
+          UI.error("Please run `fastlane frameit download_frames` to download the latest frames")
+        end
+        return nil
+      else
+        return templates.first.tr(" ", "\ ")
+      end
+    end
+
+    def self.create_file_name(device_name, color)
+      return "#{device_name} #{color}" unless color.nil?
+      return device_name
+    end
+  end
+end

data/frameit/lib/frameit/trim_box.rb

@@ -0,0 +1,35 @@
+require_relative 'module'
+
+module Frameit
+  # Represents the MiniMagick trim bounding box for cropping a text image
+  class Trimbox
+    attr_accessor :width # width of the trim box
+    attr_accessor :height # height of the trim box
+    attr_accessor :offset_x # horizontal offset from the canvas to the trim box
+    attr_accessor :offset_y # vertical offset from the canvas to the trim box
+
+    # identify_string: A string with syntax "<width>x<height>+<offset_x>+<offset_y>". This is returned by MiniMagick when using function .identify with format("%@"). It is also required for the MiniMagick .crop function.
+    def initialize(identify_string)
+      UI.user_error!("Trimbox can not be initialised with an empty 'identify_string'.") unless identify_string.length > 0
+
+      # Parse the input syntax "<width>x<height>+<offset_x>+<offset_y>".
+      # Extract these 4 parameters into an integer array, by using multiple string separators: "x" and "+":
+      trim_values = identify_string.split(/[x+]/).map(&:to_i)
+
+      # If 'identify_string' doesn't have the expected syntax with 4 parameters, show error:
+      UI.user_error!("Trimbox is initialised with an invalid value for 'identify_string'.") unless trim_values.length == 4
+
+      # Assign instance variables:
+      @width = trim_values[0]
+      @height = trim_values[1]
+      @offset_x = trim_values[2]
+      @offset_y = trim_values[3]
+    end
+
+    # Get the trimbox parameters in the MiniMagick string format
+    def string_format
+      # Convert trim box parameters to string with syntax: "<width>x<height>+<offset_x>+<offset_y>":
+      return "#{@width}x#{@height}+#{@offset_x}+#{@offset_y}"
+    end
+  end
+end

data/gym/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/gym/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/gym/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/gym/assets/gym.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>gym</i> docs were moved to <a href='https://docs.fastlane.tools/actions/gym/'>docs.fastlane.tools</a></h3>

data/gym/lib/assets/GymfileTemplate

@@ -0,0 +1,13 @@
+# For more information about this configuration visit
+# https://docs.fastlane.tools/actions/gym/#gymfile
+
+# In general, you can use the options available
+# fastlane gym --help
+
+# Remove the # in front of the line to enable the option
+
+# scheme("Example")
+
+# sdk("iphoneos9.0")
+
+output_directory("./")

data/gym/lib/assets/GymfileTemplate.swift

@@ -0,0 +1,13 @@
+// For more information about this configuration visit
+// https://docs.fastlane.tools/actions/gym/#gymfile
+
+// In general, you can use the options available
+// fastlane gym --help
+
+// Remove the // in front of the line to enable the option
+
+class Gymfile: GymfileProtocol {
+  //var sdk: String { return "iphoneos9.0" }
+  //var scheme: String { return "Example" }
+  var outputDirectory: String { return "./" }
+}

data/gym/lib/assets/wrap_xcodebuild/xcbuild-safe.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# shellcheck disable=SC2155
+# shellcheck disable=SC1090
+
+# Originally from, https://stackoverflow.com/questions/33041109
+# Modified to work in RVM and non RVM environments
+#
+# Xcode 7 (incl. 7.0.1) seems to have a dependency on the system ruby.
+# xcodebuild has issues by using rvm to map to another non-system
+# ruby. This script is a fix that allows you call xcodebuild in a
+# "safe" rvm environment, but will not (AFAIK) affect the "external"
+# rvm setting.
+#
+# The script is a drop in replacement for your xcodebuild call.
+#
+#   xcodebuild arg1 ... argn
+#
+# would become
+#
+#   path/to/xcbuild-safe.sh arg1 ... argn
+#
+# More information available here: https://github.com/fastlane/fastlane/issues/6495
+# -----
+
+which rvm > /dev/null
+# shellcheck disable=SC2181
+if [[ $? -eq 0 ]]; then
+  echo "RVM detected, forcing to use system ruby"
+  # This allows you to use rvm in a script. Otherwise you get a BS
+  # error along the lines of "cannot use rvm as function". Jeez.
+  [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"
+
+  # Cause rvm to use system ruby. AFAIK, this is effective only for
+  # the scope of this script.
+  rvm use system
+fi
+
+if which rbenv > /dev/null; then
+  echo "rbenv detected, removing env variables"
+
+  # Cause rbenv to use system ruby. Lasts only for the scope of this
+  # session which will normally just be this script.
+  rbenv shell system
+fi
+
+# Since Xcode has a dependency to 2 external gems: sqlite and CFPropertyList
+# More information https://github.com/fastlane/fastlane/issues/6495
+# We have to unset those variables for rbenv, rvm and when the user uses bundler
+unset RUBYLIB
+unset RUBYOPT
+unset BUNDLE_BIN_PATH
+unset _ORIGINAL_GEM_PATH
+unset BUNDLE_GEMFILE
+# Even if we do not use rbenv in some environments such as CircleCI,
+# We also need to unset GEM_HOME and GEM_PATH explicitly.
+# More information https://github.com/fastlane/fastlane/issues/6277
+unset GEM_HOME
+unset GEM_PATH
+
+set -x          # echoes commands
+xcodebuild "$@" # calls xcodebuild with all the arguments passed to this

data/gym/lib/gym.rb

@@ -0,0 +1,9 @@
+require_relative 'gym/manager'
+require_relative 'gym/generators/build_command_generator'
+require_relative 'gym/generators/package_command_generator'
+require_relative 'gym/runner'
+require_relative 'gym/error_handler'
+require_relative 'gym/options'
+require_relative 'gym/detect_values'
+require_relative 'gym/xcode'
+require_relative 'gym/code_signing_mapping'

data/gym/lib/gym/code_signing_mapping.rb

@@ -0,0 +1,210 @@
+require 'xcodeproj'
+
+require_relative 'module'
+
+module Gym
+  class CodeSigningMapping
+    attr_accessor :project
+
+    def initialize(project: nil)
+      self.project = project
+    end
+
+    # @param primary_mapping [Hash] The preferred mapping (e.g. whatever the user provided)
+    # @param secondary_mapping [Hash] (optional) The secondary mapping (e.g. whatever is detected from the Xcode project)
+    # @param export_method [String] The method that should be preferred in case there is a conflict
+    def merge_profile_mapping(primary_mapping: nil, secondary_mapping: nil, export_method: nil)
+      final_mapping = (primary_mapping || {}).dup # for verbose output at the end of the method
+      secondary_mapping ||= self.detect_project_profile_mapping # default to Xcode project
+
+      final_mapping = Hash[final_mapping.map { |k, v| [k.to_sym, v] }]
+      secondary_mapping = Hash[secondary_mapping.map { |k, v| [k.to_sym, v] }]
+
+      # Now it's time to merge the (potentially) existing mapping
+      #   (e.g. coming from `provisioningProfiles` of the `export_options` or from previous match calls)
+      # with the secondary hash we just created (or was provided as parameter).
+      # Both might include information about what profile to use
+      # This is important as it might not be clear for the user that they have to call match for each app target
+      # before adding this code, we'd only either use whatever we get from match, or what's defined in the Xcode project
+      # With the code below, we'll make sure to take the best of it:
+      #
+      #   1) A provisioning profile is defined in the `primary_mapping`
+      #   2) A provisioning profile is defined in the `secondary_mapping`
+      #   3) On a conflict (app identifier assigned both in xcode and match)
+      #     3.1) we'll choose whatever matches what's defined as the `export_method`
+      #     3.2) If both include the right `export_method`, we'll prefer the one from `primary_mapping`
+      #     3.3) If none has the right export_method, we'll use whatever is defined in the Xcode project
+      #
+      # To get a better sense of this, check out code_signing_spec.rb for some test cases
+
+      secondary_mapping.each do |bundle_identifier, provisioning_profile|
+        if final_mapping[bundle_identifier].nil?
+          final_mapping[bundle_identifier] = provisioning_profile
+        else
+          if self.app_identifier_contains?(final_mapping[bundle_identifier], export_method) # 3.1 + 3.2 nothing to do in this case
+          elsif self.app_identifier_contains?(provisioning_profile, export_method)
+            # Also 3.1 (3.1 is "implemented" twice, as it could be either the primary, or the secondary being the one that matches)
+            final_mapping[bundle_identifier] = provisioning_profile
+          else
+            # 3.3
+            final_mapping[bundle_identifier] = provisioning_profile
+          end
+        end
+      end
+
+      UI.verbose("Merging provisioning profile mappings")
+      UI.verbose("-------------------------------------")
+      UI.verbose("Primary provisioning profile mapping:")
+      UI.verbose(primary_mapping)
+      UI.verbose("Secondary provisioning profile mapping:")
+      UI.verbose(secondary_mapping)
+      UI.verbose("Resulting in the following mapping:")
+      UI.verbose(final_mapping)
+
+      return final_mapping
+    end
+
+    # Helper method to remove "-" and " " and downcase app identifier
+    # and compare if an app identifier includes a certain string
+    # We do some `gsub`bing, because we can't really know the profile type, so we'll just look at the name and see if it includes
+    # the export method (which it usually does, but with different notations)
+    def app_identifier_contains?(str, contains)
+      return str.to_s.gsub("-", "").gsub(" ", "").gsub("InHouse", "enterprise").downcase.include?(contains.to_s.gsub("-", "").gsub(" ", "").downcase)
+    end
+
+    def test_target?(build_settings)
+      return (!build_settings["TEST_TARGET_NAME"].nil? || !build_settings["TEST_HOST"].nil?)
+    end
+
+    def same_platform?(sdkroot)
+      destination = Gym.config[:destination].dup
+      destination.slice!("generic/platform=")
+      destination_sdkroot = []
+      case destination
+      when "macosx"
+        destination_sdkroot = ["macosx"]
+      when "iOS"
+        destination_sdkroot = ["iphoneos", "watchos"]
+      when "tvOS"
+        destination_sdkroot = ["appletvos"]
+      end
+
+      # Catalyst projects will always have an "iphoneos" sdkroot
+      # Need to force a same platform when trying to build as macos
+      if Gym.building_mac_catalyst_for_mac?
+        return true
+      end
+
+      return destination_sdkroot.include?(sdkroot)
+    end
+
+    def detect_configuration_for_archive
+      extract_from_scheme = lambda do
+        if self.project.workspace?
+          available_schemes = self.project.workspace.schemes.reject { |k, v| v.include?("Pods/Pods.xcodeproj") }
+          project_path = available_schemes[Gym.config[:scheme]]
+        else
+          project_path = self.project.path
+        end
+
+        if project_path
+          scheme_path = File.join(project_path, "xcshareddata", "xcschemes", "#{Gym.config[:scheme]}.xcscheme")
+          Xcodeproj::XCScheme.new(scheme_path).archive_action.build_configuration if File.exist?(scheme_path)
+        end
+      end
+
+      configuration = Gym.config[:configuration]
+      configuration ||= extract_from_scheme.call if Gym.config[:scheme]
+      configuration ||= self.project.default_build_settings(key: "CONFIGURATION")
+      return configuration
+    end
+
+    def detect_project_profile_mapping
+      provisioning_profile_mapping = {}
+      specified_configuration = detect_configuration_for_archive
+
+      self.project.project_paths.each do |project_path|
+        UI.verbose("Parsing project file '#{project_path}' to find selected provisioning profiles")
+        UI.verbose("Finding provision profiles for '#{specified_configuration}'") if specified_configuration
+
+        begin
+          # Storing bundle identifiers with duplicate profiles
+          # for informing user later on
+          bundle_identifiers_with_duplicates = []
+
+          project = Xcodeproj::Project.open(project_path)
+          project.targets.each do |target|
+            target.build_configuration_list.build_configurations.each do |build_configuration|
+              current = build_configuration.build_settings
+              next if test_target?(current)
+              sdkroot = build_configuration.resolve_build_setting("SDKROOT", target)
+              next unless same_platform?(sdkroot)
+              next unless specified_configuration == build_configuration.name
+
+              # Catalyst apps will have some build settings that will have a configuration
+              # that is specfic for macos so going to do our best to capture those
+              #
+              # There are other platform filters besides "[sdk=macosx*]" that we could use but
+              # this is the default that Xcode will use so this will also be our default
+              sdk_specifier = Gym.building_mac_catalyst_for_mac? ? "[sdk=macosx*]" : ""
+
+              # Look for sdk specific bundle identifier (if set) and fallback to general configuration if none
+              bundle_identifier = build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER#{sdk_specifier}", target)
+              bundle_identifier ||= build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER", target)
+              next unless bundle_identifier
+
+              # Xcode prefixes "maccatalyst." if building a Catalyst app for mac and
+              # if DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER is set to YES
+              if Gym.building_mac_catalyst_for_mac? && build_configuration.resolve_build_setting("DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER", target) == "YES"
+                bundle_identifier = "maccatalyst.#{bundle_identifier}"
+              end
+
+              # Look for sdk specific provisioning profile specifier (if set) and fallback to general configuration if none
+              provisioning_profile_specifier = build_configuration.resolve_build_setting("PROVISIONING_PROFILE_SPECIFIER#{sdk_specifier}", target)
+              provisioning_profile_specifier ||= build_configuration.resolve_build_setting("PROVISIONING_PROFILE_SPECIFIER", target)
+
+              # Look for sdk specific provisioning profile uuid (if set) and fallback to general configuration if none
+              provisioning_profile_uuid = build_configuration.resolve_build_setting("PROVISIONING_PROFILE#{sdk_specifier}", target)
+              provisioning_profile_uuid ||= build_configuration.resolve_build_setting("PROVISIONING_PROFILE", target)
+
+              has_profile_specifier = provisioning_profile_specifier.to_s.length > 0
+              has_profile_uuid = provisioning_profile_uuid.to_s.length > 0
+
+              # Stores bundle identifiers that have already been mapped to inform user
+              if provisioning_profile_mapping[bundle_identifier] && (has_profile_specifier || has_profile_uuid)
+                bundle_identifiers_with_duplicates << bundle_identifier
+              end
+
+              # Creates the mapping for a bundle identifier and profile specifier/uuid
+              if has_profile_specifier
+                provisioning_profile_mapping[bundle_identifier] = provisioning_profile_specifier
+              elsif has_profile_uuid
+                provisioning_profile_mapping[bundle_identifier] = provisioning_profile_uuid
+              end
+            end
+
+            # Alerting user to explicitly specify a mapping if cannot be determined
+            next if bundle_identifiers_with_duplicates.empty?
+            UI.error("Couldn't automatically detect the provisioning profile mapping")
+            UI.error("There were multiple profiles for bundle identifier(s): #{bundle_identifiers_with_duplicates.uniq.join(', ')}")
+            UI.error("You need to provide an explicit mapping of what provisioning")
+            UI.error("profile to use for each bundle identifier of your app")
+          end
+        rescue => ex
+          # We catch errors here, as we might run into an exception on one included project
+          # But maybe the next project actually contains the information we need
+          if Helper.xcode_at_least?("9.0")
+            UI.error("Couldn't automatically detect the provisioning profile mapping")
+            UI.error("Since Xcode 9 you need to provide an explicit mapping of what")
+            UI.error("provisioning profile to use for each target of your app")
+            UI.error(ex)
+            UI.verbose(ex.backtrace.join("\n"))
+          end
+        end
+      end
+
+      return provisioning_profile_mapping
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end