fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/update_app_group_identifiers.rb

@@ -0,0 +1,91 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      APP_GROUP_IDENTIFIERS = :APP_GROUP_IDENTIFIERS
+    end
+
+    class UpdateAppGroupIdentifiersAction < Action
+      require 'plist'
+
+      def self.run(params)
+        UI.message("Entitlements File: #{params[:entitlements_file]}")
+        UI.message("New App Group Identifiers: #{params[:app_group_identifiers]}")
+
+        entitlements_file = params[:entitlements_file]
+        UI.user_error!("Could not find entitlements file at path '#{entitlements_file}'") unless File.exist?(entitlements_file)
+
+        # parse entitlements
+        result = Plist.parse_xml(entitlements_file)
+        UI.user_error!("Entitlements file at '#{entitlements_file}' cannot be parsed.") unless result
+
+        # get app group field
+        app_group_field = result['com.apple.security.application-groups']
+        UI.user_error!("No existing App group field specified. Please specify an App Group in the entitlements file.") unless app_group_field
+
+        # set new app group identifiers
+        UI.message("Old App Group Identifiers: #{app_group_field}")
+        result['com.apple.security.application-groups'] = params[:app_group_identifiers]
+
+        # save entitlements file
+        result.save_plist(entitlements_file)
+        UI.message("New App Group Identifiers set: #{result['com.apple.security.application-groups']}")
+
+        Actions.lane_context[SharedValues::APP_GROUP_IDENTIFIERS] = result['com.apple.security.application-groups']
+      end
+
+      def self.description
+        "This action changes the app group identifiers in the entitlements file"
+      end
+
+      def self.details
+        "Updates the App Group Identifiers in the given Entitlements file, so you can have app groups for the app store build and app groups for an enterprise build."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :entitlements_file,
+                                       env_name: "FL_UPDATE_APP_GROUP_IDENTIFIER_ENTITLEMENTS_FILE_PATH", # The name of the environment variable
+                                       description: "The path to the entitlement file which contains the app group identifiers", # a short description of this parameter
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a path to an entitlements file. ") unless value.include?(".entitlements")
+                                         UI.user_error!("Could not find entitlements file") if !File.exist?(value) && !Helper.test?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_group_identifiers,
+                                       env_name: "FL_UPDATE_APP_GROUP_IDENTIFIER_APP_GROUP_IDENTIFIERS",
+                                       description: "An Array of unique identifiers for the app groups. Eg. ['group.com.test.testapp']",
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The parameter app_group_identifiers need to be an Array.") unless value.kind_of?(Array)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['APP_GROUP_IDENTIFIERS', 'The new App Group Identifiers']
+        ]
+      end
+
+      def self.authors
+        ["mathiasAichinger"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'update_app_group_identifiers(
+            entitlements_file: "/path/to/entitlements_file.entitlements",
+            app_group_identifiers: ["group.your.app.group.identifier"]
+          )'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/update_app_identifier.rb

@@ -0,0 +1,124 @@
+module Fastlane
+  module Actions
+    class UpdateAppIdentifierAction < Action
+      def self.run(params)
+        require 'plist'
+        require 'xcodeproj'
+
+        info_plist_key = 'INFOPLIST_FILE'
+        identifier_key = 'PRODUCT_BUNDLE_IDENTIFIER'
+
+        # Read existing plist file
+        info_plist_path = resolve_path(params[:plist_path], params[:xcodeproj])
+        UI.user_error!("Couldn't find info plist file at path '#{params[:plist_path]}'") unless File.exist?(info_plist_path)
+        plist = Plist.parse_xml(info_plist_path)
+
+        # Check if current app identifier product bundle identifier
+        app_id_equals_bundle_id = %W($(#{identifier_key}) ${#{identifier_key}}).include?(plist['CFBundleIdentifier'])
+        if app_id_equals_bundle_id
+          # Load .xcodeproj
+          project_path = params[:xcodeproj]
+          project = Xcodeproj::Project.open(project_path)
+
+          # Fetch the build configuration objects
+          configs = project.objects.select { |obj| obj.isa == 'XCBuildConfiguration' && !obj.build_settings[identifier_key].nil? }
+          UI.user_error!("Info plist uses #{identifier_key}, but xcodeproj does not") if configs.empty?
+
+          configs = configs.select { |obj| resolve_path(obj.build_settings[info_plist_key], params[:xcodeproj]) == info_plist_path }
+          UI.user_error!("Xcodeproj doesn't have configuration with info plist #{params[:plist_path]}.") if configs.empty?
+
+          # For each of the build configurations, set app identifier
+          configs.each do |c|
+            c.build_settings[identifier_key] = params[:app_identifier]
+          end
+
+          # Write changes to the file
+          project.save
+
+          UI.success("Updated #{params[:xcodeproj]} 💾.")
+        else
+          # Update plist value
+          plist['CFBundleIdentifier'] = params[:app_identifier]
+
+          # Write changes to file
+          plist_string = Plist::Emit.dump(plist)
+          File.write(info_plist_path, plist_string)
+
+          UI.success("Updated #{params[:plist_path]} 💾.")
+        end
+      end
+
+      def self.resolve_path(path, xcodeproj_path)
+        return nil unless path
+        project_dir = File.dirname(xcodeproj_path)
+        # SRCROOT, SOURCE_ROOT and PROJECT_DIR are the same
+        %w{SRCROOT SOURCE_ROOT PROJECT_DIR}.each do |variable_name|
+          path = path.sub("$(#{variable_name})", project_dir)
+        end
+        path = File.absolute_path(path, project_dir)
+        path
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+
+      def self.description
+        "Update the project's bundle identifier"
+      end
+
+      def self.details
+        "Update an app identifier by either setting `CFBundleIdentifier` or `PRODUCT_BUNDLE_IDENTIFIER`, depending on which is already in use."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "FL_UPDATE_APP_IDENTIFIER_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass the path to the project, not the workspace") unless value.end_with?(".xcodeproj")
+                                         UI.user_error!("Could not find Xcode project") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :plist_path,
+                                       env_name: "FL_UPDATE_APP_IDENTIFIER_PLIST_PATH",
+                                       description: "Path to info plist, relative to your Xcode project",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Invalid plist file") unless value[-6..-1].casecmp(".plist").zero?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                       env_name: 'FL_UPDATE_APP_IDENTIFIER',
+                                       description: 'The app Identifier you want to set',
+                                       code_gen_sensitive: true,
+                                       default_value: ENV['PRODUCE_APP_IDENTIFIER'] || CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                       default_value_dynamic: true)
+        ]
+      end
+
+      def self.authors
+        ['squarefrog', 'tobiasstrebitzer']
+      end
+
+      def self.example_code
+        [
+          'update_app_identifier(
+            xcodeproj: "Example.xcodeproj", # Optional path to xcodeproj, will use the first .xcodeproj if not set
+            plist_path: "Example/Info.plist", # Path to info plist file, relative to xcodeproj
+            app_identifier: "com.test.example" # The App Identifier
+          )'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/update_code_signing_settings.rb

@@ -0,0 +1,203 @@
+require 'xcodeproj'
+module Fastlane
+  module Actions
+    class UpdateCodeSigningSettingsAction < Action
+      def self.run(params)
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for code signing settings")
+        path = params[:path]
+        path = File.join(File.expand_path(path), "project.pbxproj")
+
+        project = Xcodeproj::Project.open(params[:path])
+        UI.user_error!("Could not find path to project config '#{path}'. Pass the path to your project (not workspace)!") unless File.exist?(path)
+        UI.message("Updating the Automatic Codesigning flag to #{params[:use_automatic_signing] ? 'enabled' : 'disabled'} for the given project '#{path}'")
+
+        unless project.root_object.attributes["TargetAttributes"]
+          UI.user_error!("Seems to be a very old project file format - please open your project file in a more recent version of Xcode")
+          return false
+        end
+
+        changed_targets = []
+        changed_build_configurations = []
+
+        project.targets.each do |target|
+          if params[:targets]
+            unless params[:targets].include?(target.name)
+              UI.important("Skipping #{target.name} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          target.build_configurations.each do |config|
+            if params[:build_configurations]
+              unless params[:build_configurations].include?(config.name)
+                UI.important("Skipping #{config.name} not selected (#{params[:build_configurations].join(',')})")
+                next
+              end
+            end
+
+            style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+            set_build_setting(config, "CODE_SIGN_STYLE", style_value)
+
+            if params[:team_id]
+              set_build_setting(config, "DEVELOPMENT_TEAM", params[:team_id])
+              UI.important("Set Team id to: #{params[:team_id]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:code_sign_identity]
+              set_build_setting(config, "CODE_SIGN_IDENTITY", params[:code_sign_identity])
+              UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:profile_name]
+              set_build_setting(config, "PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+              UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+            if params[:profile_uuid]
+              set_build_setting(config, "PROVISIONING_PROFILE", params[:profile_uuid])
+              UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:bundle_identifier]
+              set_build_setting(config, "PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+              UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+
+            changed_build_configurations << config.name
+          end
+
+          changed_targets << target.name
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          project.targets.each do |target|
+            UI.important("\t* #{target.name}")
+          end
+        else
+          UI.success("Successfully updated project settings to use Code Sign Style = '#{params[:use_automatic_signing] ? 'Automatic' : 'Manual'}'")
+          UI.success("Modified Targets:")
+          changed_targets.each do |target|
+            UI.success("\t * #{target}")
+          end
+
+          UI.success("Modified Build Configurations:")
+          changed_build_configurations.each do |name|
+            UI.success("\t * #{name}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.set_build_setting(configuration, name, value)
+        # Iterate over any keys that start with this name
+        # This will also set keys that have filtering like [sdk=iphoneos*]
+        keys = configuration.build_settings.keys.select { |key| key.to_s.match(/#{name}.*/) }
+        keys.each do |key|
+          configuration.build_settings[key] = value
+        end
+
+        # Explicitly set the key with value if keys don't exist
+        configuration.build_settings[name] = value
+      end
+
+      def self.description
+        "Configures Xcode's Codesigning options"
+      end
+
+      def self.details
+        "Configures Xcode's Codesigning options of all targets in the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_PROJECT_SIGNING_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path is invalid") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :use_automatic_signing,
+                                       env_name: "FL_PROJECT_USE_AUTOMATIC_SIGNING",
+                                       description: "Defines if project should use automatic signing",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project",
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :targets,
+                                       env_name: "FL_PROJECT_SIGNING_TARGETS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify targets you want to toggle the signing mech. (default to all targets)",
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :build_configurations,
+                                       env_name: "FL_PROJECT_SIGNING_BUILD_CONFIGURATIONS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify build_configurations you want to toggle the signing mech. (default to all targets)",
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          ' # manual code signing
+          update_code_signing_settings(
+            use_automatic_signing: false,
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          ' # automatic code signing
+          update_code_signing_settings(
+            use_automatic_signing: true,
+            path: "demo-project/demo/demo.xcodeproj"
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+
+      def self.return_value
+        "The current status (boolean) of codesigning after modification"
+      end
+
+      def self.authors
+        ["mathiasAichinger", "hjanuschka", "p4checo", "portellaa", "aeons", "att55"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/update_fastlane.rb

@@ -0,0 +1,137 @@
+require 'rubygems/spec_fetcher'
+require 'rubygems/command_manager'
+
+module Fastlane
+  module Actions
+    # Makes sure fastlane tools are up-to-date when running fastlane
+    class UpdateFastlaneAction < Action
+      ALL_TOOLS = ["fastlane"]
+
+      def self.run(options)
+        return if options[:no_update] # this is used to update itself
+
+        tools_to_update = ALL_TOOLS
+        UI.message("Looking for updates for #{tools_to_update.join(', ')}...")
+
+        updater = Gem::CommandManager.instance[:update]
+        cleaner = Gem::CommandManager.instance[:cleanup]
+
+        gem_dir = ENV['GEM_HOME'] || Gem.dir
+        sudo_needed = !File.writable?(gem_dir)
+
+        if sudo_needed
+          UI.important("It seems that your Gem directory is not writable by your current user.")
+          UI.important("fastlane would need sudo rights to update itself, however, running 'sudo fastlane' is not recommended.")
+          UI.important("If you still want to use this action, please read the documentation on how to set this up:")
+          UI.important("https://docs.fastlane.tools/actions/update_fastlane/")
+          return
+        end
+
+        unless updater.respond_to?(:highest_installed_gems)
+          UI.important("The update_fastlane action requires rubygems version 2.1.0 or greater.")
+          UI.important("Please update your version of ruby gems before proceeding.")
+          UI.command "gem install rubygems-update"
+          UI.command "update_rubygems"
+          UI.command "gem update --system"
+          return
+        end
+
+        highest_versions = updater.highest_installed_gems.keep_if { |key| tools_to_update.include?(key) }
+        update_needed = updater.which_to_update(highest_versions, tools_to_update)
+
+        if update_needed.count == 0
+          UI.success("Nothing to update ✅")
+          return
+        end
+
+        # suppress updater output - very noisy
+        Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
+
+        update_needed.each do |tool_info|
+          tool = tool_info[0]
+          local_version = Gem::Version.new(highest_versions[tool].version)
+          latest_official_version = FastlaneCore::UpdateChecker.fetch_latest(tool)
+
+          UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
+
+          # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
+          requirement_version = local_version.approximate_recommendation
+          updater.update_gem(tool, Gem::Requirement.new(requirement_version))
+
+          UI.success("Finished updating #{tool}")
+        end
+
+        UI.message("Cleaning up old versions...")
+        cleaner.options[:args] = tools_to_update
+        cleaner.execute
+
+        UI.message("fastlane.tools successfully updated! I will now restart myself... 😴")
+
+        # Set no_update to true so we don't try to update again
+        exec("FL_NO_UPDATE=true #{$PROGRAM_NAME} #{ARGV.join(' ')}")
+      end
+
+      def self.description
+        "Makes sure fastlane-tools are up-to-date when running fastlane"
+      end
+
+      def self.details
+        sample = <<-SAMPLE.markdown_sample
+          ```bash
+          export GEM_HOME=~/.gems
+          export PATH=$PATH:~/.gems/bin
+          ```
+        SAMPLE
+
+        [
+          "This action will update fastlane to the most recent version - major version updates will not be performed automatically, as they might include breaking changes. If an update was performed, fastlane will be restarted before the run continues.",
+          "",
+          "If you are using rbenv or rvm, everything should be good to go. However, if you are using the system's default ruby, some additional setup is needed for this action to work correctly. In short, fastlane needs to be able to access your gem library without running in `sudo` mode.",
+          "",
+          "The simplest possible fix for this is putting the following lines into your `~/.bashrc` or `~/.zshrc` file:".markdown_preserve_newlines,
+          sample,
+          "After the above changes, restart your terminal, then run `mkdir $GEM_HOME` to create the new gem directory. After this, you're good to go!",
+          "",
+          "Recommended usage of the `update_fastlane` action is at the top inside of the `before_all` block, before running any other action."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :no_update,
+                                       env_name: "FL_NO_UPDATE",
+                                       description: "Don't update during this run. This is used internally",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :nightly,
+                                       env_name: "FL_UPDATE_FASTLANE_NIGHTLY",
+                                       description: "Opt-in to install and use nightly fastlane builds",
+                                       is_string: false,
+                                       default_value: false,
+                                       deprecated: "Nightly builds are no longer being made available")
+        ]
+      end
+
+      def self.authors
+        ["milch", "KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'before_all do
+            update_fastlane
+            # ...
+          end'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end