Implement begining of migration

Move Function/Query definition

src/main/kotlin/fr/postgresjson/definition/Function.kt

@@ -0,0 +1,48 @@
+package fr.postgresjson.definition
+
+import java.io.File
+
+
+open class Function (
+    override val name: String,
+    override val script: String,
+    override val parameters: List<Parameter>
+) : Resource, ParametersInterface {
+    override var source: File? = null
+
+    companion object {
+        fun build(source: File): List<Function> {
+            return build(source.readText())
+        }
+
+        fun build(functionContent: String): List<Function> {
+            val functionRegex = """create .*(procedure|function) *(?<name>[^(\s]+)\s*\((?<params>(\s*((IN|OUT|INOUT|VARIADIC)?\s+)?([^\s,)]+\s+)?([^\s,)]+)(\s+(?:default\s|=)\s*[^\s,)]+)?\s*(,|(?=\))))*)\) *(?<return>RETURNS *[^ ]+)?"""
+                .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
+
+            val paramsRegex = """\s*(?<param>((?<direction>IN|OUT|INOUT|VARIADIC)?\s+)?(?<name>[^\s,)]+\s+)?(?<type>[^\s,)]+)(\s+(?<default>default\s|=)\s*[^\s,)]+)?)\s*(,|$)"""
+                .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
+
+            return functionRegex.findAll(functionContent).map { queryMatch ->
+                val functionName = queryMatch.groups["name"]?.value?.trim()
+                val functionParameters = queryMatch.groups["params"]?.value?.trim()
+                val returns = queryMatch.groups["return"]?.value?.trim()
+
+                /* Create parameters definition */
+                val parameters = if (functionParameters !== null) {
+                    val matchesParams = paramsRegex.findAll(functionParameters)
+                    matchesParams.map { paramsMatch ->
+                        Parameter(
+                            paramsMatch.groups["name"]!!.value.trim(),
+                            paramsMatch.groups["type"]!!.value.trim(),
+                            paramsMatch.groups["direction"]?.value?.trim(),
+                            paramsMatch.groups["default"]?.value?.trim())
+                    }.toList()
+                } else {
+                    listOf()
+                }
+
+                Function(functionName!!, functionContent, parameters)
+            }.toList()
+        }
+    }
+}

src/main/kotlin/fr/postgresjson/definition/Parameter.kt

@@ -0,0 +1,34 @@
+package fr.postgresjson.definition
+
+interface ParameterI {
+    val name: String
+    val type: String
+    val direction: Parameter.Direction
+    val default: String
+}
+
+class Parameter(val name: String, val type: String, direction: Direction? = Direction.IN, val default: Any? = null)
+{
+    val direction: Direction
+
+    init {
+        if (direction === null) {
+            this.direction = Direction.IN
+        } else {
+            this.direction = direction
+        }
+    }
+
+    constructor(name: String, type: String, direction: String? = "IN", default: Any? = null) : this(
+        name = name,
+        type = type,
+        direction = direction?.let { Direction.valueOf(direction.toUpperCase())},
+        default = default
+    )
+
+    enum class Direction { IN, OUT, INOUT }
+}
+
+interface ParametersInterface {
+    val parameters: List<Parameter>
+}

src/main/kotlin/fr/postgresjson/definition/Resource.kt

@@ -0,0 +1,13 @@
+package fr.postgresjson.definition
+
+import java.io.File
+
+interface Resource {
+    val name: String
+    val script: String
+    var source: File?
+}
+
+interface ResourceCollection {
+    val parameters: List<Parameter>
+}