janito 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/tools/adapters/local/search_text/traverse_directory.py

@@ -1,145 +1,145 @@
-import os
-from janito.gitignore_utils import GitignoreFilter
-from .match_lines import match_line, should_limit, read_file_lines
-
-
-def walk_directory(search_path, max_depth):
-    if max_depth == 1:
-        walk_result = next(os.walk(search_path), None)
-        if walk_result is None:
-            return [(search_path, [], [])]
-        else:
-            return [walk_result]
-    else:
-        return os.walk(search_path)
-
-
-def filter_dirs(dirs, root, gitignore_filter):
-    # Always exclude directories named .git, regardless of gitignore
-    return [
-        d
-        for d in dirs
-        if d != ".git" and not gitignore_filter.is_ignored(os.path.join(root, d))
-    ]
-
-
-def process_file_count_only(
-    file_path,
-    per_file_counts,
-    pattern,
-    regex,
-    use_regex,
-    case_sensitive,
-    max_results,
-    total_results,
-):
-    match_count, file_limit_reached, _ = read_file_lines(
-        file_path,
-        pattern,
-        regex,
-        use_regex,
-        case_sensitive,
-        True,
-        max_results,
-        total_results + sum(count for _, count in per_file_counts),
-    )
-    if match_count > 0:
-        per_file_counts.append((file_path, match_count))
-    return file_limit_reached
-
-
-def process_file_collect(
-    file_path,
-    dir_output,
-    per_file_counts,
-    pattern,
-    regex,
-    use_regex,
-    case_sensitive,
-    max_results,
-    total_results,
-):
-    actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
-        file_path,
-        pattern,
-        regex,
-        use_regex,
-        case_sensitive,
-        False,
-        max_results,
-        total_results + len(dir_output),
-    )
-    dir_output.extend(file_lines_output)
-    if actual_match_count > 0:
-        per_file_counts.append((file_path, actual_match_count))
-    return file_limit_reached
-
-
-def should_limit_depth(root, search_path, max_depth, dirs):
-    if max_depth > 0:
-        rel_root = os.path.relpath(root, search_path)
-        if rel_root != ".":
-            depth = rel_root.count(os.sep) + 1
-            if depth >= max_depth:
-                del dirs[:]
-
-
-def traverse_directory(
-    search_path,
-    pattern,
-    regex,
-    use_regex,
-    case_sensitive,
-    max_depth,
-    max_results,
-    total_results,
-    count_only,
-):
-    dir_output = []
-    dir_limit_reached = False
-    per_file_counts = []
-    walker = walk_directory(search_path, max_depth)
-    gitignore_filter = GitignoreFilter(search_path)
-
-    for root, dirs, files in walker:
-        dirs[:] = filter_dirs(dirs, root, gitignore_filter)
-        for file in files:
-            file_path = os.path.join(root, file)
-            if gitignore_filter.is_ignored(file_path):
-                continue
-            if count_only:
-                file_limit_reached = process_file_count_only(
-                    file_path,
-                    per_file_counts,
-                    pattern,
-                    regex,
-                    use_regex,
-                    case_sensitive,
-                    max_results,
-                    total_results,
-                )
-                if file_limit_reached:
-                    dir_limit_reached = True
-                    break
-            else:
-                file_limit_reached = process_file_collect(
-                    file_path,
-                    dir_output,
-                    per_file_counts,
-                    pattern,
-                    regex,
-                    use_regex,
-                    case_sensitive,
-                    max_results,
-                    total_results,
-                )
-                if file_limit_reached:
-                    dir_limit_reached = True
-                    break
-        if dir_limit_reached:
-            break
-        should_limit_depth(root, search_path, max_depth, dirs)
-    if count_only:
-        return per_file_counts, dir_limit_reached, []
-    else:
-        return dir_output, dir_limit_reached, per_file_counts
+import os
+from janito.gitignore_utils import GitignoreFilter
+from .match_lines import match_line, should_limit, read_file_lines
+
+
+def walk_directory(search_path, max_depth):
+    if max_depth == 1:
+        walk_result = next(os.walk(search_path), None)
+        if walk_result is None:
+            return [(search_path, [], [])]
+        else:
+            return [walk_result]
+    else:
+        return os.walk(search_path)
+
+
+def filter_dirs(dirs, root, gitignore_filter):
+    # Always exclude directories named .git, regardless of gitignore
+    return [
+        d
+        for d in dirs
+        if d != ".git" and not gitignore_filter.is_ignored(os.path.join(root, d))
+    ]
+
+
+def process_file_count_only(
+    file_path,
+    per_file_counts,
+    pattern,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    match_count, file_limit_reached, _ = read_file_lines(
+        file_path,
+        pattern,
+        regex,
+        use_regex,
+        case_sensitive,
+        True,
+        max_results,
+        total_results + sum(count for _, count in per_file_counts),
+    )
+    if match_count > 0:
+        per_file_counts.append((file_path, match_count))
+    return file_limit_reached
+
+
+def process_file_collect(
+    file_path,
+    dir_output,
+    per_file_counts,
+    pattern,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
+        file_path,
+        pattern,
+        regex,
+        use_regex,
+        case_sensitive,
+        False,
+        max_results,
+        total_results + len(dir_output),
+    )
+    dir_output.extend(file_lines_output)
+    if actual_match_count > 0:
+        per_file_counts.append((file_path, actual_match_count))
+    return file_limit_reached
+
+
+def should_limit_depth(root, search_path, max_depth, dirs):
+    if max_depth > 0:
+        rel_root = os.path.relpath(root, search_path)
+        if rel_root != ".":
+            depth = rel_root.count(os.sep) + 1
+            if depth >= max_depth:
+                del dirs[:]
+
+
+def traverse_directory(
+    search_path,
+    pattern,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_depth,
+    max_results,
+    total_results,
+    count_only,
+):
+    dir_output = []
+    dir_limit_reached = False
+    per_file_counts = []
+    walker = walk_directory(search_path, max_depth)
+    gitignore_filter = GitignoreFilter(search_path)
+
+    for root, dirs, files in walker:
+        dirs[:] = filter_dirs(dirs, root, gitignore_filter)
+        for file in files:
+            file_path = os.path.join(root, file)
+            if gitignore_filter.is_ignored(file_path):
+                continue
+            if count_only:
+                file_limit_reached = process_file_count_only(
+                    file_path,
+                    per_file_counts,
+                    pattern,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+            else:
+                file_limit_reached = process_file_collect(
+                    file_path,
+                    dir_output,
+                    per_file_counts,
+                    pattern,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+        if dir_limit_reached:
+            break
+        should_limit_depth(root, search_path, max_depth, dirs)
+    if count_only:
+        return per_file_counts, dir_limit_reached, []
+    else:
+        return dir_output, dir_limit_reached, per_file_counts

janito/tools/adapters/local/validate_file_syntax/__init__.py

@@ -1 +1 @@
-# Validation syntax package
+# Validation syntax package

janito/tools/adapters/local/validate_file_syntax/core.py

@@ -1,106 +1,106 @@
-import os
-from janito.i18n import tr
-from janito.tools.tool_base import ToolBase
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_utils import display_path
-from janito.tools.adapters.local.adapter import register_local_tool as register_tool
-
-from .python_validator import validate_python
-from .json_validator import validate_json
-from .yaml_validator import validate_yaml
-from .ps1_validator import validate_ps1
-from .xml_validator import validate_xml
-from .html_validator import validate_html
-from .markdown_validator import validate_markdown
-from .js_validator import validate_js
-from .css_validator import validate_css
-
-
-def _get_validator(ext):
-    """Return the appropriate validator function for the file extension."""
-    mapping = {
-        ".py": validate_python,
-        ".pyw": validate_python,
-        ".json": validate_json,
-        ".yml": validate_yaml,
-        ".yaml": validate_yaml,
-        ".ps1": validate_ps1,
-        ".xml": validate_xml,
-        ".html": validate_html,
-        ".htm": validate_html,
-        ".md": validate_markdown,
-        ".js": validate_js,
-        ".css": validate_css,
-    }
-    return mapping.get(ext)
-
-
-def _handle_validation_error(e, report_warning):
-    msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
-    if report_warning:
-        report_warning(msg)
-    return msg
-
-
-def validate_file_syntax(
-    file_path: str, report_info=None, report_warning=None, report_success=None
-) -> str:
-    ext = os.path.splitext(file_path)[1].lower()
-    validator = _get_validator(ext)
-    try:
-        if validator:
-            return validator(file_path)
-        else:
-            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
-            if report_warning:
-                report_warning(msg)
-            return msg
-    except Exception as e:
-        return _handle_validation_error(e, report_warning)
-
-
-class ValidateFileSyntaxTool(ToolBase):
-    """
-    Validate a file for syntax issues.
-
-    Supported types:
-      - Python (.py, .pyw)
-      - JSON (.json)
-      - YAML (.yml, .yaml)
-      - PowerShell (.ps1)
-      - XML (.xml)
-      - HTML (.html, .htm) [lxml]
-      - Markdown (.md)
-      - JavaScript (.js)
-
-    Args:
-        file_path (str): Path to the file to validate.
-    Returns:
-        str: Validation status message. Example:
-            - "✅ Syntax OK"
-            - "⚠️ Warning: Syntax error: <error message>"
-            - "⚠️ Warning: Unsupported file extension: <ext>"
-    """
-
-    tool_name = "validate_file_syntax"
-
-    def run(self, file_path: str) -> str:
-        disp_path = display_path(file_path)
-        self.report_action(
-            tr(
-                "🔎 Validate syntax for file '{disp_path}' ...",
-                disp_path=disp_path,
-            ),
-            ReportAction.READ,
-        )
-        result = validate_file_syntax(
-            file_path,
-            report_info=self.report_info,
-            report_warning=self.report_warning,
-            report_success=self.report_success,
-        )
-        if result.startswith("✅"):
-            self.report_success(result, ReportAction.READ)
-
-        return result
+import os
+from janito.i18n import tr
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+
+from .python_validator import validate_python
+from .json_validator import validate_json
+from .yaml_validator import validate_yaml
+from .ps1_validator import validate_ps1
+from .xml_validator import validate_xml
+from .html_validator import validate_html
+from .markdown_validator import validate_markdown
+from .js_validator import validate_js
+from .css_validator import validate_css
+
+
+def _get_validator(ext):
+    """Return the appropriate validator function for the file extension."""
+    mapping = {
+        ".py": validate_python,
+        ".pyw": validate_python,
+        ".json": validate_json,
+        ".yml": validate_yaml,
+        ".yaml": validate_yaml,
+        ".ps1": validate_ps1,
+        ".xml": validate_xml,
+        ".html": validate_html,
+        ".htm": validate_html,
+        ".md": validate_markdown,
+        ".js": validate_js,
+        ".css": validate_css,
+    }
+    return mapping.get(ext)
+
+
+def _handle_validation_error(e, report_warning):
+    msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
+    if report_warning:
+        report_warning(msg)
+    return msg
+
+
+def validate_file_syntax(
+    file_path: str, report_info=None, report_warning=None, report_success=None
+) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    validator = _get_validator(ext)
+    try:
+        if validator:
+            return validator(file_path)
+        else:
+            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
+            if report_warning:
+                report_warning(msg)
+            return msg
+    except Exception as e:
+        return _handle_validation_error(e, report_warning)
+
+
+class ValidateFileSyntaxTool(ToolBase):
+    """
+    Validate a file for syntax issues.
+
+    Supported types:
+      - Python (.py, .pyw)
+      - JSON (.json)
+      - YAML (.yml, .yaml)
+      - PowerShell (.ps1)
+      - XML (.xml)
+      - HTML (.html, .htm) [lxml]
+      - Markdown (.md)
+      - JavaScript (.js)
+
+    Args:
+        file_path (str): Path to the file to validate.
+    Returns:
+        str: Validation status message. Example:
+            - "✅ Syntax OK"
+            - "⚠️ Warning: Syntax error: <error message>"
+            - "⚠️ Warning: Unsupported file extension: <ext>"
+    """
+
+    tool_name = "validate_file_syntax"
+
+    def run(self, file_path: str) -> str:
+        disp_path = display_path(file_path)
+        self.report_action(
+            tr(
+                "🔎 Validate syntax for file '{disp_path}' ...",
+                disp_path=disp_path,
+            ),
+            ReportAction.READ,
+        )
+        result = validate_file_syntax(
+            file_path,
+            report_info=self.report_info,
+            report_warning=self.report_warning,
+            report_success=self.report_success,
+        )
+        if result.startswith("✅"):
+            self.report_success(result, ReportAction.READ)
+
+        return result

janito/tools/adapters/local/validate_file_syntax/css_validator.py

@@ -1,35 +1,35 @@
-from janito.i18n import tr
-import re
-
-
-def validate_css(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    errors = []
-    # Check for unmatched curly braces
-    if content.count("{") != content.count("}"):
-        errors.append("Unmatched curly braces { }")
-    # Check for unclosed comments
-    if content.count("/*") != content.count("*/"):
-        errors.append("Unclosed comment (/* ... */)")
-    # Check for invalid property declarations (very basic)
-    for i, line in enumerate(content.splitlines(), 1):
-        # Ignore empty lines and comments
-        if not line.strip() or line.strip().startswith("/*"):
-            continue
-        # Match property: value; (allow whitespace)
-        if ":" in line and not re.search(r":.*;", line):
-            errors.append(
-                f"Line {i}: Missing semicolon after property value | {line.strip()}"
-            )
-        # Match lines with property but missing colon
-        if ";" in line and ":" not in line:
-            errors.append(
-                f"Line {i}: Missing colon in property declaration | {line.strip()}"
-            )
-    if errors:
-        msg = tr(
-            "⚠️ Warning: CSS syntax issues found:\n{errors}", errors="\n".join(errors)
-        )
-        return msg
-    return "✅ OK"
+from janito.i18n import tr
+import re
+
+
+def validate_css(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    # Check for unmatched curly braces
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    # Check for unclosed comments
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed comment (/* ... */)")
+    # Check for invalid property declarations (very basic)
+    for i, line in enumerate(content.splitlines(), 1):
+        # Ignore empty lines and comments
+        if not line.strip() or line.strip().startswith("/*"):
+            continue
+        # Match property: value; (allow whitespace)
+        if ":" in line and not re.search(r":.*;", line):
+            errors.append(
+                f"Line {i}: Missing semicolon after property value | {line.strip()}"
+            )
+        # Match lines with property but missing colon
+        if ";" in line and ":" not in line:
+            errors.append(
+                f"Line {i}: Missing colon in property declaration | {line.strip()}"
+            )
+    if errors:
+        msg = tr(
+            "⚠️ Warning: CSS syntax issues found:\n{errors}", errors="\n".join(errors)
+        )
+        return msg
+    return "✅ OK"