public ActionResult Index()
        {
            var dirs = Directory.GetDirectories(_settings.RepositoryRootPath);
            var viewModel = new RepositoriesViewModel { List = new List<RepositoryViewModel>() };
            foreach (string path in dirs)
            {
                var isValid = Repository.IsValid(path);
                if (isValid)
                {
                    using (var repo = new Repository(path))
                    {
                        viewModel.List.Add(new RepositoryViewModel
                        {
                            Name = repo.IsBare ? Path.GetFileName(repo.Directory.TrimGit())
                            : Path.GetFileName(path.TrimGit()),
                            Description = repo.Directory,
                            Path = repo.Directory,
                            CurrentCommit = repo.Branches["master"].CurrentCommit
                        });
                    }
                }

            }

            return View(viewModel);
        }

        public void LoadBackupList(WorldSave save)
        {
            backupView.Items.Clear();

            if (!Repository.IsValid(save.Path))
                return;

            using (Repository repo = new Repository(save.Path))
            {
                foreach (Commit commit in repo.CurrentBranch.CurrentCommit.Ancestors)
                {
                    DateTime commitTime = commit.CommitDate.LocalDateTime;

                    ListViewItem item = new ListViewItem(commit.Message);
                    ListViewItem.ListViewSubItem dateItem = item.SubItems.Add(
                        commitTime.ToString());
                    dateItem.Name = "date";

                    ListViewItem.ListViewSubItem hashItem =
                        item.SubItems.Add(commit.ShortHash);
                    hashItem.Name = "shorthash";

                    ListViewItem.ListViewSubItem longHashItem =
                        item.SubItems.Add(commit.Hash);
                    longHashItem.Name = "hash";

                    backupView.Items.Add(item);
                }
            }
        }

 ///	<summary>
 /// Parsed reflog entry.
 /// </summary>
 public ReflogReader(Repository db, string refName)
 {
     _logName = new FileInfo(
         Path.Combine(
             db.Directory.FullName,
                 Path.Combine("logs", refName)).Replace('/', Path.DirectorySeparatorChar));
 }

 private void LoadRepository()
 {
     if (!Directory.Exists(Path.Combine(ResourceLocation, ".git"))) {
         Git.Init(ResourceLocation);
     }
     Repo = new Repository(ResourceLocation);
 }

 protected void SetupContext()
 {
     _nicolai = new Author("Nicolai Meltveit", "[email protected]");
     _repositoryUrl = "git://github.com/flyrev/Smeedee_dummy.git";
     _localDirectory = "C:\\ennå_nyare\\";
     _repo = new Repository(_localDirectory);
 }

 ///	<summary>
 /// Construct an object writer for the specified repository.
 /// </summary>
 ///	<param name="repo"> </param>
 public ObjectWriter(Repository repo)
 {
     _r = repo;
     _buf = new byte[0x2000];
     _md = new MessageDigest();
     _def = new Deflater(_r.Config.getCore().getCompression());
 }

 public ObjectWriter(Repository repo)
 {
     this.r = repo;
     buf = new byte[8192];
     md = new MessageDigest(); // [henon] Sha1 hash digest generator
     def = new Deflater(r.Config.Core.Compression);
 }

 public Index(Repository repo)
 {
     _repo = repo;
     //GitIndex.FilenameEncoding = repo.PreferredEncoding;
     //if (_repo.PreferredEncoding != Encoding.UTF8 && _repo.PreferredEncoding != Encoding.Default)
     //   GitIndex.FilenameEncoding = Encoding.Default;
 }

        /// <summary>
        /// TODO: only get GitDetail on Project level?
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static GitDetail GetGitDetail(string path)
        {
            GitDetail detail = null;
            if (string.IsNullOrEmpty(path)) return detail;
            try
            {
                var repoPath = Repository.FindRepository(path);
                if (string.IsNullOrEmpty(repoPath)) return detail;

                var repo = new Repository(repoPath);

                detail = new GitDetail();
                // Convert to forward slash
                detail.LocalWorkingDirectory = repo.WorkingDirectory.BackSlashToForwardSlash();
                if (repo.Head == null) return detail;

                var branch = repo.CurrentBranch;
                detail.RemoteRepositoryUrl = repo.Config["remote.origin.url"];
                detail.RemoteBranch = branch.Name;
                // detail.Description = repo.Head.CurrentCommit.ShortHash;
                detail.RelativePath = PathUtility.MakeRelativePath(Path.GetDirectoryName(repoPath), path);
            }
            catch (Exception)
            {
                // SWALLOW exception?
                // Console.Error.WriteLine(e.Message);
            }

            return detail;
        }

 public RefDatabase(Repository repo)
 {
     Repository = repo;
     _gitDir = repo.Directory;
     _refsDir = PathUtil.CombineDirectoryPath(_gitDir, "refs");
     _packedRefsFile = PathUtil.CombineFilePath(_gitDir, "packed-refs");
     ClearCache();
 }

        private readonly int tzOffset; // offset in minutes to UTC

        #endregion Fields

        #region Constructors

        ///	<summary>
        /// Creates new PersonIdent from config info in repository, with current time.
        ///	This new PersonIdent gets the info from the default committer as available
        ///	from the configuration.
        ///	</summary>
        ///	<param name="repo"></param>
        public PersonIdent(Repository repo)
        {
            RepositoryConfig config = repo.Config;
            string username = config.getString("user", null, "name");
            string email = config.getString("user", null, "email");
            Name = username;
            EmailAddress = email;
        }

 ///	<summary>
 /// Create a checkout class for checking out one tree, merging with the index
 ///	</summary>
 ///	<param name="repo"> </param>
 ///	<param name="root"> workdir </param>
 ///	<param name="index"> current index </param>
 ///	<param name="merge"> tree to check out </param>
 public WorkDirCheckout(Repository repo, FileSystemInfo root, GitIndex index, Tree merge)
     : this()
 {
     this._repo = repo;
     this._root = root;
     this._index = index;
     this._merge = merge;
 }

        public Versioning(Data data, GitSharp.Repository repo)
        {
            GitDetails = null;
            InitializeComponent();
            VersionControlData = data;
            _repo = repo;

            LoadFileStructure();
        }

 public RepositoryNavigationViewModelBase(Repository repository, RepositoryNavigationRequest request)
     : this()
 {
     RepositoryName = request.RepositoryName;
     Treeish = request.Treeish;
     Path = request.Path;
     RepositoryLocation = request.RepositoryLocation;
     FillFromRepository(repository, request);
 }

 public PersonIdent(Repository repo)
 {
     RepositoryConfig config = repo.Config;
     string username = config.GetString("user", null, "name");
     string email = config.GetString("user", null, "email");
     this.Name = username;
     this.EmailAddress = email;
     this.when_time = DateTimeOffset.Now;
 }

        public static IEnumerable<Change> GetChanges(string path, string firstIdentifier, string secondIdentifier, string repositoryPath = "Backend.git")
        {
            var repo = new Repository(repositoryPath);

            var firstCommit = repo.Get<Commit>(firstIdentifier);
            var secondCommit = repo.Get<Commit>(secondIdentifier);
            if (firstCommit == null || secondCommit == null) return null;

            return secondCommit.CompareAgainst(firstCommit).ToArray();
        }

 ///	<summary> * The constructor from object identifier
 ///	</summary>
 ///	<param name="base">the base configuration file </param>
 ///	<param name="r">the repository</param>
 /// <param name="objectid">the object identifier</param>
 /// <exception cref="IOException">
 /// the blob cannot be read from the repository. </exception>
 /// <exception cref="ConfigInvalidException">
 /// the blob is not a valid configuration format.
 /// </exception> 
 public BlobBasedConfig(Config @base, Repository r, ObjectId objectid)
     : base(@base)
 {
     ObjectLoader loader = r.OpenBlob(objectid);
     if (loader == null)
     {
         throw new IOException("Blob not found: " + objectid);
     }
     fromText(RawParseUtils.decode(loader.Bytes));
 }

        public void MyTestInitialize()
        {
            _tempFiles = new TempFiles();
            _repoPath = _tempFiles.GetTemporaryDirectory();
            _gitPath = Path.Combine(_repoPath, ".git");
            Directory.CreateDirectory(_gitPath);

            Program.Initialize();
            _gitRepository = new GitRepository(ObjectFactory.GetInstance<TextWriter>(), _gitPath);
            _csharpRepository = new Repository(_gitPath);
        }

 public CommitViewModel(Repository repository, RepositoryNavigationRequest request, Commit commit, bool fillParents)
     : base(new RepositoryNavigationRequest(request) { Treeish = commit.Hash })
 {
     if (fillParents)
     {
         Parents = new List<CommitViewModel>(commit.Parents.Select(x =>
             new CommitViewModel(repository, request, x, false)));
     }
     Tree = new TreeNodeViewModel(repository, request, commit.Tree);
     Commit = commit;
 }

        private readonly int tzOffset; // offset in minutes to UTC

        #endregion Fields

        #region Constructors

        public PersonIdent(Repository repo)
        {
            RepositoryConfig config = repo.Config;
            string username = config.getString("user", null, "name");
            string email = config.getString("user", null, "email");
            Name = username;
            EmailAddress = email;
            DateTimeOffset now = DateTimeOffset.Now;
            When = now.Millisecond;
            tzOffset = now.Offset.Minutes;
        }