fastlane 2.142.0 → 2.143.0

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

@@ -1,18 +1,134 @@
+require_relative 'device'
+require_relative 'module'
+require 'deliver/app_screenshot'
+
 module Frameit
   module Color
-    BLACK = "Space Gray"
-    SILVER = "Silver"
+    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"
-    WHITE = "White"
-    CORAL = "Coral"
-    BLUE = "Blue"
+    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
+  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)
+    # 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

@@ -18,8 +18,9 @@ module Frameit
     attr_accessor :image # the current image used for editing
     attr_accessor :space_to_device
 
-    def initialize(screenshot, debug_mode = false)
+    def initialize(screenshot, config, debug_mode = false)
       @screenshot = screenshot
+      @config = config
       self.debug_mode = debug_mode
     end
 
@@ -121,7 +122,7 @@ module Frameit
     def offset
       return @offset_information if @offset_information
 
-      @offset_information = fetch_config['offset'] || Offsets.image_offset(screenshot).dup
+      @offset_information = @config['offset'] || Offsets.image_offset(screenshot).dup
 
       if @offset_information && (@offset_information['offset'] || @offset_information['offset'])
         return @offset_information
@@ -148,7 +149,7 @@ module Frameit
 
     # Do we add a background and title as well?
     def is_complex_framing_mode?
-      return (fetch_config['background'] and (fetch_config['title'] or fetch_config['keyword']))
+      return (@config['background'] and (@config['title'] or @config['keyword']))
     end
 
     # more complex mode: background, frame and title
@@ -157,8 +158,8 @@ module Frameit
 
       self.space_to_device = vertical_frame_padding
 
-      if fetch_config['title']
-        background = put_title_into_background(background, fetch_config['stack_title'])
+      if @config['title']
+        background = put_title_into_background(background, @config['stack_title'])
       end
 
       if self.frame # we have no frame on le mac
@@ -169,7 +170,7 @@ module Frameit
         frame_width = background.width - horizontal_frame_padding * 2
         frame_height = background.height - effective_text_height - vertical_frame_padding
 
-        if fetch_config['show_complete_frame']
+        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
@@ -191,7 +192,7 @@ module Frameit
 
     # Horizontal adding around the frames
     def horizontal_frame_padding
-      padding = fetch_config['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?('%')
@@ -201,7 +202,7 @@ module Frameit
 
     # Vertical adding around the frames
     def vertical_frame_padding
-      padding = fetch_config['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?('%')
@@ -212,7 +213,7 @@ module Frameit
     # Minimum height for the title
     def title_min_height
       @title_min_height ||= begin
-        height = fetch_config['title_min_height'] || 0
+        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
@@ -244,12 +245,12 @@ module Frameit
     end
 
     def title_below_image
-      @title_below_image ||= fetch_config['title_below_image']
+      @title_below_image ||= @config['title_below_image']
     end
 
     # Returns a correctly sized background image
     def generate_background
-      background = MiniMagick::Image.open(fetch_config['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
@@ -338,12 +339,12 @@ module Frameit
       sum_width = title.width
       sum_width += keyword.width + keyword_padding if keyword
 
-      title_below_image = fetch_config['title_below_image']
+      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 / actual_font_size # The fraction of the actual height of the images compared to the available space
+      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)
@@ -385,7 +386,7 @@ module Frameit
     end
 
     def actual_font_size
-      font_scale_factor = fetch_config['font_scale_factor'] || 0.1
+      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
@@ -420,7 +421,7 @@ module Frameit
         text.gsub!('\n', "\n")
         text.gsub!(/(?<!\\)(')/) { |s| "\\#{s}" } # escape unescaped apostrophes with a backslash
 
-        interline_spacing = fetch_config['interline_spacing']
+        interline_spacing = @config['interline_spacing']
 
         # Add the actual title
         text_image.combine_options do |i|
@@ -429,7 +430,7 @@ module Frameit
           i.pointsize(actual_font_size)
           i.draw("text 0,0 '#{text}'")
           i.interline_spacing(interline_spacing) if interline_spacing
-          i.fill(fetch_config[key.to_s]['color'])
+          i.fill(@config[key.to_s]['color'])
         end
 
         results[key] = text_image
@@ -491,18 +492,6 @@ module Frameit
       results
     end
 
-    # Loads the config (colors, background, texts, etc.)
-    # Don't use this method to access the actual text and use `fetch_texts` instead
-    def fetch_config
-      return @config if @config
-
-      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)
-      file = ConfigParser.new.load(config_path)
-      return {} unless file # no config file at all
-      @config = file.fetch_value(screenshot.path)
-    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)
@@ -518,20 +507,19 @@ module Frameit
       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 = fetch_config[type.to_s]['text'] if fetch_config[type.to_s] && fetch_config[type.to_s]['text'] && fetch_config[type.to_s]['text'].length > 0 # Ignore empty string
+      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 = fetch_config['frame']
-      if color == "BLACK"
-        return Frameit::Color::BLACK
-      elsif color == "WHITE"
-        return Frameit::Color::SILVER
-      elsif color == "GOLD"
-        return Frameit::Color::GOLD
-      elsif color == "ROSE_GOLD"
-        return Frameit::Color::ROSE_GOLD
+      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
@@ -539,10 +527,10 @@ module Frameit
 
     # The font we want to use
     def font(key)
-      single_font = fetch_config[key.to_s]['font']
+      single_font = @config[key.to_s]['font']
       return single_font if single_font
 
-      fonts = fetch_config[key.to_s]['fonts']
+      fonts = @config[key.to_s]['fonts']
       if fonts
         fonts.each do |font|
           if font['supported']

data/frameit/lib/frameit/offsets.rb

@@ -13,9 +13,16 @@ module Frameit
         @offsets_cache = JSON.parse(File.read(offsets_json_path))
       end
 
-      offset_value = @offsets_cache["portrait"][screenshot.device_name]
+      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

@@ -1,6 +1,8 @@
 require 'fastlane_core/configuration/config_item'
 
 require_relative 'module'
+require_relative 'config_parser'
+require_relative 'device_types'
 
 module Frameit
   class Options
@@ -8,74 +10,99 @@ module Frameit
       @options ||= [
 
         FastlaneCore::ConfigItem.new(key: :white,
-                                     env_name: "FRAMEIT_WHITE_FRAME",
-                                     description: "Use white device frames",
-                                     type: Boolean,
-                                     optional: true),
+                                       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),
+                                       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),
+                                       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),
+                                       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|
-                                       available = ['iPhone_6_Plus', 'iPhone_5s', 'iPhone_4', 'iPad_mini', 'Mac']
-                                       unless available.include?(value)
-                                         UI.user_error!("Invalid device type '#{value}'. Available values: #{available}")
-                                       end
-                                     end),
+                                       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",
+                                       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_iphone6s,
-                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_6_S",
-                                     description: "Use iPhone 6s frames instead of iPhone 7 frames",
+        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_iphonex,
-                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_X",
-                                     description: "Use iPhone X instead of iPhone XS frames",
+        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),
+                                       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),
+                                       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)
+                                       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 (IOS is default to ensure backward compatibility)",
+                                       optional: true,
+                                       default_value: Platform::IOS,
+                                       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