public void Humanize_model_labels_with_custom_casing(LetterCasing casing, string expected) { ModelMetadata metadata; switch (casing) { case LetterCasing.AllCaps: metadata = GetMetadataFor(m => m.FieldWithNoAttributes, To.UpperCase); break; case LetterCasing.LowerCase: metadata = GetMetadataFor(m => m.FieldWithNoAttributes, To.LowerCase); break; case LetterCasing.Sentence: metadata = GetMetadataFor(m => m.FieldWithNoAttributes, To.SentenceCase); break; // ReSharper disable once RedundantCaseLabel case LetterCasing.Title: default: metadata = GetMetadataFor(m => m.FieldWithNoAttributes, To.TitleCase); break; } Assert.That(metadata.DisplayName, Is.EqualTo(expected)); }
public static string ApplyCase(this string input, LetterCasing casing) { switch (casing) { case LetterCasing.Title: return(CultureInfo.CurrentCulture.TextInfo.ToTitleCase(input)); case LetterCasing.LowerCase: return(input.ToLower()); case LetterCasing.AllCaps: return(input.ToUpper()); case LetterCasing.Sentence: if (input.Length >= 1) { return(string.Concat(input.Substring(0, 1).ToUpper(), input.Substring(1))); } return(input.ToUpper()); default: throw new ArgumentOutOfRangeException("casing"); } }
public static List <IdNameIntDto> GetAll <TEnum>(LetterCasing letterCasing = LetterCasing.Title) where TEnum : struct { var enumerationType = typeof(TEnum); if (!enumerationType.IsEnum) { throw new ArgumentException("Enumeration type is expected."); } var dictionary = new Dictionary <int, string>(); foreach (int value in Enum.GetValues(enumerationType)) { var name = Enum.GetName(enumerationType, value); dictionary.Add(value, name); } var myList = dictionary.ToList(); myList.Sort( (pair1, pair2) => string.Compare(pair1.Value, pair2.Value, StringComparison.Ordinal) ); var list = new List <IdNameIntDto>(); myList.ForEach(item => { list.Add(new IdNameIntDto { Id = item.Key, Name = item.Value.Humanize(letterCasing) }); }); return(list); }
// Token: 0x06000032 RID: 50 RVA: 0x00002220 File Offset: 0x00000420 public static string ApplyCase(this string input, LetterCasing casing) { switch (casing) { case LetterCasing.Title: return(input.Transform(new IStringTransformer[] { To.TitleCase })); case LetterCasing.AllCaps: return(input.Transform(new IStringTransformer[] { To.UpperCase })); case LetterCasing.LowerCase: return(input.Transform(new IStringTransformer[] { To.LowerCase })); case LetterCasing.Sentence: return(input.Transform(new IStringTransformer[] { To.SentenceCase })); default: throw new ArgumentOutOfRangeException("casing"); } }
/// <summary> /// Register the HumanizedLabels metadata provider as the current Model Metadata Provider. /// </summary> public static void Register(LetterCasing casing = LetterCasing.Sentence) { ModelMetadataProviders.Current = new HumanizedLabels() { Casing = casing }; }
public void Humanize_model_labels_with_custom_casing(LetterCasing casing, string expected) { HumanizedLabels.Register(casing); var m = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(NonHumanizedViewModel), "SomeFieldName"); Assert.That(m.DisplayName, Is.EqualTo(expected)); }
public static string RemovePrefix(string prefix, string s, LetterCasing nextLetterCasing = LetterCasing.Upper) { if (!s.StartsWith(prefix, StringComparison.Ordinal)) { return(s); } var x = s.Substring(prefix.Length); if (x != FirstLetter(nextLetterCasing, x)) { return(s); } return(x); }
public static string FirstLetter(LetterCasing casing, string name) { switch (casing) { case LetterCasing.Lower: return(name.Substring(0, 1).ToLower() + name.Substring(1)); case LetterCasing.Upper: return(name.Substring(0, 1).ToUpper() + name.Substring(1)); case LetterCasing.None: default: return(name); } }
public static string ApplyCase(this string input, LetterCasing casing) { switch (casing) { case LetterCasing.Title: return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(input); case LetterCasing.LowerCase: return input.ToLower(); case LetterCasing.AllCaps: return input.ToUpper(); } return input; }
protected byte[] Decode(string input, LetterCasing casing) { if (casing == LetterCasing.Lower && input.Any(char.IsUpper)) { input = input.ToLower(); } if (casing == LetterCasing.Upper && input.Any(char.IsLower)) { input = input.ToUpper(); } return(Enumerable.Range(0, input.Length / 2) .Select(i => (byte)Convert.ToInt32(input.Substring(i * 2, 2), 16)) .ToArray()); }
/// <summary> /// Changes the casing of the provided input /// </summary> /// <param name="input"></param> /// <param name="casing"></param> /// <returns></returns> public static string ApplyCase(this string input, LetterCasing casing) { switch (casing) { case LetterCasing.Title: return input.Transform(To.TitleCase); case LetterCasing.LowerCase: return input.Transform(To.LowerCase); case LetterCasing.AllCaps: return input.Transform(To.UpperCase); case LetterCasing.Sentence: return input.Transform(To.SentenceCase); default: throw new ArgumentOutOfRangeException(nameof(casing)); } }
public static List <IdNameDescriptionDto> GetDescriptionAll <TEnum>(LetterCasing letterCasing = LetterCasing.Title) where TEnum : struct { var enumerationType = typeof(TEnum); if (!enumerationType.IsEnum) { throw new ArgumentException("Enumeration type is expected."); } var dictionary = new Dictionary <int, string>(); foreach (int value in Enum.GetValues(enumerationType)) { var name = enumerationType.GetEnumName(value); var memInfo = enumerationType.GetMember(name); var descriptionAttribute = memInfo[0] .GetCustomAttributes(typeof(DescriptionAttribute), false) .FirstOrDefault() as DescriptionAttribute; dictionary.Add(value, descriptionAttribute != null ? descriptionAttribute.Description : name); } var myList = dictionary.ToList(); myList.Sort( (pair1, pair2) => string.Compare(pair1.Value, pair2.Value, StringComparison.Ordinal) ); var list = new List <IdNameDescriptionDto>(); myList.ForEach(item => list.Add(new IdNameDescriptionDto { Id = item.Key, Description = item.Value })); return(list); }
/// <summary> /// Changes the casing of the provided input /// </summary> /// <param name="input"></param> /// <param name="casing"></param> /// <returns></returns> public static string ApplyCase(this string input, LetterCasing casing) { switch (casing) { case LetterCasing.Title: return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(input); case LetterCasing.LowerCase: return input.ToLower(); case LetterCasing.AllCaps: return input.ToUpper(); case LetterCasing.Sentence: if (input.Length >= 1) return string.Concat(input.Substring(0, 1).ToUpper(), input.Substring(1)); return input.ToUpper(); default: throw new ArgumentOutOfRangeException("casing"); } }
protected byte[] Decode(string input, bool padding, LetterCasing casing) { if (padding) { input = input.TrimEnd('='); } if (casing == LetterCasing.Lower && input.Any(char.IsUpper)) { input = input.ToLower(); } if (casing == LetterCasing.Upper && input.Any(char.IsLower)) { input = input.ToUpper(); } var bits = 0; var value = 0; var index = 0; var output = new byte[(input.Length * 5 / 8) | 0]; for (var i = 0; i < input.Length; i++) { value = (value << 5) | Array.IndexOf(Alphabet, input[i]); bits += 5; if (bits >= 8) { output[index++] = (byte)(((uint)value >> (bits - 8)) & 255); bits -= 8; } } return(output); }
/// <summary> /// Turns an enum member into a human readable string with the provided casing; e.g. AnonymousUser with Title casing -> Anonymous User. It also honors DescriptionAttribute data annotation /// </summary> /// <param name="input">The enum member to be humanized</param> /// <param name="casing">The casing to use for humanizing the enum member</param> /// <returns></returns> public static string Humanize(this Enum input, LetterCasing casing) { var humanizedEnum = Humanize(input); return(humanizedEnum.ApplyCase(casing)); }
protected string Encode(byte[] input, LetterCasing casing) { var format = casing == LetterCasing.Lower ? "{0:x2}" : "{0:X2}"; return(input.Aggregate(new StringBuilder(), (sb, b) => sb.AppendFormat(format, b)).ToString()); }
/// <summary> /// Turns an enum member into a human readable string with the provided casing; e.g. AnonymousUser with Title casing -> Anonymous User. It also honors DescriptionAttribute data annotation /// </summary> /// <param name="input">The enum member to be humanized</param> /// <param name="casing">The casing to use for humanizing the enum member</param> /// <returns></returns> public static string Humanize(this Enum input, LetterCasing casing) { var humanizedEnum = Humanize(input); return humanizedEnum.ApplyCase(casing); }
/// <summary> /// Humanized the input string based on the provided casing /// </summary> /// <param name="input">The string to be humanized</param> /// <param name="casing">The desired casing for the output</param> /// <returns></returns> public static string Humanize(this string input, LetterCasing casing) { return input.Humanize().ApplyCase(casing); }
/// <summary> /// Humanized the input string based on the provided casing /// </summary> /// <param name="input">The string to be humanized</param> /// <param name="casing">The desired casing for the output</param> /// <returns></returns> public static string Humanize(this string input, LetterCasing casing) { return(input.Humanize().ApplyCase(casing)); }
public static string Humanize(this string input, LetterCasing casing) { var humanizedString = input.Humanize(); return(ApplyCase(humanizedString, casing)); }
/// <summary> /// Humanized the input string based on the provided casing /// </summary> /// <param name="input">The string to be humanized</param> /// <param name="casing">The desired casing for the output</param> /// <returns></returns> public static string Humanize(this string input, LetterCasing casing) { var humanizedString = input.Humanize(); return humanizedString.ApplyCase(casing); }
public static object ConvertToString(object value, Type enumType, CultureInfo culture, LetterCasing letterCasing) { return value != null ? value.ToString().Humanize(letterCasing) : DependencyProperty.UnsetValue; }