public static CaseConverter GetCasingConverter(this CasingType casingType, bool removeNonAlphaNumericChars, bool removeWhiteSpace, bool removeAccents)
{
switch (casingType)
{
case CasingType.UpperCase:
return(new UpperCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.LowerCase:
return(new LowerCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.PascalCase:
return(new PascalCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.CamelCase:
return(new CamelCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.HypenCase:
return(new HypenCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.SnakeCase:
return(new SnakeCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
case CasingType.Original:
default:
return(new OriginalCaseConverter(removeNonAlphaNumericChars, removeWhiteSpace, removeAccents));
}
}
private string ApplyCasing(
string propertyName,
CasingType casing)
{
switch (casing)
{
case CasingType.Original:
return(propertyName);
case CasingType.CamelCase:
{
var parts = PropertyNameSplitter.Split(propertyName);
return(string.Join("", parts.Select((part, idx) => idx == 0 ? part : FirstLetterUppercase(part))));
}
case CasingType.PascalCase:
{
var parts = PropertyNameSplitter.Split(propertyName);
return(string.Join("", parts.Select(FirstLetterUppercase)));
}
case CasingType.Custom:
return(settings.CustomPropertyNamingFunc(propertyName));
default:
throw new ArgumentOutOfRangeException(nameof(casing), casing, null);
}
}
public static string CreateValidIdentifier(string identifier, CasingType casingType = CasingType.None)
{
string casedIdentifier;
switch (casingType)
{
case CasingType.Camel:
casedIdentifier = identifier.ToCamelCase();
break;
case CasingType.Pascal:
casedIdentifier = identifier.ToPascalCase();
break;
default:
casedIdentifier = identifier;
break;
}
bool isValid = CodeProvider.IsValidIdentifier(casedIdentifier);
if (!isValid)
{
// File name contains invalid chars, remove them
casedIdentifier = Regex.Replace(casedIdentifier, string.Empty);
// Class name doesn't begin with a letter, insert an underscore
if (!char.IsLetter(casedIdentifier, 0))
{
casedIdentifier = casedIdentifier.Insert(0, "_");
}
}
return(CodeProvider.CreateValidIdentifier(casedIdentifier.Replace(" ", string.Empty)));
}
private static JsonSerializerSettings GetSelializationSettings(CasingType casingType)
{
var settings = default(JsonSerializerSettings);
switch (casingType)
{
case CasingType.Camel:
settings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
break;
case CasingType.Snake:
settings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = new SnakeCaseNamingStrategy()
}
};
break;
}
return(settings);
}
public void TextHeaderPropagatorIsCaseSensitive(CasingType casingType)
{
UInt64 spanId = 4952807665017200957;
UInt64 traceId = 14848807816610383171;
var headers = new Dictionary <string, string>
{
{ ToCase("Ot-Tracer-Spanid", casingType), spanId.ToString("X") },
{ ToCase("Ot-Tracer-Traceid", casingType), traceId.ToString("X") },
};
var textPropagator = new TextMapPropagator();
var extractedContext =
textPropagator.Extract(BuiltinFormats.TextMap,
new TextMapExtractAdapter(headers));
if (casingType != CasingType.LowerCase)
{
Assert.Null(extractedContext);
return;
}
Assert.NotNull(extractedContext);
Assert.Equal(spanId.ToString("x"), extractedContext.SpanId);
Assert.Equal(traceId.ToString("x"), extractedContext.TraceId);
}
/// <summary>
/// Return a Random color.
/// </summary>
/// <param name="format"></param>
/// <param name="casing"></param>
/// <param name="grayscale"></param>
/// <example>
/// <code language="cs">
/// // this will return a string. (ex. "rgba(128, 255, 128, 0.5)")
/// var color = _random.Color(ColorFormat.Rgba);
/// </code>
/// </example>
/// <returns></returns>
public string Color(ColorFormat format, CasingType casing = CasingType.Lower, bool grayscale = true)
{
var colorValue = "";
switch (format)
{
case ColorFormat.Hex:
colorValue = string.Format("#{0}", grayscale ? Gray(Hash(2)) : Hash(6));
break;
case ColorFormat.ShortHex:
colorValue = string.Format("#{0}", grayscale ? Gray(Hash(1)) : Hash(3));
break;
case ColorFormat.Rgb:
if (grayscale)
{
var rgb = Gray(Natural(max: 255).ToString(), ",");
colorValue = string.Format("rgb({0})", rgb);
}
else
{
var r = Natural(255);
var g = Natural(255);
var b = Natural(255);
colorValue = string.Format("rgb({0}, {1}, {2})", r, g, b);
}
break;
case ColorFormat.Rgba:
if (grayscale)
{
var rgb = Gray(Natural(max: 255).ToString(), ",");
var alpha = Float(0, 1);
colorValue = string.Format("rgba({0}, {1})", rgb, alpha);
}
else
{
var r = Natural(255);
var g = Natural(255);
var b = Natural(255);
var alpha = Float(0, 1);
colorValue = string.Format("rgba({0}, {1}, {2}, {3})", r, g, b, alpha);
}
break;
case ColorFormat.ConstantHex:
colorValue = string.Format("0x{0}", grayscale ? Gray(Hash(2)) : Hash(6));
break;
default:
colorValue = string.Empty;
break;
}
if (casing == CasingType.Upper)
colorValue = colorValue.ToUpper();
return colorValue;
}
public static string ToJsonString <T>(this T data, CasingType casingType = CasingType.Pascal)
{
var settings = GetSelializationSettings(casingType);
if (settings != null)
{
return(JsonConvert.SerializeObject(data, settings));
}
return(JsonConvert.SerializeObject(data));
}
private string ToCase(string input, CasingType casingType)
{
switch (casingType)
{
case CasingType.LowerCase:
return(input.ToLower());
case CasingType.UpperCase:
return(input.ToUpper());
}
return(input);
}
/// <summary>
/// Return a random hex hash.
/// </summary>
/// <param name="length"></param>
/// <param name="casing"></param>
/// <returns></returns>
public string Hash(int length = 40, CasingType casing = CasingType.Lower)
{
length.ThrowIfOutOfRange(0, 512);
var pool = Constants.HexPool;
switch (casing)
{
case CasingType.Upper:
pool = pool.ToUpper();
break;
case CasingType.Both:
pool = (pool + Constants.CharsUpper);
break;
}
return String(length, pool);
}
/// <summary>
/// Return a random hex hash.
/// </summary>
/// <param name="length"></param>
/// <param name="casing"></param>
/// <returns></returns>
public string Hash(int length = 40, CasingType casing = CasingType.Lower)
{
length.ThrowIfOutOfRange(0, 512);
var pool = Constants.HexPool;
switch (casing)
{
case CasingType.Upper:
pool = pool.ToUpper();
break;
case CasingType.Both:
pool = (pool + Constants.CharsUpper);
break;
}
return(String(length, pool));
}
public void HttpHeaderPropagatorIsCaseInsensitive(CasingType casingType)
{
UInt64 spanId = 4952807665017200957;
UInt64 traceId = 14848807816610383171;
var headers = new Dictionary <string, string>
{
{ ToCase("Ot-Tracer-Spanid", casingType), spanId.ToString("X") },
{ ToCase("Ot-Tracer-Traceid", casingType), traceId.ToString("X") },
};
var httpPropagator = new HttpHeadersPropagator();
var extractedContext =
httpPropagator.Extract(BuiltinFormats.HttpHeaders,
new TextMapExtractAdapter(headers));
Assert.NotNull(extractedContext);
Assert.Equal(spanId.ToString(), extractedContext.SpanId);
Assert.Equal(traceId.ToString(), extractedContext.TraceId);
}
/// <summary>
/// Return a random character.
/// </summary>
/// <param name="symbols">specify use of symbols (!@#$%^&*()).</param>
/// <param name="alpha">specify alpha for only an alphanumeric character.</param>
/// <param name="pool">specify a pool and the character will be generated with characters only from that pool.</param>
/// <param name="casing">specify casing</param>
/// <example>
/// <code language="cs">var character = _random.Character(false, true);</code>
/// </example>
/// <returns>A char from the char pool.</returns>
public char Character(bool symbols = false, bool alpha = true, string pool = Constants.DefaultStringPool, CasingType casing = CasingType.Both)
{
string letters;
string charPool;
switch (casing)
{
case CasingType.Lower:
letters = Constants.CharsLower;
break;
case CasingType.Upper:
letters = Constants.CharsUpper;
break;
default:
letters = Constants.CharsLower + Constants.CharsUpper;
break;
}
if (!string.IsNullOrEmpty(pool))
{
charPool = pool;
}
else if (alpha)
{
charPool = letters;
}
else if (symbols)
{
charPool = Constants.CharSymbols;
}
else
{
charPool = string.Format("{0}{1}{2}", letters, Constants.Numbers, Constants.CharSymbols);
}
var natural = Natural(max: charPool.Length - 1);
return charPool[natural];
}
/// <summary>
/// Set the type of fixed component
/// </summary>
/// <param name="casingType">The type of fixed component</param>
public void setCasingType(CasingType casingType)
{
_typeHoleCasing = casingType;
}
/// <summary>
/// Set the type of fixed component
/// </summary>
/// <param name="casingType">The type of fixed component</param>
public void setCasingType(CasingType casingType)
{
_typeHoleCasing = casingType;
}
/// <summary>
/// Return a Random color.
/// </summary>
/// <param name="format"></param>
/// <param name="casing"></param>
/// <param name="grayscale"></param>
/// <example>
/// <code language="cs">
/// // this will return a string. (ex. "rgba(128, 255, 128, 0.5)")
/// var color = _random.Color(ColorFormat.Rgba);
/// </code>
/// </example>
/// <returns></returns>
public string Color(ColorFormat format, CasingType casing = CasingType.Lower, bool grayscale = true)
{
var colorValue = "";
switch (format)
{
case ColorFormat.Hex:
colorValue = string.Format("#{0}", grayscale ? Gray(Hash(2)) : Hash(6));
break;
case ColorFormat.ShortHex:
colorValue = string.Format("#{0}", grayscale ? Gray(Hash(1)) : Hash(3));
break;
case ColorFormat.Rgb:
if (grayscale)
{
var rgb = Gray(Natural(max: 255).ToString(), ",");
colorValue = string.Format("rgb({0})", rgb);
}
else
{
var r = Natural(255);
var g = Natural(255);
var b = Natural(255);
colorValue = string.Format("rgb({0}, {1}, {2})", r, g, b);
}
break;
case ColorFormat.Rgba:
if (grayscale)
{
var rgb = Gray(Natural(max: 255).ToString(), ",");
var alpha = Float(0, 1);
colorValue = string.Format("rgba({0}, {1})", rgb, alpha);
}
else
{
var r = Natural(255);
var g = Natural(255);
var b = Natural(255);
var alpha = Float(0, 1);
colorValue = string.Format("rgba({0}, {1}, {2}, {3})", r, g, b, alpha);
}
break;
case ColorFormat.ConstantHex:
colorValue = string.Format("0x{0}", grayscale ? Gray(Hash(2)) : Hash(6));
break;
default:
colorValue = string.Empty;
break;
}
if (casing == CasingType.Upper)
{
colorValue = colorValue.ToUpper();
}
return(colorValue);
}
public static string ToValidIdentifier(this string value, CasingType casingType)
{
return(CSharpUtils.CreateValidIdentifier(value, casingType));
}
/// <summary>
/// Return a random character.
/// </summary>
/// <param name="symbols">specify use of symbols (!@#$%^&*()).</param>
/// <param name="alpha">specify alpha for only an alphanumeric character.</param>
/// <param name="pool">specify a pool and the character will be generated with characters only from that pool.</param>
/// <param name="casing">specify casing</param>
/// <example>
/// <code language="cs">var character = _random.Character(false, true);</code>
/// </example>
/// <returns>A char from the char pool.</returns>
public char Character(bool symbols = false, bool alpha = true, string pool = Constants.DefaultStringPool, CasingType casing = CasingType.Both)
{
string letters;
string charPool;
switch (casing)
{
case CasingType.Lower:
letters = Constants.CharsLower;
break;
case CasingType.Upper:
letters = Constants.CharsUpper;
break;
default:
letters = Constants.CharsLower + Constants.CharsUpper;
break;
}
if (!string.IsNullOrEmpty(pool))
{
charPool = pool;
}
else if (alpha)
{
charPool = letters;
}
else if (symbols)
{
charPool = Constants.CharSymbols;
}
else
{
charPool = string.Format("{0}{1}{2}", letters, Constants.Numbers, Constants.CharSymbols);
}
var natural = Natural(max: charPool.Length - 1);
return(charPool[natural]);
}
