humanizer (Humanizr/Humanizer)

humanizer (Humanizr/Humanizer) | MoltPulse

"PascalCaseInputStringIsTurnedIntoSentence".Humanize() 
    => "Pascal case input string is turned into sentence"

"Underscored_input_string_is_turned_into_sentence".Humanize() 
    => "Underscored input string is turned into sentence"

"dash-separated-string".Humanize() 
    => "Dash separated string"

"HTML".Humanize() => "HTML"  // Acronym preserved
"HUMANIZER".Humanize() => "HUMANIZER"  // All caps preserved

// Force humanization with Transform
"HUMANIZER".Transform(To.LowerCase, To.TitleCase) => "Humanizer"

"CanReturnTitleCase".Humanize(LetterCasing.Title) => "Can Return Title Case"
"CanReturnLowerCase".Humanize(LetterCasing.LowerCase) => "can return lower case"
"CanHumanizeIntoUpperCase".Humanize(LetterCasing.AllCaps) => "CAN HUMANIZE INTO UPPER CASE"
"some string".Humanize(LetterCasing.Sentence) => "Some string"

// Before v3.0: returned ""
// v3.0 and later: returns "@@"
"@@".Humanize() => "@@"

// Cyrillic and other Unicode scripts are also preserved
"Майк".Titleize() => "Майк"

"Pascal case input string is turned into sentence".Dehumanize() 
    => "PascalCaseInputStringIsTurnedIntoSentence"

"some string".Dehumanize() => "SomeString"
"Some String".Dehumanize() => "SomeString"

"Sentence casing".Transform(To.LowerCase) => "sentence casing"
"Sentence casing".Transform(To.SentenceCase) => "Sentence casing"
"Sentence casing".Transform(To.TitleCase) => "Sentence Casing"
"Sentence casing".Transform(To.UpperCase) => "SENTENCE CASING"

"Long text to truncate".Truncate(10) => "Long text…"
"Long text to truncate".Truncate(10, "---") => "Long te---"

// Fixed length (default)
"Long text to truncate".Truncate(10, Truncator.FixedLength) => "Long text…"

// Fixed number of words
"Long text to truncate".Truncate(2, Truncator.FixedNumberOfWords) => "Long text…"

// Truncate from the left
"Long text to truncate".Truncate(10, Truncator.FixedLength, TruncateFrom.Left) 
    => "… truncate"

public enum UserType
{
    [Description("Custom description")]
    MemberWithDescriptionAttribute,
    MemberWithoutDescriptionAttribute,
    ALLCAPITALS
}

// DescriptionAttribute value is used
UserType.MemberWithDescriptionAttribute.Humanize() => "Custom description"

// Automatic humanization when no attribute
UserType.MemberWithoutDescriptionAttribute.Humanize() 
    => "Member without description attribute"

// Apply casing transformations
UserType.MemberWithoutDescriptionAttribute.Humanize().Transform(To.TitleCase) 
    => "Member Without Description Attribute"

"Member without description attribute".DehumanizeTo<UserType>() 
    => UserType.MemberWithoutDescriptionAttribute

// Non-generic version for runtime types
"Member without description attribute".DehumanizeTo(typeof(UserType)) 
    => UserType.MemberWithoutDescriptionAttribute

// Handle missing matches gracefully
"Invalid".DehumanizeTo<UserType>(OnNoMatch.ReturnsNull) => null

DateTime.UtcNow.AddHours(-2).Humanize() => "2 hours ago"
DateTime.UtcNow.AddHours(-30).Humanize() => "yesterday"

DateTime.UtcNow.AddHours(2).Humanize() => "2 hours from now"
DateTime.UtcNow.AddHours(30).Humanize() => "tomorrow"

DateTimeOffset.UtcNow.AddHours(1).Humanize() => "an hour from now"

public static string Humanize(this DateTime input, bool utcDate = true, DateTime? dateToCompareAgainst = null, CultureInfo culture = null)
public static string Humanize(this DateTimeOffset input, DateTimeOffset? dateToCompareAgainst = null, CultureInfo culture = null)

// In ar culture
DateTime.UtcNow.AddDays(-1).Humanize() => "أمس"
DateTime.UtcNow.AddDays(-2).Humanize() => "منذ يومين"
DateTime.UtcNow.AddDays(-3).Humanize() => "منذ 3 أيام"
DateTime.UtcNow.AddDays(-11).Humanize() => "منذ 11 يوم"

// In ru-RU culture
DateTime.UtcNow.AddMinutes(-1).Humanize() => "минуту назад"
DateTime.UtcNow.AddMinutes(-2).Humanize() => "2 минуты назад"
DateTime.UtcNow.AddMinutes(-10).Humanize() => "10 минут назад"
DateTime.UtcNow.AddMinutes(-21).Humanize() => "21 минуту назад"
DateTime.UtcNow.AddMinutes(-22).Humanize() => "22 минуты назад"
DateTime.UtcNow.AddMinutes(-40).Humanize() => "40 минут назад"

Configurator.DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy(precision: .75);
Configurator.DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy(precision: .75); // configure when humanizing DateTimeOffset

44 seconds => 44 seconds ago/from now
45 seconds => one minute ago/from now
104 seconds => one minute ago/from now
105 seconds => two minutes ago/from now

25 days => a month ago/from now

TimeSpan.FromMilliseconds(1).Humanize() => "1 millisecond"
TimeSpan.FromMilliseconds(2).Humanize() => "2 milliseconds"
TimeSpan.FromDays(1).Humanize() => "1 day"
TimeSpan.FromDays(16).Humanize() => "2 weeks"

TimeSpan.FromDays(1).Humanize(precision:2) => "1 day" // no difference when there is only one unit in the provided TimeSpan
TimeSpan.FromDays(16).Humanize(2) => "2 weeks, 2 days"

// the same TimeSpan value with different precision returns different results
TimeSpan.FromMilliseconds(1299630020).Humanize() => "2 weeks"
TimeSpan.FromMilliseconds(1299630020).Humanize(3) => "2 weeks, 1 day, 1 hour"
TimeSpan.FromMilliseconds(1299630020).Humanize(4) => "2 weeks, 1 day, 1 hour, 30 seconds"
TimeSpan.FromMilliseconds(1299630020).Humanize(5) => "2 weeks, 1 day, 1 hour, 30 seconds, 20 milliseconds"

TimeSpan.FromMilliseconds(3603001).Humanize(3) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan.FromMilliseconds(3603001).Humanize(3, countEmptyUnits:true) => "1 hour, 3 seconds"

// in de-DE culture
TimeSpan.FromDays(1).Humanize() => "Ein Tag"
TimeSpan.FromDays(2).Humanize() => "2 Tage"

// in sk-SK culture
TimeSpan.FromMilliseconds(1).Humanize() => "1 milisekunda"
TimeSpan.FromMilliseconds(2).Humanize() => "2 milisekundy"
TimeSpan.FromMilliseconds(5).Humanize() => "5 milisekúnd"

TimeSpan.FromDays(1).Humanize(culture: "ru-RU") => "один день"

TimeSpan.FromMilliseconds(122500).Humanize(minUnit: TimeUnit.Second) => "2 minutes, 2 seconds"    // instead of 2 minutes, 2 seconds, 500 milliseconds
TimeSpan.FromHours(25).Humanize(minUnit: TimeUnit.Day) => "1 Day"   //instead of 1 Day, 1 Hour

TimeSpan.FromDays(7).Humanize(maxUnit: TimeUnit.Day) => "7 days"    // instead of 1 week
TimeSpan.FromMilliseconds(2000).Humanize(maxUnit: TimeUnit.Millisecond) => "2000 milliseconds"    // instead of 2 seconds

TimeSpan.FromDays(486).Humanize(maxUnit: TimeUnit.Year, precision: 7) => "1 year, 3 months, 29 days" // One day further is 1 year, 4 month
TimeSpan.FromDays(517).Humanize(maxUnit: TimeUnit.Year, precision: 7) => "1 year, 4 months, 30 days" // This month has 30 days and one day further is 1 year, 5 months

TimeSpan.FromMilliseconds(1299630020).Humanize(3) => "2 weeks, 1 day, 1 hour"

TimeSpan.Zero.Humanize(1) => "0 milliseconds"
TimeSpan.Zero.Humanize(1, toWords: true) => "no time"
TimeSpan.Zero.Humanize(1, minUnit: Humanizer.Localisation.TimeUnit.Second) => "0 seconds"

TimeSpan.FromMilliseconds(1299630020).Humanize(3, collectionSeparator: " - ") => "2 weeks - 1 day - 1 hour"

// in en-US culture
TimeSpan.FromMilliseconds(1299630020).Humanize(3, collectionSeparator: null) => "2 weeks, 1 day, and 1 hour"

// in de-DE culture
TimeSpan.FromMilliseconds(1299630020).Humanize(3, collectionSeparator: null) => "2 Wochen, Ein Tag und Eine Stunde"

TimeSpan.FromMilliseconds(1299630020).Humanize(3, toWords: true) => "two weeks, one day, one hour"

// in en-US culture
TimeSpan.FromDays(750).ToAge() => "2 years old"

// in fr culture
TimeSpan.FromDays(750).ToAge() => "2 ans"

class SomeClass
{
    public string SomeString;
    public int SomeInt;
    public override string ToString()
    {
        return "Specific String";
    }
}

string FormatSomeClass(SomeClass sc)
{
    return string.Format("SomeObject #{0} - {1}", sc.SomeInt, sc.SomeString);
}

var collection = new List<SomeClass>
{
    new SomeClass { SomeInt = 1, SomeString = "One" },
    new SomeClass { SomeInt = 2, SomeString = "Two" },
    new SomeClass { SomeInt = 3, SomeString = "Three" }
};

collection.Humanize()                                    // "Specific String, Specific String, and Specific String"
collection.Humanize("or")                                // "Specific String, Specific String, or Specific String"
collection.Humanize(FormatSomeClass)                     // "SomeObject #1 - One, SomeObject #2 - Two, and SomeObject #3 - Three"
collection.Humanize(sc => sc.SomeInt.Ordinalize(), "or") // "1st, 2nd, or 3rd"

"Man".Pluralize() => "Men"
"string".Pluralize() => "strings"
"person".Pluralize() => "people"

// Uncertain plurality? Use the optional parameter
"Men".Pluralize(inputIsKnownToBeSingular: false) => "Men"
"string".Pluralize(inputIsKnownToBeSingular: false) => "strings"

"Men".Singularize() => "Man"
"strings".Singularize() => "string"
"people".Singularize() => "person"

// Uncertain plurality? Use the optional parameter
"Man".Singularize(inputIsKnownToBePlural: false) => "Man"

// Adds a word to the vocabulary which cannot easily be pluralized/singularized by RegEx.
// Will match both "salesperson" and "person".
Vocabularies.Default.AddIrregular("person", "people");

// To only match "person" and not "salesperson" you would pass false for the 'matchEnding' parameter.
Vocabularies.Default.AddIrregular("person", "people", matchEnding: false);

// Adds an uncountable word to the vocabulary.  Will be ignored when plurality is changed:
Vocabularies.Default.AddUncountable("fish");

// Adds a rule to the vocabulary that does not follow trivial rules for pluralization:
Vocabularies.Default.AddPlural("bus", "buses");

// Adds a rule to the vocabulary that does not follow trivial rules for singularization
// (will match both "vertices" -> "vertex" and "indices" -> "index"):
Vocabularies.Default.AddSingular("(vert|ind)ices$", "$1ex");

"case".ToQuantity(0) => "0 cases"
"case".ToQuantity(1) => "1 case"
"case".ToQuantity(5) => "5 cases"
"man".ToQuantity(2) => "2 men"

// Display quantity as words or hide it
"case".ToQuantity(5, ShowQuantityAs.Words) => "five cases"
"case".ToQuantity(5, ShowQuantityAs.None) => "cases"

// Format with custom number formatting
"dollar".ToQuantity(2, "C0", new CultureInfo("en-US")) => "$2 dollars"
"cases".ToQuantity(12000, "N0") => "12,000 cases"

1.Ordinalize() => "1st"
5.Ordinalize() => "5th"
21.Ordinalize() => "21st"
"21".Ordinalize() => "21st"

// Supports grammatical gender (culture-specific)
1.Ordinalize(GrammaticalGender.Feminine) => "1ª"  // Brazilian Portuguese
1.Ordinalize(GrammaticalGender.Masculine) => "1º"  // Brazilian Portuguese

// Titleize: Title Case with spaces
"some_title".Titleize() => "Some Title"

// Pascalize: UpperCamelCase without spaces
"some_title for something".Pascalize() => "SomeTitleForSomething"

// Camelize: lowerCamelCase without spaces
"some_title for something".Camelize() => "someTitleForSomething"

// Underscore: snake_case
"SomeTitle".Underscore() => "some_title"

// Dasherize/Hyphenate: Replace underscores with dashes
"some_title".Dasherize() => "some-title"
"some_title".Hyphenate() => "some-title"

// Kebaberize: kebab-case (lowercase with hyphens)
"SomeText".Kebaberize() => "some-text"
"some property name".Kebaberize() => "some-property-name"

2.Milliseconds() => TimeSpan.FromMilliseconds(2)
5.Seconds() => TimeSpan.FromSeconds(5)
3.Minutes() => TimeSpan.FromMinutes(3)
4.Hours() => TimeSpan.FromHours(4)
7.Days() => TimeSpan.FromDays(7)
2.Weeks() => TimeSpan.FromDays(14)

// Instead of this:
DateTime.Now.AddDays(2).AddHours(3).AddMinutes(-5)

// Write this:
DateTime.Now + 2.Days() + 3.Hours() - 5.Minutes()

In.TheYear(2010) => new DateTime(2010, 1, 1)
In.January => January 1st of current year
In.FebruaryOf(2009) => February 1st, 2009

On.January.The4th => January 4th of current year
On.February.The(12) => February 12th of current year

var date = new DateTime(2011, 2, 10, 5, 25, 45, 125);

date.In(2008) => Changes year to 2008
date.At(2, 20, 15) => Changes time to 2:20:15.125
date.AtNoon() => Changes time to 12:00:00
date.AtMidnight() => Changes time to 00:00:00

3.Thousands() => 3000
5.Millions() => 5000000
1.25.Billions() => 1250000000

// Chain for complex values
3.Hundreds().Thousands() => 300000

1.ToWords() => "one"
10.ToWords() => "ten"
122.ToWords() => "one hundred and twenty-two"
3501.ToWords() => "three thousand five hundred and one"

// Grammatical gender support (culture-specific)
1.ToWords(GrammaticalGender.Masculine, new CultureInfo("ru")) => "один"
1.ToWords(GrammaticalGender.Feminine, new CultureInfo("ru")) => "одна"

// Control "and" usage
3501.ToWords(addAnd: false) => "three thousand five hundred one"

0.ToOrdinalWords() => "zeroth"
1.ToOrdinalWords() => "first"
2.ToOrdinalWords() => "second"
10.ToOrdinalWords() => "tenth"
21.ToOrdinalWords() => "twenty first"
121.ToOrdinalWords() => "hundred and twenty first"

// Grammatical gender support (culture-specific)
1.ToOrdinalWords(GrammaticalGender.Masculine, new CultureInfo("pt-BR")) => "primeiro"
1.ToOrdinalWords(GrammaticalGender.Feminine, new CultureInfo("pt-BR")) => "primeira"

"twenty".ToNumber(new CultureInfo("en")) => 20
"one hundred and five".ToNumber(new CultureInfo("en")) => 105
"three thousand two hundred".ToNumber(new CultureInfo("en")) => 3200

// Try pattern for safe conversion
if ("forty-two".TryToNumber(out var number, new CultureInfo("en")))
    Console.WriteLine(number); // Outputs: 42

// Get unrecognized words on failure
if (!"tenn".TryToNumber(out var invalid, new CultureInfo("en"), out var badWord))
    Console.WriteLine($"Unrecognized word: {badWord}"); // Outputs: Unrecognized word: tenn

// English UK
new DateTime(2015, 1, 1).ToOrdinalWords() => "1st January 2015"
new DateTime(2015, 3, 22).ToOrdinalWords() => "22nd March 2015"

// English US
new DateTime(2015, 1, 1).ToOrdinalWords() => "January 1st, 2015"
new DateTime(2015, 2, 12).ToOrdinalWords() => "February 12th, 2015"

// Grammatical case support (culture-specific)
new DateTime(2015, 1, 1).ToOrdinalWords(GrammaticalCase.Genitive)

// English US
new TimeOnly(3, 0).ToClockNotation() => "three o'clock"
new TimeOnly(12, 0).ToClockNotation() => "noon"
new TimeOnly(14, 30).ToClockNotation() => "half past two"

// Brazilian Portuguese
new TimeOnly(3, 0).ToClockNotation() => "três em ponto"
new TimeOnly(14, 30).ToClockNotation() => "duas e meia"

// Round to nearest 5 minutes
new TimeOnly(15, 7).ToClockNotation(ClockNotationRounding.NearestFiveMinutes) 
    => "five past three"

// To Roman (supports 1-3999)
1.ToRoman() => "I"
4.ToRoman() => "IV"
10.ToRoman() => "X"
1990.ToRoman() => "MCMXC"

// From Roman
"XIV".FromRoman() => 14
"MCMXC".FromRoman() => 1990

// To Metric
1d.ToMetric() => "1"
1230d.ToMetric() => "1.23k"
0.1d.ToMetric() => "100m"
456789.ToMetric(decimals: 2) => "456.79k"

// From Metric
"1.23k".FromMetric() => 1230
"100m".FromMetric() => 0.1

var fileSize = (10).Kilobytes();

fileSize.Bits      => 81920
fileSize.Bytes     => 10240
fileSize.Kilobytes => 10
fileSize.Megabytes => 0.009765625
fileSize.Gigabytes => 9.53674316e-6
fileSize.Terabytes => 9.31322575e-9

3.Bits();
5.Bytes();
(10.5).Kilobytes();
(2.5).Megabytes();
(10.2).Gigabytes();
(4.7).Terabytes();

var total = (10).Gigabytes() + (512).Megabytes() - (2.5).Gigabytes();
total.Subtract((2500).Kilobytes()).Add((25).Megabytes());

var maxFileSize = (10).Kilobytes();

maxFileSize.LargestWholeNumberSymbol;  // "KB"
maxFileSize.LargestWholeNumberValue;   // 10

7.Bits().ToString();           // 7 b
8.Bits().ToString();           // 1 B
(.5).Kilobytes().Humanize();   // 512 B
(1000).Kilobytes().ToString(); // 1000 KB
(1024).Kilobytes().Humanize(); // 1 MB
(.5).Gigabytes().Humanize();   // 512 MB
(1024).Gigabytes().ToString(); // 1 TB

var b = (10.505).Kilobytes();

// Default number format is #.##
b.ToString("KB");         // 10.52 KB
b.Humanize("MB");         // .01 MB
b.Humanize("b");          // 86057 b

// Default symbol is the largest metric prefix value >= 1
b.ToString("#.#");        // 10.5 KB

// All valid values of double.ToString(string format) are acceptable
b.ToString("0.0000");     // 10.5050 KB
b.Humanize("000.00");     // 010.51 KB

// You can include number format and symbols
b.ToString("#.#### MB");  // .0103 MB
b.Humanize("0.00 GB");    // 0 GB
b.Humanize("#.## B");     // 10757.12 B

7.Bits().ToFullWords();           // 7 bits
8.Bits().ToFullWords();           // 1 byte
(.5).Kilobytes().ToFullWords();   // 512 bytes
(1000).Kilobytes().ToFullWords(); // 1000 kilobytes
(1024).Kilobytes().ToFullWords(); // 1 megabyte
(.5).Gigabytes().ToFullWords();   // 512 megabytes
(1024).Gigabytes().ToFullWords(); // 1 terabyte

ByteSize output;
ByteSize.TryParse("1.5mb", out output);

// Invalid
ByteSize.Parse("1.5 b");   // Can't have partial bits

// Valid
ByteSize.Parse("5b");
ByteSize.Parse("1.55B");
ByteSize.Parse("1.55KB");
ByteSize.Parse("1.55 kB "); // Spaces are trimmed
ByteSize.Parse("1.55 kb");
ByteSize.Parse("1.55 MB");
ByteSize.Parse("1.55 mB");
ByteSize.Parse("1.55 mb");
ByteSize.Parse("1.55 GB");
ByteSize.Parse("1.55 gB");
ByteSize.Parse("1.55 gb");
ByteSize.Parse("1.55 TB");
ByteSize.Parse("1.55 tB");
ByteSize.Parse("1.55 tb");

var size = ByteSize.FromMegabytes(10);
var measurementInterval = TimeSpan.FromSeconds(1);

var text = size.Per(measurementInterval).Humanize();
// 10 MB/s

text = size.Per(measurementInterval).Humanize(TimeUnit.Minute);
// 600 MB/min

text = size.Per(measurementInterval).Humanize(TimeUnit.Hour);
// 35.15625 GB/hour

19854651984.Bytes().Per(1.Seconds()).Humanize("#.##");
// 18.49 GB/s

360.ToHeading();
// N
720.ToHeading();
// N

180.ToHeading(HeadingStyle.Full);
// south
360.ToHeading(HeadingStyle.Full);
// north

90.ToHeadingArrow();
// →
225.ToHeadingArrow();
// ↙

"S".FromShortHeading();
// 180
"SW".FromShortHeading();
// 225

1.Tupleize();
// single
3.Tupleize();
// triple
100.Tupleize();
// centuple

TimeUnit.Day.ToSymbol();
// d
TimeUnit.Week.ToSymbol();
// week
TimeUnit.Year.ToSymbol();
// y

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using Humanizer;

public class HumanizerMetadataProvider : DataAnnotationsModelMetadataProvider
{
    protected override ModelMetadata CreateMetadata(
        IEnumerable<Attribute> attributes,
        Type containerType,
        Func<object> modelAccessor,
        Type modelType,
        string propertyName)
    {
        var propertyAttributes = attributes.ToList();
        var modelMetadata = base.CreateMetadata(propertyAttributes, containerType, modelAccessor, modelType, propertyName);

        if (IsTransformRequired(modelMetadata, propertyAttributes))
            modelMetadata.DisplayName = modelMetadata.PropertyName.Humanize();

        return modelMetadata;
    }

    private static bool IsTransformRequired(ModelMetadata modelMetadata, IList<Attribute> propertyAttributes)
    {
        if (string.IsNullOrEmpty(modelMetadata.PropertyName))
            return false;

        if (propertyAttributes.OfType<DisplayNameAttribute>().Any())
            return false;

        if (propertyAttributes.OfType<DisplayAttribute>().Any())
            return false;

        return true;
    }
}

ModelMetadataProviders.Current = new HumanizerMetadataProvider();

public class RegisterModel
{
    [Display(Name = "User name")]
    public string UserName { get; set; }

    [Display(Name = "Email address")]
    public string EmailAddress { get; set; }

    [Display(Name = "Confirm password")]
    public string ConfirmPassword { get; set; }
}

public class RegisterModel
{
    public string UserName { get; set; }
    public string EmailAddress { get; set; }
    public string ConfirmPassword { get; set; }
}

modelMetadata.DisplayName = modelMetadata.PropertyName.Humanize().Transform(To.TitleCase);

humanizer

Molt Pulse

<img width="30px" src="logo.png" /> Humanizer

Install

Supported frameworks

Specify Languages (Optional)

Features

Humanize String

Version 3.0 Behavioral Change

Dehumanize String

Transform String

Truncate String

Humanize Enums

Dehumanize Enums

Humanize DateTime

Humanize TimeSpan

Humanize Collections

Inflector methods

Pluralize

Singularize

Adding Words

ToQuantity

Ordinalize

Titleize, Pascalize, Camelize

Underscore, Dasherize, Kebaberize

Fluent Date

Number to numbers

Number to words

Number to ordinal words

Words to Number Conversion

DateTime to ordinal words

TimeOnly to Clock Notation

Roman numerals

Metric numerals

ByteSize

Heading to words

Tupleize

Time unit to symbol

Mix this into your framework to simplify your life

Use in ASP.NET 4.x MVC Views

Continuous Integration from Azure DevOps

Related projects

Humanizer ReSharper Annotations

PowerShell Humanizer

Humanizer JVM

Humanizer.node

Contributing

License

Reporting Issues

Icon

Ecosystem Role