Add linter, formatter, and tests

Closes #18

Author: StefanosChaliasos

README.md

@@ -12,7 +12,7 @@ source venv/bin/activate
 Next, you can run the fuzzer locally:
 
 ```
-pip install -r requirements.txt
+pip install -e .
 python src/zkregex_fuzzer/cli.py --help
 ```
 
@@ -23,6 +23,18 @@ pip install -e .
 zkregex-fuzzer --help
 ```
 
+## Linting and tests
+
+```
+pip install -e '.[dev]'
+# Either run manually
+ruff check .
+ruff format .
+pytest
+# or through the script
+python scripts/lint_and_tests.py
+```
+
 ## Example Run
 
 ### Fuzzing

pyproject.toml

@@ -24,5 +24,26 @@ dependencies = [
   "exrex",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "pytest",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+lint.select = ["E", "F", "W"]
+lint.extend-select = ["I"]
+lint.ignore = ["F401", "E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
 [project.scripts]
 zkregex-fuzzer = "zkregex_fuzzer.cli:main"
+
+# Automatically find packages under `src/`
+[tool.setuptools.packages.find]
+where = ["src"]

requirements.txt

@@ -0,0 +1,39 @@
+import subprocess
+import sys
+
+
+def run_command(command: str) -> int:
+    """Runs a shell command and returns the exit code."""
+    print(f"Running: {command}")
+    process = subprocess.run(command, shell=True)
+    return process.returncode
+
+
+def run_linter() -> int:
+    """Runs Ruff to check for linting errors."""
+    print("Running Ruff Linter...")
+    return run_command("ruff check .")
+
+
+def run_formatter() -> int:
+    """Runs Black to check for formatting errors."""
+    print("Running Black Formatter...")
+    return run_command("ruff format .")
+
+
+def run_tests() -> int:
+    """Placeholder for future test execution."""
+    print("Running Tests (Placeholder)...")
+    return run_command("pytest")
+
+
+if __name__ == "__main__":
+    lint_exit_code = run_linter()
+    test_exit_code = run_tests()
+
+    if lint_exit_code != 0 or test_exit_code != 0:
+        print("❌ Checks failed!")
+        sys.exit(1)  # Fail GitHub Action if linting or tests fail
+    else:
+        print("✅ All checks passed!")
+        sys.exit(0)

scripts/lint_and_tests.py

@@ -7,44 +7,48 @@
 import random
 import uuid
 from pathlib import Path
-from zkregex_fuzzer.reproduce import reproduce
+
+from zkregex_fuzzer.configs import GENERATORS, TARGETS, VALID_INPUT_GENERATORS
 from zkregex_fuzzer.fuzzer import fuzz_with_database, fuzz_with_grammar
 from zkregex_fuzzer.grammar import REGEX_GRAMMAR
-from zkregex_fuzzer.configs import TARGETS, VALID_INPUT_GENERATORS, GENERATORS
 from zkregex_fuzzer.harness import HarnessStatus
 from zkregex_fuzzer.logger import logger
-from zkregex_fuzzer.runner.circom import CircomSubprocess, SnarkjsSubprocess, ZkRegexSubprocess
+from zkregex_fuzzer.reproduce import reproduce
+from zkregex_fuzzer.runner.circom import (
+    CircomSubprocess,
+    SnarkjsSubprocess,
+    ZkRegexSubprocess,
+)
+
 
 def fuzz_parser():
-    parser = argparse.ArgumentParser(
-        add_help=False
-    )
+    parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument(
         "--regex-num",
         type=int,
         default=10,
-        help="Number of regexes to generate (default: 10)."
+        help="Number of regexes to generate (default: 10).",
     )
     parser.add_argument(
         "--inputs-num",
         type=int,
         default=10,
-        help="Number of inputs to generate for each regex (default: 10)."
+        help="Number of inputs to generate for each regex (default: 10).",
     )
     parser.add_argument(
         "--oracle",
         choices=["valid", "invalid"],
-        help="Wherether the generated inputs should be valid or invalid wrt the regex."
+        help="Wherether the generated inputs should be valid or invalid wrt the regex.",
     )
     parser.add_argument(
         "--target",
         choices=list(TARGETS.keys()),
-        help=f"The target to fuzz (options: {list(TARGETS.keys())})."
+        help=f"The target to fuzz (options: {list(TARGETS.keys())}).",
     )
     parser.add_argument(
         "--valid-input-generator",
         choices=list(VALID_INPUT_GENERATORS.keys()),
-        help=f"The valid input generator to use for the fuzzer (options: {list(VALID_INPUT_GENERATORS.keys())})."
+        help=f"The valid input generator to use for the fuzzer (options: {list(VALID_INPUT_GENERATORS.keys())}).",
     )
     parser.add_argument(
         "--save",
@@ -56,7 +60,7 @@ def fuzz_parser():
         "--save-output",
         type=str,
         default=os.getcwd(),
-        help=f"The output path where the reproducible files will be stored (default: .)"
+        help="The output path where the reproducible files will be stored (default: .)",
     )
     parser.add_argument(
         "--fuzzer",
@@ -68,56 +72,55 @@ def fuzz_parser():
         "--grammar-max-depth",
         type=int,
         default=5,
-        help="Maximum depth of recursion in the grammar (default: 5)."
+        help="Maximum depth of recursion in the grammar (default: 5).",
     )
     parser.add_argument(
         "--circom-max-input-size",
         type=int,
         default=600,
-        help="Maximum size of the circuit input (default: 600)."
+        help="Maximum size of the circuit input (default: 600).",
     )
     parser.add_argument(
         "--circom-library",
         nargs="*",
         type=str,
-        help="Path to the circom library to be included"
+        help="Path to the circom library to be included",
     )
 
     parser.add_argument(
         "--circom-prove",
         action="store_true",
-        help="Run the proving and verification step with SnarkJS."
+        help="Run the proving and verification step with SnarkJS.",
     )
 
     parser.add_argument(
         "--circom-ptau",
         type=str,
-        help="Path to the ptau (powers-of-tau) file for the proving step"
+        help="Path to the ptau (powers-of-tau) file for the proving step",
     )
-    
 
     return parser
 
+
 def reproduce_parser():
-    parser = argparse.ArgumentParser(
-        add_help=False
-    )
+    parser = argparse.ArgumentParser(add_help=False)
 
     parser.add_argument(
         "--path",
         nargs="+",
         type=str,
         help="Path to the target directory output that want to be reproduced (support wildcard pattern).",
-        required=True
+        required=True,
     )
 
     return parser
 
+
 def do_fuzz(args):
     if args.oracle == "valid" and not args.valid_input_generator:
         print("Valid input generator is required for valid oracle.")
         exit(1)
-    
+
     if args.target == "circom":
         try:
             circom_version = CircomSubprocess.get_installed_version()
@@ -150,7 +153,7 @@ def do_fuzz(args):
             if not args.circom_ptau:
                 print("Path to ptau file is required for proving.")
                 exit(1)
-            
+
             ptau_path = Path(args.circom_ptau).resolve()
             if not ptau_path.exists():
                 print(f"Path to ptau file {ptau_path} does not exist.")
@@ -171,7 +174,7 @@ def do_fuzz(args):
 
     # set global seed
     seed = str(uuid.uuid4())
-    kwargs['seed'] = seed
+    kwargs["seed"] = seed
     random.seed(seed)
 
     if args.fuzzer == "grammar":
@@ -182,52 +185,50 @@ def do_fuzz(args):
             regex_num=args.regex_num,
             inputs_num=args.inputs_num,
             max_depth=args.grammar_max_depth,
-            kwargs=kwargs
+            kwargs=kwargs,
         )
     elif args.fuzzer == "database":
         fuzz_with_database(
             target_implementation=args.target,
             oracle_params=(args.oracle == "valid", args.valid_input_generator),
             regex_num=args.regex_num,
             inputs_num=args.inputs_num,
-            kwargs=kwargs
+            kwargs=kwargs,
         )
 
+
 def do_reproduce(args):
     reproduce(args.path)
 
+
 def main():
-    
     parser = argparse.ArgumentParser()
     parser.add_argument(
         "--logger-level",
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
         default="INFO",
-        help="Set the logger level (default: INFO)."
+        help="Set the logger level (default: INFO).",
     )
 
     subparser = parser.add_subparsers(dest="subcommand")
     subparser.add_parser(
-        "fuzz",
-        help="Fuzz the target regex implementation.", 
-        parents=[fuzz_parser()]
+        "fuzz", help="Fuzz the target regex implementation.", parents=[fuzz_parser()]
     )
     subparser.add_parser(
         "reproduce",
         help="Reproduce the bug that found by the fuzzer.",
-        parents=[reproduce_parser()]
+        parents=[reproduce_parser()],
     )
 
     args = parser.parse_args()
 
-
     logger.setLevel(args.logger_level)
 
     if args.subcommand == "fuzz":
         do_fuzz(args)
     elif args.subcommand == "reproduce":
         do_reproduce(args)
-    
+
 
 if __name__ == "__main__":
     main()

src/zkregex_fuzzer/__init__.py

@@ -1,8 +1,7 @@
-from zkregex_fuzzer.runner import CircomRunner, PythonReRunner
 from zkregex_fuzzer.grammar import REGEX_GRAMMAR
-from zkregex_fuzzer.regexgen import GrammarRegexGenerator, DatabaseRegexGenerator
-from zkregex_fuzzer.vinpgen import GrammarBasedGenerator, RstrGenerator, ExrexGenerator
-
+from zkregex_fuzzer.regexgen import DatabaseRegexGenerator, GrammarRegexGenerator
+from zkregex_fuzzer.runner import CircomRunner, PythonReRunner
+from zkregex_fuzzer.vinpgen import ExrexGenerator, GrammarBasedGenerator, RstrGenerator
 
 TARGETS = {
     "circom": CircomRunner,
@@ -22,4 +21,4 @@
 GENERATORS = {
     "grammar": GrammarRegexGenerator,
     "database": DatabaseRegexGenerator,
-}
+}