예제 #1
0
            private string ReplaceText(string format)
            {
                StringBuilder builder = new StringBuilder();

                foreach (PythonTuple pt in StringFormatParser.Parse(format))
                {
                    string text          = (string)pt[0];
                    string fieldName     = (string)pt[1];
                    string formatSpec    = (string)pt[2];
                    string conversionStr = (string)pt[3];
                    char?  conversion    = conversionStr != null && conversionStr.Length > 0 ? conversionStr[0] : (char?)null;

                    builder.Append(text);

                    if (fieldName != null)
                    {
                        // get the argument value
                        object argValue = GetArgumentValue(ParseFieldName(fieldName, true));

                        // apply the conversion
                        argValue = ApplyConversion(conversion, argValue);

                        // handle computed format specifiers
                        formatSpec = ReplaceComputedFormats(formatSpec);

                        // append the string
                        builder.Append(Builtin.format(_context.SharedContext, argValue, formatSpec));
                    }
                }

                return(builder.ToString());
            }
예제 #2
0
        /// <inheritdoc/>
        public IApplicationStructureConfigurationBuilder Include(ApplicationArea area, string format)
        {
            if (!format.StartsWith("["))
            {
                format = $"[.]{format}";
            }
            var formatsByArea = new Dictionary <ApplicationArea, IEnumerable <IStringFormat> >(_structureFormats);
            var parser        = new StringFormatParser();
            var stringFormat  = parser.Parse(format);

            List <IStringFormat> formats;

            if (formatsByArea.ContainsKey(area))
            {
                formats = new List <IStringFormat>(formatsByArea[area]);
            }
            else
            {
                formats = new List <IStringFormat>();
            }

            formats.Add(stringFormat);
            formatsByArea[area] = formats;

            var builder = new ApplicationStructureConfigurationBuilder(formatsByArea);

            return(builder);
        }
예제 #3
0
        public static void TryParse(string format)
        {
            var success = StringFormatParser <LengthUnit> .TryParse(format, out var actual);

            Assert.AreEqual(true, success);
            Assert.AreEqual(null, actual.PrePadding);
            Assert.AreEqual("F1", actual.ValueFormat);
            Assert.AreEqual(" ", actual.Padding);
            Assert.AreEqual("mm", actual.SymbolFormat);
            Assert.AreEqual(null, actual.PostPadding);
        }
    public void Calling_Parse_With_A_String_Without_Placeholders_Returns_Error()
    {
        // Arrange
        var input = "test";

        // Act
        var actual = StringFormatParser.Parse(input);

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.First().Should().Be("No format placeholders were found");
    }
    public void Calling_Parse_With_Too_Many_CloseBrackets_Returns_Error()
    {
        // Arrange
        var input = "}}";

        // Act
        var actual = StringFormatParser.Parse(input);

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.First().Should().Be("Too many close brackets found");
    }
    public void Calling_ParseWithArgumentsString_With_Empty_ArgumentsString_Returns_Error()
    {
        // Arrange
        var input = "";

        // Act
        var actual = StringFormatParser.ParseWithArgumentsString("something", input);

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.First().Should().Be("Arguments string is empty");
    }
    public void Calling_Parse_With_Empty_FormatString_Returns_Error()
    {
        // Arrange
        var input = "";

        // Act
        var actual = StringFormatParser.Parse(input, new[] { "A" });

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.First().Should().Be("Format string is empty");
    }
    public void CanUseParsedArgumentsStringForStringFormat()
    {
        // Arrange
        const string FormatString    = "Hello, {0}{1}";
        const string ArgumentsString = "John Doe, !";
        var          parsedArguments = StringFormatParser.ParseWithArgumentsString(FormatString, ArgumentsString).Values.Select(kvp => kvp.Value.ToString()).ToArray(); //note that we have to replace the double quotes...

        // Act
        var actual = string.Format(FormatString, parsedArguments);

        // Assert
        actual.Should().Be("Hello, John Doe!");
    }
    public void CanParseFormatStringWithArgumentUsedMultipleTimes()
    {
        // Arrange
        const string FormatString = "Hello {0}{1}{1}{1}";
        var          args = new object[] { "world", "!" }.ToArray();

        // Act
        var actual = StringFormatParser.Parse(FormatString, args);

        // Assert
        actual.IsSuccessful.Should().BeTrue();
        actual.ErrorMessages.Should().BeEmpty();
        var contents = string.Join("|", actual.Values.Select(kvp => string.Format("{0};{1}", kvp.Key, kvp.Value)));

        contents.Should().Be("0;world|1;!");
    }
    public void CanParseFormatStringWithFormatter()
    {
        // Arrange
        const string FormatString = "Hello {0}{1} on {2:dd-MM-yyyy}";
        var          args = new object[] { "world", "!", new DateTime(2018, 1, 1) }.ToArray();

        // Act
        var actual = StringFormatParser.Parse(FormatString, args);

        // Assert
        actual.IsSuccessful.Should().BeTrue();
        actual.ErrorMessages.Should().BeEmpty();
        var contents = string.Join("|", actual.Values.Select(kvp => string.Format("{0};{1}", kvp.Key, kvp.Value)));

        contents.Should().Be($"0;world|1;!|2;{new DateTime(2018, 1, 1)}");
    }
    public void CanParseFormatStringWithArgumentsString()
    {
        // Arrange
        const string FormatString = "Hello {0}{1}";
        const string Args         = "\"world\", \"!\"";

        // Act
        var actual = StringFormatParser.ParseWithArgumentsString(FormatString, Args);

        // Assert
        actual.IsSuccessful.Should().BeTrue();
        actual.ErrorMessages.Should().BeEmpty();
        var contents = string.Join("|", actual.Values.Select(kvp => string.Format("{0};{1}", kvp.Key, kvp.Value)));

        contents.Should().Be("0;\"world\"|1;\"!\"");
    }
    public void CanParseFormatStringWithMissingArguments()
    {
        // Arrange
        const string FormatString = "Hello {0}{1}";
        var          args = new object[] { "world" }.ToArray();

        // Act
        var actual = StringFormatParser.Parse(FormatString, args);

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.ElementAt(0).Should().Be("Format placeholders count (2) is not equal to column values count (1), see #MISSING# in format values list (values)");
        var contents = string.Join("|", actual.Values.Select(kvp => string.Format("{0};{1}", kvp.Key, kvp.Value)));

        contents.Should().Be("0;world|1;#MISSING#");
    }
    public void CanParseFormatStringWithMissingFormatSpecifiers()
    {
        // Arrange
        const string FormatString = "Hello {0}{1";
        var          args = new object[] { "world", "!" }.ToArray();

        // Act
        var actual = StringFormatParser.Parse(FormatString, args);

        // Assert
        actual.IsSuccessful.Should().BeFalse();
        actual.ErrorMessages.Should().HaveCount(1);
        actual.ErrorMessages.ElementAt(0).Should().Be("Warning: Format value 1 was not found in format placeholders");
        var contents = string.Join("|", actual.Values.Select(kvp => string.Format("{0};{1}", kvp.Key, kvp.Value)));

        contents.Should().Be("0;world|1;!");
    }
예제 #14
0
        public string Format(LoggerEvent loggerEvent)
        {
            var args = new object[_messageNames.Count];

            for (int i = 0; i < _messageNames.Count; ++i)
            {
                args[i] = string.Empty;
                if (loggerEvent.Properties.ContainsKey(_messageNames[i]))
                {
                    object arg = loggerEvent[_messageNames[i]];
                    if (_singleFileProps.Contains(_messageNames[i]))
                    {
                        arg = SavePropToFile(_messageNames[i], arg);
                    }
                    if (!(arg is string) && (arg is IEnumerable))
                    {
                        args[i] = ObjectDumper.DumpObject(arg, dumperSetting);
                    }
                    else
                    {
                        args[i] = arg;
                    }
                }
                else
                {
                    switch (_messageNames[i])
                    {
                    case LoggerEvent.EVENTTYPE_PROPERTY:
                        args[i] = loggerEvent.EventType;
                        break;
                    }
                }
            }
            try
            {
                return(string.Format(_format, args));
            }
            catch (Exception ex)
            {
                _format = StringFormatParser.Parse(DEFAULT_FORMAT, out _messageNames);
                CoreApplication.Instance.Logger.LogWarning(Message.Common_SingleLineFormatterFormatError, ex, _userFormat);
                return(Format(loggerEvent));
            }
        }
예제 #15
0
 public void Init(NameValueConfigurationCollection props)
 {
     if (props[PAR_FORMAT] != null && !String.IsNullOrEmpty(props[PAR_FORMAT].Value))
     {
         _userFormat = props[PAR_FORMAT].Value;
         _format     = StringFormatParser.Parse(_userFormat, out _messageNames);
         _format     = _format.Replace("\\n", "\n").Replace("\\r", "\r").Replace("\\t", "\t");
     }
     else
     {
         _format = StringFormatParser.Parse(DEFAULT_FORMAT, out _messageNames);
     }
     if (props[PAR_ARRAY_DELIMITER] != null && !String.IsNullOrEmpty(props[PAR_ARRAY_DELIMITER].Value))
     {
         dumperSetting.EnumerableDelimiter = props[PAR_ARRAY_DELIMITER].Value;
     }
     if (props[PAR_SINGLE_FILE_PROPS] != null && !String.IsNullOrEmpty(props[PAR_SINGLE_FILE_PROPS].Value))
     {
         _singleFileProps.Clear();
         _singleFileProps.AddRange(props[PAR_SINGLE_FILE_PROPS].Value.Split(';'));
     }
 }
예제 #16
0
 public FormattedTraceListener(string format)
 {
     _format = StringFormatParser.Parse(format, out _messageNames);
     _format = _format.Replace("\\n", "\n").Replace("\\r", "\r").Replace("\\t", "\t");
 }
예제 #17
0
        /// <summary>
        /// Gets the formatting information for the given format.  This is a list of tuples.  The tuples
        /// include:
        ///
        /// text, field name, format spec, conversion
        /// </summary>
        public static IEnumerable <PythonTuple /*!*/> /*!*/ GetFormatInfo(string /*!*/ format)
        {
            ContractUtils.RequiresNotNull(format, "format");

            return(StringFormatParser.Parse(format));
        }