fastlane 2.142.0 → 2.143.0

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/match/lib/match/change_password.rb

@@ -45,7 +45,7 @@ module Match
     end
 
     # This method is called from both here, and from `openssl.rb`
-    def self.ask_password(message: "Passphrase for Git Repo: ", confirm: nil)
+    def self.ask_password(message: "Passphrase for Match storage: ", confirm: nil)
       ensure_ui_interactive
       loop do
         password = UI.password(message)

data/match/lib/match/encryption.rb

@@ -14,6 +14,10 @@ module Match
           },
           "google_cloud" => lambda { |params|
             return nil
+          },
+          "s3" => lambda { |params|
+            params[:keychain_name] = params[:s3_bucket]
+            return Encryption::OpenSSL.configure(params)
           }
         }
       end

data/match/lib/match/importer.rb

@@ -54,9 +54,9 @@ module Match
 
       case cert_type
       when :development
-        certificate_type = Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DEVELOPMENT
+        certificate_type = Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DEVELOPMENT + "," + Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPMENT
       when :distribution, :enterprise
-        certificate_type = Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DISTRIBUTION
+        certificate_type = Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DISTRIBUTION + "," + Spaceship::ConnectAPI::Certificate::CertificateType::DISTRIBUTION
       else
         UI.user_error!("Cert type '#{cert_type}' is not supported")
       end

data/match/lib/match/module.rb

@@ -13,7 +13,7 @@ module Match
   end
 
   def self.storage_modes
-    return %w(git google_cloud)
+    return %w(git google_cloud s3)
   end
 
   def self.profile_type_sym(type)

data/match/lib/match/nuke.rb

@@ -37,7 +37,11 @@ module Match
         clone_branch_directly: params[:clone_branch_directly],
         google_cloud_bucket_name: params[:google_cloud_bucket_name].to_s,
         google_cloud_keys_file: params[:google_cloud_keys_file].to_s,
-        google_cloud_project_id: params[:google_cloud_project_id].to_s
+        google_cloud_project_id: params[:google_cloud_project_id].to_s,
+        s3_region: params[:s3_region].to_s,
+        s3_access_key: params[:s3_access_key].to_s,
+        s3_secret_access_key: params[:s3_secret_access_key].to_s,
+        s3_bucket: params[:s3_bucket].to_s
       })
       self.storage.download
 

data/match/lib/match/options.rb

@@ -159,6 +159,24 @@ module Match
                                      description: "ID of the Google Cloud project to use for authentication",
                                      optional: true),
 
+        # Storage: S3
+        FastlaneCore::ConfigItem.new(key: :s3_region,
+                                     env_name: "MATCH_S3_REGION",
+                                     description: "Name of the S3 region",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :s3_access_key,
+                                     env_name: "MATCH_S3_ACCESS_KEY",
+                                     description: "S3 access key",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :s3_secret_access_key,
+                                     env_name: "MATCH_S3_SECRET_ACCESS_KEY",
+                                     description: "S3 secret secret access key",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :s3_bucket,
+                                     env_name: "MATCH_S3_BUCKET",
+                                     description: "Name of the S3 bucket",
+                                     optional: true),
+
         # Keychain
         FastlaneCore::ConfigItem.new(key: :keychain_name,
                                      short_option: "-s",

data/match/lib/match/runner.rb

@@ -46,6 +46,10 @@ module Match
         google_cloud_bucket_name: params[:google_cloud_bucket_name].to_s,
         google_cloud_keys_file: params[:google_cloud_keys_file].to_s,
         google_cloud_project_id: params[:google_cloud_project_id].to_s,
+        s3_region: params[:s3_region].to_s,
+        s3_access_key: params[:s3_access_key].to_s,
+        s3_secret_access_key: params[:s3_secret_access_key].to_s,
+        s3_bucket: params[:s3_bucket].to_s,
         readonly: params[:readonly],
         username: params[:readonly] ? nil : params[:username], # only pass username if not readonly
         team_id: params[:team_id],

data/match/lib/match/setup.rb

@@ -34,7 +34,7 @@ module Match
     end
 
     def storage_options
-      return ["git", "google_cloud"]
+      return ["git", "google_cloud", "s3"]
     end
   end
 end

data/match/lib/match/storage.rb

@@ -1,6 +1,7 @@
 require_relative 'storage/interface'
 require_relative 'storage/git_storage'
 require_relative 'storage/google_cloud_storage'
+require_relative 'storage/s3_storage'
 
 module Match
   module Storage
@@ -12,6 +13,9 @@ module Match
           },
           "google_cloud" => lambda { |params|
             return Storage::GoogleCloudStorage.configure(params)
+          },
+          "s3" => lambda { |params|
+            return Storage::S3Storage.configure(params)
           }
         }
       end

data/match/lib/match/storage/s3_storage.rb

@@ -0,0 +1,162 @@
+require 'fastlane_core/command_executor'
+require 'fastlane_core/configuration/configuration'
+require 'fastlane/helper/s3_client_helper'
+
+require_relative '../options'
+require_relative '../module'
+require_relative '../spaceship_ensure'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities on AWS S3
+    class S3Storage < Interface
+      attr_reader :s3_bucket
+      attr_reader :s3_region
+      attr_reader :s3_client
+      attr_reader :readonly
+      attr_reader :username
+      attr_reader :team_id
+      attr_reader :team_name
+
+      def self.configure(params)
+        s3_region = params[:s3_region]
+        s3_access_key = params[:s3_access_key]
+        s3_secret_access_key = params[:s3_secret_access_key]
+        s3_bucket = params[:s3_bucket]
+
+        if params[:git_url].to_s.length > 0
+          UI.important("Looks like you still define a `git_url` somewhere, even though")
+          UI.important("you use S3 Storage. You can remove the `git_url`")
+          UI.important("from your Matchfile and Fastfile")
+          UI.message("The above is just a warning, fastlane will continue as usual now...")
+        end
+
+        return self.new(
+          s3_region: s3_region,
+          s3_access_key: s3_access_key,
+          s3_secret_access_key: s3_secret_access_key,
+          s3_bucket: s3_bucket,
+          readonly: params[:readonly],
+          username: params[:username],
+          team_id: params[:team_id],
+          team_name: params[:team_name]
+        )
+      end
+
+      def initialize(s3_region: nil,
+                     s3_access_key: nil,
+                     s3_secret_access_key: nil,
+                     s3_bucket: nil,
+                     readonly: nil,
+                     username: nil,
+                     team_id: nil,
+                     team_name: nil)
+        @s3_bucket = s3_bucket
+        @s3_region = s3_region
+        @s3_client = Fastlane::Helper::S3ClientHelper.new(access_key: s3_access_key, secret_access_key: s3_secret_access_key, region: s3_region)
+        @readonly = readonly
+        @username = username
+        @team_id = team_id
+        @team_name = team_name
+      end
+
+      # To make debugging easier, we have a custom exception here
+      def prefixed_working_directory
+        # We fall back to "*", which means certificates and profiles
+        # from all teams that use this bucket would be installed. This is not ideal, but
+        # unless the user provides a `team_id`, we can't know which one to use
+        # This only happens if `readonly` is activated, and no `team_id` was provided
+        @_folder_prefix ||= currently_used_team_id
+        if @_folder_prefix.nil?
+          # We use a `@_folder_prefix` variable, to keep state between multiple calls of this
+          # method, as the value won't change. This way the warning is only printed once
+          UI.important("Looks like you run `match` in `readonly` mode, and didn't provide a `team_id`. This will still work, however it is recommended to provide a `team_id` in your Appfile or Matchfile")
+          @_folder_prefix = "*"
+        end
+        return File.join(working_directory, @_folder_prefix)
+      end
+
+      # Call this method for the initial clone/download of the
+      # user's certificates & profiles
+      # As part of this method, the `self.working_directory` attribute
+      # will be set
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory && Dir.exist?(@working_directory)
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        s3_client.find_bucket!(s3_bucket).objects.each do |object|
+          file_path = object.public_url.to_s.split("s3.amazonaws.com/").last
+          download_path = File.join(self.working_directory, file_path)
+
+          FileUtils.mkdir_p(File.expand_path("..", download_path))
+          UI.verbose("Downloading file from S3 '#{file_path}' on bucket #{self.s3_bucket}")
+
+          object.download_file(download_path)
+        end
+        UI.verbose("Successfully downloaded files from S3 to #{self.working_directory}")
+      end
+
+      # Returns a short string describing + identifing the current
+      # storage backend. This will be printed when nuking a storage
+      def human_readable_description
+        return "S3 Bucket [#{s3_bucket}] on region #{s3_region}"
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        # `files_to_upload` is an array of files that need to be uploaded to S3
+        # Those doesn't mean they're new, it might just be they're changed
+        # Either way, we'll upload them using the same technique
+
+        files_to_upload.each do |current_file|
+          # Go from
+          #   "/var/folders/px/bz2kts9n69g8crgv4jpjh6b40000gn/T/d20181026-96528-1av4gge/profiles/development/Development_me.mobileprovision"
+          # to
+          #   "profiles/development/Development_me.mobileprovision"
+          #
+
+          target_path = current_file.gsub(self.working_directory + "/", "")
+          UI.verbose("Uploading '#{target_path}' to S3 Storage...")
+
+          body = File.read(current_file)
+          acl = 'private'
+          s3_url = s3_client.upload_file(s3_bucket, target_path, body, acl)
+          UI.verbose("Uploaded '#{s3_url}' to S3 Storage.")
+        end
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        files_to_delete.each do |file_name|
+          s3_client.delete_file(s3_bucket, file_name)
+        end
+      end
+
+      def skip_docs
+        false
+      end
+
+      # Implement this for the `fastlane match init` command
+      # This method must return the content of the Matchfile
+      # that should be generated
+      def generate_matchfile_content(template: nil)
+        return "s3_bucket(\"#{self.s3_bucket}\")"
+      end
+
+      private
+
+      def currently_used_team_id
+        if self.readonly
+          # In readonly mode, we still want to see if the user provided a team_id
+          # see `prefixed_working_directory` comments for more details
+          return self.team_id
+        else
+          spaceship = SpaceshipEnsure.new(self.username, self.team_id, self.team_name)
+          return spaceship.team_id
+        end
+      end
+    end
+  end
+end