refactor: prefix helper functions with an underscore

Author: filipchristiansen

src/gitingest/exceptions.py

@@ -0,0 +1,6 @@
+class InvalidPatternError(ValueError):
+    def __init__(self, pattern: str) -> None:
+        super().__init__(
+            f"Pattern '{pattern}' contains invalid characters. Only alphanumeric characters, dash (-), "
+            "underscore (_), dot (.), forward slash (/), plus (+), and asterisk (*) are allowed."
+        )

src/gitingest/parse_query.py

@@ -5,12 +5,71 @@
 from typing import Any
 from urllib.parse import unquote
 
+from gitingest.exceptions import InvalidPatternError
 from gitingest.ignore_patterns import DEFAULT_IGNORE_PATTERNS
 
 TMP_BASE_PATH: str = "../tmp"
 HEX_DIGITS = set(string.hexdigits)
 
 
+def parse_query(
+    source: str,
+    max_file_size: int,
+    from_web: bool,
+    include_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+) -> dict[str, Any]:
+    """
+    Parses the input source to construct a query dictionary with specified parameters.
+
+    Parameters
+    ----------
+    source : str
+        The source URL or file path to parse.
+    max_file_size : int
+        The maximum file size in bytes to include.
+    from_web : bool
+        Flag indicating whether the source is a web URL.
+    include_patterns : Optional[Union[List[str], str]], optional
+        Patterns to include, by default None. Can be a list of strings or a single string.
+    ignore_patterns : Optional[Union[List[str], str]], optional
+        Patterns to ignore, by default None. Can be a list of strings or a single string.
+
+    Returns
+    -------
+    Dict[str, Any]
+        A dictionary containing the parsed query parameters, including 'max_file_size',
+        'ignore_patterns', and 'include_patterns'.
+    """
+    # Determine the parsing method based on the source type
+    if from_web or source.startswith("https://") or "github.com" in source:
+        query = _parse_url(source)
+    else:
+        query = _parse_path(source)
+
+    # Process ignore patterns
+    ignore_patterns_list = DEFAULT_IGNORE_PATTERNS.copy()
+    if ignore_patterns:
+        ignore_patterns_list += _parse_patterns(ignore_patterns)
+
+    # Process include patterns and override ignore patterns accordingly
+    if include_patterns:
+        parsed_include = _parse_patterns(include_patterns)
+        ignore_patterns_list = _override_ignore_patterns(ignore_patterns_list, include_patterns=parsed_include)
+    else:
+        parsed_include = None
+
+    # Update the query dictionary with max_file_size and processed patterns
+    query.update(
+        {
+            "max_file_size": max_file_size,
+            "ignore_patterns": ignore_patterns_list,
+            "include_patterns": parsed_include,
+        }
+    )
+    return query
+
+
 def _parse_url(url: str) -> dict[str, Any]:
     url = url.split(" ")[0]
     url = unquote(url)  # Decode URL-encoded characters
@@ -96,12 +155,13 @@ def _parse_patterns(pattern: list[str] | str) -> list[str]:
 
     Raises
     ------
-    ValueError
+    InvalidPatternError
         If any pattern contains invalid characters. Only alphanumeric characters,
         dash (-), underscore (_), dot (.), forward slash (/), plus (+), and
         asterisk (*) are allowed.
     """
     patterns = pattern if isinstance(pattern, list) else [pattern]
+    patterns = [p.strip() for p in patterns]
 
     parsed_patterns = []
     for p in patterns:
@@ -110,11 +170,8 @@ def _parse_patterns(pattern: list[str] | str) -> list[str]:
     parsed_patterns = [p for p in parsed_patterns if p != ""]
 
     for p in parsed_patterns:
-        if not all(c.isalnum() or c in "-_./+*" for c in p):
-            raise ValueError(
-                f"Pattern '{p}' contains invalid characters. Only alphanumeric characters, dash (-), "
-                "underscore (_), dot (.), forward slash (/), plus (+), and asterisk (*) are allowed."
-            )
+        if not _is_valid_pattern(p):
+            raise InvalidPatternError(p)
 
     return [_normalize_pattern(p) for p in parsed_patterns]
 
@@ -149,59 +206,18 @@ def _parse_path(path: str) -> dict[str, Any]:
     return query
 
 
-def parse_query(
-    source: str,
-    max_file_size: int,
-    from_web: bool,
-    include_patterns: list[str] | str | None = None,
-    ignore_patterns: list[str] | str | None = None,
-) -> dict[str, Any]:
+def _is_valid_pattern(pattern: str) -> bool:
     """
-    Parses the input source to construct a query dictionary with specified parameters.
+    _summary_
 
     Parameters
     ----------
-    source : str
-        The source URL or file path to parse.
-    max_file_size : int
-        The maximum file size in bytes to include.
-    from_web : bool
-        Flag indicating whether the source is a web URL.
-    include_patterns : Optional[Union[List[str], str]], optional
-        Patterns to include, by default None. Can be a list of strings or a single string.
-    ignore_patterns : Optional[Union[List[str], str]], optional
-        Patterns to ignore, by default None. Can be a list of strings or a single string.
+    pattern : str
+        _description_
 
     Returns
     -------
-    Dict[str, Any]
-        A dictionary containing the parsed query parameters, including 'max_file_size',
-        'ignore_patterns', and 'include_patterns'.
+    bool
+        _description_
     """
-    # Determine the parsing method based on the source type
-    if from_web or source.startswith("https://") or "github.com" in source:
-        query = _parse_url(source)
-    else:
-        query = _parse_path(source)
-
-    # Process ignore patterns
-    ignore_patterns_list = DEFAULT_IGNORE_PATTERNS.copy()
-    if ignore_patterns:
-        ignore_patterns_list += _parse_patterns(ignore_patterns)
-
-    # Process include patterns and override ignore patterns accordingly
-    if include_patterns:
-        parsed_include = _parse_patterns(include_patterns)
-        ignore_patterns_list = _override_ignore_patterns(ignore_patterns_list, include_patterns=parsed_include)
-    else:
-        parsed_include = None
-
-    # Update the query dictionary with max_file_size and processed patterns
-    query.update(
-        {
-            "max_file_size": max_file_size,
-            "ignore_patterns": ignore_patterns_list,
-            "include_patterns": parsed_include,
-        }
-    )
-    return query
+    return all(c.isalnum() or c in "-_./+*" for c in pattern)