Redo command-line interface

Author: nobodywasishere

.gitignore

@@ -1,3 +1,4 @@
 __pycache__
 dist
-vhdlproc.egg-info
+vhdlproc.egg-info
+*.proc.vhdl

README.md

@@ -30,30 +30,48 @@ $ ./vhdlproc/vhdlproc.py --help
 ### Command Line
 
 ```
-usage: vhdlproc.py [-h] [-i I] [-o O] [-D IDENTIFIER=value]
+usage: vhdlproc.py [-h] [-D IDENTIFIER=value] [-o DIRECTORY] [-e EXTENSION] [--self-test]
+                   [--log-level LEVEL]
+                   [input ...]
 
-VHDLproc v1.2.0 - VHDL Preprocessor
+VHDLproc v2.2 - VHDL Preprocessor
 
-optional arguments:
+positional arguments:
+  input                Input files (will skip over files with the output extension)
+
+options:
   -h, --help           show this help message and exit
-  -i I                 Input file (Omit to read from stdin)
-  -o O                 Output file (Omit to print to stdout)
   -D IDENTIFIER=value  Specify identifiers for conditional compilation, ex. DEBUG_LEVEL=2
+  -o DIRECTORY         Directory to store parsed files
+  -e EXTENSION         Output extension for processed files (defaults to '.proc.vhdl')
+  --self-test          Run a self-test to ensure functionality
+  --log-level LEVEL    Configure the logging level
 ```
 
-You can read from stdin or a file, and print to stdout or another file.
+A basic example, where VHDLproc will parse each input file, output the processed text to a new file with a given extension, and the processed files are then passed to GHDL:
 
+```bash
+vhdlproc *.vhdl              # preprocess all the files
+ghdl -a --std=08 *.proc.vhdl # pass processed files to ghdl
+ghdl -r --std=08 testbench   # run simulation
 ```
-$ cat tests/define.vhdl | python vhdlproc/vhdlproc.py
-`if VHDL_VERSION >= "2008" then
-...
-`end if
-...
+
+As VHDLproc also outputs each of the processed filenames to STDOUT, this would also work:
+```bash
+ghdl -a --std=08 $(vhdlproc *.vhdl)
+ghdl -r --std=08 testbench
+```
+
+The parsed files can also be stored to another directory:
+```bash
+vhdlproc *.vhdl -o build/     # preprocess all the files and store in build/
+ghdl -a --std=08 build/*.vhdl # pass processed files in build/ to ghdl
+ghdl -r --std=08 testbench    # run simulation
 ```
 
 ### Python Library
 
-Parse files:
+Parse files (will automatically set the include path):
 
 ```python
 from vhdlproc import VHDLproc
@@ -84,7 +102,7 @@ code = [
     '`include "some/file.vhdl"',
 ]
 
-parsed_text_list = processor.parse_file(code, identifiers=identifiers, include_path="path/to/pull/include/directives/from")
+parsed_text = processor.parse(code, identifiers=identifiers, include_path="path/to/pull/include/directives/from")
 
 # Parse string
 code = '''
@@ -96,7 +114,7 @@ constant test_var : integer := 100
 `include "some/file.vhdl"
 '''
 
-parsed_text_str = processor.parse_file(code, identifiers=identifiers, include_path="path/to/pull/include/directives/from")
+parsed_text = processor.parse(code, identifiers=identifiers, include_path="path/to/pull/include/directives/from")
 ```
 
 ### Preprocessor Directives (what you put in your VHDL files)
@@ -136,7 +154,7 @@ By default, `TOOL_NAME` is set to `VHDLproc` and `TOOL_VERSION` is set to the cu
 - [ ] Prevent a file from including itself (to prevent infinite loops)
 - [ ] Modify text and file operations to work on Windows (if they don't already)
 - [ ] Throw an error if a `` `warning `` or `` `error `` string isn't wrapped in quotes
-- [ ] Add the option to the CLI to take in a series of file inputs, process them, save the individual results to temporary files (i.e. in `/tmp/` or a local path), then return all of the filepaths. This would be useful for doing this with GHDL: `ghdl -a $(vhdlproc -f *.vhdl)`. 
+- [x] Add the option to the CLI to take in a series of file inputs, process them, save the individual results to temporary files (i.e. in `/tmp/` or a local path), then return all of the filepaths. This would be useful for doing this with GHDL: `ghdl -a $(vhdlproc *.vhdl)`. 
 
 ## Examples
 

setup.py

@@ -11,7 +11,7 @@
     license="GPLv3",
     packages=["vhdlproc"],
     package_data={"vhdlproc": ["tests/*"]},
-    install_requires=["argparse", "black"],
+    install_requires=[],
     classifiers=[
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.6",

vhdlproc/vhdlproc.py

@@ -8,7 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
-__version__ = "v2.1"
+__version__ = "v2.2"
 
 
 # Infix class based on https://code.activestate.com/recipes/384122/
@@ -270,7 +270,7 @@ def parse(
             if not ifstack[-1][0] and code[line_i].strip()[:2] != "--":
                 code[line_i] = self._comment_char + code[line_i]
 
-            # print(f'ifstack: {ifstack}')
+            # logging.debug(f'ifstack: {ifstack}')
 
         if len(ifstack) > 1:
             raise Exception(f"Line {line_i+1}: Missing `end [ if ]")
@@ -288,7 +288,7 @@ def test_file(name: str, identifiers: Dict[str, str] = {}) -> bool:
     Returns:
         bool: Whether the test passed or failed
     """
-    print(f"\n== Testing {name} ==")
+    logging.info(f"\n== Testing {name} ==")
     proc = VHDLproc()
     filename = os.path.dirname(__file__) + f"/tests/{name}.vhdl"
     passed = True
@@ -308,63 +308,93 @@ def test_file(name: str, identifiers: Dict[str, str] = {}) -> bool:
     return passed
 
 
-def test_all():
+def test_all(identifiers: Dict[str, str]):
     """Runs the 'include', 'and', and 'nest' tests
 
     Returns:
         bool: Whether the tests passed or failed
     """
-    return not (test_file("include") and test_file("and") and test_file("nest"))
+    return not (
+        test_file("include", identifiers)
+        and test_file("and", identifiers)
+        and test_file("nest", identifiers)
+    )
 
 
 def _cli():
     parser = argparse.ArgumentParser(
-        description=f"VHDLproc v{__version__} - VHDL Preprocessor"
+        description=f"VHDLproc {__version__} - VHDL Preprocessor"
     )
-    parser.add_argument("-i", help="Input file (Omit to read from stdin)")
-    parser.add_argument("-o", help="Output file (Omit to print to stdout)")
     parser.add_argument(
-        "--test", action="store_true", help="Tests VHDLproc to ensure functionality"
+        "input",
+        nargs="*",
+        help="Input files (will skip over files with the output extension)",
     )
     parser.add_argument(
         "-D",
         action="append",
         metavar="IDENTIFIER=value",
         help="Specify identifiers for conditional compilation, ex. DEBUG_LEVEL=2",
     )
+    parser.add_argument(
+        "-o",
+        metavar="DIRECTORY",
+        help="Directory to store parsed files",
+    )
+    parser.add_argument(
+        "-e",
+        metavar="EXTENSION",
+        default=".proc.vhdl",
+        help="Output extension for processed files (defaults to '.proc.vhdl')",
+    )
+    parser.add_argument(
+        "--self-test",
+        action="store_true",
+        help="Run a self-test to ensure functionality",
+    )
     parser.add_argument(
         "--log-level",
+        metavar="LEVEL",
         default=logging.INFO,
         type=(lambda x: getattr(logging, x)),
-        help="Configure the logging level.",
+        help="Configure the logging level",
     )
     args = parser.parse_args()
 
     logging.basicConfig(level=args.log_level, format="%(levelname)s: %(message)s")
 
-    if args.test:
-        retn = test_all()
-        exit(retn)
+    identifiers = (
+        {id.split("=")[0]: str(id.split("=")[1]) for id in args.D} if args.D else {}
+    )
 
-    identifiers = {}
+    if args.self_test:
+        test_all(identifiers)
+        return
 
-    if args.D:
-        for id in args.D:
-            identifiers[id.split("=")[0]] = str(id.split("=")[1])
+    if not os.path.exists(args.temp_dir):
+        os.makedirs(args.temp_dir)
 
     proc = VHDLproc()
-    if args.i:
-        parsed_code = proc.parse_file(args.i, identifiers=identifiers)
-    else:
-        code = []
-        for line in sys.stdin:
-            code.append(line.rstrip("\n"))
-        parsed_code = proc.parse(code, identifiers=identifiers)
-
-    if args.o:
-        open(args.o, "w+").write(parsed_code)
-    else:
-        print(parsed_code)
+    for file in args.input:
+        if file.endswith(args.extension):
+            logging.debug(f"Skipping file {file}")
+            continue
+
+        if args.out_dir is not None:
+            newfile = os.path.join(
+                args.out_dir,
+                os.path.splitext(os.path.basename(file))[0] + args.extension,
+            )
+        else:
+            newfile = os.path.splitext(file)[0] + args.extension
+
+        print(newfile)
+
+        logging.debug(f"Parsing file {file} to {newfile}")
+
+        parsed_code = proc.parse_file(file, identifiers=identifiers)
+        with open(newfile, "w") as f:
+            f.write(parsed_code)
 
 
 if __name__ == "__main__":