fastlane_pricing_fix 2.212.1

data/deliver/lib/deliver/commands_generator.rb

@@ -0,0 +1,191 @@
+require 'commander'
+require 'fastlane/version'
+require 'fastlane_core/ui/help_formatter'
+
+require_relative 'download_screenshots'
+require_relative 'options'
+require_relative 'module'
+require_relative 'generate_summary'
+require_relative 'runner'
+
+HighLine.track_eof = false
+
+module Deliver
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def deliverfile_options(skip_verification: false)
+      available_options = Deliver::Options.available_options
+      return available_options unless skip_verification
+
+      # These don't matter for downloading metadata, so verification can be skipped
+      irrelevant_options_keys = [:ipa, :pkg, :app_rating_config_path]
+
+      available_options.each do |opt|
+        next unless irrelevant_options_keys.include?(opt.key)
+        opt.verify_block = nil
+        opt.conflicting_options = nil
+      end
+
+      return available_options
+    end
+
+    def self.force_overwrite_metadata?(options, path)
+      res = options[:force]
+      res ||= ENV["DELIVER_FORCE_OVERWRITE"] # for backward compatibility
+      res ||= UI.confirm("Do you want to overwrite existing metadata on path '#{File.expand_path(path)}'?") if UI.interactive?
+      res
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    def run
+      program :name, 'deliver'
+      program :version, Fastlane::VERSION
+      program :description, Deliver::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <deliver@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'Documentation', 'https://docs.fastlane.tools/actions/deliver/'
+      program :help_formatter, FastlaneCore::HelpFormatter
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+      global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+
+      always_trace!
+
+      command :run do |c|
+        c.syntax = 'fastlane deliver'
+        c.description = 'Upload metadata and binary to App Store Connect'
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          loaded = options.load_configuration_file("Deliverfile")
+
+          # Check if we already have a deliver setup in the current directory
+          loaded = true if options[:description] || options[:ipa] || options[:pkg]
+          loaded = true if File.exist?(File.join(FastlaneCore::FastlaneFolder.path || ".", "metadata"))
+          unless loaded
+            if UI.confirm("No deliver configuration found in the current directory. Do you want to setup deliver?")
+              is_swift = UI.confirm("Would you like to use Swift instead of Ruby?")
+              require 'deliver/setup'
+              Deliver::Runner.new(options) # to login...
+              Deliver::Setup.new.run(options, is_swift: is_swift)
+              return 0
+            end
+          end
+
+          Deliver::Runner.new(options).run
+        end
+      end
+
+      command :submit_build do |c|
+        c.syntax = 'fastlane deliver submit_build'
+        c.description = 'Submit a specific build-nr for review, use latest for the latest build'
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          options[:submit_for_review] = true
+          options[:build_number] = "latest" unless options[:build_number]
+          Deliver::Runner.new(options).run
+        end
+      end
+
+      command :init do |c|
+        c.syntax = 'fastlane deliver init'
+        c.description = 'Create the initial `deliver` configuration based on an existing app'
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          if File.exist?("Deliverfile") || File.exist?("fastlane/Deliverfile")
+            UI.important("You already have a running deliver setup in this directory")
+            return 0
+          end
+
+          require 'deliver/setup'
+
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          options[:run_precheck_before_submit] = false # precheck doesn't need to run during init
+
+          Deliver::Runner.new(options) # to login...
+          Deliver::Setup.new.run(options)
+        end
+      end
+
+      command :generate_summary do |c|
+        c.syntax = 'fastlane deliver generate_summary'
+        c.description = 'Generate HTML Summary without uploading/downloading anything'
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options, options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options)
+          html_path = Deliver::GenerateSummary.new.run(options)
+          UI.success("Successfully generated HTML report at '#{html_path}'")
+          system("open '#{html_path}'") unless options[:force]
+        end
+      end
+
+      command :download_screenshots do |c|
+        c.syntax = 'fastlane deliver download_screenshots'
+        c.description = "Downloads all existing screenshots from App Store Connect and stores them in the screenshots folder"
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options(skip_verification: true), options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options, skip_version: true) # to login...
+          containing = FastlaneCore::Helper.fastlane_enabled_folder_path
+          path = options[:screenshots_path] || File.join(containing, 'screenshots')
+          Deliver::DownloadScreenshots.run(options, path)
+        end
+      end
+
+      command :download_metadata do |c|
+        c.syntax = 'fastlane deliver download_metadata'
+        c.description = "Downloads existing metadata and stores it locally. This overwrites the local files."
+
+        FastlaneCore::CommanderGenerator.new.generate(deliverfile_options, command: c)
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(deliverfile_options(skip_verification: true), options.__hash__)
+          options.load_configuration_file("Deliverfile")
+          Deliver::Runner.new(options) # to login...
+          containing = FastlaneCore::Helper.fastlane_enabled_folder_path
+          path = options[:metadata_path] || File.join(containing, 'metadata')
+          res = Deliver::CommandsGenerator.force_overwrite_metadata?(options, path)
+          return 0 unless res
+
+          require 'deliver/setup'
+          app = Deliver.cache[:app]
+          platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+          v = app.get_latest_app_store_version(platform: platform)
+          if options[:app_version].to_s.length > 0
+            v = app.get_live_app_store_version(platform: platform) if v.version_string != options[:app_version]
+            if v.nil? || v.version_string != options[:app_version]
+              raise "Neither the current nor live version match specified app_version \"#{options[:app_version]}\""
+            end
+          end
+
+          Deliver::Setup.new.generate_metadata_files(app, v, path, options)
+        end
+      end
+
+      default_command(:run)
+
+      run!
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end

data/deliver/lib/deliver/detect_values.rb

@@ -0,0 +1,104 @@
+require 'fastlane_core/fastlane_folder'
+require 'fastlane_core/ipa_file_analyser'
+require 'fastlane_core/pkg_file_analyser'
+require 'spaceship/tunes/tunes'
+require 'spaceship/tunes/application'
+
+require_relative 'module'
+require_relative 'languages'
+
+module Deliver
+  class DetectValues
+    def run!(options, skip_params = {})
+      Deliver.cache = {}
+
+      find_platform(options)
+      find_app_identifier(options)
+      find_app(options)
+      find_folders(options)
+      ensure_folders_created(options)
+      find_version(options) unless skip_params[:skip_version]
+
+      verify_languages!(options)
+    end
+
+    def find_app_identifier(options)
+      return if options[:app_identifier]
+
+      if options[:ipa]
+        identifier = FastlaneCore::IpaFileAnalyser.fetch_app_identifier(options[:ipa])
+      elsif options[:pkg]
+        identifier = FastlaneCore::PkgFileAnalyser.fetch_app_identifier(options[:pkg])
+      end
+
+      options[:app_identifier] = identifier if identifier.to_s.length > 0
+      options[:app_identifier] ||= UI.input("The Bundle Identifier of your App: ")
+    rescue => ex
+      UI.error("#{ex.message}\n#{ex.backtrace.join('\n')}")
+      UI.user_error!("Could not infer your App's Bundle Identifier")
+    end
+
+    def find_app(options)
+      app_identifier = options[:app_identifier]
+      app_id = options[:app] if app_identifier.to_s.empty?
+
+      if !app_identifier.to_s.empty?
+        app = Spaceship::ConnectAPI::App.find(app_identifier)
+      elsif !app_id.kind_of?(Spaceship::ConnectAPI::App) && !app_id.to_s.empty?
+        app = Spaceship::ConnectAPI::App.get(app_id: app_id)
+      end
+
+      Deliver.cache[:app] = app
+
+      unless app
+        UI.user_error!("Could not find app with app identifier '#{options[:app_identifier]}' in your App Store Connect account (#{options[:username]} - Team: #{Spaceship::Tunes.client.team_id})")
+      end
+    end
+
+    def find_folders(options)
+      containing = Helper.fastlane_enabled? ? FastlaneCore::FastlaneFolder.path : '.'
+      options[:screenshots_path] ||= File.join(containing, 'screenshots')
+      options[:metadata_path] ||= File.join(containing, 'metadata')
+    end
+
+    def ensure_folders_created(options)
+      FileUtils.mkdir_p(options[:screenshots_path])
+      FileUtils.mkdir_p(options[:metadata_path])
+    end
+
+    def find_version(options)
+      return if options[:app_version]
+
+      if options[:ipa]
+        options[:app_version] ||= FastlaneCore::IpaFileAnalyser.fetch_app_version(options[:ipa])
+      elsif options[:pkg]
+        options[:app_version] ||= FastlaneCore::PkgFileAnalyser.fetch_app_version(options[:pkg])
+      end
+    rescue => ex
+      UI.error("#{ex.message}\n#{ex.backtrace.join('\n')}")
+      UI.user_error!("Could not infer your app's version")
+    end
+
+    def find_platform(options)
+      if options[:ipa]
+        options[:platform] ||= FastlaneCore::IpaFileAnalyser.fetch_app_platform(options[:ipa])
+      elsif options[:pkg]
+        options[:platform] = 'osx'
+      end
+    end
+
+    def verify_languages!(options)
+      languages = options[:languages]
+      return unless languages
+
+      # 2020-08-24 - Available locales are not available as an endpoint in App Store Connect
+      # Update with Spaceship::Tunes.client.available_languages.sort (as long as endpoint is avilable)
+      all_languages = Deliver::Languages::ALL_LANGUAGES
+      diff = languages - all_languages
+
+      unless diff.empty?
+        UI.user_error!("The following languages are invalid and cannot be activated: #{diff.join(',')}\n\nValid languages are: #{all_languages}")
+      end
+    end
+  end
+end

data/deliver/lib/deliver/download_screenshots.rb

@@ -0,0 +1,75 @@
+require_relative 'module'
+require 'spaceship'
+
+module Deliver
+  class DownloadScreenshots
+    def self.run(options, path)
+      UI.message("Downloading all existing screenshots...")
+      download(options, path)
+      UI.success("Successfully downloaded all existing screenshots")
+    rescue => ex
+      UI.error(ex)
+      UI.error("Couldn't download already existing screenshots from App Store Connect.")
+    end
+
+    def self.download(options, folder_path)
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      if options[:use_live_version]
+        version = app.get_live_app_store_version(platform: platform)
+        UI.user_error!("Could not find a live version on App Store Connect. Try using '--use_live_version false'") if version.nil?
+      else
+        version = app.get_edit_app_store_version(platform: platform)
+        UI.user_error!("Could not find an edit version on App Store Connect. Try using '--use_live_version true'") if version.nil?
+      end
+
+      localizations = version.get_app_store_version_localizations
+      threads = []
+      localizations.each do |localization|
+        threads << Thread.new do
+          download_screenshots(folder_path, localization)
+        end
+      end
+      threads.each(&:join)
+    end
+
+    def self.download_screenshots(folder_path, localization)
+      language = localization.locale
+      screenshot_sets = localization.get_app_screenshot_sets
+      screenshot_sets.each do |screenshot_set|
+        screenshot_set.app_screenshots.each_with_index do |screenshot, index|
+          file_name = [index, screenshot_set.screenshot_display_type, index].join("_")
+          original_file_extension = File.extname(screenshot.file_name).strip.downcase[1..-1]
+          file_name += "." + original_file_extension
+
+          url = screenshot.image_asset_url(type: original_file_extension)
+          next if url.nil?
+
+          UI.message("Downloading existing screenshot '#{file_name}' for language '#{language}'")
+
+          # If the screen shot is for an appleTV we need to store it in a way that we'll know it's an appleTV
+          # screen shot later as the screen size is the same as an iPhone 6 Plus in landscape.
+          if screenshot_set.apple_tv?
+            containing_folder = File.join(folder_path, "appleTV", language)
+          else
+            containing_folder = File.join(folder_path, language)
+          end
+
+          if screenshot_set.imessage?
+            containing_folder = File.join(folder_path, "iMessage", language)
+          end
+
+          begin
+            FileUtils.mkdir_p(containing_folder)
+          rescue
+            # if it's already there
+          end
+
+          path = File.join(containing_folder, file_name)
+          File.binwrite(path, FastlaneCore::Helper.open_uri(url).read)
+        end
+      end
+    end
+  end
+end

data/deliver/lib/deliver/generate_summary.rb

@@ -0,0 +1,13 @@
+require_relative 'upload_metadata'
+require_relative 'html_generator'
+require_relative 'upload_screenshots'
+
+module Deliver
+  class GenerateSummary
+    def run(options)
+      screenshots = UploadScreenshots.new.collect_screenshots(options)
+      UploadMetadata.new.load_from_filesystem(options)
+      HtmlGenerator.new.render(options, screenshots, '.')
+    end
+  end
+end

data/deliver/lib/deliver/html_generator.rb

@@ -0,0 +1,78 @@
+require 'spaceship'
+
+require_relative 'module'
+
+module Deliver
+  class HtmlGenerator
+    # Splits keywords supporting:
+    # * separated by commas (with optional whitespace)
+    # * separated by newlines
+    KEYWORD_SPLITTER = /(?:,\s?|\r?\n)/
+
+    def run(options, screenshots)
+      begin
+        # Use fastlane folder or default to current directory
+        fastlane_path = FastlaneCore::FastlaneFolder.path || "."
+        html_path = self.render(options, screenshots, fastlane_path)
+      rescue => ex
+        UI.error(ex.inspect)
+        UI.error(ex.backtrace.join("\n"))
+        okay = UI.input("Could not render HTML preview. Do you still want to continue?")
+        return if okay
+        UI.crash!("Could not render HTML page")
+      end
+      UI.important("Verifying the upload via the HTML file can be disabled by either adding")
+      UI.important("`force true` to your Deliverfile or using `fastlane deliver --force`")
+
+      system("open '#{html_path}'")
+      okay = UI.confirm("Does the Preview on path '#{html_path}' look okay for you?")
+
+      if okay
+        UI.success("HTML file confirmed...") # print this to give feedback to the user immediately
+      else
+        UI.user_error!("Did not upload the metadata, because the HTML file was rejected by the user")
+      end
+    end
+
+    # Returns a path relative to FastlaneFolder.path
+    # This is needed as the Preview.html file is located inside FastlaneFolder.path
+    def render_relative_path(export_path, path)
+      export_path = Pathname.new(File.expand_path(export_path))
+      path = Pathname.new(File.expand_path(path)).relative_path_from(export_path)
+      return path.to_path
+    end
+
+    # Renders all data available to quickly see if everything was correctly generated.
+    # @param export_path (String) The path to a folder where the resulting HTML file should be stored.
+    def render(options, screenshots, export_path = nil)
+      @screenshots = screenshots || []
+      @options = options
+      @export_path = export_path
+
+      @app_name = (options[:name]['en-US'] || options[:name].values.first) if options[:name]
+      @app_name ||= Deliver.cache[:app].name
+
+      @languages = options[:description].keys if options[:description]
+      @languages ||= begin
+        platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+        version = Deliver.cache[:app].get_edit_app_store_version(platform: platform)
+
+        version.get_app_store_version_localizations.collect(&:locale)
+      end
+
+      html_path = File.join(Deliver::ROOT, "lib/assets/summary.html.erb")
+      html = ERB.new(File.read(html_path)).result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+      export_path = File.join(export_path, "Preview.html")
+      File.write(export_path, html)
+
+      return export_path
+    end
+
+    # Splits a string of keywords separated by comma or newlines into a presentable list
+    # @param keywords (String)
+    def split_keywords(keywords)
+      keywords.split(KEYWORD_SPLITTER)
+    end
+  end
+end

data/deliver/lib/deliver/languages.rb

@@ -0,0 +1,7 @@
+module Deliver
+  module Languages
+    # 2020-08-24 - Available locales are not available as an endpoint in App Store Connect
+    # Update with Spaceship::Tunes.client.available_languages.sort (as long as endpoint is avilable)
+    ALL_LANGUAGES = %w[ar-SA ca cs da de-DE el en-AU en-CA en-GB en-US es-ES es-MX fi fr-CA fr-FR he hi hr hu id it ja ko ms nl-NL no pl pt-BR pt-PT ro ru sk sv th tr uk vi zh-Hans zh-Hant]
+  end
+end

data/deliver/lib/deliver/loader.rb

@@ -0,0 +1,157 @@
+require_relative 'module'
+require_relative 'app_screenshot'
+require_relative 'app_screenshot_validator'
+require_relative 'upload_metadata'
+require_relative 'languages'
+
+module Deliver
+  module Loader
+    # The directory 'appleTV' and `iMessage` are special folders that will cause our screenshot gathering code to iterate
+    # through it as well searching for language folders.
+    APPLE_TV_DIR_NAME = "appleTV".freeze
+    IMESSAGE_DIR_NAME = "iMessage".freeze
+    DEFAULT_DIR_NAME = "default".freeze
+
+    EXPANDABLE_DIR_NAMES = [APPLE_TV_DIR_NAME, IMESSAGE_DIR_NAME].freeze
+    SPECIAL_DIR_NAMES = [APPLE_TV_DIR_NAME, IMESSAGE_DIR_NAME, DEFAULT_DIR_NAME].freeze
+
+    # Some exception directories may exist from other actions that should not be iterated through
+    SUPPLY_DIR_NAME = "android".freeze
+    FRAMEIT_FONTS_DIR_NAME = "fonts".freeze
+    META_DIR_NAMES = UploadMetadata::ALL_META_SUB_DIRS.map(&:downcase)
+
+    EXCEPTION_DIRECTORIES = (META_DIR_NAMES << SUPPLY_DIR_NAME << FRAMEIT_FONTS_DIR_NAME).freeze
+
+    # A class that represents language folder under screenshots or metadata folder
+    class LanguageFolder
+      attr_reader :path
+
+      # @return [String] A normalized language name that corresponds to the directory's name
+      attr_reader :language
+
+      def self.available_languages
+        # 2020-08-24 - Available locales are not available as an endpoint in App Store Connect
+        # Update with Spaceship::Tunes.client.available_languages.sort (as long as endpoint is avilable)
+        Deliver::Languages::ALL_LANGUAGES
+      end
+
+      def self.allowed_directory_names_with_case
+        available_languages + SPECIAL_DIR_NAMES
+      end
+
+      # @param path [String] A directory path otherwise this initializer fails
+      # @param nested [Boolan] Whether given path is nested of another special directory.
+      #  This affects `expandable?` to return `false` when this set to `true`.
+      def initialize(path, nested: false)
+        raise(ArgumentError, "Given path must be a directory path - #{path}") unless File.directory?(path)
+        @path = path
+        @language = self.class.available_languages.find { |lang| basename.casecmp?(lang) }
+        @nested = nested
+      end
+
+      def nested?
+        @nested
+      end
+
+      def valid?
+        self.class.allowed_directory_names_with_case.any? { |name| name.casecmp?(basename) }
+      end
+
+      def expandable?
+        !nested? && EXPANDABLE_DIR_NAMES.any? { |name| name.casecmp?(basename) }
+      end
+
+      def skip?
+        EXCEPTION_DIRECTORIES.map(&:downcase).include?(basename.downcase)
+      end
+
+      def file_paths(extensions = '{png,jpg,jpeg}')
+        Dir.glob(File.join(path, "*.#{extensions}"), File::FNM_CASEFOLD).sort
+      end
+
+      def framed_file_paths(extensions = '{png,jpg,jpeg}')
+        Dir.glob(File.join(path, "*_framed.#{extensions}"), File::FNM_CASEFOLD).sort
+      end
+
+      def basename
+        File.basename(@path)
+      end
+    end
+
+    # Returns the list of valid app screenshot. When detecting invalid screenshots, this will cause an error.
+    #
+    # @param root [String] A directory path
+    # @param ignore_validation [String] Set false not to raise the error when finding invalid folder name
+    # @return [Array<Deliver::AppScreenshot>] The list of AppScreenshot that exist under given `root` directory
+    def self.load_app_screenshots(root, ignore_validation)
+      screenshots = language_folders(root, ignore_validation, true).flat_map do |language_folder|
+        paths = if language_folder.framed_file_paths.count > 0
+                  UI.important("Framed screenshots are detected! 🖼 Non-framed screenshot files may be skipped. 🏃")
+                  # watchOS screenshots can be picked up even when framed ones were found since frameit doesn't support watchOS screenshots
+                  framed_or_watch, skipped = language_folder.file_paths.partition { |path| path.downcase.include?('framed') || path.downcase.include?('watch') }
+                  skipped.each { |path| UI.important("🏃 Skipping screenshot file: #{path}") }
+                  framed_or_watch
+                else
+                  language_folder.file_paths
+                end
+        paths.map { |path| AppScreenshot.new(path, language_folder.language) }
+      end
+
+      errors = []
+      valid_screenshots = screenshots.select { |screenshot| Deliver::AppScreenshotValidator.validate(screenshot, errors) }
+
+      errors_to_skip, errors_to_crash = errors.partition(&:to_skip)
+
+      unless errors_to_skip.empty?
+        UI.important("🏃 Screenshots to be skipped are detected!")
+        errors_to_skip.each { |error| UI.message(error) }
+      end
+
+      unless errors_to_crash.empty?
+        UI.important("🚫 Invalid screenshots were detected! Here are the reasons:")
+        errors_to_crash.each { |error| UI.error(error) }
+        UI.user_error!("Canceled uploading screenshots. Please check the error messages above and fix the screenshots.")
+      end
+
+      valid_screenshots
+    end
+
+    # Returns the list of language folders
+    #
+    # @param roort [String] A directory path to get the list of language folders
+    # @param ignore_validation [Boolean] Set false not to raise the error when finding invalid folder name
+    # @param expand_sub_folders [Boolean] Set true to expand special folders; such as "iMessage" to nested language folders
+    # @return [Array<LanguageFolder>] The list of LanguageFolder whose each of them
+    def self.language_folders(root, ignore_validation, expand_sub_folders = false)
+      folders = Dir.glob(File.join(root, '*'))
+                   .select { |path| File.directory?(path) }
+                   .map { |path| LanguageFolder.new(path, nested: false) }
+                   .reject(&:skip?)
+
+      selected_folders, rejected_folders = folders.partition(&:valid?)
+
+      if !ignore_validation && !rejected_folders.empty?
+        rejected_folders = rejected_folders.map(&:basename)
+        UI.user_error!("Unsupported directory name(s) for screenshots/metadata in '#{root}': #{rejected_folders.join(', ')}" \
+                       "\nValid directory names are: #{LanguageFolder.allowed_directory_names_with_case}" \
+                       "\n\nEnable 'ignore_language_directory_validation' to prevent this validation from happening")
+      end
+
+      # Expand selected_folders for the special directories
+      if expand_sub_folders
+        selected_folders = selected_folders.flat_map do |folder|
+          if folder.expandable?
+            Dir.glob(File.join(folder.path, '*'))
+               .select { |p| File.directory?(p) }
+               .map { |p| LanguageFolder.new(p, nested: true) }
+               .select(&:valid?)
+          else
+            folder
+          end
+        end
+      end
+
+      selected_folders
+    end
+  end
+end

data/deliver/lib/deliver/module.rb

@@ -0,0 +1,24 @@
+require 'fastlane_core/helper'
+require 'fastlane_core/ui/ui'
+require 'fastlane/boolean'
+
+module Deliver
+  class << self
+    attr_accessor :cache
+
+    def cache
+      @cache ||= {}
+      @cache
+    end
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
+
+  # Constant that captures the root Pathname for the project. Should be used for building paths to assets or other
+  # resources that code needs to locate locally
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  DESCRIPTION = 'Upload screenshots, metadata and your app to the App Store using a single command'
+end