fastlane_hotfix 2.165.0

data/frameit/lib/frameit/config_parser.rb

@@ -0,0 +1,136 @@
+require_relative 'device_types'
+
+module Frameit
+  class ConfigParser
+    attr_reader :data
+
+    def load(path)
+      return nil unless File.exist?(path) # we are okay with no config at all
+      UI.verbose("Parsing config file '#{path}'")
+      @path = path
+      self.parse(File.read(path))
+    end
+
+    # @param data (String) the JSON data to be parsed
+    def parse(data)
+      begin
+        @data = JSON.parse(data)
+      rescue => ex
+        UI.error(ex.message)
+        UI.user_error!("Invalid JSON file at path '#{@path}'. Make sure it's a valid JSON file")
+      end
+
+      self
+    end
+
+    # Fetches the finished configuration for a given path. This will try to look for a specific value
+    # and fallback to a default value if nothing was found
+    def fetch_value(path)
+      specifics = @data['data'].select { |a| path.include?(a['filter']) }
+
+      default = @data['default']
+
+      values = default.clone
+      specifics.each do |specific|
+        values = values.fastlane_deep_merge(specific)
+      end
+
+      change_paths_to_absolutes!(values)
+      validate_values(values)
+
+      values
+    end
+
+    # Use absolute paths instead of relative
+    def change_paths_to_absolutes!(values)
+      values.each do |key, value|
+        if value.kind_of?(Hash)
+          change_paths_to_absolutes!(value) # recursive call
+        elsif value.kind_of?(Array)
+          value.each do |current|
+            change_paths_to_absolutes!(current) if current.kind_of?(Hash) # recursive call
+          end
+        else
+          if ['font', 'background'].include?(key)
+            # Change the paths to relative ones
+            # `replace`: to change the content of the string, so it's actually stored
+            if @path # where is the config file. We don't have a config file in tests
+              containing_folder = File.expand_path('..', @path)
+              value.replace(File.join(containing_folder, value))
+            end
+          end
+        end
+      end
+    end
+
+    # Make sure the paths/colors are valid
+    def validate_values(values)
+      values.each do |key, value|
+        if value.kind_of?(Hash)
+          validate_values(value) # recursive call
+        else
+          validate_key(key, value)
+        end
+      end
+    end
+
+    def validate_key(key, value)
+      case key
+      when 'font'
+        UI.user_error!("Could not find font at path '#{File.expand_path(value)}'") unless File.exist?(value)
+      when 'fonts'
+        check_fonts(value)
+      when 'background'
+        UI.user_error!("Could not find background image at path '#{File.expand_path(value)}'") unless File.exist?(value)
+      when 'color'
+        UI.user_error!("Invalid color '#{value}'. Must be valid Hex #123123") unless value.include?("#")
+      when 'padding'
+        unless integer_or_percentage(value) || value.split('x').length == 2
+          UI.user_error!("padding must be an integer, or pair of integers of format 'AxB', or a percentage of screen size")
+        end
+      when 'title_min_height'
+        unless integer_or_percentage(value)
+          UI.user_error!("padding must be an integer, or a percentage of screen size")
+        end
+      when 'show_complete_frame', 'title_below_image'
+        UI.user_error!("'#{key}' must be a Boolean") unless [true, false].include?(value)
+      when 'font_scale_factor'
+        UI.user_error!("font_scale_factor must be numeric") unless value.kind_of?(Numeric)
+      when 'frame'
+        UI.user_error!("Invalid frame color '#{value}'. Frame color must be one of " + Color.all_colors.join(', ')) unless ConfigParser.supported_color?(value)
+      when 'use_platform'
+        UI.user_error!("Invalid platform type '#{value}'. Available values are " + Platform.all_platforms.join(', ') + ".") unless ConfigParser.supported_platform?(value)
+      when 'force_device_type'
+        UI.user_error!("Invalid device type '#{value}'. Available values: " + Devices.all_device_names_without_apple.join(', ')) unless ConfigParser.supported_device?(value)
+      end
+    end
+
+    def check_fonts(value)
+      UI.user_error!("`fonts` must be an array") unless value.kind_of?(Array)
+
+      value.each do |current|
+        UI.user_error!("You must specify a font path") if current.fetch('font', '').length == 0
+        UI.user_error!("Could not find font at path '#{File.expand_path(current.fetch('font'))}'") unless File.exist?(current.fetch('font'))
+        UI.user_error!("`supported` must be an array") unless current.fetch('supported', []).kind_of?(Array)
+      end
+    end
+
+    def integer_or_percentage(value)
+      value.kind_of?(Integer) || (value.end_with?('%') && value.to_f > 0)
+    end
+
+    def self.supported_color?(value)
+      return false if value.nil?
+      Color.all_colors.any? { |c| c == value }
+    end
+
+    def self.supported_platform?(value)
+      return false if value.nil?
+      Platform.all_platforms.any? { |c| c == value }
+    end
+
+    def self.supported_device?(value)
+      return !Device.find_device_by_id_or_name(value).nil?
+    end
+  end
+end

data/frameit/lib/frameit/dependency_checker.rb

@@ -0,0 +1,22 @@
+require_relative 'module'
+
+module Frameit
+  class DependencyChecker
+    def self.check_dependencies
+      return if Helper.test?
+
+      self.check_image_magick
+    end
+
+    def self.check_image_magick
+      unless `which convert`.include?("convert")
+        UI.error('#############################################################')
+        UI.error("# You have to install the ImageMagick to use FrameIt")
+        UI.error("# Install it using 'brew update && brew install imagemagick'")
+        UI.error("# If you don't have homebrew: http://brew.sh")
+        UI.error('#############################################################')
+        UI.user_error!("Install ImageMagick and start frameit again!")
+      end
+    end
+  end
+end

data/frameit/lib/frameit/device.rb

@@ -0,0 +1,90 @@
+require 'fastimage'
+require_relative 'module'
+
+module Frameit
+  class Device
+    REQUIRED_PRIORITY = 999
+
+    attr_reader :id
+    attr_reader :deliver_screen_id
+    attr_reader :formatted_name
+    attr_reader :resolutions
+    attr_reader :density_ppi
+    attr_reader :default_color
+    attr_reader :platform
+    attr_reader :priority_config_key
+
+    def initialize(id, formatted_name, priority, resolutions, density_ppi, default_color, platform = Platform::IOS, deliver_screen_id = nil, priority_config_key = nil)
+      Raise("Priority mustn't be higher than #{REQUIRED_PRIORITY}") if priority > REQUIRED_PRIORITY
+      @id = id
+      @deliver_screen_id = deliver_screen_id
+      @formatted_name = formatted_name
+      @priority = priority
+      @resolutions = resolutions
+      @density_ppi = density_ppi
+      @default_color = default_color
+      @platform = platform
+      @priority_config_key = priority_config_key
+    end
+
+    def priority
+      if !priority_config_key.nil? && Frameit.config[priority_config_key]
+        REQUIRED_PRIORITY
+      else
+        @priority
+      end
+    end
+
+    def is_chosen_platform?(platform)
+      @platform == platform || platform == Platform::ANY
+    end
+
+    def formatted_name_without_apple
+      formatted_name.gsub("Apple", "").strip.to_s
+    end
+
+    def self.detect_device(path, platform)
+      size = FastImage.size(path)
+
+      UI.user_error!("Could not find or parse file at path '#{path}'") if size.nil? || size.count == 0
+
+      found_device = nil
+      filename_device = nil
+      filename = Pathname.new(path).basename.to_s
+      Devices.constants.each do |c|
+        device = Devices.const_get(c)
+        next unless device.resolutions.include?(size)
+        # assign to filename_device if the filename contains the formatted name / id and its priority is higher than the current filename_device
+        filename_device = device if (filename.include?(device.formatted_name_without_apple) || filename.include?(device.id)) && (filename_device.nil? || filename_device.priority < device.priority)
+        next unless device.is_chosen_platform?(platform) && (found_device.nil? || device.priority > found_device.priority)
+        found_device = device
+      end
+
+      # prefer filename
+      return filename_device if filename_device
+
+      # return found_device which was detected according to platform & priority & settings if found
+      return found_device if found_device
+
+      # no device detected - show error and return nil
+      UI.user_error!("Unsupported screen size #{size} for path '#{path}'")
+      return nil
+    end
+
+    # Previously ENV[FRAMEIT_FORCE_DEVICE_TYPE] was matched to Deliver::AppScreenshot::ScreenSize constants. However,
+    # options.rb defined a few Apple devices with unspecified IDs, this option was never read from Frameit.config.
+    # Therefore this function matches both ScreenSize constants and formatted names to maintain backward compatibility.
+    def self.find_device_by_id_or_name(id)
+      return nil if id.nil?
+      found_device = nil
+      # multiple devices can be matched to the same deliver_screen_id constant -> we return the one with the highest priority
+      Devices.constants.each do |c|
+        device = Devices.const_get(c)
+        if (device.id == id || device.deliver_screen_id == id || device.formatted_name_without_apple == id) && (found_device.nil? || device.priority > found_device.priority)
+          found_device = device
+        end
+      end
+      return found_device
+    end
+  end
+end

data/frameit/lib/frameit/device_types.rb

@@ -0,0 +1,144 @@
+require_relative 'module'
+require_relative './device'
+require 'deliver/app_screenshot'
+
+module Frameit
+  module Color
+    MATTE_BLACK ||= "Matte Black"
+    SPACE_GRAY ||= "Space Gray"
+    ROSE_GOLD ||= "Rose Gold"
+    CLEARLY_WHITE ||= "Clearly White"
+    JUST_BLACK ||= "Just Black"
+    NOT_PINK ||= "Not Pink"
+    SILVER_TITANIUM ||= "Silver Titanium"
+    ARCTIC_SILVER ||= "Arctic Silver"
+    CORAL_BLUE ||= "Coral Blue"
+    MAPLE_GOLD ||= "Maple Gold"
+    MIDNIGHT_BLACK ||= "Midnight Black"
+    MIDNIGHT_GREEN ||= "Midnight Green"
+    ORCHID_GRAY ||= "Orchid Gray"
+    BURGUNDY_RED ||= "Burgundy Red"
+    LILAC_PURPLE ||= "Lilac Purple"
+    SUNRISE_GOLD ||= "Sunrise Gold"
+    TITANIUM_GRAY ||= "Titanium Gray"
+    FLAMINGO_PINK ||= "Flamingo Pink"
+    PRISM_BLACK ||= "Prism Black"
+    PRISM_BLUE ||= "Prism Blue"
+    PRISM_GREEN ||= "Prism Green"
+    PRISM_WHITE ||= "Prism White"
+    CERAMIC_WHITE ||= "Ceramic White"
+    OH_SO_ORANGE ||= "Oh So Orange"
+    AURA_BLACK ||= "Aura Black"
+    AURA_GLOW ||= "Aura Glow"
+    AURA_PINK ||= "Aura Pink"
+    AURA_RED ||= "Aura Red"
+    AURA_WHITE ||= "Aura White"
+    AURA_BLUE ||= "Aura Blue"
+    CORAL ||= "Coral"
+    BLACK ||= "Black"
+    WHITE ||= "White"
+    GOLD ||= "Gold"
+    SILVER ||= "Silver"
+    BLUE ||= "Blue"
+    RED ||= "Red"
+    YELLOW ||= "Yellow"
+    GREEN ||= "Green"
+    PINK ||= "Pink"
+    PURPLE ||= "Purple"
+
+    def self.all_colors
+      Color.constants.map { |c| Color.const_get(c).upcase.gsub(' ', '_') }
+    end
+  end
+
+  module Orientation
+    PORTRAIT ||= "PORTRAIT"
+    LANDSCAPE ||= "LANDSCAPE"
+  end
+
+  module Platform
+    ANDROID ||= "ANDROID"
+    IOS ||= "IOS"
+    ANY ||= "ANY"
+
+    def self.all_platforms
+      Platform.constants.map { |c| Platform.const_get(c) }
+    end
+
+    def self.symbol_to_constant(symbol)
+      if symbol == :android
+        ANDROID
+      else
+        IOS
+      end
+    end
+  end
+
+  module Devices
+    GOOGLE_PIXEL_3 ||= Frameit::Device.new("google-pixel-3", "Google Pixel 3", 7, [[1080, 2160], [2160, 1080]], 443, Color::JUST_BLACK, Platform::ANDROID)
+    GOOGLE_PIXEL_3_XL ||= Frameit::Device.new("google-pixel-3-xl", "Google Pixel 3 XL", 7, [[1440, 2960], [2960, 1440]], 523, Color::JUST_BLACK, Platform::ANDROID)
+    # Google Pixel 4's priority should be higher than Samsung Galaxy S10+ (priority 8):
+    GOOGLE_PIXEL_4 ||= Frameit::Device.new("google-pixel-4", "Google Pixel 4", 9, [[1080, 2280], [2280, 1080]], 444, Color::JUST_BLACK, Platform::ANDROID)
+    GOOGLE_PIXEL_4_XL ||= Frameit::Device.new("google-pixel-4-xl", "Google Pixel 4 XL", 9, [[1440, 3040], [3040, 1440]], 537, Color::JUST_BLACK, Platform::ANDROID)
+    HTC_ONE_A9 ||= Frameit::Device.new("htc-one-a9", "HTC One A9", 6, [[1080, 1920], [1920, 1080]], 441, Color::BLACK, Platform::ANDROID)
+    HTC_ONE_M8 ||= Frameit::Device.new("htc-one-m8", "HTC One M8", 3, [[1080, 1920], [1920, 1080]], 441, Color::BLACK, Platform::ANDROID)
+    HUAWEI_P8 ||= Frameit::Device.new("huawei-p8", "Huawei P8", 5, [[1080, 1920], [1920, 1080]], 424, Color::BLACK, Platform::ANDROID)
+    MOTOROLA_MOTO_E ||= Frameit::Device.new("motorola-moto-e", "Motorola Moto E", 3, [[540, 960], [960, 540]], 245, Color::BLACK, Platform::ANDROID)
+    MOTOROLA_MOTO_G ||= Frameit::Device.new("motorola-moto-g", "Motorola Moto G", 4, [[1080, 1920], [1920, 1080]], 401, nil, Platform::ANDROID, nil)
+    NEXUS_4 ||= Frameit::Device.new("nexus-4", "Nexus 4", 7, [[768, 1280], [1820, 768]], 318, nil, Platform::ANDROID)
+    NEXUS_5X ||= Frameit::Device.new("nexus-5x", "Nexus 5X", 7, [[1080, 1920], [1920, 1080]], 423, nil, Platform::ANDROID)
+    NEXUS_6P ||= Frameit::Device.new("nexus-6p", "Nexus 6P", 7, [[1440, 2560], [2560, 1440]], 518, nil, Platform::ANDROID)
+    NEXUS_9 ||= Frameit::Device.new("nexus-9", "Nexus 9", 7, [[1536, 2048], [2048, 1536]], 281, nil, Platform::ANDROID)
+    SAMSUNG_GALAXY_GRAND_PRIME ||= Frameit::Device.new("samsung-galaxy-grand-prime", "Samsung Galaxy Grand Prime", 5, [[540, 960], [960, 540]], 220, Color::BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_NOTE_5 ||= Frameit::Device.new("samsung-galaxy-note-5", "Samsung Galaxy Note 5", 5, [[1440, 2560], [2560, 1440]], 518, Color::BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_NOTE_10 ||= Frameit::Device.new("samsung-galaxy-note-10", "Samsung Galaxy Note 10", 6, [[1080, 2280], [2280, 1080]], 401, Color::AURA_BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_NOTE_10_PLUS ||= Frameit::Device.new("samsung-galaxy-note-10-plus", "Samsung Galaxy Note 10+", 7, [[1440, 3040], [3040, 1440]], 498, Color::AURA_BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S_DUOS ||= Frameit::Device.new("samsung-galaxy-s-duos", "Samsung Galaxy S Duos", 3, [[480, 800], [800, 480]], 233, nil, Platform::ANDROID)
+    SAMSUNG_GALAXY_S3 ||= Frameit::Device.new("samsung-galaxy-s3", "Samsung Galaxy S3", 3, [[720, 1280], [1280, 720]], 306, nil, Platform::ANDROID)
+    SAMSUNG_GALAXY_S5 ||= Frameit::Device.new("samsung-galaxy-s5", "Samsung Galaxy S5", 3, [[1080, 1920], [1920, 1080]], 432, Color::BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S7 ||= Frameit::Device.new("samsung-galaxy-s7", "Samsung Galaxy S7", 4, [[1440, 2560], [2560, 1440]], 577, Color::BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S8 ||= Frameit::Device.new("samsung-galaxy-s8", "Samsung Galaxy S8", 5, [[1440, 2960], [2960, 1440]], 570, Color::MIDNIGHT_BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S9 ||= Frameit::Device.new("samsung-galaxy-s9", "Samsung Galaxy S9", 6, [[1440, 2960], [2960, 1440]], 570, Color::MIDNIGHT_BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S10 ||= Frameit::Device.new("samsung-galaxy-s10", "Samsung Galaxy S10", 7, [[1440, 3040], [3040, 1440]], 550, Color::PRISM_BLACK, Platform::ANDROID)
+    SAMSUNG_GALAXY_S10_PLUS ||= Frameit::Device.new("samsung-galaxy-s10-plus", "Samsung Galaxy S10+", 8, [[1440, 3040], [3040, 1440]], 522, Color::PRISM_BLACK, Platform::ANDROID)
+    XIAOMI_MI_MIX_ALPHA ||= Frameit::Device.new("xiaomi-mi-mix-alpha", "Xiaomi Mi Mix Alpha", 1, [[2088, 2250], [2250, 2088]], 388, nil, Platform::ANDROID)
+    IPHONE_5S ||= Frameit::Device.new("iphone-5s", "Apple iPhone 5s", 2, [[640, 1096], [640, 1136], [1136, 600], [1136, 640]], 326, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_40, :use_legacy_iphone5s)
+    IPHONE_5C ||= Frameit::Device.new("iphone-5c", "Apple iPhone 5c", 2, [[640, 1136], [1136, 640]], 326, Color::WHITE)
+    IPHONE_SE ||= Frameit::Device.new("iphone-se", "Apple iPhone SE", 3, [[640, 1096], [640, 1136], [1136, 600], [1136, 640]], 326, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_40)
+    IPHONE_6S ||= Frameit::Device.new("iphone-6s", "Apple iPhone 6s", 4, [[750, 1334], [1334, 750]], 326, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_47, :use_legacy_iphone6s)
+    IPHONE_6S_PLUS ||= Frameit::Device.new("iphone-6s-plus", "Apple iPhone 6s Plus", 4, [[1242, 2208], [2208, 1242]], 401, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_55, :use_legacy_iphone6s)
+    IPHONE_7 ||= Frameit::Device.new("iphone-7", "Apple iPhone 7", 5, [[750, 1334], [1334, 750]], 326, Color::MATTE_BLACK, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_47, :use_legacy_iphone7)
+    IPHONE_7_PLUS ||= Frameit::Device.new("iphone-7-plus", "Apple iPhone 7 Plus", 5, [[1242, 2208], [2208, 1242]], 401, Color::MATTE_BLACK, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_55, :use_legacy_iphone7)
+    IPHONE_8 ||= Frameit::Device.new("iphone-8", "Apple iPhone 8", 6, [[750, 1334], [1334, 750]], 326, Color::SPACE_GRAY)
+    IPHONE_8_PLUS ||= Frameit::Device.new("iphone-8-plus", "Apple iPhone 8 Plus", 6, [[1080, 1920], [1920, 1080]], 401, Color::SPACE_GRAY)
+    IPHONE_X ||= Frameit::Device.new("iphone-X", "Apple iPhone X", 7, [[1125, 2436], [2436, 1125]], 458, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_58, :use_legacy_iphonex)
+    IPHONE_XS ||= Frameit::Device.new("iphone-XS", "Apple iPhone XS", 8, [[1125, 2436], [2436, 1125]], 458, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_58, :use_legacy_iphonexs)
+    IPHONE_XR ||= Frameit::Device.new("iphone-XR", "Apple iPhone XR", 8, [[828, 1792], [1792, 828]], 326, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_61, :use_legacy_iphonexr)
+    IPHONE_XS_MAX ||= Frameit::Device.new("iphone-XS-Max", "Apple iPhone XS Max", 8, [[1242, 2688], [2688, 1242]], 458, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_65, :use_legacy_iphonexsmax)
+    IPHONE_11 ||= Frameit::Device.new("iphone-11", "Apple iPhone 11", 9, [[828, 1792], [1792, 828]], 326, Color::BLACK, Platform::IOS)
+    IPHONE_11_PRO ||= Frameit::Device.new("iphone-11-pro", "Apple iPhone 11 Pro", 9, [[1125, 2436], [2436, 1125]], 458, Color::SPACE_GRAY, Platform::IOS)
+    IPHONE_11_PRO_MAX ||= Frameit::Device.new("iphone11-pro-max", "Apple iPhone 11 Pro Max", 9, [[1242, 2688], [2688, 1242]], 458, Color::SPACE_GRAY, Platform::IOS)
+    IPAD_10_2 ||= Frameit::Device.new("ipad-10-2", "Apple iPad 10.2", 1, [[1620, 2160], [2160, 1620]], 264, Color::SPACE_GRAY, Platform::IOS)
+    IPAD_AIR_2 ||= Frameit::Device.new("ipad-air-2", "Apple iPad Air 2", 1, [[1536, 2048], [2048, 1536]], 264, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD)
+    IPAD_AIR_2019 ||= Frameit::Device.new("ipad-air-2019", "Apple iPad Air (2019)", 2, [[1668, 2224], [2224, 1668]], 265, Color::SPACE_GRAY, Platform::IOS)
+    IPAD_MINI_4 ||= Frameit::Device.new("ipad-mini-4", "Apple iPad Mini 4", 2, [[1536, 2048], [2048, 1536]], 324, Color::SPACE_GRAY)
+    IPAD_MINI_2019 ||= Frameit::Device.new("ipad-mini-2019", "Apple iPad Mini (2019)", 3, [[1536, 2048], [2048, 1536]], 324, Color::SPACE_GRAY)
+    # this is 1st or 2nd gen of iPad Pro 12.9:
+    IPAD_PRO ||= Frameit::Device.new("ipad-pro", "Apple iPad Pro", 3, [[2048, 2732], [2732, 2048]], 264, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD_PRO)
+    # 3rd generation:
+    IPAD_PRO_12_9 ||= Frameit::Device.new("ipadPro129", "Apple iPad Pro (12.9-inch) (3rd generation)", 4, [[2048, 2732], [2732, 2048]], 264, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD_PRO_12_9)
+    # 4th generation:
+    IPAD_PRO_12_9_4 ||= Frameit::Device.new("ipadPro129", "Apple iPad Pro (12.9-inch) (4th generation)", 5, [[2048, 2732], [2732, 2048]], 264, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD_PRO_12_9)
+    # iPad Pro (10.5-inch) is not in frameit-frames repo, but must be included so that we are backward compatible with PR #15373
+    # priority must be lower so that users who didn't copy the frame to their frameit frames folder will not get an error
+    # ID and formatted name must be exactly as specified so that device.detect_device() will select this device if the filename includes them
+    IPAD_PRO_10_5 ||= Frameit::Device.new("ipad105", "Apple iPad Pro (10.5-inch)", 1, [[1668, 2224], [2224, 1668]], 265, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD_10_5)
+    IPAD_PRO_11 ||= Frameit::Device.new("ipadPro11", "Apple iPad Pro (11-inch)", 1, [[1668, 2388], [2388, 1668]], 265, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::IOS_IPAD_11)
+
+    MAC ||= Frameit::Device.new("mac", "Apple MacBook", 0, [[1280, 800], [1440, 900], [2560, 1600], [2880, 1800]], nil, Color::SPACE_GRAY, Platform::IOS, Deliver::AppScreenshot::ScreenSize::MAC)
+
+    def self.all_device_names_without_apple
+      Devices.constants.map { |c| Devices.const_get(c).formatted_name_without_apple }
+    end
+  end
+end

data/frameit/lib/frameit/editor.rb

@@ -0,0 +1,560 @@
+require 'mini_magick'
+
+require_relative 'template_finder'
+require_relative 'trim_box'
+require_relative 'module'
+require_relative 'offsets'
+require_relative 'config_parser'
+require_relative 'strings_parser'
+require_relative 'device_types'
+
+module Frameit
+  # Currently the class is 2 lines too long. Reevaluate refactoring when it's length changes significantly
+  class Editor # rubocop:disable Metrics/ClassLength
+    attr_accessor :screenshot # reference to the screenshot object to fetch the path, title, etc.
+    attr_accessor :debug_mode
+    attr_accessor :frame_path
+    attr_accessor :frame # the frame of the device
+    attr_accessor :image # the current image used for editing
+    attr_accessor :space_to_device
+
+    def initialize(screenshot, config, debug_mode = false)
+      @screenshot = screenshot
+      @config = config
+      self.debug_mode = debug_mode
+    end
+
+    def frame!
+      prepare_image
+
+      @frame_path = load_frame
+      if @frame_path # Mac doesn't need a frame
+        self.frame = MiniMagick::Image.open(@frame_path)
+        # Rotate the frame according to the device orientation
+        self.frame.rotate(self.rotation_for_device_orientation)
+      elsif self.class == Editor
+        # Couldn't find device frame (probably an iPhone 4, for which there are no images available any more)
+        # Message is already shown elsewhere
+        return
+      end
+
+      if is_complex_framing_mode?
+        @image = complex_framing
+      else
+        # easy mode from 1.0 - no title or background
+        put_into_frame # put it in the frame
+      end
+
+      store_result # write to file system
+    end
+
+    def load_frame
+      color = fetch_frame_color
+      if color
+        screenshot.color = color
+      end
+      TemplateFinder.get_template(screenshot)
+    end
+
+    def prepare_image
+      @image = MiniMagick::Image.open(screenshot.path)
+    end
+
+    def rotation_for_device_orientation
+      return 90 if self.screenshot.landscape_right?
+      return -90 if self.screenshot.landscape_left?
+      return 0
+    end
+
+    def should_skip?
+      return is_complex_framing_mode? && !fetch_text(:title)
+    end
+
+    private
+
+    def store_result
+      output_path = screenshot.output_path
+      image.format("png")
+      image.write(output_path)
+      Helper.hide_loading_indicator
+      UI.success("Added frame: '#{File.expand_path(output_path)}'")
+    end
+
+    # puts the screenshot into the frame
+    def put_into_frame
+      # We have to rotate the screenshot, since the offset information is for portrait
+      # only. Instead of doing the calculations ourselves, it's much easier to let
+      # imagemagick do the hard lifting for landscape screenshots
+      rotation = self.rotation_for_device_orientation
+      frame.rotate(-rotation)
+      @image.rotate(-rotation)
+
+      # Debug Mode: Add filename to frame
+      if self.debug_mode
+        filename = File.basename(@frame_path, ".*")
+        filename.sub!('Apple', '') # remove 'Apple'
+
+        width = screenshot.size[0]
+        font_size = width / 20 # magic number that works well
+
+        offset_top = offset['offset'].split("+")[2].to_f
+        annotate_offset = "+0+#{offset_top}" # magic number that works semi well
+
+        frame.combine_options do |c|
+          c.gravity('North')
+          c.undercolor('#00000080')
+          c.fill('white')
+          c.pointsize(font_size)
+          c.annotate(annotate_offset.to_s, filename.to_s)
+        end
+      end
+
+      @image = frame.composite(image, "png") do |c|
+        c.compose("DstOver")
+        c.geometry(offset['offset'])
+      end
+
+      # Revert the rotation from above
+      frame.rotate(rotation)
+      @image.rotate(rotation)
+    end
+
+    def offset
+      return @offset_information if @offset_information
+
+      @offset_information = @config['offset'] || Offsets.image_offset(screenshot).dup
+
+      if @offset_information && (@offset_information['offset'] || @offset_information['offset'])
+        return @offset_information
+      end
+      UI.user_error!("Could not find offset_information for '#{screenshot}'")
+    end
+
+    #########################################################################################
+    # Everything below is related to title, background, etc. and is not used in the easy mode
+    #########################################################################################
+
+    # this is used to correct the 1:1 offset information
+    # the offset information is stored to work for the template images
+    # since we resize the template images to have higher quality screenshots
+    # we need to modify the offset information by a certain factor
+    def modify_offset(multiplicator)
+      # Format: "+133+50"
+      hash = offset['offset']
+      x = hash.split("+")[1].to_f * multiplicator
+      y = hash.split("+")[2].to_f * multiplicator
+      new_offset = "+#{x.round}+#{y.round}"
+      @offset_information['offset'] = new_offset
+    end
+
+    # Do we add a background and title as well?
+    def is_complex_framing_mode?
+      return (@config['background'] and (@config['title'] or @config['keyword']))
+    end
+
+    # more complex mode: background, frame and title
+    def complex_framing
+      background = generate_background
+
+      self.space_to_device = vertical_frame_padding
+
+      if @config['title']
+        background = put_title_into_background(background, @config['stack_title'])
+      end
+
+      if self.frame # we have no frame on le mac
+        resize_frame!
+        put_into_frame
+
+        # Decrease the size of the framed screenshot to fit into the defined padding + background
+        frame_width = background.width - horizontal_frame_padding * 2
+        frame_height = background.height - effective_text_height - vertical_frame_padding
+
+        if @config['show_complete_frame']
+          # calculate the final size of the screenshot to resize in one go
+          # it may be limited either by the width or height of the frame
+          image_aspect_ratio = @image.width.to_f / @image.height.to_f
+          image_width = [frame_width, @image.width].min
+          image_height = [frame_height, image_width / image_aspect_ratio].min
+          image_width = image_height * image_aspect_ratio
+          @image.resize("#{image_width}x#{image_height}") if image_width < @image.width || image_height < @image.height
+        else
+          # the screenshot size is only limited by width.
+          # If higher than the frame, the screenshot is cut off at the bottom
+          @image.resize("#{frame_width}x") if frame_width < @image.width
+        end
+      end
+
+      @image = put_device_into_background(background)
+
+      image
+    end
+
+    # Horizontal adding around the frames
+    def horizontal_frame_padding
+      padding = @config['padding']
+      if padding.kind_of?(String) && padding.split('x').length == 2
+        padding = padding.split('x')[0]
+        padding = padding.to_i unless padding.end_with?('%')
+      end
+      return scale_padding(padding)
+    end
+
+    # Vertical adding around the frames
+    def vertical_frame_padding
+      padding = @config['padding']
+      if padding.kind_of?(String) && padding.split('x').length == 2
+        padding = padding.split('x')[1]
+        padding = padding.to_i unless padding.end_with?('%')
+      end
+      return scale_padding(padding)
+    end
+
+    # Minimum height for the title
+    def title_min_height
+      @title_min_height ||= begin
+        height = @config['title_min_height'] || 0
+        if height.kind_of?(String) && height.end_with?('%')
+          height = ([image.width, image.height].min * height.to_f * 0.01).ceil
+        end
+        height
+      end
+    end
+
+    def scale_padding(padding)
+      if padding.kind_of?(String) && padding.end_with?('%')
+        padding = ([image.width, image.height].min * padding.to_f * 0.01).ceil
+      end
+      multi = 1.0
+      multi = 1.7 if self.screenshot.triple_density?
+      return padding * multi
+    end
+
+    def effective_text_height
+      [space_to_device, title_min_height].max
+    end
+
+    def device_top(background)
+      @device_top ||= begin
+        if title_below_image
+          background.height - effective_text_height - image.height
+        else
+          effective_text_height
+        end
+      end
+    end
+
+    def title_below_image
+      @title_below_image ||= @config['title_below_image']
+    end
+
+    # Returns a correctly sized background image
+    def generate_background
+      background = MiniMagick::Image.open(@config['background'])
+
+      if background.height != screenshot.size[1]
+        background.resize("#{screenshot.size[0]}x#{screenshot.size[1]}^") # `^` says it should fill area
+        background.merge!(["-gravity", "center", "-crop", "#{screenshot.size[0]}x#{screenshot.size[1]}+0+0"]) # crop from center
+      end
+      background
+    end
+
+    def put_device_into_background(background)
+      left_space = (background.width / 2.0 - image.width / 2.0).round
+
+      @image = background.composite(image, "png") do |c|
+        colorspace = image.data["colorspace"]
+        c.colorspace(colorspace) if colorspace
+
+        c.compose("Over")
+        c.geometry("+#{left_space}+#{device_top(background)}")
+      end
+
+      return image
+    end
+
+    # Resize the frame as it's too low quality by default
+    def resize_frame!
+      screenshot_width = self.screenshot.portrait? ? screenshot.size[0] : screenshot.size[1]
+
+      multiplicator = (screenshot_width.to_f / offset['width'].to_f) # by how much do we have to change this?
+      new_frame_width = multiplicator * frame.width # the new width for the frame
+      frame.resize("#{new_frame_width.round}x") # resize it to the calculated width
+      modify_offset(multiplicator) # modify the offset to properly insert the screenshot into the frame later
+    end
+
+    def resize_text(text)
+      width = text.width
+      ratio = width / (image.width.to_f - horizontal_frame_padding * 2)
+      if ratio > 1.0
+        # too large - resizing now
+        text.resize("#{((1.0 / ratio) * text.width).round}x")
+      end
+    end
+
+    # Add the title above or below the device
+    def put_title_into_background_stacked(background, title, keyword)
+      resize_text(title)
+      resize_text(keyword)
+
+      vertical_padding = vertical_frame_padding # assign padding to variable
+      spacing_between_title_and_keyword = (actual_font_size('keyword') / 2)
+      title_left_space = (background.width / 2.0 - title.width / 2.0).round
+      keyword_left_space = (background.width / 2.0 - keyword.width / 2.0).round
+
+      self.space_to_device += title.height + keyword.height + spacing_between_title_and_keyword + vertical_padding
+
+      if title_below_image
+        keyword_top = background.height - effective_text_height / 2 - (keyword.height + spacing_between_title_and_keyword + title.height) / 2
+      else
+        keyword_top = device_top(background) / 2 - spacing_between_title_and_keyword / 2 - keyword.height
+      end
+      title_top = keyword_top + keyword.height + spacing_between_title_and_keyword
+
+      # keyword
+      background = background.composite(keyword, "png") do |c|
+        c.compose("Over")
+        c.geometry("+#{keyword_left_space}+#{keyword_top}")
+      end
+      # Place the title below the keyword
+      background = background.composite(title, "png") do |c|
+        c.compose("Over")
+        c.geometry("+#{title_left_space}+#{title_top}")
+      end
+      background
+    end
+
+    def put_title_into_background(background, stack_title)
+      text_images = build_text_images(image.width - 2 * horizontal_frame_padding, image.height - 2 * vertical_frame_padding, stack_title)
+
+      keyword = text_images[:keyword]
+      title = text_images[:title]
+
+      if stack_title && !keyword.nil? && !title.nil? && keyword.width > 0 && title.width > 0
+        background = put_title_into_background_stacked(background, title, keyword)
+        return background
+      end
+      # sum_width: the width of both labels together including the space in-between
+      #   is used to calculate the ratio
+      sum_width = title.width
+      sum_width += keyword.width + keyword_padding if keyword
+
+      title_below_image = @config['title_below_image']
+
+      # Resize the 2 labels if they exceed the available space either horizontally or vertically:
+      image_scale_factor = 1.0 # default
+      ratio_horizontal = sum_width / (image.width.to_f - horizontal_frame_padding * 2) # The fraction of the text images compared to the left and right padding
+      ratio_vertical = title.height.to_f / effective_text_height # The fraction of the actual height of the images compared to the available space
+      if ratio_horizontal > 1.0 || ratio_vertical > 1.0
+        # If either is too large, resize with the maximum ratio:
+        image_scale_factor = (1.0 / [ratio_horizontal, ratio_vertical].max)
+
+        UI.verbose("Text for image #{self.screenshot.path} is quite long, reducing font size by #{(100 * (1.0 - image_scale_factor)).round(1)}%")
+
+        title.resize("#{(image_scale_factor * title.width).round}x")
+        keyword.resize("#{(image_scale_factor * keyword.width).round}x") if keyword
+        sum_width *= image_scale_factor
+      end
+
+      vertical_padding = vertical_frame_padding # assign padding to variable
+      left_space = (background.width / 2.0 - sum_width / 2.0).round
+
+      self.space_to_device += actual_font_size('title') + vertical_padding
+
+      if title_below_image
+        title_top = background.height - effective_text_height / 2 - title.height / 2
+      else
+        title_top = device_top(background) / 2 - title.height / 2
+      end
+
+      # First, put the keyword on top of the screenshot, if we have one
+      if keyword
+        background = background.composite(keyword, "png") do |c|
+          c.compose("Over")
+          c.geometry("+#{left_space}+#{title_top}")
+        end
+
+        left_space += keyword.width + (keyword_padding * image_scale_factor)
+      end
+
+      # Then, put the title on top of the screenshot next to the keyword
+      background = background.composite(title, "png") do |c|
+        c.compose("Over")
+        c.geometry("+#{left_space}+#{title_top}")
+      end
+      background
+    end
+
+    def actual_font_size(key)
+      font_size = @config[key.to_s]['font_size']
+      return font_size if !font_size.nil? && font_size > 0
+
+      font_scale_factor = @config['font_scale_factor'] || 0.1
+      UI.user_error!("Parameter 'font_scale_factor' can not be 0. Please provide a value larger than 0.0 (default = 0.1).") if font_scale_factor == 0.0
+      [@image.width * font_scale_factor].max.round
+    end
+
+    # The space between the keyword and the title
+    def keyword_padding
+      (actual_font_size('keyword') / 3.0).round
+    end
+
+    # This will build up to 2 individual images with the title and optional keyword, which will then be added to the real image
+    def build_text_images(max_width, max_height, stack_title)
+      words = [:keyword, :title].keep_if { |a| fetch_text(a) } # optional keyword/title
+      results = {}
+      trim_boxes = {}
+      top_vertical_trim_offset = Float::INFINITY # Init at a large value, as the code will search for a minimal value.
+      bottom_vertical_trim_offset = 0
+      words.each do |key|
+        # Create empty background
+        empty_path = File.join(Frameit::ROOT, "lib/assets/empty.png")
+        text_image = MiniMagick::Image.open(empty_path)
+        image_height = max_height # gets trimmed afterwards anyway, and on the iPad the `y` would get cut
+        text_image.combine_options do |i|
+          # Oversize as the text might be larger than the actual image. We're trimming afterwards anyway
+          i.resize("#{max_width * 5.0}x#{image_height}!") # `!` says it should ignore the ratio
+        end
+
+        current_font = font(key)
+        text = fetch_text(key)
+        UI.verbose("Using #{current_font} as font the #{key} of #{screenshot.path}") if current_font
+        UI.verbose("Adding text '#{text}'")
+
+        text.gsub!('\n', "\n")
+        text.gsub!(/(?<!\\)(')/) { |s| "\\#{s}" } # escape unescaped apostrophes with a backslash
+
+        interline_spacing = @config['interline_spacing']
+
+        # Add the actual title
+        text_image.combine_options do |i|
+          i.font(current_font) if current_font
+          i.weight(@config[key.to_s]['font_weight']) if @config[key.to_s]['font_weight']
+          i.gravity("Center")
+          i.pointsize(actual_font_size(key))
+          i.draw("text 0,0 '#{text}'")
+          i.interline_spacing(interline_spacing) if interline_spacing
+          i.fill(@config[key.to_s]['color'])
+        end
+
+        results[key] = text_image
+
+        # Natively trimming the image with .trim will result in the loss of the common baseline between the text in all images when side-by-side (e.g. stack_title is false).
+        # Hence retrieve the calculated trim bounding box without actually trimming:
+        calculated_trim_box = text_image.identify do |b|
+          b.format("%@") # CALCULATED: trim bounding box (without actually trimming), see: http://www.imagemagick.org/script/escape.php
+        end
+
+        # Create a Trimbox object from the MiniMagick .identify string with syntax "<width>x<height>+<offset_x>+<offset_y>":
+        trim_box = Frameit::Trimbox.new(calculated_trim_box)
+
+        # Get the minimum top offset of the trim box:
+        if trim_box.offset_y < top_vertical_trim_offset
+          top_vertical_trim_offset = trim_box.offset_y
+        end
+
+        # Get the maximum bottom offset of the trim box, this is the top offset + height:
+        if (trim_box.offset_y + trim_box.height) > bottom_vertical_trim_offset
+          bottom_vertical_trim_offset = trim_box.offset_y + trim_box.height
+        end
+
+        # Store for the crop action:
+        trim_boxes[key] = trim_box
+      end
+
+      # Crop text images:
+      words.each do |key|
+        # Get matching trim box:
+        trim_box = trim_boxes[key]
+
+        # For side-by-side text images (e.g. stack_title is false) adjust the trim box based on top_vertical_trim_offset and bottom_vertical_trim_offset to maintain the text baseline:
+        unless stack_title
+          # Determine the trim area by maintaining the same vertical top offset based on the smallest value from all trim boxes (top_vertical_trim_offset).
+          # When the vertical top offset is larger than the smallest vertical top offset, the trim box needs to be adjusted:
+          if trim_box.offset_y > top_vertical_trim_offset
+            # Increase the height of the trim box with the difference in vertical top offset:
+            trim_box.height += trim_box.offset_y - top_vertical_trim_offset
+            # Change the vertical top offset to match that of the others:
+            trim_box.offset_y = top_vertical_trim_offset
+
+            UI.verbose("Trim box for key \"#{key}\" is adjusted to align top: #{trim_box}\n")
+          end
+
+          # Check if the height needs to be adjusted to reach the bottom offset:
+          if (trim_box.offset_y + trim_box.height) < bottom_vertical_trim_offset
+            # Set the height of the trim box to the difference between vertical bottom and top offset:
+            trim_box.height = bottom_vertical_trim_offset - trim_box.offset_y
+
+            UI.verbose("Trim box for key \"#{key}\" is adjusted to align bottom: #{trim_box}\n")
+          end
+        end
+
+        # Crop image with (adjusted) trim box parameters in MiniMagick string format:
+        results[key].crop(trim_box.string_format)
+      end
+
+      results
+    end
+
+    # Fetches the title + keyword for this particular screenshot
+    def fetch_text(type)
+      UI.user_error!("Valid parameters :keyword, :title") unless [:keyword, :title].include?(type)
+
+      # Try to get it from a keyword.strings or title.strings file
+      strings_path = File.join(File.expand_path("../", screenshot.path), "#{type}.strings")
+      strings_path = File.join(File.expand_path("../../", screenshot.path), "#{type}.strings") unless File.exist?(strings_path)
+      strings_path = File.join(File.expand_path("../../../", screenshot.path), "#{type}.strings") unless File.exist?(strings_path)
+      if File.exist?(strings_path)
+        parsed = StringsParser.parse(strings_path)
+        text_array = parsed.find { |k, v| screenshot.path.upcase.include?(k.upcase) }
+        return text_array.last if text_array && text_array.last.length > 0 # Ignore empty string
+      end
+
+      UI.verbose("Falling back to text in Framefile.json as there was nothing specified in the #{type}.strings file")
+
+      # No string files, fallback to Framefile config
+      text = @config[type.to_s]['text'] if @config[type.to_s] && @config[type.to_s]['text'] && @config[type.to_s]['text'].length > 0 # Ignore empty string
+      return text
+    end
+
+    def fetch_frame_color
+      color = @config['frame']
+      unless color.nil?
+        Frameit::Color.constants.each do |c|
+          constant = Frameit::Color.const_get(c)
+          if color == constant.upcase.gsub(' ', '_')
+            return constant
+          end
+        end
+      end
+
+      return nil
+    end
+
+    # The font we want to use
+    def font(key)
+      single_font = @config[key.to_s]['font']
+      return single_font if single_font
+
+      fonts = @config[key.to_s]['fonts']
+      if fonts
+        fonts.each do |font|
+          if font['supported']
+            font['supported'].each do |language|
+              if screenshot.language == language
+                return font["font"]
+              end
+            end
+          else
+            # No `supported` array, this will always be true
+            UI.verbose("Found a font with no list of supported languages, using this now")
+            return font["font"]
+          end
+        end
+      end
+
+      UI.verbose("No custom font specified for #{screenshot}, using the default one")
+      return nil
+    end
+  end
+end