public static IEnumerable<FileChanged> GetChangedFiles(SvnLogEventArgs logEvent) { foreach (var p in logEvent.ChangedPaths) { yield return new FileChanged(logEvent.Time, p.Path); } }
public void ChangeInfo_GetInfoCompare() { SvnSandBox sbox = new SvnSandBox(this); Uri reposUri = sbox.CreateRepository(SandBoxRepository.MergeScenario); string reposPath = reposUri.LocalPath; using (SvnClient cl = new SvnClient()) { SvnSetPropertyArgs sa = new SvnSetPropertyArgs(); sa.BaseRevision = 17; sa.LogMessage = "Message"; cl.RemoteSetProperty(reposUri, "MyProp", "Value", sa); } for (long ii = 1; ii < 19; ii++) { using (SvnLookClient lcl = new SvnLookClient()) using (SvnClient cl = new SvnClient()) { SvnChangeInfoEventArgs r; SvnChangeInfoArgs ia = new SvnChangeInfoArgs(); SvnLookOrigin origin = new SvnLookOrigin(reposPath, ii); SvnLogArgs la = new SvnLogArgs(); la.Start = la.End = ii; Collection <SvnLogEventArgs> lrc; //ia.RetrieveChangedPaths = false; // Will fail if true Assert.That(lcl.GetChangeInfo(origin, ia, out r)); Assert.That(cl.GetLog(reposUri, la, out lrc)); Assert.That(r, Is.Not.Null); Assert.That(lrc.Count, Is.EqualTo(1)); SvnLogEventArgs lr = lrc[0]; Assert.That(r.Author, Is.EqualTo(lr.Author)); Assert.That(r.Revision, Is.EqualTo(lr.Revision)); Assert.That(r.BaseRevision, Is.EqualTo(lr.Revision - 1)); Assert.That(r.LogMessage, Is.EqualTo(lr.LogMessage)); Assert.That(r.Time, Is.EqualTo(lr.Time)); Assert.That(r.ChangedPaths, Is.Not.Null, "r.ChangedPaths({0})", ii); Assert.That(lr.ChangedPaths, Is.Not.Null, "lr.ChangedPaths({0})", ii); Assert.That(r.ChangedPaths.Count, Is.EqualTo(lr.ChangedPaths.Count)); for (int i = 0; i < r.ChangedPaths.Count; i++) { SvnChangeItem c = r.ChangedPaths[i]; SvnChangeItem lc = lr.ChangedPaths[c.Path]; Assert.That(c.Path, Is.EqualTo(lc.Path)); Assert.That(c.Action, Is.EqualTo(lc.Action)); Assert.That(c.CopyFromPath, Is.EqualTo(lc.CopyFromPath)); Assert.That(c.CopyFromRevision, Is.EqualTo(lc.CopyFromRevision)); } } } }
public SvnLogEventArgsWrapper(SvnLogEventArgs args) { Author = args.Author; LogMessage = args.LogMessage; Revision = args.Revision; Time = args.Time; }
private void RaiseWorkflow(SVNServerRecord hostRecord, SvnLogEventArgs log) { var contentManager = this.orchardServices.ContentManager; var svnLogContentItem = contentManager.New(SVNLogPart.ContentItemTypeName); var svnLogPart = svnLogContentItem.As <SVNLogPart>(); svnLogPart.LogMessage = log.LogMessage; svnLogPart.Author = log.Author; svnLogPart.Revision = log.Revision; svnLogPart.Time = log.Time; svnLogPart.LogOrigin = log.LogOrigin.AbsolutePath; contentManager.Create(svnLogContentItem); contentManager.Publish(svnLogContentItem); workflowManager.TriggerEvent( SVNLogReceivedActivity.ActivityName, svnLogContentItem, () => new Dictionary <string, object> { { "Content", svnLogContentItem } }); hostRecord.LastRevision = log.Revision; this.svnServerRepository.Flush(); }
/// <summary> /// Does it match the LogMessage object /// </summary> /// <param name="msg"></param> public void CheckMatch(SvnLogEventArgs e) { Assert.That(e.Author, Is.EqualTo(this.author), "Author differs"); Assert.That(e.LogMessage, Is.EqualTo(this.message), "Message differs"); Assert.That(e.Revision, Is.EqualTo(this.revision), "Revision differs"); Assert.That(e.Time, Is.EqualTo(this.date), "Date differs"); }
private void CommitToDestination(SvnLogEventArgs e, bool allowCopySourceRevision) { SvnCommitResult result; _g.Svn.Commit(_g.WorkingDir, new SvnCommitArgs { LogMessage = e.LogMessage }, out result); if (result == null) { return; } var sourceRevision = e.Revision; var destinationReivison = result.Revision; _g.RevisionMap.TrackRevision(sourceRevision, destinationReivison); if (CopyAuthor) { _g.Svn.SetRevisionProperty(_g.Destination, destinationReivison, PropertyKeyAuthor, e.Author); } if (CopyDateTime) { _g.Svn.SetRevisionProperty(_g.Destination, destinationReivison, PropertyKeyDateTime, e.Time.ToString("O") + "Z"); } if (CopySourceRevision && allowCopySourceRevision) { _g.Svn.SetRevisionProperty(_g.Destination, destinationReivison, PropertyKeySourceRevision, sourceRevision.ToString("#0")); } _g.Svn.Update(_g.WorkingDir, _ignoreExternalUpdate); _g.Interaction.UpdateProgress(sourceRevision, destinationReivison); }
private void LogHandler(object sender, SvnLogEventArgs e) { try { List <string> filesChanged = new List <string>(); ChangeSetDictionary changedItems = new ChangeSetDictionary(); if (e.ChangedPaths == null) { return; } foreach (SvnChangeItem item in e.ChangedPaths) { filesChanged.Add(item.Path); changedItems.Add(item.Path, new ChangedPathInfo(item)); } int revision = Convert.ToInt32(e.Revision); OnChangeSet(revision, e.Author, e.Time, e.LogMessage, filesChanged, changedItems); } catch (Exception ex) { OnError(ex); } }
private void OnLogResult2(object sender, SvnLogEventArgs args) { foreach (var item in args.ChangedPaths) { Console.WriteLine(item.Action + " " + item.NodeKind + " " + item.RepositoryPath + " " + item.CopyFromPath); } }
public void Delete(SvnChangeItem node, SvnLogEventArgs e, string destinationPath) { if (File.Exists(destinationPath) || Directory.Exists(destinationPath)) { _g.Svn.Delete(destinationPath); _g.Interaction.Trace("\tDeleted " + destinationPath); } }
private void OnLogResult(object sender, SvnLogEventArgs args) { Console.WriteLine(args.Revision + " -> " + args.LogMessage + " by " + args.Author); foreach (var item in args.ChangedPaths) { Console.WriteLine(item.Path); } }
public bool exportFileFromLog(SvnLogEventArgs log, string expdir, bool excDel) { Console.WriteLine(string.Format(@"リビジョン:{0} を抽出します。", log.Revision)); var revname = retPadLeftZero(log.Revision); var toRevPath = expdir + @"\" + @"r" + revname; this._exlStm.addRevSht(@"r" + revname, log.LogMessage); var trgtFlLst = this.filterLogFiles(log.ChangedPaths, this._filterList, revname, excDel); if (trgtFlLst.Count == 0) { Directory.CreateDirectory(toRevPath + @"_対象なし"); return(false); } var root = this._reporoot; var args = new SvnExportArgs() { Depth = SvnDepth.Files }; var addCmd = @"echo F | xcopy /v /y ""{0}"" ""{1}"" " + Environment.NewLine + @"svn add ""{1}"" "; var delCmd = @"if exist ""{0}"" ( " + Environment.NewLine + @" svn delete ""{0}"" " + Environment.NewLine + @")"; Directory.CreateDirectory(toRevPath); var sw = createCopyBatStrm(expdir, revname); foreach (var i in trgtFlLst) { var flPth = getFilePath(i.Path); var topath = toRevPath + flPth; if (i.Action != SvnChangeAction.Delete) { var srcp = Path.Combine(root.ToString() , i.RepositoryPath.ToString()); var todir = Path.GetDirectoryName(topath); if (!Directory.Exists(todir)) { Directory.CreateDirectory(todir); } _svncl.Export(new SvnUriTarget(srcp, log.Revision), topath, args); sw.WriteLine(string.Format(addCmd, topath, @"%dstRoot%" + flPth)); } else { sw.WriteLine(string.Format(delCmd, @"%dstRoot" + flPth)); } } this.setCommitComment(expdir, sw, log, revname); sw.Close(); return(true); }
private void OnLogDelegate(object sender, SvnLogEventArgs args) { var largs = sender as Svn2SvnLogArgs; if (largs != null) { largs.revisions.Add(args.Revision, args); } args.Detach(); }
public void Modify(SvnChangeItem node, SvnLogEventArgs e, string destinationPath) { var source = _g.Source.GetSourceTarget(node, e.Revision); if (node.NodeKind == SvnNodeKind.File) { _g.Svn.Export(source, destinationPath); } _g.Interaction.Trace(ActionModified + destinationPath); CopyProperties(source, destinationPath); }
private void OnLogDelegate(object sender, SvnLogEventArgs args) { var largs = sender as Svn2SvnLogArgs; if (largs != null) { largs.revisions.Add(args.Revision, args); } args.Detach(); }
void ReceiveItem(object sender, SvnLogEventArgs e) { if (!_cancel) { OnReceivedItem(e); } else { e.Cancel = true; } }
public void Handler(object sender, SvnLogEventArgs args) { Commit commit = new Commit() { Author = args.Author, Message = args.LogMessage, Timestamp = args.Time, Revision = args.Revision, }; Logs.Add(commit); }
/// <summary> /// Return false if _g._stopRequested, otherwise true. /// </summary> private bool ProcessNodes(IEnumerable <SvnChangeItem> nodes, SvnLogEventArgs e, Action <SvnChangeItem, SvnLogEventArgs, string> action) { foreach (var node in nodes) { if (_g.StopRequested) { return(false); // canceled } _nodeProcessor.ProcessNode(e, action, node); } return(true); // finished }
public void getChangeItem(SvnLogEventArgs log) { var tmp = new Collection <SvnChangeItem>(); foreach (var i in log.ChangedPaths) { if (i.NodeKind == SvnNodeKind.File) { tmp.Add(i); } } }
public void ProcessNode(SvnLogEventArgs e, Action <SvnChangeItem, SvnLogEventArgs, string> action, SvnChangeItem node) { var destinationPath = _g.Source.GetDestinationPath(_g.WorkingDir, node.Path); if (destinationPath == null) { return; } _g.Interaction.DoInteractively( ref _ignoreItemError, TitleErrorProcessingNode, () => action(node, e, destinationPath)); }
public void Handler(object sender, SvnLogEventArgs args) { foreach (var changedPath in args.ChangedPaths) { FileDiff fileInfo = new FileDiff( ConvertFrom(changedPath.Action), ConvertFrom(changedPath.NodeKind), changedPath.Path, changedPath.CopyFromPath); FileChanges.Add(fileInfo.Name, fileInfo); } }
public static IEnumerable <long> GetIssueIds(this SvnLogEventArgs svnLogEventArgs) { var result = Regex.Matches(svnLogEventArgs.LogMessage, @"#(\d+)", RegexOptions.Compiled) .Cast <Match>() .Select(match => long.Parse(match.Groups.Cast <System.Text.RegularExpressions.Group>() .ElementAt(1) .Value)) .ToArray(); return(result); }
private void setCommitComment(string workDir, StreamWriter btFlSw, SvnLogEventArgs log, string revname) { var cmmtFlNm = revname + @"_cmmnt.txt"; var cmmt = @"以下のリポジトリよりコピー" + Environment.NewLine + string.Format(@"repo:{0}", this._uri) + Environment.NewLine + string.Format(@"rev :{0}", log.Revision.ToString()); using (var st = new StreamWriter(Path.Combine(workDir, cmmtFlNm), false, Encoding.GetEncoding(932))) st.WriteLine(cmmt); var cmd = @"" + Environment.NewLine + string.Format(@"svn commit --file ""{0}"" ""%dstRoot%""", Path.Combine(workDir, cmmtFlNm)) + Environment.NewLine + string.Format(@"svn update ""%dstRoot%"""); btFlSw.WriteLine(cmd); }
public Log(SvnLogEventArgs e) { revision = e.Revision; author = e.Author; time = e.Time.AddHours(8); message = e.LogMessage; paths = e.ChangedPaths; if (message != null && message.Contains("\n")) { short_message = message.Split('\n')[0]; } else { short_message = message; } }
private static void GetRevision(Collection <SvnLogEventArgs> logs, long revision) { Console.Write("#### 检测SVNlog数据 ####\n\n"); int count = logs.Count; for (int i = 0; i < count; i++) { SvnLogEventArgs args = logs[i]; if (revision != 0 && args.Revision == revision) { if (i == 0) { Console.Write("#### SVNRevision Num未发生改变 ####\n\n"); ConsoleTool.Close(); return; } break; } if (i == 0) { Patch = args.Revision; } SvnChangeItemCollection itemCollection = args.ChangedPaths; foreach (SvnChangeItem item in itemCollection) { string path = item.Path; if (CheckChangePath(path) && CheckSuffix(path)) { if (Changes.Contains(path) == true) { continue; } Changes.Add(Path.GetFileName(path)); } else { continue; } } } Console.Write(string.Format("#### 最新Revision Num : {0} ####\n\n", Patch)); foreach (string path in Changes) { Console.Write(string.Format("====>更新文件:{0}\n", path)); } Console.Write("########################################\n"); }
private WorkItem ToWorkItem(SvnLogEventArgs logEntry) { var item = new WorkItem( logEntry.Revision.ToString(CultureInfo.InvariantCulture), logEntry.Author, logEntry.LogMessage, logEntry.Time); if (logEntry.ChangedPaths != null) { foreach (SvnChangeItem ci in logEntry.ChangedPaths) { item.ChangedFilePaths.Add(ci.Path); } } return(item); }
public void Commit_SetCustomProps() { SvnSandBox sbox = new SvnSandBox(this); sbox.Create(SandBoxRepository.Empty); string WcPath = sbox.Wc; string fp = Path.Combine(WcPath, "NewFile.cs"); Touch2(fp); Client.Add(fp); SvnCommitArgs ca = new SvnCommitArgs(); ca.LogMessage = "Committed extra"; ca.LogProperties.Add("my:prop", "PropValue"); ca.RunTortoiseHooks = true; SvnCommitResult cr; Client.Commit(WcPath, ca, out cr); string value; Client.GetRevisionProperty(sbox.RepositoryUri, cr.Revision, "my:prop", out value); Assert.That(value, Is.EqualTo("PropValue")); SvnLogArgs la = new SvnLogArgs(); la.RetrieveProperties.Add("my:prop"); la.Start = la.End = cr.Revision; Collection <SvnLogEventArgs> lc; Client.GetLog(WcPath, la, out lc); Assert.That(lc.Count, Is.EqualTo(1)); Assert.That(lc[0].RevisionProperties.Contains("my:prop")); SvnLogEventArgs l = lc[0]; Assert.That(l.RevisionProperties["my:prop"].StringValue, Is.EqualTo("PropValue")); Assert.That(l.Author, Is.EqualTo(Environment.UserName)); }
public void ProcessRevisionLog(SvnLogEventArgs e) { var sourceRevision = e.Revision; _g.Interaction.Info("{0} {1} {2} {3}", sourceRevision, e.Author, e.Time.ToLocalTime(), e.LogMessage); if (sourceRevision <= _resyncToRevision) { _firstLoad = false; if (!_ignoreResyncMismatch) { _g.Interaction.DoInteractively( ref _ignoreResyncMismatch, TitleErrorResyncRevision, () => CheckResyncRevision(sourceRevision)); } return; } _g.Interaction.DoInteractively( ref _ignoreRevisionError, TitleProcessRevision, () => { var sourceTarget = new SvnUriTarget(_g.Source.Uri, e.Revision); bool success = _firstLoad ? _nodeProcessor.ExportDirectory(sourceTarget, _g.WorkingDir) : ChangeWorkingCopy(e); if (success) { CommitToDestination(e, true); _firstLoad = false; } else { e.Cancel = true; } }); }
public void Add(SvnChangeItem node, SvnLogEventArgs e, string destinationPath) { if (destinationPath == _g.WorkingDir) { return; } var source = _g.Source.GetSourceTarget(node, e.Revision); bool processed = false; if (node.CopyFromPath != null) { processed = TryCopy(node, destinationPath); if (!processed && node.NodeKind == SvnNodeKind.Directory) { ExportDirectory(source, destinationPath); return; } } else if (node.NodeKind == SvnNodeKind.Directory) { _g.Svn.CreateDirectory(destinationPath); processed = true; } if (node.NodeKind != SvnNodeKind.Directory) { _g.Svn.Export(source, destinationPath, _infiniteOverwriteExport); } if (!processed) { _g.Svn.Add(destinationPath, _infiniteForceAdd); } _g.Interaction.Trace(ActionCreated + destinationPath); CopyProperties(source, destinationPath); }
/// <summary> /// Return false we didn't finish because _g._stopRequested, otherwise true. /// </summary> private bool ChangeWorkingCopy(SvnLogEventArgs e) { var changes = e.ChangedPaths; var itemsAdded = from x in changes where x.Action == SvnChangeAction.Add orderby x.Path select x; var itemsModified = from x in changes where x.Action == SvnChangeAction.Modify select x; var itemsDeleted = from x in changes where x.Action == SvnChangeAction.Delete orderby x.Path descending select x; if (!DetectNameChangeByCaseOnly(changes)) { return(ProcessNodes(itemsAdded, e, _nodeProcessor.Add) && ProcessNodes(itemsModified, e, _nodeProcessor.Modify) && ProcessNodes(itemsDeleted, e, _nodeProcessor.Delete)); } var success = ProcessNodes(itemsDeleted, e, _nodeProcessor.Delete) && ProcessNodes(itemsModified, e, _nodeProcessor.Modify); if (!success) { return(false); } CommitToDestination(e, false); return(ProcessNodes(itemsAdded, e, _nodeProcessor.Add)); }
private void OnLog(object sender, SvnLogEventArgs args) { _revisions.Add(args.Revision, args); args.Detach(); Console.Write("."); }
private void OnLog(object sender, SvnLogEventArgs args) { _revisions.Add(args.Revision, args); args.Detach(); Console.Write("."); }
private void LogCallback(object sender, SvnLogEventArgs e) { e.Detach(); this.logMessages.Add(e); }
void LoadRevisions() { int limit; Int32.TryParse(textBoxLoadBunch.Text, out limit); var cts = new CancellationTokenSource(); Task.Factory .StartNew(() => { using (var client = new SvnClient()) { client.Authentication.SslServerTrustHandlers += (sender, e) => { e.AcceptedFailures = SvnCertificateTrustFailures.MaskAllFailures; }; client.Authentication.DefaultCredentials = CredentialCache.DefaultNetworkCredentials; SvnInfoEventArgs info; client.GetInfo(_url != null ? (SvnTarget)new SvnUriTarget(_url) : new SvnPathTarget(_path), out info); _repoUri = info.RepositoryRoot; var args = new SvnLogArgs { Limit = limit }; var url = _url; if (_lastLoaded != null) { args.OperationalRevision = _lastLoaded.Revision - 1; } Collection<SvnLogEventArgs> entries; if (url != null) client.GetLog(url, args, out entries); else client.GetLog(_path, args, out entries); return entries; } }, cts.Token) .TrackProgress(loadingOperation, cts) .LockControls(textBoxUrl, buttonLoad, buttonLoadNext, textBoxLoadBunch) .ContinueWith(t => { if (t.IsFaulted || t.IsCanceled) { // if error occured - strat from scratch: can be load first N entries, can't continue _lastLoaded = null; buttonLoad.Enabled = true; buttonLoadNext.Enabled = false; } cts.Token.ThrowIfCancellationRequested(); var entries = t.Result; if (entries.Count < limit) { // nothing to load next - all revisions loaded buttonLoadNext.Enabled = false; _lastLoaded = null; } else { _lastLoaded = entries.Last(); } try { listViewLog.BeginUpdate(); foreach (var entry in entries) { var lvi = new ListViewItem(new[] { entry.Revision.ToString(CultureInfo.InvariantCulture), entry.Author, entry.LogMessage }) { Tag = entry }; listViewLog.Items.Add(lvi); } } finally { listViewLog.EndUpdate(); } }, TaskScheduler.FromCurrentSynchronizationContext()) //.TrackProgress(loadingOperation) .WithDisposeWeak(cts) ; }
void buttonLoad_Click(object sender, EventArgs e) { UsageMetrics.IncrementUsage(UsageMetrics.UsageKind.SvnLogLoad); _lastLoaded = null; buttonLoadNext.Enabled = true; listViewLog.Items.Clear(); _path = null; _url = null; Settings.Default.LastSvnLogUrl = textBoxUrl.Text; Settings.Default.Save(); if (UrlScheme.IsMatch(textBoxUrl.Text)) _url = new Uri(textBoxUrl.Text); else if(Directory.Exists(textBoxUrl.Text) || File.Exists(textBoxUrl.Text)) _path = textBoxUrl.Text; LoadRevisions(); }
private static RevisionInfo MapToRevisionInfo(SvnLogEventArgs svnLogEventArgs) { if (svnLogEventArgs == null) return null; return new RevisionInfo { Author = svnLogEventArgs.Author, Created = svnLogEventArgs.Time, Revision = svnLogEventArgs.Revision }; }
private void LogCallback(object sender, SvnLogEventArgs e) { e.Detach(); this.logMessages.Add(e); }
/// <summary> /// Creates a Qvx data entry from an Svn log entry. /// </summary> /// <param name="item">The Svn log entry to be used as a source</param> /// <param name="table">The destination Qvx table</param> /// <returns>The resulting row</returns> private QvxDataRow MakeEntry(SvnLogEventArgs entry, QvxTable table) { QvxDataRow row = new QvxDataRow(); row[table.Fields[0]] = entry.Author; row[table.Fields[1]] = entry.LogMessage; row[table.Fields[2]] = entry.Revision; row[table.Fields[3]] = entry.Time.ToOADate(); return row; }
public static string WriteString(SvnLogEventArgs log) { return "Date={0}\nPaths={1}".FormatWith(log.Time, WriteString(log.ChangedPaths)); }
/// <summary> /// Does it match the LogMessage object /// </summary> /// <param name="msg"></param> public void CheckMatch(SvnLogEventArgs e) { Assert.That(e.Author, Is.EqualTo(this.author), "Author differs"); Assert.That(e.LogMessage, Is.EqualTo(this.message), "Message differs"); Assert.That(e.Revision, Is.EqualTo(this.revision), "Revision differs"); Assert.That(e.Time, Is.EqualTo(this.date), "Date differs"); }
private void LogHandler(object sender, SvnLogEventArgs e) { try { List<string> filesChanged = new List<string>(); ChangeSetDictionary changedItems = new ChangeSetDictionary(); if(e.ChangedPaths == null) { return; } foreach (SvnChangeItem item in e.ChangedPaths) { filesChanged.Add(item.Path); changedItems.Add(item.Path, new ChangedPathInfo(item)); } int revision = Convert.ToInt32(e.Revision); OnChangeSet(revision, e.Author, e.Time, e.LogMessage, filesChanged, changedItems); } catch(Exception ex) { OnError(ex); } }
void HandleLog(object sender, SvnLogEventArgs e) { WriteObject(e); }
public void Copy() { long lastSyncRevision = 0; if (_args.Incremental) { SvnLogParser logParser = new SvnLogParser(_args.Destination); lastSyncRevision = logParser.GetLastSyncedRevisionFromDestination(); Console.WriteLine("Last revision synched: {0}", lastSyncRevision); } Console.Write("Collecting svn log: "); if (_args.RevisionRange != null) { Console.Write("{0}:{1} ", _args.RevisionRange.StartRevision, _args.RevisionRange.EndRevision); } // fetch the source svn respository and SvnInfo sourceInfo = new SvnInfo(_args.Source); Console.WriteLine("Source SVN root: {0}", sourceInfo.Info.RepositoryRoot); Console.WriteLine("Source SVN uri: {0}", sourceInfo.Info.Uri); string sourceRelativePath = sourceInfo.Info.Uri.ToString().Remove( 0, sourceInfo.Info.RepositoryRoot.ToString().Length - 1); Console.WriteLine("Relative path: {0}", sourceRelativePath); if (!string.IsNullOrEmpty(_args.Root)) { sourceRelativePath = _args.Root; Console.WriteLine("Substituting relative path: {0}", sourceRelativePath); } SvnLogArgs logArgs = new SvnLogArgs(); logArgs.StrictNodeHistory = _args.StopOnCopy; logArgs.ThrowOnError = true; logArgs.Range = _args.RevisionRange; logArgs.RetrieveChangedPaths = true; _client.Log(_args.Source, logArgs, new EventHandler <SvnLogEventArgs>(OnLog)); Console.WriteLine(); Console.WriteLine("Collected {0} revisions.", _revisions.Count); SvnTarget fromSvnTarget = SvnTarget.FromString(_args.Source); foreach (KeyValuePair <long, SvnLogEventArgs> revisionPair in _revisions) { SvnLogEventArgs revision = revisionPair.Value; if (_args.Incremental && lastSyncRevision != 0 && lastSyncRevision >= revision.Revision) { Console.WriteLine("Skipping revision {0} ({1})", revision.Revision, revision.Time); continue; } Console.WriteLine("Revision {0} ({1})", revision.Revision, revision.Time); if (_args.SimulationOnly) { continue; } SvnExportArgs exportArgs = new SvnExportArgs(); exportArgs.Overwrite = true; exportArgs.ThrowOnError = true; exportArgs.Revision = revision.Revision; SvnUpdateResult exportResult = null; _client.Export(fromSvnTarget, _args.Destination, exportArgs, out exportResult); if (revision.ChangedPaths == null) { throw new Exception(string.Format("No changed paths in rev. {0}", revision.Revision)); } SortedList <string, SvnChangeItem> changeItems = new SortedList <string, SvnChangeItem>(); foreach (SvnChangeItem changeItem in revision.ChangedPaths) { changeItems.Add(changeItem.Path, changeItem); } List <string> filesAdd = new List <string>(); List <string> filesDelete = new List <string>(); List <string> filesModify = new List <string>(); // add files in forward order (add directories first) // delete files in reverse order (delete files first) foreach (SvnChangeItem changeItem in changeItems.Values) { // anything above (outside) of the source path is ignored, we didn't export that if (!changeItem.Path.StartsWith(sourceRelativePath)) { Console.WriteLine("Skipping {0}. Did you need to specify /root:<path>?)", changeItem.Path); continue; } string targetSvnPath = changeItem.Path.Remove(0, sourceRelativePath.Length); string targetOSPath = targetSvnPath.Replace("/", @"\"); string targetPath = Path.Combine(_args.Destination, targetOSPath); Console.WriteLine(" {0} {1}", changeItem.Action, changeItem.Path); switch (changeItem.Action) { case SvnChangeAction.Add: case SvnChangeAction.Replace: filesAdd.Add(targetPath); break; case SvnChangeAction.Delete: filesDelete.Insert(0, targetPath); break; case SvnChangeAction.Modify: filesModify.Add(targetPath); break; } } Console.WriteLine("Applying changes @ rev. {0} ...", revision.Revision); foreach (string targetPath in filesModify) { Console.WriteLine(" M {0}", targetPath); } foreach (string targetPath in filesAdd) { if (!File.Exists(targetPath)) { throw new Exception(string.Format("Added file '{0}' doesn't exist. Did you need to specify /root:<path>?", targetPath)); } Console.WriteLine(" A {0}", targetPath); SvnAddArgs svnAddArgs = new SvnAddArgs(); svnAddArgs.ThrowOnError = true; svnAddArgs.Depth = SvnDepth.Empty; _client.Add(targetPath, svnAddArgs); } foreach (string targetPath in filesDelete) { Console.WriteLine(" D {0}", targetPath); SvnDeleteArgs svnDeleteArgs = new SvnDeleteArgs(); svnDeleteArgs.ThrowOnError = true; svnDeleteArgs.Force = true; _client.Delete(targetPath, svnDeleteArgs); } SvnCommitArgs commitArgs = new SvnCommitArgs(); commitArgs.LogMessage = revision.LogMessage; commitArgs.LogMessage += string.Format("\nCopied from {0}, rev. {1} by {2} @ {3} {4}", sourceInfo.Info.Uri, revision.Revision, revision.Author, revision.Time.ToShortDateString(), revision.Time.ToShortTimeString()); commitArgs.ThrowOnError = true; Console.WriteLine("Committing changes @ rev. {0} in {1}", revision.Revision, _args.Destination); Console.WriteLine("----------------------------------------------------------------------------"); Console.WriteLine(commitArgs.LogMessage); Console.WriteLine("----------------------------------------------------------------------------"); if (_args.Prompt) { while (true) { Console.Write("Commit? [Y/N] "); char k = Char.ToLower(Console.ReadKey().KeyChar); Console.WriteLine(); if (k == 'y') { break; } if (k == 'n') { throw new Exception("Aborted by user."); } } } SvnCommitResult commitResult = null; _client.Commit(_args.Destination, commitArgs, out commitResult); if (commitResult != null) { Console.WriteLine("Commited revision {0}.", commitResult.Revision); } else { Console.WriteLine("There were no committable changes."); Console.WriteLine("Subversion property changes are not supported."); } } }