add spelling conventions and name fixes in a whole project

Author: AndreiKingsley

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt

@@ -168,12 +168,12 @@ public fun <C> ColumnMatch(left: ColumnReference<C>, right: ColumnReference<C>):
 public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnsResolver<*>
 
 public enum class JoinType {
-    Left, // all data from left data frame, nulls for mismatches in right data frame
-    Right, // all data from right data frame, nulls for mismatches in left data frame
-    Inner, // only matched data from right and left data frame
-    Filter, // only matched data from left data frame
-    Full, // all data from left and from right data frame, nulls for any mismatches
-    Exclude, // mismatched rows from left data frame
+    Left, // all data from left dataframe, nulls for mismatches in right dataframe
+    Right, // all data from right dataframe, nulls for mismatches in left dataframe
+    Inner, // only matched data from right and left dataframe
+    Filter, // only matched data from left dataframe
+    Full, // all data from left and from right dataframe, nulls for any mismatches
+    Exclude, // mismatched rows from left dataframe
 }
 
 internal val JoinType.addNewColumns: Boolean

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt

@@ -5,9 +5,9 @@ import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.AnyApiLinks
 /**
  * ## Access APIs
  *
- * By nature, data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * By nature, dataframes are dynamic objects, column labels depend on the input source and also new columns could be added
  * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
- * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+ * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a dataframe is tricky.
  *
  * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they're essentially different, they
  * look pretty similar in the data wrangling DSL. These include:

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt

@@ -8,14 +8,14 @@ import org.jetbrains.kotlinx.dataframe.DataFrameExpression as DfDataFrameExpress
 
 /**
  * ## Expressions Given DataFrame
- * Expressing values using a "Data Frame Expression" can occur exclusively in a
+ * Expressing values using a "DataFrame Expression" can occur exclusively in a
  * {@include [DataFrameExpressionLink]}.
  */
 internal interface ExpressionsGivenDataFrame {
 
     interface OPERATION
 
-    /** Provide a new value for every selected data frame using a [dataframe expression][DfDataFrameExpression]. */
+    /** Provide a new value for every selected dataframe using a [dataframe expression][DfDataFrameExpression]. */
     interface DataFrameExpression {
 
         /**
@@ -28,6 +28,6 @@ internal interface ExpressionsGivenDataFrame {
         interface WithExample
     }
 
-    /** [Data Frame Expression][DataFrameExpression] */
+    /** [DataFrame Expression][DataFrameExpression] */
     interface DataFrameExpressionLink
 }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt

@@ -105,34 +105,34 @@ internal fun <A, B> DataFrame<A>.joinImpl(
             leftCol.path to allRightJoinColumns[colNumber].path
         }.toMap()
 
-    // compute pairs of join key to row index from right data frame
+    // compute pairs of join key to row index from right dataframe
     val rightJoinKeyToIndex = other
         .indices()
         .map { index -> allRightJoinColumns.map { it.data[index] } to index }
 
-    // group row indices by key from right data frame
+    // group row indices by key from right dataframe
     val groupedRight = when (joinType) {
         JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList() }
         else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }
     }
 
     var outputRowsCount = 0
 
-    // for every row index from left data frame compute a list of matched indices from right data frame
+    // for every row index from left dataframe compute a list of matched indices from right dataframe
     val leftToRightMapping = indices.map { leftIndex ->
         val leftKey = allLeftJoinColumns.map { it.data[leftIndex] }
         val rightIndices = groupedRight[leftKey]
         outputRowsCount += rightIndices?.size ?: if (joinType.allowRightNulls) 1 else 0
         rightIndices
     }
 
-    // for every row index in right data frame store a flag indicating whether this row was matched by some row in left data frame
+    // for every row index in right dataframe store a flag indicating whether this row was matched by some row in left dataframe
     val rightMatched = BooleanArray(other.nrow) { false }
 
-    // number of rows in right data frame that were not matched by any row in left data frame. Used for correct allocation of an output array
+    // number of rows in right dataframe that were not matched by any row in left dataframe. Used for correct allocation of an output array
     var rightUnmatchedCount = other.nrow
 
-    // compute matched indices from right data frame and number of rows in output data frame
+    // compute matched indices from right dataframe and number of rows in output dataframe
     if (joinType.allowLeftNulls) {
         leftToRightMapping.forEach { rightIndices ->
             rightIndices?.forEach { i ->

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt

@@ -59,12 +59,12 @@ internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
                 ?.takeIf { it.findAnnotation<DataSchema>() != null }
                 ?.let { registeredMarkers[it] ?: MarkersExtractor.get(it) }
             if (currentMarker != null) {
-                // we need to make sure that the property's marker type is open in order to let derived data frames be assignable to it
+                // we need to make sure that the property's marker type is open in order to let derived dataframes be assignable to it
                 if (currentMarker.isOpen) {
                     val columnSchema = currentMarker.schema
-                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual data frame type
+                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual dataframe type
                     if (wasProcessedBefore || columnSchema == targetSchema) {
-                        // property scheme is valid for current data frame, but we should also check that all compatible open markers are implemented by it
+                        // property scheme is valid for current dataframe, but we should also check that all compatible open markers are implemented by it
                         val requiredBaseMarkers = registeredMarkers.values.filterRequiredForSchema(columnSchema)
                         if (requiredBaseMarkers.any() && requiredBaseMarkers.all { currentMarker.implements(it) }) {
                             return CodeWithTypeCastGenerator.EMPTY

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
 import java.net.URL
 
 /**
- * Reader that can read a data frame from a URL. It tries to guess the format based on the given [formats] and returns
+ * Reader that can read a dataframe from a URL. It tries to guess the format based on the given [formats] and returns
  * [DfReadResult.Success], or returns [DfReadResult.Error] if it fails.
  */
 public val CodeGenerator.Companion.urlDfReader: (url: URL, formats: List<SupportedFormat>) -> DfReadResult

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt

@@ -32,7 +32,7 @@ internal fun AnyFrame.renderToString(
 
     // title
     if (title) {
-        sb.appendLine("Data Frame [${size()}]")
+        sb.appendLine("DataFrame [${size()}]")
         sb.appendLine()
     }
 

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt

@@ -153,7 +153,7 @@ class CodeGenerationTests : BaseTest() {
     }
 
     @Test
-    fun `generate marker interface for nested data frame`() {
+    fun `generate marker interface for nested dataframe`() {
         val property = ::df
         val grouped = df.move { name and city }.under("nameAndCity")
         val generated = ReplCodeGenerator.create().process(grouped, property)

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt

@@ -77,7 +77,7 @@ internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
     }
 
     @Test
-    fun `data frame`() {
+    fun `dataframe`() {
         fields.keys.asClue {
             fields["f"]!!.renderAccessorFieldType() shouldBe
                 "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
@@ -125,7 +125,7 @@ internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
     }
 
     @Test
-    fun `data frame column`() {
+    fun `dataframe column`() {
         fields.keys.asClue {
             fields["f"]!!.renderColumnType() shouldBe
                 "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>>"

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt

@@ -1977,7 +1977,7 @@ class DataFrameTests : BaseTest() {
     }
 
     @Test
-    fun `render nested data frames to string`() {
+    fun `render nested dataframes to string`() {
         val rendered = typed
             .drop(1)
             .groupBy { name }