Beispiel #1
0
        private void RewriteCommit(Commit commit, RewriteHistoryOptions options)
        {
            var newHeader = CommitRewriteInfo.From(commit);
            var newTree   = commit.Tree;

            // Find the new parents
            var newParents = commit.Parents;

            if (targetedCommits.Contains(commit))
            {
                // Get the new commit header
                if (options.CommitHeaderRewriter != null)
                {
                    newHeader = options.CommitHeaderRewriter(commit) ?? newHeader;
                }

                if (options.CommitTreeRewriter != null)
                {
                    // Get the new commit tree
                    var newTreeDefinition = options.CommitTreeRewriter(commit);
                    newTree = repo.ObjectDatabase.CreateTree(newTreeDefinition);
                }

                // Retrieve new parents
                if (options.CommitParentsRewriter != null)
                {
                    newParents = options.CommitParentsRewriter(commit);
                }
            }

            // Create the new commit
            var mappedNewParents = newParents
                                   .Select(oldParent => objectMap.ContainsKey(oldParent)
                            ? objectMap[oldParent] as Commit
                            : oldParent)
                                   .Where(newParent => newParent != null)
                                   .ToList();

            if (options.PruneEmptyCommits &&
                TryPruneEmptyCommit(commit, mappedNewParents, newTree))
            {
                return;
            }

            var newCommit = repo.ObjectDatabase.CreateCommit(newHeader.Author,
                                                             newHeader.Committer,
                                                             newHeader.Message,
                                                             newTree,
                                                             mappedNewParents,
                                                             options.PrettifyMessages);

            // Record the rewrite
            objectMap[commit] = newCommit;
        }
        public HistoryRewriter(
            Repository repo,
            IEnumerable <Commit> commitsToRewrite,
            RewriteHistoryOptions options)
        {
            this.repo       = repo;
            this.options    = options;
            targetedCommits = new HashSet <Commit>(commitsToRewrite);

            backupRefsNamespace = this.options.BackupRefsNamespace;

            if (!backupRefsNamespace.EndsWith("/", StringComparison.Ordinal))
            {
                backupRefsNamespace += "/";
            }
        }
Beispiel #3
0
        private async Task AnonymizeDestRepo()
        {
            Logger.Info("Anonymizing commits...");

            var options = new RewriteHistoryOptions
            {
                CommitHeaderRewriter = commit =>
                {
                    var signature = new Signature(_defaultSignature.Name, _defaultSignature.Email,
                                                  commit.Committer.When);
                    return(new CommitRewriteInfo
                    {
                        Author = signature, Committer = signature, Message = commit.Message
                    });
                }
            };
            await Task.Run(() =>
            {
                using var repo = new GitRepository("destRepo");
                repo.Refs.RewriteHistory(options, repo.Commits);
            });
        }
Beispiel #4
0
 public override void RewriteHistory(RewriteHistoryOptions options, params Commit[] commitsToRewrite)
 => throw new NotImplementedException();
Beispiel #5
0
 public override void RewriteHistory(RewriteHistoryOptions options, IEnumerable <Commit> commitsToRewrite)
 => throw new NotImplementedException();