public TreeDirectory(Repository repository, string relativePath, TreeDirectory parent, FileStatus status, string name)
: base(repository, relativePath, parent, status, name)
{
_directories = new List<TreeDirectory>();
_files = new List<TreeFile>();
_commits = new List<TreeCommit>();
}
public static Note CreateNote(Repository repository, NoteData noteData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(noteData, "noteData");
return new Note(repository, noteData.Name, noteData.ObjectName, noteData.Message);
}
public static void IsValidGitObject(GitNamedObjectWithLifetime gitObject, Repository repository, string parameterName)
{
Assert.IsNotNull(repository);
Assert.IsNeitherNullNorWhitespace(parameterName);
if(gitObject == null)
{
throw new ArgumentNullException(parameterName);
}
if(gitObject.Repository != repository)
{
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
Resources.ExcSuppliedObjectIsNotHandledByThisRepository,
gitObject.GetType().Name),
parameterName);
}
if(gitObject.IsDeleted)
{
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
Resources.ExcSuppliedObjectIsDeleted,
gitObject.GetType().Name),
parameterName);
}
}
internal StashedState(Repository repository, int index, Revision revision)
: base(repository, index.ToString().SurroundWith(GitConstants.StashName + "@{", "}"))
{
Verify.Argument.IsNotNull(revision, "revision");
Verify.Argument.IsNotNegative(index, "index");
_revision = revision;
}
public RevisionLog(Repository repository, IList<Revision> revisions)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(revisions, "revisions");
_repository = repository;
_revisions = revisions;
}
/// <summary>Create <see cref="User"/>.</summary>
/// <param name="repository">Related repository.</param>
/// <param name="name">User name.</param>
/// <param name="email">User email.</param>
/// <param name="commits">Commit count.</param>
internal User(Repository repository, string name, string email, int commits)
: base(repository, name + "\n" + email)
{
_name = name;
_email = email;
_commits = commits;
_avatar = new Gravatar(email);
}
public DynamicRevisionPointer(Repository repository, string pointer)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNeitherNullNorWhitespace(pointer, "pointer");
_repository = repository;
_pointer = pointer;
}
internal Revision(Repository repository, Hash hash)
: base(repository)
{
_parents = new RevisionParentsCollection();
_references = new RevisionReferencesCollection();
_hash = hash;
_hashString = hash.ToString();
}
public IndexChangesDiffSource(Repository repository, bool cached, IList<string> paths)
{
Verify.Argument.IsNotNull(repository, "repository");
_repository = repository;
_cached = cached;
_paths = paths;
_repository.Status.Changed += OnStatusChanged;
}
public RevisionLog(Repository repository, IList<Revision> revisions, Dictionary<Revision, IList<Revision>> parents)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(revisions, "revisions");
_repository = repository;
_revisions = revisions;
_parents = parents;
}
internal RemoteReferencesCollection(Remote remote)
{
Verify.Argument.IsNotNull(remote, "remote");
_remote = remote;
_repository = remote.Repository;
_remoteBranches = new Dictionary<string, RemoteRepositoryBranch>();
_remoteTags = new Dictionary<string, RemoteRepositoryTag>();
_syncRoot = new object();
}
/// <summary>Create <see cref="Hook"/>.</summary>
/// <param name="repository">Related <see cref="Repository"/>.</param>
/// <param name="name">Hook name.</param>
internal Hook(Repository repository, string name)
: base(repository, name)
{
_relativePath = "hooks" + Path.DirectorySeparatorChar + name;
_fullPath = Path.Combine(repository.GitDirectory, _relativePath);
if(!File.Exists(_fullPath))
{
MarkAsDeleted();
}
}
public static ConfigParameter CreateConfigParameter(Repository repository, ConfigParameterData configParameterData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(configParameterData, "configParameterData");
return new ConfigParameter(
repository,
configParameterData.ConfigFile,
configParameterData.Name,
configParameterData.Value);
}
public static void FetchOrPull(Repository repository, Remote remote, bool pull)
{
var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag;
if(pull)
{
affectedReferences |= ReferenceType.LocalBranch;
}
ReferenceChange[] changes;
var state1 = RefsState.Capture(repository, affectedReferences);
using(repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged,
RepositoryNotifications.TagChanged))
{
try
{
if(pull)
{
var p = new PullParameters();
if(remote != null)
{
p.Repository = remote.Name;
}
repository.Accessor.Pull.Invoke(p);
}
else
{
var p = new FetchParameters();
if(remote != null)
{
p.Repository = remote.Name;
}
repository.Accessor.Fetch.Invoke(p);
}
}
finally
{
repository.Refs.Refresh(affectedReferences);
var state2 = RefsState.Capture(repository, affectedReferences);
changes = RefsDiff.Calculate(state1, state2);
if(changes != null && changes.Length != 0)
{
repository.OnUpdated();
}
}
}
if(pull)
{
repository.Remotes.OnPullCompleted(remote, changes);
}
else
{
repository.Remotes.OnFetchCompleted(remote, changes);
}
}
/// <summary>Create <see cref="RepositoryMonitor"/>.</summary>
/// <param name="repository">Related <see cref="Repository"/>.</param>
internal RepositoryMonitor(Repository repository)
{
Verify.Argument.IsNotNull(repository, "repository");
_repository = repository;
_blockedNotifications = new List<NotificationBlock>();
_pendingNotifications = new Queue<IRepositoryChangedNotification>();
_delayedNotifications = new Queue<IRepositoryChangedNotification>();
_delayedUnblocks = new Queue<NotificationDelayedUnblock>();
}
protected TreeItem(Repository repository, string relativePath,
TreeDirectory parent, FileStatus status, string name)
: base(repository, name)
{
_parent = parent;
if(parent != null)
{
_stagedStatus = parent._stagedStatus;
}
_status = status;
_relativePath = relativePath;
}
/// <summary>Initializes a new instance of the <see cref="ReflogRecord"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="reflog">Owner reflog.</param>
/// <param name="revision">Target revision.</param>
/// <param name="message">Reflog record message.</param>
/// <param name="index">Reflog record index.</param>
internal ReflogRecord(Repository repository, Reflog reflog, Revision revision, string message, int index)
: base(repository)
{
Verify.Argument.IsNotNull(reflog, "reflog");
Verify.Argument.IsNotNull(revision, "revision");
Verify.Argument.IsNotNull(message, "message");
Verify.Argument.IsNotNegative(index, "index");
_reflog = reflog;
_revision = revision;
_message = message;
_index = index;
}
/// <summary>Create <see cref="Reference"/>.</summary>
/// <param name="repository">Host <see cref="Repository"/>.</param>
/// <param name="name">Reference name.</param>
/// <param name="pointer">Referenced object.</param>
internal Reference(Repository repository, string name, IRevisionPointer pointer)
: base(repository, name)
{
Verify.Argument.IsNotNull(pointer, "pointer");
_pointer = PrepareInputPointer(pointer);
_reflogSync = new object();
EnterPointer(_pointer);
var rev = _pointer.Dereference();
if(rev != null)
{
EnterRevision(_pointer.Dereference());
}
}
public static Branch CreateBranch(Repository repository, BranchData branchData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(branchData, "branchData");
Verify.Argument.IsFalse(branchData.IsRemote, "branchData", "Cannot create remote branch.");
Revision revision;
lock(repository.Revisions.SyncRoot)
{
revision = repository.Revisions.GetOrCreateRevision(branchData.SHA1);
}
var branch = new Branch(repository, branchData.Name, revision);
if(branchData.IsCurrent) repository.Head.Pointer = branch;
return branch;
}
private RefsState(Repository repository, ReferenceType referenceTypes)
{
_states = new Dictionary<string, ReferenceState>();
if((referenceTypes & ReferenceType.LocalBranch) == ReferenceType.LocalBranch)
{
CaptureHeads(repository);
}
if((referenceTypes & ReferenceType.RemoteBranch) == ReferenceType.RemoteBranch)
{
CaptureRemotes(repository);
}
if((referenceTypes & ReferenceType.Tag) == ReferenceType.Tag)
{
CaptureTags(repository);
}
}
private Tree(Repository repository, string treeHash, bool load)
: base(repository)
{
Verify.Argument.IsNeitherNullNorWhitespace(treeHash, "treeHash");
_treeHash = treeHash;
var strRoot = repository.WorkingDirectory;
if(strRoot.EndsWith("\\"))
{
strRoot = strRoot.Substring(0, strRoot.Length - 1);
}
int i = strRoot.LastIndexOf('\\');
string name = (i != -1) ? strRoot.Substring(i + 1) : strRoot;
_root = new TreeDirectory(Repository, string.Empty, null, name);
if(load)
{
Refresh();
}
}
/// <summary>Create <see cref="Status"/> object.</summary>
/// <param name="repository">Related repository.</param>
internal Status(Repository repository)
: base(repository)
{
_unstagedPlainList = new Dictionary<string, TreeFile>();
_stagedPlainList = new Dictionary<string, TreeFile>();
var strRoot = Repository.WorkingDirectory;
if(strRoot.EndsWithOneOf(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))
{
strRoot = strRoot.Substring(0, strRoot.Length - 1);
}
_unstagedRoot = new TreeDirectory(Repository, string.Empty, null, strRoot)
{
StagedStatus = StagedStatus.Unstaged
};
_stagedRoot = new TreeDirectory(Repository, string.Empty, null, strRoot)
{
StagedStatus = StagedStatus.Staged
};
}
public TreeFile(Repository repository, string relativePath, TreeDirectory parent, FileStatus status, string name, long size)
: base(repository, relativePath, parent, status, name)
{
_size = size;
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="pointer">Target of this reference.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository, IRevisionPointer pointer)
: base(repository, GitConstants.HEAD, pointer)
{
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository)
: base(repository, GitConstants.HEAD, GetHeadPointer(repository))
{
}
/// <summary>Returns object pointed by HEAD.</summary>
/// <param name="repository">Repository to get HEAD from.</param>
/// <returns>Object pointed by HEAD of the specified repository.</returns>
private static IRevisionPointer GetHeadPointer(Repository repository)
{
var head = repository.Accessor.QuerySymbolicReference.Invoke(
new QuerySymbolicReferenceParameters(GitConstants.HEAD));
switch(head.TargetType)
{
case ReferenceType.LocalBranch:
Branch branch;
lock(repository.Refs.Heads.SyncRoot)
{
branch = repository.Refs.Heads.TryGetItem(head.TargetObject);
if(branch == null)
{
var info = repository.Accessor.QueryBranch.Invoke(
new QueryBranchParameters(head.TargetObject, false));
if(info != null)
{
branch = repository.Refs.Heads.NotifyCreated(info);
}
}
}
if(branch == null)
{
return new NowherePointer(repository, head.TargetObject);
}
else
{
return branch;
}
case ReferenceType.Revision:
lock(repository.Revisions.SyncRoot)
{
return repository.Revisions.GetOrCreateRevision(new Hash(head.TargetObject));
}
default:
return new NowherePointer(repository, head.TargetObject);
}
}
public Revision Merge(ICollection <IRevisionPointer> branches, bool noCommit, bool noFastForward, bool squash, string message)
{
Verify.Argument.IsValidRevisionPointerSequence(branches, Repository, "branches");
Verify.Argument.IsTrue(branches.Count != 0, "branches",
Resources.ExcCollectionMustContainAtLeastOneObject.UseAsFormat("branch"));
Verify.State.IsFalse(IsEmpty,
Resources.ExcCantDoOnEmptyRepository.UseAsFormat("merge"));
if (branches.Count == 1)
{
foreach (var branch in branches)
{
return(Merge(branch, noCommit, noFastForward, squash, message));
}
}
var oldRevs = new List <Revision>(branches.Count);
var branchNames = new List <string>(branches.Count);
foreach (var branch in branches)
{
oldRevs.Add(branch.Dereference());
branchNames.Add(branch.FullName);
}
var currentBranch = CurrentBranch;
using (Repository.Monitor.BlockNotifications(
RepositoryNotifications.Checkout,
RepositoryNotifications.WorktreeUpdated,
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.BranchChanged))
{
try
{
Repository.Accessor.Merge.Invoke(
new MergeParameters(branchNames)
{
NoCommit = noCommit,
NoFastForward = noFastForward,
Squash = squash,
Message = message,
});
}
catch (AutomaticMergeFailedException)
{
Repository.OnStateChanged();
Repository.Status.Refresh();
throw;
}
}
if (currentBranch != null)
{
currentBranch.Refresh();
}
else
{
Refresh();
}
var headRev = Revision;
if (noCommit)
{
Repository.OnStateChanged();
Repository.Status.Refresh();
}
else
{
if (noFastForward || !oldRevs.Contains(headRev)) //not fast-forwarded
{
Repository.OnCommitCreated(headRev);
}
}
NotifyRelogRecordAdded();
return(headRev);
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository)
: base(repository, GitConstants.HEAD, GetHeadPointer(repository))
{
}
public static User CreateUser(Repository repository, UserData userData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(userData, "userData");
return new User(repository, userData.UserName, userData.Email, userData.Commits);
}
public static TreeFile CreateTreeFile(Repository repository, TreeFileData treeFileData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(treeFileData, "treeFileData");
var shortName = treeFileData.ShortName.Length == 0 ?
GetShortName(treeFileData.Name) : treeFileData.ShortName;
return new TreeFile(repository, treeFileData.Name, null, treeFileData.FileStatus, shortName)
{
ConflictType = treeFileData.ConflictType,
StagedStatus = treeFileData.StagedStatus,
};
}
public static TreeDirectory CreateTreeDirectory(Repository repository, TreeDirectoryData treeDirectoryData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(treeDirectoryData, "treeDirectoryData");
var directory = new TreeDirectory(repository, treeDirectoryData.Name, null, treeDirectoryData.ShortName)
{
StagedStatus = treeDirectoryData.StagedStatus,
};
foreach(var subDirectory in treeDirectoryData.Directories)
{
directory.AddDirectory(CreateTreeDirectory(repository, subDirectory));
}
foreach(var file in treeDirectoryData.Files)
{
directory.AddFile(ObjectFactories.CreateTreeFile(repository, file));
}
return directory;
}
public static Tag CreateTag(Repository repository, TagData tagData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(tagData, "tagData");
Revision revision;
lock(repository.Revisions.SyncRoot)
{
revision = repository.Revisions.GetOrCreateRevision(tagData.SHA1);
}
return new Tag(repository, tagData.Name, revision, tagData.TagType);
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="pointer">Target of this reference.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository, IRevisionPointer pointer)
: base(repository, GitConstants.HEAD, pointer)
{
}