treefs 2.0.0__tar.gz

treefs-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 marcelodevops
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

treefs-2.0.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: treefs
+Version: 2.0.0
+Summary: Filesystem generator/importer using tree, YAML, JSON, TOML and tree format. Deluxe edition.
+Author: Marcelo
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/marcelodevops/treefspy
+Project-URL: Repository, https://github.com/marcelodevops/treefspy
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: toml>=0.10.2
+Dynamic: license-file
+
+# 🧰 TreeFS
+
+A powerful CLI toolkit to build and export directory structures from **tree text**, **YAML**, **JSON**, or **TOML** configs — with support for templates, Git initialization, and cross-platform release binaries.
+
+Originally inspired by a tiny Bash script, TreeFS has grown into a full-featured Python project that helps automate project scaffolding and structure generation.
+
+---
+
+##  Features
+
+-  **Build directory trees** from:
+  - Tree-formatted text files
+  - YAML / JSON / TOML config files
+-  Support for **file templates** and content templates
+-  **Export** file systems into tree text or structured configs
+-  **Git integration**
+  - `git init` with optional `.gitignore` and hooks
+-  **Cross-platform binaries**
+  - Build single-file executables via PyInstaller
+-  GitHub Actions workflow included to auto-build release binaries
+
+---
+
+## 🧾 Installation
+
+Install locally using `pip`:
+
+```bash
+pip install .
+```
+
+## Usage
+- Build from a tree file
+```bash
+treefs build tree.txt myproject/
+
+```
+- Add optional templates and git setup
+```bash
+treefs build project.yaml myproj/ \
+  --templates ./templates \
+  --init-git \
+  --gitignore ./common_gitignore \
+  --git-hooks ./my-hooks
+```
+- Preview what would be created without writing to disk:
+```bash
+treefs build project.yaml myproj/ --dry-run
+```
+### Export project structure
+- Export a folder to a tree layout text:
+```bash
+treefs export-tree myproj/ tree.txt
+```
+- Or export to structured configs:
+```bash
+treefs export-config myproj/ project.yaml
+treefs export-config myproj/ project.json
+treefs export-config myproj/ project.toml
+```
+### Bundling a binary
+- If PyInstaller is installed, you can auto-bundle TreeFS:
+```bash
+treefs bundle treefs.py --name treefs
+```

treefs-2.0.0/README.md

@@ -0,0 +1,65 @@
+# 🧰 TreeFS
+
+A powerful CLI toolkit to build and export directory structures from **tree text**, **YAML**, **JSON**, or **TOML** configs — with support for templates, Git initialization, and cross-platform release binaries.
+
+Originally inspired by a tiny Bash script, TreeFS has grown into a full-featured Python project that helps automate project scaffolding and structure generation.
+
+---
+
+##  Features
+
+-  **Build directory trees** from:
+  - Tree-formatted text files
+  - YAML / JSON / TOML config files
+-  Support for **file templates** and content templates
+-  **Export** file systems into tree text or structured configs
+-  **Git integration**
+  - `git init` with optional `.gitignore` and hooks
+-  **Cross-platform binaries**
+  - Build single-file executables via PyInstaller
+-  GitHub Actions workflow included to auto-build release binaries
+
+---
+
+## 🧾 Installation
+
+Install locally using `pip`:
+
+```bash
+pip install .
+```
+
+## Usage
+- Build from a tree file
+```bash
+treefs build tree.txt myproject/
+
+```
+- Add optional templates and git setup
+```bash
+treefs build project.yaml myproj/ \
+  --templates ./templates \
+  --init-git \
+  --gitignore ./common_gitignore \
+  --git-hooks ./my-hooks
+```
+- Preview what would be created without writing to disk:
+```bash
+treefs build project.yaml myproj/ --dry-run
+```
+### Export project structure
+- Export a folder to a tree layout text:
+```bash
+treefs export-tree myproj/ tree.txt
+```
+- Or export to structured configs:
+```bash
+treefs export-config myproj/ project.yaml
+treefs export-config myproj/ project.json
+treefs export-config myproj/ project.toml
+```
+### Bundling a binary
+- If PyInstaller is installed, you can auto-bundle TreeFS:
+```bash
+treefs bundle treefs.py --name treefs
+```

treefs-2.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "treefs"
+version = "2.0.0"
+description = "Filesystem generator/importer using tree, YAML, JSON, TOML and tree format. Deluxe edition."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{name = "Marcelo"}]
+dependencies = ["PyYAML>=6.0", "toml>=0.10.2"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/marcelodevops/treefspy"
+Repository = "https://github.com/marcelodevops/treefspy"
+
+[project.scripts]
+treefs = "treefs:main"
+
+[tool.setuptools]
+py-modules = ["treefs"]

treefs-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

treefs-2.0.0/tests/test_treefs.py

@@ -0,0 +1,116 @@
+"""Unit tests for treefs.py's tree-file parser and build logic.
+
+Run with: python -m unittest discover -s tests
+(stdlib unittest is used so no extra test-runner dependency is required.)
+"""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import treefs  # noqa: E402
+
+
+class TreeToDictTests(unittest.TestCase):
+    def _parse(self, text: str) -> dict:
+        with tempfile.NamedTemporaryFile("w", suffix=".tree", delete=False) as f:
+            f.write(text)
+            path = Path(f.name)
+        try:
+            return treefs.tree_to_dict(path)
+        finally:
+            path.unlink()
+
+    def test_directories_without_trailing_slash(self):
+        # This is what the stock `tree` command actually outputs: no
+        # trailing "/" on directory names.
+        text = (
+            "myproj\n"
+            "├── src\n"
+            "│   ├── main.py\n"
+            "│   └── utils.py\n"
+            "└── README.md\n"
+        )
+        structure = self._parse(text)
+        self.assertEqual(
+            structure,
+            {
+                "myproj": {
+                    "src": {"main.py": "", "utils.py": ""},
+                    "README.md": "",
+                }
+            },
+        )
+
+    def test_directories_with_trailing_slash(self):
+        text = (
+            "myproj/\n"
+            "├── src/\n"
+            "│   └── main.py\n"
+            "└── README.md\n"
+        )
+        structure = self._parse(text)
+        self.assertEqual(
+            structure,
+            {"myproj": {"src": {"main.py": ""}, "README.md": ""}},
+        )
+
+    def test_deep_nesting_with_spacer_indent(self):
+        # Last child of a directory uses plain spaces instead of "│   ".
+        text = (
+            "myproj\n"
+            "├── src\n"
+            "│   ├── pkg\n"
+            "│   │   └── deep.py\n"
+            "│   └── utils.py\n"
+            "└── docs\n"
+            "    └── guide.md\n"
+        )
+        structure = self._parse(text)
+        self.assertEqual(
+            structure,
+            {
+                "myproj": {
+                    "src": {"pkg": {"deep.py": ""}, "utils.py": ""},
+                    "docs": {"guide.md": ""},
+                }
+            },
+        )
+
+    def test_empty_directory_needs_trailing_slash(self):
+        # An empty directory has no children to infer depth from, so it must
+        # be marked explicitly with a trailing "/".
+        text = "myproj\n├── empty_dir/\n└── file.txt\n"
+        structure = self._parse(text)
+        self.assertEqual(
+            structure,
+            {"myproj": {"empty_dir": {}, "file.txt": ""}},
+        )
+
+
+class BuildFromTreeTests(unittest.TestCase):
+    def test_build_creates_expected_files_on_disk(self):
+        text = (
+            "myproj\n"
+            "├── src\n"
+            "│   └── main.py\n"
+            "└── README.md\n"
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            tree_file = tmp_path / "sample.tree"
+            tree_file.write_text(text, encoding="utf-8")
+
+            root = tmp_path / "out"
+            root.mkdir()
+            treefs.build_from_tree(tree_file, root, force=False, dry_run=False)
+
+            self.assertTrue((root / "src").is_dir())
+            self.assertTrue((root / "src" / "main.py").is_file())
+            self.assertTrue((root / "README.md").is_file())
+
+
+if __name__ == "__main__":
+    unittest.main()

treefs-2.0.0/treefs.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: treefs
+Version: 2.0.0
+Summary: Filesystem generator/importer using tree, YAML, JSON, TOML and tree format. Deluxe edition.
+Author: Marcelo
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/marcelodevops/treefspy
+Project-URL: Repository, https://github.com/marcelodevops/treefspy
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: toml>=0.10.2
+Dynamic: license-file
+
+# 🧰 TreeFS
+
+A powerful CLI toolkit to build and export directory structures from **tree text**, **YAML**, **JSON**, or **TOML** configs — with support for templates, Git initialization, and cross-platform release binaries.
+
+Originally inspired by a tiny Bash script, TreeFS has grown into a full-featured Python project that helps automate project scaffolding and structure generation.
+
+---
+
+##  Features
+
+-  **Build directory trees** from:
+  - Tree-formatted text files
+  - YAML / JSON / TOML config files
+-  Support for **file templates** and content templates
+-  **Export** file systems into tree text or structured configs
+-  **Git integration**
+  - `git init` with optional `.gitignore` and hooks
+-  **Cross-platform binaries**
+  - Build single-file executables via PyInstaller
+-  GitHub Actions workflow included to auto-build release binaries
+
+---
+
+## 🧾 Installation
+
+Install locally using `pip`:
+
+```bash
+pip install .
+```
+
+## Usage
+- Build from a tree file
+```bash
+treefs build tree.txt myproject/
+
+```
+- Add optional templates and git setup
+```bash
+treefs build project.yaml myproj/ \
+  --templates ./templates \
+  --init-git \
+  --gitignore ./common_gitignore \
+  --git-hooks ./my-hooks
+```
+- Preview what would be created without writing to disk:
+```bash
+treefs build project.yaml myproj/ --dry-run
+```
+### Export project structure
+- Export a folder to a tree layout text:
+```bash
+treefs export-tree myproj/ tree.txt
+```
+- Or export to structured configs:
+```bash
+treefs export-config myproj/ project.yaml
+treefs export-config myproj/ project.json
+treefs export-config myproj/ project.toml
+```
+### Bundling a binary
+- If PyInstaller is installed, you can auto-bundle TreeFS:
+```bash
+treefs bundle treefs.py --name treefs
+```

treefs-2.0.0/treefs.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+treefs.py
+tests/test_treefs.py
+treefs.egg-info/PKG-INFO
+treefs.egg-info/SOURCES.txt
+treefs.egg-info/dependency_links.txt
+treefs.egg-info/entry_points.txt
+treefs.egg-info/requires.txt
+treefs.egg-info/top_level.txt

treefs-2.0.0/treefs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

treefs-2.0.0/treefs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+treefs = treefs:main

treefs-2.0.0/treefs.egg-info/requires.txt

@@ -0,0 +1,2 @@
+PyYAML>=6.0
+toml>=0.10.2

treefs-2.0.0/treefs.egg-info/top_level.txt

@@ -0,0 +1 @@
+treefs

treefs-2.0.0/treefs.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+TreeFS — deluxe edition (fixed parser version)
+
+Changes:
+- Replaced fragile ASCII-tree stack parser
+- Introduced AST-based tree parser (tree → dict)
+- build_from_tree now reuses build_from_dict safely
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# optional deps: pyyaml, toml
+try:
+    import yaml
+except Exception:
+    yaml = None
+
+try:
+    import toml
+except Exception:
+    toml = None
+
+
+# ---------- Utilities ----------
+
+# 4-character indentation units a tree line's prefix is built from (one per
+# ancestor depth level that is *not* the immediate parent connector).
+_INDENT_UNITS = ("│   ", "    ", "|   ")
+
+# 4-character connectors that introduce an entry's own name.
+_CONNECTORS = ("├── ", "└── ", "|-- ", "`-- ")
+
+
+def _parse_tree_line(line: str) -> tuple[int, str]:
+    """Split a single tree line into (depth, name).
+
+    This walks the line manually instead of relying on trailing slashes or
+    fragile character-replacement math, so it works whether or not the tree
+    file marks directories with a trailing "/" (the stock `tree` command does
+    not do so unless run with `-F`).
+
+    A bare root line (no leading indent units and no connector, e.g. the
+    "myproj" line at the very top of `tree` output) is one level *above* its
+    connector-prefixed children, even though they share the same count of
+    indent units, so it gets depth -1 relative to them.
+    """
+    i = 0
+    depth = 0
+    while line[i:i + 4] in _INDENT_UNITS:
+        depth += 1
+        i += 4
+
+    has_connector = line[i:i + 4] in _CONNECTORS
+    if has_connector:
+        i += 4
+    else:
+        depth -= 1
+
+    name = line[i:].strip()
+    return depth, name
+
+
+def is_tty() -> bool:
+    return sys.stdout.isatty()
+
+
+def colorize(text: str, color: str) -> str:
+    if not is_tty():
+        return text
+    codes = {
+        "green": "\033[92m",
+        "yellow": "\033[93m",
+        "blue": "\033[94m",
+        "red": "\033[91m",
+        "reset": "\033[0m",
+    }
+    return f"{codes.get(color, '')}{text}{codes['reset']}"
+
+
+def safe_print(msg: str = "", c: str = "green"):
+    print(colorize(msg, c))
+
+
+def ensure_parent(path: Path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+# ---------- FIXED: TREE PARSER (AST BUILDER) ----------
+
+
+def tree_to_dict(tree_file: Path) -> dict:
+    """
+    Converts ASCII tree file into nested dictionary (AST).
+
+    Directories are detected either by an explicit trailing "/" on the name,
+    or (since the stock `tree` command doesn't add one) by the presence of a
+    following line indented one level deeper.
+    """
+
+    entries = []  # (depth, name, has_trailing_slash)
+
+    with tree_file.open("r", encoding="utf-8") as f:
+        for raw in f:
+            line = raw.rstrip()
+
+            if not line or line.strip() == "│":
+                continue
+
+            if line.lower().startswith("project"):
+                continue
+
+            depth, name = _parse_tree_line(line)
+            if not name:
+                continue
+
+            has_slash = name.endswith("/")
+            entries.append((depth, name.rstrip("/"), has_slash))
+
+    root: dict = {}
+    stack = [(-2, root)]  # (depth, node); -2 is below any real/root depth
+
+    for idx, (depth, name, has_slash) in enumerate(entries):
+        is_dir = has_slash
+        if not is_dir and idx + 1 < len(entries):
+            is_dir = entries[idx + 1][0] > depth
+
+        # move to correct parent
+        while stack and stack[-1][0] >= depth:
+            stack.pop()
+
+        parent = stack[-1][1]
+
+        if is_dir:
+            node: dict = {}
+            parent[name] = node
+            stack.append((depth, node))
+        else:
+            parent[name] = ""
+
+    return root
+
+
+# ---------- FIXED: BUILD FROM TREE ----------
+
+
+def build_from_tree(
+    tree_file: Path,
+    root: Path,
+    force: bool,
+    dry_run: bool,
+    templates_dir: Optional[Path] = None,
+):
+    structure = tree_to_dict(tree_file)
+
+    # unwrap single-root tree (platform/ etc.)
+    if len(structure) == 1:
+        structure = list(structure.values())[0]
+
+    return build_from_dict(
+        root=root,
+        structure=structure,
+        force=force,
+        dry_run=dry_run,
+        templates_dir=templates_dir,
+    )
+
+
+# ---------- BUILD FROM DICT (UNCHANGED CORE) ----------
+
+
+def build_from_dict(
+    root: Path,
+    structure: Dict[str, Any],
+    force: bool,
+    dry_run: bool,
+    templates_dir: Optional[Path] = None,
+):
+    created = []
+
+    def recurse(base: Path, node: Dict[str, Any]):
+        for name, val in node.items():
+            path = base / name
+
+            if isinstance(val, dict):
+                if dry_run:
+                    created.append(str(path) + "/ (would create)")
+                else:
+                    path.mkdir(parents=True, exist_ok=True)
+                    created.append(str(path) + "/")
+
+                recurse(path, val)
+
+            else:
+                ensure_parent(path)
+
+                if path.exists() and not force:
+                    created.append(f"{path} (exists, kept)")
+                else:
+                    if dry_run:
+                        created.append(f"{path} (would create file)")
+                    else:
+                        path.write_text(val or "", encoding="utf-8")
+                        created.append(str(path))
+
+    recurse(root, structure)
+    return created
+
+
+# ---------- EXPORT TREE ----------
+
+
+def export_tree(root: Path, output: Path):
+    lines = [root.name + "/"]
+
+    def walk(p: Path, prefix: str = ""):
+        entries = sorted(p.iterdir(), key=lambda x: x.name)
+        for i, entry in enumerate(entries):
+            connector = "└── " if i == len(entries) - 1 else "├── "
+            lines.append(prefix + connector + entry.name)
+
+            if entry.is_dir():
+                ext = "    " if i == len(entries) - 1 else "│   "
+                walk(entry, prefix + ext)
+
+    walk(root)
+    output.write_text("\n".join(lines), encoding="utf-8")
+    return str(output)
+
+
+# ---------- EXPORT CONFIG ----------
+
+
+def export_dict(root: Path) -> Dict[str, Any]:
+    def recurse(p: Path):
+        data = {}
+        for child in sorted(p.iterdir(), key=lambda x: x.name):
+            if child.is_dir():
+                data[child.name] = recurse(child)
+            else:
+                data[child.name] = child.read_text(encoding="utf-8")
+        return data
+
+    return {root.name: recurse(root)}
+
+
+# ---------- CLI ----------
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser("treefs")
+    sub = parser.add_subparsers(dest="cmd")
+
+    b = sub.add_parser("build")
+    b.add_argument("input")
+    b.add_argument("root")
+    b.add_argument("--force", action="store_true")
+    b.add_argument("--dry-run", action="store_true")
+
+    t = sub.add_parser("export-tree")
+    t.add_argument("root")
+    t.add_argument("output")
+
+    c = sub.add_parser("export-config")
+    c.add_argument("root")
+    c.add_argument("output")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "build":
+        inp = Path(args.input)
+        root = Path(args.root)
+        root.mkdir(parents=True, exist_ok=True)
+
+        created = build_from_tree(
+            inp,
+            root,
+            force=args.force,
+            dry_run=args.dry_run,
+        )
+
+        safe_print("\nCreated / Verified:", "yellow")
+        for cstr in created:
+            safe_print(" - " + cstr)
+
+    elif args.cmd == "export-tree":
+        out = Path(args.output)
+        safe_print("Exporting tree...", "blue")
+        export_tree(Path(args.root), out)
+        safe_print("Saved", "yellow")
+
+    elif args.cmd == "export-config":
+        root = Path(args.root)
+        out = Path(args.output)
+        struct = export_dict(root)
+
+        fmt = out.suffix.lower().lstrip(".")
+        if fmt == "json":
+            out.write_text(json.dumps(struct, indent=2))
+        elif fmt == "yaml" and yaml:
+            out.write_text(yaml.safe_dump(struct))
+        elif fmt == "toml" and toml:
+            out.write_text(toml.dumps(struct))
+        else:
+            raise RuntimeError("Unsupported format")
+
+        safe_print("Saved", "yellow")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()