:calls: `PUT /repos/:owner/:repo/pulls/:number/merge <http://developer.github.com/v3/pulls>`_
        :param commit_message: string
        :rtype: :class:`github.PullRequestMergeStatus.PullRequestMergeStatus`
777299
def merge(self, commit_message=github.GithubObject.NotSet, commit_title=github.GithubObject.NotSet, merge_method=github.GithubObject.NotSet, sha=github.GithubObject.NotSet):
        
        assert commit_message is github.GithubObject.NotSet or isinstance(commit_message, (str, unicode)), commit_message
        assert commit_title is github.GithubObject.NotSet or isinstance(commit_title, (str, unicode)), commit_title
        assert merge_method is github.GithubObject.NotSet or isinstance(merge_method, (str, unicode)), merge_method
        assert sha is github.GithubObject.NotSet or isinstance(sha, (str, unicode)), sha
        post_parameters = dict()
        if commit_message is not github.GithubObject.NotSet:
            post_parameters["commit_message"] = commit_message
        if commit_title is not github.GithubObject.NotSet:
            post_parameters["commit_title"] = commit_title
        if merge_method is not github.GithubObject.NotSet:
            post_parameters["merge_method"] = merge_method
        if sha is not github.GithubObject.NotSet:
            post_parameters["sha"] = sha
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            self.url + "/merge",
            input=post_parameters
        )
        return github.PullRequestMergeStatus.PullRequestMergeStatus(self._requester, headers, data, completed=True)
1299629
def merge(self, base, head, commit_message=github.GithubObject.NotSet):
        
        assert isinstance(base, (str, unicode)), base
        assert isinstance(head, (str, unicode)), head
        assert commit_message is github.GithubObject.NotSet or isinstance(commit_message, (str, unicode)), commit_message
        post_parameters = {
            "base": base,
            "head": head,
        }
        if commit_message is not github.GithubObject.NotSet:
            post_parameters["commit_message"] = commit_message
        headers, data = self._requester.requestJsonAndCheck(
            "POST",
            self.url + "/merges",
            input=post_parameters
        )
        if data is None:
            return None
        else:
            return github.Commit.Commit(self._requester, headers, data, completed=True)
342751
def post_commit_status(self):
        
        if self.violations:
            plural = '' if self.introduced_issues_count == 1 else 's'
            description = 'Pull Request introduced {} linting violation{}'.format(
                self.introduced_issues_count, plural)
            self._post_status('failure', description)
        else:
            self._post_status('success', 'Linting detected no new issues.')
643028
def amend_commit(
            self,
            append_to_msg: typing.Optional[str] = None,
            new_message: typing.Optional[str] = None,
            files_to_add: typing.Optional[typing.Union[typing.List[str], str]] = None,
    ):
        
1180483
def commit(self, commit):
		
		try:
			return self._commitData(self.repo.commit(commit))
		except (ValueError, KeyError, BadObject):
			if self._repo_info:
				raise KeyError("Commit %s not found for %s" % (commit, str(self._repo_info)))
			else:
				raise KeyError("Commit %s not found" % commit)
885592
public GitContext commitMessage(String message) {
        if (commitMessage.length() == 0) {
            commitMessage.append(message + "\n");
        } else {
            commitMessage.append("\n- " + message);
        }
        return this;
    }
773238
def put(self, file):
        
        input_ = {
            "message": file.logs,
            "author": file.author.dict(),
            "content": file.base64,
            "branch": file.branch
        }
        uri = "{api}/repos/{origin}/contents/{path}".format(
            api=self.github_api_url,
            origin=self.origin,
            path=file.path
        )
        data = self.request("PUT", uri, data=input_)

        if data.status_code == 201:
            file.pushed = True
            return file
        else:
            decoded_data = json.loads(data.content.decode("utf-8"))
            return self.ProxyError(
                data.status_code, (decoded_data, "message"),
                step="put", context={
                    "uri": uri,
                    "params": input_
                }
            )
408254
def check_commit_message_non_ascii(message)
      check_label = 'Only ASCII characters'

      if message.ascii_only?
        Status.report(check_label, true)
      else
        Status.report(check_label, false)
        @errors.push('Commit messages may not contain non-ASCII characters')
      end
    end
845695
def deliver(message = nil, status = :success)
      return unless ENV[ci_computer.to_s]

      author, commit_message = last_git_log

      client.post(text: text(status, author, commit_message, message),
                  icon_emoji: ":#{ send(status.to_s + '_icon') }:")
    end
846458
def commit_config(self, message=""):
        
        if message:
            raise NotImplementedError(
                "Commit message not implemented for this platform"
            )
        # Always generate a rollback config on commit
        self._gen_rollback_cfg()

        if self.config_replace:
            # Replace operation
            filename = self.candidate_cfg
            cfg_file = self._gen_full_path(filename)
            if not self._check_file_exists(cfg_file):
                raise ReplaceConfigException("Candidate config file does not exist")
            if self.auto_rollback_on_error:
                cmd = "configure replace {} force revert trigger error".format(cfg_file)
            else:
                cmd = "configure replace {} force".format(cfg_file)
            output = self._commit_handler(cmd)
            if (
                ("original configuration has been successfully restored" in output)
                or ("error" in output.lower())
                or ("not a valid config file" in output.lower())
                or ("failed" in output.lower())
            ):
                msg = "Candidate config could not be applied\n{}".format(output)
                raise ReplaceConfigException(msg)
            elif "%Please turn config archive on" in output:
                msg = "napalm-ios replace() requires Cisco 'archive' feature to be enabled."
                raise ReplaceConfigException(msg)
        else:
            # Merge operation
            filename = self.merge_cfg
            cfg_file = self._gen_full_path(filename)
            if not self._check_file_exists(cfg_file):
                raise MergeConfigException("Merge source config file does not exist")
            cmd = "copy {} running-config".format(cfg_file)
            output = self._commit_handler(cmd)
            if "Invalid input detected" in output:
                self.rollback()
                err_header = "Configuration merge failed; automatic rollback attempted"
                merge_error = "{0}:\n{1}".format(err_header, output)
                raise MergeConfigException(merge_error)

        # After a commit - we no longer know whether this is configured or not.
        self.prompt_quiet_configured = None

        # Save config to startup (both replace and merge)
        output += self.device.save_config()
384642
def post_comment(self, message):
        
        report_url = (
            'https://api.github.com/repos/%s/issues/%s/comments'
            % (self.repo_name, self.pr_number)
        )
        result = self.requester.post(report_url, {'body': message})
        if result.status_code >= 400:
            log.error("Error posting comment to github. %s", result.json())
        return result
887850
def last_commit_msg(self) -> str:
        
        last_msg: str = self.latest_commit().message.rstrip()
        LOGGER.debug('last msg: %s', last_msg)
        return last_msg
614284
def get_commit_command(self, message, author=None):
        """"""
        command = ['bzr', 'commit']
        if author:
            command.extend(('--author', author.combined))
        command.append('--message')
        command.append(message)
        return command
793827
def message(message)
      reqdata = reqdata()
      reqdata.merge!({
        :nick => @endpoint[:nick],
        :type => "chat",
        :style => "",
        :timestamp => Time.now.to_f * 1000
      })
      reqdata.merge!(message)
      httpost('/messages', reqdata)
    end
758673
@SneakyThrows
    public void commitAll(final String message) {
        this.gitInstance.add().addFilepattern(".").call();
        this.gitInstance.commit()
            .setMessage(message)
            .setAll(true)
            .setAuthor("CAS", "cas@apereo.org")
            .call();
    }
40039
def commit(self, commit):
		
		try:
			return self._commitData(self.repo.get_commit(commit))
		except (ValueError, KeyError, GithubException):
			raise KeyError("Commit %s not found" % commit)
1204535
public RevCommit addAndCommit(Git git, String message) {
        try {
            git.add()
                .addFilepattern(".")
                .call();
            return git.commit()
                .setMessage(message)
                .call();
        } catch (GitAPIException e) {
            throw new IllegalStateException(e);
        }
    }