org.eclipse.jgit.treewalk.WorkingTreeOptions Java Examples

/**
 * Constructor for ResolveMerger.
 *
 * @param local
 *            the {@link org.eclipse.jgit.lib.Repository}.
 * @param inCore
 *            a boolean.
 */
protected ResolveMerger(Repository local, boolean inCore) {
	super(local);
	Config config = local.getConfig();
	mergeAlgorithm = getMergeAlgorithm(config);
	inCoreLimit = getInCoreLimit(config);
	commitNames = defaultCommitNames();
	this.inCore = inCore;

	if (inCore) {
		implicitDirCache = false;
		dircache = DirCache.newInCore();
	} else {
		implicitDirCache = true;
		workingTreeOptions = local.getConfig().get(WorkingTreeOptions.KEY);
	}
}
 

@Override
protected void run () throws GitException {
    Repository repository = getRepository();
    org.eclipse.jgit.api.BlameCommand cmd = new Git(repository).blame();
    cmd.setFilePath(Utils.getRelativePath(getRepository().getWorkTree(), file));
    if (revision != null) {
        cmd.setStartCommit(Utils.findCommit(repository, revision));
    } else if (repository.getConfig().get(WorkingTreeOptions.KEY).getAutoCRLF() != CoreConfig.AutoCRLF.FALSE) {
        // work-around for autocrlf
        cmd.setTextComparator(new AutoCRLFComparator());
    }
    cmd.setFollowFileRenames(true);
    try {
        BlameResult cmdResult = cmd.call();
        if (cmdResult != null) {
            result = getClassFactory().createBlameResult(cmdResult, repository);
        }
    } catch (GitAPIException ex) {
        throw new GitException(ex);
    }
}
 

private void cacheContents (List<String> conflicts) throws IOException {
    File workTree = getRepository().getWorkTree();
    WorkingTreeOptions opt = getRepository().getConfig().get(WorkingTreeOptions.KEY);
    boolean autocrlf = opt.getAutoCRLF() != CoreConfig.AutoCRLF.FALSE;
    try (ObjectInserter inserter = getRepository().newObjectInserter();) {
        for (String path : conflicts) {
            File f = new File(workTree, path);
            Path p = null;
            try {
                p = f.toPath();
            } catch (InvalidPathException ex) {
                Logger.getLogger(CheckoutRevisionCommand.class.getName()).log(Level.FINE, null, ex);
            }
            if (p != null && Files.isSymbolicLink(p)) {
                Path link = Utils.getLinkPath(p);                                
                cachedContents.put(path, inserter.insert(Constants.OBJ_BLOB, Constants.encode(link.toString())));
            } else if (f.isFile()) {
                long sz = f.length();
                try (FileInputStream in = new FileInputStream(f)) {
                    if (autocrlf) {
                        ByteBuffer buf = IO.readWholeStream(in, (int) sz);
                        cachedContents.put(path, inserter.insert(Constants.OBJ_BLOB, buf.array(), buf.position(), buf.limit() - buf.position()));
                    } else {
                        cachedContents.put(path, inserter.insert(Constants.OBJ_BLOB, sz, in));
                    }
                }
            }
        }
        inserter.flush();
    }
}
 

private void checkoutFile (MergeResult<RawText> merge, String path) throws IOException {
    File file = new File(getRepository().getWorkTree(), path);
    file.getParentFile().mkdirs();
    MergeFormatter format = new MergeFormatter();
    WorkingTreeOptions opt = getRepository().getConfig().get(WorkingTreeOptions.KEY);
    try (OutputStream fos = opt.getAutoCRLF() != CoreConfig.AutoCRLF.FALSE
            ? new AutoCRLFOutputStream(new FileOutputStream(file))
            : new FileOutputStream(file)) {
        format.formatMerge(fos, merge, Arrays.asList(new String[] { "BASE", "OURS", "THEIRS" }), //NOI18N
                Constants.CHARACTER_ENCODING);
    }
}
 

private GitStagedFiles(Log log, Repository repository, Set<String> filePaths) {
  this.log = requireNonNull(log);
  this.repository = requireNonNull(repository);
  this.filePaths = Collections.unmodifiableSet(filePaths);

  WorkingTreeOptions workingTreeOptions = repository.getConfig().get(WorkingTreeOptions.KEY);
  if (workingTreeOptions.getAutoCRLF() == AutoCRLF.TRUE) {
    eolStreamType = EolStreamType.AUTO_CRLF;
  } else {
    eolStreamType = EolStreamType.DIRECT;
  }
  log.debug("eolStreamType is '" + eolStreamType + "'");
}
 

public NoGitignoreIterator(
        File root,
        FS fs,
        WorkingTreeOptions options,
        FileModeStrategy fileModeStrategy
) {
    super(root, fs, options, fileModeStrategy);
}
 

@Override
  protected void run() throws GitException {
      Repository repository = getRepository();
      String workTreePath = repository.getWorkTree().getAbsolutePath();
      try (DiffFormatter formatter = new DiffFormatter(out);
          ObjectReader or = repository.newObjectReader()) {
          formatter.setRepository(repository);
          Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
          if (!pathFilters.isEmpty()) {
              formatter.setPathFilter(PathFilterGroup.create(pathFilters));
          }
          if (repository.getConfig().get(WorkingTreeOptions.KEY).getAutoCRLF() != CoreConfig.AutoCRLF.FALSE) {
              // work-around for autocrlf
              formatter.setDiffComparator(new AutoCRLFComparator());
          }
          AbstractTreeIterator firstTree = getIterator(firstCommit, or);
          AbstractTreeIterator secondTree = getIterator(secondCommit, or);
          List<DiffEntry> diffEntries;
          if (secondTree instanceof WorkingTreeIterator) {
              // remote when fixed in JGit, see ExportDiffTest.testDiffRenameDetectionProblem
              formatter.setDetectRenames(false);
              diffEntries = formatter.scan(firstTree, secondTree);
              formatter.setDetectRenames(true);
              RenameDetector detector = formatter.getRenameDetector();
              detector.reset();
              detector.addAll(diffEntries);
diffEntries = detector.compute(new ContentSource.Pair(ContentSource.create(or), ContentSource.create((WorkingTreeIterator) secondTree)), NullProgressMonitor.INSTANCE);
          } else {
              formatter.setDetectRenames(true);
              diffEntries = formatter.scan(firstTree, secondTree);
          }
          for (DiffEntry ent : diffEntries) {
              if (monitor.isCanceled()) {
                  break;
              }
              listener.notifyFile(new File(workTreePath + File.separator + ent.getNewPath()), ent.getNewPath());
              formatter.format(ent);
          }
          formatter.flush();
      } catch (IOException ex) {
          throw new GitException(ex);
      }
  }
 

private GfsTreeIterator(List<GfsTreeEntry> files) {
  super((WorkingTreeOptions) null);
  this.files = files;
  next(1);
}
 

private GfsTreeIterator(List<GfsTreeEntry> files) {
  super((WorkingTreeOptions) null);
  this.files = files;
  next(1);
}
 

public NoGitignoreIterator(File root, FS fs, WorkingTreeOptions options) {
    super(root, fs, options);
}