fastlane 1.111.0 → 2.0.1

data/supply/lib/supply/listing.rb

@@ -0,0 +1,32 @@
+module Supply
+  class Listing
+    attr_reader :language
+
+    attr_accessor :title
+    attr_accessor :short_description
+    attr_accessor :full_description
+    attr_accessor :video
+
+    # Initializes the listing to use the given api client, language, and fills it with the current listing if available
+    def initialize(google_api, language, source_listing = nil)
+      @google_api = google_api
+      @language = language
+
+      if source_listing # this might be nil, e.g. when creating a new locale
+        self.title = source_listing.title
+        self.short_description = source_listing.short_description
+        self.full_description = source_listing.full_description
+        self.video = source_listing.video
+      end
+    end
+
+    # Updates the listing in the current edit
+    def save
+      @google_api.update_listing_for_language(language: language,
+                                              title: title,
+                                              short_description: short_description,
+                                              full_description: full_description,
+                                              video: video)
+    end
+  end
+end

data/supply/lib/supply/options.rb

@@ -0,0 +1,135 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Supply
+  class Options
+    def self.available_options
+      valid_tracks = %w(production beta alpha rollout)
+      @options ||= [
+        FastlaneCore::ConfigItem.new(key: :package_name,
+                                     env_name: "SUPPLY_PACKAGE_NAME",
+                                     short_option: "-p",
+                                     description: "The package name of the Application to modify",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:package_name)),
+        FastlaneCore::ConfigItem.new(key: :track,
+                                     short_option: "-a",
+                                     env_name: "SUPPLY_TRACK",
+                                     description: "The Track to upload the Application to: #{valid_tracks.join(', ')}",
+                                     default_value: 'production',
+                                     verify_block: proc do |value|
+                                       available = valid_tracks
+                                       UI.user_error! "Invalid value '#{value}', must be #{available.join(', ')}" unless available.include? value
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :rollout,
+                                     short_option: "-r",
+                                     description: "The percentage of the user fraction when uploading to the rollout track",
+                                     default_value: '0.1',
+                                     verify_block: proc do |value|
+                                       min = 0.05
+                                       max = 0.5
+                                       UI.user_error! "Invalid value '#{value}', must be between #{min} and #{max}" unless value.to_f.between?(min, max)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :metadata_path,
+                                     env_name: "SUPPLY_METADATA_PATH",
+                                     short_option: "-m",
+                                     optional: true,
+                                     description: "Path to the directory containing the metadata files",
+                                     default_value: (Dir["./fastlane/metadata/android"] + Dir["./metadata"]).first),
+        FastlaneCore::ConfigItem.new(key: :key,
+                                     env_name: "SUPPLY_KEY",
+                                     short_option: "-k",
+                                     conflicting_options: [:json_key],
+                                     deprecated: 'Use --json_key instead',
+                                     description: "The p12 File used to authenticate with Google",
+                                     default_value: Dir["*.p12"].first || CredentialsManager::AppfileConfig.try_fetch_value(:keyfile),
+                                     verify_block: proc do |value|
+                                       UI.user_error! "Could not find p12 file at path '#{File.expand_path(value)}'" unless File.exist?(File.expand_path(value))
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :issuer,
+                                     env_name: "SUPPLY_ISSUER",
+                                     short_option: "-i",
+                                     conflicting_options: [:json_key],
+                                     deprecated: 'Use --json_key instead',
+                                     description: "The issuer of the p12 file (email address of the service account)",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:issuer),
+                                     verify_block: proc do |value|
+                                       UI.important("DEPRECATED --issuer OPTION. Use --json_key instead")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :json_key,
+                                     env_name: "SUPPLY_JSON_KEY",
+                                     short_option: "-j",
+                                     conflicting_options: [:issuer, :key],
+                                     optional: true, # this is shouldn't be optional but is until --key and --issuer are completely removed
+                                     description: "The service account json file used to authenticate with Google",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
+                                     verify_block: proc do |value|
+                                       UI.user_error! "Could not find service account json file at path '#{File.expand_path(value)}'" unless File.exist?(File.expand_path(value))
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :apk,
+                                     env_name: "SUPPLY_APK",
+                                     description: "Path to the APK file to upload",
+                                     short_option: "-b",
+                                     conflicting_options: [:apk_paths],
+                                     default_value: Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-Release.apk")].last,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error! "Could not find apk file at path '#{value}'" unless File.exist?(value)
+                                       UI.user_error! "apk file is not an apk" unless value.end_with?('.apk')
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :apk_paths,
+                                     env_name: "SUPPLY_APK_PATHS",
+                                     conflicting_options: [:apk],
+                                     optional: true,
+                                     type: Array,
+                                     description: "An array of paths to APK files to upload",
+                                     short_option: "-u",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not evaluate array from '#{value}'") unless value.kind_of?(Array)
+                                       value.each do |path|
+                                         UI.user_error! "Could not find apk file at path '#{path}'" unless File.exist?(path)
+                                         UI.user_error! "file at path '#{path}' is not an apk" unless path.end_with?('.apk')
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :skip_upload_apk,
+                                     env_name: "SUPPLY_SKIP_UPLOAD_APK",
+                                     optional: true,
+                                     description: "Whether to skip uploading APK",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_upload_metadata,
+                                     env_name: "SUPPLY_SKIP_UPLOAD_METADATA",
+                                     optional: true,
+                                     description: "Whether to skip uploading metadata",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_upload_images,
+                                     env_name: "SUPPLY_SKIP_UPLOAD_IMAGES",
+                                     optional: true,
+                                     description: "Whether to skip uploading images, screenshots not included",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_upload_screenshots,
+                                     env_name: "SUPPLY_SKIP_UPLOAD_SCREENSHOTS",
+                                     optional: true,
+                                     description: "Whether to skip uploading SCREENSHOTS",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :track_promote_to,
+                                     env_name: "SUPPLY_TRACK_PROMOTE_TO",
+                                     optional: true,
+                                     description: "The Track to promote to: #{valid_tracks.join(', ')}",
+                                     verify_block: proc do |value|
+                                       available = valid_tracks
+                                       UI.user_error! "Invalid value '#{value}', must be #{available.join(', ')}" unless available.include? value
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :validate_only,
+                                     env_name: "SUPPLY_VALIDATE_ONLY",
+                                     optional: true,
+                                     description: "Indicate that changes will only be validated with Google Play rather than actually published",
+                                     is_string: false,
+                                     default_value: false)
+
+      ]
+    end
+  end
+end

data/supply/lib/supply/setup.rb

@@ -0,0 +1,102 @@
+module Supply
+  class Setup
+    def perform_download
+      if File.exist?(metadata_path)
+        UI.important("Metadata already exists at path '#{metadata_path}'")
+        return
+      end
+
+      client.begin_edit(package_name: Supply.config[:package_name])
+
+      client.listings.each do |listing|
+        store_metadata(listing)
+        create_screenshots_folder(listing)
+        download_images(listing)
+      end
+
+      client.apks_version_codes.each do |apk_version_code|
+        client.apk_listings(apk_version_code).each do |apk_listing|
+          store_apk_listing(apk_listing)
+        end
+      end
+
+      client.abort_current_edit
+
+      UI.success("Successfully stored metadata in '#{metadata_path}'")
+    end
+
+    def store_metadata(listing)
+      containing = File.join(metadata_path, listing.language)
+      FileUtils.mkdir_p(containing)
+
+      Supply::AVAILABLE_METADATA_FIELDS.each do |key|
+        path = File.join(containing, "#{key}.txt")
+        UI.message("Writing to #{path}...")
+        File.open(path, 'w:UTF-8') { |file| file.write(listing.send(key)) }
+      end
+    end
+
+    def download_images(listing)
+      # We cannot download existing screenshots as they are compressed
+      # But we can at least download the images
+      require 'net/http'
+
+      IMAGES_TYPES.each do |image_type|
+        if ['featureGraphic'].include?(image_type)
+          # we don't get all files in full resolution :(
+          UI.message("Due to the limit of the Google Play API `supply` can't download your existing feature graphics...")
+          next
+        end
+
+        begin
+          UI.message("Downloading #{image_type} for #{listing.language}...")
+
+          url = client.fetch_images(image_type: image_type, language: listing.language).last
+          next unless url
+
+          path = File.join(metadata_path, listing.language, IMAGES_FOLDER_NAME, "#{image_type}.png")
+          File.write(path, Net::HTTP.get(URI.parse(url)))
+        rescue => ex
+          UI.error(ex.to_s)
+          UI.error("Error downloading '#{image_type}' for #{listing.language}...")
+        end
+      end
+    end
+
+    def create_screenshots_folder(listing)
+      containing = File.join(metadata_path, listing.language)
+
+      FileUtils.mkdir_p(File.join(containing, IMAGES_FOLDER_NAME))
+      Supply::SCREENSHOT_TYPES.each do |screenshot_type|
+        FileUtils.mkdir_p(File.join(containing, IMAGES_FOLDER_NAME, screenshot_type))
+      end
+
+      UI.message("Due to the limit of the Google Play API `supply` can't download your existing screenshots...")
+    end
+
+    def store_apk_listing(apk_listing)
+      containing = File.join(metadata_path, apk_listing.language, CHANGELOGS_FOLDER_NAME)
+      unless File.exist?(containing)
+        FileUtils.mkdir_p(containing)
+      end
+
+      path = File.join(containing, "#{apk_listing.apk_version_code}.txt")
+      UI.message("Writing to #{path}...")
+      File.write(path, apk_listing.recent_changes)
+    end
+
+    private
+
+    def metadata_path
+      @metadata_path ||= Supply.config[:metadata_path]
+      @metadata_path ||= "fastlane/metadata/android" if Helper.fastlane_enabled?
+      @metadata_path ||= "metadata" unless Helper.fastlane_enabled?
+
+      return @metadata_path
+    end
+
+    def client
+      @client ||= Client.make_from_config
+    end
+  end
+end

data/supply/lib/supply/uploader.rb

@@ -0,0 +1,221 @@
+module Supply
+  class Uploader
+    def perform_upload
+      FastlaneCore::PrintTable.print_values(config: Supply.config, hide_keys: [:issuer], title: "Summary for supply #{Fastlane::VERSION}")
+
+      client.begin_edit(package_name: Supply.config[:package_name])
+
+      UI.user_error!("No local metadata found, make sure to run `supply init` to setup supply") unless metadata_path || Supply.config[:apk] || Supply.config[:apk_paths]
+
+      if metadata_path
+        UI.user_error!("Could not find folder #{metadata_path}") unless File.directory? metadata_path
+
+        all_languages.each do |language|
+          next if language.start_with?('.') # e.g. . or .. or hidden folders
+          UI.message("Preparing to upload for language '#{language}'...")
+
+          listing = client.listing_for_language(language)
+
+          upload_metadata(language, listing) unless Supply.config[:skip_upload_metadata]
+          upload_images(language) unless Supply.config[:skip_upload_images]
+          upload_screenshots(language) unless Supply.config[:skip_upload_screenshots]
+          upload_changelogs(language) unless Supply.config[:skip_upload_metadata]
+        end
+      end
+
+      upload_binaries unless Supply.config[:skip_upload_apk]
+
+      promote_track if Supply.config[:track_promote_to]
+
+      if Supply.config[:validate_only]
+        UI.message("Validating all changes with Google Play...")
+        client.validate_current_edit!
+        UI.success("Successfully validated the upload to Google Play")
+      else
+        UI.message("Uploading all changes to Google Play...")
+        client.commit_current_edit!
+        UI.success("Successfully finished the upload to Google Play")
+      end
+    end
+
+    def promote_track
+      version_codes = client.track_version_codes(Supply.config[:track])
+      # the actual value passed for the rollout argument does not matter because it will be ignored by the Google Play API
+      # but it has to be between 0.05 and 0.5 to pass the validity check. So we are passing the default value 0.1
+      client.update_track(Supply.config[:track], 0.1, nil)
+      version_codes.each do |apk_version_code|
+        client.update_track(Supply.config[:track_promote_to], Supply.config[:rollout], apk_version_code)
+      end
+    end
+
+    def upload_changelogs(language)
+      client.apks_version_codes.each do |apk_version_code|
+        upload_changelog(language, apk_version_code)
+      end
+    end
+
+    def upload_changelog(language, apk_version_code)
+      path = File.join(metadata_path, language, Supply::CHANGELOGS_FOLDER_NAME, "#{apk_version_code}.txt")
+      if File.exist?(path)
+        UI.message("Updating changelog for code version '#{apk_version_code}' and language '#{language}'...")
+        apk_listing = ApkListing.new(File.read(path, encoding: 'UTF-8'), language, apk_version_code)
+        client.update_apk_listing_for_language(apk_listing)
+      end
+    end
+
+    def upload_metadata(language, listing)
+      Supply::AVAILABLE_METADATA_FIELDS.each do |key|
+        path = File.join(metadata_path, language, "#{key}.txt")
+        listing.send("#{key}=".to_sym, File.read(path, encoding: 'UTF-8')) if File.exist?(path)
+      end
+      begin
+        listing.save
+      rescue Encoding::InvalidByteSequenceError => ex
+        message = (ex.message || '').capitalize
+        UI.user_error!("Metadata must be UTF-8 encoded. #{message}")
+      end
+    end
+
+    def upload_images(language)
+      Supply::IMAGES_TYPES.each do |image_type|
+        search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, image_type) + ".#{IMAGE_FILE_EXTENSIONS}"
+        path = Dir.glob(search, File::FNM_CASEFOLD).last
+        next unless path
+
+        UI.message("Uploading image file #{path}...")
+        client.upload_image(image_path: File.expand_path(path),
+                            image_type: image_type,
+                              language: language)
+      end
+    end
+
+    def upload_screenshots(language)
+      Supply::SCREENSHOT_TYPES.each do |screenshot_type|
+        search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, screenshot_type, "*.#{IMAGE_FILE_EXTENSIONS}")
+        paths = Dir.glob(search, File::FNM_CASEFOLD)
+        next unless paths.count > 0
+
+        client.clear_screenshots(image_type: screenshot_type, language: language)
+
+        paths.sort.each do |path|
+          UI.message("Uploading screenshot #{path}...")
+          client.upload_image(image_path: File.expand_path(path),
+                              image_type: screenshot_type,
+                                language: language)
+        end
+      end
+    end
+
+    def upload_binaries
+      apk_paths = [Supply.config[:apk]] unless (apk_paths = Supply.config[:apk_paths])
+
+      apk_version_codes = []
+
+      apk_paths.each do |apk_path|
+        apk_version_codes.push(upload_binary_data(apk_path))
+      end
+
+      update_track(apk_version_codes)
+    end
+
+    private
+
+    ##
+    # Upload binary apk and obb and corresponding change logs with client
+    #
+    # @param [String] apk_path
+    #    Path of the apk file to upload.
+    #
+    # @return [Integer] The apk version code returned after uploading, or nil if there was a problem
+    def upload_binary_data(apk_path)
+      apk_version_code = nil
+      if apk_path
+        UI.message("Preparing apk at path '#{apk_path}' for upload...")
+        apk_version_code = client.upload_apk(apk_path)
+        UI.user_error!("Could not upload #{apk_path}") unless apk_version_code
+
+        upload_obbs(apk_path, apk_version_code)
+
+        if metadata_path
+          all_languages.each do |language|
+            next if language.start_with?('.') # e.g. . or .. or hidden folders
+            upload_changelog(language, apk_version_code)
+          end
+        end
+      else
+        UI.message("No apk file found, you can pass the path to your apk using the `apk` option")
+      end
+      apk_version_code
+    end
+
+    def update_track(apk_version_codes)
+      UI.message("Updating track '#{Supply.config[:track]}'...")
+      if Supply.config[:track].eql? "rollout"
+        client.update_track(Supply.config[:track], Supply.config[:rollout], apk_version_codes)
+      else
+        client.update_track(Supply.config[:track], 1.0, apk_version_codes)
+      end
+    end
+
+    def all_languages
+      Dir.foreach(metadata_path).sort { |x, y| x <=> y }
+    end
+
+    def client
+      @client ||= Client.make_from_config
+    end
+
+    def metadata_path
+      Supply.config[:metadata_path]
+    end
+
+    # searches for obbs in the directory where the apk is located and
+    # upload at most one main and one patch file. Do nothing if it finds
+    # more than one of either of them.
+    def upload_obbs(apk_path, apk_version_code)
+      expansion_paths = find_obbs(apk_path)
+      ['main', 'patch'].each do |type|
+        if expansion_paths[type]
+          upload_obb(expansion_paths[type], type, apk_version_code)
+        end
+      end
+    end
+
+    # @return a map of the obb paths for that apk
+    # keyed by their detected expansion file type
+    # E.g.
+    # { 'main' => 'path/to/main.obb', 'patch' => 'path/to/patch.obb' }
+    def find_obbs(apk_path)
+      search = File.join(File.dirname(apk_path), '*.obb')
+      paths = Dir.glob(search, File::FNM_CASEFOLD)
+      expansion_paths = {}
+      paths.each do |path|
+        type = obb_expansion_file_type(path)
+        next unless type
+        if expansion_paths[type]
+          UI.important("Can only upload one '#{type}' apk expansion. Skipping obb upload entirely.")
+          UI.important("If you'd like this to work differently, please submit an issue.")
+          return {}
+        end
+        expansion_paths[type] = path
+      end
+      expansion_paths
+    end
+
+    def upload_obb(obb_path, expansion_file_type, apk_version_code)
+      UI.message("Uploading obb file #{obb_path}...")
+      client.upload_obb(obb_file_path: obb_path,
+                        apk_version_code: apk_version_code,
+                        expansion_file_type: expansion_file_type)
+    end
+
+    def obb_expansion_file_type(obb_file_path)
+      filename = File.basename(obb_file_path, ".obb")
+      if filename.include?('main')
+        'main'
+      elsif filename.include?('patch')
+        'patch'
+      end
+    end
+  end
+end