adding more tests, refactoring

Author: nikolay-e

requirements.txt

@@ -4,3 +4,4 @@ pathspec
 build
 twine
 pyinstaller
+pytest-cov

setup.cfg

@@ -18,12 +18,28 @@ package_dir =
 packages = find:
 python_requires = >=3.9
 install_requires =
-    pathspec
-    pyyaml
+    pathspec>=0.9
+    pyyaml>=5.4
 
 [options.packages.find]
 where = src
 
 [options.entry_points]
 console_scripts =
-    treemapper = treemapper.treemapper:main
+    treemapper = treemapper.treemapper:main
+
+[options.extras_require]
+dev =
+    pytest>=7.0
+    pytest-cov>=3.0
+    build>=0.10
+    twine>=4.0
+    pyinstaller>=5.0
+    flake8>=5.0
+    black>=23.0
+    isort>=5.10
+    mypy>=1.0
+    types-PyYAML
+    types-pathspec
+    pyyaml
+    pathspec

src/treemapper/cli.py

@@ -1,12 +1,14 @@
+# src/treemapper/cli.py
 import argparse
 import sys
 from pathlib import Path
 from typing import Tuple
 
 
-def parse_args() -> Tuple[Path, Path, Path, bool, int]:
+def parse_args() -> Tuple[Path | None, Path | None, Path | None, bool, int]:
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
+        prog='treemapper', # <--- ДОБАВЛЕНО ЭТО
         description="Generate a YAML representation of a directory structure.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 
@@ -29,7 +31,7 @@ def parse_args() -> Tuple[Path, Path, Path, bool, int]:
     parser.add_argument(
         "--no-default-ignores",
         action="store_true",
-        help="Disable all default ignores (including .gitignore and .treemapperignore)")
+        help="Disable default ignores (.treemapperignore, .gitignore, output file)") # Уточнено описание
 
     parser.add_argument(
         "-v", "--verbosity",
@@ -41,15 +43,32 @@ def parse_args() -> Tuple[Path, Path, Path, bool, int]:
 
     args = parser.parse_args()
 
-    root_dir = Path(args.directory).resolve()
-    if not root_dir.is_dir():
-        print(f"Error: The path '{root_dir}' is not a valid directory.")
-        sys.exit(1)
+    # Проверяем директорию
+    try:
+        root_dir = Path(args.directory).resolve(strict=True) # strict=True проверит существование
+        if not root_dir.is_dir():
+            # Эта проверка может быть избыточна с strict=True, но оставим для ясности
+            print(f"Error: The path '{root_dir}' is not a valid directory.", file=sys.stderr)
+            sys.exit(1)
+    except FileNotFoundError:
+         print(f"Error: The directory '{args.directory}' does not exist.", file=sys.stderr)
+         sys.exit(1)
+    except Exception as e: # Другие возможные ошибки resolve
+         print(f"Error resolving directory path '{args.directory}': {e}", file=sys.stderr)
+         sys.exit(1)
 
+    # Обрабатываем путь к файлу вывода
     output_file = Path(args.output_file)
     if not output_file.is_absolute():
+        # Берем текущую рабочую директорию ДО ее возможного изменения в тестах
         output_file = Path.cwd() / output_file
+    # Не резолвим output_file здесь, т.к. он может еще не существовать
 
-    ignore_file = Path(args.ignore_file) if args.ignore_file else None
+    # Обрабатываем путь к ignore-файлу
+    ignore_file_path = Path(args.ignore_file) if args.ignore_file else None
+    if ignore_file_path and not ignore_file_path.is_absolute():
+         ignore_file_path = Path.cwd() / ignore_file_path
+    # Не резолвим ignore_file здесь, проверка на существование будет в ignore.py
 
-    return root_dir, ignore_file, output_file, args.no_default_ignores, args.verbosity
+    # Возвращаем resolved root_dir и подготовленные output_file/ignore_file
+    return root_dir, ignore_file_path, output_file, args.no_default_ignores, args.verbosity

src/treemapper/ignore.py

@@ -1,3 +1,4 @@
+# src/treemapper/ignore.py
 import logging
 import os
 from pathlib import Path
@@ -10,11 +11,17 @@ def read_ignore_file(file_path: Path) -> List[str]:
     """Read the ignore patterns from the specified ignore file."""
     ignore_patterns = []
     if file_path.is_file():
-        with file_path.open('r') as f:
-            ignore_patterns = [line.strip() for line in f
-                               if line.strip() and not line.startswith('#')]
-        logging.info(f"Using ignore patterns from {file_path}")
-        logging.debug(f"Read ignore patterns from {file_path}: {ignore_patterns}")
+        try:
+            # Explicitly use utf-8 for reading ignore files
+            with file_path.open('r', encoding='utf-8') as f:
+                ignore_patterns = [line.strip() for line in f
+                                   if line.strip() and not line.startswith('#')]
+            logging.info(f"Using ignore patterns from {file_path}")
+            logging.debug(f"Read ignore patterns from {file_path}: {ignore_patterns}")
+        except IOError as e:
+             logging.warning(f"Could not read ignore file {file_path}: {e}")
+        except UnicodeDecodeError as e:
+             logging.warning(f"Could not decode ignore file {file_path} as UTF-8: {e}")
     return ignore_patterns
 
 
@@ -27,86 +34,143 @@ def load_pathspec(patterns: List[str], syntax='gitwildmatch') -> pathspec.PathSp
 
 def get_ignore_specs(
     root_dir: Path,
-    custom_ignore_file: Path = None,
+    custom_ignore_file: Path | None = None,
     no_default_ignores: bool = False,
-    output_file: Path = None
+    output_file: Path | None = None
 ) -> Tuple[pathspec.PathSpec, Dict[Path, pathspec.PathSpec]]:
     """Get combined ignore specs and git ignore specs."""
     default_patterns = get_default_patterns(root_dir, no_default_ignores, output_file)
     custom_patterns = get_custom_patterns(root_dir, custom_ignore_file)
-    combined_patterns = custom_patterns if no_default_ignores else default_patterns + custom_patterns
+
+    # Determine combined patterns based on no_default_ignores flag
+    if no_default_ignores:
+        # Only use custom patterns + output file ignore (if applicable and INSIDE root)
+        combined_patterns = custom_patterns
+        if output_file:
+             try:
+                 resolved_output = output_file.resolve()
+                 resolved_root = root_dir.resolve()
+                 if resolved_output.is_relative_to(resolved_root): # Check if output is inside root
+                     relative_output_str = resolved_output.relative_to(resolved_root).as_posix()
+                     output_pattern = f"/{relative_output_str}" # Pattern relative to root
+                     if output_pattern not in combined_patterns: # Avoid duplicates if specified in custom
+                         combined_patterns.append(output_pattern)
+                         logging.debug(f"Adding output file to ignores (no_default_ignores=True): {output_pattern}")
+             except ValueError: # Not relative
+                 pass
+             except Exception as e:
+                 logging.warning(f"Could not determine relative path for output file {output_file}: {e}")
+    else:
+         # Combine default and custom patterns
+        combined_patterns = default_patterns + custom_patterns
+
+    # ---> ЛОГИРОВАНИЕ ДЛЯ ДИАГНОСТИКИ <---
+    logging.debug(f"Ignore specs params: no_default_ignores={no_default_ignores}")
+    logging.debug(f"Default patterns (used unless no_default_ignores): {default_patterns}")
+    logging.debug(f"Custom patterns (-i): {custom_patterns}")
+    logging.debug(f"Combined patterns for spec: {combined_patterns}")
+    # ---> КОНЕЦ ЛОГИРОВАНИЯ <---
+
     combined_spec = load_pathspec(combined_patterns)
     gitignore_specs = get_gitignore_specs(root_dir, no_default_ignores)
 
     return combined_spec, gitignore_specs
 
-def get_default_patterns(root_dir: Path, no_default_ignores: bool, output_file: Path) -> List[str]:
-    """Retrieve default ignore patterns."""
+
+def get_default_patterns(root_dir: Path, no_default_ignores: bool, output_file: Path | None) -> List[str]:
+    """Retrieve default ignore patterns ONLY IF no_default_ignores is FALSE."""
     if no_default_ignores:
+        # This function shouldn't even be called by get_ignore_specs if True,
+        # but double-check for safety. Or rely on get_ignore_specs logic.
+        # Let's return empty to be safe if called directly somehow.
         return []
 
     patterns = []
-    # Add .treemapperignore patterns
+    # Add patterns from .treemapperignore (located in root_dir)
     treemapper_ignore_file = root_dir / ".treemapperignore"
     patterns.extend(read_ignore_file(treemapper_ignore_file))
 
-    # Add default git patterns
-    patterns.extend([".git/", ".git/**"])
-
-    # Add the output file to ignore patterns
+    # Add the output file to ignore patterns IF it's inside root_dir
     if output_file:
         try:
-            relative_output = output_file.resolve().relative_to(root_dir.resolve())
-            patterns.append(str(relative_output))
-            if str(relative_output.parent) != ".":
-                patterns.append(str(relative_output.parent) + "/")
-        except ValueError:
-            pass  # Output file is outside root_dir; no need to add to ignores
+            resolved_output = output_file.resolve()
+            resolved_root = root_dir.resolve()
+            # Check if output is inside root_dir using is_relative_to (Python 3.9+)
+            # Use try/except ValueError for compatibility or if check fails
+            try:
+                 relative_output = resolved_output.relative_to(resolved_root)
+                 # Add only the file itself, starting with / to anchor to root
+                 output_pattern = f"/{relative_output.as_posix()}"
+                 patterns.append(output_pattern)
+                 logging.debug(f"Adding output file to default ignores: {output_pattern}")
+                 # --- УДАЛЕНО ИГНОРИРОВАНИЕ РОДИТЕЛЬСКОЙ ПАПКИ ---
+            except ValueError:
+                 # Output file is outside root_dir, no need to add to default ignores
+                 logging.debug(f"Output file {output_file} is outside root directory {root_dir}, not adding to default ignores.")
+
+        except Exception as e: # Catch potential resolve() or other errors
+            logging.warning(f"Could not determine relative path for output file {output_file}: {e}")
 
     return patterns
 
-def get_custom_patterns(root_dir: Path, custom_ignore_file: Path) -> List[str]:
-    """Retrieve custom ignore patterns."""
+
+def get_custom_patterns(root_dir: Path, custom_ignore_file: Path | None) -> List[str]:
+    """Retrieve custom ignore patterns from the file specified with -i."""
     if not custom_ignore_file:
         return []
 
-    custom_ignore_file = custom_ignore_file if custom_ignore_file.is_absolute() else root_dir / custom_ignore_file
+    # Resolve custom ignore file path relative to CWD if not absolute
+    # Note: If run_mapper changes CWD, this might need adjustment depending on expected behavior.
+    # Assuming custom_ignore_file path is relative to where the command is run.
+    if not custom_ignore_file.is_absolute():
+        custom_ignore_file = Path.cwd() / custom_ignore_file
+
     if custom_ignore_file.is_file():
         return read_ignore_file(custom_ignore_file)
+    else:
+        # Log warning only if the file was explicitly provided but not found
+        logging.warning(f"Custom ignore file '{custom_ignore_file}' not found.")
+        return []
 
-    logging.warning(f"Custom ignore file '{custom_ignore_file}' not found.")
-    return []
 
 def get_gitignore_specs(root_dir: Path, no_default_ignores: bool) -> Dict[Path, pathspec.PathSpec]:
-    """Retrieve gitignore specs for all .gitignore files in the directory."""
+    """Retrieve gitignore specs for all .gitignore files found within root_dir."""
     if no_default_ignores:
-        return {}
+        return {} # Do not load any .gitignore files if flag is set
 
     gitignore_specs = {}
-    for dirpath, _, filenames in os.walk(root_dir):
-        if ".gitignore" in filenames:
-            gitignore_path = Path(dirpath) / ".gitignore"
-            patterns = read_ignore_file(gitignore_path)
-            gitignore_specs[Path(dirpath)] = load_pathspec(patterns)
+    try:
+        for dirpath_str, dirnames, filenames in os.walk(root_dir, topdown=True):
+            # Avoid recursing into directories that should be ignored by parent specs
+            # (basic protection, full gitignore precedence is complex)
+            # This requires passing parent specs down, making it much more complex.
+            # For now, we load all found .gitignores. A simple optimization:
+            if '.git' in dirnames:
+                dirnames.remove('.git') # Don't recurse into .git
+
+            if ".gitignore" in filenames:
+                gitignore_path = Path(dirpath_str) / ".gitignore"
+                patterns = read_ignore_file(gitignore_path)
+                if patterns: # Only load spec if there are actual patterns
+                    gitignore_specs[Path(dirpath_str)] = load_pathspec(patterns)
+
+    except OSError as e:
+         logging.warning(f"Error walking directory {root_dir} to find .gitignore files: {e}")
 
     return gitignore_specs
 
 
-
-def should_ignore(file_path: str, combined_spec: pathspec.PathSpec) -> bool:
+def should_ignore(relative_path_str: str, combined_spec: pathspec.PathSpec) -> bool:
     """Check if a file or directory should be ignored based on combined pathspec."""
-    paths_to_check = [file_path]
-
-    # Add path variations for checking
-    if file_path.endswith('/'):
-        paths_to_check.append(file_path)
-
-    # Add parent directories with trailing slash
-    for part in Path(file_path).parents:
-        if part != Path('.'):
-            paths_to_check.append(part.as_posix() + '/')
-
-    result = any(combined_spec.match_file(path) for path in paths_to_check)
-    logging.debug(
-        f"Should ignore '{file_path}': {result} (checking paths: {paths_to_check})")
-    return result
+    # pathspec should handle directory matching correctly if patterns end with '/'
+    # We primarily need to check the path itself. Checking parents might over-ignore.
+    # Let's simplify: only check the path string itself.
+    # Ensure directories passed from build_tree end with '/'
+    is_ignored = combined_spec.match_file(relative_path_str)
+
+    # Optional: Check without trailing slash if it's a directory? Pathspec might do this.
+    # if relative_path_str.endswith('/') and not is_ignored:
+    #     is_ignored = combined_spec.match_file(relative_path_str.rstrip('/'))
+
+    logging.debug(f"Checking combined spec ignore for '{relative_path_str}': {is_ignored}")
+    return is_ignored