refactor string manipulation procs in meta

Author: Ivansete-status

ffi/codegen/cpp.nim

@@ -58,7 +58,7 @@ proc stripLibPrefixCpp(procName, libName: string): string =
   return procName
 
 proc reqStructName(p: FFIProcMeta): string =
-  let camel = toCamelCase(p.procName)
+  let camel = snakeToPascalCase(p.procName)
   if p.kind == FFIKind.CTOR: camel & "CtorReq" else: camel & "Req"
 
 proc cppBracedInit(structName: string, fieldNames: seq[string]): string =

ffi/codegen/meta.nim

@@ -1,7 +1,7 @@
 ## Compile-time metadata types for FFI binding generation.
 ## Populated by the {.ffiCtor.} and {.ffi.} macros and consumed by codegen.
 
-import std/strutils
+import std/[strutils, unicode]
 
 type
   FFIParamMeta* = object
@@ -51,27 +51,34 @@ const ffiNimSrcRelPath* {.strdefine.} = ""
 # Name conversion helpers shared by codegen and the ffi macro
 # ---------------------------------------------------------------------------
 
-proc toSnakeCase*(s: string): string =
+proc camelToSnakeCase*(s: string): string =
+  ## Converts camelCase to snake_case. Inserts `_` before each uppercase rune
+  ## that's not the first character and lowercases everything.
+  ## e.g. "delayMs" → "delay_ms", "timerName" → "timer_name"
   var snake = ""
-  for i, c in s:
-    if c.isUpperAscii() and i > 0:
+  var first = true
+  for r in runes(s):
+    if r.isUpper() and not first:
       snake.add('_')
-    snake.add(c.toLowerAscii())
+    snake.add($r.toLower())
+    first = false
   return snake
 
-proc toPascalCase*(s: string): string =
-  ## Returns `s` with the first character uppercased.
+proc capitalizeFirstLetter*(s: string): string =
+  ## Returns `s` with its first rune uppercased; the rest is left unchanged.
+  ## e.g. "abc" → "Abc", "" → "", "Abc" → "Abc"
   if s.len == 0:
     return s
-  var pascal = s
-  pascal[0] = s[0].toUpperAscii()
-  return pascal
+  var runesSeq = toRunes(s)
+  runesSeq[0] = runesSeq[0].toUpper()
+  return $runesSeq
 
-proc toCamelCase*(s: string): string =
-  ## Converts snake_case or mixed identifiers to PascalCase for type names.
-  ## e.g. "testlib_create" -> "TestlibCreate"
+proc snakeToPascalCase*(s: string): string =
+  ## Converts snake_case identifiers to PascalCase: split on `_`, uppercase
+  ## the first rune of each part, concatenate.
+  ## e.g. "testlib_create" → "TestlibCreate", "hello_world" → "HelloWorld"
   let parts = s.split('_')
-  var camel = ""
+  var pascal = ""
   for p in parts:
-    camel.add toPascalCase(p)
-  return camel
+    pascal.add capitalizeFirstLetter(p)
+  return pascal

ffi/codegen/rust.nim

@@ -20,7 +20,7 @@ proc nimTypeToRust*(typeName: string): string =
   of "bool": "bool"
   of "float", "float64": "f64"
   of "pointer": "u64"
-  else: toPascalCase(t)
+  else: capitalizeFirstLetter(t)
 
 proc deriveLibName*(procs: seq[FFIProcMeta]): string =
   ## Extracts the common prefix before the first `_` from proc names.
@@ -45,7 +45,7 @@ proc stripLibPrefix*(procName: string, libName: string): string =
 
 proc reqStructName(p: FFIProcMeta): string =
   ## Mirrors the Nim macro: <CamelCase(procName)>Req or CtorReq for ctors.
-  let camel = toCamelCase(p.procName)
+  let camel = snakeToPascalCase(p.procName)
   if p.kind == FFIKind.CTOR: camel & "CtorReq" else: camel & "Req"
 
 # ---------------------------------------------------------------------------
@@ -201,7 +201,7 @@ proc generateTypesRs*(
     lines.add("#[derive(Debug, Clone, Serialize, Deserialize)]")
     lines.add("pub struct $1 {" % [t.name])
     for f in t.fields:
-      let snakeName = toSnakeCase(f.name)
+      let snakeName = camelToSnakeCase(f.name)
       let rustType = nimTypeToRust(f.typeName)
       # Add serde rename if camelCase name differs from snake_case
       if snakeName != f.name:
@@ -222,7 +222,7 @@ proc generateTypesRs*(
     else:
       lines.add("pub struct $1 {" % [reqName])
       for ep in p.extraParams:
-        let snake = toSnakeCase(ep.name)
+        let snake = camelToSnakeCase(ep.name)
         let rustType =
           if ep.isPtr: "u64"
           else: nimTypeToRust(ep.typeName)
@@ -255,7 +255,7 @@ proc generateApiRs*(procs: seq[FFIProcMeta], libName: string): string =
 
   var libTypeName = ""
   if ctors.len > 0: libTypeName = ctors[0].libTypeName
-  else: libTypeName = toPascalCase(libName)
+  else: libTypeName = capitalizeFirstLetter(libName)
 
   let ctxTypeName = libTypeName & "Ctx"
 
@@ -415,7 +415,7 @@ proc generateApiRs*(procs: seq[FFIProcMeta], libName: string): string =
     var paramsList: seq[string] = @[]
     var fieldInits: seq[string] = @[]
     for ep in ctor.extraParams:
-      let snake = toSnakeCase(ep.name)
+      let snake = camelToSnakeCase(ep.name)
       let rustType =
         if ep.isPtr: "u64"
         else: nimTypeToRust(ep.typeName)
@@ -468,7 +468,7 @@ proc generateApiRs*(procs: seq[FFIProcMeta], libName: string): string =
     var paramsList: seq[string] = @[]
     var fieldInits: seq[string] = @[]
     for ep in m.extraParams:
-      let snake = toSnakeCase(ep.name)
+      let snake = camelToSnakeCase(ep.name)
       let rustType =
         if ep.isPtr: "u64"
         else: nimTypeToRust(ep.typeName)

ffi/internal/ffi_macro.nim

@@ -527,7 +527,7 @@ macro ffi*(prc: untyped): untyped =
     else:
       raw
   let cExportName = nimNameToCExport(procNameStr)
-  let camelName = toCamelCase(procNameStr)
+  let camelName = snakeToPascalCase(procNameStr)
 
   let reqTypeName = ident(camelName & "Req")
 
@@ -1160,7 +1160,7 @@ macro ffiCtor*(prc: untyped): untyped =
     else:
       procNameStr
   let cExportName = nimNameToCExport(cleanName)
-  let reqTypeNameStr = toCamelCase(cleanName) & "CtorReq"
+  let reqTypeNameStr = snakeToPascalCase(cleanName) & "CtorReq"
   let reqTypeName = ident(reqTypeNameStr)
 
   let typeDef = buildCtorRequestType(reqTypeName, paramNames, paramTypes)

tests/test_meta.nim

@@ -0,0 +1,87 @@
+## Unit tests for the string-manipulation helpers used by the codegen.
+## These names map identifier conventions between Nim (camelCase),
+## Rust (snake_case) and C++ (PascalCase types), and they're load-bearing
+## for binding generation, so it's worth pinning their behaviour with tests.
+
+import unittest
+import ../ffi/codegen/meta
+
+suite "camelToSnakeCase":
+  test "empty string":
+    check camelToSnakeCase("") == ""
+
+  test "single lowercase character":
+    check camelToSnakeCase("a") == "a"
+
+  test "single uppercase character":
+    check camelToSnakeCase("A") == "a"
+
+  test "all lowercase passes through":
+    check camelToSnakeCase("hello") == "hello"
+
+  test "simple camelCase":
+    check camelToSnakeCase("camelCase") == "camel_case"
+
+  test "two-letter suffix":
+    check camelToSnakeCase("delayMs") == "delay_ms"
+
+  test "PascalCase input — leading capital stays at start":
+    check camelToSnakeCase("PascalCase") == "pascal_case"
+
+  test "consecutive uppercase letters each get their own underscore":
+    check camelToSnakeCase("ABC") == "a_b_c"
+
+  test "multiple word boundaries":
+    check camelToSnakeCase("abcDefGhi") == "abc_def_ghi"
+
+  test "already snake_case passes through":
+    check camelToSnakeCase("already_snake") == "already_snake"
+
+suite "capitalizeFirstLetter":
+  test "empty string":
+    check capitalizeFirstLetter("") == ""
+
+  test "single lowercase character":
+    check capitalizeFirstLetter("a") == "A"
+
+  test "single uppercase character":
+    check capitalizeFirstLetter("A") == "A"
+
+  test "lowercase word":
+    check capitalizeFirstLetter("abc") == "Abc"
+
+  test "already capitalised":
+    check capitalizeFirstLetter("Abc") == "Abc"
+
+  test "all-caps stays unchanged except first stays cap":
+    check capitalizeFirstLetter("ABC") == "ABC"
+
+  test "leading non-letter is left alone":
+    check capitalizeFirstLetter("_hello") == "_hello"
+
+suite "snakeToPascalCase":
+  test "empty string":
+    check snakeToPascalCase("") == ""
+
+  test "single lowercase word":
+    check snakeToPascalCase("hello") == "Hello"
+
+  test "two-part snake_case":
+    check snakeToPascalCase("hello_world") == "HelloWorld"
+
+  test "three-part snake_case":
+    check snakeToPascalCase("testlib_create") == "TestlibCreate"
+
+  test "single-letter parts each capitalised":
+    check snakeToPascalCase("a_b_c") == "ABC"
+
+  test "trailing underscore yields empty trailing part":
+    check snakeToPascalCase("foo_") == "Foo"
+
+  test "leading underscore yields empty leading part":
+    check snakeToPascalCase("_foo") == "Foo"
+
+  test "already-mixed parts preserve their existing case after the first":
+    # split on '_', capitalize first letter of each part; "HasCaps" first
+    # letter is already 'H' so it's untouched.
+    check snakeToPascalCase("already_HasCaps") == "AlreadyHasCaps"