import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected CommitInfo doRename(Git git, String oldPath, String newPath) throws Exception {
    File file = getRelativeFile(oldPath);
    File newFile = getRelativeFile(newPath);
    if (file.exists()) {
        File parentFile = newFile.getParentFile();
        parentFile.mkdirs();
        if (!parentFile.exists()) {
            throw new IOException("Could not create directory " + parentFile + " when trying to move " + file + " to " + newFile + ". Maybe a file permission issue?");
        }
        file.renameTo(newFile);
        String filePattern = getFilePattern(newPath);
        git.add().addFilepattern(filePattern).call();
        CommitCommand commit = git.commit().setAll(true).setAuthor(personIdent).setMessage(message);
        return createCommitInfo(commitThenPush(git, commit));
    } else {
        return null;
    }
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected CommitInfo doRemove(Git git, List<String> paths) throws Exception {
    if (paths != null && paths.size() > 0) {
        int count = 0;
        for (String path : paths) {
            File file = getRelativeFile(path);
            if (file.exists()) {
                count++;
                Files.recursiveDelete(file);
                String filePattern = getFilePattern(path);
                git.rm().addFilepattern(filePattern).call();
            }
        }
        if (count > 0) {
            CommitCommand commit = git.commit().setAll(true).setAuthor(personIdent).setMessage(message);
            return createCommitInfo(commitThenPush(git, commit));
        }
    }
    return null;
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
private RevCommit writeFileAndCommitWithAuthor(Git git, String authorName, String email, String fileName, String commitMessage,
                                               String... lines) throws IOException, GitAPIException {
    StringBuilder sb = new StringBuilder();
    for (String line : lines) {
        sb.append(line);
        sb.append('\n');
    }
    writeTrashFile(fileName, sb.toString());
    git.add().addFilepattern(fileName).call();

    CommitCommand commitCommand = git.commit().setMessage(commitMessage);

    if (authorName != null && email != null) {
        return commitCommand.setAuthor(authorName, email).call();
    } else {
        return commitCommand.call();
    }
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
/**
 * Adds the files that were selected and commits them. Note: the {@link AddCommand}
 * and {@link CommitCommand} are used in this method. {@link AddCommand#setWorkingTreeIterator(WorkingTreeIterator)}
 * can be configured fia {@link #setWorkingTreeIterator(WorkingTreeIterator)} before calling this method,
 * and the {@code CommitCommand} can be configured via {@link #configureCommitCommand(CommitCommand)}.
 * @return the result of {@link #createResult(DirCache, RevCommit, List)} or null if
 *         a {@link GitAPIException} is thrown.
 */
protected final R addAndCommitSelectedFiles() {
    List<String> selectedFiles = getDialogPane().getSelectedFiles();
    try {
        AddCommand add = getGitOrThrow().add();
        selectedFiles.forEach(add::addFilepattern);
        workingTreeIterator.ifPresent(add::setWorkingTreeIterator);
        DirCache cache = add.call();

        CommitCommand commit = getGitOrThrow().commit();
        configureCommitCommand(commit);
        RevCommit revCommit = commit.call();

        return createResult(cache, revCommit, selectedFiles);
    } catch (GitAPIException e) {
        handleGitAPIException(e);
        return null;
    }
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public static RevCommit doCommitAndPush(Git git, String message, UserDetails userDetails, PersonIdent author, String branch, String origin, boolean pushOnCommit) throws GitAPIException {
    CommitCommand commit = git.commit().setAll(true).setMessage(message);
    if (author != null) {
        commit = commit.setAuthor(author);
    }

    RevCommit answer = commit.call();
    if (LOG.isDebugEnabled()) {
        LOG.debug("Committed " + answer.getId() + " " + answer.getFullMessage());
    }

    if (pushOnCommit) {
        PushCommand push = git.push();
        configureCommand(push, userDetails);
        Iterable<PushResult> results = push.setRemote(origin).call();
        for (PushResult result : results) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Pushed " + result.getMessages() + " " + result.getURI() + " branch: " + branch + " updates: " + toString(result.getRemoteUpdates()));
            }
        }
    }
    return answer;
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
@Override
public String commit(String author, String email, String message) {
    
    RevCommit revCommit = null;
    CommitCommand command = _git.commit();
    command.setCommitter(author, email);
    command.setMessage(message);
    command.setAll(true);
    try {
        revCommit = command.call();
    } catch (Throwable e) {
        throw new RuntimeException("Failed to commit", e);
    }
    
    return revCommit.getId().getName();
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public AccumuloConfigurations(Configuration config) throws Exception {
	Preconditions.checkNotNull(config, "Configuration must be supplied");
	gitDir = new File(config.getDataDir()+"/git");
	LOG.debug("Creating Git repository at {}", gitDir);
	if (!gitDir.exists()) {
		if (!gitDir.mkdir()) {
			throw new IOException("Error creating directory: "+gitDir.getAbsolutePath());
		}
		InitCommand initCommand = Git.init();
		initCommand.setBare(false);
		initCommand.setDirectory(gitDir);
		git = initCommand.call();
		CommitCommand commit = git.commit();
		commit.setMessage("Initial commit").call();
		repo = git.getRepository();
	} else {
		git = Git.open(gitDir);
		repo = git.getRepository();			
	}
	LOG.info("Accumulo configuration store initialized");
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public static String createGitRepoWithPom(final File path, final InputStream pom, final File... files) throws Exception {
    File repo = new File(path, "repo");
    if(repo.exists() == false) {
        Files.createDirectory(repo.toPath());
    }
    Git git = Git.init().setDirectory(repo).call();
    String gitUrl = "file://" + repo.getAbsolutePath();

    FileUtils.copyInputStreamToFile(pom, new File(repo, "pom.xml"));
    AddCommand add = git.add();
    add.addFilepattern("pom.xml");
    for (File f : files) {
        add.addFilepattern(f.getName());
    }
    add.call();
    CommitCommand commit = git.commit();
    commit.setMessage("initial commit").call();
    return gitUrl;
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
static void addAllAndCommit(Git git, UserProfile user, String commitMsg) throws GitAPIException {
    AddCommand addCommand = git.add()
        .addFilepattern(".")
        .addFilepattern("application.json");

    CommitCommand commitCmd = git.commit();

    if (user != null && user.name() != null && user.email() != null) {
        commitCmd.setCommitter(user.name(), user.email());
    }
    if (commitMsg != null) {
        commitCmd.setMessage(commitMsg);
    }

    GitHandler.commit(() -> {
        addCommand.call();
        return commitCmd.call();
    });
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected void commit(String comment) {
	CommitCommand ci = git.commit();
	ci.setMessage(comment);
	ci.setAuthor(user);
	ci.setCommitter(user);
	try {
		ci.call();
	} catch (GitAPIException e) {
		throw new RuntimeException(e);
	}
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected CommitInfo doCreateDirectory(Git git, String path) throws Exception {
    File file = getRelativeFile(path);
    if (file.exists()) {
        return null;
    }
    file.mkdirs();
    String filePattern = getFilePattern(path);
    AddCommand add = git.add().addFilepattern(filePattern).addFilepattern(".");
    add.call();

    CommitCommand commit = git.commit().setAll(true).setAuthor(personIdent).setMessage(message);
    RevCommit revCommit = commitThenPush(git, commit);
    return createCommitInfo(revCommit);
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected CommitInfo doWrite(Git git, String path, byte[] contents, PersonIdent personIdent, String commitMessage) throws Exception {
    File file = getRelativeFile(path);
    file.getParentFile().mkdirs();

    Files.writeToFile(file, contents);

    String filePattern = getFilePattern(path);
    AddCommand add = git.add().addFilepattern(filePattern).addFilepattern(".");
    add.call();

    CommitCommand commit = git.commit().setAll(true).setAuthor(personIdent).setMessage(commitMessage);
    RevCommit revCommit = commitThenPush(git, commit);
    return createCommitInfo(revCommit);
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
protected RevCommit commitThenPush(Git git, CommitCommand commit) throws Exception {
    RevCommit answer = commit.call();
    if (LOG.isDebugEnabled()) {
        LOG.debug("Committed " + answer.getId() + " " + answer.getFullMessage());
    }
    if (isPushOnCommit()) {
        Iterable<PushResult> results = doPush(git);
        for (PushResult result : results) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Pushed " + result.getMessages() + " " + result.getURI() + " branch: " + branch + " updates: " + toString(result.getRemoteUpdates()));
            }
        }
    }
    return answer;
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public void dumpConfiguration(Configuration config, Entry e) throws Exception {
	Preconditions.checkNotNull(config, "Configuration must be supplied.");
	Preconditions.checkNotNull(e, "Entry must be supplied.");
	AddCommand add = git.add();
	CommitCommand commit = git.commit();
	try {
		//Dump Zookeeper
		String instanceId = config.getConnector().getInstance().getInstanceID();
		String zkPath = Constants.ZROOT + "/" + instanceId;
		File zkDump = new File(gitDir, ZK_DUMP_FILE);
		LOG.debug("Dump ZooKeeper configuration at {} to {}", zkPath, zkDump);
		FileOutputStream out = new FileOutputStream(zkDump);
		DumpZookeeper.run(out, zkPath);
		out.close();
		//Dump the configuration
		LOG.debug("Dumping Accumulo configuration to {}", gitDir);
		DumpConfigCommand command = new DumpConfigCommand();
		command.allConfiguration = true;
		command.directory = gitDir.getAbsolutePath();
		Instance instance = config.getConnector().getInstance();
		String principal = config.getUsername();
		PasswordToken token = new PasswordToken(config.getPassword().getBytes());
		Admin.printConfig(instance, principal, token, command);
		//Add, commit, and tag
		add.addFilepattern(".").call();
		commit.setMessage("Backup " + e.getUUID().toString()).call();
		git.tag().setName(e.getUUID().toString()).call();
		LOG.debug("Git tag {} created.", e.getUUID());
		//Should we remove all of the files from the existing git workspace?
	} catch (Exception ex) {
		LOG.error("Error saving configuration", ex);
		git.reset().setMode(ResetType.HARD).setRef("HEAD").call();
		throw ex;
	}
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
RevCommit commit(String message) {
    try {
        CommitCommand commitCmd = git.commit().setAll(true).setMessage(message).setCommitter(getDefaultCommiter());
        return commitCmd.call();
    } catch (GitAPIException ex) {
        throw new IllegalStateException("Cannot commit: " + message, ex);
    }
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public Git call(final GitOperationsStep gitOperationsStep, Git git,
    CredentialsProvider cp, String gitRepoUrl, File gitRepoFolder)
    throws IllegalArgumentException, IOException, NoHeadException,
    NoMessageException, UnmergedPathsException,
    ConcurrentRefUpdateException, WrongRepositoryStateException,
    GitAPIException {
  CommitCommand cc = git
      .commit()
      .setAuthor(
          gitOperationsStep
              .environmentSubstitute(this.authorName == null ? ""
                  : this.authorName),
          gitOperationsStep
              .environmentSubstitute(this.authorEmail == null ? ""
                  : this.authorEmail))
      .setCommitter(
          gitOperationsStep
              .environmentSubstitute(this.committerName == null ? ""
                  : this.committerName),
          gitOperationsStep
              .environmentSubstitute(this.committerEmail == null ? ""
                  : this.committerName));

  if (!Const.isEmpty(this.commitMessage)) {
    cc = cc.setMessage(gitOperationsStep
        .environmentSubstitute(this.commitMessage));
  }
  cc.setAll(all).setInsertChangeId(insertChangeId).setAmend(amend).call();
  return git;
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
@Override
public void createMember(RequestContext ctx, ResourceState state, Responder responder) throws Exception {
    String commitMsg = state.getPropertyAsString("msg");
    Boolean includeUntracked = state.getPropertyAsBoolean("include-untracked");

    if (includeUntracked == null) {
        // Default to include all untracked files
        includeUntracked = Boolean.TRUE;
    }

    // Add changed files to staging ready for commit
    AddCommand addCmd = parent.git().add().addFilepattern(".");

    if (!includeUntracked) {
        // This will prevent new files from being added to the index, and therefore the commit
        addCmd.setUpdate(true);
    }

    // Commit staged changes
    RevCommit commit;
    CommitCommand commitCmd = parent.git().commit();

    if (ctx.securityContext() != null) {
        UserProfile user = ctx.securityContext().getUser();
        if (user != null && user.name() != null && user.email() != null) {
            commitCmd.setCommitter(user.name(), user.email());
        }
    }

    if (commitMsg != null) {
        commitCmd.setMessage(commitMsg);
    }

    commit = GitHandler.commit(() -> {
        addCmd.call();
        return commitCmd.call();
    });

    responder.resourceCreated(new GitCommitResource(this, commit));
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
/** {@inheritDoc} */
public void commit(String message) throws GitException {
    try (Repository repo = getRepository()) {
        CommitCommand cmd = git(repo).commit().setMessage(message);
        if (author!=null)
            cmd.setAuthor(author);
        if (committer!=null)
            cmd.setCommitter(new PersonIdent(committer,new Date()));
        cmd.call();
    } catch (GitAPIException e) {
        throw new GitException(e);
    }
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
/**
 * Commit all.
 *
 * @param msg the msg
 * @throws GitAPIException the git api exception
 */
public void commitAll(String msg) throws GitAPIException {
	CommitCommand command = git.commit().setMessage(msg).setAll(true);
	RevCommit result = command.call();
	String message=result.getFullMessage();
	if (message.length()>0){
		Notification.show("Commit ok, message: " + message);			
	}else{
		Notification.show("Commit ok, no commit message :( ?");
	}	
}
 

import org.eclipse.jgit.api.CommitCommand; //导入依赖的package包/类
public static void commit(Repo repo, boolean stageAll, boolean isAmend,
        String msg, String authorName, String authorEmail) throws Exception, NoHeadException, NoMessageException,
        UnmergedPathsException, ConcurrentRefUpdateException,
        WrongRepositoryStateException, GitAPIException, StopTaskException {
    Context context = SGitApplication.getContext();
    StoredConfig config = repo.getGit().getRepository().getConfig();
    String committerEmail = config.getString("user", null, "email");
    String committerName = config.getString("user", null, "name");

    if (committerName == null || committerName.equals("")) {
        committerName = Profile.getUsername(context);
    }
    if (committerEmail == null || committerEmail.equals("")) {
        committerEmail = Profile.getEmail(context);
    }
    if (committerName.isEmpty() || committerEmail.isEmpty()) {
        throw new Exception("Please set your name and email");
    }
    if (msg.isEmpty()) {
        throw new Exception("Please include a commit message");
    }
    CommitCommand cc = repo.getGit().commit()
            .setCommitter(committerName, committerEmail).setAll(stageAll)
            .setAmend(isAmend).setMessage(msg);
    if (authorName != null && authorEmail != null) {
        cc.setAuthor(authorName, authorEmail);
    }
    cc.call();
    repo.updateLatestCommitInfo();
}