private void doCheckout(GitSharp.Core.Ref branch) { if (branch == null) { throw new ArgumentNullException("branch", "Cannot checkout; no HEAD advertised by remote"); } var repo = Repository._internal_repo; if (!Constants.HEAD.Equals(branch.getName())) { RefUpdate u1 = repo.UpdateRef(Constants.HEAD); u1.disableRefLog(); u1.link(branch.getName()); } GitSharp.Core.Commit commit = repo.MapCommit(branch.ObjectId); RefUpdate u = repo.UpdateRef(Constants.HEAD); u.NewObjectId = commit.CommitId; u.forceUpdate(); GitIndex index = new GitIndex(repo); GitSharp.Core.Tree tree = commit.TreeEntry; WorkDirCheckout co = new WorkDirCheckout(repo, repo.WorkingDirectory, index, tree); co.checkout(); index.write(); }
private static GitSharp.Core.Ref guessHEAD(FetchResult result) { GitSharp.Core.Ref idHEAD = result.GetAdvertisedRef(Constants.HEAD); List <GitSharp.Core.Ref> availableRefs = new List <GitSharp.Core.Ref>(); GitSharp.Core.Ref head = null; foreach (GitSharp.Core.Ref r in result.AdvertisedRefs) { string n = r.Name; if (!n.StartsWith(Constants.R_HEADS)) { continue; } availableRefs.Add(r); if (idHEAD == null || head != null) { continue; } if (r.ObjectId.Equals(idHEAD.ObjectId)) { head = r; } } availableRefs.Sort(RefComparator.INSTANCE); if (idHEAD != null && head == null) { head = idHEAD; } return(head); }
public RefUpdate(RefDatabase refDb, Ref r, FileInfo f) { _db = refDb; _ref = r; OldObjectId = r.ObjectId; _looseFile = f; _refLogMessage = string.Empty; Result = RefUpdateResult.NotAttempted; }
public void testPushResult() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, "refs/remotes/test/master", null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef")); refUpdates.Add(rru); advertisedRefs.Add(@ref); PushResult result = executePush(); Assert.AreEqual(1, result.TrackingRefUpdates.Count); Assert.AreEqual(1, result.AdvertisedRefs.Count); Assert.AreEqual(1, result.RemoteUpdates.Count); Assert.IsNotNull(result.GetTrackingRefUpdate("refs/remotes/test/master")); Assert.IsNotNull(result.GetAdvertisedRef("refs/heads/master")); Assert.IsNotNull(result.GetRemoteUpdate("refs/heads/master")); }
public override void Execute() { if (Source.Length <= 0) { throw new ArgumentNullException("Repository", "fatal: You must specify a repository to clone."); } URIish source = new URIish(Source); if (Mirror) { Bare = true; } if (Bare) { if (OriginName != null) { throw new ArgumentException("Bare+Origin", "--bare and --origin " + OriginName + " options are incompatible."); } NoCheckout = true; } if (OriginName == null) { OriginName = "origin"; } var repo = new GitSharp.Core.Repository(new DirectoryInfo(ActualDirectory)); repo.Create(Bare); repo.Config.setBoolean("core", null, "bare", Bare); repo.Config.save(); Repository = new Repository(repo); if (!Quiet) { OutputStream.WriteLine("Initialized empty Git repository in " + repo.Directory.FullName); OutputStream.Flush(); } saveRemote(source); FetchResult r = runFetch(); GitSharp.Core.Ref branch = guessHEAD(r); if (!NoCheckout) { doCheckout(branch); } }
public void testDeleteMaster() { string sn = "refs/heads/master"; RefSpec rs = new RefSpec(":" + sn); Assert.IsFalse(rs.Force); Assert.IsFalse(rs.Wildcard); Assert.AreEqual(sn, rs.Destination); Assert.IsNull(rs.Source); Assert.AreEqual(":" + sn, rs.ToString()); Assert.AreEqual(rs, new RefSpec(rs.ToString())); Ref r = new Ref(Ref.Storage.Loose, sn, null); Assert.IsFalse(rs.MatchSource(r)); Assert.IsTrue(rs.MatchDestination(r)); Assert.AreSame(rs, rs.ExpandFromSource(r)); r = new Ref(Ref.Storage.Loose, sn + "-and-more", null); Assert.IsFalse(rs.MatchSource(r)); Assert.IsFalse(rs.MatchDestination(r)); }
private static GitSharp.Core.Ref guessHEAD(FetchResult result) { // Some transports allow us to see where HEAD points to. If that is not so, // we'll have to guess. GitSharp.Core.Ref head = result.GetAdvertisedRef(Constants.HEAD); if (head != null) { return(head); } var availableHeads = result.AdvertisedRefs.Where(r => r.Name.StartsWith(Constants.R_HEADS)); // master is our preferred guess, so if it's advertised, return that. GitSharp.Core.Ref guessedHead = result.GetAdvertisedRef(Constants.R_HEADS + Constants.MASTER); if (guessedHead == null && availableHeads.Count() > 0) { // if master is not advertised, return any other head. guessedHead = availableHeads.First(); } return(guessedHead); }
public void testUpdateMixedCases() { RemoteRefUpdate rruOk = new RemoteRefUpdate(db, null, "refs/heads/master", false, null, null); Ref refToChange = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9")); RemoteRefUpdate rruReject = new RemoteRefUpdate(db, null, "refs/heads/nonexisting", false, null, null); refUpdates.Add(rruOk); refUpdates.Add(rruReject); advertisedRefs.Add(refToChange); executePush(); Assert.AreEqual(RemoteRefUpdate.UpdateStatus.OK, rruOk.Status); Assert.AreEqual(true, rruOk.FastForward); Assert.AreEqual(RemoteRefUpdate.UpdateStatus.NON_EXISTING, rruReject.Status); }
private static RefList <Ref> parsePackedRefs(TextReader br) { var all = new RefList <Ref> .Builder <Ref>(); Ref last = null; bool peeled = false; bool needSort = false; string p; while ((p = br.ReadLine()) != null) { if (p[0] == '#') { if (p.StartsWith(PACKED_REFS_HEADER)) { p = p.Substring(PACKED_REFS_HEADER.Length); peeled = p.Contains(PACKED_REFS_PEELED); } continue; } if (p[0] == '^') { if (last == null) { throw new IOException("Peeled line before ref."); } ObjectId id = ObjectId.FromString(p.Substring(1)); last = new PeeledTag(Storage.Packed, last.getName(), last .getObjectId(), id); all.set(all.size() - 1, last); continue; } int sp = p.IndexOf(' '); ObjectId id2 = ObjectId.FromString(p.Slice(0, sp)); string name = copy(p, sp + 1, p.Length); ObjectIdRef cur; if (peeled) { cur = new PeeledNonTag(Storage.Packed, name, id2); } else { cur = new Unpeeled(Storage.Packed, name, id2); } if (last != null && RefComparator.compareTo(last, cur) > 0) { needSort = true; } all.add(cur); last = cur; } if (needSort) { all.sort(); } return(all.toRefList()); }
public void testUpdateUpToDate() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9")); testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.UP_TO_DATE, null); }
internal Branch(Repository repo, CoreRef @ref) : this(repo, GetBranchName (@ref.Name)) { _ref_name = GetRefName (@ref.Name); }
internal Branch(Repository repo, CoreRef @ref) : this(repo, GetBranchName(@ref.Name)) { _ref_name = GetRefName(@ref.Name); }
/// <summary> /// Do it. /// </summary> public override void Execute() { if (Source.Length <= 0) { throw new ArgumentException("fatal: You must specify a repository to clone."); } if (Directory != null && GitDirectory != null) { throw new ArgumentException("conflicting usage of --git-dir and arguments"); } var source = new URIish(Source); if (Directory == null) { try { Directory = source.getHumanishName(); } catch (InvalidOperationException e) { throw new ArgumentException("cannot guess local name from " + source, e); } } if (GitDirectory == null) { GitDirectory = Path.Combine(Directory, Constants.DOT_GIT); } if (Mirror) { Bare = true; } if (Bare) { if (OriginName != null) { throw new ArgumentException("Bare+Origin", "--bare and --origin " + OriginName + " options are incompatible."); } NoCheckout = true; } if (OriginName == null) { OriginName = Constants.DEFAULT_REMOTE_NAME; } if (System.IO.Directory.Exists(Directory) && System.IO.Directory.GetFileSystemEntries(Directory).Length != 0) { throw new InvalidOperationException(string.Format("destination path '{0}' already exists and is not an empty directory.", new DirectoryInfo(Directory).FullName)); } var repo = new Core.Repository(new DirectoryInfo(GitDirectory)); repo.Create(Bare); repo.Config.setBoolean("core", null, "bare", Bare); repo.Config.save(); Repository = new Repository(repo); if (!Quiet) { OutputStream.WriteLine("Initialized empty Git repository in " + repo.Directory.FullName); OutputStream.Flush(); } saveRemote(source); FetchResult r; try { r = runFetch(); } catch (NoRemoteRepositoryException) { Repository.Dispose(); throw; } GitSharp.Core.Ref branch = guessHEAD(r); if (!NoCheckout) { doCheckout(branch); } }
/// <summary> /// An set of update operations for renaming a ref /// </summary> /// <param name="fromRef"> Old ref name </param> /// <param name="toRef"> New ref name </param> /// <returns> a RefUpdate operation to rename a ref </returns> /// <exception cref="IOException"> </exception> public RefRename NewRename(string fromRef, string toRef) { RefreshPackedRefs(); Ref f = ReadRefBasic(fromRef, 0); var t = new Ref(Ref.Storage.New, toRef, null); var refUpdateFrom = new RefUpdate(this, f, FileForRef(f.Name)); var refUpdateTo = new RefUpdate(this, t, FileForRef(t.Name)); return new RefRename(refUpdateTo, refUpdateFrom); }
public void testUpdateNonFastForwardUnknownObject() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("0000000000000000000000000000000000000001")); testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.REJECTED_NONFASTFORWARD, null); }
public void testUpdateUnexpectedRemoteVsForce() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", true, null, ObjectId.FromString("0000000000000000000000000000000000000001")); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef")); testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.REJECTED_REMOTE_CHANGED, null); }
internal Commit(Repository repo, CoreRef @ref) : base(repo, @ref.ObjectId) { }
public void testForceRemotesOrigin() { string srcn = "refs/heads/*"; string dstn = "refs/remotes/origin/*"; RefSpec rs = new RefSpec("+" + srcn + ":" + dstn); Assert.IsTrue(rs.Force); Assert.IsTrue(rs.Wildcard); Assert.AreEqual(srcn, rs.Source); Assert.AreEqual(dstn, rs.Destination); Assert.AreEqual("+" + srcn + ":" + dstn, rs.ToString()); Assert.AreEqual(rs, new RefSpec(rs.ToString())); Ref r; RefSpec expanded; r = new Ref(Ref.Storage.Loose, "refs/heads/master", null); Assert.IsTrue(rs.MatchSource(r)); Assert.IsFalse(rs.MatchDestination(r)); expanded = rs.ExpandFromSource(r); Assert.AreNotSame(rs, expanded); Assert.IsTrue(expanded.Force); Assert.IsFalse(expanded.Wildcard); Assert.AreEqual(r.Name, expanded.Source); Assert.AreEqual("refs/remotes/origin/master", expanded.Destination); r = new Ref(Ref.Storage.Loose, "refs/remotes/origin/next", null); Assert.IsFalse(rs.MatchSource(r)); Assert.IsTrue(rs.MatchDestination(r)); r = new Ref(Ref.Storage.Loose, "refs/tags/v1.0", null); Assert.IsFalse(rs.MatchSource(r)); Assert.IsFalse(rs.MatchDestination(r)); }
internal Ref(Repository repo, CoreRef @ref) : this(repo, @ref.Name) { }
public void testTrackingRefUpdateDisabled() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef")); refUpdates.Add(rru); advertisedRefs.Add(@ref); PushResult result = executePush(); Assert.IsTrue(result.TrackingRefUpdates.Count == 0); }
public Entry(Entry <T> n, Ref <T> r) { Next = n; Ref = r; }
public void testUpdateRejectedByConnection() { connectionUpdateStatus = RemoteRefUpdate.UpdateStatus.REJECTED_OTHER_REASON; RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef")); testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.REJECTED_OTHER_REASON, null); }
protected RefUpdate(Ref @ref) { _ref = @ref; oldValue = @ref.getObjectId(); refLogMessage = ""; }
internal Ref(Repository repo, CoreRef @ref) : this(repo, @ref.Name) { }
private void printRefUpdateResult(URIish uri, OperationResult result, RemoteRefUpdate rru) { if (!shownUri) { shownUri = true; OutputStream.WriteLine("To " + uri); } string remoteName = rru.RemoteName; string srcRef = rru.IsDelete ? null : rru.SourceRef; switch (rru.Status) { case RemoteRefUpdate.UpdateStatus.OK: { if (rru.IsDelete) { printUpdateLine('-', "[deleted]", null, remoteName, null); } else { GitSharp.Core.Ref oldRef = result.GetAdvertisedRef(remoteName); if (oldRef == null) { string summary = remoteName.StartsWith(Constants.R_TAGS) ? "[new tag]" : "[new branch]"; printUpdateLine('*', summary, srcRef, remoteName, null); } else { bool fastForward = rru.FastForward; char flag = fastForward ? ' ' : '+'; string summary = oldRef.ObjectId.Abbreviate(Repository._internal_repo).name() + (fastForward ? ".." : "...") + rru.NewObjectId.Abbreviate(Repository._internal_repo).name(); string message = fastForward ? null : "forced update"; printUpdateLine(flag, summary, srcRef, remoteName, message); } } break; } case RemoteRefUpdate.UpdateStatus.NON_EXISTING: printUpdateLine('X', "[no match]", null, remoteName, null); break; case RemoteRefUpdate.UpdateStatus.REJECTED_NODELETE: printUpdateLine('!', "[rejected]", null, remoteName, "remote side does not support deleting refs"); break; case RemoteRefUpdate.UpdateStatus.REJECTED_NONFASTFORWARD: printUpdateLine('!', "[rejected]", srcRef, remoteName, "non-fast forward"); break; case RemoteRefUpdate.UpdateStatus.REJECTED_REMOTE_CHANGED: { string message = "remote ref object changed - is not expected one " + rru.ExpectedOldObjectId.Abbreviate(Repository._internal_repo).name(); printUpdateLine('!', "[rejected]", srcRef, remoteName, message); break; } case RemoteRefUpdate.UpdateStatus.REJECTED_OTHER_REASON: printUpdateLine('!', "[rejected]", srcRef, remoteName, rru.Message); break; case RemoteRefUpdate.UpdateStatus.UP_TO_DATE: if (Verbose) { printUpdateLine('=', "[up to date]", srcRef, remoteName, null); } break; case RemoteRefUpdate.UpdateStatus.NOT_ATTEMPTED: case RemoteRefUpdate.UpdateStatus.AWAITING_REPORT: printUpdateLine('?', "[unexpected push-process behavior]", srcRef, remoteName, rru.Message); break; } }
internal Commit(Repository repo, CoreRef @ref) : base(repo, @ref.ObjectId) { }
public void testUpdateNonFastForwardForced() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "ac7e7e44c1885efb472ad54a78327d66bfc4ecef", "refs/heads/master", true, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9")); testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.OK, false); }
public Ref Peel(Ref pRef) { return _refDb.Peel(pRef); }
/// <summary> /// Create a command to update, create or delete a ref in this repository. /// </summary> /// <param name="name">name of the ref the caller wants to modify.</param> /// <param name="detach">true to detach the ref, i.e. replace symref with object ref</param> /// <returns>An update command. The caller must finish populating this command and then invoke one of the update methods to actually make a change.</returns> public RefUpdate NewUpdate(string name, bool detach) { RefreshPackedRefs(); Ref r = ReadRefBasic(name, 0); if (r == null) { r = new Ref(Ref.Storage.New, name, null); } else if (detach) { r = new Ref(Ref.Storage.New, name, r.ObjectId); }
private PushResult testOneUpdateStatus(RemoteRefUpdate rru, Ref advertisedRef, RemoteRefUpdate.UpdateStatus expectedStatus, bool? fastForward) { refUpdates.Add(rru); if (advertisedRef != null) advertisedRefs.Add(advertisedRef); PushResult result = executePush(); Assert.AreEqual(expectedStatus, rru.Status); if (fastForward.HasValue) Assert.AreEqual(fastForward.Value, rru.FastForward); return result; }
} /// <summary> /// Returns the object that this object points to if this is a commit. /// </summary> /// <param name="dref">The ref.</param> /// <returns></returns> internal Ref Peel(Ref dref) { if (dref.Peeled) return dref; ObjectId peeled = null; try { Tag target = (Repository.MapObject(dref.ObjectId, dref.Name) as Tag); while (target != null) { peeled = target.Id; if (target.TagType == Constants.TYPE_TAG) { target = (Repository.MapObject(target.Id, dref.Name) as Tag); } else { break; } } } catch (IOException) { // Ignore a read error. Callers will also get the same error // if they try to use the result of getPeeledObjectId. }
} internal void Stored(string origName, string name, ObjectId id, DateTime time) { lock (locker) { _looseRefs[name] = new Ref(Ref.Storage.Loose, name, name, id); _looseRefsMTime[name] = time; SetModified(); }
/// <summary> /// Create a new ref pairing. /// </summary> /// <param name="refName">name of this ref.</param> /// <param name="target">the ref we reference and derive our value from.</param> public SymbolicRef(string refName, Ref target) { _name = refName; _target = target; }
} private Ref ReadRefBasic(String origName, string name, int depth) { // Prefer loose ref to packed ref as the loose // file can be more up-to-date than a packed one. // Ref @ref; _looseRefs.TryGetValue(name, out @ref); FileInfo loose = FileForRef(name); loose.Refresh(); DateTime mtime = loose.Exists ? loose.LastWriteTime : DateTime.MinValue; // [ammachado] If the file does not exists, LastWriteTimes returns '1600-12-31 22:00:00' if (@ref != null) { DateTime cachedLastModified; if (_looseRefsMTime.TryGetValue(name, out cachedLastModified) && cachedLastModified == mtime) { return _packedRefs.ContainsKey(origName) ? new Ref(Ref.Storage.LoosePacked, origName, @ref.ObjectId, @ref.PeeledObjectId, @ref.Peeled) : @ref; } _looseRefs.Remove(origName); _looseRefsMTime.Remove(origName); } if (!loose.Exists) { // File does not exist. // Try packed cache. // _packedRefs.TryGetValue(name, out @ref); if (@ref != null && [email protected](origName)) { @ref = new Ref(Ref.Storage.LoosePacked, origName, name, @ref.ObjectId); } return @ref; } string line = null; try { DateTime cachedLastModified; if (_looseRefsMTime.TryGetValue(name, out cachedLastModified) && cachedLastModified == mtime) { _looseSymRefs.TryGetValue(name, out line); } if (string.IsNullOrEmpty(line)) { line = ReadLine(loose); _looseRefsMTime[name] = mtime; _looseSymRefs[name] = line; } } catch (FileNotFoundException) { return _packedRefs[name]; } if (string.IsNullOrEmpty(line)) { _looseRefs.Remove(origName); _looseRefsMTime.Remove(origName); return new Ref(Ref.Storage.Loose, origName, name, null); } if (line.StartsWith("ref: ")) { if (depth >= 5) { throw new IOException("Exceeded maximum ref depth of " + depth + " at " + name + ". Circular reference?"); } string target = line.Substring("ref: ".Length); Ref r = ReadRefBasic(target, depth + 1); DateTime cachedMtime; if (_looseRefsMTime.TryGetValue(name, out cachedMtime) && cachedMtime != mtime) { SetModified(); } _looseRefsMTime[name] = mtime; if (r == null) { return new Ref(Ref.Storage.Loose, origName, target, null); } if (!origName.Equals(r.Name)) { r = new Ref(Ref.Storage.LoosePacked, origName, r.Name, r.ObjectId, r.PeeledObjectId, true); } return r; } SetModified(); ObjectId id; try { id = ObjectId.FromString(line); } catch (ArgumentException) { throw new IOException("Not a ref: " + name + ": " + line); } Ref.Storage storage = _packedRefs.ContainsKey(name) ? Ref.Storage.LoosePacked : Ref.Storage.Loose; @ref = new Ref(storage, name, id); _looseRefs[name] = @ref; _looseRefsMTime[name] = mtime; if (!origName.Equals(name)) { @ref = new Ref(Ref.Storage.Loose, origName, name, id); _looseRefs[origName] = @ref; }
public Ref Peel(Ref pRef) { try { return _refDb.peel(pRef); } catch (IOException) { // Historical accident; if the reference cannot be peeled due // to some sort of repository access problem we claim that the // same as if the reference was not an annotated tag. return pRef; } }
} private void RefreshPackedRefs() { lock(locker) { _packedRefsFile.Refresh(); if (!_packedRefsFile.Exists) return; DateTime currTime = _packedRefsFile.LastWriteTime; long currLen = currTime == DateTime.MinValue ? 0 : _packedRefsFile.Length; if (currTime == _packedRefsLastModified && currLen == _packedRefsLength) return; if (currTime == DateTime.MinValue) { _packedRefsLastModified = DateTime.MinValue; _packedRefsLength = 0; _packedRefs = new Dictionary<string, Ref>(); return; } var newPackedRefs = new Dictionary<string, Ref>(); try { using (var b = OpenReader(_packedRefsFile)) { string p; Ref last = null; while ((p = b.ReadLine()) != null) { if (p[0] == '#') continue; if (p[0] == '^') { if (last == null) { throw new IOException("Peeled line before ref."); } ObjectId id = ObjectId.FromString(p.Substring(1)); last = new Ref(Ref.Storage.Packed, last.Name, last.Name, last.ObjectId, id, true); newPackedRefs.put(last.Name, last); continue; } int sp = p.IndexOf(' '); ObjectId id2 = ObjectId.FromString(p.Slice(0, sp)); string name = p.Substring(sp + 1); last = new Ref(Ref.Storage.Packed, name, name, id2); newPackedRefs.Add(last.Name, last); } } _packedRefsLastModified = currTime; _packedRefsLength = currLen; _packedRefs = newPackedRefs; SetModified(); } catch (FileNotFoundException) { // Ignore it and leave the new map empty. // _packedRefsLastModified = DateTime.MinValue; _packedRefsLength = 0; _packedRefs = newPackedRefs; } catch (IOException e) { throw new GitException("Cannot read packed refs", e); }
/// <summary> /// Peel a possibly unpeeled reference by traversing the annotated tags. /// <para/> /// If the reference cannot be peeled (as it does not refer to an annotated /// tag) the peeled id stays null, but <see cref="Ref.IsPeeled"/> will be true. /// <para/> /// Implementors should check <see cref="Ref.IsPeeled"/> before performing any /// additional work effort. /// </summary> /// <param name="ref">The reference to peel</param> /// <returns> /// {@code ref} if {@code ref.isPeeled()} is true; otherwise a new /// Ref object representing the same data as Ref, but isPeeled() will /// be true and getPeeledObjectId() will contain the peeled object /// (or null). /// </returns> public abstract Ref peel(Ref @ref);
public LooseSymbolicRef(long mtime, string refName, Ref target) : base(refName, target) { _lastModified = mtime; }
public RefDirectoryUpdate(RefDirectory r, Ref @ref) : base(@ref) { _database = r; }
public void testTrackingRefUpdateOnReject() { RemoteRefUpdate rru = new RemoteRefUpdate(db, "ac7e7e44c1885efb472ad54a78327d66bfc4ecef", "refs/heads/master", false, null, null); Ref @ref = new Ref(Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9")); PushResult result = testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.REJECTED_NONFASTFORWARD, null); Assert.IsTrue(result.TrackingRefUpdates.Count == 0); }