public void AppendTest()
        {
            var sb  = new StringBuilder();
            var fsb = new FormattedStringBuilder();

            sb.Append(true);
            fsb.Append(true);
            sb.Append((byte)10);
            fsb.Append((byte)10);
            sb.Append((decimal)10.0);
            fsb.Append((decimal)10.0);
            sb.Append(3.14);
            fsb.Append(3.14);
            sb.Append(3.14f);
            fsb.Append(3.14f);
            sb.Append((short)10);
            fsb.Append((short)10);
            sb.Append(19);
            fsb.Append(19);
            sb.Append(1L);
            fsb.Append(1L);
            sb.Append((object)"aaa");
            fsb.Append((object)"aaa");
            sb.Append('1');
            fsb.Append('1');
            sb.Append("text text");
            fsb.Append("text text");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
        }
예제 #2
0
        public void FormattedStringBuilderEndToEnd1()
        {
            var classificationFormatMap = new MockClassificationFormatMap();
            var htmlMarkupProvider = new HtmlMarkupProvider(
                classificationFormatMap,
                MockClassificationType.Default,
                Brushes.White);
            var classifier = new MockClassifier();

            var formattedStringBuilder = new FormattedStringBuilder(
                htmlMarkupProvider,
                classifier,
                MockClassificationType.Default,
                waitIndicator: null);

            var snapshot = new MockTextSnapshot("bla");
            var spans = new NormalizedSnapshotSpanCollection(new []
            {
                new SnapshotSpan(snapshot, 0, 3)
            });

            var actualResult = formattedStringBuilder.AppendSnapshotSpans(spans);
            var expectedResult = "<pre style=\"font-family:Consolas;font-size:12;color:black;background:white;\">b<span style=\"color:blue;\">l</span>a\r\n</pre>";

            Assert.AreEqual(expectedResult, actualResult);
        }
        public void InsertTest()
        {
            var sb  = new StringBuilder();
            var fsb = new FormattedStringBuilder();

            sb.Append("abcdefghijk");
            fsb.Append("abcdefghijk");

            sb.Insert(3, true);
            fsb.Insert(3, true);
            sb.Insert(3, (byte)10);
            fsb.Insert(3, (byte)10);
            sb.Insert(3, (decimal)10.0);
            fsb.Insert(3, (decimal)10.0);
            sb.Insert(3, 3.14);
            fsb.Insert(3, 3.14);
            sb.Insert(3, 3.14f);
            fsb.Insert(3, 3.14f);
            sb.Insert(3, (short)10);
            fsb.Insert(3, (short)10);
            sb.Insert(3, 19);
            fsb.Insert(3, 19);
            sb.Insert(3, 1L);
            fsb.Insert(3, 1L);
            sb.Insert(3, (object)"aaa");
            fsb.Insert(3, (object)"aaa");
            sb.Insert(3, 'c');
            fsb.Insert(3, 'c');
            sb.Insert(3, "sfg");
            fsb.Insert(3, "sfg");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
        }
 public void Generate(FormattedStringBuilder stringBuilder, string[] references)
 {
     foreach (string reference in references)
     {
         stringBuilder.AppendLine($"using {reference};");
     }
 }
        public static FormattedStringBuilder Italic(this FormattedStringBuilder source)
        {
            source.Append("<i>");
            source.PushToEnd("</i>");

            return(source);
        }
예제 #6
0
        public void FormattedStringBuilderEndToEnd1()
        {
            var classificationFormatMap = new MockClassificationFormatMap();
            var htmlMarkupProvider      = new HtmlMarkupProvider(
                classificationFormatMap,
                MockClassificationType.Default,
                Brushes.White);
            var classifier = new MockClassifier();

            var formattedStringBuilder = new FormattedStringBuilder(
                htmlMarkupProvider,
                classifier,
                MockClassificationType.Default,
                waitIndicator: null);

            var snapshot = new MockTextSnapshot("bla");
            var spans    = new NormalizedSnapshotSpanCollection(new []
            {
                new SnapshotSpan(snapshot, 0, 3)
            });

            var actualResult   = formattedStringBuilder.AppendSnapshotSpans(spans);
            var expectedResult = "<pre style=\"font-family:Consolas;font-size:12;color:black;background:white;\">b<span style=\"color:blue;\">l</span>a\r\n</pre>";

            Assert.AreEqual(expectedResult, actualResult);
        }
        public static FormattedStringBuilder Bold(this FormattedStringBuilder source)
        {
            source.Append("<b>");
            source.PushToEnd("</b>");

            return(source);
        }
예제 #8
0
 private void GenerateMembers(FormattedStringBuilder stringBuilder, IMemberGenerationTemplate memberGenerationTemplate, IList <MemberDetails> members)
 {
     foreach (MemberDetails details in members)
     {
         memberGenerationTemplate.Generate(stringBuilder, details.Name, details.Type, details.Cardinality);
     }
 }
        public static FormattedStringBuilder Color(this FormattedStringBuilder source, string color)
        {
            source.Append("<color=");
            source.Append(color);
            source.Append(">");

            source.PushToEnd("</color>");

            return(source);
        }
        public static FormattedStringBuilder Size(this FormattedStringBuilder source, int size)
        {
            source.Append("<size=");
            source.Append(size.ToString());
            source.Append(">");

            source.PushToEnd("</size>");

            return(source);
        }
        //[Fact] not ready yet
        public void Create_default_format_with_builder()
        {
            string actual = new FormattedStringBuilder()
                            .AddTime("H:mm:ss")
                            .AddText("|")
                            .AddLevel(-7)
                            .AddText("|")
                            .Build();

            Assert.Equal("{time:H:mm:ss,fff}|{level,-7}|{source}|{message}{error}", actual);
        }
        public void AppendLineTest()
        {
            var sb  = new StringBuilder();
            var fsb = new FormattedStringBuilder();

            sb.AppendLine();
            fsb.AppendLine();
            sb.AppendLine("aaa");
            fsb.AppendLine("aaa");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
        }
예제 #13
0
        public void Generate(FormattedStringBuilder stringBuilder, string className, Visibility visibility, IMemberGenerationTemplate propertyGenerationTemplate, IList <MemberDetails> memberDetails)
        {
            string modifier = visibility.Equals(Visibility.Private) ? "private" : "public";

            stringBuilder.AppendLine($"{modifier} class {className}");

            stringBuilder.AppendLine("{");
            stringBuilder.LevelDown();

            GenerateMembers(stringBuilder, propertyGenerationTemplate, memberDetails);

            stringBuilder.LevelUp();
            stringBuilder.AppendLine("}");
        }
        public void Generate(FormattedStringBuilder stringBuilder, string propertyName, string propertyType, Cardinality cardinality)
        {
            switch (cardinality)
            {
            case Cardinality.OneToOne:
                stringBuilder.AppendLine($"public virtual {propertyType} {propertyName} {{ get; set; }}");
                break;

            case Cardinality.OneToMany:
                stringBuilder.AppendLine($"public virtual IList<{propertyType}> {propertyName} {{ get; private set;}}");
                break;

            default:
                throw new NotSupportedException($"Cardinality {cardinality} is not supported for this template.");
            }
        }
예제 #15
0
    public void Empty()
    {
        var sb = new FormattedStringBuilder();

        sb.Append("")
        .Append(FormattedString.Empty)
        .Append(new FormattedString(""))
        .Append(new FormattedString("", new ConsoleFormat(Foreground: AnsiColor.Red)))
        .Append(new FormattedString("", new FormatSpan(0, 0, new ConsoleFormat(Foreground: AnsiColor.Red))));

        Assert.Equal(0, sb.Length);
        Assert.Equal(FormattedString.Empty, sb.ToFormattedString());

        sb.Clear();

        Assert.Equal(0, sb.Length);
        Assert.Equal(FormattedString.Empty, sb.ToFormattedString());
    }
        public void RemoveTest()
        {
            var sb  = new StringBuilder();
            var fsb = new FormattedStringBuilder();

            sb.Append("abcdefghijk");
            fsb.Append("abcdefghijk");

            sb.Remove(0, 2);
            fsb.Remove(0, 2);

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());

            sb.Remove(sb.Length - 3, 3);
            fsb.Remove(fsb.Length - 3, 3);

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);
        }
예제 #17
0
        public void FontTest()
        {
            var span = new Span()
            {
                Text = "text", FontAttributes = FontAttributes.Bold
            };

            FormattedString a     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             aText = "<span font=\"bold\">text</span>";

            span.FontAttributes = FontAttributes.Bold | FontAttributes.Italic;
            FormattedString b     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             bText = "<span font=\"italic-bold\">text</span>";

            Assert.AreEqual(converter.SerializeObject(a), aText);
            Assert.AreEqual(converter.SerializeObject(b), bText);

            Assert.AreEqual(spanEquals(a, converter.DeserializeObject(converter.SerializeObject(a))), true);
            Assert.AreEqual(spanEquals(b, converter.DeserializeObject(converter.SerializeObject(b))), true);
        }
예제 #18
0
        public void FontSizeTest()
        {
            var span = new Span()
            {
                Text = "test\ntest", FontSize = FontSize.UltraBig
            };

            FormattedString a     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             aText = "<span font-size=\"ultra-big\">test<br>test</span>";

            span.FontSize = FontSize.Normal;
            FormattedString b     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             bText = "<span>test<br>test</span>";

            Assert.AreEqual(converter.SerializeObject(a), aText);
            Assert.AreEqual(converter.SerializeObject(b), bText);

            Assert.AreEqual(spanEquals(a, converter.DeserializeObject(converter.SerializeObject(a))), true);
            Assert.AreEqual(spanEquals(b, converter.DeserializeObject(converter.SerializeObject(b))), true);
        }
예제 #19
0
        public void ColorTest()
        {
            var span = new Span()
            {
                Text = "text", ForegroundColor = new SpanColor(1, 2, 3, 4)
            };

            FormattedString a     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             aText = "<span f-color=\"1,2,3,4\">text</span>";

            span.ForegroundColor = SpanColor.DefaultValue;
            span.BackgroundColor = new SpanColor(4, 3, 2, 1);
            FormattedString b     = new FormattedStringBuilder().Append(span).ToFormattedString();
            var             bText = "<span b-color=\"4,3,2,1\">text</span>";

            Assert.AreEqual(converter.SerializeObject(a), aText);
            Assert.AreEqual(converter.SerializeObject(b), bText);

            Assert.AreEqual(spanEquals(a, converter.DeserializeObject(converter.SerializeObject(a))), true);
            Assert.AreEqual(spanEquals(b, converter.DeserializeObject(converter.SerializeObject(b))), true);
        }
예제 #20
0
    public void Append()
    {
        var sb = new FormattedStringBuilder();

        sb.Append("1")
        .Append(FormattedString.Empty)
        .Append("2", new FormatSpan(0, 1, new ConsoleFormat(Foreground: AnsiColor.Red)))
        .Append("34", new FormatSpan(0, 1, new ConsoleFormat(Foreground: AnsiColor.Green)), new FormatSpan(1, 1, new ConsoleFormat(Foreground: AnsiColor.Yellow)));

        Assert.Equal(4, sb.Length);
        Assert.Equal(
            new FormattedString(
                "1234",
                new FormatSpan(1, 1, new ConsoleFormat(Foreground: AnsiColor.Red)),
                new FormatSpan(2, 1, new ConsoleFormat(Foreground: AnsiColor.Green)),
                new FormatSpan(3, 1, new ConsoleFormat(Foreground: AnsiColor.Yellow))),
            sb.ToFormattedString());

        sb.Clear();

        Assert.Equal(0, sb.Length);
        Assert.Equal(FormattedString.Empty, sb.ToFormattedString());
    }
 public static FormattedStringBuilder Yellow(this FormattedStringBuilder source) => source.Color("yellow");
 public static FormattedStringBuilder Navy(this FormattedStringBuilder source) => source.Color("navy");
 public static FormattedStringBuilder Olive(this FormattedStringBuilder source) => source.Color("olive");
 public static FormattedStringBuilder Orange(this FormattedStringBuilder source) => source.Color("orange");
 public static FormattedStringBuilder Purple(this FormattedStringBuilder source) => source.Color("purple");
 public static FormattedStringBuilder Red(this FormattedStringBuilder source) => source.Color("red");
 public static FormattedStringBuilder Silver(this FormattedStringBuilder source) => source.Color("silver");
 public static FormattedStringBuilder Teal(this FormattedStringBuilder source) => source.Color("teal");
        public void ReplaceTest()
        {
            var sb  = new StringBuilder();
            var fsb = new FormattedStringBuilder();

            sb.Append("ashgilassfianvlaih");
            fsb.Append("ashgilassfianvlaih");
            sb.Replace('a', 'b');
            fsb.Replace('a', 'b');

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());

            sb.Clear();
            fsb.Clear();
            sb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            fsb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            sb.Replace('a', 'b', 2, 4);
            fsb.Replace('a', 'b', 2, 4);

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());

            sb.Clear();
            fsb.Clear();
            sb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            fsb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            sb.Replace("a", "[]");
            fsb.Replace("a", "[]");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);

            sb.Replace("[]", "a");
            fsb.Replace("[]", "a");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);

            sb.Replace("aaa", "b");
            fsb.Replace("aaa", "b");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);

            sb.Replace("b", "a", 1, 2);
            fsb.Replace("b", "a", 1, 2);

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);

            sb.Replace("a", "");
            fsb.Replace("a", "");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);

            sb.Clear();
            fsb.Clear();
            sb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            fsb.Append("aaaaaaaaaaaaaaaaaaaaaaaaa");
            sb.Replace("c", "[]");
            fsb.Replace("c", "[]");

            Assert.AreEqual(fsb.ToFormattedString().Text, sb.ToString());
            Assert.AreEqual(fsb.Length, sb.Length);
        }
 public static FormattedStringBuilder White(this FormattedStringBuilder source) => source.Color("white");
예제 #31
0
 public void Generate(FormattedStringBuilder formattedStringBuilder, string @namespace)
 {
     formattedStringBuilder.AppendLine($"namespace {@namespace}");
     formattedStringBuilder.AppendLine();
 }
예제 #32
0
        public string GenerateHtml(NormalizedSnapshotSpanCollection spans, IWpfTextView textView)
        {
            if (spans == null || spans.Count == 0)
            {
                return "";
            }

            // this will trigger loading of the package
            // so we can ensure ToolsOptionsPage gets created and
            // ToolsOptionsPage.Instance gets set
            var dte = (_DTE)_serviceProvider.GetService(typeof(_DTE));
            var props = dte.Properties[CopyAsHtmlPackage.CategoryName, CopyAsHtmlPackage.PageName];

            IClassificationFormatMap formatMap = _classificationFormatMappingService.GetClassificationFormatMap(textView);
            IClassificationType defaultClassificationType = _classificationTypeRegistry.GetClassificationType("text");
            HtmlMarkupProvider htmlMarkupProvider = new HtmlMarkupProvider(
                formatMap,
                defaultClassificationType,
                textView.Background);
            IClassifier classifier = _classifierAggregatorService.GetClassifier(textView.TextBuffer);

            var formattedStringBuilder = new FormattedStringBuilder(
                htmlMarkupProvider,
                classifier,
                defaultClassificationType,
                this.WaitIndicator);

            string result = formattedStringBuilder.AppendSnapshotSpans(spans);

            var classifierDispose = classifier as System.IDisposable;
            if (classifierDispose != null)
            {
                classifierDispose.Dispose();
            }

            return result;
        }