adding more tests, refactoring

Author: nikolay-e

.github/workflows/ci.yml

@@ -11,8 +11,8 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ ubuntu-latest, ubuntu-20.04, ubuntu-22.04, macos-latest, windows-latest ]
-        python-version: [ 3.9, '3.10', '3.11' ]
+        os: [ ubuntu-20.04, ubuntu-22.04, ubuntu-24.04, macos-latest, windows-latest ]
+        python-version: [ 3.9, '3.10', '3.11', '3.12']
 
     runs-on: ${{ matrix.os }}
 
@@ -55,7 +55,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ pypy-3.9 ]
+        python-version: [ pypy-3.9, pypy-3.10 ]
 
     steps:
       - name: Checkout Code

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
+from typing import Tuple, Optional # <--- Добавлен Optional
 
-
-def parse_args() -> Tuple[Path, Path, Path, bool, int]:
+# ---> ИЗМЕНЕНИЕ: Заменяем | None на Optional[...] <---
+def parse_args() -> Tuple[Path, Optional[Path], Optional[Path], 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,26 @@ 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)
+        if not root_dir.is_dir():
+            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:
+         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
 
-    ignore_file = Path(args.ignore_file) if args.ignore_file else None
+    ignore_file_path: Optional[Path] = None # Используем Optional для ясности
+    if args.ignore_file:
+        ignore_file_path = Path(args.ignore_file)
+        if not ignore_file_path.is_absolute():
+             ignore_file_path = Path.cwd() / ignore_file_path
 
-    return root_dir, ignore_file, output_file, args.no_default_ignores, args.verbosity
+    return root_dir, ignore_file_path, output_file, args.no_default_ignores, args.verbosity

src/treemapper/ignore.py

@@ -1,7 +1,9 @@
+# src/treemapper/ignore.py
 import logging
 import os
 from pathlib import Path
-from typing import List, Dict, Tuple
+# ---> ИЗМЕНЕНИЕ: Добавляем импорты из typing <---
+from typing import List, Dict, Tuple, Optional
 
 import pathspec
 
@@ -10,11 +12,16 @@ 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:
+            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
 
 
@@ -24,89 +31,110 @@ def load_pathspec(patterns: List[str], syntax='gitwildmatch') -> pathspec.PathSp
     logging.debug(f"Loaded pathspec with patterns: {patterns}")
     return spec
 
-
+# ---> ИЗМЕНЕНИЕ: Заменяем | None на Optional[...] <---
 def get_ignore_specs(
     root_dir: Path,
-    custom_ignore_file: Path = None,
+    custom_ignore_file: Optional[Path] = None,
     no_default_ignores: bool = False,
-    output_file: Path = None
+    output_file: Optional[Path] = 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
+
+    if no_default_ignores:
+        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):
+                     relative_output_str = resolved_output.relative_to(resolved_root).as_posix()
+                     output_pattern = f"/{relative_output_str}"
+                     if output_pattern not in combined_patterns:
+                         combined_patterns.append(output_pattern)
+                         logging.debug(f"Adding output file to ignores (no_default_ignores=True): {output_pattern}")
+             except ValueError: pass
+             except Exception as e:
+                 logging.warning(f"Could not determine relative path for output file {output_file}: {e}")
+    else:
+        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."""
+# ---> ИЗМЕНЕНИЕ: Заменяем | None на Optional[...] <---
+def get_default_patterns(root_dir: Path, no_default_ignores: bool, output_file: Optional[Path]) -> List[str]:
+    """Retrieve default ignore patterns ONLY IF no_default_ignores is FALSE."""
     if no_default_ignores:
         return []
 
     patterns = []
-    # Add .treemapperignore patterns
     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
     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()
+            try:
+                 relative_output = resolved_output.relative_to(resolved_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:
+                 logging.debug(f"Output file {output_file} is outside root directory {root_dir}, not adding to default ignores.")
+        except Exception as e:
+            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."""
+# ---> ИЗМЕНЕНИЕ: Заменяем | None на Optional[...] <---
+def get_custom_patterns(root_dir: Path, custom_ignore_file: Optional[Path]) -> 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
+    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:
+        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 {}
 
     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):
+            if '.git' in dirnames:
+                dirnames.remove('.git')
+            if ".gitignore" in filenames:
+                gitignore_path = Path(dirpath_str) / ".gitignore"
+                patterns = read_ignore_file(gitignore_path)
+                if 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
+    is_ignored = combined_spec.match_file(relative_path_str)
+    logging.debug(f"Checking combined spec ignore for '{relative_path_str}': {is_ignored}")
+    return is_ignored