fastlane_iac_publish 0.1.0

data/frameit/lib/frameit/frame_downloader.rb

@@ -0,0 +1,85 @@
+require 'fastlane_core/module'
+
+require_relative 'module'
+
+module Frameit
+  class FrameDownloader
+    HOST_URL = "https://fastlane.github.io/frameit-frames"
+
+    def download_frames
+      print_disclaimer
+
+      require 'json'
+      require 'fileutils'
+
+      UI.message("Downloading device frames to '#{templates_path}'")
+      FileUtils.mkdir_p(templates_path)
+
+      frames_version = download_file("version.txt")
+      UI.important("Using frame version '#{frames_version}', you can optionally lock that version in your Framefile.json using `device_frame_version`")
+
+      files = JSON.parse(download_file("files.json"))
+      files.each_with_index do |current, index|
+        content = download_file(current, txt: "#{index + 1} of #{files.count} files")
+        File.binwrite(File.join(templates_path, current), content)
+      end
+      File.write(File.join(templates_path, "offsets.json"), download_file("offsets.json"))
+
+      # Write the version.txt at the very end to properly resume downloads
+      # if it's interrupted
+      File.write(File.join(templates_path, "version.txt"), frames_version)
+
+      UI.success("Successfully downloaded all required image assets")
+    end
+
+    def frames_exist?(version: "latest")
+      version_path = File.join(templates_path, "version.txt")
+      version = File.read(version_path) if File.exist?(version_path)
+      Dir["#{templates_path}/*.png"].count > 0 && version.to_i > 0
+    end
+
+    def self.templates_path
+      # Previously ~/.frameit/device_frames_2/x
+      legacy_path = File.join(ENV['HOME'], ".frameit/devices_frames_2", Frameit.frames_version)
+      return legacy_path if File.directory?(legacy_path)
+
+      # New path, being ~/.fastlane/frameit/x
+      return File.join(FastlaneCore.fastlane_user_dir, "frameit", Frameit.frames_version)
+    end
+
+    def templates_path
+      self.class.templates_path
+    end
+
+    def print_disclaimer
+      UI.header("Device frames disclaimer")
+      UI.important("All used device frames are available via Facebook Design: http://facebook.design/devices")
+      UI.message("----------------------------------------")
+      UI.message("While Facebook has redrawn and shares these assets for the benefit")
+      UI.message("of the design community, Facebook does not own any of the underlying")
+      UI.message("product or user interface designs.")
+      UI.message("By accessing these assets, you agree to obtain all necessary permissions")
+      UI.message("from the underlying rights holders and/or adhere to any applicable brand")
+      UI.message("use guidelines before using them.")
+      UI.message("Facebook disclaims all express or implied warranties with respect to these assets, including")
+      UI.message("non-infringement of intellectual property rights.")
+      UI.message("----------------------------------------")
+    end
+
+    private
+
+    def download_file(path, txt: "file")
+      require 'uri'
+      require 'excon'
+
+      url = File.join(HOST_URL, Frameit.frames_version, URI.escape(path))
+      UI.message("Downloading #{txt} from '#{url}' ...")
+      body = Excon.get(url).body
+      raise body if body.include?("<Error>")
+      return body
+    rescue => ex
+      UI.error(ex)
+      UI.user_error!("Error accessing URL '#{url}'")
+    end
+  end
+end

data/frameit/lib/frameit/mac_editor.rb

@@ -0,0 +1,35 @@
+require 'mini_magick'
+require_relative 'editor'
+
+module Frameit
+  # Responsible for framing Mac Screenshots
+  class MacEditor < Editor
+    def prepare_image
+      image = super
+      image.resize("#{offset['width']}x") if offset['width']
+    end
+
+    def put_device_into_background(background)
+      self.top_space_above_device = offset['titleHeight'] # needed for centering the title
+
+      @image = background.composite(image, "png") do |c|
+        c.compose("Over")
+        c.geometry(offset['offset'])
+      end
+
+      return image
+    end
+
+    def load_frame
+      nil # Macs don't need frames - backgrounds only
+    end
+
+    def is_complex_framing_mode?
+      true # Mac screenshots always need a background
+    end
+
+    def generate_background
+      MiniMagick::Image.open(fetch_config['background']) # no resizing on the Mac
+    end
+  end
+end

data/frameit/lib/frameit/module.rb

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

data/frameit/lib/frameit/offsets.rb

@@ -0,0 +1,21 @@
+require_relative 'module'
+require_relative 'frame_downloader'
+
+module Frameit
+  class Offsets
+    # Returns the image offset needed for a certain device type
+    def self.image_offset(screenshot)
+      require 'json'
+
+      unless @offsets_cache
+        offsets_json_path = File.join(FrameDownloader.new.templates_path, "offsets.json")
+        UI.user_error!("Could not find offsets.json file at path '#{offsets_json_path}'") unless File.exist?(offsets_json_path)
+        @offsets_cache = JSON.parse(File.read(offsets_json_path))
+      end
+
+      offset_value = @offsets_cache["portrait"][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
+  end
+end

data/frameit/lib/frameit/options.rb

@@ -0,0 +1,82 @@
+require 'fastlane_core/configuration/config_item'
+
+require_relative 'module'
+
+module Frameit
+  class Options
+    def self.available_options
+      @options ||= [
+
+        FastlaneCore::ConfigItem.new(key: :white,
+                                     env_name: "FRAMEIT_WHITE_FRAME",
+                                     description: "Use white device frames",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :silver,
+                                     env_name: "FRAMEIT_SILVER_FRAME",
+                                     description: "Use white device frames. Alias for :white",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :rose_gold,
+                                     env_name: "FRAMEIT_ROSE_GOLD_FRAME",
+                                     description: "Use rose gold device frames. Alias for :rose_gold",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :gold,
+                                     env_name: "FRAMEIT_GOLD_FRAME",
+                                     description: "Use gold device frames. Alias for :gold",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :force_device_type,
+                                     env_name: "FRAMEIT_FORCE_DEVICE_TYPE",
+                                     description: "Forces a given device type, useful for Mac screenshots, as their sizes vary",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       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),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphone5s,
+                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_5_S",
+                                     description: "Use iPhone 5s instead of iPhone SE frames",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_iphone6s,
+                                     env_name: "FRAMEIT_USE_LEGACY_IPHONE_6_S",
+                                     description: "Use iPhone 6s frames instead of iPhone 7 frames",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_legacy_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: :force_orientation_block,
+                                     type: :string_callback,
+                                     description: "[Advanced] A block to customize your screenshots' device orientation",
+                                     display_in_shell: false,
+                                     optional: true,
+                                     default_value: proc do |filename|
+                                       f = filename.downcase
+                                       if f.end_with?("force_landscapeleft")
+                                         :landscape_left
+                                       elsif f.end_with?("force_landscaperight")
+                                         :landscape_right
+                                       end
+                                     end,
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :debug_mode,
+                                     env_name: "FRAMEIT_DEBUG_MODE",
+                                     description: "Output debug information in framed screenshots",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :resume,
+                                     env_name: "FRAMEIT_RESUME",
+                                     description: "Resume frameit instead of reprocessing all screenshots",
+                                     default_value: false,
+                                     type: Boolean)
+      ]
+    end
+  end
+end

data/frameit/lib/frameit/runner.rb

@@ -0,0 +1,82 @@
+require 'fastimage'
+
+require_relative 'frame_downloader'
+require_relative 'module'
+require_relative 'screenshot'
+require_relative 'device_types'
+
+module Frameit
+  class Runner
+    def initialize
+      downloader = FrameDownloader.new
+      unless downloader.frames_exist?
+        downloader.download_frames
+      end
+    end
+
+    def run(path, color = nil)
+      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]
+      end
+
+      screenshots = Dir.glob("#{path}/**/*.{png,PNG}").uniq # uniq because thanks to {png,PNG} there are duplicates
+
+      if screenshots.count > 0
+        screenshots.each do |full_path|
+          next if skip_path?(full_path)
+
+          begin
+            screenshot = Screenshot.new(full_path, color)
+
+            next if skip_up_to_date?(screenshot)
+
+            editor = editor(screenshot)
+
+            if editor.should_skip?
+              UI.message("Skipping framing of screenshot #{screenshot.path}.  No title provided in your Framefile.json or title.strings.")
+            else
+              Helper.show_loading_indicator("Framing screenshot '#{full_path}'")
+              editor.frame!
+            end
+          rescue => ex
+            UI.error(ex.to_s)
+            UI.error("Backtrace:\n\t#{ex.backtrace.join("\n\t")}") if FastlaneCore::Globals.verbose?
+          end
+        end
+      else
+        UI.error("Could not find screenshots in current directory: '#{File.expand_path(path)}'")
+      end
+    end
+
+    def skip_path?(path)
+      return true if path.include?("_framed.png")
+      return true if path.include?(".itmsp/") # a package file, we don't want to modify that
+      return true if path.include?("device_frames/") # these are the device frames the user is using
+      device = path.rpartition('/').last.partition('-').first # extract device name
+      if device.downcase.include?("watch")
+        UI.error("Apple Watch screenshots are not framed: '#{path}'")
+        return true # we don't care about watches right now
+      end
+      false
+    end
+
+    def skip_up_to_date?(screenshot)
+      if !screenshot.outdated? && Frameit.config[:resume]
+        UI.message("Skipping framing of screenshot #{screenshot.path} because its framed file seems up-to-date.")
+        return true
+      end
+      false
+    end
+
+    def editor(screenshot)
+      if screenshot.mac?
+        return MacEditor.new(screenshot)
+      else
+        return Editor.new(screenshot, Frameit.config[:debug_mode])
+      end
+    end
+  end
+end

data/frameit/lib/frameit/screenshot.rb

@@ -0,0 +1,137 @@
+require 'deliver/app_screenshot'
+
+require_relative 'editor'
+require_relative 'mac_editor'
+require_relative 'device_types'
+require_relative 'module'
+
+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 :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)
+      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)
+    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_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
+      # 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
+    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)
+    end
+
+    # Super old devices (iPhone 4)
+    def mini?
+      (screen_size == Deliver::AppScreenshot::ScreenSize::IOS_35)
+    end
+
+    def mac?
+      return device_name == 'MacBook'
+    end
+
+    # The name of the orientation of a screenshot. Used to find the correct template
+    def orientation_name
+      return Orientation::PORTRAIT if size[0] < size[1]
+      return Orientation::LANDSCAPE
+    end
+
+    def frame_orientation
+      filename = File.basename(self.path, ".*")
+      block = Frameit.config[:force_orientation_block]
+
+      unless block.nil?
+        orientation = block.call(filename)
+        valid = [:landscape_left, :landscape_right, :portrait, nil]
+        UI.user_error("orientation_block must return #{valid[0..-2].join(', ')} or nil") unless valid.include?(orientation)
+      end
+
+      puts("Forced orientation: #{orientation}") unless orientation.nil?
+
+      return orientation unless orientation.nil?
+      return :portrait if self.orientation_name == Orientation::PORTRAIT
+      return :landscape_right # Default landscape orientation
+    end
+
+    def portrait?
+      return (frame_orientation == :portrait)
+    end
+
+    def landscape_left?
+      return (frame_orientation == :landscape_left)
+    end
+
+    def landscape_right?
+      return (frame_orientation == :landscape_right)
+    end
+
+    def landscape?
+      return self.landscape_left? || self.landscape_right
+    end
+
+    def output_path
+      path.gsub('.png', '_framed.png').gsub('.PNG', '_framed.png')
+    end
+
+    # If the framed screenshot was generated *before* the screenshot file,
+    # then we must be outdated.
+    def outdated?
+      return true unless File.exist?(output_path)
+      return File.mtime(path) > File.mtime(output_path)
+    end
+
+    def to_s
+      self.path
+    end
+  end
+end