fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/gym.rb

@@ -0,0 +1,10 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/build_app'
+    class GymAction < BuildAppAction
+      def self.description
+        "Alias for the `build_app` action"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/hg_add_tag.rb

@@ -0,0 +1,48 @@
+module Fastlane
+  module Actions
+    # Adds a hg tag to the current commit
+    class HgAddTagAction < Action
+      def self.run(options)
+        tag = options[:tag]
+
+        UI.message("Adding mercurial tag '#{tag}' 🎯.")
+
+        command = "hg tag \"#{tag}\""
+        return command if Helper.test?
+
+        Actions.sh(command)
+      end
+
+      def self.description
+        "This will add a hg tag to the current branch"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :tag,
+                                       env_name: "FL_HG_TAG_TAG",
+                                       description: "Tag to create")
+        ]
+      end
+
+      def self.author
+        # credits to lmirosevic for original git version
+        "sjrmanning"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'hg_add_tag(tag: "1.3")'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/hg_commit_version_bump.rb

@@ -0,0 +1,183 @@
+module Fastlane
+  module Actions
+    # Commits version bump.
+    class HgCommitVersionBumpAction < Action
+      def self.run(params)
+        require 'xcodeproj'
+        require 'pathname'
+        require 'set'
+        require 'shellwords'
+
+        xcodeproj_path = params[:xcodeproj] ? File.expand_path(File.join('.', params[:xcodeproj])) : nil
+
+        if Helper.test?
+          xcodeproj_path = "/tmp/Test.xcodeproj"
+        end
+
+        # get the repo root path
+        repo_path = Helper.test? ? '/tmp/repo' : Actions.sh('hg root').strip
+        repo_pathname = Pathname.new(repo_path)
+
+        if xcodeproj_path
+          # ensure that the xcodeproj passed in was OK
+          unless Helper.test?
+            UI.user_error!("Could not find the specified xcodeproj: #{xcodeproj_path}") unless File.directory?(xcodeproj_path)
+          end
+        else
+          # find an xcodeproj (ignoring dependencies)
+          xcodeproj_paths = Fastlane::Helper::XcodeprojHelper.find(repo_path)
+
+          # no projects found: error
+          UI.user_error!('Could not find a .xcodeproj in the current repository\'s working directory.') if xcodeproj_paths.count == 0
+
+          # too many projects found: error
+          if xcodeproj_paths.count > 1
+            relative_projects = xcodeproj_paths.map { |e| Pathname.new(e).relative_path_from(repo_pathname).to_s }.join("\n")
+            UI.user_error!("Found multiple .xcodeproj projects in the current repository's working directory. Please specify your app's main project: \n#{relative_projects}")
+          end
+
+          # one project found: great
+          xcodeproj_path = xcodeproj_paths.first
+        end
+
+        # find the pbxproj path, relative to hg directory
+        if Helper.test?
+          hg_dirty_files = params[:test_dirty_files].split(",")
+          expected_changed_files = params[:test_expected_files].split(",")
+        else
+          pbxproj_pathname = Pathname.new(File.join(xcodeproj_path, 'project.pbxproj'))
+          pbxproj_path = pbxproj_pathname.relative_path_from(repo_pathname).to_s
+
+          # find the info_plist files
+          project = Xcodeproj::Project.open(xcodeproj_path)
+          info_plist_files = project.objects.select do |object|
+            object.isa == 'XCBuildConfiguration'
+          end.map(&:to_hash).map do |object_hash|
+            object_hash['buildSettings']
+          end.select do |build_settings|
+            build_settings.key?('INFOPLIST_FILE')
+          end.map do |build_settings|
+            build_settings['INFOPLIST_FILE']
+          end.uniq.map do |info_plist_path|
+            Pathname.new(File.expand_path(File.join(xcodeproj_path, '..', info_plist_path))).relative_path_from(repo_pathname).to_s
+          end
+
+          # create our list of files that we expect to have changed, they should all be relative to the project root, which should be equal to the hg workdir root
+          expected_changed_files = []
+          expected_changed_files << pbxproj_path
+          expected_changed_files << info_plist_files
+          expected_changed_files.flatten!.uniq!
+
+          # get the list of files that have actually changed in our hg workdir
+          hg_dirty_files = Actions.sh('hg status -n').split("\n")
+        end
+
+        # little user hint
+        UI.user_error!("No file changes picked up. Make sure you run the `increment_build_number` action first.") if hg_dirty_files.empty?
+
+        # check if the files changed are the ones we expected to change (these should be only the files that have version info in them)
+        dirty_set = Set.new(hg_dirty_files.map(&:downcase))
+        expected_set = Set.new(expected_changed_files.map(&:downcase))
+        changed_files_as_expected = dirty_set.subset?(expected_set)
+        unless changed_files_as_expected
+          unless params[:force]
+            str = ["Found unexpected uncommitted changes in the working directory. Expected these files to have changed:",
+                   "#{expected_changed_files.join("\n")}.",
+                   "But found these actual changes: \n#{hg_dirty_files.join("\n")}.",
+                   "Make sure you have cleaned up the build artifacts and are only left with the changed version files at this",
+                   "stage in your lane, and don't touch the working directory while your lane is running. You can also use the :force option to ",
+                   "bypass this check, and always commit a version bump regardless of the state of the working directory."].join("\n")
+            UI.user_error!(str)
+          end
+        end
+
+        # create a commit with a message
+        command = "hg commit -m '#{params[:message]}'"
+        return command if Helper.test?
+        begin
+          Actions.sh(command)
+
+          UI.success("Committed \"#{params[:message]}\" 💾.")
+        rescue => ex
+          UI.error(ex)
+          UI.important("Didn't commit any changes. 😐")
+        end
+      end
+
+      def self.description
+        "This will commit a version bump to the hg repo"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_COMMIT_BUMP_MESSAGE",
+                                       description: "The commit message when committing the version bump",
+                                       default_value: "Version Bump"),
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "FL_BUILD_NUMBER_PROJECT",
+                                       description: "The path to your project file (Not the workspace). If you have only one, this is optional",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass the path to the project, not the workspace") if value.end_with?(".xcworkspace")
+                                         UI.user_error!("Could not find Xcode project") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_FORCE_COMMIT",
+                                       description: "Forces the commit, even if other files than the ones containing the version number have been modified",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :test_dirty_files,
+                                       env_name: "FL_HG_COMMIT_TEST_DIRTY_FILES",
+                                       description: "A list of dirty files passed in for testing",
+                                       optional: true,
+                                       default_value: "file1, file2"),
+          FastlaneCore::ConfigItem.new(key: :test_expected_files,
+                                       env_name: "FL_HG_COMMIT_TEST_EXP_FILES",
+                                       description: "A list of expected changed files passed in for testing",
+                                       optional: true,
+                                       default_value: "file1, file2")
+        ]
+      end
+
+      def self.author
+        # credits to lmirosevic for original git version
+        "sjrmanning"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          All `.plist` files
+          The `.xcodeproj/project.pbxproj` file
+        LIST
+        [
+          "The mercurial equivalent of the [commit_version_bump](https://docs.fastlane.tools/actions/commit_version_bump/) git action. Like the git version, it is useful in conjunction with [`increment_build_number`](https://docs.fastlane.tools/actions/increment_build_number/).",
+          "It checks the repo to make sure that only the relevant files have changed, these are the files that `increment_build_number` (`agvtool`) touches:".markdown_preserve_newlines,
+          list,
+          "Then commits those files to the repo.",
+          "Customize the message with the `:message` option, defaults to 'Version Bump'",
+          "If you have other uncommitted changes in your repo, this action will fail. If you started off in a clean repo, and used the _ipa_ and or _sigh_ actions, then you can use the [clean_build_artifacts](https://docs.fastlane.tools/actions/clean_build_artifacts/) action to clean those temporary files up before running this action."
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'hg_commit_version_bump',
+          'hg_commit_version_bump(
+            message: "Version Bump",                 # create a commit with a custom message
+            xcodeproj: "./path/MyProject.xcodeproj", # optional, if you have multiple Xcode project files, you must specify your main project here
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/hg_ensure_clean_status.rb

@@ -0,0 +1,53 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      HG_REPO_WAS_CLEAN_ON_START = :HG_REPO_WAS_CLEAN_ON_START
+    end
+    # Raises an exception and stop the lane execution if the repo is not in a clean state
+    class HgEnsureCleanStatusAction < Action
+      def self.run(params)
+        repo_clean = `hg status`.empty?
+
+        if repo_clean
+          UI.success('Mercurial status is clean, all good! 😎')
+          Actions.lane_context[SharedValues::HG_REPO_WAS_CLEAN_ON_START] = true
+        else
+          UI.user_error!('Mercurial repository is dirty! Please ensure the repo is in a clean state by committing/stashing/discarding all changes first.')
+        end
+      end
+
+      def self.description
+        "Raises an exception if there are uncommitted hg changes"
+      end
+
+      def self.details
+        "Along the same lines as the [ensure_git_status_clean](https://docs.fastlane.tools/actions/ensure_git_status_clean/) action, this is a sanity check to ensure the working mercurial repo is clean. Especially useful to put at the beginning of your Fastfile in the `before_all` block."
+      end
+
+      def self.output
+        [
+          ['HG_REPO_WAS_CLEAN_ON_START', 'Stores the fact that the hg repo was clean at some point']
+        ]
+      end
+
+      def self.author
+        # credits to lmirosevic for original git version
+        "sjrmanning"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'hg_ensure_clean_status'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/hg_push.rb

@@ -0,0 +1,64 @@
+module Fastlane
+  module Actions
+    # Pushes commits to the remote hg repo
+    class HgPushAction < Action
+      def self.run(params)
+        command = ['hg', 'push']
+
+        command << '--force' if params[:force]
+        command << params[:destination] unless params[:destination].empty?
+
+        return command.join(' ') if Helper.test?
+
+        Actions.sh(command.join(' '))
+        UI.success('Successfully pushed changes to remote 🚀.')
+      end
+
+      def self.description
+        "This will push changes to the remote hg repository"
+      end
+
+      def self.details
+        "The mercurial equivalent of [push_to_git_remote](https://docs.fastlane.tools/actions/push_to_git_remote/). Pushes your local commits to a remote mercurial repo. Useful when local changes such as adding a version bump commit or adding a tag are part of your lane’s actions."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_HG_PUSH_FORCE",
+                                       description: "Force push to remote",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       env_name: "FL_HG_PUSH_DESTINATION",
+                                       description: "The destination to push to",
+                                       default_value: '',
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        # credits to lmirosevic for original git version
+        "sjrmanning"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'hg_push',
+          'hg_push(
+            destination: "ssh://hg@repohost.com/owner/repo",
+            force: true
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/hipchat.rb

@@ -0,0 +1,200 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class HipchatAction < Action
+      def self.run(options)
+        require 'net/http'
+        require 'uri'
+
+        api_token = options[:api_token]
+        api_version = options[:version]
+        api_host = options[:api_host]
+
+        message_format = options[:message_format]
+
+        channel = options[:channel]
+        if ['yellow', 'red', 'green', 'purple', 'gray', 'random'].include?(options[:custom_color]) == true
+          color = options[:custom_color]
+        else
+          color = (options[:success] ? 'green' : 'red')
+        end
+
+        from = options[:from]
+
+        message = options[:message]
+        if (message_format == "html") && (options[:include_html_header] == true)
+          message = "<table><tr><td><img src='https://fastlane.tools/assets/img/fastlane_icon.png' width='50' height='50'></td><td>#{message[0..9999]}</td></tr></table>"
+        end
+
+        if api_version.to_i == 1
+          ########## running on V1 ##########
+          if user?(channel)
+            UI.user_error!("HipChat private message not working with API V1 please use API V2 instead")
+          else
+            uri = URI.parse("https://#{api_host}/v1/rooms/message")
+            response = Net::HTTP.post_form(uri, { 'from' => from,
+                                                  'auth_token' => api_token,
+                                                  'color' => color,
+                                                  'message_format' => message_format,
+                                                  'room_id' => channel,
+                                                  'message' => message,
+                                                  'notify' => options[:notify_room] ? '1' : '0' })
+
+            check_response_code(response, channel)
+          end
+        else
+          ########## running on V2 ##########
+          # Escape channel's name to guarantee it is a valid URL resource.
+          # First of all we verify that the value is not already escaped,
+          # escaping an escaped value will produce a wrong channel name.
+          escaped_channel = URI.unescape(channel) == channel ? URI.escape(channel) : channel
+          if user?(channel)
+            params = { 'message' => message, 'message_format' => message_format }
+            json_headers = { 'Content-Type' => 'application/json',
+                             'Accept' => 'application/json', 'Authorization' => "Bearer #{api_token}" }
+
+            uri = URI.parse("https://#{api_host}/v2/user/#{escaped_channel}/message")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+
+            response = http.post(uri.path, params.to_json, json_headers)
+          else
+            uri = URI.parse("https://#{api_host}/v2/room/#{escaped_channel}/notification")
+            response = Net::HTTP.post_form(uri, { 'from' => from,
+                                                  'auth_token' => api_token,
+                                                  'color' => color,
+                                                  'message_format' => message_format,
+                                                  'message' => message,
+                                                  'notify' => options[:notify_room] ? 'true' : 'false' })
+          end
+          check_response_code(response, channel)
+        end
+      end
+
+      def self.user?(channel)
+        channel.to_s.start_with?('@')
+      end
+
+      def self.check_response_code(response, channel)
+        case response.code.to_i
+        when 200, 204
+          true
+        when 404
+          UI.user_error!("Channel `#{channel}` not found")
+        when 401
+          UI.user_error!("Access denied for channel `#{channel}`")
+        else
+          UI.user_error!("Unexpected #{response.code} for `#{channel}` with response: #{response.body}")
+        end
+      end
+
+      def self.description
+        "Send a error/success message to [HipChat](https://www.hipchat.com/)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_HIPCHAT_MESSAGE",
+                                       description: "The message to post on HipChat",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :channel,
+                                       env_name: "FL_HIPCHAT_CHANNEL",
+                                       description: "The room or @username"),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "HIPCHAT_API_TOKEN",
+                                       sensitive: true,
+                                       description: "Hipchat API Token",
+                                       verify_block: proc do |value|
+                                         unless value.to_s.length > 0
+                                           UI.error("Please add 'ENV[\"HIPCHAT_API_TOKEN\"] = \"your token\"' to your Fastfile's `before_all` section.")
+                                           UI.user_error!("No HIPCHAT_API_TOKEN given.")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :custom_color,
+                                       env_name: "FL_HIPCHAT_CUSTOM_COLOR",
+                                       description: "Specify a custom color, this overrides the success boolean. Can be one of 'yellow', 'red', 'green', 'purple', 'gray', or 'random'",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :success,
+                                       env_name: "FL_HIPCHAT_SUCCESS",
+                                       description: "Was this build successful? (true/false)",
+                                       optional: true,
+                                       default_value: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "HIPCHAT_API_VERSION",
+                                       description: "Version of the Hipchat API. Must be 1 or 2",
+                                       verify_block: proc do |value|
+                                         if value.nil? || ![1, 2].include?(value.to_i)
+                                           UI.error("Please add 'ENV[\"HIPCHAT_API_VERSION\"] = \"1 or 2\"' to your Fastfile's `before_all` section.")
+                                           UI.user_error!("No HIPCHAT_API_VERSION given.")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :notify_room,
+                                       env_name: "HIPCHAT_NOTIFY_ROOM",
+                                       description: "Should the people in the room be notified? (true/false)",
+                                       default_value: false,
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :api_host,
+                                       env_name: "HIPCHAT_API_HOST",
+                                       description: "The host of the HipChat-Server API",
+                                       default_value: "api.hipchat.com",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :message_format,
+                                       env_name: "FL_HIPCHAT_MESSAGE_FORMAT",
+                                       description: "Format of the message to post. Must be either 'html' or 'text'",
+                                       default_value: "html",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         unless ["html", "text"].include?(value.to_s)
+                                           UI.error("Please specify the message format as either 'html' or 'text'.")
+                                           UI.user_error!("Unrecognized message_format.")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :include_html_header,
+                                       env_name: "FL_HIPCHAT_INCLUDE_HTML_HEADER",
+                                       description: "Should html formatted messages include a preformatted header? (true/false)",
+                                       default_value: true,
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :from,
+                                       env_name: "FL_HIPCHAT_FROM",
+                                       description: "Name the message will appear to be sent from",
+                                       default_value: "fastlane",
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        "jingx23"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.details
+        "Send a message to **room** (by default) or a direct message to **@username** with success (green) or failure (red) status."
+      end
+
+      def self.example_code
+        [
+          'hipchat(
+            message: "App successfully released!",
+            message_format: "html", # or "text", defaults to "html"
+            channel: "Room or @username",
+            success: true
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end