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 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>
/// 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 };
}
/// <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;
}
