docstring-generator-ext 2.0.1__tar.gz → 2.0.2__tar.gz

{docstring_generator_ext-2.0.1 → docstring_generator_ext-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docstring_generator_ext
-Version: 2.0.1
+Version: 2.0.2
 Summary: Generate Docstrings with type-hint information.
 Author-email: FelixTheC <fberndt87@gmail.com>
 Classifier: Environment :: Console

{docstring_generator_ext-2.0.1 → docstring_generator_ext-2.0.2}/docstring_generator_ext.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docstring_generator_ext
-Version: 2.0.1
+Version: 2.0.2
 Summary: Generate Docstrings with type-hint information.
 Author-email: FelixTheC <fberndt87@gmail.com>
 Classifier: Environment :: Console

{docstring_generator_ext-2.0.1 → docstring_generator_ext-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docstring_generator_ext"
-version = "2.0.1"
+version = "2.0.2"
 description = "Generate Docstrings with type-hint information."
 authors = [
     { name = "FelixTheC", email = "fberndt87@gmail.com" },

docstring_generator_ext-2.0.2/src/GoogleDocstring.cpp

@@ -0,0 +1,145 @@
+#include "GoogleDocstring.hpp"
+
+#include <format>
+
+#include "parser.hpp"
+
+void GoogleDocstring::check_current_docstring() noexcept {
+    auto current_py_tab = get_tabs();
+    auto google_args_begin = functionInfo.docstring.docstring.find("Args:");
+
+    if (google_args_begin < std::string::npos) {
+        functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
+            0,
+            google_args_begin - (current_py_tab.size() + 1)
+        );
+        functionInfo.docstring.end_line = functionInfo.docstring.start_line + google_args_begin;
+    }
+}
+
+std::string GoogleDocstring::docstringArgs() noexcept {
+    auto current_py_tab = get_tabs();
+
+    std::string result;
+    result.reserve(256); // rough upfront guess for typical arg count
+
+    if (!functionInfo.docstring.docstring.empty()) {
+         result += functionInfo.docstring.docstring;
+         result += "\n";
+    }
+
+    if (functionInfo.args.empty())
+        return "";
+
+    if (PY_TAB != current_py_tab) {
+        result += current_py_tab;
+        current_py_tab += PY_TAB;
+    } else {
+        result += PY_TAB;
+        current_py_tab = PY_TAB + PY_TAB;
+    }
+
+    int idx = 0;
+    const int last_idx = functionInfo.args.size();
+    result += "Args:\n";
+    for (const auto &val : functionInfo.args) {
+        ++idx;
+        result += current_py_tab;
+        result += val.name;
+        if (!val.type.empty()) {
+            result += " (";
+            result += val.type;
+            if (!val.default_value.empty()) {
+                result += ", optional";
+            }
+            result += ")";
+        }
+        if (!val.description.empty()) {
+            result += ": ";
+            result += val.description;
+        }
+        if (!val.default_value.empty()) {
+            result += " (default is ";
+            result += val.default_value;
+            result += ")";
+        }
+
+        if (idx < last_idx) {
+            result += "\n";
+        }
+    }
+    return result;
+}
+
+std::string GoogleDocstring::docstringReturn() noexcept {
+    std::string result;
+    result.reserve(256); // rough upfront guess for typical arg count
+
+    auto current_py_tab = get_tabs();
+
+    if (!functionInfo.returns.description.empty() || !functionInfo.returns.type.empty()) {
+        result += "\n";
+
+        if (PY_TAB != current_py_tab) {
+            result += PY_TAB;
+        } else {
+            result += PY_TAB;
+            current_py_tab = PY_TAB + PY_TAB;
+        }
+
+        result += "Returns:\n";
+        result += current_py_tab;
+
+        if (!functionInfo.returns.type.empty()) {
+            result += std::format("{}: ", functionInfo.returns.type);
+        }
+        if (!functionInfo.returns.description.empty()) {
+            result += functionInfo.returns.description;
+        }
+    } else {
+        result = "";
+    }
+
+    return result;
+}
+
+std::string GoogleDocstring::docstringExceptions() noexcept {
+    if (functionInfo.exceptions.empty())
+        return "\n";
+
+    std::string result;
+    result.reserve(256); // rough upfront guess for typical arg count
+    auto current_py_tab = get_tabs();
+
+    result += "\n";
+
+    if (PY_TAB != current_py_tab) {
+        result += PY_TAB;
+    } else {
+        result += PY_TAB;
+        current_py_tab = PY_TAB + PY_TAB;
+    }
+
+    result += "Raises:\n";
+    result += current_py_tab;
+
+    int idx = 0;
+    const int last_exception = functionInfo.exceptions.size();
+    for (const auto &[name, description] : functionInfo.exceptions) {
+        ++idx;
+
+        if (!name.empty()) {
+            result += std::format("{}: ", name);
+        }
+        if (!description.empty()) {
+            result += description;
+        }
+
+        result += "\n";
+        if (idx < last_exception) {
+             result += current_py_tab;
+        }
+    }
+
+    return result;
+}

docstring_generator_ext-2.0.2/src/IDocstringFormat.cpp

@@ -0,0 +1,39 @@
+#include "IDocstringFormat.hpp"
+#include "parser.hpp"
+#include <sstream>
+
+[[ nodiscard ]] std::string DocstringFormat::docstring() noexcept {
+    std::string result;
+    result.reserve(1024); // rough upfront guess for typical arg count
+    const auto current_pytab = get_tabs();
+
+    result += current_pytab;
+    result += R"(""")";
+    if (functionInfo.docstring.docstring.empty()) {
+        result += "\n";
+    }
+    if (const auto argTxt = docstringArgs(); !argTxt.empty()) {
+        result += argTxt;
+    }
+    if (const auto returnTxt = docstringReturn(); !returnTxt.empty())
+        result += docstringReturn();
+    if (const auto exceptionTxt = docstringExceptions(); !exceptionTxt.empty())
+        result += docstringExceptions();
+
+    result += current_pytab;
+    result += R"(""")";
+    if (functionInfo.docstring.docstring.empty()) {
+        result += "\n";
+    }
+
+    return result;
+}
+
+[[ nodiscard ]] std::string DocstringFormat::get_tabs() const noexcept {
+    auto current_py_tab = PY_TAB;
+    for (uint32_t idx = 0; idx < (functionInfo.offset / 4); ++idx) {
+        current_py_tab += PY_TAB;
+    }
+
+    return current_py_tab;
+}

{docstring_generator_ext-2.0.1 → docstring_generator_ext-2.0.2}/src/docstringFormat.cpp

@@ -52,7 +52,7 @@ void parse_file(std::string &file_path, DocstringFormatStyle &formatStyle) {
             )) {
             FunctionInfo function_info = analyze_function(obj, ast_module);
             function_info.update_descriptions(formatStyle);
-            infos.emplace_back();
+            infos.emplace_back(function_info);
         }
     }
 
@@ -165,19 +165,25 @@ void write_to_file_position(
         lines.insert(lines.begin() + start_pos, docstring_format->docstring());
     }
 
-    file.open(file_path, std::ios::out);
+    {
+        std::ofstream out_file(file_path);
+        if (!out_file.is_open()) {
+            py::print("Error: Unable to open file for writing.");
+            std::cerr << "Error: Unable to open file for writing.\n";
+            return;
+        }
 
-    std::ranges::for_each(
-        lines,
-        [&file](const auto &line) {
-            file << line;
-            if (line[line.size() - 1] != '\n') {
-                file << "\n";
+        std::string output;
+        output.reserve(lines.size() * 80); // rough estimate
+        for (const auto &line : lines) {
+            output += line;
+            if (line.empty() || line[line.size() - 1] != '\n') {
+                output += '\n';
             }
         }
-    );
-
-    file.close();
+        out_file.write(output.data(), static_cast<std::streamsize>(output.size()));
+        out_file.close();
+    }
 }
 
 

{docstring_generator_ext-2.0.1 → docstring_generator_ext-2.0.2}/src/parser.hpp

@@ -39,6 +39,7 @@ std::vector<FunctionParameter> generate_function_parameters(
 
 void get_docstring_arg_descr(FunctionInfo &functionInfo) noexcept;
 
+
 void get_exception(
     const pybind11::object &function_body,
     py::module &ast_module,

docstring_generator_ext-2.0.1/src/GoogleDocstring.cpp

@@ -1,121 +0,0 @@
-#include "GoogleDocstring.hpp"
-
-#include "parser.hpp"
-
-void GoogleDocstring::check_current_docstring() noexcept {
-    auto current_py_tab = get_tabs();
-    auto google_args_begin = functionInfo.docstring.docstring.find("Args:");
-
-    if (google_args_begin < std::string::npos) {
-        functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
-            0,
-            google_args_begin - (current_py_tab.size() + 1)
-        );
-        functionInfo.docstring.end_line = functionInfo.docstring.start_line + google_args_begin;
-    }
-}
-
-std::string GoogleDocstring::docstringArgs() noexcept {
-    std::stringstream sstream;
-    auto current_py_tab = get_tabs();
-
-    if (!functionInfo.docstring.docstring.empty()) {
-        sstream << functionInfo.docstring.docstring;
-        sstream << "\n";
-    }
-
-    if (PY_TAB != current_py_tab) {
-        sstream << current_py_tab;
-        current_py_tab += PY_TAB;
-    } else {
-        sstream << PY_TAB;
-        current_py_tab = PY_TAB + PY_TAB;
-    }
-
-    sstream << "Args:\n";
-    std::ranges::for_each(functionInfo.args,
-        [&sstream, &current_py_tab](const FunctionParameter &val) {
-            sstream << current_py_tab << val.name;
-            if (!val.type.empty()) {
-                sstream << " (" << val.type;
-                if (!val.default_value.empty()) {
-                    sstream << ", optional";
-                }
-                sstream << ")";
-            }
-
-            if (!val.description.empty()) {
-                sstream << ": " << val.description;
-            }
-
-            if (!val.default_value.empty()) {
-                sstream << " (default is " << val.default_value << ")\n";
-            }
-        }
-    );
-
-    return sstream.str();
-}
-
-std::string GoogleDocstring::docstringReturn() noexcept {
-    std::stringstream sstream;
-    auto current_py_tab = get_tabs();
-
-    if (!functionInfo.returns.description.empty() || !functionInfo.returns.type.empty()) {
-        sstream << "\n";
-
-        if (PY_TAB != current_py_tab) {
-            sstream << PY_TAB;
-        } else {
-            sstream << PY_TAB;
-            current_py_tab = PY_TAB + PY_TAB;
-        }
-
-        sstream << "Returns:\n";
-        sstream << current_py_tab;
-
-        if (!functionInfo.returns.type.empty()) {
-            sstream << functionInfo.returns.type << ": ";
-        }
-        if (!functionInfo.returns.description.empty()) {
-            sstream << functionInfo.returns.description;
-        }
-    } else {
-        sstream << "";
-    }
-
-    return sstream.str();
-}
-
-std::string GoogleDocstring::docstringExceptions() noexcept {
-    if (functionInfo.exceptions.empty())
-        return "\n";
-
-    std::stringstream sstream;
-    auto current_py_tab = get_tabs();
-
-    sstream << "\n";
-
-    if (PY_TAB != current_py_tab) {
-        sstream << PY_TAB;
-    } else {
-        sstream << PY_TAB;
-        current_py_tab = PY_TAB + PY_TAB;
-    }
-
-    sstream << "Raises:\n";
-    sstream << current_py_tab;
-
-    for (const auto &[name, description] : functionInfo.exceptions) {
-        if (!name.empty()) {
-            sstream << name << ": ";
-        }
-        if (!description.empty()) {
-            sstream << description;
-        }
-
-        sstream << "\n";
-    }
-
-    return sstream.str();
-}

docstring_generator_ext-2.0.1/src/IDocstringFormat.cpp

@@ -1,32 +0,0 @@
-#include "IDocstringFormat.hpp"
-#include "parser.hpp"
-#include <sstream>
-
-[[ nodiscard ]] std::string DocstringFormat::docstring() noexcept {
-    std::stringstream sstream;
-    const auto current_pytab = get_tabs();
-
-    sstream << current_pytab << R"(""")";
-    if (functionInfo.docstring.docstring.empty()) {
-        sstream << "\n";
-    }
-    sstream << docstringArgs();
-    sstream << docstringReturn();
-    sstream << docstringExceptions();
-
-    sstream << current_pytab << R"(""")";
-    if (functionInfo.docstring.docstring.empty()) {
-        sstream << "\n";
-    }
-
-    return sstream.str();
-}
-
-[[ nodiscard ]] std::string DocstringFormat::get_tabs() const noexcept {
-    auto current_py_tab = PY_TAB;
-    for (uint32_t idx = 0; idx < (functionInfo.offset / 4); ++idx) {
-        current_py_tab += PY_TAB;
-    }
-
-    return current_py_tab;
-}