From a34e15e1572bee0efa2187d9b70a7b498488f7fb Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Tue, 24 Mar 2015 15:44:21 +0300 Subject: [PATCH] Rename methods: trimLeft/Right -> trimStart/End, padLeft/Right -> padStart/End --- libraries/stdlib/src/kotlin/text/Strings.kt | 34 ++++--- libraries/stdlib/test/text/StringTest.kt | 106 ++++++++++---------- 2 files changed, 75 insertions(+), 65 deletions(-) diff --git a/libraries/stdlib/src/kotlin/text/Strings.kt b/libraries/stdlib/src/kotlin/text/Strings.kt index 329353ae609..5afe40048b9 100644 --- a/libraries/stdlib/src/kotlin/text/Strings.kt +++ b/libraries/stdlib/src/kotlin/text/Strings.kt @@ -40,7 +40,7 @@ inline public fun String.trim(predicate: (Char) -> Boolean): String { /** * Returns the string with leading characters matching the [predicate] trimmed. */ -inline public fun String.trimLeading(predicate: (Char) -> Boolean): String { +inline public fun String.trimStart(predicate: (Char) -> Boolean): String { for (index in this.indices) if (!predicate(this[index])) return substring(index) @@ -51,7 +51,7 @@ inline public fun String.trimLeading(predicate: (Char) -> Boolean): String { /** * Returns the string with trailing characters matching the [predicate] trimmed. */ -inline public fun String.trimTrailing(predicate: (Char) -> Boolean): String { +inline public fun String.trimEnd(predicate: (Char) -> Boolean): String { for (index in this.indices.reversed()) if (!predicate(this[index])) return substring(0, index + 1) @@ -67,12 +67,12 @@ public fun String.trim(vararg chars: Char): String = trim { it in chars } /** * Returns the string with leading and trailing characters in the [chars] array trimmed. */ -public fun String.trimLeading(vararg chars: Char): String = trimLeading { it in chars } +public fun String.trimStart(vararg chars: Char): String = trimStart { it in chars } /** * Returns the string with trailing characters in the [chars] array trimmed. */ -public fun String.trimTrailing(vararg chars: Char): String = trimTrailing { it in chars } +public fun String.trimEnd(vararg chars: Char): String = trimEnd { it in chars } deprecated("Use removePrefix() instead") public fun String.trimLeading(prefix: String): String = removePrefix(prefix) @@ -88,20 +88,28 @@ public fun String.trim(): String = trim { it.isWhitespace() } /** * Returns a string with leading whitespace removed. */ -public fun String.trimLeading(): String = trimLeading { it.isWhitespace() } +public fun String.trimStart(): String = trimStart { it.isWhitespace() } + +deprecated("Use trimStart instead.") +public fun String.trimLeading(): String = trimStart { it.isWhitespace() } /** * Returns a string with trailing whitespace removed. */ -public fun String.trimTrailing(): String = trimTrailing { it.isWhitespace() } +public fun String.trimEnd(): String = trimEnd { it.isWhitespace() } + +deprecated("Use trimEnd instead.") +public fun String.trimTrailing(): String = trimEnd { it.isWhitespace() } /** * Left pad a String with a specified character or space. * * @param length the desired string length. * @param padChar the character to pad string with, if it has length less than the [length] specified. Space is used by default. + * @returns Returns a string, of length at least [length], consisting of string prepended with [padChar] as many times. + * as are necessary to reach that length. */ -public fun String.padLeft(length: Int, padChar: Char = ' '): String { +public fun String.padStart(length: Int, padChar: Char = ' '): String { if (length < 0) throw IllegalArgumentException("String length $length is less than zero.") if (length <= this.length()) @@ -119,8 +127,10 @@ public fun String.padLeft(length: Int, padChar: Char = ' '): String { * * @param length the desired string length. * @param padChar the character to pad string with, if it has length less than the [length] specified. Space is used by default. + * @returns Returns a string, of length at least [length], consisting of string prepended with [padChar] as many times. + * as are necessary to reach that length. */ -public fun String.padRight(length: Int, padChar: Char = ' '): String { +public fun String.padEnd(length: Int, padChar: Char = ' '): String { if (length < 0) throw IllegalArgumentException("String length $length is less than zero.") if (length <= this.length()) @@ -367,7 +377,7 @@ public fun String.removeSuffix(suffix: String): String { * it starts with the [prefix] and ends with the [suffix]. * Otherwise returns this string unchanged. */ -public fun String.removeEnclosing(prefix: String, suffix: String): String { +public fun String.removeSurrounding(prefix: String, suffix: String): String { if (startsWith(prefix) && endsWith(suffix)) { return substring(prefix.length(), length() - suffix.length()) } @@ -375,11 +385,11 @@ public fun String.removeEnclosing(prefix: String, suffix: String): String { } /** - * Removes the given [enclosing] string both from the start and the end of this string - * if and only if it starts with and ends with the [enclosing]. + * Removes the given [delimiter] string from both the start and the end of this string + * if and only if it starts with and ends with the [delimiter]. * Otherwise returns this string unchanged. */ -public fun String.removeEnclosing(enclosing: String): String = removeEnclosing(enclosing, enclosing) +public fun String.removeSurrounding(delimiter: String): String = removeSurrounding(delimiter, delimiter) /** * Replace part of string before the first occurrence of given delimiter with the [replacement] string. diff --git a/libraries/stdlib/test/text/StringTest.kt b/libraries/stdlib/test/text/StringTest.kt index ac998ec101c..35e7ae787c5 100644 --- a/libraries/stdlib/test/text/StringTest.kt +++ b/libraries/stdlib/test/text/StringTest.kt @@ -153,45 +153,45 @@ class StringTest { assertTrue(sum == 14) } - test fun trimLeading() { - assertEquals("", "".trimLeading()) - assertEquals("a", "a".trimLeading()) - assertEquals("a", " a".trimLeading()) - assertEquals("a", " a".trimLeading()) - assertEquals("a ", " a ".trimLeading()) - assertEquals("a b", " a b".trimLeading()) - assertEquals("a b ", " a b ".trimLeading()) - assertEquals("a", " \u00A0 a".trimLeading()) + test fun trimStart() { + assertEquals("", "".trimStart()) + assertEquals("a", "a".trimStart()) + assertEquals("a", " a".trimStart()) + assertEquals("a", " a".trimStart()) + assertEquals("a ", " a ".trimStart()) + assertEquals("a b", " a b".trimStart()) + assertEquals("a b ", " a b ".trimStart()) + assertEquals("a", " \u00A0 a".trimStart()) - assertEquals("a", "\ta".trimLeading()) - assertEquals("a", "\t\ta".trimLeading()) - assertEquals("a", "\ra".trimLeading()) - assertEquals("a", "\na".trimLeading()) + assertEquals("a", "\ta".trimStart()) + assertEquals("a", "\t\ta".trimStart()) + assertEquals("a", "\ra".trimStart()) + assertEquals("a", "\na".trimStart()) - assertEquals("a=", "-=-=a=".trimLeading('-','=')) - assertEquals("123a", "ab123a".trimLeading { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS + assertEquals("a=", "-=-=a=".trimStart('-','=')) + assertEquals("123a", "ab123a".trimStart { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS } - test fun trimTrailing() { - assertEquals("", "".trimTrailing()) - assertEquals("a", "a".trimTrailing()) - assertEquals("a", "a ".trimTrailing()) - assertEquals("a", "a ".trimTrailing()) - assertEquals(" a", " a ".trimTrailing()) - assertEquals("a b", "a b ".trimTrailing()) - assertEquals(" a b", " a b ".trimTrailing()) - assertEquals("a", "a \u00A0 ".trimTrailing()) + test fun trimEnd() { + assertEquals("", "".trimEnd()) + assertEquals("a", "a".trimEnd()) + assertEquals("a", "a ".trimEnd()) + assertEquals("a", "a ".trimEnd()) + assertEquals(" a", " a ".trimEnd()) + assertEquals("a b", "a b ".trimEnd()) + assertEquals(" a b", " a b ".trimEnd()) + assertEquals("a", "a \u00A0 ".trimEnd()) - assertEquals("a", "a\t".trimTrailing()) - assertEquals("a", "a\t\t".trimTrailing()) - assertEquals("a", "a\r".trimTrailing()) - assertEquals("a", "a\n".trimTrailing()) + assertEquals("a", "a\t".trimEnd()) + assertEquals("a", "a\t\t".trimEnd()) + assertEquals("a", "a\r".trimEnd()) + assertEquals("a", "a\n".trimEnd()) - assertEquals("=a", "=a=-=-".trimTrailing('-','=')) - assertEquals("ab123", "ab123a".trimTrailing { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS + assertEquals("=a", "=a=-=-".trimEnd('-','=')) + assertEquals("ab123", "ab123a".trimEnd { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS } - test fun trimTrailingAndLeading() { + test fun trimStartAndEnd() { val examples = array( "a", " a ", @@ -205,8 +205,8 @@ class StringTest { ) for (example in examples) { - assertEquals(example.trim(), example.trimTrailing().trimLeading()) - assertEquals(example.trim(), example.trimLeading().trimTrailing()) + assertEquals(example.trim(), example.trimEnd().trimStart()) + assertEquals(example.trim(), example.trimStart().trimEnd()) } val examplesForPredicate = array( @@ -217,28 +217,28 @@ class StringTest { val trimChars = charArray('-','=') val trimPredicate = { (it: Char) -> it < '0' || it > '9' } // TODO: Use !it.isDigit when available in JS for (example in examplesForPredicate) { - assertEquals(example.trimLeading(*trimChars).trimTrailing(*trimChars), example.trim(*trimChars)) - assertEquals(example.trimLeading(trimPredicate).trimTrailing(trimPredicate), example.trim(trimPredicate)) + assertEquals(example.trimStart(*trimChars).trimEnd(*trimChars), example.trim(*trimChars)) + assertEquals(example.trimStart(trimPredicate).trimEnd(trimPredicate), example.trim(trimPredicate)) } } - test fun padLeft() { - assertEquals("s", "s".padLeft(0)) - assertEquals("s", "s".padLeft(1)) - assertEquals(" ", "".padLeft(2)) - assertEquals("--s", "s".padLeft(3, '-')) + test fun padStart() { + assertEquals("s", "s".padStart(0)) + assertEquals("s", "s".padStart(1)) + assertEquals(" ", "".padStart(2)) + assertEquals("--s", "s".padStart(3, '-')) fails { - "s".padLeft(-1) + "s".padStart(-1) } } - test fun padRight() { - assertEquals("s", "s".padRight(0)) - assertEquals("s", "s".padRight(1)) - assertEquals(" ", "".padRight(2)) - assertEquals("s--", "s".padRight(3, '-')) + test fun padEnd() { + assertEquals("s", "s".padEnd(0)) + assertEquals("s", "s".padEnd(1)) + assertEquals(" ", "".padEnd(2)) + assertEquals("s--", "s".padEnd(3, '-')) fails { - "s".padRight(-1) + "s".padEnd(-1) } } @@ -256,12 +256,12 @@ class StringTest { assertEquals("sample", "sample".removeSuffix("")) } - test fun removeEnclosing() { - assertEquals("value", "".removeEnclosing("<", ">")) - assertEquals("", "<>".removeEnclosing("<", ">"), "Removes enclosing once") - assertEquals(""), "Only removes enclosing when both prefix and suffix present") - assertEquals("value>", "value>".removeEnclosing("<", ">"), "Only removes enclosing when both prefix and suffix present") - assertEquals("value", "value".removeEnclosing("<", ">")) + test fun removeSurrounding() { + assertEquals("value", "".removeSurrounding("<", ">")) + assertEquals("", "<>".removeSurrounding("<", ">"), "Removes surrounding once") + assertEquals(""), "Only removes surrounding when both prefix and suffix present") + assertEquals("value>", "value>".removeSurrounding("<", ">"), "Only removes surrounding when both prefix and suffix present") + assertEquals("value", "value".removeSurrounding("<", ">")) } }