Initialize Treescriptify Project (#1)

Documentation:
* Create README.md

Input:
* Create __init__.py
* Create argument_parser.py
* Create input_data.py

Test Input:
* Create __init__.py
* Create test_argument_parser.py

Test Treescriptify:
* Create __init__.py
* Create test_script_writer.py

Treescriptify:
* Create __init__.py
* Create script_writer.py
* Create tree_node_data.py
* Create tree_reader.py
* Create tree_runner.py

Workflows:
* Create __main__.py
* Create ci_run.yml
* Create dependabot.yml

Author: DK96-OS

.github/dependabot.yml

@@ -0,0 +1,15 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    # Workflow files stored in the default location of `.github/workflows`. (You don't need to specify `/.github/workflows` for `directory`. You can use `directory: "/"`.)
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every weekday
+      interval: "daily"
+    open-pull-requests-limit: 2
+

.github/workflows/ci_run.yml

@@ -0,0 +1,35 @@
+# This workflow installs Python dependencies, run lint checks and unit tests
+# Info: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python App lint check and unit test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ '3.12' ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Dependencies
+        run: python -m pip install --user pytest pytest-cov
+
+      - name: Run unit tests
+        run: pytest test/ --cov --cov-report=html --cov-fail-under=75
+
+      - name: Upload Test Coverage Reports
+        uses: actions/upload-artifact@v3
+        with:
+          name: treescriptify-cov
+          path: htmlcov/

README.md

@@ -0,0 +1,13 @@
+# TreeScriptify
+Get Started fast with a TreeScript generated from an existing directory.
+
+## How To Use
+Run `python <path-to-tsfy-dir>` command in a directory to treescript-ify.
+
+1. You can pipe program output to a file, or
+2. Display it on-screen for copy-paste workflow integration.
+
+## Program Architecture
+![tsfy](https://github.com/DK96-OS/tsfy/assets/69859316/84f127f0-cf19-418b-be78-572fbb96868c)
+
+

__main__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/python
+"""Main Entry Point
+"""
+from sys import argv
+
+from input.argument_parser import parse_args
+from treescriptify import tsfy
+
+
+def main():
+    input_data = parse_args(argv[1:])
+    print(tsfy(input_data))
+
+
+if __name__ == '__main__':
+    main()

input/__init__.py

@@ -0,0 +1,55 @@
+"""Argument Parsing Methods
+"""
+from argparse import ArgumentParser
+
+from input.input_data import InputData
+
+
+def parse_args(arguments: list[str]) -> InputData:
+    """Parse the arguments, and determine the program's Input Data.
+    """
+    try:
+        args = _define_arguments().parse_args(arguments)
+    except SystemExit as e:
+        exit("Unable to Parse Arguments.")
+    return InputData(
+        include_hidden=args.hide,
+        directories_only=args.directories,
+        git_ignore=args.gitignore,
+        prune_dirs=args.prune
+    )
+
+
+def _define_arguments() -> ArgumentParser:
+    """Create and initialize the ArgumentParser.
+    """
+    parser = ArgumentParser(
+        description='Treescriptify'
+    )
+    parser.add_argument(
+        '-a',
+        '--hide',
+        action='store_false',
+        default=True,
+        help='Hidden files are shown by default. This flag hides them.'
+    )
+    parser.add_argument(
+        '-d',
+        '--directories',
+        action='store_true',
+        default=False,
+        help='Flag to show only the directories.'
+    )
+    parser.add_argument(
+        '--gitignore',
+        action='store_false',
+        default=True,
+        help='Gitignore is enabled by default. This flag disables .gitignore.'
+    )
+    parser.add_argument(
+        '--prune',
+        action='store_true',
+        default=False,
+        help='Flag to prune empty directories from the output.'
+    )
+    return parser

input/argument_parser.py

@@ -0,0 +1,17 @@
+"""Input Data to the Program
+"""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class InputData:
+    """The optional flags to modify the output of the program.
+    """
+
+    include_hidden: bool = True
+    #
+    directories_only: bool = False
+    #
+    git_ignore: bool = True
+    #
+    prune_dirs: bool = False

input/input_data.py

@@ -0,0 +1,37 @@
+"""Testing Module Methods
+"""
+import pytest
+
+from input.input_data import InputData
+from input.argument_parser import parse_args
+
+
+@pytest.mark.parametrize(
+    'test_input,expected',
+    [
+        ([], InputData()),
+        (['-a'], InputData(include_hidden=False)),
+        (['-d'], InputData(directories_only=True)),
+        (['--gitignore'], InputData(git_ignore=False)),
+        (['--prune'], InputData(prune_dirs=True)),
+    ]
+)
+def test_parse_args_returns_input(test_input, expected):
+	assert parse_args(test_input) == expected
+
+
+@pytest.mark.parametrize(
+    'test_input',
+    [
+        (['']),
+        ([' ']),
+        (['r']),
+        (['eeee']),
+    ]
+)
+def test_parse_args_raises_exit(test_input):
+	try:
+		parse_args(test_input)
+		assert False
+	except SystemExit:
+		assert True

test/__init__.py

@@ -0,0 +1,35 @@
+"""Testing Module Methods
+"""
+import pytest
+
+from treescriptify.script_writer import generate_script
+from treescriptify.tree_node_data import TreeNodeData
+
+
+def generator_single_dir_node(name: str, depth: int=0):
+	yield TreeNodeData(depth, True, name)
+
+
+def generator_single_file_node(name: str, depth: int=0):
+	yield TreeNodeData(depth, False, name)
+
+
+def generator_depth_1():
+	yield TreeNodeData(0, True, 'module')
+	yield TreeNodeData(1, False, 'file.txt')
+	yield TreeNodeData(1, True, 'src')
+
+
+@pytest.mark.parametrize(
+    'test_input,expected',
+    [
+        (generator_single_dir_node('.directory'), '.directory/'),
+        (generator_single_dir_node('.directory', 1), '  .directory/'),
+        (generator_single_file_node('file.txt'), 'file.txt'),
+        (generator_single_file_node('file.txt', 1), '  file.txt'),
+		(generator_depth_1(), 'module/\n  file.txt\n  src/')
+    ]
+)
+def test_generate_script_returns_str(test_input, expected):
+	script_gen = generate_script(test_input)
+	assert "\n".join(script_gen) == expected

test/input/__init__.py

@@ -0,0 +1,18 @@
+"""TreeScriptify Package
+"""
+from input.input_data import InputData
+from treescriptify.tree_runner import get_tree_json
+from treescriptify.tree_reader import generate_from_json
+from treescriptify.script_writer import generate_script
+
+
+def tsfy(data: InputData) -> str:
+    """Run Treescriptify on the given Inputs.
+    """
+    return '\n'.join(
+        generate_script(
+            generate_from_json(
+                get_tree_json(data)
+            )
+        )
+    )

test/input/test_argument_parser.py

@@ -0,0 +1,21 @@
+"""Generate TreeScript from Tree Node Data.
+"""
+from typing import Generator
+
+from treescriptify.tree_node_data import TreeNodeData
+
+
+def generate_script(tree_nodes: Generator[TreeNodeData, None, None]) -> Generator[str, None, None]:
+    """Generate the TreeScript Line by Line for each Tree Node.
+    """
+    for node in tree_nodes:
+        yield _write_line(node)
+
+
+def _write_line(data: TreeNodeData) -> str:
+    """Convert a Tree Node into a line of TreeScript.
+    """
+    line = data.depth * '  ' + data.name
+    if data.is_dir:
+        line += '/'
+    return line

test/treescriptify/test_script_writer.py

@@ -0,0 +1,15 @@
+"""Tree Node Data
+"""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TreeNodeData:
+    """
+    """
+
+    depth: int
+    #
+    is_dir: bool
+    #
+    name: str

treescriptify/__init__.py

@@ -0,0 +1,27 @@
+"""
+"""
+import json
+from typing import Generator
+
+from treescriptify.tree_node_data import TreeNodeData
+
+
+def generate_from_json(json_string: str) -> Generator[TreeNodeData, None, None]:
+    """Read the JSON string and generate TreeNodeData for all elements.
+    """
+    full_json = json.loads(json_string)[0]
+    for i in full_json['contents']:
+        for node in _process_node(i, 0):
+            yield node
+
+
+def _process_node(node: dict, depth: int) -> Generator[TreeNodeData, None, None]:
+    """
+    """
+    if node['type'] == 'file':
+        yield TreeNodeData(depth, False, node['name'])
+    else:
+        yield TreeNodeData(depth, True, node['name'])
+        for nested_nodes in node.get('contents', []):
+            for node in _process_node(nested_nodes, depth + 1):
+                yield node

treescriptify/script_writer.py

@@ -0,0 +1,35 @@
+"""Tree Runner
+"""
+import subprocess
+
+from input.input_data import InputData
+
+
+def get_tree_json(data: InputData) -> str:
+    """Obtain the Tree Information as a JSON string.
+    """
+    result = subprocess.run(
+        args='tree -Jix --noreport ' + _check_arguments(data),
+        capture_output=True,
+        text=True,
+        shell=True,
+        timeout=3
+    )
+    output = result.stdout
+    #error = result.stderr
+    return output
+
+
+def _check_arguments(data: InputData) -> str:
+    """Check the Input Data and map flags to tree command.
+    """
+    extras = []
+    if data.directories_only:
+        extras.append('-d ')
+    if data.prune_dirs:
+        extras += ['--prune ']
+    if data.include_hidden:
+        extras += ['-a ']
+    if data.git_ignore:
+        extras.append('--gitignore ')
+    return ' '.join(extras)