Rename support

Author: ptmt

src/com/potomushto/statik/cms/CmsModels.kt

@@ -105,6 +105,7 @@ data class CmsMediaListResponse(
 data class CmsSaveRequest(
     val type: CmsContentType,
     val sourcePath: String,
+    val previousSourcePath: String? = null,
     val frontmatter: String = "",
     val body: String = "",
     val sync: Boolean = false,

src/com/potomushto/statik/cms/CmsRepository.kt

@@ -49,6 +49,13 @@ class CmsRepository(
                     )
                     """.trimIndent()
                 )
+                statement.execute(
+                    """
+                    create table if not exists cms_content_deleted (
+                        source_path text primary key
+                    )
+                    """.trimIndent()
+                )
             }
         }
     }
@@ -116,6 +123,30 @@ class CmsRepository(
         }
     }
 
+    fun deleteContent(sourcePath: String) {
+        withConnection { connection ->
+            connection.prepareStatement("delete from cms_content where source_path = ?").use { statement ->
+                statement.setString(1, sourcePath)
+                statement.executeUpdate()
+            }
+        }
+    }
+
+    fun markContentDeleted(sourcePath: String) {
+        withConnection { connection ->
+            connection.prepareStatement(
+                """
+                insert into cms_content_deleted (source_path)
+                values (?)
+                on conflict(source_path) do nothing
+                """.trimIndent()
+            ).use { statement ->
+                statement.setString(1, sourcePath)
+                statement.executeUpdate()
+            }
+        }
+    }
+
     fun upsertMedia(entry: CmsMediaEntry) {
         withConnection { connection ->
             upsertMedia(connection, entry)
@@ -227,7 +258,7 @@ class CmsRepository(
 
     fun dirtySourcePaths(): List<String> {
         return withConnection { connection ->
-            connection.prepareStatement(
+            val dirtyContent = connection.prepareStatement(
                 """
                 select source_path
                 from cms_content
@@ -243,6 +274,24 @@ class CmsRepository(
                     }
                 }
             }
+
+            val deletedContent = connection.prepareStatement(
+                """
+                select source_path
+                from cms_content_deleted
+                order by source_path asc
+                """.trimIndent()
+            ).use { statement ->
+                statement.executeQuery().use { resultSet ->
+                    buildList {
+                        while (resultSet.next()) {
+                            add(resultSet.getString("source_path"))
+                        }
+                    }
+                }
+            }
+
+            (dirtyContent + deletedContent).distinct().sorted()
         }
     }
 
@@ -287,6 +336,18 @@ class CmsRepository(
                     }
                     statement.executeBatch()
                 }
+                connection.prepareStatement(
+                    """
+                    delete from cms_content_deleted
+                    where source_path = ?
+                    """.trimIndent()
+                ).use { statement ->
+                    sourcePaths.forEach { sourcePath ->
+                        statement.setString(1, sourcePath)
+                        statement.addBatch()
+                    }
+                    statement.executeBatch()
+                }
                 connection.commit()
             } catch (error: Exception) {
                 connection.rollback()
@@ -360,12 +421,19 @@ class CmsRepository(
     }
 
     fun dirtyCount(): Int = withConnection { connection ->
-        connection.prepareStatement("select count(*) as total from cms_content where dirty = 1").use { statement ->
+        val dirtyContent = connection.prepareStatement("select count(*) as total from cms_content where dirty = 1").use { statement ->
+            statement.executeQuery().use { resultSet ->
+                resultSet.next()
+                resultSet.getInt("total")
+            }
+        }
+        val deletedContent = connection.prepareStatement("select count(*) as total from cms_content_deleted").use { statement ->
             statement.executeQuery().use { resultSet ->
                 resultSet.next()
                 resultSet.getInt("total")
             }
         }
+        dirtyContent + deletedContent
     }
 
     fun mediaDirtyCount(): Int = withConnection { connection ->
@@ -434,6 +502,10 @@ class CmsRepository(
             }
             statement.executeUpdate()
         }
+        connection.prepareStatement("delete from cms_content_deleted where source_path = ?").use { statement ->
+            statement.setString(1, entry.sourcePath)
+            statement.executeUpdate()
+        }
     }
 
     private fun upsertMedia(connection: Connection, entry: CmsMediaEntry) {

src/com/potomushto/statik/cms/CmsService.kt

@@ -4,9 +4,11 @@ import com.potomushto.statik.config.BlogConfig
 import com.potomushto.statik.generators.AssetManager
 import com.potomushto.statik.generators.FileWalker
 import com.potomushto.statik.generators.SiteGenerator
+import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
 import java.time.LocalDateTime
+import java.util.Comparator
 
 class CmsService(
     private val rootPath: Path,
@@ -16,7 +18,7 @@ class CmsService(
     private val mediaFileService: MediaFileService = MediaFileService(rootPath, config),
     databasePath: Path? = null,
     private val repository: CmsRepository = CmsRepository(databasePath ?: resolveDatabasePath(rootPath, config.cms.databasePath)),
-    private val gitSyncService: GitSyncService = GitSyncService(rootPath, config.cms.git),
+    private val gitSyncService: GitSyncService = GitSyncService(rootPath, config.cms.git, config.theme.output),
     private val assetManager: AssetManager = AssetManager(rootPath.toString(), config, FileWalker(rootPath.toString()))
 ) {
     private val lock = Any()
@@ -66,14 +68,35 @@ class CmsService(
     fun save(request: CmsSaveRequest, accessToken: String? = null): CmsSaveResponse {
         synchronized(lock) {
             val normalizedSourcePath = normalizeSourcePath(request.sourcePath)
-            val existing = repository.find(normalizedSourcePath)
-            val saved = contentFileService.save(request.copy(sourcePath = normalizedSourcePath))
+            val normalizedPreviousSourcePath = request.previousSourcePath
+                ?.takeIf { it.isNotBlank() }
+                ?.let(::normalizeSourcePath)
+
+            val previousEntry = normalizedPreviousSourcePath?.let(repository::find)
+            if (previousEntry != null && previousEntry.sourcePath != normalizedSourcePath) {
+                contentFileService.rename(previousEntry.sourcePath, normalizedSourcePath, previousEntry.type)
+            }
+
+            val existing = repository.find(normalizedSourcePath) ?: previousEntry
+            val saved = contentFileService.save(
+                request.copy(
+                    sourcePath = normalizedSourcePath,
+                    previousSourcePath = normalizedPreviousSourcePath
+                )
+            )
             val dirtyEntry = saved.copy(
                 dirty = true,
                 updatedAt = System.currentTimeMillis(),
                 lastSyncedAt = existing?.lastSyncedAt
             )
 
+            if (previousEntry != null && previousEntry.sourcePath != normalizedSourcePath) {
+                markContentDeleted(previousEntry.sourcePath, previousEntry.lastSyncedAt, previousEntry.dirty)
+                if (previousEntry.outputPath != saved.outputPath) {
+                    deleteGeneratedContent(previousEntry.outputPath)
+                }
+            }
+
             repository.upsert(dirtyEntry)
             generator.regenerate(listOf(rootPath.resolve(saved.sourcePath)))
 
@@ -252,6 +275,53 @@ class CmsService(
         )
     }
 
+    private fun markContentDeleted(sourcePath: String, lastSyncedAt: Long?, dirty: Boolean) {
+        if (dirty && lastSyncedAt == null) {
+            repository.deleteContent(sourcePath)
+            return
+        }
+
+        repository.deleteContent(sourcePath)
+        repository.markContentDeleted(sourcePath)
+    }
+
+    private fun deleteGeneratedContent(outputPath: String) {
+        val outputRoot = rootPath.resolve(config.theme.output).normalize()
+        val target = if (outputPath.isBlank()) {
+            outputRoot.resolve("index.html")
+        } else {
+            outputRoot.resolve(outputPath)
+        }.normalize()
+
+        if (!target.startsWith(outputRoot) || !Files.exists(target)) {
+            return
+        }
+
+        if (Files.isDirectory(target)) {
+            Files.walk(target).use { stream ->
+                stream.sorted(Comparator.reverseOrder()).forEach { candidate ->
+                    Files.deleteIfExists(candidate)
+                }
+            }
+            pruneEmptyGeneratedDirectories(target.parent, outputRoot)
+        } else {
+            Files.deleteIfExists(target)
+            pruneEmptyGeneratedDirectories(target.parent, outputRoot)
+        }
+    }
+
+    private fun pruneEmptyGeneratedDirectories(start: Path?, stopAt: Path) {
+        var current = start
+        while (current != null && current.startsWith(stopAt) && current != stopAt) {
+            val isEmpty = Files.list(current).use { stream -> !stream.findFirst().isPresent }
+            if (!isEmpty) {
+                return
+            }
+            Files.deleteIfExists(current)
+            current = current.parent
+        }
+    }
+
     private fun composeMediaPath(targetDirectory: String, fileName: String): String {
         val directory = targetDirectory.trim().trimEnd('/').removePrefix("/")
         return listOf(directory, fileName.trim().removePrefix("/"))