improved value constraints feature (now handling the excel 255 char limit)

Author: walien

src/main/kotlin/io/retable/RetableExcelSupport.kt

@@ -194,24 +194,85 @@ class RetableExcelSupport<T : RetableColumns>(
     private fun String.isUrl(): Boolean =
         take(7) == "http://" || take(8) == "https://"
 
+    /**
+     * Sets up Excel data validation (dropdown lists) for all [StringRetableColumn]s that define allowed values.
+     *
+     * Tries the standard inline approach first ([setupStdValueConstraints]). If it fails due to the
+     * Excel 255-character formula limit, falls back to a hidden sheet-based approach
+     * ([setupHiddenSheetBasedValueConstraints]).
+     */
     private fun XSSFSheet.setupValueConstraints(columns: T) {
-        columns.list()
+        val constrainedColumns = columns.list()
             .filterIsInstance<StringRetableColumn>()
             .filter { it.allowedValues.orEmpty().isNotEmpty() }
-            .forEach { column ->
-                val allowedValues = column.allowedValues.orEmpty()
-                val constraint = dataValidationHelper.createExplicitListConstraint(allowedValues.toTypedArray())
-                val cellRange = CellRangeAddressList(
-                    if (options.firstRecordAsHeader) 1 else 0,
-                    workbook.spreadsheetVersion.lastRowIndex,
-                    column.index - 1,
-                    column.index - 1
-                )
-                val validation = dataValidationHelper.createValidation(constraint, cellRange)
-                validation.showPromptBox = true
-                validation.suppressDropDownArrow = false
-                addValidationData(validation)
+
+        if (constrainedColumns.isNotEmpty()) {
+            try {
+                setupStdValueConstraints(constrainedColumns)
+            } catch (_: IllegalArgumentException) {
+                // excel formula 255-character limit potentially exceeded,
+                // fallback to hidden sheet-based value constraints
+                setupHiddenSheetBasedValueConstraints(constrainedColumns)
             }
+        }
+    }
+
+    private fun XSSFSheet.setupStdValueConstraints(constrainedColumns: List<StringRetableColumn>) {
+        constrainedColumns.forEach { column ->
+            val columnIndex = column.index - 1
+
+            val allowedValues = column.allowedValues.orEmpty()
+            val constraint = dataValidationHelper.createExplicitListConstraint(allowedValues.toTypedArray())
+            val cellRange = CellRangeAddressList(
+                if (options.firstRecordAsHeader) 1 else 0,
+                workbook.spreadsheetVersion.lastRowIndex,
+                columnIndex,
+                columnIndex
+            )
+            val validation = dataValidationHelper.createValidation(constraint, cellRange)
+            validation.showPromptBox = true
+            validation.suppressDropDownArrow = false
+            addValidationData(validation)
+        }
+    }
+
+    private fun XSSFSheet.setupHiddenSheetBasedValueConstraints(constrainedColumns: List<StringRetableColumn>) {
+        val constraintSheetName = "_constraints_${this.sheetName}"
+        val constraintSheet = workbook.createSheet(constraintSheetName)
+        val constraintSheetIndex = workbook.getSheetIndex(constraintSheet)
+        workbook.setSheetHidden(constraintSheetIndex, true)
+
+        constrainedColumns.forEach { column ->
+            val columnIndex = column.index - 1
+
+            val allowedValues = column.allowedValues.orEmpty()
+            allowedValues.forEachIndexed { rowIndex, value ->
+                val row = constraintSheet.getRow(rowIndex)
+                    ?: constraintSheet.createRow(rowIndex)
+                row.createCell(columnIndex).setCellValue(value)
+            }
+
+            val rangeName = "${constraintSheetName}_${columnIndex}"
+            val lastRow = allowedValues.size
+            val colLetter = ('A' + columnIndex)
+            val formulaRef = "'$constraintSheetName'!\$${colLetter}\$1:\$${colLetter}\$$lastRow"
+
+            val name = workbook.createName()
+            name.nameName = rangeName
+            name.refersToFormula = formulaRef
+
+            val constraint = dataValidationHelper.createFormulaListConstraint(rangeName)
+            val cellRange = CellRangeAddressList(
+                if (options.firstRecordAsHeader) 1 else 0,
+                workbook.spreadsheetVersion.lastRowIndex,
+                columnIndex,
+                columnIndex
+            )
+            val validation = dataValidationHelper.createValidation(constraint, cellRange)
+            validation.showPromptBox = true
+            validation.suppressDropDownArrow = false
+            addValidationData(validation)
+        }
     }
 }
 

src/test/kotlin/io/retable/RetableExcelTest.kt

@@ -210,11 +210,32 @@ class RetableExcelTest {
     }
 
     @Test
-    fun `should export with defined value constraints`() {
-        val resultFilePath = pathTo("export_with_value_constraints.xlsx")
+    fun `should export with defined std value constraints`() {
+        val resultFilePath = pathTo("export_with_std_value_constraints.xlsx")
         val columns = object : RetableColumns() {
             val COMPANY = string("company_name", index = 1, allowedValues = listOf("Google", "4sh"))
-            val ENABLED = string("enabled", index = 2)
+            val ENABLED = string("enabled", index = 2, allowedValues = listOf("true", "false"))
+        }
+        Retable(columns)
+            .data(
+                listOf(
+                    listOf("Google", "true"),
+                    listOf("4sh", "true")
+                )
+            )
+            .write(Retable.excel(columns) to File(resultFilePath).outputStream())
+
+        expectThat(File(resultFilePath)) {
+            get { exists() }.isTrue()
+        }
+    }
+
+    @Test
+    fun `should export with defined sheet based value constraints`() {
+        val resultFilePath = pathTo("export_with_sheet_value_constraints.xlsx")
+        val columns = object : RetableColumns() {
+            val COMPANY = string("company_name", index = 1, allowedValues = (1..500).map { "Company $it" })
+            val ENABLED = string("enabled", index = 2, allowedValues = listOf("true", "false"))
         }
         Retable(columns)
             .data(

src/test/resources/examples/.gitignore

@@ -6,7 +6,8 @@ export_data_cols.xlsx
 export_data_cols_date.csv
 export_data_cols_date.xlsx
 export_data_indexed_cols.csv
-export_with_value_constraints.xlsx
+export_with_std_value_constraints.xlsx
+export_with_sheet_value_constraints.xlsx
 export_with_hyperlink.xlsx
 export_with_raw_hyperlink.xlsx
 simple_export_test_result.csv