Fix issue 13632: Enhancement to std.string.strip

Added second argument similar to Python `str.strip`

Second argument accepts list of chars to strip and strips only
those chars.

Examples:

    "xyzhello".stripLeft("xyz") == ""hello"
    "helloxy ".stripRight("xy ") == "hello"
    "xhellox".strip("x") == "hello"

Signed-off-by: Aravinda VK <mail@aravindavk.in>

Author: aravindavk

std/string.d

@@ -2855,6 +2855,36 @@ if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) &&
     return input;
 }
 
+/++
+    Strips leading characters as specified in second argument.
+
+    Params:
+        input = string or $(REF_ALTTEXT forward range, isForwardRange, std,range,primitives)
+        of characters
+        chars = list of chars to strip
+
+    Returns: $(D input) stripped of extra characters.
+
+    Postconditions: $(D input) and the returned value
+    will share the same tail (see $(REF sameTail, std,array)).
+
+    See_Also:
+        Generic stripping on ranges: $(REF _stripLeft, std, algorithm, mutation)
+  +/
+auto stripLeft(Range)(Range input, string chars)
+if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) &&
+    !isInfinite!Range && !isConvertibleToString!Range)
+{
+    while (!input.empty)
+    {
+        auto c = input.front;
+        if (indexOf(chars, c) == -1)
+            break;
+        input.popFront();
+    }
+    return input;
+}
+
 ///
 @safe pure unittest
 {
@@ -2870,10 +2900,24 @@ if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) &&
     assert(stripLeft([paraSep] ~ "hello world" ~ paraSep) ==
            "hello world" ~ [paraSep]);
 
+    assert(stripLeft("     hello world     ", " ") ==
+           "hello world     ");
+    assert(stripLeft("xxxxxhello world     ", "x") ==
+           "hello world     ");
+    assert(stripLeft("xxxyy    hello world     ", "xy ") ==
+           "hello world     ");
+
     import std.array : array;
-    import std.utf : byChar;
+    import std.utf : byChar, byWchar, byDchar;
     assert(stripLeft("     hello world     "w.byChar).array ==
            "hello world     ");
+
+    assert(stripLeft("  xxxyy hello world     "w.byChar, "xy ").array ==
+           "hello world     ");
+
+    assert(stripLeft("\u2028\u2020hello world\u2028"w.byWchar, "\u2028").array == "\u2020hello world\u2028");
+    assert(stripLeft("\U00010001hello world"w.byWchar, " ").array == "\U00010001hello world"w);
+    assert(stripLeft("\U00010001 xyhello world"d.byDchar, "\U00010001 xy").array == "hello world"d);
 }
 
 auto stripLeft(Range)(auto ref Range str)
@@ -2882,6 +2926,12 @@ if (isConvertibleToString!Range)
     return stripLeft!(StringTypeOf!Range)(str);
 }
 
+auto stripLeft(Range)(auto ref Range str, string chars)
+if (isConvertibleToString!Range)
+{
+    return stripLeft!(StringTypeOf!Range)(str, chars);
+}
+
 @safe pure unittest
 {
     assert(testAliasedString!stripLeft("  hello"));
@@ -2995,6 +3045,53 @@ if (isSomeString!Range ||
     }
 }
 
+/++
+    Strips trailing characters as specified in second argument.
+
+    Params:
+        str = string or random access range of characters
+        chars = list of chars to strip
+
+    Returns:
+        slice of $(D str) stripped of trailing extra characters.
+
+    See_Also:
+        Generic stripping on ranges: $(REF _stripRight, std, algorithm, mutation)
+  +/
+auto stripRight(Range)(Range str, string chars)
+if (isSomeString!Range ||
+    isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range &&
+    !isConvertibleToString!Range &&
+    isSomeChar!(ElementEncodingType!Range))
+{
+    alias C = Unqual!(ElementEncodingType!(typeof(str)));
+
+    static if (isSomeString!(typeof(str)))
+    {
+        import std.utf : codeLength;
+
+        foreach_reverse (i, dchar c; str)
+        {
+            if (indexOf(chars, c) == -1)
+                return str[0 .. i + codeLength!C(c)];
+        }
+
+        return str[0 .. 0];
+    }
+    else
+    {
+        size_t i = str.length;
+        while (i--)
+        {
+            if (indexOf(chars, str[i]) != -1)
+                continue;
+            break;
+        }
+
+        return str[0 .. i + 1];
+    }
+}
+
 ///
 @safe pure
 unittest
@@ -3010,6 +3107,13 @@ unittest
            [lineSep] ~ "hello world");
     assert(stripRight([paraSep] ~ "hello world" ~ paraSep) ==
            [paraSep] ~ "hello world");
+
+    assert(stripRight("     hello world     ", "x") ==
+           "     hello world     ");
+    assert(stripRight("     hello world     ", " ") ==
+           "     hello world");
+    assert(stripRight("     hello worldxy     ", "xy ") ==
+           "     hello world");
 }
 
 auto stripRight(Range)(auto ref Range str)
@@ -3018,6 +3122,12 @@ if (isConvertibleToString!Range)
     return stripRight!(StringTypeOf!Range)(str);
 }
 
+auto stripRight(Range)(auto ref Range str, string chars)
+if (isConvertibleToString!Range)
+{
+    return stripRight!(StringTypeOf!Range)(str, chars);
+}
+
 @safe pure unittest
 {
     assert(testAliasedString!stripRight("hello   "));
@@ -3045,6 +3155,11 @@ if (isConvertibleToString!Range)
     cast(void) stripRight("a\x80".byUTF!char).array;
     wstring ws = ['a', cast(wchar) 0xDC00];
     cast(void) stripRight(ws.byUTF!wchar).array;
+
+    assert(stripRight("     hello world  xyz   ".byChar, "xyz ").array == "     hello world");
+    assert(stripRight("\u2028hello world\u2020\u2028"w.byWchar, "\u2028").array == "\u2028hello world\u2020");
+    assert(stripRight("hello world\U00010001"w.byWchar, " ").array == "hello world\U00010001"w);
+    assert(stripRight("hello world\U00010001 xy"d.byDchar, "\U00010001 xy").array == "hello world"d);
 }
 
 
@@ -3070,6 +3185,29 @@ if (isSomeString!Range ||
     return stripRight(stripLeft(str));
 }
 
+/++
+    Strips both leading and trailing extra characters as specified in the
+    second argument.
+
+    Params:
+        str = string or random access range of characters
+        chars = list of chars to strip
+
+    Returns:
+        slice of $(D str) stripped of leading and trailing extra characters.
+
+    See_Also:
+        Generic stripping on ranges: $(REF _strip, std, algorithm, mutation)
+  +/
+auto strip(Range)(Range str, string chars)
+if (isSomeString!Range ||
+    isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range &&
+    !isConvertibleToString!Range &&
+    isSomeChar!(ElementEncodingType!Range))
+{
+    return stripRight(stripLeft(str, chars), chars);
+}
+
 ///
 @safe pure unittest
 {
@@ -3084,6 +3222,12 @@ if (isSomeString!Range ||
            "hello world");
     assert(strip([paraSep] ~ "hello world" ~ [paraSep]) ==
            "hello world");
+    assert(strip("     hello world     ", "x") ==
+           "     hello world     ");
+    assert(strip("     hello world     ", " ") ==
+           "hello world");
+    assert(strip("   xyxyhello worldxyxy     ", "xy ") ==
+           "hello world");
 }
 
 auto strip(Range)(auto ref Range str)
@@ -3092,6 +3236,12 @@ if (isConvertibleToString!Range)
     return strip!(StringTypeOf!Range)(str);
 }
 
+auto strip(Range)(auto ref Range str, string chars)
+if (isConvertibleToString!Range)
+{
+    return strip!(StringTypeOf!Range)(str, chars);
+}
+
 @safe pure unittest
 {
     assert(testAliasedString!strip("     hello world     "));