fastlane 2.179.0 → 2.183.0

data/fastlane/lib/fastlane/actions/notification.rb

@@ -13,7 +13,7 @@ module Fastlane
           app_icon: :appIcon,
           content_image: :contentImage
         }
-        options = Hash[options.map { |k, v| [option_map.fetch(k, k), v] }]
+        options = options.transform_keys { |k| option_map.fetch(k, k) }
         TerminalNotifier.notify(message, options)
       end
 

data/fastlane/lib/fastlane/actions/slack.rb

@@ -1,70 +1,178 @@
+require 'fastlane/notification/slack'
+
 # rubocop:disable Style/CaseEquality
 # rubocop:disable Style/MultilineTernaryOperator
 # rubocop:disable Style/NestedTernaryOperator
 module Fastlane
   module Actions
     class SlackAction < Action
-      def self.is_supported?(platform)
-        true
-      end
+      class Runner
+        def initialize(slack_url)
+          @notifier = Fastlane::Notification::Slack.new(slack_url)
+        end
 
-      # As there is a text limit in the notifications, we are
-      # usually interested in the last part of the message
-      # e.g. for tests
-      def self.trim_message(message)
-        # We want the last 7000 characters, instead of the first 7000, as the error is at the bottom
-        start_index = [message.length - 7000, 0].max
-        message = message[start_index..-1]
-        # We want line breaks to be shown on slack output so we replace
-        # input non-interpreted line break with interpreted line break
-        message.gsub('\n', "\n")
-      end
+        def run(options)
+          options[:message] = self.class.trim_message(options[:message].to_s || '')
+          options[:message] = Fastlane::Notification::Slack::LinkConverter.convert(options[:message])
 
-      def self.run(options)
-        require 'slack-notifier'
+          options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
 
-        options[:message] = self.trim_message(options[:message].to_s || '')
-        options[:message] = Slack::Notifier::Util::LinkFormatter.format(options[:message])
+          if options[:channel].to_s.length > 0
+            channel = options[:channel]
+            channel = ('#' + options[:channel]) unless ['#', '@'].include?(channel[0]) # send message to channel by default
+          end
 
-        options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
+          username = options[:use_webhook_configured_username_and_icon] ? nil : options[:username]
 
-        if options[:channel].to_s.length > 0
-          channel = options[:channel]
-          channel = ('#' + options[:channel]) unless ['#', '@'].include?(channel[0]) # send message to channel by default
+          slack_attachment = self.class.generate_slack_attachments(options)
+          link_names = options[:link_names]
+          icon_url = options[:use_webhook_configured_username_and_icon] ? nil : options[:icon_url]
+
+          post_message(
+            channel: channel,
+            username: username,
+            attachments: [slack_attachment],
+            link_names: link_names,
+            icon_url: icon_url,
+            fail_on_error: options[:fail_on_error]
+          )
         end
 
-        username = options[:use_webhook_configured_username_and_icon] ? nil : options[:username]
+        def post_message(channel:, username:, attachments:, link_names:, icon_url:, fail_on_error:)
+          @notifier.post_to_legacy_incoming_webhook(
+            channel: channel,
+            username: username,
+            link_names: link_names,
+            icon_url: icon_url,
+            attachments: attachments
+          )
+          UI.success('Successfully sent Slack notification')
+        rescue => error
+          UI.error("Exception: #{error}")
+          message = "Error pushing Slack message, maybe the integration has no permission to post on this channel? Try removing the channel parameter in your Fastfile, this is usually caused by a misspelled or changed group/channel name or an expired SLACK_URL"
+          if fail_on_error
+            UI.user_error!(message)
+          else
+            UI.error(message)
+          end
+        end
 
-        notifier = Slack::Notifier.new(options[:slack_url], channel: channel, username: username)
+        # As there is a text limit in the notifications, we are
+        # usually interested in the last part of the message
+        # e.g. for tests
+        def self.trim_message(message)
+          # We want the last 7000 characters, instead of the first 7000, as the error is at the bottom
+          start_index = [message.length - 7000, 0].max
+          message = message[start_index..-1]
+          # We want line breaks to be shown on slack output so we replace
+          # input non-interpreted line break with interpreted line break
+          message.gsub('\n', "\n")
+        end
 
-        link_names = options[:link_names]
+        def self.generate_slack_attachments(options)
+          color = (options[:success] ? 'good' : 'danger')
+          should_add_payload = ->(payload_name) { options[:default_payloads].map(&:to_sym).include?(payload_name.to_sym) }
 
-        icon_url = options[:use_webhook_configured_username_and_icon] ? nil : options[:icon_url]
+          slack_attachment = {
+            fallback: options[:message],
+            text: options[:message],
+            pretext: options[:pretext],
+            color: color,
+            mrkdwn_in: ["pretext", "text", "fields", "message"],
+            fields: []
+          }
 
-        slack_attachment = generate_slack_attachments(options)
+          # custom user payloads
+          slack_attachment[:fields] += options[:payload].map do |k, v|
+            {
+              title: k.to_s,
+              value: Fastlane::Notification::Slack::LinkConverter.convert(v.to_s),
+              short: false
+            }
+          end
 
-        return [notifier, slack_attachment] if Helper.test? # tests will verify the slack attachments and other properties
+          # Add the lane to the Slack message
+          # This might be nil, if slack is called as "one-off" action
+          if should_add_payload[:lane] && Actions.lane_context[Actions::SharedValues::LANE_NAME]
+            slack_attachment[:fields] << {
+              title: 'Lane',
+              value: Actions.lane_context[Actions::SharedValues::LANE_NAME],
+              short: true
+            }
+          end
 
-        begin
-          results = notifier.ping('', link_names: link_names, icon_url: icon_url, attachments: [slack_attachment])
-        rescue => exception
-          UI.error("Exception: #{exception}")
-        ensure
-          result = results.first if results
-          if !result.nil? && result.code.to_i == 200
-            UI.success('Successfully sent Slack notification')
-          else
-            UI.verbose(result) unless result.nil?
-            message = "Error pushing Slack message, maybe the integration has no permission to post on this channel? Try removing the channel parameter in your Fastfile, this is usually caused by a misspelled or changed group/channel name or an expired SLACK_URL"
-            if options[:fail_on_error]
-              UI.user_error!(message)
+          # test_result
+          if should_add_payload[:test_result]
+            slack_attachment[:fields] << {
+              title: 'Result',
+              value: (options[:success] ? 'Success' : 'Error'),
+              short: true
+            }
+          end
+
+          # git branch
+          if Actions.git_branch && should_add_payload[:git_branch]
+            slack_attachment[:fields] << {
+              title: 'Git Branch',
+              value: Actions.git_branch,
+              short: true
+            }
+          end
+
+          # git_author
+          if Actions.git_author_email && should_add_payload[:git_author]
+            if FastlaneCore::Env.truthy?('FASTLANE_SLACK_HIDE_AUTHOR_ON_SUCCESS') && options[:success]
+            # We only show the git author if the build failed
             else
-              UI.error(message)
+              slack_attachment[:fields] << {
+                title: 'Git Author',
+                value: Actions.git_author_email,
+                short: true
+              }
             end
           end
+
+          # last_git_commit
+          if Actions.last_git_commit_message && should_add_payload[:last_git_commit]
+            slack_attachment[:fields] << {
+              title: 'Git Commit',
+              value: Actions.last_git_commit_message,
+              short: false
+            }
+          end
+
+          # last_git_commit_hash
+          if Actions.last_git_commit_hash(true) && should_add_payload[:last_git_commit_hash]
+            slack_attachment[:fields] << {
+              title: 'Git Commit Hash',
+              value: Actions.last_git_commit_hash(short: true),
+              short: false
+            }
+          end
+
+          # merge additional properties
+          deep_merge(slack_attachment, options[:attachment_properties])
+        end
+
+        # Adapted from https://stackoverflow.com/a/30225093/158525
+        def self.deep_merge(a, b)
+          merger = proc do |key, v1, v2|
+            Hash === v1 && Hash === v2 ?
+              v1.merge(v2, &merger) : Array === v1 && Array === v2 ?
+                                        v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2
+          end
+          a.merge(b, &merger)
         end
       end
 
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.run(options)
+        Runner.new(options[:slack_url]).run(options)
+      end
+
       def self.description
         "Send a success/error message to your [Slack](https://slack.com) group"
       end
@@ -185,99 +293,13 @@ module Fastlane
       # @!group Helper
       #####################################################
 
-      def self.generate_slack_attachments(options)
-        color = (options[:success] ? 'good' : 'danger')
-        should_add_payload = ->(payload_name) { options[:default_payloads].map(&:to_sym).include?(payload_name.to_sym) }
-
-        slack_attachment = {
-          fallback: options[:message],
-          text: options[:message],
-          pretext: options[:pretext],
-          color: color,
-          mrkdwn_in: ["pretext", "text", "fields", "message"],
-          fields: []
-        }
-
-        # custom user payloads
-        slack_attachment[:fields] += options[:payload].map do |k, v|
-          {
-            title: k.to_s,
-            value: Slack::Notifier::Util::LinkFormatter.format(v.to_s),
-            short: false
-          }
-        end
-
-        # Add the lane to the Slack message
-        # This might be nil, if slack is called as "one-off" action
-        if should_add_payload[:lane] && Actions.lane_context[Actions::SharedValues::LANE_NAME]
-          slack_attachment[:fields] << {
-            title: 'Lane',
-            value: Actions.lane_context[Actions::SharedValues::LANE_NAME],
-            short: true
-          }
-        end
-
-        # test_result
-        if should_add_payload[:test_result]
-          slack_attachment[:fields] << {
-            title: 'Result',
-            value: (options[:success] ? 'Success' : 'Error'),
-            short: true
-          }
-        end
-
-        # git branch
-        if Actions.git_branch && should_add_payload[:git_branch]
-          slack_attachment[:fields] << {
-            title: 'Git Branch',
-            value: Actions.git_branch,
-            short: true
-          }
-        end
-
-        # git_author
-        if Actions.git_author_email && should_add_payload[:git_author]
-          if FastlaneCore::Env.truthy?('FASTLANE_SLACK_HIDE_AUTHOR_ON_SUCCESS') && options[:success]
-            # We only show the git author if the build failed
-          else
-            slack_attachment[:fields] << {
-              title: 'Git Author',
-              value: Actions.git_author_email,
-              short: true
-            }
-          end
-        end
-
-        # last_git_commit
-        if Actions.last_git_commit_message && should_add_payload[:last_git_commit]
-          slack_attachment[:fields] << {
-            title: 'Git Commit',
-            value: Actions.last_git_commit_message,
-            short: false
-          }
-        end
-
-        # last_git_commit_hash
-        if Actions.last_git_commit_hash(true) && should_add_payload[:last_git_commit_hash]
-          slack_attachment[:fields] << {
-            title: 'Git Commit Hash',
-            value: Actions.last_git_commit_hash(short: true),
-            short: false
-          }
-        end
-
-        # merge additional properties
-        deep_merge(slack_attachment, options[:attachment_properties])
+      def self.trim_message(message)
+        Runner.trim_message(message)
       end
 
-      # Adapted from https://stackoverflow.com/a/30225093/158525
-      def self.deep_merge(a, b)
-        merger = proc do |key, v1, v2|
-          Hash === v1 && Hash === v2 ?
-                 v1.merge(v2, &merger) : Array === v1 && Array === v2 ?
-                   v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2
-        end
-        a.merge(b, &merger)
+      def self.generate_slack_attachments(options)
+        UI.deprecated('`Fastlane::Actions::Slack.generate_slack_attachments` is subject to be removed as Slack recommends migrating `attachments` to Block Kit. fastlane will also follow the same direction.')
+        Runner.generate_slack_attachments(options)
       end
     end
   end

data/fastlane/lib/fastlane/actions/sourcedocs.rb

@@ -0,0 +1,164 @@
+module Fastlane
+  module Actions
+    class SourcedocsAction < Action
+      def self.run(params)
+        UI.user_error!("You have to install sourcedocs using `brew install sourcedocs`") if `which sourcedocs`.to_s.length == 0 && !Helper.test?
+
+        command =  "sourcedocs generate"
+        command << " --all-modules" if params[:all_modules]
+        command << " --spm-module #{params[:spm_module]}" unless params[:spm_module].nil?
+        command << " --module-name #{params[:module_name]}" unless params[:module_name].nil?
+        command << " --link-beginning #{params[:link_beginning]}" unless params[:link_beginning].nil?
+        command << " --link-ending #{params[:link_ending]}" unless params[:link_ending].nil?
+        command << " --output-folder #{params[:output_folder]}" unless params[:output_folder].nil?
+        command << " --min-acl #{params[:min_acl]}" unless params[:min_acl].nil?
+        command << " --module-name-path" if params[:module_name_path]
+        command << " --clean" if params[:clean]
+        command << " --collapsible" if params[:collapsible]
+        command << " --table-of-contents" if params[:table_of_contents]
+        command << " --reproducible-docs" if params[:reproducible]
+        unless params[:scheme].nil?
+          command << " -- -scheme #{params[:scheme]}"
+          command << " -sdk #{params[:sdk_platform]}" unless params[:sdk_platform].nil?
+        end
+        Actions.sh(command)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Generate docs using SourceDocs"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :all_modules,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_ALL_MODULES',
+            description: 'Generate documentation for all modules in a Swift package',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :spm_module,
+            env_name: 'FL_SOURCEDOCS_SPM_MODULE',
+            description: 'Generate documentation for Swift Package Manager module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME',
+            description: 'Generate documentation for a Swift module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_beginning,
+            env_name: 'FL_SOURCEDOCS_LINK_BEGINNING',
+            description: 'The text to begin links with',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_ending,
+            env_name: 'FL_SOURCEDOCS_LINK_ENDING',
+            description: 'The text to end links with (default: .md)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :output_folder,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_FOLDER',
+            description: 'Output directory to clean (default: Documentation/Reference)',
+            type: String,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :min_acl,
+            env_name: 'FL_SOURCEDOCS_MIN_ACL',
+            description: 'Access level to include in documentation [private, fileprivate, internal, public, open] (default: public)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name_path,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME_PATH',
+            description: 'Include the module name as part of the output folder path',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :clean,
+            env_name: 'FL_SOURCEDOCS_CLEAN',
+            description: 'Delete output folder before generating documentation',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :collapsible,
+            env_name: 'FL_SOURCEDOCS_COLLAPSIBLE',
+            description: 'Put methods, properties and enum cases inside collapsible blocks',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :table_of_contents,
+            env_name: 'FL_SOURCEDOCS_TABLE_OF_CONTENT',
+            description: 'Generate a table of contents with properties and methods for each type',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :reproducible,
+            env_name: 'FL_SOURCEDOCS_REPRODUCIBLE',
+            description: 'Generate documentation that is reproducible: only depends on the sources',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :scheme,
+            env_name: 'FL_SOURCEDOCS_SCHEME',
+            description: 'Create documentation for specific scheme',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :sdk_platform,
+            env_name: 'FL_SOURCEDOCS_SDK_PlATFORM',
+            description: 'Create documentation for specific sdk platform',
+            type: String,
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["Kukurijek"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "sourcedocs(output_folder: 'docs')",
+          "sourcedocs(output_folder: 'docs', clean: true, reproducible: true, scheme: 'MyApp')"
+        ]
+      end
+
+      def self.category
+        :documentation
+      end
+    end
+  end
+end