pywrit 0.2.18__tar.gz → 0.2.19__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: pywrit
3
- Version: 0.2.18
3
+ Version: 0.2.19
4
4
  Summary: Python client + CLI for Writ — the gate before the write
5
5
  License-Expression: MIT
6
6
  Project-URL: Homepage, https://withwrit.com
@@ -61,7 +61,7 @@ install test.
61
61
  | --- | --- | --- | --- |
62
62
  | Python | Yes | Yes, inserts `_writ_check` gates | Parsed with the stdlib `ast`, no extra needed |
63
63
  | TypeScript / JavaScript | Yes, with `pywrit[polyglot]` | No, scan only | Needs the extra: `pip install 'pywrit[polyglot]'`. Without it, the report says so loudly: a warning block names the unscanned files instead of reporting zero findings |
64
- | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
64
+ | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal, including WITH-CTE writes. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
65
65
 
66
66
  ## 60-second quickstart: scan → wrap → gate
67
67
 
@@ -191,7 +191,7 @@ pipeline (twilio-style generated clients, e.g. `twilio-node`).
191
191
 
192
192
  pip install 'pywrit[polyglot]'
193
193
 
194
- Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), a leading WITH (CTE), or a Raw call on a non-db/tx receiver never fires. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: WITH-CTE raw-SQL writes and other Go write patterns.
194
+ Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), or a Raw call on a non-db/tx receiver never fires. A leading WITH is graded past: the CTE list is parsed and the main statement's first keyword is graded the same way, so WITH ... DELETE / INSERT / UPDATE fires while WITH ... SELECT stays silent; a write verb inside a CTE query never decides the grade, and a malformed WITH grades as a read. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: other Go write patterns.
195
195
 
196
196
  ## GitHub Action
197
197
 
@@ -38,7 +38,7 @@ install test.
38
38
  | --- | --- | --- | --- |
39
39
  | Python | Yes | Yes, inserts `_writ_check` gates | Parsed with the stdlib `ast`, no extra needed |
40
40
  | TypeScript / JavaScript | Yes, with `pywrit[polyglot]` | No, scan only | Needs the extra: `pip install 'pywrit[polyglot]'`. Without it, the report says so loudly: a warning block names the unscanned files instead of reporting zero findings |
41
- | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
41
+ | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal, including WITH-CTE writes. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
42
42
 
43
43
  ## 60-second quickstart: scan → wrap → gate
44
44
 
@@ -168,7 +168,7 @@ pipeline (twilio-style generated clients, e.g. `twilio-node`).
168
168
 
169
169
  pip install 'pywrit[polyglot]'
170
170
 
171
- Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), a leading WITH (CTE), or a Raw call on a non-db/tx receiver never fires. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: WITH-CTE raw-SQL writes and other Go write patterns.
171
+ Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), or a Raw call on a non-db/tx receiver never fires. A leading WITH is graded past: the CTE list is parsed and the main statement's first keyword is graded the same way, so WITH ... DELETE / INSERT / UPDATE fires while WITH ... SELECT stays silent; a write verb inside a CTE query never decides the grade, and a malformed WITH grades as a read. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: other Go write patterns.
172
172
 
173
173
  ## GitHub Action
174
174
 
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
4
4
 
5
5
  [project]
6
6
  name = "pywrit"
7
- version = "0.2.18"
7
+ version = "0.2.19"
8
8
  description = "Python client + CLI for Writ — the gate before the write"
9
9
  readme = "README.md"
10
10
  license = "MIT"
@@ -27,7 +27,7 @@ from .errors import (
27
27
  WritError,
28
28
  )
29
29
 
30
- __version__ = "0.2.18"
30
+ __version__ = "0.2.19"
31
31
 
32
32
  __all__ = [
33
33
  "WritClient",
@@ -1395,7 +1395,7 @@ def _tsjs_scan_source(src, filename, parser):
1395
1395
  return sites, gated
1396
1396
 
1397
1397
 
1398
- # writ scan, Go (slices 1-4): deterministic and scan-only (Go files are
1398
+ # writ scan, Go (slices 1-5): deterministic and scan-only (Go files are
1399
1399
  # never rewritten). Same tree-sitter tier as TS/JS, same
1400
1400
  # `pywrit[polyglot]` extra plus the tree-sitter-go grammar; without the
1401
1401
  # extra the missing-extra block counts Go files too. Slice 1 covers one
@@ -1410,8 +1410,10 @@ def _tsjs_scan_source(src, filename, parser):
1410
1410
  # generated clients (<pkg>.<New|Update|Delete|Create>, the pre-v87
1411
1411
  # stripe-go shape: charge.New(params)). Slice 4 adds the GORM raw-SQL
1412
1412
  # helper: <db|tx>.Raw(<write SQL string literal>) graded on the
1413
- # literal's first keyword. Wider Go coverage (os/io/fs writes, sqlx,
1414
- # raw-SQL conditions on Exec, WITH-CTE raw-SQL writes, Go-specific
1413
+ # literal's first keyword. Slice 5 grades past a leading WITH: the
1414
+ # main statement after the CTE list is graded on its first keyword the
1415
+ # same way. Wider Go coverage (os/io/fs writes, sqlx,
1416
+ # raw-SQL conditions on Exec, Go-specific
1415
1417
  # non-product suppression classes) ships in later slices.
1416
1418
  # ---------------------------------------------------------------------------
1417
1419
 
@@ -1425,12 +1427,13 @@ _GO_TEST_DIRS = {"tests", "testing"}
1425
1427
  # resource-segment rule.
1426
1428
  _GO_PKG_ROOTS = {"http", "sql", "gorm"}
1427
1429
 
1428
- # Write-first SQL verbs for the slice-4 GORM raw-SQL grade: a Raw()
1430
+ # Write-first SQL verbs for the slice-4/5 GORM raw-SQL grade: a Raw()
1429
1431
  # string literal is a write only when its first keyword (leading
1430
- # whitespace stripped) is one of these, case-insensitive. Read-first
1431
- # statements (SELECT, SHOW, DESCRIBE, EXPLAIN) never fire, and a
1432
- # leading WITH (CTE) is deliberately not graded past in this slice:
1433
- # it never fires, write tail or not.
1432
+ # whitespace stripped) is one of these, case-insensitive. A leading
1433
+ # WITH (slice 5) is graded past: the main statement after the CTE
1434
+ # list is graded on its first keyword the same way. Read-first
1435
+ # statements (SELECT, SHOW, DESCRIBE, EXPLAIN, and WITH ... SELECT)
1436
+ # never fire.
1434
1437
  _GO_RAWSQL_WRITE_VERBS = ("insert", "update", "delete", "replace",
1435
1438
  "truncate", "merge")
1436
1439
 
@@ -1500,22 +1503,129 @@ _GO_PKGCLIENT_NONRESOURCE = (
1500
1503
  )
1501
1504
 
1502
1505
 
1506
+ def _go_sql_first_kw(lit):
1507
+ """The first keyword that decides the write grade of a Raw() SQL
1508
+ literal, else None when no keyword qualifies. Normally the
1509
+ literal's first keyword; for a leading WITH (slice 5) the CTE list
1510
+ is walked and the keyword is the main statement's first keyword
1511
+ instead. The CTE walk is a real parse, not a substring search for
1512
+ a write verb: keywords inside a CTE query never decide the grade.
1513
+ Anything not keyword-shaped (an empty literal, one that starts
1514
+ with "(" or "--") and a WITH statement off the CTE-list shape
1515
+ (unbalanced parens, a CTE list that never terminates, a paren
1516
+ right after WITH, no main verb) never reaches _GO_RAWSQL_WRITE_VERBS,
1517
+ so it falls through as a read."""
1518
+ s = lit.lstrip()
1519
+ m = _re.match(r"[A-Za-z_][A-Za-z0-9_$]*", s)
1520
+ first = m.group(0).lower() if m else ""
1521
+ if first != "with":
1522
+ return first or None
1523
+ i = m.end()
1524
+ n = len(s)
1525
+ if i < n and s[i] == "(":
1526
+ # not the name-first CTE-list shape (a row list): off shape
1527
+ return None
1528
+
1529
+ def ws(j):
1530
+ while j < n and s[j].isspace():
1531
+ j += 1
1532
+ return j
1533
+
1534
+ def word(j):
1535
+ j = ws(j)
1536
+ k = j
1537
+ while k < n and (s[k].isalnum() or s[k] in "_$"):
1538
+ k += 1
1539
+ return (s[j:k].lower(), k) if k > j else (None, k)
1540
+
1541
+ def ident(j):
1542
+ j = ws(j)
1543
+ w, k = word(j)
1544
+ if w is not None:
1545
+ return k
1546
+ if j < n and s[j] in '"`[': # a quoted CTE name
1547
+ close = "]" if s[j] == "[" else s[j]
1548
+ k = j + 1
1549
+ while k < n:
1550
+ if s[k] == close:
1551
+ if k + 1 < n and s[k + 1] == close:
1552
+ k += 2
1553
+ continue
1554
+ return k + 1
1555
+ k += 1
1556
+ return -1
1557
+
1558
+ def parens(j):
1559
+ j = ws(j)
1560
+ if j >= n or s[j] != "(":
1561
+ return -1
1562
+ depth = 0
1563
+ while j < n:
1564
+ if s[j] == "(":
1565
+ depth += 1
1566
+ elif s[j] == ")":
1567
+ depth -= 1
1568
+ if depth == 0:
1569
+ return j + 1
1570
+ j += 1
1571
+ return -1
1572
+
1573
+ if word(i)[0] == "recursive":
1574
+ i = word(i)[1]
1575
+ while True:
1576
+ # each CTE definition: name, optional column list, AS,
1577
+ # optional (NOT) MATERIALIZED, one balanced query group
1578
+ if ws(i) >= n:
1579
+ return None # no name after WITH or comma: malformed
1580
+ i = ident(i)
1581
+ if i < 0:
1582
+ return None
1583
+ j = ws(i)
1584
+ if j < n and s[j] == "(": # optional column list
1585
+ i = parens(i)
1586
+ if i < 0:
1587
+ return None
1588
+ w, i = word(i)
1589
+ if w != "as":
1590
+ return None
1591
+ w, i = word(i)
1592
+ if w == "materialized":
1593
+ i = word(i)[1]
1594
+ elif w == "not":
1595
+ w, i = word(i)
1596
+ if w != "materialized":
1597
+ return None
1598
+ i = word(i)[1]
1599
+ i = parens(i) # the CTE query: may nest parens, commas, verbs
1600
+ if i < 0:
1601
+ return None
1602
+ j = ws(i)
1603
+ if j < n and s[j] == ",":
1604
+ i = j + 1
1605
+ continue
1606
+ return word(i)[0] # the main verb, or None when missing
1607
+
1608
+
1503
1609
  def _go_rawsql_write(call, f):
1504
1610
  """Slice-4 grade for the GORM Raw helper: the call is a write only
1505
1611
  when argument 0 is an interpreted or backtick string literal whose
1506
- first keyword (leading whitespace stripped, case-insensitive) is a
1507
- write verb in _GO_RAWSQL_WRITE_VERBS. A variable, a concatenation,
1508
- a fmt.Sprintf call, or any non-literal first argument never fires
1509
- (literal() returns None); read-first SQL (SELECT, SHOW, DESCRIBE,
1510
- EXPLAIN) and a leading WITH (CTE) fall through as reads."""
1612
+ grading keyword (case-insensitive) is a write verb in
1613
+ _GO_RAWSQL_WRITE_VERBS. A variable, a concatenation, a fmt.Sprintf
1614
+ call, or any non-literal first argument never fires (literal()
1615
+ returns None); read-first SQL (SELECT, SHOW, DESCRIBE, EXPLAIN)
1616
+ falls through as a read. Slice 5: the grading keyword of a leading
1617
+ WITH statement is the main statement verb past the CTE list, so
1618
+ WITH ... DELETE / INSERT / UPDATE fires while WITH ... SELECT
1619
+ stays silent; a malformed WITH statement grades as a read."""
1511
1620
  args = _go_args(call)
1512
1621
  if not args:
1513
1622
  return False
1514
1623
  lit = f.literal(args[0])
1515
1624
  if lit is None:
1516
1625
  return False
1517
- words = lit.lstrip().split(None, 1)
1518
- return bool(words) and words[0].lower() in _GO_RAWSQL_WRITE_VERBS
1626
+ return _go_sql_first_kw(lit) in _GO_RAWSQL_WRITE_VERBS
1627
+
1628
+
1519
1629
 
1520
1630
 
1521
1631
  class _GoFile:
@@ -1643,8 +1753,9 @@ def _go_classify(call, chain, f, pkg_paths=None):
1643
1753
  # GORM shape: db.Create / Save / Update / Updates / Delete
1644
1754
  return "go-orm-write", "db"
1645
1755
  if tail == "raw" and _go_rawsql_write(call, f):
1646
- # GORM raw SQL (slice 4): db.Raw / tx.Raw, only when the
1647
- # literal SQL's first keyword is a write verb.
1756
+ # GORM raw SQL (slices 4-5): db.Raw / tx.Raw, only when
1757
+ # the literal SQL's grading keyword is a write verb (past
1758
+ # a leading WITH when present).
1648
1759
  return "go-rawsql-write", "db"
1649
1760
  if tail in _GO_HTTP_VERBS:
1650
1761
  if norm[0] == "http" and len(norm) == 2:
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: pywrit
3
- Version: 0.2.18
3
+ Version: 0.2.19
4
4
  Summary: Python client + CLI for Writ — the gate before the write
5
5
  License-Expression: MIT
6
6
  Project-URL: Homepage, https://withwrit.com
@@ -61,7 +61,7 @@ install test.
61
61
  | --- | --- | --- | --- |
62
62
  | Python | Yes | Yes, inserts `_writ_check` gates | Parsed with the stdlib `ast`, no extra needed |
63
63
  | TypeScript / JavaScript | Yes, with `pywrit[polyglot]` | No, scan only | Needs the extra: `pip install 'pywrit[polyglot]'`. Without it, the report says so loudly: a warning block names the unscanned files instead of reporting zero findings |
64
- | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
64
+ | Go | Yes, with `pywrit[polyglot]` | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client <client>.<Resource>.<New\|Update\|Delete\|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients <pkg>.<New\|Update\|Delete\|Create> on an imported resource-shaped package, GORM Raw `db.Raw` / `tx.Raw` with a write-first SQL string literal, including WITH-CTE writes. Without the extra, the report names the unscanned Go files in the same warning block as TS/JS |
65
65
 
66
66
  ## 60-second quickstart: scan → wrap → gate
67
67
 
@@ -191,7 +191,7 @@ pipeline (twilio-style generated clients, e.g. `twilio-node`).
191
191
 
192
192
  pip install 'pywrit[polyglot]'
193
193
 
194
- Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), a leading WITH (CTE), or a Raw call on a non-db/tx receiver never fires. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: WITH-CTE raw-SQL writes and other Go write patterns.
194
+ Covered in this first family plus request-pipeline and package-level generated-client detection: `database/sql` `Exec` / `ExecContext`, GORM `Create` / `Save` / `Update` / `Updates` / `Delete`, HTTP client `Post` / `Put` / `Patch` / `Delete` and `http.NewRequest` / `NewRequestWithContext` with a write method, generated-client calls shaped `<client>.<Resource>.<New|Update|Delete|Create>` with an uppercase resource segment (the stripe-go shape), request-pipeline calls `X.Call(method, ...)` / `X.RawRequest(method, ...)` where argument 0 is a write method (the `stripe.Backend` shape, e.g. `c.B.Call(http.MethodPost, "/v1/accounts", ...)`), and package-level generated-client calls `<pkg>.<New|Update|Delete|Create>(...)` where `<pkg>` is imported in the file and the import path's last segment is resource-shaped, not structy (`params`, `config`, ...) and not service-, client-, library-, or test-double-shaped (`svc`, `service`, `client`, `api`, `sdk`, `internal`, `mock`, `fake`). This is the pre-v87 stripe-go shape (`charge.New(params)`), aliased imports included: the guard reads the import path, so `acmeinvoice "example.com/acme/acme-payments/invoice"` fires while `paymentsvc.New(cfg)` does not. GORM raw-SQL calls `db.Raw("INSERT INTO ...")` / `tx.Raw("DELETE FROM ...")` fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), or a Raw call on a non-db/tx receiver never fires. A leading WITH is graded past: the CTE list is parsed and the main statement's first keyword is graded the same way, so WITH ... DELETE / INSERT / UPDATE fires while WITH ... SELECT stays silent; a write verb inside a CTE query never decides the grade, and a malformed WITH grades as a read. GET/HEAD requests, `db.Query` / `QueryRow`, bare constructors (`.New` on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. `_test.go` files and `vendor/` trees are skipped. Go is **scan-only**: `writ scan --apply` never rewrites `.go` files, gate those by hand. Not yet covered: other Go write patterns.
195
195
 
196
196
  ## GitHub Action
197
197
 
@@ -113,8 +113,8 @@ class FixtureRulesTest(unittest.TestCase):
113
113
  verbs = __import__("json").loads(policy.read_text())
114
114
  self.assertEqual(code, 0)
115
115
  n = len(_expected())
116
- self.assertIn("go files scanned: 7 skipped: 0 (scan only, no --apply)", out)
117
- self.assertIn("go write sites: %d in 11 function(s)" % n, out)
116
+ self.assertIn("go files scanned: 8 skipped: 0 (scan only, no --apply)", out)
117
+ self.assertIn("go write sites: %d in 13 function(s)" % n, out)
118
118
  self.assertIn("go gated: 0/%d (0%%)" % n, out)
119
119
  self.assertIn(" db.go:13 [db] go-db-write deleteOrder(): "
120
120
  "db.Exec(\"DELETE FROM orders WHERE id = $1\", id)", out)
@@ -317,7 +317,7 @@ class JsonReportTest(unittest.TestCase):
317
317
  self.assertEqual(code, 0, out)
318
318
  doc = j.loads(out)
319
319
  self.assertFalse(doc["go_hint"])
320
- self.assertEqual(doc["files_scanned"], 7)
320
+ self.assertEqual(doc["files_scanned"], 8)
321
321
  go_findings = [f for f in doc["findings"]
322
322
  if f["language"] == "go"]
323
323
  self.assertEqual(len(go_findings), len(_expected()), doc)
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes