janito 3.1.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/tools/search_text/match_lines.py

@@ -0,0 +1,67 @@
+import re
+from janito.gitignore_utils import GitignoreFilter
+import os
+
+
+def is_binary_file(path, blocksize=1024):
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(blocksize)
+            if b"\0" in chunk:
+                return True
+            text_characters = bytearray(
+                {7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100))
+            )
+            nontext = chunk.translate(None, text_characters)
+            if len(nontext) / max(1, len(chunk)) > 0.3:
+                return True
+    except Exception:
+        return True
+    return False
+
+
+def match_line(line, query, regex, use_regex, case_sensitive):
+    if use_regex:
+        return regex and regex.search(line)
+    if not case_sensitive:
+        return query.lower() in line.lower()
+    return query in line
+
+
+def should_limit(max_results, total_results, match_count, count_only, dir_output):
+    if max_results > 0:
+        current_count = total_results + (match_count if count_only else len(dir_output))
+        return current_count >= max_results
+    return False
+
+
+def read_file_lines(
+    path,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    count_only,
+    max_results,
+    total_results,
+):
+    dir_output = []
+    dir_limit_reached = False
+    match_count = 0
+    if not is_binary_file(path):
+        try:
+            open_kwargs = {"mode": "r", "encoding": "utf-8"}
+            with open(path, **open_kwargs) as f:
+                for lineno, line in enumerate(f, 1):
+                    if match_line(line, query, regex, use_regex, case_sensitive):
+                        match_count += 1
+                        if not count_only:
+                            dir_output.append(f"{path}:{lineno}: {line.rstrip()}")
+                    if should_limit(
+                        max_results, total_results, match_count, count_only, dir_output
+                    ):
+                        dir_limit_reached = True
+                        break
+        except Exception:
+            pass
+    return match_count, dir_limit_reached, dir_output

janito/plugins_backup_20250825_070018/tools/search_text/pattern_utils.py

@@ -0,0 +1,73 @@
+import re
+from janito.i18n import tr
+from janito.tools.tool_utils import pluralize
+
+
+def prepare_pattern(pattern, is_regex, case_sensitive, report_error, report_warning):
+    if not pattern:
+        report_error(
+            tr("Error: Empty search pattern provided. Operation aborted."),
+            ReportAction.SEARCH,
+        )
+        return (
+            None,
+            False,
+            tr("Error: Empty search pattern provided. Operation aborted."),
+        )
+    regex = None
+    use_regex = False
+    if is_regex:
+        try:
+            flags = 0
+            if not case_sensitive:
+                flags |= re.IGNORECASE
+            regex = re.compile(pattern, flags=flags)
+            use_regex = True
+        except re.error as e:
+            report_warning(tr("⚠️ Invalid regex pattern."))
+            return (
+                None,
+                False,
+                tr(
+                    "Error: Invalid regex pattern: {error}. Operation aborted.", error=e
+                ),
+            )
+    else:
+        # Do not compile as regex if is_regex is False; treat as plain text
+        regex = None
+        use_regex = False
+        if not case_sensitive:
+            pattern = pattern.lower()
+    return regex, use_regex, None
+
+
+def format_result(
+    query, use_regex, output, limit_reached, count_only=False, per_file_counts=None
+):
+    # Ensure output is always a list for joining
+    if output is None or not isinstance(output, (list, tuple)):
+        output = []
+    if count_only:
+        lines = []
+        total = 0
+        if per_file_counts:
+            for path, count in per_file_counts:
+                lines.append(f"{path}: {count}")
+                total += count
+        lines.append(f"Total matches: {total}")
+        if limit_reached:
+            lines.append(tr("[Max results reached. Output truncated.]"))
+        return "\n".join(lines)
+    else:
+        if not output:
+            return tr("No matches found.")
+        result = "\n".join(output)
+        if limit_reached:
+            result += tr("\n[Max results reached. Output truncated.]")
+        return result
+
+
+def summarize_total(all_per_file_counts):
+    total = sum(count for _, count in all_per_file_counts)
+    summary = f"\nGrand total matches: {total}"
+    return summary

janito/plugins_backup_20250825_070018/tools/search_text/traverse_directory.py

@@ -0,0 +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(
+    path,
+    per_file_counts,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    match_count, file_limit_reached, _ = read_file_lines(
+        path,
+        query,
+        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((path, match_count))
+    return file_limit_reached
+
+
+def process_file_collect(
+    path,
+    dir_output,
+    per_file_counts,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
+        path,
+        query,
+        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((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,
+    query,
+    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:
+            path = os.path.join(root, file)
+            if gitignore_filter.is_ignored(path):
+                continue
+            if count_only:
+                file_limit_reached = process_file_count_only(
+                    path,
+                    per_file_counts,
+                    query,
+                    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(
+                    path,
+                    dir_output,
+                    per_file_counts,
+                    query,
+                    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/plugins_backup_20250825_070018/tools/validate_file_syntax/css_validator.py

@@ -0,0 +1,35 @@
+from janito.i18n import tr
+import re
+
+
+def validate_css(path: str) -> str:
+    with open(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"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/html_validator.py

@@ -0,0 +1,100 @@
+from janito.i18n import tr
+import re
+
+try:
+    from lxml import etree
+except ImportError:
+    etree = None
+
+
+def validate_html(path: str) -> str:
+    html_content = _read_html_content(path)
+    warnings = _find_js_outside_script(html_content)
+    lxml_error = _parse_html_and_collect_errors(path)
+    msg = _build_result_message(warnings, lxml_error)
+    return msg
+
+
+def _read_html_content(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _find_js_outside_script(html_content):
+    script_blocks = [
+        m.span()
+        for m in re.finditer(
+            r"<script[\s\S]*?>[\s\S]*?<\/script>", html_content, re.IGNORECASE
+        )
+    ]
+    js_patterns = [
+        r"document\.addEventListener",
+        r"^\s*(var|let|const)\s+\w+\s*[=;]",
+        r"^\s*function\s+\w+\s*\(",
+        r"^\s*(const|let|var)\s+\w+\s*=\s*\(.*\)\s*=>",
+        r"^\s*window\.\w+\s*=",
+        r"^\s*\$\s*\(",
+    ]
+    warnings = []
+    for pat in js_patterns:
+        for m in re.finditer(pat, html_content):
+            in_script = False
+            for s_start, s_end in script_blocks:
+                if s_start <= m.start() < s_end:
+                    in_script = True
+                    break
+            if not in_script:
+                warnings.append(
+                    f"Line {html_content.count(chr(10), 0, m.start())+1}: JavaScript code ('{pat}') found outside <script> tag."
+                )
+    return warnings
+
+
+def _parse_html_and_collect_errors(path):
+    lxml_error = None
+    if etree is None:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+        return lxml_error
+    try:
+        parser = etree.HTMLParser(recover=False)
+        with open(path, "rb") as f:
+            etree.parse(f, parser=parser)
+        error_log = parser.error_log
+        syntax_errors = []
+        for e in error_log:
+            if (
+                "mismatch" in e.message.lower()
+                or "tag not closed" in e.message.lower()
+                or "unexpected end tag" in e.message.lower()
+                or "expected" in e.message.lower()
+            ):
+                syntax_errors.append(str(e))
+        if syntax_errors:
+            lxml_error = tr("Syntax error: {error}", error="; ".join(syntax_errors))
+        elif error_log:
+            lxml_error = tr(
+                "HTML syntax errors found:\n{errors}",
+                errors="\n".join(str(e) for e in error_log),
+            )
+    except ImportError:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+    except Exception as e:
+        lxml_error = tr("Syntax error: {error}", error=str(e))
+    return lxml_error
+
+
+def _build_result_message(warnings, lxml_error):
+    msg = ""
+    if warnings:
+        msg += (
+            tr(
+                "⚠️ Warning: JavaScript code found outside <script> tags. This is invalid HTML and will not execute in browsers.\n"
+                + "\n".join(warnings)
+            )
+            + "\n"
+        )
+    if lxml_error:
+        msg += lxml_error
+    if msg:
+        return msg.strip()
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/jinja2_validator.py

@@ -0,0 +1,50 @@
+"""Jinja2 template syntax validator."""
+
+import os
+from janito.i18n import tr
+
+
+def validate_jinja2(path: str) -> str:
+    """Validate Jinja2 template syntax."""
+    try:
+        from jinja2 import Environment, TemplateSyntaxError
+
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Create a Jinja2 environment and try to parse the template
+        env = Environment()
+        try:
+            env.parse(content)
+            return tr("✅ Syntax OK")
+        except TemplateSyntaxError as e:
+            line_num = getattr(e, "lineno", 0)
+            return tr(
+                "⚠️ Warning: Syntax error: {error} at line {line}",
+                error=str(e),
+                line=line_num,
+            )
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))
+
+    except ImportError:
+        # If jinja2 is not available, just check basic structure
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Basic checks for common Jinja2 syntax issues
+            open_tags = content.count("{%")
+            close_tags = content.count("%}")
+            open_vars = content.count("{{")
+            close_vars = content.count("}}")
+
+            if open_tags != close_tags:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 tags")
+            if open_vars != close_vars:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 variables")
+
+            return tr("✅ Syntax OK (basic validation)")
+
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/js_validator.py

@@ -0,0 +1,27 @@
+from janito.i18n import tr
+import re
+
+
+def validate_js(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    if content.count("(") != content.count(")"):
+        errors.append("Unmatched parentheses ( )")
+    if content.count("[") != content.count("]"):
+        errors.append("Unmatched brackets [ ]")
+    for quote in ["'", '"', "`"]:
+        unescaped = re.findall(rf"(?<!\\){quote}", content)
+        if len(unescaped) % 2 != 0:
+            errors.append(f"Unclosed string literal ({quote}) detected")
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed block comment (/* ... */)")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: JavaScript syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/json_validator.py

@@ -0,0 +1,6 @@
+def validate_json(path: str) -> str:
+    import json
+
+    with open(path, "r", encoding="utf-8") as f:
+        json.load(f)
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/markdown_validator.py

@@ -0,0 +1,109 @@
+from janito.i18n import tr
+import re
+
+
+def validate_markdown(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    lines = content.splitlines()
+    errors = []
+    errors.extend(_check_header_space(lines))
+    errors.extend(_check_unclosed_code_block(content))
+    errors.extend(_check_unclosed_links_images(lines))
+    errors.extend(_check_list_formatting(lines))
+    errors.extend(_check_unclosed_inline_code(content))
+    return _build_markdown_result(errors)
+
+
+def _check_header_space(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if re.match(r"^#+[^ #]", line):
+            errors.append(f"Line {i}: Header missing space after # | {line.strip()}")
+    return errors
+
+
+def _check_unclosed_code_block(content):
+    errors = []
+    if content.count("```") % 2 != 0:
+        errors.append("Unclosed code block (```) detected")
+    return errors
+
+
+def _check_unclosed_links_images(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if re.search(r"\[[^\]]*\]\([^)]+$", line):
+            errors.append(
+                f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
+            )
+    return errors
+
+
+def _is_table_line(line):
+    return line.lstrip().startswith("|")
+
+
+def _list_item_missing_space(line):
+    return re.match(r"^[-*+][^ \n]", line)
+
+
+def _should_skip_list_item(line):
+    stripped = line.strip()
+    return stripped.startswith("*") and stripped.endswith("*") and len(stripped) > 2
+
+
+def _needs_blank_line_before_bullet(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
+    return not prev_is_list and prev_line.strip() != ""
+
+
+def _needs_blank_line_before_numbered(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
+    return not prev_is_numbered_list and prev_line.strip() != ""
+
+
+def _check_list_formatting(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if _is_table_line(line):
+            continue
+        if _list_item_missing_space(line):
+            if not _should_skip_list_item(line):
+                errors.append(
+                    f"Line {i}: List item missing space after bullet | {line.strip()}"
+                )
+        if re.match(r"^\s*[-*+] ", line):
+            if _needs_blank_line_before_bullet(lines, i):
+                errors.append(
+                    f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
+        if re.match(r"^\s*\d+\. ", line):
+            if _needs_blank_line_before_numbered(lines, i):
+                errors.append(
+                    f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
+    return errors
+
+
+def _check_unclosed_inline_code(content):
+    errors = []
+    if content.count("`") % 2 != 0:
+        errors.append("Unclosed inline code (`) detected")
+    return errors
+
+
+def _build_markdown_result(errors):
+    if errors:
+        msg = tr(
+            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/ps1_validator.py

@@ -0,0 +1,32 @@
+from janito.i18n import tr
+import re
+
+
+def validate_ps1(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    # Unmatched curly braces
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    # Unmatched parentheses
+    if content.count("(") != content.count(")"):
+        errors.append("Unmatched parentheses ( )")
+    # Unmatched brackets
+    if content.count("[") != content.count("]"):
+        errors.append("Unmatched brackets [ ]")
+    # Unclosed string literals
+    for quote in ["'", '"']:
+        unescaped = re.findall(rf"(?<!\\){quote}", content)
+        if len(unescaped) % 2 != 0:
+            errors.append(f"Unclosed string literal ({quote}) detected")
+    # Unclosed block comments <# ... #>
+    if content.count("<#") != content.count("#>"):
+        errors.append("Unclosed block comment (<# ... #>)")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: PowerShell syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/python_validator.py

@@ -0,0 +1,5 @@
+def validate_python(path: str) -> str:
+    import py_compile
+
+    py_compile.compile(path, doraise=True)
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/xml_validator.py

@@ -0,0 +1,11 @@
+from janito.i18n import tr
+
+
+def validate_xml(path: str) -> str:
+    try:
+        from lxml import etree
+    except ImportError:
+        return tr("⚠️ lxml not installed. Cannot validate XML.")
+    with open(path, "rb") as f:
+        etree.parse(f)
+    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/yaml_validator.py

@@ -0,0 +1,6 @@
+def validate_yaml(path: str) -> str:
+    import yaml
+
+    with open(path, "r", encoding="utf-8") as f:
+        yaml.safe_load(f)
+    return "✅ OK"

janito/plugins_backup_20250825_070018/ui/__init__.py

@@ -0,0 +1,7 @@
+"""
+User Interface Plugin Package
+
+Contains user interaction and interface tools.
+"""
+
+__all__ = ["userinterface"]