private static void AddCompleteItems(Type type, SortedDictionary <string, AutoCompleteItem> completeItems) { foreach (var member in type.GetFields(BindingFlags.Public | BindingFlags.Instance)) { completeItems.Add(new AutoCompleteItem(member)); } foreach (var member in type.GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(info => info.GetIndexParameters().Length == 0)) { completeItems.Add(new AutoCompleteItem(member)); } foreach (var member in type.GetEvents(BindingFlags.Public | BindingFlags.Instance)) { completeItems.Add(new AutoCompleteItem(member)); } if (!type.IsValueType && !typeof(Delegate).IsAssignableFrom(type)) { completeItems.Add(new AutoCompleteItem(AttachedMemberConstants.DataContext, AttachedMemberConstants.DataContext, MemberTypes.Custom)); } foreach (var attachedName in BindingServiceProvider.MemberProvider.GetAttachedMembers(type)) { if (!completeItems.ContainsKey(attachedName.Key) && XmlTokenizer.IsValidName(attachedName.Key)) { completeItems.Add(new AutoCompleteItem(attachedName.Key, attachedName.Key, MemberTypes.Custom, attachedName.Value.Type)); } } }
public void NewspaperDtdComplete() { var s = new SourceManager(@"<!DOCTYPE NEWSPAPER [ <!ELEMENT NEWSPAPER (ARTICLE+)> <!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)> <!ELEMENT HEADLINE (#PCDATA)> <!ELEMENT BYLINE (#PCDATA)> <!ELEMENT LEAD (#PCDATA)> <!ELEMENT BODY (#PCDATA)> <!ELEMENT NOTES (#PCDATA)> <!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED> <!ATTLIST ARTICLE EDITOR CDATA #IMPLIED> <!ATTLIST ARTICLE DATE CDATA #IMPLIED> <!ATTLIST ARTICLE EDITION CDATA #IMPLIED> <!ENTITY NEWSPAPER ""Vervet Logic Times""> <!ENTITY PUBLISHER ""Vervet Logic Press""> <!ENTITY COPYRIGHT 'Copyright 1998 Vervet Logic Press'> ]>"); var t = new XmlTokenizer(s); t.DTD.Reset(); var e = t.Get(); Assert.AreEqual(XmlTokenType.DOCTYPE, e.Type); var d = (XmlDoctypeToken)e; Assert.IsFalse(d.IsNameMissing); Assert.AreEqual("NEWSPAPER", d.Name); Assert.IsTrue(d.IsSystemIdentifierMissing); Assert.AreEqual(14, t.DTD.Count); }
public static FlowDocument ColorizeXAML(string xamlText, FlowDocument targetDoc) { XmlTokenizer tokenizer = new XmlTokenizer(); XmlTokenizerMode mode = XmlTokenizerMode.OutsideElement; List <XmlToken> tokens = tokenizer.Tokenize(xamlText, ref mode); List <string> tokenTexts = new List <string>(tokens.Count); List <Color> colors = new List <Color>(tokens.Count); int position = 0; foreach (XmlToken token in tokens) { string tokenText = xamlText.Substring(position, token.Length); tokenTexts.Add(tokenText); Color color = ColorForToken(token, tokenText); colors.Add(color); position += token.Length; } Paragraph p = new Paragraph(); // Loop through tokens for (int i = 0; i < tokenTexts.Count; i++) { Run r = new Run(tokenTexts[i]); r.Foreground = new SolidColorBrush(colors[i]); p.Inlines.Add(r); } targetDoc.Blocks.Add(p); return(targetDoc); }
public void EmptyXmlDocumentTokenization() { var s = new TextSource(""); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.IsInstanceOf <XmlEndOfFileToken>(e); }
public void EmptyXmlDocumentTokenization() { var s = new SourceManager(""); var t = new XmlTokenizer(s); var e = t.Get(); Assert.AreEqual(XmlToken.EOF, e); }
public void ValidXmlDeclarationOnlyVersion() { var s = new TextSource("<?xml version=\"1.0\"?>"); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.AreEqual(XmlTokenType.Declaration, e.Type); Assert.AreEqual("1.0", ((XmlDeclarationToken)e).Version); }
/// <summary> /// Creates a new instance of the XML parser. /// </summary> /// <param name="document">The document instance to be filled.</param> internal XmlDomBuilder(Document document) { var resolver = document.Options.GetService<IEntityService>() ?? XmlEntityService.Resolver; _tokenizer = new XmlTokenizer(document.Source, document.Options.Events, resolver); _document = document; _standalone = false; _openElements = new List<Element>(); _currentMode = XmlTreeMode.Initial; }
/// <summary> /// Format Xml in the passed rich text box. /// </summary> /// <param name="xmlEditor"></param> public static void FormatXml(RichTextBox xmlEditor) { // Stop redrawing RichTextDrawing.StopRedraw(xmlEditor); // Tokenize the Xml string List <XmlToken> tokens = XmlTokenizer.Tokenize(xmlEditor.Text); foreach (XmlToken token in tokens) { xmlEditor.Select(token.Index, token.Text.Length); switch (token.Type) { case XmlTokenType.None: xmlEditor.SelectionColor = xmlEditor.ForeColor; break; case XmlTokenType.SpecialChar: xmlEditor.SelectionColor = specialCharColor; break; case XmlTokenType.Escape: xmlEditor.SelectionColor = escapeColor; break; case XmlTokenType.Element: xmlEditor.SelectionColor = elementColor; break; case XmlTokenType.Attribute: xmlEditor.SelectionColor = attributeColor; break; case XmlTokenType.Value: xmlEditor.SelectionColor = valueColor; break; case XmlTokenType.Comment: xmlEditor.SelectionColor = commentColor; break; } } // Sample code to show that the perf problem is a RichTexBox problem //string content = xmlEditor.Text; //Random gen = new Random(); //for (int i = 0; i < content.Length; i++) //{ // xmlEditor.Select(i, 1); // Color c = Color.FromArgb(gen.Next(256), gen.Next(256), gen.Next(256)); // xmlEditor.SelectionColor = c; //} // Resume redraw RichTextDrawing.RestoreRedraw(xmlEditor); }
async void GenerateOutput(Object obj) { CmdletObject cmd = Tab.EditorContext.CurrentCmdlet; ModuleObject module = Tab.Module; if (cmd == null) { return; } BusyControlVisible = Visibility.Visible; RtbVisible = Visibility.Collapsed; WebBrowserVisible = Visibility.Collapsed; if (HtmlChecked) { HtmlText = await HtmlProcessor.GenerateHtmlView(cmd, module); HtmlText = String.Format(Properties.Resources.HtmlTemplate, cmd.Name, HtmlText, cmd.ExtraHeader, cmd.ExtraFooter); BusyControlVisible = Visibility.Collapsed; RtbVisible = Visibility.Collapsed; WebBrowserVisible = Visibility.Visible; return; } IEnumerable <XmlToken> data = new List <XmlToken>(); if (XmlChecked) { if (module.UpgradeRequired) { Utils.MsgBox("Warning", "The module is offline and requires upgrade. Upgrade the project to allow XML view.", MessageBoxButton.OK, MessageBoxImage.Warning); BusyControlVisible = Visibility.Collapsed; return; } List <CmdletObject> cmdlets = new List <CmdletObject> { cmd }; StringBuilder SB = new StringBuilder(); await XmlProcessor.XmlGenerateHelp(SB, cmdlets, null, module.IsOffline); data = XmlTokenizer.LoopTokenize(SB.ToString()); } else if (HtmlSourceChecked) { data = await HtmlProcessor.GenerateHtmlSourceHelp(cmd, module); } Paragraph para = new Paragraph(); para.Inlines.AddRange(ColorizeSource(data)); Document = new FlowDocument(); Document.Blocks.Add(para); BusyControlVisible = Visibility.Collapsed; WebBrowserVisible = Visibility.Collapsed; RtbVisible = Visibility.Visible; }
/// <summary> /// Tries to parse the Xml. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="element">The element.</param> /// <param name="to">To.</param> /// <returns></returns> public static bool TryParseXml <T>(IXPathNavigable element, out T to) where T : class, new() { if (element == null) { throw new ArgumentNullException("element"); } return(XmlTokenizer <T> .TryParse(element, new TokenizerArgs(), out to)); }
public void OneCommentInXmlDocument() { var c = "My comment"; var s = new TextSource("<!--" + c + "-->"); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.AreEqual(XmlTokenType.Comment, e.Type); Assert.AreEqual(c, ((XmlCommentToken)e).Data); }
/// <summary> /// Creates a new instance of the XML parser. /// </summary> /// <param name="document">The document instance to be filled.</param> /// <param name="creator">The optional non-standard creator to use.</param> internal XmlDomBuilder(Document document, Func<Document, String, String, Element> creator = null) { var resolver = document.Options.GetProvider<IEntityProvider>() ?? XmlEntityService.Resolver; _tokenizer = new XmlTokenizer(document.Source, resolver); _document = document; _standalone = false; _openElements = new List<Element>(); _currentMode = XmlTreeMode.Initial; _creator = creator ?? CreateElement; }
public void ProductCatalogDtdComplete() { var s = new SourceManager(@"<!DOCTYPE CATALOG [ <!ENTITY AUTHOR ""John Doe""> <!ENTITY COMPANY ""JD Power Tools, Inc.""> <!ENTITY EMAIL ""*****@*****.**""> <!ELEMENT CATALOG (PRODUCT+)> <!ELEMENT PRODUCT (SPECIFICATIONS+,OPTIONS?,PRICE+,NOTES?)> <!ATTLIST PRODUCT NAME CDATA #IMPLIED CATEGORY (HandTool|Table|Shop-Professional) ""HandTool"" PARTNUM CDATA #IMPLIED PLANT (Pittsburgh|Milwaukee|Chicago) ""Chicago"" INVENTORY (InStock|Backordered|Discontinued) ""InStock""> <!ELEMENT SPECIFICATIONS (#PCDATA)> <!ATTLIST SPECIFICATIONS WEIGHT CDATA #IMPLIED POWER CDATA #IMPLIED> <!ELEMENT OPTIONS (#PCDATA)> <!ATTLIST OPTIONS FINISH (Metal|Polished|Matte) ""Matte"" ADAPTER (Included|Optional|NotApplicable) ""Included"" CASE (HardShell|Soft|NotApplicable) ""HardShell""> <!ELEMENT PRICE (#PCDATA)> <!ATTLIST PRICE MSRP CDATA #IMPLIED WHOLESALE CDATA #IMPLIED STREET CDATA #IMPLIED SHIPPING CDATA #IMPLIED> <!ELEMENT NOTES (#PCDATA)> ]>"); var t = new XmlTokenizer(s); t.DTD.Reset(); var e = t.Get(); Assert.AreEqual(XmlTokenType.DOCTYPE, e.Type); var d = (XmlDoctypeToken)e; Assert.IsFalse(d.IsNameMissing); Assert.AreEqual("CATALOG", d.Name); Assert.IsTrue(d.IsSystemIdentifierMissing); Assert.AreEqual(13, t.DTD.Count); }
public void XmlTokenizerStringAndCustomEntityToken() { var resolver = new MockEntityProvider(str => str.Equals("bar;") ? "foo" : null); var s = new TextSource("test&bar;"); var t = new XmlTokenizer(s, resolver); var test = t.Get(); var end = t.Get(); Assert.AreEqual(XmlTokenType.Character, test.Type); Assert.AreEqual("testfoo", ((XmlCharacterToken)test).Data); Assert.AreEqual(XmlTokenType.EndOfFile, end.Type); }
public void ValidXmlDeclarationVersionAndEncoding() { var s = new TextSource("<?xml version=\"1.1\" encoding=\"utf-8\" ?>"); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.AreEqual(XmlTokenType.Declaration, e.Type); var x = (XmlDeclarationToken)e; Assert.AreEqual("1.1", x.Version); Assert.IsFalse(x.IsEncodingMissing); Assert.AreEqual("utf-8", x.Encoding); }
public void OneDoctypeInXmlDocument() { var s = new TextSource("<!DOCTYPE root_element SYSTEM \"DTD_location\">"); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.AreEqual(XmlTokenType.Doctype, e.Type); var d = (XmlDoctypeToken)e; Assert.IsFalse(d.IsNameMissing); Assert.AreEqual("root_element", d.Name); Assert.IsFalse(d.IsSystemIdentifierMissing); Assert.AreEqual("DTD_location", d.SystemIdentifier); }
public void ValidXmlDeclarationEverything() { var s = new TextSource("<?xml version='1.0' encoding='ISO-8859-1' standalone=\"yes\" ?>"); var t = new XmlTokenizer(s, null); var e = t.Get(); Assert.AreEqual(XmlTokenType.Declaration, e.Type); var x = (XmlDeclarationToken)e; Assert.AreEqual("1.0", x.Version); Assert.IsFalse(x.IsEncodingMissing); Assert.AreEqual("ISO-8859-1", x.Encoding); Assert.AreEqual(true, x.Standalone); }
public void TestSubscriptionOfSingleObserver() { using (ITokenizer tokenizer = new XmlTokenizer(this.BaseStream)) { Mock <IObserver <ReadOnlySequence <byte> > > observerMock = new Mock <IObserver <ReadOnlySequence <byte> > >(); List <String> actualMessages = new List <String>(); using (ManualResetEventSlim sync = new ManualResetEventSlim()) { observerMock.Setup(x => x.OnNext(It.IsAny <ReadOnlySequence <byte> >())).Callback((ReadOnlySequence <byte> token) => { String message = XmlSerializationSettings.Encoding.GetString(token.ToArray()); actualMessages.Add(message); }); observerMock.Setup(x => x.OnCompleted()).Callback(() => { sync.Set(); }); using (IDisposable subscription = tokenizer.Subscribe(observerMock.Object)) { sync.Wait(); // Number of calls depends on buffer size. observerMock.Verify(x => x.OnNext(It.IsAny <ReadOnlySequence <byte> >()), Times.Exactly(this.Messages.Count)); Assert.AreEqual(actualMessages.Count, this.Messages.Count); for (int i = 0; i < actualMessages.Count; i++) { String expected = this.Messages[i]; String actual = actualMessages[i]; XmlComparer.AreEqual(expected, actual); } Assert.IsNotNull(subscription); } } } }
public void WithDefaultTokenizationOptions_ShouldUseOptionsWhenSearchingWithNoTokenizerOptions() { var factory = new Mock <ITokenizerFactory>(); var tokenizer = new FakeTokenizer(); var xmlTokenizer = new XmlTokenizer(); factory.Setup(f => f.Create(It.Is <TokenizationOptions>(o => o.TokenizerKind == TokenizerKind.XmlContent))).Returns(xmlTokenizer); factory.Setup(f => f.Create(It.Is <TokenizationOptions>(o => o.TokenizerKind == TokenizerKind.PlainText))).Returns(tokenizer); var parser = this.ConfigureQueryParserMock(); this.sut.WithTokenizerFactory(factory.Object); this.sut.WithDefaultTokenizationOptions(o => o.XmlContent()); var index = this.sut.Build(); index.Search("test").Should().BeEmpty(); index.Search("test with tokenization options", TokenizationOptions.Default).Should().BeEmpty(); parser.Verify(p => p.Parse(It.IsAny <IIndexedFieldLookup>(), "test", xmlTokenizer), Times.Once); parser.Verify(p => p.Parse(It.IsAny <IIndexedFieldLookup>(), "test with tokenization options", tokenizer), Times.Once); }
public void TestSubscriptionOfMultipleObservers() { using (ITokenizer tokenizer = new XmlTokenizer(this.BaseStream, Diagnostics.NullInteractionLog.Instance, bufferSize: 16, XmlSerializationSettings.MaximumMessageSize)) { Mock <IObserver <ReadOnlySequence <byte> > > observerMockFirst = new(); Mock <IObserver <ReadOnlySequence <byte> > > observerMockSecond = new(); using (ManualResetEventSlim observerMockFirstSync = new ManualResetEventSlim()) { using (ManualResetEventSlim observerMockSecondSync = new ManualResetEventSlim()) { observerMockFirst.Setup(x => x.OnCompleted()).Callback(() => { observerMockFirstSync.Set(); }); observerMockSecond.Setup(x => x.OnCompleted()).Callback(() => { observerMockSecondSync.Set(); }); IConnectableObservable <ReadOnlySequence <byte> > observable = (from token in tokenizer select token).Publish(); observable.Subscribe(observerMockFirst.Object); observable.Subscribe(observerMockSecond.Object); observable.Connect(); observerMockFirstSync.Wait(); observerMockSecondSync.Wait(); // Number of calls depends on buffer size. observerMockFirst.Verify(x => x.OnNext(It.IsAny <ReadOnlySequence <byte> >()), Times.AtLeast(this.Messages.Count)); observerMockSecond.Verify(x => x.OnNext(It.IsAny <ReadOnlySequence <byte> >()), Times.AtLeast(this.Messages.Count)); } } } }
public void TVScheduleDtdSubset() { var dtd = @"<!ELEMENT TVSCHEDULE (CHANNEL+)> <!ELEMENT CHANNEL (BANNER,DAY+)> <!ELEMENT BANNER (#PCDATA)> <!ELEMENT DAY (DATE,(HOLIDAY|PROGRAMSLOT+)+)> <!ELEMENT HOLIDAY (#PCDATA)> <!ELEMENT DATE (#PCDATA)> <!ELEMENT PROGRAMSLOT (TIME,TITLE,DESCRIPTION?)> <!ELEMENT TIME (#PCDATA)> <!ELEMENT TITLE (#PCDATA)> <!ELEMENT DESCRIPTION (#PCDATA)> <!ATTLIST TVSCHEDULE NAME CDATA #REQUIRED> <!ATTLIST CHANNEL CHAN CDATA #REQUIRED> <!ATTLIST PROGRAMSLOT VTR CDATA #IMPLIED> <!ATTLIST TITLE RATING CDATA #IMPLIED> <!ATTLIST TITLE LANGUAGE CDATA #IMPLIED>"; var text = "<!DOCTYPE TVSCHEDULE [" + dtd + "]>"; var s = new SourceManager(text); var t = new XmlTokenizer(s); t.DTD.Reset(); var e = t.Get(); Assert.AreEqual(XmlTokenType.DOCTYPE, e.Type); var d = (XmlDoctypeToken)e; Assert.IsFalse(d.IsNameMissing); Assert.AreEqual("TVSCHEDULE", d.Name); Assert.IsTrue(d.IsSystemIdentifierMissing); Assert.AreEqual(15, t.DTD.Count); //Unfortunately C# counts newlines with 2 characters since \r\n is used Assert.AreEqual(dtd.Replace("\r\n", "\n"), d.InternalSubset); //This is annoying but meh - what can we do? W3C specifies we need to use //\n for newlines and omit \r completely. }
/// <summary> /// Tries to write XML. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="xmlWriter">The XML writer.</param> /// <param name="value">The value.</param> /// <param name="args">The args.</param> /// <returns></returns> public static bool TryWriteXml <T>(XmlWriter xmlWriter, T value, TokenizerArgs args) where T : class, new() { return(XmlTokenizer <T> .TryWrite(xmlWriter, value, args)); }
public void XmlTokenizerStringAndCustomEntityToken() { var resolver = new MockEntityResolver(str => str.Equals("bar") ? "foo" : null); var s = new TextSource("test&bar;"); var t = new XmlTokenizer(s, null, resolver); var test = t.Get(); var end = t.Get(); Assert.AreEqual(XmlTokenType.Character, test.Type); Assert.AreEqual("testfoo", ((XmlCharacterToken)test).Data); Assert.AreEqual(XmlTokenType.EndOfFile, end.Type); }
public void XmlWorkSplittingNew() { var splitter = new XmlTokenizer(); splitter.Process(WikipediaData.SampleData[0].text).ToList(); }
public void TVScheduleDtdComplete() { var dtd = @"<!DOCTYPE TVSCHEDULE [ <!ELEMENT TVSCHEDULE (CHANNEL+)> <!ELEMENT CHANNEL (BANNER,DAY+)> <!ELEMENT BANNER (#PCDATA)> <!ELEMENT DAY (DATE,(HOLIDAY|PROGRAMSLOT+)+)> <!ELEMENT HOLIDAY (#PCDATA)> <!ELEMENT DATE (#PCDATA)> <!ELEMENT PROGRAMSLOT (TIME,TITLE,DESCRIPTION?)> <!ELEMENT TIME (#PCDATA)> <!ELEMENT TITLE (#PCDATA)> <!ELEMENT DESCRIPTION (#PCDATA)> <!ATTLIST TVSCHEDULE NAME CDATA #REQUIRED> <!ATTLIST CHANNEL CHAN CDATA #REQUIRED> <!ATTLIST PROGRAMSLOT VTR CDATA #IMPLIED> <!ATTLIST TITLE RATING CDATA #IMPLIED> <!ATTLIST TITLE LANGUAGE CDATA #IMPLIED> ]>"; var s = new SourceManager(dtd); var t = new XmlTokenizer(s); t.DTD.Reset(); var e = t.Get(); Assert.IsTrue(t.DTD[0] is ElementDeclaration); var f1 = (t.DTD[0] as ElementDeclaration); Assert.AreEqual("TVSCHEDULE", f1.Name); Assert.AreEqual(ElementContentType.Children, f1.Entry.Type); Assert.IsTrue(f1.Entry is ElementChoiceDeclarationEntry); var g1 = (f1.Entry as ElementChoiceDeclarationEntry); Assert.AreEqual(ElementQuantifier.One, g1.Quantifier); Assert.AreEqual(1, g1.Choice.Count); Assert.IsTrue(g1.Choice[0] is ElementNameDeclarationEntry); var h1 = (g1.Choice[0] as ElementNameDeclarationEntry); Assert.AreEqual(ElementQuantifier.OneOrMore, h1.Quantifier); Assert.AreEqual("CHANNEL", h1.Name); Assert.IsTrue(t.DTD[3] is ElementDeclaration); var f2 = (t.DTD[3] as ElementDeclaration); Assert.AreEqual("DAY", f2.Name); Assert.AreEqual(ElementContentType.Children, f2.Entry.Type); Assert.IsTrue(f2.Entry is ElementSequenceDeclarationEntry); var g2 = (f2.Entry as ElementSequenceDeclarationEntry); Assert.AreEqual(ElementQuantifier.One, g2.Quantifier); Assert.AreEqual(2, g2.Sequence.Count); Assert.AreEqual(ElementQuantifier.One, g2.Sequence[0].Quantifier); Assert.AreEqual(ElementQuantifier.OneOrMore, g2.Sequence[1].Quantifier); Assert.IsTrue(g2.Sequence[0] is ElementNameDeclarationEntry); Assert.IsTrue(g2.Sequence[1] is ElementChoiceDeclarationEntry); var g3 = (g2.Sequence[0] as ElementNameDeclarationEntry); var g4 = (g2.Sequence[1] as ElementChoiceDeclarationEntry); Assert.AreEqual("DATE", g3.Name); Assert.AreEqual(2, g4.Choice.Count); Assert.IsTrue(g4.Choice[0] is ElementNameDeclarationEntry); Assert.IsTrue(g4.Choice[1] is ElementNameDeclarationEntry); var g5 = (g4.Choice[0] as ElementNameDeclarationEntry); var g6 = (g4.Choice[1] as ElementNameDeclarationEntry); Assert.AreEqual("HOLIDAY", g5.Name); Assert.AreEqual("PROGRAMSLOT", g6.Name); Assert.AreEqual(ElementQuantifier.One, g5.Quantifier); Assert.AreEqual(ElementQuantifier.OneOrMore, g6.Quantifier); Assert.IsTrue(t.DTD[10] is AttributeDeclaration); var f7 = (t.DTD[10] as AttributeDeclaration); Assert.AreEqual("TVSCHEDULE", f7.Name); Assert.AreEqual(1, f7.Count); Assert.AreEqual("NAME", f7[0].Name); Assert.IsInstanceOfType(f7[0].Type, typeof(AttributeStringType)); Assert.IsInstanceOfType(f7[0].Default, typeof(AttributeRequiredValue)); }
public XmlTokenizerTests() { this.sut = new XmlTokenizer(); ((ITokenizer)this.sut).Configure(TokenizationOptions.Default); }