public override IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            var repositoryLocation = Repository.Discover(context.InputFolder);
            if (repositoryLocation == null)
                throw new ArgumentException("No git repository found");

            using (Repository repository = new Repository(repositoryLocation))
            {

                var data = GetCommitInformation(repository);
                var lookup = data.ToLookup(x => x.Path.ToLower());
                return inputs.Select(x =>
                {
                    string relativePath = GetRelativePath(Path.GetDirectoryName(Path.GetDirectoryName(repositoryLocation.ToLower())), x.Source.ToLower()); // yes we need to do it twice
                    if (!lookup.Contains(relativePath))
                        return x;

                    var commitsOfFile = lookup[relativePath]
                        .GroupBy(y => y.Author)
                        .ToDictionary(y => y.Key,
                                    y => y.OrderByDescending(z => z.AuthorDateTime).First())
                        .Select(y => y.Value)
                        .ToArray();

                    return x.Clone(new[]
                    {
                        new KeyValuePair<string, object>(_metadataName, commitsOfFile)
                    });
                }).ToArray(); // Don't do it lazy or Commit is disposed.
            }
        }

 RepositoryWriter( Repository r, string userName = null, string userEmail = null )
 {
     if( (userEmail == null) != (userName== null ) ) throw new ArgumentException();
     _repo = r;
     _userEmail = userEmail;
     _userName = userName;
 }

 internal ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options)
 {
     Proxy.git_diff_blobs(repo.Handle,
                          oldBlob != null ? oldBlob.Id : null,
                          newBlob != null ? newBlob.Id : null,
                          options, FileCallback, HunkCallback, LineCallback);
 }

 public PersistentInfo( Repository r )
     : this()
 {
     if( r == null ) RepositoryError = "No repository.";
     else
     {
         var branch = r.Head;
         if( branch.Tip == null ) RepositoryError = "Unitialized repository.";
         else
         {
             CommitSha = branch.Tip.Sha;
             var repositoryStatus = r.Index.RetrieveStatus();
             IsDirty =  repositoryStatus.Added.Any()
                         || repositoryStatus.Missing.Any()
                         || repositoryStatus.Modified.Any()
                         || repositoryStatus.Removed.Any()
                         || repositoryStatus.Staged.Any();
             ReleasedTag = FindReleasedVersion( r, branch.Tip );
             if( ReleasedTag.IsValid )
             {
                 BranchName = ReleasedTag.BranchName;
             }
             else
             {
                 BranchName = branch.Name;
             }
         }
     }
 }

 private static string HashWithLibGit2Sharp(Stream file)
 {
     var repository = new Repository(Environment.CurrentDirectory);
     var temp = new FileStream(Path.GetTempFileName(),FileMode.Open);
     file.CopyTo(temp);
     return repository.ObjectDatabase.CreateBlob(temp.Name).Sha.ToString();
 }

        internal ObjectDatabase(Repository repo)
        {
            this.repo = repo;
            handle = Proxy.git_repository_odb(repo.Handle);

            repo.RegisterForCleanup(handle);
        }

        static void Main(string[] args)
        {
            string ruta = @"C:\Users\developer\Documents\GitHub\libgit2sharp";
            var repo = new Repository(ruta);

            //Listar(repo);
            int numCommits = 0;
            int programadores = 8;
            int años = 2014 - 2010; //desde 2010
            Console.WriteLine("Numero de commits por branch:");

            foreach (var rama in repo.Branches)
            {
                    Console.WriteLine("Rama: " + rama.Name + " tiene " + rama.Commits.Count() + " commits");
                    numCommits += rama.Commits.Count();

            }

            Console.ForegroundColor = ConsoleColor.DarkCyan;
            Console.WriteLine("\r\nRamas listadas " + repo.Branches.Count());
            Console.WriteLine("Total commits: " + numCommits);
            float lineas = ((numCommits/programadores)/(años*365));

            Console.WriteLine("Lineas media por dia: " + lineas);
            //ObtenerComits(repo);
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.Write("\r\nFin");
            Console.Read();
        }

        /// <summary>
        /// Get the git configuration
        /// </summary>
        /// <returns>A Config object.</returns>
        public Config GetConfig()
        {
            //Run at startup, this will create the global repository, only needs to be run once.
            Repository.Init(GlobalGitRepositoryLocation, true);

            //Run at startup, this will create the instance specific clone on the local machine, should be run on every service start.
            //Don't need to do this more than once the first time
            if (!Repository.IsValid(LocalGitRepositoryLocation)) { Repository.Clone(GlobalGitRepositoryLocation, LocalGitRepositoryLocation, new CloneOptions { IsBare = true }); }

            //In application code attempt to use the git repository
            using (var repository = new Repository(LocalGitRepositoryLocation))
            {
                try { repository.Network.Fetch(repository.Network.Remotes[ConfigurationRemote]); } catch { }

                var refOriginMaster = repository.Refs[ConfigurationRemoteRef];
                if (refOriginMaster == null) { return new Config(); }

                var sha = refOriginMaster.TargetIdentifier;

                var configFile = repository.Lookup<Commit>(sha)[GitConfigurationFile];
                if (configFile == null || !(configFile.Target is Blob)) { return new Config(); }

                using (var fileStream = ((Blob)configFile.Target).GetContentStream())
                using (var reader = new StreamReader(fileStream, Encoding.UTF8))
                {
                    var result = reader.ReadToEnd();
                    try { return new JavaScriptSerializer().Deserialize<Config>(result); }
                    catch { return new Config(); }
                }
            }
        }

 public static void AddUpdateFile(string FileName, string RepoPath)
 {
     using (var repo = new Repository(RepoPath))
     {
         repo.Index.Stage(FileName);
     }
 }

        private void btnCommit_Click(object sender, RibbonControlEventArgs e)
        {
            //Get Active  Project
            var pj = Globals.ThisAddIn.Application.ActiveProject;

            //Get Project Filename.
            var projectFile = pj.FullName;

            //Get Directory from File Name
            var directory = Path.GetDirectoryName(projectFile);

            //Create a new Git Repository
            Repository.Init(directory);

            //Open the git repository in a using context so its automatically disposed of.
            using (var repo = new Repository(directory))
            {
                // Stage the file
                repo.Index.Stage(projectFile);

                // Create the committer's signature and commit
                var author = new Signature("Richard", "@ARM", DateTime.Now);
                var committer = author;

                // Commit to the repository
                var commit = repo.Commit("Initial commit", author, committer);
            }
        }

 public void TestLibGit2_CreateLocalBranches()
 {
     using (var myRepository = new Repository(@"C:\dev1\Gsx.Monitor.Project"))
     {
         Trace.WriteLine(string.Join("\n", from b in myRepository.Branches select $"{b.FriendlyName}({b.IsRemote})"));
     }
 }

 protected RepositoryBase(string path, string repoName, string userName, string password)
 {
     Repository = new Repository(path);
     RepositoryName = repoName;
     UserName = userName;
     Password = password;
 }

        /// <summary>
        /// Builds the file history from a repository path, file path and the reference to object SysVersionControlTmpItem
        /// </summary>
        /// <param name="repoPath">Repository main path</param>
        /// <param name="filePath">File to be pulling the commits</param>
        /// <param name="tmpItem">Ref to the SysVersionControlTmpItem object to be inserting to</param>
        /// <returns>A SysVersionControlTmpItem filled with the commits</returns>
        public static SysVersionControlTmpItem BuildFileHistory(string repoPath, string filePath, ref SysVersionControlTmpItem tmpItem)
        {
            FileInfo fileInfo = new FileInfo(filePath);

            using (var repo = new Repository(repoPath))
            {
                var indexPath = fileInfo.FullName.Replace(repo.Info.WorkingDirectory, string.Empty);
                var commits = repo.Head.Commits.Where(c => c.Parents.Count() == 1 && c.Tree[indexPath] != null && (c.Parents.FirstOrDefault().Tree[indexPath] == null || c.Tree[indexPath].Target.Id != c.Parents.FirstOrDefault().Tree[indexPath].Target.Id));

                foreach (Commit commit in commits)
                {
                    tmpItem.User = commit.Author.ToString();
                    tmpItem.GTXShaShort = commit.Sha.Substring(0, 7);
                    tmpItem.GTXSha = commit.Sha;
                    tmpItem.Comment = commit.Message;
                    tmpItem.ShortComment = commit.MessageShort;
                    tmpItem.VCSDate = commit.Committer.When.Date;
                    tmpItem.VCSTime = (int)commit.Committer.When.DateTime.TimeOfDay.TotalSeconds;
                    tmpItem.Filename_ = FileGetVersion(repoPath, fileInfo.FullName, commit.Sha, Path.Combine(Path.GetTempPath(), string.Format("{0}_{1}", commit.Sha.Substring(0, 7), fileInfo.Name)));
                    tmpItem.InternalFilename = fileInfo.FullName;
                    tmpItem.ItemPath = indexPath;
                    tmpItem.GTXFileRepoStatus = GetFileStatus(repoPath, fileInfo.FullName);
                    tmpItem.insert();
                }
            }

            return tmpItem;
        }

        public void ChangeBranch(RepositoryItem repository, string BranchName)
        {
            var repo = new LibGit2Sharp.Repository(repository.Path);

            var branches = repo.Branches.Where(b => b.Name == BranchName).ToList();
            if (branches.Any())
            {
                var localBranch = branches.FirstOrDefault(x => !x.IsRemote);
                if (localBranch != null)
                {
                    repo.Checkout(localBranch, new CheckoutOptions(), new Signature(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.Now));
                }
                else
                {
                    throw new Exception("You must checkout manually the first time");

                    //COMMENTED THIS OUT AS IT CREATES DUPLICATE REMOTE BRANCHES, For instance R15_Release will duplicate as origin/R15_Release.
                    //Current work around is to get them to check out the branch manually the first time around.

                    //var remoteBranch = branches.FirstOrDefault(x => x.IsRemote);
                    //if (remoteBranch != null)
                    //{
                    //    var newLocalBranch = repo.CreateBranch(BranchName, remoteBranch.Tip);
                    //    newLocalBranch = repo.Branches.Update(newLocalBranch,
                    //        b =>
                    //        {
                    //            b.TrackedBranch = remoteBranch.CanonicalName;
                    //        });
                    //    repo.Checkout(newLocalBranch, new CheckoutOptions(), new Signature(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.Now));
                    //}
                }
            }
        }

        public static void NormalizeGitDirectory(string gitDirectory, Arguments arguments, string branch = null)
        {
            using (var repo = new Repository(gitDirectory))
            {
                var remote = EnsureOnlyOneRemoteIsDefined(repo);

                AddMissingRefSpecs(repo, remote);

                Logger.WriteInfo(string.Format("Fetching from remote '{0}' using the following refspecs: {1}.",
                    remote.Name, string.Join(", ", remote.FetchRefSpecs.Select(r => r.Specification))));

                var fetchOptions = BuildFetchOptions(arguments.Username, arguments.Password);
                repo.Network.Fetch(remote, fetchOptions);

                CreateMissingLocalBranchesFromRemoteTrackingOnes(repo, remote.Name);

                if (!repo.Info.IsHeadDetached)
                {
                    Logger.WriteInfo(string.Format("HEAD points at branch '{0}'.", repo.Refs.Head.TargetIdentifier));
                    return;
                }

                Logger.WriteInfo(string.Format("HEAD is detached and points at commit '{0}'.", repo.Refs.Head.TargetIdentifier));

                if (branch != null)
                {
                    Logger.WriteInfo(string.Format("Checking out local branch 'refs/heads/{0}'.", branch));
                    repo.Checkout("refs/heads/" + branch);
                }
                else
                {
                    CreateFakeBranchPointingAtThePullRequestTip(repo);
                }
            }
        }

 public void CreateEmptyRepo()
 {
     _repoPath = Environment.CurrentDirectory + "\\myRepo";
     var directory = Directory.CreateDirectory(_repoPath);
     LibGit2Sharp.Repository.Init(_repoPath);
     _repo = new LibGit2Sharp.Repository(_repoPath);
 }

        public BranchInfoActor()
        {
            Receive<GetBranchInfo>(message =>
            {
                Logger.WriteLine($"Starting Branch info {message.DirPath} -> {message.BranchName}");
                using (var repository = new Repository(message.RepositoryPath))
                {
                    var branch = repository.Branches[message.BranchName];
                    var branchLastCommit = branch.Tip;
                    var branchInfo = new BranchInfo
                    {
                        Name = branch.Name,
                        CommitterDate = branchLastCommit.Committer.When,
                        CommitterName = branchLastCommit.Committer.Name,
                        CommitterEmail = branchLastCommit.Committer.Email,
                        Message = branchLastCommit.Message,
                        Sha = branchLastCommit.Sha,
                    };

                    var repoAndBranchInfo = new RepoAndBranchInfo(message.DirPath, branchInfo);

                    Context.ActorSelection(ActorSelectionRouting.BranchInfoAggregationActorPath)
                        .Tell(new RepositoryAndBranchInfo(repoAndBranchInfo));

                }
            });
        }

        //readonly Tree masterTree;
        //readonly Tree currentTree;
        public Stalker(String localRepo, String sourceFileName, String ignoreFileName, String localStalkBranch = null, String targetTag = null, String localMaster = "master")
        {
            repo = new Repository (localRepo);

            master = repo.Branches.Single (branch => branch.FriendlyName == localMaster);

            if (targetTag != null) {
                tag = repo.Tags.Single (t => t.FriendlyName == targetTag);
            }

            //			if (localStalkBranch != null)
                head = repo.Branches.Single (branch => branch.FriendlyName == localStalkBranch);
            //			else
            //				head = repo.Head;

            //			if (head != repo.Branches.Single (b => b.IsCurrentRepositoryHead)) {
            //                repo.Checkout(head);
            //			}
            //            head = repo.Branches.Single(b => b.IsCurrentRepositoryHead);
            //var filter = new CommitFilter { Since = repo.Branches["master"], Until = repo.Branches["development"] };
            //masterTree = repo.Lookup<Tree>(master.Tip.Sha);
            //currentTree = repo.Lookup<Tree>(head.Tip.Sha);
            try {
                sources = File.ReadAllLines (Path.Combine (localRepo, sourceFileName));
            } catch {
            } finally {
            }
            try {
                ignore = File.ReadAllLines (Path.Combine (localRepo, ignoreFileName));
            } catch {
            } finally {
            }
        }

        public Task<List<ISourceItem>> FetchAllFiles(BuildConfig config)
        {

            string gitFolder = config.BuildFolder + "\\git";

            //// temporary hack...
            //// git-pull does not work
            //if (Directory.Exists(gitFolder)) {
            //    Directory.Delete(gitFolder, true);
            //}

            if (!Directory.Exists(gitFolder))
            {
                Directory.CreateDirectory(gitFolder);


                Console.WriteLine("Cloning repository " + config.SourceUrl);

                CloneOptions clone = new CloneOptions();
                clone.CredentialsProvider = CredentialsHandler;
                var rep = Repository.Clone(config.SourceUrl, gitFolder, clone);

                Console.WriteLine("Repository clone successful");
            }
            else {
                Console.WriteLine("Fetching remote Repository");
                var rep = new Repository(gitFolder);
                FetchOptions options = new FetchOptions();
                options.CredentialsProvider = CredentialsHandler;
                Remote remote = rep.Network.Remotes["origin"];

                //Commands.Fetch(rep,remote.Name,)

                //rep.Fetch(remote.Name, options);
                var master = rep.Branches["master"];
                Commands.Pull(rep, new Signature("IISCI", "[email protected]", DateTime.Now),  new PullOptions()
                {
                    FetchOptions = options,
                    MergeOptions = new MergeOptions() { 
                        MergeFileFavor = MergeFileFavor.Theirs,
                        CommitOnSuccess = true                        
                    }
                });
                Console.WriteLine("Fetch successful");
            }

            List<ISourceItem> files = new List<ISourceItem>();

            EnumerateFiles( new DirectoryInfo(gitFolder), files, "" );


            Parallel.ForEach(files, file =>
            {
                var md5 = System.Security.Cryptography.MD5.Create();
                ((GitSourceItem)file).Version = Convert.ToBase64String(md5.ComputeHash(File.ReadAllBytes(file.Url)));
            });


            return Task.FromResult(files);
        }

        // GET api/values
        public HttpResponseMessage Get(string path)
        {
            using (var repo = new Repository(path))
            {
                var files = repo
                    .RetrieveStatus(new StatusOptions() { IncludeUnaltered = true })
                    .Where(s => s.State != FileStatus.Ignored && s.State != FileStatus.NewInWorkdir)
                    .Select(s => s.FilePath)
                    .ToList();
                var diffs =
                    files.Select(f => new { path = f, history = repo.Commits.QueryBy(f).Select(x => x.Commit).ToList() })
                        .ToList();

                var patches =
                    diffs.Select(
                        d =>
                            new
                            {
                                d.path,
                                history =
                                    d.history.Where(p => p.Parents.Any())
                                        .SelectMany(
                                            c =>
                                                repo.Diff.Compare<Patch>(c.Parents.First().Tree,c.Tree)
                                                    .Where(p => p.Path == d.path)
                                                    .Select(p => new { p.LinesAdded, p.LinesDeleted, c.Author.When })
                                                    .ToArray())
                                        .ToArray()
                            }).ToArray();
                return Request.CreateResponse(HttpStatusCode.OK, patches);
            }
        }