make golang interface pass tests

Author: kguzek

src/lpg/interfaces/file.py

@@ -6,16 +6,16 @@
 
 from .lang.base import BaseLanguageInterface
 from .lang.c import CLanguageInterface
+from .lang.golang import GoLanguageInterface
 from .lang.java import JavaLanguageInterface
 from .lang.javascript import JavaScriptLanguageInterface
 from .lang.python import PythonLanguageInterface
 from .lang.python3 import Python3LanguageInterface
 from .lang.typescript import TypeScriptLanguageInterface
-from .lang.golang import GoLanguageInterface
 
 LANGUAGE_INTERFACES: dict[str, BaseLanguageInterface] = {
     "c": CLanguageInterface(),
-    "g": GoLanguageInterface(),
+    "golang": GoLanguageInterface(),
     "java": JavaLanguageInterface(),
     "javascript": JavaScriptLanguageInterface(),
     "typescript": TypeScriptLanguageInterface(),

src/lpg/interfaces/lang/base.py

@@ -74,17 +74,28 @@ def get_supplemental_code(self, template: str) -> str | None:
             if match is not None
         )
 
+    def is_void_return_type(self) -> bool:
+        """Determines if the solution function return type is void. Can be overridden."""
+        return self.groups["returnType"] == "void"
+
     def get_formatted_nonvoid_template(
-        self, template: str, nonvoid_callback: Callable[[], str]
+        self,
+        template: str,
+        nonvoid_callback: Callable[[], str],
+        result_var_declaration: str | None = None,
     ) -> str:
         """Adjusts the return type and method call when the return type is void.
         Useful for C-style languages where assigning to a void variable is not allowed.
         """
-        if self.groups["returnType"] == "void":
+        if self.is_void_return_type():
             self.groups["result_var_declaration"] = ""
             self.groups["result_var"] = "0"
             return template
-        self.groups["result_var_declaration"] = f"{self.groups['returnType']} result = "
+        self.groups["result_var_declaration"] = (
+            f"{self.groups['returnType']} result = "
+            if result_var_declaration is None
+            else result_var_declaration
+        )
         self.groups["result_var"] = "result"
         return nonvoid_callback()
 

src/lpg/interfaces/lang/golang.py

@@ -1,6 +1,7 @@
 """Project generator for the Go language."""
 
 import re
+
 from .base import BaseLanguageInterface
 
 # Go function signature pattern
@@ -9,44 +10,68 @@
     flags=re.MULTILINE,
 )
 
-SOLUTION_FILE_TEMPLATE = """\
-package solution
-
-{supplemental_code}
-func {name}({params}) {returnType} {
-    // TODO: Implement solution
-    {return_statement}
-}
-"""
 
 TEST_FILE_TEMPLATE = """\
 package main
 
 import (
     "fmt"
-    "./solution"
 )
 
-func main() {
+func main() {{
     // Test case setup
     {params_setup}
     
     // Execute solution
-    {result_var_declaration}solution.{name}({params_call})
+    {result_var_declaration}{name}({params_call})
     
     // Display result
     fmt.Printf("{OUTPUT_RESULT_PREFIX} %v\\n", {result_var})
-}
+}}
 """
+SOLUTION_REPLACEMENT_PATTERN = re.compile(r"\n}")
+SOLUTION_REPLACEMENT_TEMPLATE = "{return_statement}\n}}"
 
 
 class GoLanguageInterface(BaseLanguageInterface):
     """Implementation of the Go language project template interface."""
 
     function_signature_pattern = FUNCTION_SIGNATURE_PATTERN
-    compile_command = ["go", "build", "-o", "test", "test.go"]
     test_command = ["./test"]
-    default_output = "0"
+
+    @property
+    def compile_command(self):
+        args = ["go", "build", "-o", "test", "test.go", "solution.go"]
+
+        supplemental_filename = self.get_supplemental_filename()
+        if supplemental_filename is not None:
+            args.append(supplemental_filename)
+
+        return args
+
+    def get_supplemental_filename(self):
+        """Obtains the name of the supplemental file."""
+        return "extra.go" if self.groups["supplemental_code"] else None
+
+    @property
+    def default_output(self):
+
+        if self.is_void_return_type():
+            return "0"
+        if "[]" in self.groups["returnType"]:
+            return "[]"
+        output = self._get_default_value(self.groups["returnType"])
+        # Converts the Go type to its string representation
+        match output:
+            case '""':
+                return ""
+            case "nil":
+                return "<nil>"
+            case _:
+                return output
+
+    def is_void_return_type(self):
+        return self.groups["returnType"].strip() == ""
 
     def prepare_project_files(self, template: str):
         params = self.groups["params"].split(", ")
@@ -68,7 +93,7 @@ def prepare_project_files(self, template: str):
 
         self.groups["params_setup"] = ";\n    ".join(
             [
-                f"{name} := {self._get_default_value(param_type)}"
+                self._get_variable_declaration(name, param_type)
                 for name, param_type in zip(param_names, param_types)
             ]
         )
@@ -80,13 +105,31 @@ def prepare_project_files(self, template: str):
 
         # Handle non-void return types
         formatted_template = self.get_formatted_nonvoid_template(
-            TEST_FILE_TEMPLATE, lambda: TEST_FILE_TEMPLATE
+            template,
+            lambda: re.sub(
+                SOLUTION_REPLACEMENT_PATTERN,
+                (SOLUTION_REPLACEMENT_TEMPLATE.format(**self.groups)),
+                template,
+            ),
+            "result := ",
         )
 
-        return {
-            "solution/solution.go": SOLUTION_FILE_TEMPLATE.format(**self.groups),
-            "test.go": formatted_template.format(**self.groups),
+        project_files = {
+            "solution.go": f"package main\n\n{formatted_template}",
+            "test.go": TEST_FILE_TEMPLATE.format(**self.groups),
         }
+        if self.groups["supplemental_code"]:
+            filename = self.get_supplemental_filename()
+            project_files[filename] = (
+                f"package main\n\n{self.groups["supplemental_code"]}"
+            )
+        return project_files
+
+    def _get_variable_declaration(self, name: str, variable_type: str) -> str:
+        default_value = self._get_default_value(variable_type)
+        if default_value == "nil":
+            return f"var {name} {variable_type}"
+        return f"{name} := {default_value}"
 
     def _get_default_value(self, param_type: str) -> str:
         """Returns a default value for the given Go type."""
@@ -100,8 +143,11 @@ def _get_default_value(self, param_type: str) -> str:
             "bool": "false",
         }
 
+        if "[]" in param_type:
+            return f"{param_type}{{}}"  # Default slice initialization
+
         # Check for specific patterns
-        if "[]" in param_type or "map" in param_type or "*" in param_type:
+        if "map" in param_type or "*" in param_type:
             return "nil"
 
         # Check for simple matches in dictionary

src/lpg/interfaces/lang_test.py

@@ -72,7 +72,7 @@ def conduct_tests(self, code_snippets: list[dict[str, str]]):
                 continue
             self.assertMultiLineEqual(
                 result.stdout.decode().strip(),
-                f"{OUTPUT_RESULT_PREFIX} {interface.default_output}",
+                f"{OUTPUT_RESULT_PREFIX} {interface.default_output}".strip(),
             )