private void DescribeTfsRemotes(IGitTfsRemote remote)
 {
     // add a line of whitespace to improve readability
     stdout.WriteLine();
     stdout.WriteLine("remote tfs id: '{0}' {1} {2}", remote.Id, remote.TfsUrl, remote.TfsRepositoryPath);
     stdout.WriteLine("               {0} - {1} @ {2}", remote.RemoteRef, remote.MaxCommitHash, remote.MaxChangesetId);
 }

        /// <summary>
        /// Configures a IGitTfsRemote to export metadata
        /// </summary>
        /// <param name="remote"></param>
        /// <param name="shouldExportMetadata"></param>
        public void InitializeRemote(IGitTfsRemote remote, bool shouldExportMetadata)
        {
            remote.ExportMetadatas = shouldExportMetadata;
            remote.ExportWorkitemsMapping = new Dictionary<string, string>();

            if (shouldExportMetadata && File.Exists(exportMetadatasFilePath))
            {
                try
                {
                    foreach (var lineRead in File.ReadAllLines(exportMetadatasFilePath))
                    {
                        if (string.IsNullOrWhiteSpace(lineRead))
                            continue;
                        var values = lineRead.Split('|');
                        var oldWorkitem = values[0].Trim();
                        if (!remote.ExportWorkitemsMapping.ContainsKey(oldWorkitem))
                            remote.ExportWorkitemsMapping.Add(oldWorkitem, values[1].Trim());
                    }
                }
                catch (Exception)
                {
                    throw new GitTfsException("error: bad format of workitems mapping file! One line format should be: OldWorkItemId|NewWorkItemId");
                }
            }
        }

 protected override void DoFetch(IGitTfsRemote remote, bool stopOnFailMergeCommit)
 {
     if (InitialChangeset.HasValue)
         remote.QuickFetch(InitialChangeset.Value);
     else
         remote.QuickFetch();
 }

 protected override void DoFetch(IGitTfsRemote remote)
 {
     if (InitialChangeset.HasValue)
         remote.QuickFetch(InitialChangeset.Value);
     else
         remote.QuickFetch();
 }

 public IEnumerable<ITfsChangeset> GetChangesets(string path, long startVersion, IGitTfsRemote remote, long lastVersion = -1, bool byLots = false)
 {
     if (!_script.Changesets.Any(c => c.IsBranchChangeset) && _script.Changesets.Any(c => c.IsMergeChangeset))
         return _script.Changesets.Where(x => x.Id >= startVersion).Select(x => BuildTfsChangeset(x, remote));
     return _script.Changesets
         .Where(x => x.Id >= startVersion && x.Changes.Any(c => c.RepositoryPath.ToLower().IndexOf(path.ToLower()) == 0 || path.ToLower().IndexOf(c.RepositoryPath.ToLower()) == 0))
         .Select(x => BuildTfsChangeset(x, remote));
 }

 public TfsWorkspace(Workspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote)
 {
     _workspace = workspace;
     _contextVersion = contextVersion;
     _remote = remote;
     _localDirectory = localDirectory;
     _stdout = stdout;
 }

 protected override void DoFetch(IGitTfsRemote remote)
 {
     if (changeSetId == default(int))
         // Just grab the latest changeset:
         remote.QuickFetch();
     else
         // Use a specific changeset to start from:
         remote.QuickFetch(changeSetId);
 }

 protected override void DoFetch(IGitTfsRemote remote, bool stopOnFailMergeCommit)
 {
     if (InitialChangeset.HasValue)
         remote.QuickFetch(InitialChangeset.Value);
     else
         remote.QuickFetch();
     _properties.InitialChangeset = remote.MaxChangesetId;
     _properties.PersistAllOverrides();
 }

 public IEnumerable<ITfsChangeset> GetChangesets(string path, int startVersion, IGitTfsRemote remote, int lastVersion = -1, bool byLots = false)
 {
     if (!_script.Changesets.Any(c => c.IsBranchChangeset) && _script.Changesets.Any(c => c.IsMergeChangeset))
         return _script.Changesets.Where(x => x.Id >= startVersion).Select(x => BuildTfsChangeset(x, remote));
     var branchPath = path + "/";
     return _script.Changesets
         .Where(x => x.Id >= startVersion && x.Changes.Any(c => c.RepositoryPath.IndexOf(branchPath, StringComparison.CurrentCultureIgnoreCase) == 0 || branchPath.IndexOf(c.RepositoryPath, StringComparison.CurrentCultureIgnoreCase) == 0))
         .Select(x => BuildTfsChangeset(x, remote));
 }

 protected override void DoFetch(IGitTfsRemote remote)
 {
     if (InitialChangeset.HasValue)
         // Just grab the latest changeset:
         remote.QuickFetch();
     else
         // Use a specific changeset to start from:
         remote.QuickFetch(InitialChangeset.Value);
 }

 protected virtual void DoFetch(IGitTfsRemote remote)
 {
     // It is possible that we have outdated refs/remotes/tfs/<id>.
     // E.g. someone already fetched changesets from TFS into another git repository and we've pulled it since
     // in that case tfs fetch will retrieve same changes again unnecessarily. To prevent it we will scan tree from HEAD and see if newer changesets from
     // TFS exists (by checking git-tfs-id mark in commit's comments).
     // The process is similar to bootstrapping.
     globals.Repository.MoveTfsRefForwardIfNeeded(remote);
     remote.Fetch();
 }

 public TfsWorkspace(IWorkspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote, CheckinOptions checkinOptions, ITfsHelper tfsHelper)
 {
     _workspace = workspace;
     _contextVersion = contextVersion;
     _remote = remote;
     _checkinOptions = checkinOptions;
     _tfsHelper = tfsHelper;
     _localDirectory = localDirectory;
     _stdout = stdout;
 }

        private void InitMocks4Tests(out IGitRepository gitRepository, out IGitTfsRemote remote)
        {
            // mock git repository
            gitRepository = _mocks.Get<IGitRepository>();
            gitRepository.Stub(r => r.HasRemote(Arg<string>.Is.Anything)).Return(true);
            _mocks.Get<Globals>().Repository = gitRepository;

            // mock tfs remote
            _mocks.Get<Globals>().UserSpecifiedRemoteId = "default";
            remote = MockRepository.GenerateStub<IGitTfsRemote>();
            gitRepository.Stub(r => r.ReadTfsRemote(Arg<string>.Is.Anything)).Return(remote);
        }

        private int CreateLabelsForTfsBranch(IGitTfsRemote tfsRemote)
        {
            if (string.IsNullOrWhiteSpace(NameFilter))
                NameFilter = null;
            else
                NameFilter = NameFilter.Trim();

            UpdateRemote(tfsRemote);
            _stdout.WriteLine("Looking for label on " + tfsRemote.TfsRepositoryPath + "...");
            var labels = tfsRemote.Tfs.GetLabels(tfsRemote.TfsRepositoryPath, NameFilter);
            _stdout.WriteLine(labels.Count() +" labels found!");

            Regex exludeRegex = null;
            if (ExcludeNameFilter != null)
                exludeRegex = new Regex(ExcludeNameFilter);

            foreach (var label in labels)
            {
                if (ExcludeNameFilter != null && exludeRegex.IsMatch(label.Name))
                    continue;

                Trace.WriteLine("LabelId:" + label.Id + "/ChangesetId:" + label.ChangesetId + "/LabelName:" + label.Name + "/Owner:" + label.Owner);
                Trace.WriteLine("Try to find changeset in git repository...");
                string sha1TagCommit = _globals.Repository.FindCommitHashByChangesetId(label.ChangesetId);
                if (string.IsNullOrWhiteSpace(sha1TagCommit))
                {
                    Trace.WriteLine("This label does not match an existing commit...");
                    continue;
                }
                Trace.WriteLine("Commit found! sha1 : " + sha1TagCommit);

                string ownerName;
                string ownerEmail;
                if(_authors.Authors.ContainsKey(label.Owner))
                {
                    var author = _authors.Authors[label.Owner];
                    ownerName = author.Name;
                    ownerEmail = author.Email;
                }
                else
                {
                    ownerName = label.Owner;
                    ownerEmail = label.Owner;
                }
                var labelName = (label.IsTransBranch ? label.Name + "(" + tfsRemote.Id + ")" : label.Name).ToGitRefName();
                _stdout.WriteLine("Writing label '" + labelName + "'...");
                _globals.Repository.CreateTag(labelName, sha1TagCommit, label.Comment, ownerName, ownerEmail ,label.Date);
            }
            return GitTfsExitCodes.OK;
        }

        private void InitMocks4Tests(string gitBranchToInit, out IGitRepository gitRepository, out IGitTfsRemote remote, out IGitTfsRemote newBranchRemote)
        {
            gitRepository = mocks.Get<IGitRepository>();
            mocks.Get<Globals>().Repository = gitRepository;
            mocks.Get<Globals>().GitDir = ".git";
            remote = MockRepository.GenerateStub<IGitTfsRemote>();
            remote.TfsUsername = "user";
            remote.TfsPassword = "pwd";
            remote.TfsRepositoryPath = "$/MyProject/Trunk";
            remote.TfsUrl = "http://myTfsServer:8080/tfs";
            remote.Tfs = new VsFake.TfsHelper(mocks.Container, null, null);
            gitRepository.Stub(r => r.GitDir).Return(".");

            newBranchRemote = MockRepository.GenerateStub<IGitTfsRemote>();
            newBranchRemote.Id = gitBranchToInit;
        }

 private void DescribeTfsRemotes(IGitTfsRemote remote)
 {
     DisplayReadabilityLineJump();
     _stdout.WriteLine("remote tfs id: '{0}' {1} {2}", remote.Id, remote.TfsUrl, remote.TfsRepositoryPath);
     _stdout.WriteLine("               {0} - {1} @ {2}", remote.RemoteRef, remote.MaxCommitHash, remote.MaxChangesetId);
 }

        private string FindTfsRepositoryPathOfMergedBranch(IGitTfsRemote remoteToCheckin, string[] gitParents, string target)
        {
            var repo = remoteToCheckin.Repository;
            if (gitParents.Length != 0)
            {
                _stdout.WriteLine("Working on the merge commit: " + target);
                if (gitParents.Length > 1)
                    _stdout.WriteLine("warning: only 1 parent is supported by TFS for a merge changeset. The other parents won't be materialized in the TFS merge!");
                foreach (var gitParent in gitParents)
                {
                    var tfsCommit = repo.GetTfsCommit(gitParent);
                    if (tfsCommit != null)
                        return tfsCommit.Remote.TfsRepositoryPath;
                    var lastCheckinCommit = repo.GetLastParentTfsCommits(gitParent).First();
                    if (lastCheckinCommit != null)
                    {
                        if(!ForceCheckin && lastCheckinCommit.Remote.Id != remoteToCheckin.Id)
                            throw new GitTfsException("error: the merged branch '" + lastCheckinCommit.Remote.Id
                                + "' is a TFS tracked branch ("+lastCheckinCommit.Remote.TfsRepositoryPath
                                + ") with some commits not checked in.\nIn this case, the local merge won't be materialized as a merge in tfs...")
                                .WithRecommendation("check in all the commits of the tfs merged branch in TFS before trying to check in a merge commit",
                                "use --ignore-merge option to ignore merged TFS branch and check in commit as a normal changeset (not a merge).");
                    }

                    _stdout.WriteLine("warning: the parent " + gitParent + " does not belong to a TFS tracked branch (not checked in TFS) and will be ignored!");
                }
            }
            return null;
        }

 private ITfsChangeset BuildTfsChangeset(ScriptedChangeset changeset, IGitTfsRemote remote)
 {
     var tfsChangeset = _container.With<ITfsHelper>(this).With<IChangeset>(new Changeset(_versionControlServer, changeset)).GetInstance<TfsChangeset>();
     tfsChangeset.Summary = new TfsChangesetInfo { ChangesetId = changeset.Id, Remote = remote };
     return tfsChangeset;
 }

 public void WithWorkspace(string directory, IGitTfsRemote remote, TfsChangesetInfo versionToFetch, Action<ITfsWorkspace> action)
 {
     Trace.WriteLine("Setting up a TFS workspace at " + directory);
     var fakeWorkspace = new FakeWorkspace(directory, remote.TfsRepositoryPath);
     var workspace = _container.With("localDirectory").EqualTo(directory)
         .With("remote").EqualTo(remote)
         .With("contextVersion").EqualTo(versionToFetch)
         .With("workspace").EqualTo(fakeWorkspace)
         .With("tfsHelper").EqualTo(this)
         .GetInstance<TfsWorkspace>();
     action(workspace);
 }

 public int ListShelvesets(ShelveList shelveList, IGitTfsRemote remote)
 {
     throw new NotImplementedException();
 }