fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/capture_ios_screenshots.rb

@@ -0,0 +1,61 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SNAPSHOT_SCREENSHOTS_PATH = :SNAPSHOT_SCREENSHOTS_PATH
+    end
+
+    class CaptureIosScreenshotsAction < Action
+      def self.run(params)
+        return nil unless Helper.mac?
+        require 'snapshot'
+
+        Snapshot.config = params
+        Snapshot::DependencyChecker.check_simulators
+        Snapshot::Runner.new.work
+
+        Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] = File.expand_path(params[:output_directory]) # absolute URL
+
+        true
+      end
+
+      def self.description
+        "Generate new localized screenshots on multiple devices (via _snapshot_)"
+      end
+
+      def self.available_options
+        return [] unless Helper.mac?
+        require 'snapshot'
+        Snapshot::Options.available_options
+      end
+
+      def self.output
+        [
+          ['SNAPSHOT_SCREENSHOTS_PATH', 'The path to the screenshots']
+        ]
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'capture_ios_screenshots',
+          'snapshot # alias for "capture_ios_screenshots"',
+          'capture_ios_screenshots(
+            skip_open_summary: true,
+            clean: true
+          )'
+        ]
+      end
+
+      def self.category
+        :screenshots
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/capture_screenshots.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/capture_ios_screenshots'
+    class CaptureScreenshotsAction < CaptureIosScreenshotsAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `capture_ios_screenshots` action"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/carthage.rb

@@ -0,0 +1,215 @@
+module Fastlane
+  module Actions
+    class CarthageAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.run(params)
+        validate(params)
+
+        cmd = [params[:executable]]
+        command_name = params[:command]
+        cmd << command_name
+
+        if command_name == "archive" && params[:frameworks].count > 0
+          cmd.concat(params[:frameworks])
+        elsif ["update", "build", "bootstrap"].include?(command_name) && params[:dependencies].count > 0
+          cmd.concat(params[:dependencies])
+        end
+
+        cmd << "--output #{params[:output]}" if params[:output]
+        cmd << "--use-ssh" if params[:use_ssh]
+        cmd << "--use-submodules" if params[:use_submodules]
+        cmd << "--no-use-binaries" if params[:use_binaries] == false
+        cmd << "--no-build" if params[:no_build] == true
+        cmd << "--no-skip-current" if params[:no_skip_current] == true
+        cmd << "--verbose" if params[:verbose] == true
+        cmd << "--platform #{params[:platform]}" if params[:platform]
+        cmd << "--configuration #{params[:configuration]}" if params[:configuration]
+        cmd << "--derived-data #{params[:derived_data].shellescape}" if params[:derived_data]
+        cmd << "--toolchain #{params[:toolchain]}" if params[:toolchain]
+        cmd << "--project-directory #{params[:project_directory]}" if params[:project_directory]
+        cmd << "--cache-builds" if params[:cache_builds]
+        cmd << "--new-resolver" if params[:new_resolver]
+        cmd << "--log-path #{params[:log_path]}" if params[:log_path]
+
+        Actions.sh(cmd.join(' '))
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.validate(params)
+        command_name = params[:command]
+        if command_name != "archive" && params[:frameworks].count > 0
+          UI.user_error!("Frameworks option is available only for 'archive' command.")
+        end
+        if command_name != "archive" && params[:output]
+          UI.user_error!("Output option is available only for 'archive' command.")
+        end
+
+        if params[:log_path] && !%w(build bootstrap update).include?(command_name)
+          UI.user_error!("Log path option is available only for 'build', 'bootstrap', and 'update' command.")
+        end
+      end
+
+      def self.description
+        "Runs `carthage` for your project"
+      end
+
+      def self.available_commands
+        %w(build bootstrap update archive)
+      end
+
+      def self.available_platforms
+        %w(all iOS Mac tvOS watchOS)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :command,
+                                       env_name: "FL_CARTHAGE_COMMAND",
+                                       description: "Carthage command (one of: #{available_commands.join(', ')})",
+                                       default_value: 'bootstrap',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid command. Use one of the following: #{available_commands.join(', ')}") unless available_commands.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :dependencies,
+                                       description: "Carthage dependencies to update, build or bootstrap",
+                                       default_value: [],
+                                       is_string: false,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :use_ssh,
+                                       env_name: "FL_CARTHAGE_USE_SSH",
+                                       description: "Use SSH for downloading GitHub repositories",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_submodules,
+                                       env_name: "FL_CARTHAGE_USE_SUBMODULES",
+                                       description: "Add dependencies as Git submodules",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_binaries,
+                                       env_name: "FL_CARTHAGE_USE_BINARIES",
+                                       description: "Check out dependency repositories even when prebuilt frameworks exist",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_build,
+                                       env_name: "FL_CARTHAGE_NO_BUILD",
+                                       description: "When bootstrapping Carthage do not build",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_skip_current,
+                                       env_name: "FL_CARTHAGE_NO_SKIP_CURRENT",
+                                       description: "Don't skip building the Carthage project (in addition to its dependencies)",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :derived_data,
+                                       env_name: "FL_CARTHAGE_DERIVED_DATA",
+                                       description: "Use derived data folder at path",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_CARTHAGE_VERBOSE",
+                                       description: "Print xcodebuild output inline",
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "FL_CARTHAGE_PLATFORM",
+                                       description: "Define which platform to build for",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         value.split(',').each do |platform|
+                                           UI.user_error!("Please pass a valid platform. Use one of the following: #{available_platforms.join(', ')}") unless available_platforms.map(&:downcase).include?(platform.downcase)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :cache_builds,
+                                       env_name: "FL_CARTHAGE_CACHE_BUILDS",
+                                       description: "By default Carthage will rebuild a dependency regardless of whether it's the same resolved version as before. Passing the --cache-builds will cause carthage to avoid rebuilding a dependency if it can",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :frameworks,
+                                       description: "Framework name or names to archive, could be applied only along with the archive command",
+                                       default_value: [],
+                                       is_string: false,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :output,
+                                       description: "Output name for the archive, could be applied only along with the archive command. Use following format *.framework.zip",
+                                       is_string: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid string for output. Use following format *.framework.zip") unless value.end_with?("framework.zip")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       env_name: "FL_CARTHAGE_CONFIGURATION",
+                                       description: "Define which build configuration to use when building",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         if value.chomp(' ').empty?
+                                           UI.user_error!("Please pass a valid build configuration. You can review the list of configurations for this project using the command: xcodebuild -list")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :toolchain,
+                                       env_name: "FL_CARTHAGE_TOOLCHAIN",
+                                       description: "Define which xcodebuild toolchain to use when building",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :project_directory,
+                                       env_name: "FL_CARTHAGE_PROJECT_DIRECTORY",
+                                       description: "Define the directory containing the Carthage project",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :new_resolver,
+                                       env_name: "FL_CARTHAGE_NEW_RESOLVER",
+                                       description: "Use new resolver when resolving dependency graph",
+                                       is_string: false,
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :log_path,
+                                       env_name: "FL_CARTHAGE_LOG_PATH",
+                                       description: "Path to the xcode build output",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :executable,
+                                       env_name: "FL_CARTHAGE_EXECUTABLE",
+                                       description: "Path to the `carthage` executable on your machine",
+                                       default_value: 'carthage')
+        ]
+      end
+
+      def self.example_code
+        [
+          'carthage',
+          'carthage(
+            frameworks: ["MyFramework1", "MyFramework2"],   # Specify which frameworks to archive (only for the archive command)
+            output: "MyFrameworkBundle.framework.zip",      # Specify the output archive name (only for the archive command)
+            command: "bootstrap",                           # One of: build, bootstrap, update, archive. (default: bootstrap)
+            dependencies: ["Alamofire", "Notice"],          # Specify which dependencies to update or build (only for update, build and bootstrap commands)
+            use_ssh: false,                                 # Use SSH for downloading GitHub repositories.
+            use_submodules: false,                          # Add dependencies as Git submodules.
+            use_binaries: true,                             # Check out dependency repositories even when prebuilt frameworks exist
+            no_build: false,                                # When bootstrapping Carthage do not build
+            no_skip_current: false,                         # Don\'t skip building the current project (only for frameworks)
+            verbose: false,                                 # Print xcodebuild output inline
+            platform: "all",                                # Define which platform to build for (one of ‘all’, ‘Mac’, ‘iOS’, ‘watchOS’, ‘tvOS‘, or comma-separated values of the formers except for ‘all’)
+            configuration: "Release",                       # Build configuration to use when building
+            cache_builds: true,                             # By default Carthage will rebuild a dependency regardless of whether its the same resolved version as before.
+            toolchain: "com.apple.dt.toolchain.Swift_2_3",  # Specify the xcodebuild toolchain
+            new_resolver: false,                            # Use the new resolver to resolve depdendency graph
+            log_path: "carthage.log"                        # Path to the xcode build output
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.authors
+        ["bassrock", "petester42", "jschmid", "JaviSoto", "uny", "phatblat", "bfcrampton", "antondomashnev", "gbrhaz"]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/cert.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/get_certificates'
+    class CertAction < GetCertificatesAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `get_certificates` action"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/changelog_from_git_commits.rb

@@ -0,0 +1,197 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      FL_CHANGELOG = :FL_CHANGELOG
+    end
+
+    class ChangelogFromGitCommitsAction < Action
+      def self.run(params)
+        if params[:commits_count]
+          UI.success("Collecting the last #{params[:commits_count]} Git commits")
+        else
+          if params[:between]
+            if params[:between].kind_of?(String) && params[:between].include?(",") # :between is string
+              from, to = params[:between].split(",", 2)
+            elsif params[:between].kind_of?(Array)
+              from, to = params[:between]
+            end
+          else
+            from = Actions.last_git_tag_name(params[:match_lightweight_tag], params[:tag_match_pattern])
+            UI.verbose("Found the last Git tag: #{from}")
+            to = 'HEAD'
+          end
+          UI.success("Collecting Git commits between #{from} and #{to}")
+        end
+
+        # Normally it is not good practice to take arbitrary input and convert it to a symbol
+        # because prior to Ruby 2.2, symbols are never garbage collected. However, we've
+        # already validated that the input matches one of our allowed values, so this is OK
+        merge_commit_filtering = params[:merge_commit_filtering].to_sym
+
+        # We want to be specific and exclude nil for this comparison
+        if params[:include_merges] == false
+          merge_commit_filtering = :exclude_merges
+        end
+
+        params[:path] = './' unless params[:path]
+
+        Dir.chdir(params[:path]) do
+          if params[:commits_count]
+            changelog = Actions.git_log_last_commits(params[:pretty], params[:commits_count], merge_commit_filtering, params[:date_format], params[:ancestry_path])
+          else
+            changelog = Actions.git_log_between(params[:pretty], from, to, merge_commit_filtering, params[:date_format], params[:ancestry_path])
+          end
+
+          changelog = changelog.gsub("\n\n", "\n") if changelog # as there are duplicate newlines
+          Actions.lane_context[SharedValues::FL_CHANGELOG] = changelog
+
+          if params[:quiet] == false
+            puts("")
+            puts(changelog)
+            puts("")
+          end
+
+          changelog
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Collect git commit messages into a changelog"
+      end
+
+      def self.details
+        "By default, messages will be collected back to the last tag, but the range can be controlled"
+      end
+
+      def self.output
+        [
+          ['FL_CHANGELOG', 'The changelog string generated from the collected git commit messages']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :between,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_BETWEEN',
+                                       description: 'Array containing two Git revision values between which to collect messages, you mustn\'t use it with :commits_count key at the same time',
+                                       optional: true,
+                                       is_string: false,
+                                       conflicting_options: [:commits_count],
+                                       verify_block: proc do |value|
+                                         if value.kind_of?(String)
+                                           UI.user_error!(":between must contain comma") unless value.include?(',')
+                                         else
+                                           UI.user_error!(":between must be of type array") unless value.kind_of?(Array)
+                                           UI.user_error!(":between must not contain nil values") if value.any?(&:nil?)
+                                           UI.user_error!(":between must be an array of size 2") unless (value || []).size == 2
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :commits_count,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_COUNT',
+                                       description: 'Number of commits to include in changelog, you mustn\'t use it with :between key at the same time',
+                                       optional: true,
+                                       is_string: false,
+                                       conflicting_options: [:between],
+                                       type: Integer,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(":commits_count must be >= 1") unless value.to_i >= 1
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_PATH',
+                                       description: 'Path of the git repository',
+                                       optional: true,
+                                       default_value: './'),
+          FastlaneCore::ConfigItem.new(key: :pretty,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_PRETTY',
+                                       description: 'The format applied to each commit while generating the collected value',
+                                       optional: true,
+                                       default_value: '%B',
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :date_format,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_DATE_FORMAT',
+                                       description: 'The date format applied to each commit while generating the collected value',
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :ancestry_path,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_ANCESTRY_PATH',
+                                       description: 'Whether or not to use ancestry-path param',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :tag_match_pattern,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_TAG_MATCH_PATTERN',
+                                       description: 'A glob(7) pattern to match against when finding the last git tag',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :match_lightweight_tag,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_MATCH_LIGHTWEIGHT_TAG',
+                                       description: 'Whether or not to match a lightweight tag when searching for the last one',
+                                       optional: true,
+                                       default_value: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_TAG_QUIET',
+                                       description: 'Whether or not to disable changelog output',
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :include_merges,
+                                       deprecated: "Use `:merge_commit_filtering` instead",
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_INCLUDE_MERGES',
+                                       description: "Whether or not to include any commits that are merges",
+                                       optional: true,
+                                       is_string: false,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.important("The :include_merges option is deprecated. Please use :merge_commit_filtering instead") unless value.nil?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :merge_commit_filtering,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_MERGE_COMMIT_FILTERING',
+                                       description: "Controls inclusion of merge commits when collecting the changelog. Valid values: #{GIT_MERGE_COMMIT_FILTERING_OPTIONS.map { |o| "`:#{o}`" }.join(', ')}",
+                                       optional: true,
+                                       default_value: 'include_merges',
+                                       verify_block: proc do |value|
+                                         matches_option = GIT_MERGE_COMMIT_FILTERING_OPTIONS.any? { |opt| opt.to_s == value }
+                                         UI.user_error!("Valid values for :merge_commit_filtering are #{GIT_MERGE_COMMIT_FILTERING_OPTIONS.map { |o| "'#{o}'" }.join(', ')}") unless matches_option
+                                       end)
+        ]
+      end
+
+      def self.return_value
+        "Returns a String containing your formatted git commits"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.author
+        ['mfurtak', 'asfalcone', 'SiarheiFedartsou', 'allewun']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'changelog_from_git_commits',
+          'changelog_from_git_commits(
+            between: ["7b092b3", "HEAD"],            # Optional, lets you specify a revision/tag range between which to collect commit info
+            pretty: "- (%ae) %s",                    # Optional, lets you provide a custom format to apply to each commit when generating the changelog text
+            date_format: "short",                    # Optional, lets you provide an additional date format to dates within the pretty-formatted string
+            match_lightweight_tag: false,            # Optional, lets you ignore lightweight (non-annotated) tags when searching for the last tag
+            merge_commit_filtering: "exclude_merges" # Optional, lets you filter out merge commits
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end