Replace comments instead of whole functions (#217)

* replace comments only instead of functions

* fix tests

* add ci test

* version bump

* update prompt

* add newline to formats

* add newline to formats

* fix spaces

Author: CTY-git

.github/workflows/test.yml

@@ -71,6 +71,13 @@ jobs:
           --github_api_key=${{ secrets.SCM_GITHUB_KEY }} \
           --pr_url=https://github.com/patched-codes/patchwork/pull/${{ steps.findPr.outputs.number }}
 
+      - name: Generate Docstring
+        run: |
+          poetry run patchwork GenerateDocstring --log debug \
+          --openai_api_key=${{ secrets.OPENAI_KEY }} \
+          --github_api_key=${{ secrets.SCM_GITHUB_KEY }} \
+          --base_path=tests/cicd/generate_docstring
+
       - name: Generate README
         run: |
           # Specify the parent folder you want to check

patchwork/common/context_strategy/generic.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from .position import Position
-from .protocol import ContextStrategyProtocol
+from patchwork.common.context_strategy.langugues import GenericLanguage
+from patchwork.common.context_strategy.position import Position
+from patchwork.common.context_strategy.protocol import ContextStrategyProtocol
 
 
 class FullFileStrategy(ContextStrategyProtocol):
@@ -14,7 +15,7 @@ def get_contexts(self, src: list[str]) -> list[Position]:
         Returns:
             list[Position]: A list of Position objects representing the context of the source code.
         """
-        return [Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]))]
+        return [Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]), language=self.language)]
 
     def get_context_indexes(self, src: list[str], start: int, end: int) -> Position:
         """
@@ -28,7 +29,7 @@ def get_context_indexes(self, src: list[str], start: int, end: int) -> Position:
         Returns:
             Position: A Position object containing the calculated context indexes.
         """
-        return Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]))
+        return Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]), language=self.language)
 
     def is_file_supported(self, filename: str, src: list[str]) -> bool:
         """
@@ -43,6 +44,16 @@ def is_file_supported(self, filename: str, src: list[str]) -> bool:
         """
         return True
 
+    @property
+    def language(self) -> GenericLanguage:
+        """
+        Retrieve the language for the current context strategy.
+
+        Returns:
+            str: The language for the current context strategy.
+        """
+        return GenericLanguage()
+
 
 class NoopStrategy(ContextStrategyProtocol):
     def get_contexts(self, src: list[str]) -> list[Position]:
@@ -69,7 +80,7 @@ def get_context_indexes(self, src: list[str], start: int, end: int) -> Position:
         Returns:
             Position: The context position with start and end indexes and start_col and end_col values.
         """
-        return Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]))
+        return Position(start=0, end=len(src), start_col=0, end_col=len(src[-1]), language=self.language)
 
     def is_file_supported(self, filename: str, src: list[str]) -> bool:
         """
@@ -83,3 +94,13 @@ def is_file_supported(self, filename: str, src: list[str]) -> bool:
         bool: True if the file is restricted, False otherwise.
         """
         return True
+
+    @property
+    def language(self) -> GenericLanguage:
+        """
+        Retrieve the language for the current context strategy.
+
+        Returns:
+            str: The language for the current context strategy.
+        """
+        return GenericLanguage()

patchwork/common/context_strategy/java.py

@@ -1,3 +1,4 @@
+from patchwork.common.context_strategy.langugues import JavaLanguage
 from patchwork.common.context_strategy.protocol import TreeSitterStrategy
 
 
@@ -9,7 +10,7 @@ def __init__(self, query: str):
         Args:
         query (str): The search query string to be used for Java file search.
         """
-        super().__init__("java", query, [".java"])
+        super().__init__("java", query, [".java"], JavaLanguage())
         self.query = query
 
 

patchwork/common/context_strategy/javascript.py

@@ -1,3 +1,4 @@
+from patchwork.common.context_strategy.langugues import JavascriptLanguage
 from patchwork.common.context_strategy.protocol import TreeSitterStrategy
 
 _javascript_language = "typescript"
@@ -39,7 +40,7 @@ def __init__(self):
             _class_query (str): Query string used for class searches within JavaScript files.
             _javascript_exts (tuple): A tuple containing the file extensions for JavaScript files.
         """
-        super().__init__(_javascript_language, _class_query, _javascript_exts)
+        super().__init__(_javascript_language, _class_query, _javascript_exts, JavascriptLanguage())
 
 
 class JavascriptFunctionStrategy(TreeSitterStrategy):
@@ -55,7 +56,7 @@ def __init__(self):
         Returns:
         - None
         """
-        super().__init__(_javascript_language, _function_query, _javascript_exts)
+        super().__init__(_javascript_language, _function_query, _javascript_exts, JavascriptLanguage())
 
 
 class JavascriptBlockStrategy(TreeSitterStrategy):
@@ -68,7 +69,7 @@ def __init__(self):
         - _block_query (str): The query to block JavaScript functionalities.
         - _javascript_exts (list): List of JavaScript file extensions.
         """
-        super().__init__(_javascript_language, _block_query, _javascript_exts)
+        super().__init__(_javascript_language, _block_query, _javascript_exts, JavascriptLanguage())
 
 
 class JsxClassStrategy(TreeSitterStrategy):
@@ -81,7 +82,7 @@ def __init__(self):
         - _class_query (str): The class query parameter.
         - _jsx_exts (str): The JSX extensions parameter.
         """
-        super().__init__(_jsx_language, _class_query, _jsx_exts)
+        super().__init__(_jsx_language, _class_query, _jsx_exts, JavascriptLanguage())
 
 
 class JsxFunctionStrategy(TreeSitterStrategy):
@@ -94,7 +95,7 @@ def __init__(self):
         - _function_query (str): The query for functions.
         - _jsx_exts (str): The file extension for JSX files.
         """
-        super().__init__(_jsx_language, _function_query, _jsx_exts)
+        super().__init__(_jsx_language, _function_query, _jsx_exts, JavascriptLanguage())
 
 
 class JsxBlockStrategy(TreeSitterStrategy):
@@ -109,4 +110,4 @@ def __init__(self):
         Returns:
         - None
         """
-        super().__init__(_jsx_language, _block_query, _jsx_exts)
+        super().__init__(_jsx_language, _block_query, _jsx_exts, JavascriptLanguage())

patchwork/common/context_strategy/langugues.py

@@ -0,0 +1,108 @@
+from typing_extensions import Protocol
+
+
+class LanguageProtocol(Protocol):
+    @property
+    def docstring_format(self) -> str:
+        """
+        Retrieve the comment format for the language.
+
+        Returns:
+        str: The comment format for the language.
+        """
+        ...
+
+
+class GenericLanguage(LanguageProtocol):
+    def __init__(self):
+        """
+        Initialize the NoopLanguage instance.
+        """
+        self._comment_format = ""
+
+    @property
+    def docstring_format(self) -> str:
+        """
+        Retrieve the comment format for the language.
+
+        Returns:
+        str: The comment format for the language.
+        """
+        return self._comment_format
+
+
+class JavaLanguage(LanguageProtocol):
+    def __init__(self):
+        """
+        Initialize the JavaLanguage instance.
+        """
+        self._comment_format = """\
+/**
+* <Method description>
+* 
+* @param <Parameter name> <Parameter description>
+* @return <Return description>
+*/
+"""
+
+    @property
+    def docstring_format(self) -> str:
+        """
+        Retrieve the comment format for the language.
+
+        Returns:
+        str: The comment format for the language.
+        """
+        return self._comment_format
+
+
+class PythonLanguage(LanguageProtocol):
+    def __init__(self):
+        """
+        Initialize the PythonLanguage instance.
+        """
+        # This is currently google docstring format
+        self._comment_format = '''\
+"""<Method description>
+
+Args:
+    <Parameter name> <Parameter type>: <Parameter description>
+
+Returns:
+    <Return type>: <Return description>
+"""
+'''
+
+    @property
+    def docstring_format(self) -> str:
+        """
+        Retrieve the comment format for the language.
+
+        Returns:
+        str: The comment format for the language.
+        """
+        return self._comment_format
+
+
+class JavascriptLanguage(LanguageProtocol):
+    def __init__(self):
+        """
+        Initialize the JavascriptLanguage instance.
+        """
+        self._comment_format = """\
+/**
+ * <Method description>
+ * @param {<Parameter type>}  <Parameter Name> - <Parameter description>
+ * @returns {<Return type>} <Return description>
+ */
+"""
+
+    @property
+    def docstring_format(self) -> str:
+        """
+        Retrieve the comment format for the language.
+
+        Returns:
+        str: The comment format for the language.
+        """
+        return self._comment_format

patchwork/common/context_strategy/position.py

@@ -2,13 +2,16 @@
 
 from attrs import Factory, define
 
+from patchwork.common.context_strategy.langugues import LanguageProtocol
+
 
 @define
 class Position:
     start: int
     end: int
     start_col: int
     end_col: int
+    language: LanguageProtocol
     meta_positions: dict[str, "Position"] = Factory(dict)
 
     # def extract_lines(self, src: list[str]) -> list[str]:

patchwork/common/context_strategy/protocol.py

@@ -3,6 +3,7 @@
 from tree_sitter_languages.core import get_language, get_parser
 from typing_extensions import Protocol
 
+from patchwork.common.context_strategy.langugues import LanguageProtocol
 from patchwork.common.context_strategy.position import Position
 
 
@@ -47,20 +48,32 @@ def is_file_supported(self, filename: str, src: list[str]) -> bool:
         """
         ...
 
+    @property
+    def language(self) -> LanguageProtocol:
+        """
+        Retrieve the language for the current context strategy.
+
+        Returns:
+        str: The language for the current context strategy.
+        """
+        ...
+
 
 class TreeSitterStrategy(ContextStrategyProtocol):
-    def __init__(self, language: str, query: str, exts: list[str]):
+    def __init__(self, language: str, query: str, exts: list[str], language_protocol: LanguageProtocol):
         """
         Initialize the instance with specified language, query, and file extensions.
 
         Args:
             language (str): The programming language for the search.
             query (str): The search query.
             exts (list[str]): The list of file extensions to consider for the search.
+            language_protocol (LanguageProtocol): The language protocol associated.
         """
-        self.language = language
+        self.tree_sitter_language = language
         self.query = query
         self.exts = exts
+        self.language_protocol = language_protocol
 
     def query_src(self, src: list[str]):
         """
@@ -72,8 +85,8 @@ def query_src(self, src: list[str]):
         Returns:
         list: Returns a list of captures that match the query in the source code's abstract syntax tree (AST).
         """
-        language = get_language(self.language)
-        parser = get_parser(self.language)
+        language = get_language(self.tree_sitter_language)
+        parser = get_parser(self.tree_sitter_language)
         tree = parser.parse("".join(src).encode("utf-8-sig"))
         return language.query(self.query).captures(tree.root_node)
 
@@ -100,6 +113,7 @@ def get_contexts(self, src: list[str]) -> list[Position]:
                 end=node.end_point[0] + 1,
                 start_col=node.start_point[1],
                 end_col=node.end_point[1] + 1,
+                language=self.language,
             )
             positions.append(position)
 
@@ -115,6 +129,7 @@ def get_contexts(self, src: list[str]) -> list[Position]:
                         end=node.end_point[0] + 1,
                         start_col=node.start_point[1],
                         end_col=node.end_point[1] + 1,
+                        language=self.language,
                     )
                     break
 
@@ -150,3 +165,7 @@ def is_file_supported(self, filename: str, src: list[str]) -> bool:
         bool: True if the file's extension is in the list of supported extensions and `src` is not empty, otherwise False.
         """
         return any(filename.endswith(ext) for ext in self.exts) and len(src) > 0
+
+    @property
+    def language(self) -> LanguageProtocol:
+        return self.language_protocol

patchwork/common/context_strategy/python.py

@@ -16,6 +16,7 @@
 
 from patchwork.common.context_strategy.position import Position
 
+from .langugues import PythonLanguage
 from .protocol import ContextStrategyProtocol
 
 
@@ -58,6 +59,7 @@ def _visit(self, node: libcst.CSTNode) -> Position:
             end=code_range.end.line,
             start_col=code_range.start.column - 1,
             end_col=code_range.end.column,
+            language=PythonLanguage(),
         )
         self.positions.append(position)
         return position
@@ -98,6 +100,7 @@ def visit_FunctionDef(self, node: FunctionDef) -> Optional[bool]:
                 end=code_range.end.line,
                 start_col=code_range.start.column - 1,
                 end_col=code_range.end.column,
+                language=PythonLanguage(),
             )
             position.meta_positions["comment"] = comment_position
         return True
@@ -226,6 +229,10 @@ def is_file_supported(self, filename: str, src: list[str]) -> bool:
             return False
         return filename.endswith(".py") and len(src) > 0
 
+    @property
+    def language(self) -> PythonLanguage:
+        return PythonLanguage()
+
 
 class PythonFunctionStrategy(PythonStrategy):
     def __init__(self):