Merge branch 'main' of github.com:zksecurity/zkregex_fuzzer into noir-runner

Author: Merricx

.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI Checks
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  run-checks:
+    name: Run Linting & Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y graphviz graphviz-dev
+
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.13"  
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .[dev]  
+
+      - name: Run Linter & Tests
+        run: python scripts/lint_and_tests.py
+

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

@@ -11,18 +11,39 @@ authors = [
 ]
 license = { text = "MIT" }
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.13"
 keywords = ["fuzzing", "grammar", "zkregex"]
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: MIT License",
   "Operating System :: OS Independent"
 ]
 dependencies = [
-  "fuzzingbook>=0.11.0",
+  "fuzzingbook",
   "rstr",
   "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,45 +7,44 @@
 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.reproduce import reproduce
 from zkregex_fuzzer.runner.circom import CircomSubprocess, SnarkjsSubprocess, ZkRegexSubprocess
 from zkregex_fuzzer.runner.subprocess import BarretenbergSubprocess, NoirSubprocess
 
 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(
         "--seed",
@@ -62,7 +61,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",
@@ -74,31 +73,31 @@ 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(
         "--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",
     )
 
     parser.add_argument(
@@ -117,17 +116,16 @@ def fuzz_parser():
 
     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,
     )
     parser.add_argument(
         "--logger-level",
@@ -138,11 +136,12 @@ def reproduce_parser():
 
     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:
             zk_regex_version = ZkRegexSubprocess.get_installed_version()
@@ -177,7 +176,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.")
@@ -221,46 +220,44 @@ 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()
 
     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,8 @@
 from zkregex_fuzzer.runner import CircomRunner, PythonReRunner, NoirRunner
 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,
@@ -23,4 +23,4 @@
 GENERATORS = {
     "grammar": GrammarRegexGenerator,
     "database": DatabaseRegexGenerator,
-}
+}