protected override string GetValue(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); return snippet.Title; }
/// <summary> /// Validates literals of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); foreach (Literal literal in snippet.Literals) { if (string.IsNullOrEmpty(literal.Identifier)) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingLiteralIdentifier, "Snippet literal identifier is missing.", ResultImportance.Error, literal); } else if (!snippet.Placeholders.Contains(literal.Identifier)) { yield return new SnippetValidationResult( snippet, ErrorCode.LiteralWithoutPlaceholder, "Snippet literal does not have corresponding placeholder in code.", ResultImportance.Error, literal); } if (!ValidationHelper.IsValidLiteralIdentifier(literal.Identifier)) { yield return new SnippetValidationResult( snippet, ErrorCode.InvalidLiteralIdentifier, "Snippet literal identifier is invalid.", ResultImportance.Error, literal); } if (string.IsNullOrEmpty(literal.DefaultValue)) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingLiteralDefault, "Snippet literal default value is missing.", ResultImportance.Error, literal); } } foreach (IGrouping<string, Literal> grp in snippet.Literals.GroupBy(f => f.Identifier, _stringComparer)) { if (grp.CountExceeds(1)) { yield return new SnippetValidationResult( snippet, ErrorCode.LiteralIdentifierDuplicate, $"Snippet literal identifier '{grp.Key}' is duplicated.", ResultImportance.Warning); } } }
/// <summary> /// Finds the parameters in a snippet. /// </summary> /// <param name="snippet">The snippet.</param> /// <returns>The parameter names.</returns> public static string[] ExtractParameterNames(Snippet snippet) { List<string> parms = new List<string>(); foreach(Match m in ParametersRegex.Matches(snippet.Content)) { string value = m.Value.Substring(1, m.Value.Length - 2); if(m.Success && !parms.Contains(value)) parms.Add(value); } return parms.ToArray(); }
/// <summary> /// Validates the specified <see cref="Snippet"/> according the the code snippet schema. /// </summary> /// <param name="snippet">A <see cref="Snippet"/> that is being validated.</param> /// <returns>A <see cref="SnippetValidationContext"/> that stores data about the validation.</returns> public IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); var context = new SnippetValidationContext(snippet); foreach (SnippetValidationResult result in Validate(context)) yield return result; }
/// <summary> /// Initializes a new instance of the <see cref="SnippetValidationResult"/> class using the specified snippet, code, description, importance and content. /// </summary> /// <param name="snippet">A snippet.</param> /// <param name="code">Alphanumeric code the identifies the result.</param> /// <param name="description">Result description.</param> /// <param name="importance">Result importance.</param> /// <param name="content">Additional result content. The value can be <c>null</c>.</param> /// <exception cref="ArgumentNullException"><paramref name="snippet"/> is <c>null</c>.</exception> public SnippetValidationResult(Snippet snippet, string code, string description, ResultImportance importance, object content) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); Snippet = snippet; Code = code; Description = description; Importance = importance; Content = content; }
public SnippetButton(Snippet snippet, Action<Snippet> onClick) { InitializeComponent(); SnippetName.Text = snippet.Name; Trigger.Text = snippet.Trigger; ToolTip = new SnippetTooltip(snippet); ToolTipService.SetPlacement(this, PlacementMode.Left); SnippetBtn.Click += (s, e) => onClick(snippet); }
public SnippetViewModel(Snippet snippet) { if(snippet == null) return; CreatedBy = snippet.CreatedBy; DateCreated = snippet.DateCreated; Key = snippet.Key; Model = snippet.Model; Title = snippet.Title; View = snippet.View; Notes = snippet.Notes; Revision = snippet.Revision; }
public void CompileExecutable_ValidSyntax_CompilesExecutable() { var snippet = new Snippet { Code = "Console.WriteLine(\"Hello World\");" }; snippet.References.Add("System.dll"); snippet.Imports.Add("System"); var compiler = new CSharpSnippetCompiler("output"); var results = compiler.CompileExecutable(snippet); Assert.That(results.Errors.Count == 0, results.Errors.GetDisplayString()); }
/// <summary> /// Validates a description of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); if (string.IsNullOrEmpty(snippet.Description)) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingDescription, "Snippet description is missing.", ResultImportance.Information); } }
/// <summary> /// Validates a format version of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); if (snippet.SnippetTypes == SnippetTypes.None) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingSnippetType, "Snippet type is missing.", ResultImportance.Information); } }
private void SetupTestDefaults() { snippet = new Snippet() { View = @"@{ var Now = DateTime.Now.ToString(); } <h1>Basic Integration Test</h1> Test performed at: @Now ", Title = "Basic Integration Test", Notes = "Having a meaningful note helps you in remembering things in future.", CreatedBy = "Anonymous", Revision = 0, }; }
private static OracleCodeSnippet BuildCodeSnippet(Snippet s, SourcePosition sourcePosition) { return new OracleCodeSnippet { Name = s.Name, BaseText = s.Text, Description = s.Description, SourceToReplace = sourcePosition, Parameters = new List<ICodeSnippetParameter>( (s.Parameters ?? Enumerable.Empty<SnippetParameter>()).Select(p => new OracleCodeSnippetParameter { Index = p.Index, DefaultValue = p.DefaultValue })).AsReadOnly() }; }
/// <summary> /// Validates namespaces of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); foreach (IGrouping<string, string> grp in snippet.Namespaces.GroupBy(f => f, _stringComparer)) { if (grp.CountExceeds(1)) { yield return new SnippetValidationResult( snippet, ErrorCode.NamespaceDuplicate, $"Namespace '{grp.Key}' is duplicated.", ResultImportance.Warning); } } }
public void append() { var snippet = new Snippet("the sample"); snippet.Append("something", 5); snippet.Text.ShouldEqual("something" + Environment.NewLine); snippet.Start.ShouldEqual(5); snippet.End.ShouldEqual(5); snippet.Append("else", 6); snippet.Append("and more", 7); snippet.Start.ShouldEqual(5); snippet.End.ShouldEqual(7); snippet.Text.ShouldEqual(@"something{0}else{0}and more{0}".ToFormat(Environment.NewLine).TrimStart()); }
/// <summary> /// Validates assembly references of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); foreach (AssemblyReference reference in snippet.AssemblyReferences) { if (string.IsNullOrEmpty(reference.AssemblyName)) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingAssemblyReferenceName, "Snippet assembly reference name is missing.", ResultImportance.Error, reference); } } }
private void btnSave_Click(object sender, EventArgs e) { if (currentSnippet != null) { if (action != "insert") { Language language = new Language(); language.Id = (int)cmbLanguage.SelectedValue; language.Name = cmbLanguage.Name; currentSnippet.Language = language; } else { currentSnippet = new Snippet(); currentSnippet.Text = rtxtCode.Text; currentSnippet.Title = txtNotes.Text; currentSnippet.AccessLevel = new AccessLevel(); currentSnippet.AccessLevel.Id = (int)cmbAccessLevel.SelectedValue; currentSnippet.AccessLevel.Name = cmbAccessLevel.SelectedText; currentSnippet.Description = txtDescription.Text; currentSnippet.Language = new Language(); currentSnippet.Language.Id = (int)cmbLanguage.SelectedValue; currentSnippet.Language.DisplayName = cmbAccessLevel.SelectedText; currentSnippet.Notes = txtNotes.Text; currentSnippet.Usage = txtUsage.Text; currentSnippet.UserId = user.Id; currentSnippet = this.BuildSnippet(); } if (codeKeep != null) if (action == "insert") codeKeep.AddSnippet(currentSnippet); else codeKeep.UpdateSnippet(currentSnippet); } btnSave.Enabled = false; }
public void ReadXml(XmlReader reader) { var elementName = string.Empty; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { elementName = reader.Name; if (elementName == "Snippets") { var subReader = reader.ReadSubtree(); var snippets = new List<Snippet>(); while (subReader.ReadToFollowing("Snippet")) { var snippet = new Snippet(); snippet.ReadXml(subReader); snippets.Add(snippet); } Snippets = snippets.ToArray(); break; } } else if (reader.NodeType == XmlNodeType.Text) { switch (elementName) { case "Keywords": Keywords = reader.Value.Split(' '); break; } } else if (reader.NodeType == XmlNodeType.EndElement) { elementName = string.Empty; } } }
/// <summary> /// Validates a format version of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); if (snippet.FormatVersion == null) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingVersion, "Snippet format version is missing.", ResultImportance.Error); } if (!ValidationHelper.IsValidVersion(snippet.FormatVersion)) { yield return new SnippetValidationResult( snippet, ErrorCode.InvalidVersion, "Snippet format version is has invalid format.", ResultImportance.Error); } }
/// <summary> /// Validates a title of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); if (snippet.Title.Length == 0) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingTitle, "Snippet title is missing.", ResultImportance.Error); } if (string.IsNullOrWhiteSpace(snippet.Title)) { yield return new SnippetValidationResult( snippet, ErrorCode.TitleTitleContainsWhiteSpaceOnly, "Snippet title contains white-space only.", ResultImportance.Error); } }
/// <summary> /// Validates a shortcut of the specified <see cref="Snippet"/>. /// </summary> /// <param name="snippet">A snippet to be validated.</param> /// <returns>Enumerable collection of validation results.</returns> public override IEnumerable<SnippetValidationResult> Validate(Snippet snippet) { if (snippet == null) throw new ArgumentNullException(nameof(snippet)); if (string.IsNullOrEmpty(snippet.Shortcut)) { yield return new SnippetValidationResult( snippet, ErrorCode.MissingShortcut, "Snippet shortcut is missing.", ResultImportance.Error); } if (!ValidationHelper.IsValidShortcut(snippet.Shortcut)) { yield return new SnippetValidationResult( snippet, ErrorCode.InvalidShortcut, "Snippet shortcut is invalid.", ResultImportance.Error); } }
private static bool SnippetAreConnected(Snippet first, Snippet second) { if (first.End == null || second.Begin == null) return false; if (first.End.SourceContext != second.Begin.SourceContext) return false; if (first.End.Offset != second.Begin.Offset) return false; return true; }
public SourceWriter WriteCode(IEnumerable<Snippet> snippets) { // compact snippets so vs language service doesn't have to var compacted = new Snippets(snippets.Count()); Snippet prior = null; foreach (var snippet in snippets) { if (prior != null && SnippetAreConnected(prior, snippet)) { prior = new Snippet { Value = prior.Value + snippet.Value, Begin = prior.Begin, End = snippet.End }; continue; } if (prior != null) compacted.Add(prior); prior = snippet; } if (prior != null) compacted.Add(prior); // write them out and keep mapping-to-spark source information foreach (var snippet in compacted) { if (snippet.Begin != null) { Mappings.Add(new SourceMapping { Source = snippet, OutputBegin = Length, OutputEnd = Length + snippet.Value.Length }); } Write(snippet.Value); } return this; }
internal void InsertSnippet(Snippet snip, int startPos) { NativeScintilla.BeginUndoAction(); IsActive = false; string snippet = snip.RealCode; // First properly indent the template. We do this by // getting the indent string of the current line and // adding it to all newlines int indentPoint = 0; string line = Scintilla.Lines.Current.Text; if(line != string.Empty) { while (indentPoint < line.Length) { char c = line[indentPoint]; if (c != ' ' && c != '\t') break; indentPoint++; } } // Grab the current selected text in case we have a surrounds with scenario. string selText = Scintilla.Selection.Text; // Now we clear the selection if (selText != string.Empty) Scintilla.Selection.Clear(); if (indentPoint > 0) { string indent = line.Substring(0, indentPoint); // This is a bit of a tough decision, but I think the best way to handle it // is to assume that the Snippet's Eol Marker matches the Platform DOCUMENT_DEFAULT // but the target Eol Marker should match the Document's. snippet = snippet.Replace(Environment.NewLine, Scintilla.EndOfLine.EolString + indent); // Same deal with the selected text if any selText = selText.Replace(Environment.NewLine, Scintilla.EndOfLine.EolString + indent); } int anchorPos = -1; int caretPos = -1; int endPos = -1; int selPos = -1; SortedList<int, int> dropMarkers = new SortedList<int, int>(); SortedList<int, SnippetLinkRange> indexedRangesToActivate = new SortedList<int, SnippetLinkRange>(); List<SnippetLinkRange> unindexedRangesToActivate = new List<SnippetLinkRange>(); Match m = snippetRegex1.Match(snippet); while (m.Success) { // Did it match a $DropMarker$ token? if (m.Groups["dm"].Success) { // Yep, was it an indexed or unindexed DropMarker if (m.Groups["dmi"].Success) { // Indexed, set the indexed drop marker's character offset // if it is specified more than once the last one wins. dropMarkers[int.Parse(m.Groups["dmi"].Value)] = m.Groups["dm"].Index; } else { // Unindexed, just tack it on at the _end dropMarkers[dropMarkers.Count] = m.Groups["dm"].Index; } // Take the token out of the string snippet = snippet.Remove(m.Groups["dm"].Index, m.Groups["dm"].Length); } else if (m.Groups["c"].Success) { // We matched the $Caret$ Token. Since there can be // only 1 we set the caretPos. If this is specified // more than once the last one wins caretPos = m.Groups["c"].Index; // Take the token out of the string snippet = snippet.Remove(m.Groups["c"].Index, m.Groups["c"].Length); } else if (m.Groups["a"].Success) { // We matched the $Anchor$ Token. Since there can be // only 1 we set the anchorPos. If this is specified // more than once the last one wins anchorPos = m.Groups["a"].Index; // Take the token out of the string snippet = snippet.Remove(m.Groups["a"].Index, m.Groups["a"].Length); } else if (m.Groups["e"].Success) { // We matched the $End$ Token. Since there can be // only 1 we set the endPos. If this is specified // more than once the last one wins endPos = m.Groups["e"].Index; // Take the token out of the string snippet = snippet.Remove(m.Groups["e"].Index, m.Groups["e"].Length); } else if (m.Groups["s"].Success) { // We matched the $Selection$ Token. Simply insert the // selected text at this position selPos = m.Groups["s"].Index; // Take the token out of the string snippet = snippet.Remove(m.Groups["s"].Index, m.Groups["s"].Length); snippet = snippet.Insert(m.Groups["s"].Index, selText); } else if (m.Groups["l"].Success) { // Finally match for Snippet Link Ranges. This is at the bottom of the if/else // because we want the more specific regex groups to match first so that this // generic expression group doesn't create a SnippetLinkRange for say the // $Caret$ Token. Group g = m.Groups["l"]; int rangeIndex; string groupKey; if (m.Groups["li"].Success) { // We have a subindexed SnippetLinkRange along the lines of $sometoken[1]$ Group sg = m.Groups["li"]; // At this point g.Value = $sometoken[1]$ // and sg.Value = [1]. // We want the range's Key, which would be sometoken groupKey = g.Value.Substring(1, g.Value.Length - sg.Length - 2); // Now we need the range's Index which would be 1 in our fictitional case rangeIndex = int.Parse(sg.Value.Substring(1, sg.Value.Length - 2)); // Now we need to determine the actual _start and _end positions of the range. // Keep in mind we'll be stripping out the 2 $ and the subindex string (eg [1]) int start = startPos + g.Index; int end = start + g.Length - sg.Length - 2; // And now we add (or replace) the snippet link range at the index // keep in mind duplicates will stomp all over each other, the last // one wins. Replaced tokens won't get a range indexedRangesToActivate[rangeIndex] = new SnippetLinkRange(start, end, Scintilla, groupKey); ; // And remove all the token info including the subindex from the snippet text // leaving only the key snippet = snippet.Remove(g.Index, 1).Remove(g.Index - 2 + g.Length - sg.Length, sg.Length + 1); } else { // We have a regular old SnippetLinkRange along the lines of $sometoken$ // We want the range's Key, which would be sometoken groupKey = g.Value.Substring(1, g.Value.Length - 2); // Now we need to determine the actual _start and _end positions of the range. // Keep in mind we'll be stripping out the 2 $ int start = startPos + g.Index; int end = start + g.Length - 2; // Now create the range object unindexedRangesToActivate.Add(new SnippetLinkRange(start, end, Scintilla, groupKey)); // And remove all the token info from the snippet text // leaving only the key snippet = snippet.Remove(g.Index, 1).Remove(g.Index + g.Length - 2, 1); } } // Any more matches? Note that I'm rerunning the regexp query // on the snippet string becuase it's contents have been modified // and we need to get the updated index values. m = snippetRegex1.Match(snippet); } // Replace the snippet Keyword with the snippet text. Or if this // isn't triggered by a shortcut, it will insert at the current // Caret Position Scintilla.GetRange(startPos, NativeScintilla.GetCurrentPos()).Text = snippet; // Now that we have the text set we can activate our link ranges // we couldn't do it before becuase they were managed ranges and // would get offset by the text change // Since we are done adding new SnippetLinkRanges we can tack // on the unindexed ranges to the _end of the indexed ranges SnippetLinkRange[] allLinks = new SnippetLinkRange[indexedRangesToActivate.Count + unindexedRangesToActivate.Count]; for (int i = 0; i < indexedRangesToActivate.Values.Count; i++) allLinks[i] = indexedRangesToActivate[i]; for (int i = 0; i < unindexedRangesToActivate.Count; i++) allLinks[i + indexedRangesToActivate.Count] = unindexedRangesToActivate[i]; foreach (SnippetLinkRange slr in allLinks) addSnippetLink(slr); foreach (SnippetLinkRange slr in allLinks) slr.Init(); // Now we need to activate the Snippet links. However we have a bit // of a styling confilct. If we set the indicator styles before the // SQL Lexer styles the newly added text it won't get styled. So to // make sure we set the Indicator Styles after we put the call on // a timer. if (_snippetLinks.Count > 0) { Timer t = new Timer(); t.Interval = 10; // Oh how I love anonymous delegates, this is starting to remind // me of JavaScript and SetTimeout... t.Tick += new EventHandler(delegate(object sender, EventArgs te) { t.Dispose(); IsActive = true; }); t.Start(); } // Add all the Drop markers in the indexed order. The // order is reversed of course because drop markers work // in a FILO manner for (int i = dropMarkers.Count - 1; i >= 0; i--) Scintilla.DropMarkers.Drop(startPos + dropMarkers.Values[i]); // Place the caret at either the position of the token or // at the _end of the snippet text. if (caretPos >= 0) Scintilla.Caret.Goto(startPos + caretPos); else Scintilla.Caret.Goto(startPos + snippet.Length); // Ahoy, way anchor! if (anchorPos >= 0) Scintilla.Caret.Anchor = startPos + anchorPos; // Do we have an _end cursor? if (endPos >= 0) { // If they have snippet link ranges activated in this snippet // go ahead and set up an EndPoint marker if (allLinks.Length > 0) { SnippetLinkEnd eci = new SnippetLinkEnd(endPos + startPos, Scintilla); Scintilla.ManagedRanges.Add(eci); _snippetLinks.EndPoint = eci; } else { // Otherwise we treat it like an Anchor command because // the SnippetLink mode isn't activated Scintilla.Caret.Goto(endPos + startPos); } } NativeScintilla.EndUndoAction(); }
public void InsertSnippet(Snippet snip) { InsertSnippet(snip, Math.Min(NativeScintilla.GetCurrentPos(), NativeScintilla.GetAnchor())); }
public void TabIndentation() { var snippet = new Snippet( "forprops", "for (var property in object) {\r\n\tif (object.hasOwnProperty(property)) {\r\n\t\t$body$\r\n\t}\r\n};", new Declaration("p", "for (var p in object) {\r\n\tif (object.hasOwnProperty(p)) {\r\n\t\t$body$\r\n\t}\r\n};") ); using (var solution = BasicProject.Generate().ToVs()) { using (new SnippetTestOptionHolder(insertTabs: true, indentSize: 8, tabSize: 8)) { TestOneInsertSnippet(solution, snippet, "Nodejs"); solution.CloseActiveWindow(vsSaveChanges.vsSaveChangesNo); } } }
public void IndentSize() { var snippet = new Snippet( "tryf", "try {\r\n $body$\r\n} catch (e) {\r\n \r\n} finally {\r\n \r\n};", new Declaration("exception", "try {\r\n $body$\r\n} catch (exception) {\r\n \r\n} finally {\r\n \r\n};") ); using (var solution = BasicProject.Generate().ToVs()) { using (new SnippetTestOptionHolder(insertTabs: false, indentSize: 2, tabSize: 2)) { TestOneInsertSnippet(solution, snippet, "Nodejs"); solution.CloseActiveWindow(vsSaveChanges.vsSaveChangesNo); } } }
private static IEditor VerifySnippet(Snippet snippet, string body, IEditor server, bool insertViaMenu = false) { if (insertViaMenu) { Keyboard.Type(snippet.Shortcut + "\t"); // one tab for auto completion, one tab for snippet } else { Keyboard.Type(snippet.Shortcut + "\t\t"); } server.WaitForText(snippet.Expected.Replace("$body$", body)); foreach (var decl in snippet.Declarations) { Console.WriteLine("Declaration: {0}", decl.Replacement); Keyboard.Type(decl.Replacement); Keyboard.Type("→"); server.WaitForText(decl.Expected.Replace("$body$", body)); Keyboard.Type("\t"); } Keyboard.Type("\r"); return server; }
private static IEditor TestOneTabSnippet(IVisualStudioInstance solution, Snippet snippet) { Console.WriteLine("Testing: {0}", snippet.Shortcut); var server = solution.OpenItem("SnippetsTest", "server.js"); server.MoveCaret(1, 1); server.Invoke(() => server.TextView.Caret.EnsureVisible()); server.SetFocus(); return VerifySnippet(snippet, "", server); }
public void Selected() { var snippet = new Snippet( "if", "if (true) {\r\n $body$\r\n}", new Declaration("false", "if (false) {\r\n $body$\r\n}") ); using (var solution = BasicProject.Generate().ToVs()) { using (new SnippetTestOptionHolder()) { var app = TestOneTabSnippet(solution, snippet); Keyboard.Type("testing"); app.WaitForText("if (false) {\r\n testing\r\n}"); solution.CloseActiveWindow(vsSaveChanges.vsSaveChangesNo); } } }
private static IEditor TestOneSurroundWithSnippet(IVisualStudioInstance solution, Snippet snippet, string category, string body = "nonempty", string file = "nonempty.js") { Console.WriteLine("Testing: {0}", snippet.Shortcut); var server = solution.OpenItem("SnippetsTest", file); server.Select(1, 1, server.Text.Length); server.Invoke(() => server.TextView.Caret.EnsureVisible()); server.SetFocus(); solution.ExecuteCommand("Edit.SurroundWith"); Keyboard.Type(category + "\t"); return VerifySnippet(snippet, body, server, insertViaMenu: true); }