fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/typetalk.rb

@@ -0,0 +1,93 @@
+module Fastlane
+  module Actions
+    class TypetalkAction < Action
+      def self.run(params)
+        options = {
+            message: nil,
+            note_path: nil,
+            success: true,
+            topic_id: nil,
+            typetalk_token: nil
+        }.merge(params || {})
+
+        [:message, :topic_id, :typetalk_token].each do |key|
+          UI.user_error!("No #{key} given.") unless options[key]
+        end
+
+        emoticon = (options[:success] ? ':smile:' : ':rage:')
+        message = "#{emoticon} #{options[:message]}"
+
+        note_path = File.expand_path(options[:note_path]) if options[:note_path]
+        if note_path && File.exist?(note_path)
+          contents = File.read(note_path)
+          message += "\n\n```\n#{contents}\n```"
+        end
+
+        topic_id = options[:topic_id]
+        typetalk_token = options[:typetalk_token]
+
+        self.post_to_typetalk(message, topic_id, typetalk_token)
+
+        UI.success('Successfully sent Typetalk notification')
+      end
+
+      def self.post_to_typetalk(message, topic_id, typetalk_token)
+        require 'net/http'
+        require 'uri'
+
+        uri = URI.parse("https://typetalk.in/api/v1/topics/#{topic_id}")
+        response = Net::HTTP.post_form(uri, { 'message' => message,
+                                             'typetalkToken' => typetalk_token })
+
+        self.check_response(response)
+      end
+
+      def self.check_response(response)
+        case response.code.to_i
+        when 200, 204
+          true
+        else
+          UI.user_error!("Could not sent Typetalk notification")
+        end
+      end
+
+      def self.description
+        "Post a message to [Typetalk](https://www.typetalk.com/)"
+      end
+
+      def self.available_options
+        [
+          ['message', 'The message to post'],
+          ['note_path', 'Path to an additional note'],
+          ['topic_id', 'Typetalk topic id'],
+          ['success', 'Successful build?'],
+          ['typetalk_token', 'typetalk token']
+        ]
+      end
+
+      def self.author
+        "Nulab Inc."
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'typetalk(
+            message: "App successfully released!",
+            note_path: "ChangeLog.md",
+            topicId: 1,
+            success: true,
+            typetalk_token: "Your Typetalk Token"
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/unlock_keychain.rb

@@ -0,0 +1,132 @@
+module Fastlane
+  module Actions
+    class UnlockKeychainAction < Action
+      def self.run(params)
+        keychain_path = FastlaneCore::Helper.keychain_path(params[:path])
+        add_to_search_list = params[:add_to_search_list]
+        set_default = params[:set_default]
+        commands = []
+
+        # add to search list if not already added
+        if add_to_search_list == true || add_to_search_list == :add
+          commands << add_keychain_to_search_list(keychain_path)
+        elsif add_to_search_list == :replace
+          commands << replace_keychain_in_search_list(keychain_path)
+        end
+
+        # set default keychain
+        if set_default
+          commands << default_keychain(keychain_path)
+        end
+
+        escaped_path = keychain_path.shellescape
+        escaped_password = params[:password].shellescape
+
+        # Log the full path, useful for troubleshooting
+        UI.message("Unlocking keychain at path: #{escaped_path}")
+        # unlock given keychain and disable lock and timeout
+        commands << Fastlane::Actions.sh("security unlock-keychain -p #{escaped_password} #{escaped_path}", log: false)
+        commands << Fastlane::Actions.sh("security set-keychain-settings #{escaped_path}", log: false)
+        commands
+      end
+
+      def self.add_keychain_to_search_list(keychain_path)
+        keychains = Fastlane::Actions.sh("security list-keychains -d user", log: false).shellsplit
+
+        # add the keychain to the keychain list
+        unless keychains.include?(keychain_path)
+          keychains << keychain_path
+
+          Fastlane::Actions.sh("security list-keychains -s #{keychains.shelljoin}", log: false)
+        end
+      end
+
+      def self.replace_keychain_in_search_list(keychain_path)
+        Actions.lane_context[Actions::SharedValues::ORIGINAL_DEFAULT_KEYCHAIN] = Fastlane::Actions.sh("security default-keychain", log: false).strip
+        escaped_path = keychain_path.shellescape
+        Fastlane::Actions.sh("security list-keychains -s #{escaped_path}", log: false)
+      end
+
+      def self.default_keychain(keychain_path)
+        escaped_path = keychain_path.shellescape
+        Fastlane::Actions.sh("security default-keychain -s #{escaped_path}", log: false)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Unlock a keychain"
+      end
+
+      def self.details
+        [
+          "Unlocks the given keychain file and adds it to the keychain search list.",
+          "Keychains can be replaced with `add_to_search_list: :replace`."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_PATH",
+                                       description: "Path to the keychain file",
+                                       default_value: "login",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_PASSWORD",
+                                       sensitive: true,
+                                       description: "Keychain password",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :add_to_search_list,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_ADD_TO_SEARCH_LIST",
+                                       description: "Add to keychain search list, valid values are true, false, :add, and :replace",
+                                       skip_type_validation: true, # allow Boolean, Symbol
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :set_default,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_SET_DEFAULT",
+                                       description: "Set as default keychain",
+                                       type: Boolean,
+                                       default_value: false)
+
+        ]
+      end
+
+      def self.authors
+        ["xfreebird"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'unlock_keychain( # Unlock an existing keychain and add it to the keychain search list
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret"
+          )',
+          'unlock_keychain( # By default the keychain is added to the existing. To replace them with the selected keychain you may use `:replace`
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret",
+            add_to_search_list: :replace # To only add a keychain use `true` or `:add`.
+          )',
+          'unlock_keychain( # In addition, the keychain can be selected as a default keychain
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret",
+            set_default: true
+          )',
+          'unlock_keychain( # If the keychain file is located in the standard location `~/Library/Keychains`, then it is sufficient to provide the keychain file name, or file name with its suffix.
+            path: "KeychainName",
+            password: "mysecret"
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+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']",
+                                       type: Array)
+        ]
+      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,223 @@
+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'
+            development_team_setting = params[:sdk] ? "DEVELOPMENT_TEAM[sdk=#{params[:sdk]}]" : "DEVELOPMENT_TEAM"
+            code_sign_identity_setting = params[:sdk] ? "CODE_SIGN_IDENTITY[sdk=#{params[:sdk]}]" : "CODE_SIGN_IDENTITY"
+            provisioning_profile_setting = params[:sdk] ? "PROVISIONING_PROFILE_SPECIFIER[sdk=#{params[:sdk]}]" : "PROVISIONING_PROFILE_SPECIFIER"
+
+            set_build_setting(config, "CODE_SIGN_STYLE", style_value)
+
+            if params[:team_id]
+              set_build_setting(config, development_team_setting, 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_setting, 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_setting, params[:profile_name])
+              UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:entitlements_file_path]
+              set_build_setting(config, "CODE_SIGN_ENTITLEMENTS", params[:entitlements_file_path])
+              UI.important("Set Entitlements file path to: #{params[:entitlements_file_path]} 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",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :sdk,
+                                       env_name: "FASTLANE_BUILD_SDK",
+                                       optional: true,
+                                       description: "Build target SDKs (iphoneos*, macosx*, iphonesimulator*)"),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project"),
+          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)"),
+          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 configurations)"),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :entitlements_file_path,
+                                       env_name: "FL_CODE_SIGN_ENTITLEMENTS_FILE_PATH",
+                                       description: "Path to your entitlements file",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: 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"
+          )',
+          ' # more advanced manual code signing
+          update_code_signing_settings(
+            use_automatic_signing: false,
+            path: "demo-project/demo/demo.xcodeproj",
+            team_id: "QABC123DEV",
+            bundle_identifier: "com.demoapp.QABC123DEV",
+            code_sign_identity: "iPhone Distribution",
+            sdk: "iphoneos*",
+            profile_name: "Demo App Deployment Profile",
+            entitlements_file_path: "Demo App/generated/New.entitlements"
+          )'
+        ]
+      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", "abcdev"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end