fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/create_app_online.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      PRODUCE_APPLE_ID = :PRODUCE_APPLE_ID
+    end
+
+    class CreateAppOnlineAction < Action
+      def self.run(params)
+        require 'produce'
+
+        return if Helper.test?
+
+        Produce.config = params # we alread have the finished config
+
+        Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do
+          # This should be executed in the fastlane folder
+          apple_id = Produce::Manager.start_producing.to_s
+
+          Actions.lane_context[SharedValues::PRODUCE_APPLE_ID] = apple_id
+          ENV['PRODUCE_APPLE_ID'] = apple_id
+        end
+      end
+
+      def self.description
+        "Creates the given application on iTC and the Dev Portal (via _produce_)"
+      end
+
+      def self.details
+        [
+          "Create new apps on App Store Connect and Apple Developer Portal via _produce_.",
+          "If the app already exists, `create_app_online` will not do anything.",
+          "For more information about _produce_, visit its documentation page: [https://docs.fastlane.tools/actions/produce/](https://docs.fastlane.tools/actions/produce/)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'produce'
+        Produce::Options.available_options
+      end
+
+      def self.output
+        [
+          ['PRODUCE_APPLE_ID', 'The Apple ID of the newly created app. You probably need it for `deliver`']
+        ]
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'create_app_online(
+            username: "felix@krausefx.com",
+            app_identifier: "com.krausefx.app",
+            app_name: "MyApp",
+            language: "English",
+            app_version: "1.0",
+            sku: "123",
+            team_name: "SunApps GmbH" # Only necessary when in multiple teams.
+          )',
+          'produce   # alias for "create_app_online"'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_keychain.rb

@@ -0,0 +1,173 @@
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      ORIGINAL_DEFAULT_KEYCHAIN = :ORIGINAL_DEFAULT_KEYCHAIN
+    end
+
+    class CreateKeychainAction < Action
+      def self.run(params)
+        escaped_password = params[:password].shellescape
+
+        if params[:name]
+          escaped_name = params[:name].shellescape
+          keychain_path = "~/Library/Keychains/#{escaped_name}"
+        else
+          keychain_path = params[:path].shellescape
+        end
+
+        if keychain_path.nil?
+          UI.user_error!("You either have to set :name or :path")
+        end
+
+        commands = []
+
+        if !exists?(keychain_path)
+          commands << Fastlane::Actions.sh("security create-keychain -p #{escaped_password} #{keychain_path}", log: false)
+        elsif params[:require_create]
+          UI.abort_with_message!("`require_create` option passed, but found keychain '#{keychain_path}', failing create_keychain action")
+        else
+          UI.important("Found keychain '#{keychain_path}', creation skipped")
+          UI.important("If creating a new Keychain DB is required please set the `require_create` option true to cause the action to fail")
+        end
+
+        if params[:default_keychain]
+          # if there is no default keychain - setting the original will fail - silent this error
+          begin
+            Actions.lane_context[Actions::SharedValues::ORIGINAL_DEFAULT_KEYCHAIN] = Fastlane::Actions.sh("security default-keychain", log: false).strip
+          rescue
+          end
+          commands << Fastlane::Actions.sh("security default-keychain -s #{keychain_path}", log: false)
+        end
+
+        commands << Fastlane::Actions.sh("security unlock-keychain -p #{escaped_password} #{keychain_path}", log: false) if params[:unlock]
+
+        command = "security set-keychain-settings"
+        command << " -t #{params[:timeout]}" if params[:timeout]
+        command << " -l" if params[:lock_when_sleeps]
+        command << " -u" if params[:lock_after_timeout]
+        command << " #{keychain_path}"
+
+        commands << Fastlane::Actions.sh(command, log: false)
+
+        if params[:add_to_search_list]
+          keychains = list_keychains
+          expanded_path = resolved_keychain_path(keychain_path)
+          if keychains.include?(expanded_path)
+            UI.important("Found keychain '#{expanded_path}' in list-keychains, adding to search list skipped")
+          else
+            keychains << expanded_path
+            commands << Fastlane::Actions.sh("security list-keychains -s #{keychains.shelljoin}", log: false)
+          end
+        end
+
+        commands
+      end
+
+      def self.list_keychains
+        Action.sh("security list-keychains -d user").shellsplit
+      end
+
+      def self.exists?(keychain_path)
+        !resolved_keychain_path(keychain_path).nil?
+      end
+
+      # returns the expanded and resolved path for the keychain, or nil if not found
+      def self.resolved_keychain_path(keychain_path)
+        keychain_path = File.expand_path(keychain_path)
+
+        # Creating Keychains using the security
+        # CLI appends `-db` to the file name.
+        ["#{keychain_path}-db", keychain_path].each do |path|
+          return path if File.exist?(path)
+        end
+        nil
+      end
+
+      def self.description
+        "Create a new Keychain"
+      end
+
+      def self.output
+        [
+          ['ORIGINAL_DEFAULT_KEYCHAIN', 'The path to the default keychain']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       env_name: "KEYCHAIN_NAME",
+                                       description: "Keychain name",
+                                       conflicting_options: [:path],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "KEYCHAIN_PATH",
+                                       description: "Path to keychain",
+                                       is_string: true,
+                                       conflicting_options: [:name],
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "KEYCHAIN_PASSWORD",
+                                       description: "Password for the keychain",
+                                       sensitive: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :default_keychain,
+                                       description: 'Should the newly created Keychain be the new system default keychain',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :unlock,
+                                       description: 'Unlock keychain after create',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       description: 'timeout interval in seconds. Set `false` if you want to specify "no time-out"',
+                                       is_string: false,
+                                       default_value: 300),
+          FastlaneCore::ConfigItem.new(key: :lock_when_sleeps,
+                                       description: 'Lock keychain when the system sleeps',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :lock_after_timeout,
+                                       description: 'Lock keychain after timeout interval',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :add_to_search_list,
+                                       description: 'Add keychain to search list',
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :require_create,
+                                       description: 'Fail the action if the Keychain already exists',
+                                       is_string: false,
+                                       default_value: false)
+        ]
+      end
+
+      def self.authors
+        ["gin0606"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'create_keychain(
+            name: "KeychainName",
+            default_keychain: true,
+            unlock: true,
+            timeout: 3600,
+            lock_when_sleeps: true
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_pull_request.rb

@@ -0,0 +1,190 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      CREATE_PULL_REQUEST_HTML_URL = :CREATE_PULL_REQUEST_HTML_URL
+    end
+
+    class CreatePullRequestAction < Action
+      def self.run(params)
+        UI.message("Creating new pull request from '#{params[:head]}' to branch '#{params[:base]}' of '#{params[:repo]}'")
+
+        payload = {
+          'title' => params[:title],
+          'head' => params[:head],
+          'base' => params[:base]
+        }
+        payload['body'] = params[:body] if params[:body]
+
+        GithubApiAction.run(
+          server_url: params[:api_url],
+          api_token: params[:api_token],
+          http_method: 'POST',
+          path: "repos/#{params[:repo]}/pulls",
+          body: payload,
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}: #{result[:body]}")
+              return nil
+            end
+          }
+        ) do |result|
+          json = result[:json]
+          number = json['number']
+          html_url = json['html_url']
+          UI.success("Successfully created pull request ##{number}. You can see it at '#{html_url}'")
+
+          # Add labels to pull request
+          add_labels(params, number) if params[:labels]
+
+          # Add assignees to pull request
+          add_assignees(params, number) if params[:assignees]
+
+          Actions.lane_context[SharedValues::CREATE_PULL_REQUEST_HTML_URL] = html_url
+          return html_url
+        end
+      end
+
+      def self.add_labels(params, number)
+        payload = {
+          'labels' => params[:labels]
+        }
+        GithubApiAction.run(
+          server_url: params[:api_url],
+          api_token: params[:api_token],
+          http_method: 'PATCH',
+          path: "repos/#{params[:repo]}/issues/#{number}",
+          body: payload,
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}: #{result[:body]}")
+              return nil
+            end
+          }
+        )
+      end
+
+      def self.add_assignees(params, number)
+        payload = {
+          'assignees' => params[:assignees]
+        }
+        GithubApiAction.run(
+          server_url: params[:api_url],
+          api_token: params[:api_token],
+          http_method: 'POST',
+          path: "repos/#{params[:repo]}/issues/#{number}/assignees",
+          body: payload,
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}: #{result[:body]}")
+              return nil
+            end
+          }
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "This will create a new pull request on GitHub"
+      end
+
+      def self.output
+        [
+          ['CREATE_PULL_REQUEST_HTML_URL', 'The HTML URL to the created pull request']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "GITHUB_PULL_REQUEST_API_TOKEN",
+                                       description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       default_value: ENV["GITHUB_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo,
+                                       env_name: "GITHUB_PULL_REQUEST_REPO",
+                                       description: "The name of the repository you want to submit the pull request to",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :title,
+                                       env_name: "GITHUB_PULL_REQUEST_TITLE",
+                                       description: "The title of the pull request",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :body,
+                                       env_name: "GITHUB_PULL_REQUEST_BODY",
+                                       description: "The contents of the pull request",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :labels,
+                                       env_name: "GITHUB_PULL_REQUEST_LABELS",
+                                       description: "The labels for the pull request",
+                                       type: Array,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :head,
+                                       env_name: "GITHUB_PULL_REQUEST_HEAD",
+                                       description: "The name of the branch where your changes are implemented (defaults to the current branch name)",
+                                       is_string: true,
+                                       code_gen_sensitive: true,
+                                       default_value: Actions.git_branch,
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :base,
+                                       env_name: "GITHUB_PULL_REQUEST_BASE",
+                                       description: "The name of the branch you want your changes pulled into (defaults to `master`)",
+                                       is_string: true,
+                                       default_value: 'master',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :api_url,
+                                       env_name: "GITHUB_PULL_REQUEST_API_URL",
+                                       description: "The URL of GitHub API - used when the Enterprise (default to `https://api.github.com`)",
+                                       is_string: true,
+                                       code_gen_default_value: 'https://api.github.com',
+                                       default_value: 'https://api.github.com',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :assignees,
+                                       env_name: "GITHUB_PULL_REQUEST_ASSIGNEES",
+                                       description: "The assignees for the pull request",
+                                       type: Array,
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        ["seei", "tommeier", "marumemomo"]
+      end
+
+      def self.is_supported?(platform)
+        return true
+      end
+
+      def self.return_value
+        "The pull request URL when successful"
+      end
+
+      def self.example_code
+        [
+          'create_pull_request(
+            api_token: "secret",                # optional, defaults to ENV["GITHUB_API_TOKEN"]
+            repo: "fastlane/fastlane",
+            title: "Amazing new feature",
+            head: "my-feature",                 # optional, defaults to current branch name
+            base: "master",                     # optional, defaults to "master"
+            body: "Please pull this in!",       # optional
+            api_url: "http://yourdomain/api/v3" # optional, for GitHub Enterprise, defaults to "https://api.github.com"
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/danger.rb

@@ -0,0 +1,124 @@
+module Fastlane
+  module Actions
+    class DangerAction < Action
+      def self.run(params)
+        Actions.verify_gem!('danger')
+        cmd = []
+
+        cmd << 'bundle exec' if params[:use_bundle_exec] && shell_out_should_use_bundle_exec?
+        cmd << 'danger'
+        cmd << '--verbose' if params[:verbose]
+
+        danger_id = params[:danger_id]
+        dangerfile = params[:dangerfile]
+        base = params[:base]
+        head = params[:head]
+        pr = params[:pr]
+        cmd << "--danger_id=#{danger_id}" if danger_id
+        cmd << "--dangerfile=#{dangerfile}" if dangerfile
+        cmd << "--fail-on-errors=true" if params[:fail_on_errors]
+        cmd << "--new-comment" if params[:new_comment]
+        cmd << "--base=#{base}" if base
+        cmd << "--head=#{head}" if head
+        cmd << "pr #{pr}" if pr
+
+        ENV['DANGER_GITHUB_API_TOKEN'] = params[:github_api_token] if params[:github_api_token]
+
+        Actions.sh(cmd.join(' '))
+      end
+
+      def self.description
+        "Runs `danger` for the project"
+      end
+
+      def self.details
+        [
+          "Formalize your Pull Request etiquette.",
+          "More information: [https://github.com/danger/danger](https://github.com/danger/danger)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :use_bundle_exec,
+                                       env_name: "FL_DANGER_USE_BUNDLE_EXEC",
+                                       description: "Use bundle exec when there is a Gemfile presented",
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_DANGER_VERBOSE",
+                                       description: "Show more debugging information",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :danger_id,
+                                       env_name: "FL_DANGER_ID",
+                                       description: "The identifier of this Danger instance",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :dangerfile,
+                                       env_name: "FL_DANGER_DANGERFILE",
+                                       description: "The location of your Dangerfile",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :github_api_token,
+                                       env_name: "FL_DANGER_GITHUB_API_TOKEN",
+                                       description: "GitHub API token for danger",
+                                       sensitive: true,
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :fail_on_errors,
+                                       env_name: "FL_DANGER_FAIL_ON_ERRORS",
+                                       description: "Should always fail the build process, defaults to false",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :new_comment,
+                                       env_name: "FL_DANGER_NEW_COMMENT",
+                                       description: "Makes Danger post a new comment instead of editing its previous one",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :base,
+                                       env_name: "FL_DANGER_BASE",
+                                       description: "A branch/tag/commit to use as the base of the diff. [master|dev|stable]",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :head,
+                                       env_name: "FL_DANGER_HEAD",
+                                       description: "A branch/tag/commit to use as the head. [master|dev|stable]",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :pr,
+                                       env_name: "FL_DANGER_PR",
+                                       description: "Run danger on a specific pull request. e.g. \"https://github.com/danger/danger/pull/518\"",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'danger',
+          'danger(
+            danger_id: "unit-tests",
+            dangerfile: "tests/MyOtherDangerFile",
+            github_api_token: ENV["GITHUB_API_TOKEN"],
+            verbose: true
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+    end
+  end
+end