fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/set_build_number_repository.rb

@@ -0,0 +1,76 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class SetBuildNumberRepositoryAction < Action
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.run(params)
+        build_number = Fastlane::Actions::GetBuildNumberRepositoryAction.run(
+          use_hg_revision_number: params[:use_hg_revision_number]
+        )
+
+        Fastlane::Actions::IncrementBuildNumberAction.run(
+          build_number: build_number,
+          xcodeproj: params[:xcodeproj]
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Set the build number from the current repository"
+      end
+
+      def self.details
+        [
+          "This action will set the **build number** according to what the SCM HEAD reports.",
+          "Currently supported SCMs are svn (uses root revision), git-svn (uses svn revision) and git (uses short hash) and mercurial (uses short hash or revision number).",
+          "There is an option, `:use_hg_revision_number`, which allows to use mercurial revision number instead of hash."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :use_hg_revision_number,
+                                       env_name: "USE_HG_REVISION_NUMBER",
+                                       description: "Use hg revision number instead of hash (ignored for non-hg repos)",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "XCODEPROJ_PATH",
+                                       description: "explicitly specify which xcodeproj to use",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         path = File.expand_path(value)
+                                         UI.user_error!("Please pass the path to the project, not the workspace") if path.end_with?(".xcworkspace")
+                                         UI.user_error!("Could not find Xcode project at #{path}") unless Helper.test? || File.exist?(path)
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["pbrooks", "armadsen", "AndrewSB"]
+      end
+
+      def self.example_code
+        [
+          'set_build_number_repository',
+          'set_build_number_repository(
+            xcodeproj: "./path/to/MyApp.xcodeproj"
+          )'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/set_changelog.rb

@@ -0,0 +1,201 @@
+module Fastlane
+  module Actions
+    class SetChangelogAction < Action
+      def self.run(params)
+        require 'spaceship'
+
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
+        if (api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path]))
+          UI.message("Creating authorization token for App Store Connect API")
+          Spaceship::ConnectAPI.token = api_token
+        elsif !Spaceship::ConnectAPI.token.nil?
+          UI.message("Using existing authorization token for App Store Connect API")
+        else
+          UI.message("Login to App Store Connect (#{params[:username]})")
+          Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true, tunes_team_id: params[:team_id], team_name: params[:team_name])
+          UI.message("Login successful")
+        end
+
+        app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
+        UI.user_error!("Couldn't find app with identifier #{params[:app_identifier]}") if app.nil?
+
+        version_number = params[:version]
+        platform = Spaceship::ConnectAPI::Platform.map(params[:platform])
+
+        unless version_number
+          # Automatically fetch the latest version
+          UI.message("Fetching the latest version for this app")
+          edit_version = app.get_edit_app_store_version(platform: platform)
+          if edit_version
+            version_number = edit_version.version_string
+          else
+            UI.message("You have to specify a new version number: ")
+            version_number = STDIN.gets.strip
+          end
+        end
+
+        UI.message("Going to update version #{version_number}")
+
+        changelog = params[:changelog]
+        unless changelog
+          path = default_changelog_path
+          UI.message("Looking for changelog in '#{path}'...")
+          if File.exist?(path)
+            changelog = File.read(path)
+          else
+            UI.error("Couldn't find changelog.txt")
+            UI.message("Please enter the changelog here:")
+            changelog = STDIN.gets
+          end
+        end
+
+        UI.important("Going to update the changelog to:\n\n#{changelog}\n\n")
+
+        edit_version = app.get_edit_app_store_version(platform: platform)
+        if edit_version
+          if edit_version.version_string != version_number
+            # Version is already there, make sure it matches the one we want to create
+            UI.message("Changing existing version number from '#{edit_version.version_string}' to '#{version_number}'")
+            edit_version = edit_version.update(attributes: {
+              versionString: version_number
+            })
+          else
+            UI.message("Updating changelog for existing version #{edit_version.version_string}")
+          end
+        else
+          UI.message("Creating the new version: #{version_number}")
+          attributes = { versionString: version_number, platform: platform }
+          edit_version = Spaceship::ConnectAPI.post_app_store_version(app_id: app.id, attributes: attributes).first
+        end
+
+        localizations = edit_version.get_app_store_version_localizations
+        localizations.each do |localization|
+          UI.message("Updating changelog for the '#{localization.locale}'")
+          localization.update(attributes: {
+            whatsNew: changelog
+          })
+        end
+
+        UI.success("👼  Successfully pushed the new changelog to for #{edit_version.version_string}")
+      end
+
+      def self.default_changelog_path
+        File.join(FastlaneCore::FastlaneFolder.path.to_s, 'changelog.txt')
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Set the changelog for all languages on App Store Connect"
+      end
+
+      def self.details
+        [
+          "This is useful if you have only one changelog for all languages.",
+          "You can store the changelog in `#{default_changelog_path}` and it will automatically get loaded from there. This integration is useful if you support e.g. 10 languages and want to use the same \"What's new\"-text for all languages.",
+          "Defining the version is optional. _fastlane_ will try to automatically detect it if you don't provide one."
+        ].join("\n")
+      end
+
+      def self.available_options
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+        [
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_names: ["FL_SET_CHANGELOG_API_KEY_PATH", "APP_STORE_CONNECT_API_KEY_PATH"],
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:api_key],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_names: ["FL_SET_CHANGELOG_API_KEY", "APP_STORE_CONNECT_API_KEY"],
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)",
+                                     type: Hash,
+                                     default_value: Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::APP_STORE_CONNECT_API_KEY],
+                                     default_value_dynamic: true,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path]),
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "FASTLANE_APP_IDENTIFIER",
+                                     description: "The bundle identifier of your app",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                     default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "FASTLANE_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     optional: true,
+                                     default_value: user,
+                                     default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "FL_SET_CHANGELOG_VERSION",
+                                       description: "The version number to create/update",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :changelog,
+                                       env_name: "FL_SET_CHANGELOG_CHANGELOG",
+                                       description: "Changelog text that should be uploaded to App Store Connect",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       short_option: "-k",
+                                       env_name: "FL_SET_CHANGELOG_TEAM_ID",
+                                       description: "The ID of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       skip_type_validation: true, # as we also allow integers, which we convert to strings anyway
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_ITC_TEAM_ID"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       short_option: "-e",
+                                       env_name: "FL_SET_CHANGELOG_TEAM_NAME",
+                                       description: "The name of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "FL_SET_CHANGELOG_PLATFORM",
+                                       description: "The platform of the app (ios, appletvos, mac)",
+                                       default_value: "ios",
+                                       verify_block: proc do |value|
+                                         available = ['ios', 'appletvos', 'mac']
+                                         UI.user_error!("Invalid platform '#{value}', must be #{available.join(', ')}") unless available.include?(value)
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :appletvos, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'set_changelog(changelog: "Changelog for all Languages")',
+          'set_changelog(app_identifier: "com.krausefx.app", version: "1.0", changelog: "Changelog for all Languages")'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/set_github_release.rb

@@ -0,0 +1,287 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SET_GITHUB_RELEASE_HTML_LINK = :SET_GITHUB_RELEASE_HTML_LINK
+      SET_GITHUB_RELEASE_RELEASE_ID = :SET_GITHUB_RELEASE_RELEASE_ID
+      SET_GITHUB_RELEASE_JSON = :SET_GITHUB_RELEASE_JSON
+    end
+
+    class SetGithubReleaseAction < Action
+      def self.run(params)
+        UI.important("Creating release of #{params[:repository_name]} on tag \"#{params[:tag_name]}\" with name \"#{params[:name]}\".")
+        UI.important("Will also upload assets #{params[:upload_assets]}.") if params[:upload_assets]
+
+        repo_name = params[:repository_name]
+        api_token = params[:api_token]
+        api_bearer = params[:api_bearer]
+        server_url = params[:server_url]
+        tag_name = params[:tag_name]
+
+        payload = {
+          'tag_name' => params[:tag_name],
+          'draft' => !!params[:is_draft],
+          'prerelease' => !!params[:is_prerelease],
+          'generate_release_notes' => !!params[:is_generate_release_notes]
+        }
+        payload['name'] = params[:name] if params[:name]
+        payload['body'] = params[:description] if params[:description]
+        payload['target_commitish'] = params[:commitish] if params[:commitish]
+
+        GithubApiAction.run(
+          server_url: server_url,
+          api_token: api_token,
+          api_bearer: api_bearer,
+          http_method: 'POST',
+          path: "repos/#{repo_name}/releases",
+          body: payload,
+          error_handlers: {
+            422 => proc do |result|
+              UI.error(result[:body])
+              UI.error("Release on tag #{tag_name} already exists!")
+              return nil
+            end,
+            404 => proc do |result|
+              UI.error(result[:body])
+              UI.user_error!("Repository #{repo_name} cannot be found, please double check its name and that you provided a valid API token (GITHUB_API_TOKEN)")
+            end,
+            401 => proc do |result|
+              UI.error(result[:body])
+              UI.user_error!("You are not authorized to access #{repo_name}, please make sure you provided a valid API token (GITHUB_API_TOKEN)")
+            end,
+            '*' => proc do |result|
+              UI.user_error!("GitHub responded with #{result[:status]}:#{result[:body]}")
+            end
+          }
+        ) do |result|
+          json = result[:json]
+          html_url = json['html_url']
+          release_id = json['id']
+
+          UI.success("Successfully created release at tag \"#{tag_name}\" on GitHub")
+          UI.important("See release at \"#{html_url}\"")
+
+          Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_HTML_LINK] = html_url
+          Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_RELEASE_ID] = release_id
+          Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = json
+
+          assets = params[:upload_assets]
+          if assets && assets.count > 0
+            # upload assets
+            self.upload_assets(assets, json['upload_url'], api_token, api_bearer)
+
+            # fetch the release again, so that it contains the uploaded assets
+            GithubApiAction.run(
+              server_url: server_url,
+              api_token: api_token,
+              api_bearer: api_bearer,
+              http_method: 'GET',
+              path: "repos/#{repo_name}/releases/#{release_id}",
+              error_handlers: {
+                '*' => proc do |get_result|
+                  UI.error("GitHub responded with #{get_result[:status]}:#{get_result[:body]}")
+                  UI.user_error!("Failed to fetch the newly created release, but it *has been created* successfully.")
+                end
+              }
+            ) do |get_result|
+              Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = get_result[:json]
+              UI.success("Successfully uploaded assets #{assets} to release \"#{html_url}\"")
+              return get_result[:json]
+            end
+          else
+            return json || result[:body]
+          end
+        end
+      end
+
+      def self.upload_assets(assets, upload_url_template, api_token, api_bearer)
+        assets.each do |asset|
+          self.upload(asset, upload_url_template, api_token, api_bearer)
+        end
+      end
+
+      def self.upload(asset_path, upload_url_template, api_token, api_bearer)
+        # if it's a directory, zip it first in a temp directory, because we can only upload binary files
+        absolute_path = File.absolute_path(asset_path)
+
+        # check that the asset even exists
+        UI.user_error!("Asset #{absolute_path} doesn't exist") unless File.exist?(absolute_path)
+
+        if File.directory?(absolute_path)
+          Dir.mktmpdir do |dir|
+            tmpzip = File.join(dir, File.basename(absolute_path) + '.zip')
+            sh("cd \"#{File.dirname(absolute_path)}\"; zip -r --symlinks \"#{tmpzip}\" \"#{File.basename(absolute_path)}\" 2>&1 >/dev/null")
+            self.upload_file(tmpzip, upload_url_template, api_token, api_bearer)
+          end
+        else
+          self.upload_file(absolute_path, upload_url_template, api_token, api_bearer)
+        end
+      end
+
+      def self.upload_file(file, url_template, api_token, api_bearer)
+        require 'addressable/template'
+        file_name = File.basename(file)
+        expanded_url = Addressable::Template.new(url_template).expand(name: file_name).to_s
+        headers = { 'Content-Type' => 'application/zip' } # works for all binary files
+        UI.important("Uploading #{file_name}")
+        GithubApiAction.run(
+          api_token: api_token,
+          api_bearer: api_bearer,
+          http_method: 'POST',
+          headers: headers,
+          url: expanded_url,
+          raw_body: File.read(file),
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}:#{result[:body]}")
+              UI.user_error!("Failed to upload asset #{file_name} to GitHub.")
+            end
+          }
+        ) do |result|
+          UI.success("Successfully uploaded #{file_name}.")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "This will create a new release on GitHub and upload assets for it"
+      end
+
+      def self.details
+        [
+          "Creates a new release on GitHub. You must provide your GitHub Personal token (get one from [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new)), the repository name and tag name. By default, that's `master`.",
+          "If the tag doesn't exist, one will be created on the commit or branch passed in as commitish.",
+          "Out parameters provide the release's id, which can be used for later editing and the release HTML link to GitHub. You can also specify a list of assets to be uploaded to the release with the `:upload_assets` parameter."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository_name,
+                                       env_name: "FL_SET_GITHUB_RELEASE_REPOSITORY_NAME",
+                                       description: "The path to your repo, e.g. 'fastlane/fastlane'",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.include?("github.com")
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.split('/').count != 2
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :server_url,
+                                       env_name: "FL_GITHUB_RELEASE_SERVER_URL",
+                                       description: "The server url. e.g. 'https://your.internal.github.host/api/v3' (Default: 'https://api.github.com')",
+                                       default_value: "https://api.github.com",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please include the protocol in the server url, e.g. https://your.github.server/api/v3") unless value.include?("//")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_GITHUB_RELEASE_API_TOKEN",
+                                       description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                       conflicting_options: [:api_bearer],
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       default_value: ENV["GITHUB_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :api_bearer,
+                                       env_name: "FL_GITHUB_RELEASE_API_BEARER",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       description: "Use a Bearer authorization token. Usually generated by Github Apps, e.g. GitHub Actions GITHUB_TOKEN environment variable",
+                                       conflicting_options: [:api_token],
+                                       optional: true,
+                                       default_value: nil),
+          FastlaneCore::ConfigItem.new(key: :tag_name,
+                                       env_name: "FL_SET_GITHUB_RELEASE_TAG_NAME",
+                                       description: "Pass in the tag name",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       env_name: "FL_SET_GITHUB_RELEASE_NAME",
+                                       description: "Name of this release",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :commitish,
+                                       env_name: "FL_SET_GITHUB_RELEASE_COMMITISH",
+                                       description: "Specifies the commitish value that determines where the Git tag is created from. Can be any branch or commit SHA. Unused if the Git tag already exists. Default: the repository's default branch (usually master)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :description,
+                                       env_name: "FL_SET_GITHUB_RELEASE_DESCRIPTION",
+                                       description: "Description of this release",
+                                       optional: true,
+                                       default_value: Actions.lane_context[SharedValues::FL_CHANGELOG],
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :is_draft,
+                                       env_name: "FL_SET_GITHUB_RELEASE_IS_DRAFT",
+                                       description: "Whether the release should be marked as draft",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :is_prerelease,
+                                       env_name: "FL_SET_GITHUB_RELEASE_IS_PRERELEASE",
+                                       description: "Whether the release should be marked as prerelease",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :is_generate_release_notes,
+                                       env_name: "FL_SET_GITHUB_RELEASE_IS_GENERATE_RELEASE_NOTES",
+                                       description: "Whether the name and body of this release should be generated automatically",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :upload_assets,
+                                       env_name: "FL_SET_GITHUB_RELEASE_UPLOAD_ASSETS",
+                                       description: "Path to assets to be uploaded with the release",
+                                       optional: true,
+                                       type: Array,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("upload_assets must be an Array of paths to assets") unless value.kind_of?(Array)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['SET_GITHUB_RELEASE_HTML_LINK', 'Link to your created release'],
+          ['SET_GITHUB_RELEASE_RELEASE_ID', 'Release id (useful for subsequent editing)'],
+          ['SET_GITHUB_RELEASE_JSON', 'The whole release JSON object']
+        ]
+      end
+
+      def self.return_value
+        [
+          "A hash containing all relevant information of this release",
+          "Access things like 'html_url', 'tag_name', 'name', 'body'"
+        ].join("\n")
+      end
+
+      def self.return_type
+        :hash
+      end
+
+      def self.authors
+        ["czechboy0", "tommeier"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'github_release = set_github_release(
+            repository_name: "fastlane/fastlane",
+            api_token: ENV["GITHUB_TOKEN"],
+            name: "Super New actions",
+            tag_name: "v1.22.0",
+            description: (File.read("changelog") rescue "No changelog provided"),
+            commitish: "master",
+            upload_assets: ["example_integration.ipa", "./pkg/built.gem"]
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/set_info_plist_value.rb

@@ -0,0 +1,92 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class SetInfoPlistValueAction < Action
+      def self.run(params)
+        require "plist"
+
+        begin
+          path = File.expand_path(params[:path])
+          plist = Plist.parse_xml(path)
+          if params[:subkey]
+            if plist[params[:key]]
+              plist[params[:key]][params[:subkey]] = params[:value]
+            else
+              UI.message("Key doesn't exist, going to create new one ...")
+              plist[params[:key]] = { params[:subkey] => params[:value] }
+            end
+          else
+            plist[params[:key]] = params[:value]
+          end
+          new_plist = Plist::Emit.dump(plist)
+          if params[:output_file_name]
+            output = params[:output_file_name]
+            FileUtils.mkdir_p(File.expand_path("..", output))
+            File.write(File.expand_path(output), new_plist)
+          else
+            File.write(path, new_plist)
+          end
+
+          return params[:value]
+        rescue => ex
+          UI.error(ex)
+          UI.user_error!("Unable to set value to plist file at '#{path}'")
+        end
+      end
+
+      def self.description
+        "Sets value to Info.plist of your project as native Ruby data structures"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key,
+                                       env_name: "FL_SET_INFO_PLIST_PARAM_NAME",
+                                       description: "Name of key in plist",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :subkey,
+                                       env_name: "FL_SET_INFO_PLIST_SUBPARAM_NAME",
+                                       description: "Name of subkey in plist",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :value,
+                                       env_name: "FL_SET_INFO_PLIST_PARAM_VALUE",
+                                       description: "Value to setup",
+                                       skip_type_validation: true, # allow String, Hash
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_SET_INFO_PLIST_PATH",
+                                       description: "Path to plist file you want to update",
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find plist file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :output_file_name,
+                                       env_name: "FL_SET_INFO_PLIST_OUTPUT_FILE_NAME",
+                                       description: "Path to the output file you want to generate",
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["kohtenko", "uwehollatz"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'set_info_plist_value(path: "./Info.plist", key: "CFBundleIdentifier", value: "com.krausefx.app.beta")',
+          'set_info_plist_value(path: "./MyApp-Info.plist", key: "NSAppTransportSecurity", subkey: "NSAllowsArbitraryLoads", value: true, output_file_name: "./Info.plist")'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end