fastlane 2.139.0 → 2.144.0

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

data/frameit/lib/frameit/runner.rb

@@ -14,9 +14,8 @@ module Frameit
       end
     end
 
-    def run(path, color = nil)
+    def run(path, color = nil, platform = nil)
       unless color
-        color = Frameit::Color::BLACK
         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]
@@ -29,11 +28,12 @@ module Frameit
           next if skip_path?(full_path)
 
           begin
-            screenshot = Screenshot.new(full_path, color)
+            config = create_config(full_path)
+            screenshot = Screenshot.new(full_path, color, config, platform)
 
             next if skip_up_to_date?(screenshot)
 
-            editor = editor(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.")
@@ -71,12 +71,22 @@ module Frameit
       false
     end
 
-    def editor(screenshot)
+    def editor(screenshot, config)
       if screenshot.mac?
-        return MacEditor.new(screenshot)
+        return MacEditor.new(screenshot, config)
       else
-        return Editor.new(screenshot, Frameit.config[:debug_mode])
+        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)
+      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
+      file.fetch_value(screenshot_path)
+    end
   end
 end

data/frameit/lib/frameit/screenshot.rb

@@ -1,87 +1,75 @@
-require 'deliver/app_screenshot'
-
 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 :screen_size # deliver screen size type, is unique per device type, used in device_name
+    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)
+    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)
 
-      @screen_size = ENV["FRAMEIT_FORCE_DEVICE_TYPE"] || Deliver::AppScreenshot.calculate_screen_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]
+      #   - 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
-      # rubocop:disable Require/MissingRequireStatement
-      sizes = Deliver::AppScreenshot::ScreenSize
-      case @screen_size
-      when sizes::IOS_65
-        return 'iPhone XS Max'
-      when sizes::IOS_61
-        return 'iPhone XR'
-      when sizes::IOS_58
-        return Frameit.config[:use_legacy_iphonex] ? 'iPhone X' : 'iPhone XS'
-      when sizes::IOS_55
-        return Frameit.config[:use_legacy_iphone6s] ? 'iPhone 6s Plus' : 'iPhone 7 Plus'
-      when sizes::IOS_47
-        return Frameit.config[:use_legacy_iphone6s] ? 'iPhone 6s' : 'iPhone 7'
-      when sizes::IOS_40
-        return Frameit.config[:use_legacy_iphone5s] ? 'iPhone 5s' : 'iPhone SE'
-      when sizes::IOS_35
-        return 'iPhone 4'
-      when sizes::IOS_IPAD
-        return 'iPad Air 2'
-      when sizes::IOS_IPAD_10_5
-        return 'iPad Pro (10.5-inch)'
-      when sizes::IOS_IPAD_11
-        return 'iPad Pro (11-inch)'
-      when sizes::IOS_IPAD_PRO
-        return 'iPad Pro'
-      when sizes::IOS_IPAD_PRO_12_9
-        return 'iPad Pro (12.9-inch) (3rd generation)'
-      when sizes::MAC
-        return 'MacBook'
-      else
-        UI.error("Unknown device type for size #{@screen_size} for path '#{path}'")
-      end
+      @device.formatted_name
       # rubocop:enable Require/MissingRequireStatement
     end
 
-    def color
-      if !Frameit.config[:use_legacy_iphone6s] && @color == Frameit::Color::BLACK
-        if @screen_size == Deliver::AppScreenshot::ScreenSize::IOS_55 || @screen_size == Deliver::AppScreenshot::ScreenSize::IOS_47
-          return "Matte Black" # RIP space gray
-        end
-      end
-      return @color
+    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?
-      (screen_size == Deliver::AppScreenshot::ScreenSize::IOS_55 || screen_size == Deliver::AppScreenshot::ScreenSize::IOS_58 || screen_size == Deliver::AppScreenshot::ScreenSize::IOS_65)
+      !device.density_ppi.nil? && device.density_ppi > 400
     end
 
     # Super old devices (iPhone 4)
     def mini?
-      (screen_size == Deliver::AppScreenshot::ScreenSize::IOS_35)
+      !device.density_ppi.nil? && device.density_ppi < 300
     end
 
     def mac?
-      return device_name == 'MacBook'
+      device_name == 'MacBook'
     end
 
     # The name of the orientation of a screenshot. Used to find the correct template

data/frameit/lib/frameit/template_finder.rb

@@ -1,5 +1,4 @@
 require 'deliver/app_screenshot'
-
 require_relative 'module'
 require_relative 'device_types'
 require_relative 'frame_downloader'
@@ -11,32 +10,36 @@ module Frameit
     def self.get_template(screenshot)
       return nil if screenshot.mac?
 
-      filename = "Apple #{screenshot.device_name} #{screenshot.color}"
-
+      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.screen_size == Deliver::AppScreenshot::ScreenSize::IOS_35
+        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'")
-        elsif screenshot.color == Frameit::Color::ROSE_GOLD || screenshot.color == Frameit::Color::GOLD
-          # Unfortunately not every device type is available in rose gold or gold
-          # This is why we can't have nice things #yatusabes
-          # fallback to a white iPhone, which looks similar
-          UI.important("Unfortunately device type '#{screenshot.device_name}' is not available in #{screenshot.color}, falling back to silver...")
-          screenshot.color = Frameit::Color::SILVER
-          return self.get_template(screenshot)
         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 filename if Helper.test?
         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/gym/lib/gym/code_signing_mapping.rb

@@ -88,6 +88,13 @@ module Gym
       when "tvOS"
         destination_sdkroot = ["appletvos"]
       end
+
+      # Catalyst projects will always have an "iphoneos" sdkroot
+      # Need to force a same platform when trying to build as macos
+      if Gym.building_mac_catalyst_for_mac?
+        return true
+      end
+
       return destination_sdkroot.include?(sdkroot)
     end
 
@@ -134,10 +141,31 @@ module Gym
               next unless same_platform?(sdkroot)
               next unless specified_configuration == build_configuration.name
 
-              bundle_identifier = build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER", target)
+              # Catalyst apps will have some build settings that will have a configuration
+              # that is specfic for macos so going to do our best to capture those
+              #
+              # There are other platform filters besides "[sdk=macosx*]" that we could use but
+              # this is the default that Xcode will use so this will also be our default
+              sdk_specifier = Gym.building_mac_catalyst_for_mac? ? "[sdk=macosx*]" : ""
+
+              # Look for sdk specific bundle identifier (if set) and fallback to general configuration if none
+              bundle_identifier = build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER#{sdk_specifier}", target)
+              bundle_identifier ||= build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER", target)
               next unless bundle_identifier
-              provisioning_profile_specifier = build_configuration.resolve_build_setting("PROVISIONING_PROFILE_SPECIFIER", target)
-              provisioning_profile_uuid = build_configuration.resolve_build_setting("PROVISIONING_PROFILE", target)
+
+              # Xcode prefixes "maccatalyst." if building a Catalyst app for mac and
+              # if DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER is set to YES
+              if Gym.building_mac_catalyst_for_mac? && build_configuration.resolve_build_setting("DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER", target) == "YES"
+                bundle_identifier = "maccatalyst.#{bundle_identifier}"
+              end
+
+              # Look for sdk specific provisioning profile specifier (if set) and fallback to general configuration if none
+              provisioning_profile_specifier = build_configuration.resolve_build_setting("PROVISIONING_PROFILE_SPECIFIER#{sdk_specifier}", target)
+              provisioning_profile_specifier ||= build_configuration.resolve_build_setting("PROVISIONING_PROFILE_SPECIFIER", target)
+
+              # Look for sdk specific provisioning profile uuid (if set) and fallback to general configuration if none
+              provisioning_profile_uuid = build_configuration.resolve_build_setting("PROVISIONING_PROFILE#{sdk_specifier}", target)
+              provisioning_profile_uuid ||= build_configuration.resolve_build_setting("PROVISIONING_PROFILE", target)
 
               has_profile_specifier = provisioning_profile_specifier.to_s.length > 0
               has_profile_uuid = provisioning_profile_uuid.to_s.length > 0
@@ -177,5 +205,6 @@ module Gym
 
       return provisioning_profile_mapping
     end
+    # rubocop:enable Metrics/PerceivedComplexity
   end
 end