Upgraded Kotlin version to 1.5.21 and Gradle version to 7.1.1 (#416)

Author: VDovidaytis-HORIS

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/dateFormat/Format.kt

@@ -83,7 +83,7 @@ class Format(private val spec: List<SpecPart>) {
                 Pattern.HOUR_12_LEADING_ZERO -> leadZero(getHours12(dateTime))
                 Pattern.HOUR_24 -> leadZero(getHours24(dateTime))
                 Pattern.MERIDIAN_LOWER -> getMeridian(dateTime)
-                Pattern.MERIDIAN_UPPER -> getMeridian(dateTime).toUpperCase()
+                Pattern.MERIDIAN_UPPER -> getMeridian(dateTime).uppercase()
                 Pattern.DAY_OF_WEEK -> getWeekDayNumber(dateTime)
                 Pattern.DAY_OF_WEEK_ABBR -> DateLocale.weekDayAbbr[dateTime.weekDay] ?: ""
                 Pattern.DAY_OF_WEEK_FULL -> DateLocale.weekDayFull[dateTime.weekDay] ?: ""

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/enums/EnumInfoImpl.kt

@@ -14,7 +14,7 @@ class EnumInfoImpl<EnumT : Enum<EnumT>>(enumConstants: Array<EnumT>) : EnumInfo<
         get() = myOriginalNames
 
     private fun toNormalizedName(name: String): String {
-        return name.toUpperCase()
+        return name.uppercase()
     }
 
     init {

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/json/JsonSupport.kt

@@ -62,7 +62,7 @@ fun String.escape(): String {
             '\n' -> appendOutput("""\n""")
             '\r' -> appendOutput("""\r""")
             '\t' -> appendOutput("""\t""")
-            in CONTROL_CHARS -> appendOutput("""\u${ch.toInt().toString(16).padStart(4, '0')}""")
+            in CONTROL_CHARS -> appendOutput("""\u${ch.code.toString(16).padStart(4, '0')}""")
             else -> output?.append(ch)
         }
         i++

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/json/Utils.kt

@@ -36,7 +36,7 @@ fun <T : Enum<T>> parseEnum(enumStringValue: String, values: Array<T>): T =
     values.first { mode -> mode.toString().equals(enumStringValue, ignoreCase = true) }
 
 inline fun <reified T : Enum<T>> parseEnum(enumStringValue: String): T = parseEnum(enumStringValue, enumValues<T>())
-fun <T : Enum<T>> formatEnum(enumValue: T): String = enumValue.toString().toLowerCase()
+fun <T : Enum<T>> formatEnum(enumValue: T): String = enumValue.toString().lowercase()
 
 fun <T : Enum<T>> FluentObject.put(key: String, v: Collection<T>) = this.put(key, v.map { formatEnum(it) })
 fun FluentObject.put(key: String, v: List<String>) = put(key, FluentArray().addStrings(v.map { it }))

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/numberFormat/NumberFormat.kt

@@ -83,7 +83,7 @@ class NumberFormat(private val spec: Spec) {
                 val (intStr, fracStr, exponentString) =
                     "^(\\d+)\\.?(\\d+)?e?([+-]?\\d+)?\$"
                         .toRegex()
-                        .find(num.toDouble().absoluteValue.toString().toLowerCase())
+                        .find(num.toDouble().absoluteValue.toString().lowercase())
                         ?.destructured
                         ?: error("Wrong number: $num")
 
@@ -246,7 +246,7 @@ class NumberFormat(private val spec: Spec) {
             "g" -> toPrecisionFormat(numberInfo, spec.precision)
             "b" -> FormattedNumber(numberInfo.number.roundToLong().toString(2))
             "o" -> FormattedNumber(numberInfo.number.roundToLong().toString(8))
-            "X" -> FormattedNumber(numberInfo.number.roundToLong().toString(16).toUpperCase())
+            "X" -> FormattedNumber(numberInfo.number.roundToLong().toString(16).uppercase())
             "x" -> FormattedNumber(numberInfo.number.roundToLong().toString(16))
             "s" -> toSiFormat(numberInfo, spec.precision)
             else -> throw IllegalArgumentException("Wrong type: ${spec.type}")
@@ -417,7 +417,7 @@ class NumberFormat(private val spec: Spec) {
     private fun computePrefix(output: Output): Output {
         val prefix = when (spec.symbol) {
             "$" -> CURRENCY
-            "#" -> if ("boxX".indexOf(spec.type) > -1) "0${spec.type.toLowerCase()}" else ""
+            "#" -> if ("boxX".indexOf(spec.type) > -1) "0${spec.type.lowercase()}" else ""
             else -> ""
         }
         return output.copy(prefix = prefix)

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/spatial/GeoBoundingBoxCalculator.kt

@@ -5,7 +5,6 @@
 
 package jetbrains.datalore.base.spatial
 
-import jetbrains.datalore.base.gcommon.base.Preconditions
 import jetbrains.datalore.base.gcommon.collect.ClosedRange
 import jetbrains.datalore.base.spatial.LongitudeSegment.Companion.splitSegment
 import jetbrains.datalore.base.typedGeometry.*
@@ -14,8 +13,9 @@ import kotlin.math.min
 
 // Segment have direction, i.e. `start` can be less than `end` for the case
 // of the antimeridian intersection.
-// Thats why we can't use ClosedRange class with lower <= upper invariant
+// That's why we can't use ClosedRange class with lower <= upper invariant
 typealias Segment = Pair<Double, Double>
+
 val Segment.start get() = first
 val Segment.end get() = second
 
@@ -64,7 +64,10 @@ class GeoBoundingBoxCalculator<TypeT>(
     }
 
     companion object {
-        internal fun calculateLoopLimitRange(segments: Sequence<Segment>, mapRange: ClosedRange<Double>): ClosedRange<Double> {
+        internal fun calculateLoopLimitRange(
+            segments: Sequence<Segment>,
+            mapRange: ClosedRange<Double>
+        ): ClosedRange<Double> {
             return segments
                 .map {
                     splitSegment(
@@ -152,7 +155,7 @@ fun <T> GeoBoundingBoxCalculator<T>.geoRectsBBox(rectangles: List<GeoRectangle>)
 }
 
 fun <T> GeoBoundingBoxCalculator<T>.pointsBBox(xyCoords: List<Double>): Rect<T> {
-    Preconditions.checkArgument(xyCoords.size % 2 == 0, "Longitude-Latitude list is not even-numbered.")
+    require(xyCoords.size % 2 == 0) { "Longitude-Latitude list is not even-numbered." }
     val x: (Int) -> Double = { index -> xyCoords[2 * index] }
     val y: (Int) -> Double = { index -> xyCoords[2 * index + 1] }
 

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/stringFormat/StringFormat.kt

@@ -87,7 +87,7 @@ class StringFormat private constructor(
         //     "{{text}}" -> "{text}"
         //     "{.1f} -> 1.2
         //     "{{{.1f}}} -> {1.2}
-        private val BRACES_REGEX = Regex("""(?![^{]|\{\{)(\{([^{}]*)})(?=[^}]|}}|$)""")
+        private val BRACES_REGEX = Regex("""(?![^{]|\{\{)(\{([^{}]*)\})(?=[^}]|\}\}|$)""")
         const val TEXT_IN_BRACES = 2
 
         fun valueInLinePattern() = "{}"

base-portable/src/commonMain/kotlin/jetbrains/datalore/base/values/Colors.kt

@@ -65,11 +65,11 @@ object Colors {
     }
 
     fun isColorName(colorName: String): Boolean {
-        return namedColors.containsKey(colorName.toLowerCase())
+        return namedColors.containsKey(colorName.lowercase())
     }
 
     fun forName(colorName: String): Color {
-        return namedColors[colorName.toLowerCase()] ?: throw IllegalArgumentException()
+        return namedColors[colorName.lowercase()] ?: throw IllegalArgumentException()
     }
 
     fun generateHueColor(): Double {

base-portable/src/commonTest/kotlin/jetbrains/datalore/base/numberFormat/NumberFormatExtremesTest.kt

@@ -13,9 +13,9 @@ class NumberFormatExtremesTest {
     fun typeS() {
         val f = NumberFormat(".3s")
         assertEquals("0.00y", f.apply(Double.MIN_VALUE))
-        assertEquals("1000000000000000Y", f.apply(1E39))
+        assertEquals("100000000000000Y", f.apply(1E38))
         assertEquals("0.00y", f.apply(-Double.MIN_VALUE))
-        assertEquals("-1000000000000000Y", f.apply(-1E39))
+        assertEquals("-100000000000000Y", f.apply(-1E38))
 
         assertEquals("100Y", f.apply(NumberFormat.TYPE_S_MAX))
         assertEquals("-100Y", f.apply(-NumberFormat.TYPE_S_MAX))

base/src/jsMain/kotlin/jetbrains/datalore/base/encoding/Base64.kt

@@ -10,11 +10,11 @@ import kotlinx.browser.window
 actual object Base64 {
     actual fun decode(s: String): ByteArray {
         val bin = window.atob(s)
-        return ByteArray(bin.length) { i -> bin[i].toByte()}
+        return ByteArray(bin.length) { i -> bin[i].code.toByte() }
     }
 
     actual fun encode(data: ByteArray): String {
-        val binStr = data.fold(StringBuilder()) { str, byte -> str.append(byte.toChar()) }.toString()
+        val binStr = data.fold(StringBuilder()) { str, byte -> str.append(byte.toInt().toChar()) }.toString()
         return window.btoa(binStr)
     }
 }