fastlane_pricing_fix 2.212.1

data/frameit/lib/frameit/module.rb

@@ -0,0 +1,42 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+
+require_relative 'config_parser'
+
+module Frameit
+  class << self
+    attr_accessor :config
+  end
+
+  Boolean = Fastlane::Boolean
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  # Defaults to latest, might be a time stamp if defined in the Framefile.json
+  def self.frames_version
+    return @frames_version if @frames_version
+    @frames_version = "latest"
+
+    config_files = Dir["./**/Framefile.json"]
+    if config_files.count > 0
+      config = ConfigParser.new.load(config_files.first)
+      if config.data["device_frame_version"].to_s.length > 0
+        @frames_version = config.data["device_frame_version"]
+      end
+    end
+
+    UI.success("Using device frames version '#{@frames_version}'")
+
+    return @frames_version
+  end
+end
+
+# rubocop:disable all
+class ::Hash
+  def fastlane_deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+end
+# rubocop:enable all

data/frameit/lib/frameit/offsets.rb

@@ -0,0 +1,28 @@
+require_relative 'module'
+require_relative 'frame_downloader'
+
+module Frameit
+  class Offsets
+    # Returns the image offset needed for a certain device type
+    def self.image_offset(screenshot)
+      require 'json'
+
+      unless @offsets_cache
+        offsets_json_path = File.join(FrameDownloader.new.templates_path, "offsets.json")
+        UI.user_error!("Could not find offsets.json file at path '#{offsets_json_path}'") unless File.exist?(offsets_json_path)
+        @offsets_cache = JSON.parse(File.read(offsets_json_path))
+      end
+
+      offset_value = @offsets_cache["portrait"][sanitize_device_name(screenshot.device_name)]
+      UI.error("Tried looking for offset information for 'portrait', #{screenshot.device_name} in '#{offsets_json_path}'") unless offset_value
+      return offset_value
+    end
+
+    def self.sanitize_device_name(basename)
+      # this should be the same as frames_generator's sanitize_device_name (except stripping colors):
+      basename = basename.gsub("Apple", "")
+      basename = basename.gsub("-", " ")
+      basename.strip.to_s
+    end
+  end
+end

data/frameit/lib/frameit/options.rb

@@ -0,0 +1,112 @@
+require 'fastlane_core/configuration/config_item'
+require 'fastlane/actions/actions_helper'
+require 'fastlane/helper/lane_helper'
+
+require_relative 'module'
+require_relative 'config_parser'
+require_relative 'device_types'
+
+module Frameit
+  class Options
+    def self.available_options
+      @options ||= [
+
+        FastlaneCore::ConfigItem.new(key: :white,
+                                       env_name: "FRAMEIT_WHITE_FRAME",
+                                       description: "Use white device frames",
+                                       type: Boolean,
+                                       optional: true),
+        FastlaneCore::ConfigItem.new(key: :silver,
+                                       env_name: "FRAMEIT_SILVER_FRAME",
+                                       description: "Use white device frames. Alias for :white",
+                                       type: Boolean,
+                                       optional: true),
+        FastlaneCore::ConfigItem.new(key: :rose_gold,
+                                       env_name: "FRAMEIT_ROSE_GOLD_FRAME",
+                                       description: "Use rose gold device frames. Alias for :rose_gold",
+                                       type: Boolean,
+                                       optional: true),
+        FastlaneCore::ConfigItem.new(key: :gold,
+                                       env_name: "FRAMEIT_GOLD_FRAME",
+                                       description: "Use gold device frames. Alias for :gold",
+                                       type: Boolean,
+                                       optional: true),
+        FastlaneCore::ConfigItem.new(key: :force_device_type,
+                                       env_name: "FRAMEIT_FORCE_DEVICE_TYPE",
+                                       description: "Forces a given device type, useful for Mac screenshots, as their sizes vary",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Invalid device type '#{value}'. Available values: " + Devices.all_device_names_without_apple.join(', ')) unless ConfigParser.supported_device?(value)
+                                       end),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphone5s,
+                                       env_name: "FRAMEIT_USE_LEGACY_IPHONE_5_S",
+                                       description: "Use iPhone 5s instead of iPhone SE frames",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphone6s,
+                                       env_name: "FRAMEIT_USE_LEGACY_IPHONE_6_S",
+                                       description: "Use iPhone 6s frames instead of iPhone 7 frames",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphone7,
+                                       env_name: "FRAMEIT_USE_LEGACY_IPHONE_7",
+                                       description: "Use iPhone 7 frames instead of iPhone 8 frames",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphonex,
+                                       env_name: "FRAMEIT_USE_LEGACY_IPHONE_X",
+                                       description: "Use iPhone X instead of iPhone XS frames",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphonexr,
+                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_XR",
+                                     description: "Use iPhone XR instead of iPhone 11 frames",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphonexs,
+                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_XS",
+                                     description: "Use iPhone XS instead of iPhone 11 Pro frames",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphonexsmax,
+                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_XS_MAX",
+                                     description: "Use iPhone XS Max instead of iPhone 11 Pro Max frames",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :force_orientation_block,
+                                       type: :string_callback,
+                                       description: "[Advanced] A block to customize your screenshots' device orientation",
+                                       display_in_shell: false,
+                                       optional: true,
+                                       default_value: proc do |filename|
+                                         f = filename.downcase
+                                         if f.end_with?("force_landscapeleft")
+                                           :landscape_left
+                                         elsif f.end_with?("force_landscaperight")
+                                           :landscape_right
+                                         end
+                                       end,
+                                       default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :debug_mode,
+                                       env_name: "FRAMEIT_DEBUG_MODE",
+                                       description: "Output debug information in framed screenshots",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :resume,
+                                       env_name: "FRAMEIT_RESUME",
+                                       description: "Resume frameit instead of reprocessing all screenshots",
+                                       default_value: false,
+                                       type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_platform,
+                                       env_name: "FRAMEIT_USE_PLATFORM",
+                                       description: "Choose a platform, the valid options are IOS, ANDROID and ANY (default is either general platform defined in the fastfile or IOS to ensure backward compatibility)",
+                                       optional: true,
+                                       default_value: Platform.symbol_to_constant(Fastlane::Helper::LaneHelper.current_platform),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Invalid platform type '#{value}'. Available values are " + Platform.all_platforms.join(', ') + ".") unless ConfigParser.supported_platform?(value)
+                                       end)
+      ]
+    end
+  end
+end

data/frameit/lib/frameit/runner.rb

@@ -0,0 +1,97 @@
+require 'fastimage'
+
+require_relative 'frame_downloader'
+require_relative 'module'
+require_relative 'screenshot'
+require_relative 'device_types'
+
+module Frameit
+  class Runner
+    def initialize
+      downloader = FrameDownloader.new
+      unless downloader.frames_exist?
+        downloader.download_frames
+      end
+    end
+
+    def run(path, color = nil, platform = nil)
+      unless color
+        color = Frameit::Color::SILVER if Frameit.config[:white] || Frameit.config[:silver]
+        color = Frameit::Color::GOLD if Frameit.config[:gold]
+        color = Frameit::Color::ROSE_GOLD if Frameit.config[:rose_gold]
+      end
+
+      screenshots = Dir.glob("#{path}/**/*.{png,PNG}").uniq # uniq because thanks to {png,PNG} there are duplicates
+
+      if screenshots.count > 0
+        screenshots.each do |full_path|
+          next if skip_path?(full_path)
+
+          begin
+            config = create_config(full_path)
+            screenshot = Screenshot.new(full_path, color, config, platform)
+
+            next if skip_up_to_date?(screenshot)
+
+            editor = editor(screenshot, config)
+
+            if editor.should_skip?
+              UI.message("Skipping framing of screenshot #{screenshot.path}.  No title provided in your Framefile.json or title.strings.")
+            else
+              Helper.show_loading_indicator("Framing screenshot '#{full_path}'")
+              editor.frame!
+            end
+          rescue => ex
+            UI.error(ex.to_s)
+            UI.error("Backtrace:\n\t#{ex.backtrace.join("\n\t")}") if FastlaneCore::Globals.verbose?
+          end
+        end
+      else
+        UI.error("Could not find screenshots in current directory: '#{File.expand_path(path)}'")
+      end
+    end
+
+    def skip_path?(path)
+      return true if path.include?("_framed.png")
+      return true if path.include?(".itmsp/") # a package file, we don't want to modify that
+      return true if path.include?("device_frames/") # these are the device frames the user is using
+      device = path.rpartition('/').last.partition('-').first # extract device name
+      if device.downcase.include?("watch")
+        UI.error("Apple Watch screenshots are not framed: '#{path}'")
+        return true # we don't care about watches right now
+      end
+      false
+    end
+
+    def skip_up_to_date?(screenshot)
+      if !screenshot.outdated? && Frameit.config[:resume]
+        UI.message("Skipping framing of screenshot #{screenshot.path} because its framed file seems up-to-date.")
+        return true
+      end
+      false
+    end
+
+    def editor(screenshot, config)
+      if screenshot.mac?
+        return MacEditor.new(screenshot, config)
+      else
+        return Editor.new(screenshot, config, Frameit.config[:debug_mode])
+      end
+    end
+
+    # Loads the config (colors, background, texts, etc.)
+    # Don't use this method to access the actual text and use `fetch_texts` instead
+    def create_config(screenshot_path)
+      # Screengrab pulls screenshots to a different folder location
+      # frameit only handles two levels of folders, to not break
+      # compatibility with Supply we look into a different path for Android
+      # Issue https://github.com/fastlane/fastlane/issues/16289
+      config_path = File.join(File.expand_path("..", screenshot_path), "Framefile.json")
+      config_path = File.join(File.expand_path("../..", screenshot_path), "Framefile.json") unless File.exist?(config_path)
+      config_path = File.join(File.expand_path("../../../..", screenshot_path), "Framefile.json") unless File.exist?(config_path)
+      file = ConfigParser.new.load(config_path)
+      return {} unless file # no config file at all
+      file.fetch_value(screenshot_path)
+    end
+  end
+end

data/frameit/lib/frameit/screenshot.rb

@@ -0,0 +1,134 @@
+require_relative 'editor'
+require_relative 'mac_editor'
+require_relative 'device_types'
+require_relative 'module'
+require_relative 'device'
+
+module Frameit
+  # Represents one screenshot
+  class Screenshot
+    attr_accessor :path # path to the screenshot
+    attr_accessor :size # size in px array of 2 elements: height and width
+    attr_accessor :device # device detected according to resolution, priority and settings
+    attr_accessor :color # the color to use for the frame (from Frameit::Color)
+
+    # path: Path to screenshot
+    # color: Color to use for the frame
+    def initialize(path, color, config, platform_command)
+      UI.user_error!("Couldn't find file at path '#{path}'") unless File.exist?(path)
+      @color = color
+      @path = path
+      @size = FastImage.size(path)
+
+      # There are three ways how we can get settings to Frameit:
+      # - options.rb
+      #   - gets parameters via CLI (e. g. fastlane run frameit use_platform:"android") or fastfile (Fastlane's global
+      #     settings for a given project)
+      #   - see Parameters in the doc
+      #   - contains default values and validates values
+      #   - accessed via Frameit.config[:key]
+      #   - default value is either general platform from fastfile or IOS if run directly
+      #   - lowest priority
+      # - commands_generator.rb
+      #   - commands entered directly to CLI (e. g. fastlane frameit android)
+      #   - they are passed via constructors to other classes
+      #   - higher priority than options.rb (user may enter a command to override fastfile's global setting)
+      # - config_parser.rb
+      #   - gets key / values from Framefile.json
+      #   - see Advanced usage in the doc
+      #   - both default and specific values can be entered in the file (filtered by file name)
+      #   - accessed via ConfigParser.fetch_value(screenshot.path)[key] (the ConfigParser's instance is passed
+      #     to Screenshot's constructor as config, i.e. we call config[key])
+      #   - should have the highest priority, because user might set a specific value for a specific screenshot which
+      #     should override CLI parameters and fastfile global setting
+      platform = config['use_platform'] || platform_command || Frameit.config[:use_platform]
+      @device = Device.find_device_by_id_or_name(config['force_device_type'] || Frameit.config[:force_device_type]) || Device.detect_device(path, platform)
+    end
+
+    # Device name for a given screen size. Used to use the correct template
+    def device_name
+      @device.formatted_name
+      # rubocop:enable Require/MissingRequireStatement
+    end
+
+    def default_color
+      @device.default_color
+    end
+
+    def deliver_screen_id
+      @device.deliver_screen_id
+    end
+
+    # Is the device a 3x device? (e.g. iPhone 6 Plus, iPhone X)
+    def triple_density?
+      !device.density_ppi.nil? && device.density_ppi > 400
+    end
+
+    # Super old devices (iPhone 4)
+    def mini?
+      !device.density_ppi.nil? && device.density_ppi < 300
+    end
+
+    def mac?
+      device_name == 'MacBook'
+    end
+
+    # The name of the orientation of a screenshot. Used to find the correct template
+    def orientation_name
+      return Orientation::PORTRAIT if size[0] < size[1]
+      return Orientation::LANDSCAPE
+    end
+
+    def frame_orientation
+      filename = File.basename(self.path, ".*")
+      block = Frameit.config[:force_orientation_block]
+
+      unless block.nil?
+        orientation = block.call(filename)
+        valid = [:landscape_left, :landscape_right, :portrait, nil]
+        UI.user_error("orientation_block must return #{valid[0..-2].join(', ')} or nil") unless valid.include?(orientation)
+      end
+
+      puts("Forced orientation: #{orientation}") unless orientation.nil?
+
+      return orientation unless orientation.nil?
+      return :portrait if self.orientation_name == Orientation::PORTRAIT
+      return :landscape_right # Default landscape orientation
+    end
+
+    def portrait?
+      return (frame_orientation == :portrait)
+    end
+
+    def landscape_left?
+      return (frame_orientation == :landscape_left)
+    end
+
+    def landscape_right?
+      return (frame_orientation == :landscape_right)
+    end
+
+    def landscape?
+      return self.landscape_left? || self.landscape_right
+    end
+
+    def output_path
+      path.gsub('.png', '_framed.png').gsub('.PNG', '_framed.png')
+    end
+
+    # If the framed screenshot was generated *before* the screenshot file,
+    # then we must be outdated.
+    def outdated?
+      return true unless File.exist?(output_path)
+      return File.mtime(path) > File.mtime(output_path)
+    end
+
+    def language
+      @language ||= Pathname.new(path).parent.basename.to_s
+    end
+
+    def to_s
+      self.path
+    end
+  end
+end

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,41 @@
+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
+
+    # Get the trimbox parameters in a human readable JSON string format
+    def json_string_format
+      # Create a JSON string from the trim box parameters:
+      return "{\"width\" : #{@width}, \"height\" : #{@height} , \"offset_x\" : #{@offset_x}, \"offset_y\" : #{@offset_y}}"
+    end
+  end
+end

data/frameit/lib/frameit.rb

@@ -0,0 +1,13 @@
+require 'frameit/frame_downloader'
+require 'frameit/device_types'
+require 'frameit/runner'
+require 'frameit/screenshot'
+require 'frameit/config_parser'
+require 'frameit/offsets'
+require 'frameit/editor'
+require 'frameit/template_finder'
+require 'frameit/strings_parser'
+require 'frameit/mac_editor'
+require 'frameit/dependency_checker'
+require 'frameit/options'
+require 'frameit/trim_box'

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