remove str dunder

Author: saviorand

lightbug_api/app.mojo

@@ -68,7 +68,7 @@ struct App[docs_enabled: Bool = False]:
         with open((lightbug_dir / "routes.json"), "w") as f:
             f.write(to_string[pretty=True](routes_obj))
 
-        var mojodoc_status = external_call["system", UInt8]("magic run mojo doc ./lightbug.🔥 -o " + lightbug_dir.__str__() + "/mojodoc.json")
+        var mojodoc_status = external_call["system", UInt8]("magic run mojo doc ./lightbug.🔥 -o " + str(lightbug_dir) + "/mojodoc.json")
         if mojodoc_status != 0:
             logger.error("Failed to generate mojodoc.json")
             return
@@ -77,16 +77,16 @@ struct App[docs_enabled: Bool = False]:
         var generator = OpenAPIGenerator()
 
         var mojo_doc_json = generator.read_mojo_doc(
-            (self.lightbug_dir / "mojodoc.json").__str__()
+            str(self.lightbug_dir / "mojodoc.json")
         )
         var router_metadata_json = generator.read_router_metadata(
-            (self.lightbug_dir / "routes.json").__str__()
+            str(self.lightbug_dir / "routes.json")
         )
 
         var openapi_spec = generator.generate_spec(mojo_doc_json, router_metadata_json)
         generator.save_spec(
             openapi_spec, 
-            (self.lightbug_dir / "openapi_spec.json").__str__()
+            str(self.lightbug_dir / "openapi_spec.json")
         )
         return openapi_spec
 

lightbug_api/openapi/generate.mojo

@@ -19,13 +19,13 @@ struct OpenAPIGenerator:
         var routes = router_metadata["routes"][Array]._data
         for i in range(len(routes)):
             var route = routes[i][Object]
-            var handler = route["handler"].__str__().strip('"')
+            var handler = str(route["handler"]).strip('"')
             var path = route["path"][String].strip('"')
             var method = String(route["method"][String].strip('"')).lower()
             route_map[handler] = (String(path), method)
 
         for func in mojo_doc["decl"][Object]["functions"][Array]._data:
-            var func_name = func[][Object]["name"].__str__().strip('"')
+            var func_name = str(func[][Object]["name"]).strip('"')
 
             if func_name not in route_map:
                 continue
@@ -57,7 +57,7 @@ struct OpenAPIGenerator:
     fn create_endpoint(mut self, function_data: JSON, http_method: String) raises -> JSON:
         var endpoint = JSON()
         var func_name = function_data["name"]
-        endpoint["summary"] = String(func_name.__str__().strip('"')) + " endpoint"
+        endpoint["summary"] = String(str(func_name).strip('"')) + " endpoint"
         endpoint["operationId"] = func_name
 
         var responses = JSON()
@@ -71,19 +71,19 @@ struct OpenAPIGenerator:
         for i in range(len(overloads)):
             var overload = overloads[i][Array][0] # first overload only for now
             if "returnsDoc" in overload[Object]._data:
-                response_description = String(overload[Object]["returnsDoc"].__str__().strip('"'))
+                response_description = String(str(overload[Object]["returnsDoc"]).strip('"'))
             if "summary" in overload[Object]._data:
-                endpoint["description"] = String(overload[Object]["summary"].__str__().strip('"'))
-            if "description" in overload[Object]._data and overload[Object]["description"].__str__().__contains__("Tags:"):
-                var description = overload[Object]["description"].__str__()
+                endpoint["description"] = String(str(overload[Object]["summary"]).strip('"'))
+            if "description" in overload[Object]._data and str(overload[Object]["description"]).__contains__("Tags:"):
+                var description = str(overload[Object]["description"])
                 var tags_part = description.split("Tags:")[1]
                 var tags_str = String(tags_part.strip().rstrip('."'))
                 var tags = tags_str.split(",")
                 var tag_values = List[Value]()
                 for tag in tags:
                     var stripped_tag = String(tag[].strip()).replace("\\n", "").replace("\\t", "").replace("\\r", "")
                     var cleaned_tag = stripped_tag.strip("  ")
-                    tag_values.append(Value(cleaned_tag.__str__()))
+                    tag_values.append(Value(str(cleaned_tag)))
 
                 self.set_tags(tag_values)
                 endpoint["tags"] = Array(tag_values)
@@ -93,7 +93,7 @@ struct OpenAPIGenerator:
                 for i in range(len(args)):
                     var arg = args[0][Array][i][Object]
                     if "description" in arg._data:
-                        request_description = String(arg["description"].__str__().strip('"'))
+                        request_description = String(str(arg["description"]).strip('"'))
             break
 
         response_200["description"] = response_description

tests/lightbug_api/test_generate.mojo

@@ -123,9 +123,9 @@ def test_endpoint_tags():
     assert_true("tags" in endpoint)
     var tag_array = endpoint["tags"][Array]
     assert_equal(len(tag_array), 3)
-    assert_equal(tag_array[0].__str__(), '"api"')
-    assert_equal(tag_array[1].__str__(), '"test"')
-    assert_equal(tag_array[2].__str__(), '"auth"')
+    assert_equal(str(tag_array[0]), '"api"')
+    assert_equal(str(tag_array[1]), '"test"')
+    assert_equal(str(tag_array[2]), '"auth"')
 
     # Test 2: Tags with control characters
     var function_data_control_chars = JSON.from_string('''
@@ -147,9 +147,9 @@ def test_endpoint_tags():
     assert_true("tags" in endpoint_control_chars)
     var tag_array_control_chars = endpoint_control_chars["tags"][Array]
     assert_equal(len(tag_array_control_chars), 3)
-    assert_equal(tag_array_control_chars[0].__str__(), '"hello"')
-    assert_equal(tag_array_control_chars[1].__str__(), '"what"')
-    assert_equal(tag_array_control_chars[2].__str__(), '"up"')
+    assert_equal(str(tag_array_control_chars[0]), '"hello"')
+    assert_equal(str(tag_array_control_chars[1]), '"what"')
+    assert_equal(str(tag_array_control_chars[2]), '"up"')
 
     # Test 3: Tags with extra whitespace
     var function_data_whitespace = JSON.from_string("""
@@ -171,9 +171,9 @@ def test_endpoint_tags():
     assert_true("tags" in endpoint_whitespace)
     var tag_array_whitespace = endpoint_whitespace["tags"][Array]
     assert_equal(len(tag_array_whitespace), 3)
-    assert_equal(tag_array_whitespace[0].__str__(), '"api"')
-    assert_equal(tag_array_whitespace[1].__str__(), '"test"')
-    assert_equal(tag_array_whitespace[2].__str__(), '"auth"')
+    assert_equal(str(tag_array_whitespace[0]), '"api"')
+    assert_equal(str(tag_array_whitespace[1]), '"test"')
+    assert_equal(str(tag_array_whitespace[2]), '"auth"')
 
     # Test 4: No tags
     var function_data_no_tags = JSON.from_string("""