Skip to content

A powerful set of utilities for any kind of string transformation with a fluent interface

License

Notifications You must be signed in to change notification settings

MSayfullin/FluentStrings

Repository files navigation

Fluent Strings

Powerful set of utilities for any kind of string transformations with fluent interface.

Download

Fluent Strings can be downloaded either through NuGet package or as a zip archive

Examples

Let the code speak for itself.

Insert operations

Something simple at the beginning:

string transformed = "<-- some string will be inserted here".Insert("I am inserted!");
transformed.Should().Be("I am inserted!<-- some string will be inserted here");

Let's change the position:

string transformed = "Some string will be inserted here -->".Insert("I am inserted!").To(The.End);
transformed.Should().Be("Some string will be inserted here -->I am inserted!");

And simply put something at the position we want:

string transformed = "Start of the sentence <-- some string will be inserted here".Insert("I am inserted!").At(22);
transformed.Should().Be("Start of the sentence I am inserted!<-- some string will be inserted here");

Mixing up with markers:

string transformed = "MARKER, another maRKer and... marker <-- some string will be inserted here"
                      .Insert("I am inserted!").After("marker ");
transformed.Should().Be("MARKER, another maRKer and... marker I am inserted!<-- some string will be inserted here");

Even ignoring case:

string transformed = "Marker1, another maRKer2 and... marker <-- some string will be inserted here"
                     .Insert("I am inserted").After("MARKER ").IgnoringCase();
transformed.Should().Be("Marker1, another maRKer2 and... marker I am inserted<-- some string will be inserted here");

And applying all the power:

string t = "Some string will be inserted before this second 'some' word, but not before this 'some'"
           .Insert("I am inserted! ").Before(2, "some").IgnoringCase().From(The.Beginning);
t.Should().Be("Some string will be inserted before this second 'I am inserted! some' word, but not before this 'some'");

Remove operations

Eliminating totally:

string transformed = "Some string".Remove();
transformed.Should().Be(String.Empty);

Or part...

string transformed = "THIS part of string will be removed".Remove("THIS");
transformed.Should().Be(" part of string will be removed");

...by part:

string transformed = "THIS <- this string will be left, but this will be removed -> THIS".Remove("THIS").From(The.End);
transformed.Should().Be("THIS <- this string will be left, but this will be removed -> ");

By counting markers:

string transformed = "String will be removed ->TEST and this will be removed also ->TEST, except this ->TEST"
                     .Remove(2, "TEST");
transformed.Should().Be("String will be removed -> and this will be removed also ->, except this ->TEST");

Or all of them at once:

string transformed = "TEST string will be removed from both sides TEST".RemoveAll("tESt").IgnoringCase();
transformed.Should().Be(" string will be removed from both sides ");

Starting some position:

string transformed = "Some very long string".Remove().Starting(position: 7).From(The.End);
transformed.Should().Be(" string");

Or to some marker:

string transformed = "Some very VERY long string with very VERY long string at the end".Remove()
                     .To(The.EndOf, 3, of: "vERy").IgnoringCase().From(The.End);
transformed.Should().Be(" long string with very VERY long string at the end");

And starting to some positions:

string transformed = "Some very long string".Remove().Starting(position: 9).To(position: 0);
transformed.Should().Be("Slong string");

Remove operations for chars

Creating cool effects:

string transformed = "Vowels will be removed from this string".RemoveVowels();
transformed.Should().Be("Vwls wll b rmvd frm ths strng");

For different culture as well:

string transformed = "Очень длинная строка с русскими буквами, ё".RemoveVowels().For("ru");
transformed.Should().Be("чнь длнн стрк с рсскм бквм, ");

Or by specifying chars explicitly:

string transformed = "Some very long string".RemoveChars('e', 'L', 'G').IgnoringCase();
transformed.Should().Be("Som vry on strin");

Replace operations

Just replacing all for now:

string transformed = "Some vERy long string".ReplaceAll("VerY").With("not very").IgnoringCase();
transformed.Should().Be("Some not very long string");

Truncate operations

Just playing around:

string transformed = "Some very long string".TruncateTo(9);
transformed.Should().Be("Some very");

transformed = "Some very long string".TruncateTo(11).From(The.End);
transformed.Should().Be("long string");

And doing ellipsis:

string transformed = "Some very long string".TruncateTo(12).WithEllipsis();
transformed.Should().Be("Some very...");

Utility operations

Better approach for well known:

bool isEmpty = "".IsEmpty();
isEmpty.Should().Be(true);

Even for null case:

string sample = null;
bool isEmpty = sample.IsEmpty();
isEmpty.Should().Be(true);

And continuing for white spaces:

bool isEmptyOrWhiteSpace = "  ".IsEmpty().OrWhiteSpace();
isEmptyOrWhiteSpace.Should().Be(true);

Extending the basics:

var indexes = "marker with another text marker and another text marker marker".IndexesOf("marker");
indexes.Should().ContainInOrder(0, 25, 49, 56);

Breaking restrictions:

var indexes = "Some text MARKER another text MarKer marker".IndexesOf("mArkEr").IgnoringCase();
indexes.Should().ContainInOrder(10, 30, 37);

And plainly reverse the order:

var indexes = "marker with another text marker and another text marker marker".IndexesOf("marker").From(The.End);
indexes.Should().ContainInOrder(56, 49, 25, 0);

More examples could be found in test classes

License

Ms-PL

Credits

Many thanks to Fluent Assertions for making my testing experience awesome.

About

A powerful set of utilities for any kind of string transformation with a fluent interface

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages