Release 0.2 (#17)

Main:
* Update __main__.py - check if os is windows and use tsft_windows method

Publish:
* Update setup.py - update version

Treescriptify Package:
* Create windows_tree.py
* Update __init__.py - add method tsfy_windows
* Update windows_tree.py - add docs, optimize imports, simplify subdirectory content check, add method _dirs_only, add method _dirs_only_prune, modify method win_tree to accept a path parameter

Treescriptify Test Package:
* Create test_windows_tree.py
* Update test_windows_tree.py - add file system dependent expected assertion values, alter mock_hidden_tree dir and file order, differentiate input data further, add test cases, replace Path mocks with tmp_path, refactor test cases

Workflows:
* Update ci_run.yml - disable fail-fast

Author: DK96-OS

.github/workflows/ci_run.yml

@@ -13,6 +13,7 @@ jobs:
   build:
     strategy:
       max-parallel: 3
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
         python-version: [ '3.11', '3.12' ]

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name="treescriptify",
-    version="0.1.2",
+    version="0.2",
     description="Create TreeScript from an existing filesystem tree.",
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',

test/test_windows_tree.py

@@ -0,0 +1,229 @@
+"""Testing Windows tree Methods
+"""
+import os
+from pathlib import Path
+import pytest
+
+from treescriptify.input_data import InputData
+from treescriptify.tree_node_data import TreeNodeData
+from treescriptify.windows_tree import win_tree
+
+
+# File Systems on different Operating Systems behave differently.
+# In test cases with files and dirs at the same level in a tree,
+# the order of the files and dirs is switched.
+IS_WINDOWS = os.name == 'nt'
+
+
+DEFAULT_INPUT = InputData()
+EXCLUDE_HIDDEN_INPUT = InputData(include_hidden=False)
+DIR_ONLY_INPUT = InputData(directories_only=True)
+PRUNE_DIR_INPUT = InputData(prune_dirs=True)
+DIR_ONLY_PRUNE_INPUT = InputData(directories_only=True, prune_dirs=True)
+EXCLUDE_HIDDEN_WITH_DIR_ONLY_PRUNE = InputData(
+    include_hidden=False, directories_only=True, prune_dirs=True
+)
+
+
+# BASIC_TREE
+#   src/
+#     data.txt
+
+# NESTED_TREE
+#   src/
+#     main/
+#       SourceClass.java
+
+# HIDDEN_TREE
+# on Windows:
+#   .github/
+#     dependabot.yml
+#     workflows/
+#       ci.yml
+#   .hidden.txt
+#
+# on unix:
+#   .github/
+#     workflows/
+#       ci.yml
+#     dependabot.yml
+#   .hidden.txt
+
+
+@pytest.fixture
+def mock_basic_tree(tmp_path):
+    src_dir = tmp_path / 'src'  
+    src_dir.mkdir()
+    (src_dir / 'data.txt').touch()
+    return Path(str(tmp_path))
+
+
+@pytest.fixture
+def mock_nested_tree(tmp_path):
+    src_dir = tmp_path / 'src'
+    src_dir.mkdir()
+    main_dir = src_dir / 'main'
+    main_dir.mkdir()
+    (main_dir / 'SourceClass.java').touch()
+    return Path(str(tmp_path))
+
+
+@pytest.fixture
+def mock_hidden_tree(tmp_path):
+    github_dir = tmp_path / '.github'
+    github_dir.mkdir()
+    (github_dir / 'dependabot.yml').touch()
+    workflows_dir = github_dir / 'workflows'
+    workflows_dir.mkdir()
+    (workflows_dir / 'ci.yml').touch()
+    (tmp_path / '.hidden.txt').touch()
+    return Path(str(tmp_path))
+
+
+def test_win_tree_default_input_basic_tree_returns_data(mock_basic_tree):
+    result = [x for x in win_tree(DEFAULT_INPUT, mock_basic_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, False, 'data.txt'),
+    ]
+
+
+def test_win_tree_default_input_nested_tree_returns_data(mock_nested_tree):
+    result = [x for x in win_tree(DEFAULT_INPUT, mock_nested_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, True, 'main'),
+        TreeNodeData(2, False, 'SourceClass.java'),
+    ]
+
+
+def test_win_tree_default_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in win_tree(DEFAULT_INPUT, mock_hidden_tree)]
+    if IS_WINDOWS:
+        expected = [
+            TreeNodeData(0, True, '.github'),
+            TreeNodeData(1, False, 'dependabot.yml'),
+            TreeNodeData(1, True, 'workflows'),
+            TreeNodeData(2, False, 'ci.yml'),
+            TreeNodeData(0, False, '.hidden.txt'),
+        ]
+    else:
+        expected = [
+            TreeNodeData(0, True, '.github'),
+            TreeNodeData(1, True, 'workflows'),
+            TreeNodeData(2, False, 'ci.yml'),
+            TreeNodeData(1, False, 'dependabot.yml'),
+            TreeNodeData(0, False, '.hidden.txt'),
+        ]
+    assert result == expected
+
+
+def test_win_tree_exclude_hidden_input_basic_tree_returns_data(mock_basic_tree):
+    result = [x for x in win_tree(EXCLUDE_HIDDEN_INPUT, mock_basic_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, False, 'data.txt'),
+    ]
+
+
+def test_win_tree_exclude_hidden_input_nested_tree_returns_data(mock_nested_tree):
+    result = [x for x in win_tree(EXCLUDE_HIDDEN_INPUT, mock_nested_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, True, 'main'),
+        TreeNodeData(2, False, 'SourceClass.java'),
+    ]
+
+        
+def test_win_tree_exclude_hidden_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in win_tree(EXCLUDE_HIDDEN_INPUT, mock_hidden_tree)]
+    assert result == []
+
+
+def test_win_tree_dir_only_input_basic_tree_returns_data(mock_basic_tree):
+    result = [x for x in win_tree(DIR_ONLY_INPUT, mock_basic_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+    ]
+
+
+def test_win_tree_dir_only_input_nested_tree_returns_data(mock_nested_tree):
+    result = [x for x in win_tree(DIR_ONLY_INPUT, mock_nested_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, True, 'main'),
+    ]
+
+    
+def test_win_tree_dir_only_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in iter(win_tree(DIR_ONLY_INPUT, mock_hidden_tree))]
+    assert result == [
+        TreeNodeData(0, True, '.github'),
+        TreeNodeData(1, True, 'workflows'),
+    ]
+
+
+def test_win_tree_prune_dir_input_basic_tree_returns_data(mock_basic_tree):
+    result = [x for x in win_tree(PRUNE_DIR_INPUT, mock_basic_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, False, 'data.txt'),
+    ]
+
+
+def test_win_tree_prune_dir_input_nested_tree_returns_data(mock_nested_tree):    
+    result = [x for x in win_tree(PRUNE_DIR_INPUT, mock_nested_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, True, 'main'),
+        TreeNodeData(2, False, 'SourceClass.java'),
+    ]
+
+
+def test_win_tree_prune_dir_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in win_tree(PRUNE_DIR_INPUT, mock_hidden_tree)]
+    if IS_WINDOWS:
+        expected = [
+            TreeNodeData(0, True, '.github'),
+            TreeNodeData(1, False, 'dependabot.yml'),
+            TreeNodeData(1, True, 'workflows'),
+            TreeNodeData(2, False, 'ci.yml'),
+            TreeNodeData(0, False, '.hidden.txt'),
+        ]
+    else:
+        expected = [
+            TreeNodeData(0, True, '.github'),
+            TreeNodeData(1, True, 'workflows'),
+            TreeNodeData(2, False, 'ci.yml'),
+            TreeNodeData(1, False, 'dependabot.yml'),
+            TreeNodeData(0, False, '.hidden.txt'),
+        ]
+    assert result == expected
+
+
+def test_win_tree_dir_only_prune_input_basic_tree_returns_data(mock_basic_tree):
+    result = [x for x in win_tree(DIR_ONLY_PRUNE_INPUT, mock_basic_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+    ]
+
+
+def test_win_tree_dir_only_prune_input_nested_tree_returns_data(mock_nested_tree):
+    result = [x for x in win_tree(DIR_ONLY_PRUNE_INPUT, mock_nested_tree)]
+    assert result == [
+        TreeNodeData(0, True, 'src'),
+        TreeNodeData(1, True, 'main'),
+    ]
+
+
+def test_win_tree_dir_only_prune_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in win_tree(DIR_ONLY_PRUNE_INPUT, mock_hidden_tree)]
+    assert result == [
+        TreeNodeData(0, True, '.github'),
+        TreeNodeData(1, True, 'workflows'),
+    ]
+
+
+def test_win_tree_dir_only_prune_input_hidden_tree_returns_data(mock_hidden_tree):
+    result = [x for x in win_tree(EXCLUDE_HIDDEN_WITH_DIR_ONLY_PRUNE, mock_hidden_tree)]
+    assert result == []

treescriptify/__init__.py

@@ -4,6 +4,7 @@
 from .tree_runner import get_tree_json
 from .tree_reader import generate_from_json
 from .script_writer import generate_script
+from .windows_tree import win_tree
 
 
 def tsfy(data: InputData) -> str:
@@ -16,3 +17,13 @@ def tsfy(data: InputData) -> str:
             )
         )
     )
+
+
+def tsfy_windows(data: InputData) -> str:
+    """Run Treescriptify on the given Inputs, on a Windows OS.
+    """
+    return '\n'.join(
+        generate_script(
+            win_tree(data)
+        )
+    )

treescriptify/__main__.py

@@ -1,15 +1,17 @@
 #!/usr/bin/python
 """Main Entry Point
 """
+import os
 from sys import argv
 
 from .argument_parser import parse_args
-from . import tsfy
+from . import tsfy, tsfy_windows
 
 
 def main():
     input_data = parse_args(argv[1:])
-    print(tsfy(input_data))
+    output_data = tsfy_windows(input_data) if os.name == 'nt' else tsfy(input_data)
+    print(output_data)
 
 
 if __name__ == '__main__':

treescriptify/windows_tree.py

@@ -0,0 +1,85 @@
+"""Python implementation of the Tree Command, for windows OS.
+"""
+from pathlib import Path
+from typing import Generator
+
+from .input_data import InputData
+from .tree_node_data import TreeNodeData
+
+
+def win_tree(
+    data: InputData,
+    path: Path = Path('./'),
+) -> Generator[TreeNodeData, None, None]:
+    """Generate Tree Node Data for all files and directories in the given path.
+
+    Parameters:
+    - data (InputData): The
+    - path (str): The root path to run tree in.
+
+    Return:
+    Generator[TreeNodeData]
+    """
+    if data.directories_only:
+        if data.prune_dirs:
+            yield from _dirs_only_prune(data, path)
+        else:
+            yield from _dirs_only(data, path)
+    else:
+        yield from _gen_tree(data, path)
+
+
+def _gen_tree(
+    data: InputData,
+    path: Path,
+    depth: int = 0
+) -> Generator[TreeNodeData, None, None]:
+    """Mimic the Tree command.
+    """
+    for entry in path.iterdir():
+        # Check Hidden Files option
+        if not data.include_hidden and entry.name.startswith('.'):
+            continue
+        is_directory = entry.is_dir()
+        yield TreeNodeData(depth, is_directory, entry.name)
+        if is_directory:
+            yield from _gen_tree(data, entry, depth + 1)
+
+
+def _dirs_only(
+    data: InputData,
+    path: Path,
+    depth: int = 0
+) -> Generator[TreeNodeData, None, None]:
+    """Only Yields Directories.
+    """
+    for entry in path.iterdir():
+        if not data.include_hidden and entry.name.startswith('.'):
+            continue
+        if (is_directory := entry.is_dir()):
+            yield TreeNodeData(depth, is_directory, entry.name)
+            yield from _dirs_only(data, entry, depth + 1)
+        else:
+            #print(f"Ignoring File {entry.name}")
+            pass
+
+
+def _dirs_only_prune(
+    data: InputData,
+    path: Path,
+    depth: int = 0
+) -> Generator[TreeNodeData, None, None]:
+    """Only Yields Directories, after pruning.
+    """
+    for entry in path.iterdir():
+        if not data.include_hidden and entry.name.startswith('.'):
+            continue
+        if (is_directory := entry.is_dir()):
+            # Check if directory is empty
+            if any(entry.iterdir()):
+                yield TreeNodeData(depth, is_directory, entry.name)
+                yield from _dirs_only_prune(data, entry, depth + 1)
+        else:
+            #print(f"Ignoring File {entry.name}")
+            pass
+