fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/copy_artifacts.rb

@@ -0,0 +1,114 @@
+require 'fileutils'
+
+module Fastlane
+  module Actions
+    class CopyArtifactsAction < Action
+      def self.run(params)
+        # expand the path to make sure we can deal with relative paths
+        target_path = File.expand_path(params[:target_path])
+
+        # we want to make sure that our target folder exist already
+        FileUtils.mkdir_p(target_path)
+
+        # Ensure that artifacts is an array
+        artifacts_to_search = [params[:artifacts]].flatten
+
+        # If any of the paths include "*", we assume that we are referring to the Unix entries
+        # e.g /tmp/fastlane/* refers to all the files in /tmp/fastlane
+        # We use Dir.glob to expand all those paths, this would create an array of arrays though, so flatten
+        artifacts = artifacts_to_search.flat_map { |f| f.include?("*") ? Dir.glob(f) : f }
+
+        UI.verbose("Copying artifacts #{artifacts.join(', ')} to #{target_path}")
+        UI.verbose(params[:keep_original] ? "Keeping original files" : "Not keeping original files")
+
+        if params[:fail_on_missing]
+          missing = artifacts.reject { |a| File.exist?(a) }
+          UI.user_error!("Not all files were present in copy artifacts. Missing #{missing.join(', ')}") unless missing.empty?
+        else
+          # If we don't fail on non-existent files, don't try to copy non-existent files
+          artifacts.select! { |artifact| File.exist?(artifact) }
+        end
+
+        if params[:keep_original]
+          FileUtils.cp_r(artifacts, target_path, remove_destination: true)
+        else
+          FileUtils.mv(artifacts, target_path, force: true)
+        end
+
+        UI.success('Build artifacts successfully copied!')
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Copy and save your build artifacts (useful when you use reset_git_repo)"
+      end
+
+      def self.details
+        [
+          "This action copies artifacts to a target directory. It's useful if you have a CI that will pick up these artifacts and attach them to the build. Useful e.g. for storing your `.ipa`s, `.dSYM.zip`s, `.mobileprovision`s, `.cert`s.",
+          "Make sure your `:target_path` is ignored from git, and if you use `reset_git_repo`, make sure the artifacts are added to the exclude list."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :keep_original,
+                                       description: "Set this to false if you want move, rather than copy, the found artifacts",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :target_path,
+                                       description: "The directory in which you want your artifacts placed",
+                                       is_string: false,
+                                       optional: false,
+                                       default_value: 'artifacts'),
+          FastlaneCore::ConfigItem.new(key: :artifacts,
+                                       description: "An array of file patterns of the files/folders you want to preserve",
+                                       is_string: false,
+                                       optional: false,
+                                       default_value: []),
+          FastlaneCore::ConfigItem.new(key: :fail_on_missing,
+                                       description: "Fail when a source file isn't found",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false)
+        ]
+      end
+
+      def self.authors
+        ["lmirosevic"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'copy_artifacts(
+            target_path: "artifacts",
+            artifacts: ["*.cer", "*.mobileprovision", "*.ipa", "*.dSYM.zip", "path/to/file.txt", "another/path/*.extension"]
+          )
+
+          # Reset the git repo to a clean state, but leave our artifacts in place
+          reset_git_repo(
+            exclude: "artifacts"
+          )',
+          '# Copy the .ipa created by _gym_ if it was successfully created
+          artifacts = []
+          artifacts << lane_context[SharedValues::IPA_OUTPUT_PATH] if lane_context[SharedValues::IPA_OUTPUT_PATH]
+          copy_artifacts(
+             artifacts: artifacts
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/crashlytics.rb

@@ -0,0 +1,211 @@
+module Fastlane
+  module Actions
+    class CrashlyticsAction < Action
+      def self.run(params)
+        params[:groups] = params[:groups].join(",") if params[:groups].kind_of?(Array)
+        params[:emails] = params[:emails].join(",") if params[:emails].kind_of?(Array)
+
+        params.values # to validate all inputs before looking for the ipa/apk
+        tempfiles = []
+
+        # We need to store notes in a file, because the crashlytics CLI (iOS) says so
+        if params[:notes]
+          UI.error("Overwriting :notes_path, because you specified :notes") if params[:notes_path]
+
+          changelog = Helper::CrashlyticsHelper.write_to_tempfile(params[:notes], 'changelog')
+          tempfiles << changelog
+          params[:notes_path] = changelog.path
+        elsif Actions.lane_context[SharedValues::FL_CHANGELOG] && !params[:notes_path]
+          UI.message("Sending FL_CHANGELOG as release notes to Beta by Crashlytics")
+
+          changelog = Helper::CrashlyticsHelper.write_to_tempfile(
+            Actions.lane_context[SharedValues::FL_CHANGELOG], 'changelog'
+          )
+          tempfiles << changelog
+          params[:notes_path] = changelog.path
+        end
+
+        if params[:ipa_path]
+          command = Helper::CrashlyticsHelper.generate_ios_command(params)
+        elsif params[:apk_path]
+          android_manifest = Helper::CrashlyticsHelper.generate_android_manifest_tempfile
+          tempfiles << android_manifest
+          command = Helper::CrashlyticsHelper.generate_android_command(params, android_manifest.path)
+        else
+          UI.user_error!("You have to either pass an ipa or an apk file to the Crashlytics action")
+        end
+
+        UI.success('Uploading the build to Crashlytics Beta. Time for some ☕️.')
+
+        sanitizer = proc do |message|
+          message.gsub(params[:api_token], '[[API_TOKEN]]')
+                 .gsub(params[:build_secret], '[[BUILD_SECRET]]')
+        end
+
+        UI.verbose(sanitizer.call(command.join(' '))) if FastlaneCore::Globals.verbose?
+
+        error_callback = proc do |error|
+          clean_error = sanitizer.call(error)
+          UI.user_error!(clean_error)
+        end
+
+        result = Actions.sh_control_output(
+          command.join(" "),
+          print_command: false,
+          print_command_output: false,
+          error_callback: error_callback
+        )
+
+        tempfiles.each(&:unlink)
+        return command if Helper.test?
+
+        UI.verbose(sanitizer.call(result)) if FastlaneCore::Globals.verbose?
+
+        UI.success('Build successfully uploaded to Crashlytics Beta 🌷')
+        UI.success('Visit https://fabric.io/_/beta to add release notes and notify testers.')
+      end
+
+      def self.description
+        "Refer to [Firebase App Distribution](https://appdistro.page.link/fastlane-repo)"
+      end
+
+      def self.available_options
+        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+
+        if platform == :ios || platform.nil?
+          ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
+        end
+
+        if platform == :android
+          apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
+        end
+
+        [
+          # iOS Specific
+          FastlaneCore::ConfigItem.new(key: :ipa_path,
+                                       env_name: "CRASHLYTICS_IPA_PATH",
+                                       description: "Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action",
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] || ipa_path_default,
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          # Android Specific
+          FastlaneCore::ConfigItem.new(key: :apk_path,
+                                       env_name: "CRASHLYTICS_APK_PATH",
+                                       description: "Path to your APK file",
+                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH] || apk_path_default,
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          # General
+          FastlaneCore::ConfigItem.new(key: :crashlytics_path,
+                                       env_name: "CRASHLYTICS_FRAMEWORK_PATH",
+                                       description: "Path to the submit binary in the Crashlytics bundle (iOS) or `crashlytics-devtools.jar` file (Android)",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find crashlytics at path '#{File.expand_path(value)}'`") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CRASHLYTICS_API_TOKEN",
+                                       description: "Crashlytics API Key",
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API token for Crashlytics given, pass using `api_token: 'token'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :build_secret,
+                                       env_name: "CRASHLYTICS_BUILD_SECRET",
+                                       description: "Crashlytics Build Secret",
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No build secret for Crashlytics given, pass using `build_secret: 'secret'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :notes_path,
+                                       env_name: "CRASHLYTICS_NOTES_PATH",
+                                       description: "Path to the release notes",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path '#{value}' not found") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :notes,
+                                       env_name: "CRASHLYTICS_NOTES",
+                                       description: "The release notes as string - uses :notes_path under the hood",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :groups,
+                                       env_name: "CRASHLYTICS_GROUPS",
+                                       description: "The groups used for distribution, separated by commas",
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :emails,
+                                       env_name: "CRASHLYTICS_EMAILS",
+                                       description: "Pass email addresses of testers, separated by commas",
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :notifications,
+                                       env_name: "CRASHLYTICS_NOTIFICATIONS",
+                                       description: "Crashlytics notification option (true/false)",
+                                       default_value: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       env_name: "CRASHLYTICS_DEBUG",
+                                       description: "Crashlytics debug option (true/false)",
+                                       default_value: false,
+                                       is_string: false)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :android].include?(platform)
+      end
+
+      def self.author
+        ["KrauseFx", "pedrogimenez"]
+      end
+
+      def self.details
+        [
+          "Additionally, you can specify `notes`, `emails`, `groups` and `notifications`.",
+          "Distributing to Groups: When using the `groups` parameter, it's important to use the group **alias** names for each group you'd like to distribute to. A group's alias can be found in the web UI. If you're viewing the Beta page, you can open the groups dialog by clicking the 'Manage Groups' button.",
+          "This action uses the `submit` binary provided by the Crashlytics framework. If the binary is not found in its usual path, you'll need to specify the path manually by using the `crashlytics_path` option."
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'crashlytics',
+          '# If you installed Crashlytics via CocoaPods
+          crashlytics(
+            crashlytics_path: "./Pods/Crashlytics/submit", # path to your Crashlytics submit binary.
+            api_token: "...",
+            build_secret: "...",
+            ipa_path: "./app.ipa"
+          )',
+          '# If you installed Crashlytics via Carthage for iOS platform
+          crashlytics(
+            crashlytics_path: "./Carthage/Build/iOS/Crashlytics.framework/submit", # path to your Crashlytics submit binary.
+            api_token: "...",
+            build_secret: "...",
+            ipa_path: "./app.ipa"
+          )'
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        [
+          "Crashlytics Beta has been deprecated and replaced with Firebase App Distribution.",
+          "Beta will continue working until May 4, 2020.",
+          "Check out the [Firebase App Distribution docs](https://github.com/fastlane/fastlane-plugin-firebase_app_distribution) to get started."
+        ].join("\n")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_app_on_managed_play_store.rb

@@ -0,0 +1,174 @@
+require 'google/apis/playcustomapp_v1'
+require 'supply'
+
+module Fastlane
+  module Actions
+    class CreateAppOnManagedPlayStoreAction < Action
+      def self.run(params)
+        client = PlaycustomappClient.make_from_config(params: params)
+
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          mask_keys: [:json_key_data],
+          title: "Summary for create_app_on_managed_play_store"
+        )
+
+        client.create_app(
+          app_title: params[:app_title],
+          language_code: params[:language],
+          developer_account: params[:developer_account_id],
+          apk_path: params[:apk]
+        )
+      end
+
+      def self.description
+        "Create Managed Google Play Apps"
+      end
+
+      def self.authors
+        ["janpio"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Create new apps on Managed Google Play."
+      end
+
+      def self.example_code
+        [
+          "create_app_on_managed_play_store(
+            json_key: 'path/to/you/json/key/file',
+            developer_account_id: 'developer_account_id', # obtained using the `get_managed_play_store_publishing_rights` action (or looking at the Play Console url)
+            app_title: 'Your app title',
+            language: 'en_US', # primary app language in BCP 47 format
+            apk: '/files/app-release.apk'
+          )"
+        ]
+      end
+
+      def self.available_options
+        [
+          # Authorization
+          FastlaneCore::ConfigItem.new(
+            key: :json_key,
+            env_name: "SUPPLY_JSON_KEY",
+            short_option: "-j",
+            conflicting_options: [:json_key_data],
+            optional: true, # optional until it is possible specify either json_key OR json_key_data are required
+            description: "The path to a file containing service account JSON, used to authenticate with Google",
+            code_gen_sensitive: true,
+            default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
+            default_value_dynamic: true,
+            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))
+              UI.user_error!("'#{value}' doesn't seem to be a JSON file") unless FastlaneCore::Helper.json_file?(File.expand_path(value))
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :json_key_data,
+            env_name: "SUPPLY_JSON_KEY_DATA",
+            short_option: "-c",
+            conflicting_options: [:json_key],
+            optional: true,
+            description: "The raw service account JSON data used to authenticate with Google",
+            code_gen_sensitive: true,
+            default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_data_raw),
+            default_value_dynamic: true,
+            verify_block: proc do |value|
+              begin
+                JSON.parse(value)
+              rescue JSON::ParserError
+                UI.user_error!("Could not parse service account json: JSON::ParseError")
+              end
+            end
+          ),
+          FastlaneCore::ConfigItem.new(key: :developer_account_id,
+            short_option: "-k",
+            env_name: "SUPPLY_DEVELOPER_ACCOUNT_ID",
+            description: "The ID of your Google Play Console account. Can be obtained from the URL when you log in (`https://play.google.com/apps/publish/?account=...` or when you 'Obtain private app publishing rights' (https://developers.google.com/android/work/play/custom-app-api/get-started#retrieve_the_developer_account_id)",
+            code_gen_sensitive: true,
+            default_value: CredentialsManager::AppfileConfig.try_fetch_value(:developer_account_id),
+            default_value_dynamic: true),
+          # APK
+          FastlaneCore::ConfigItem.new(
+            key: :apk,
+            env_name: "SUPPLY_APK",
+            description: "Path to the APK file to upload",
+            short_option: "-b",
+            code_gen_sensitive: true,
+            default_value: Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last,
+            default_value_dynamic: true,
+            verify_block: proc do |value|
+              UI.user_error!("No value found for 'apk'") if value.to_s.length == 0
+              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
+          ),
+          # Title
+          FastlaneCore::ConfigItem.new(key: :app_title,
+            env_name: "SUPPLY_APP_TITLE",
+            short_option: "-q",
+            description: "App Title"),
+          # Language
+          FastlaneCore::ConfigItem.new(key: :language,
+            short_option: "-m",
+            env_name: "SUPPLY_LANGUAGE",
+            description: "Default app language (e.g. 'en_US')",
+            default_value: "en_US",
+            verify_block: proc do |language|
+              unless Supply::Languages::ALL_LANGUAGES.include?(language)
+                UI.user_error!("Please enter one of the available languages: #{Supply::Languages::ALL_LANGUAGES}")
+              end
+            end),
+          # Google Play API
+          FastlaneCore::ConfigItem.new(key: :root_url,
+            env_name: "SUPPLY_ROOT_URL",
+            description: "Root URL for the Google Play API. The provided URL will be used for API calls in place of https://www.googleapis.com/",
+            optional: true,
+            verify_block: proc do |value|
+              UI.user_error!("Could not parse URL '#{value}'") unless value =~ URI.regexp
+            end),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+            env_name: "SUPPLY_TIMEOUT",
+            optional: true,
+            description: "Timeout for read, open, and send (in seconds)",
+            type: Integer,
+            default_value: 300)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end
+
+require 'supply/client'
+class PlaycustomappClient < Supply::AbstractGoogleServiceClient
+  SERVICE = Google::Apis::PlaycustomappV1::PlaycustomappService
+  SCOPE = Google::Apis::PlaycustomappV1::AUTH_ANDROIDPUBLISHER
+
+  #####################################################
+  # @!group Create
+  #####################################################
+
+  def create_app(app_title: nil, language_code: nil, developer_account: nil, apk_path: nil)
+    custom_app = Google::Apis::PlaycustomappV1::CustomApp.new(title: app_title, language_code: language_code)
+
+    call_google_api do
+      client.create_account_custom_app(
+        developer_account,
+        custom_app,
+        upload_source: apk_path
+      )
+    end
+  end
+end