local-triage 0.0.0-stage → 0.10.0-dev.32
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.
- package/LICENSE +21 -0
- package/README.md +90 -2
- package/THIRD-PARTY-NOTICES.md +48 -0
- package/app/__init__.py +3 -0
- package/app/affiliation.py +137 -0
- package/app/ask.py +300 -0
- package/app/build_info.py +98 -0
- package/app/capec.py +168 -0
- package/app/capec_view.py +27 -0
- package/app/codecmp.py +59 -0
- package/app/config.py +411 -0
- package/app/context.py +1451 -0
- package/app/cvss.py +357 -0
- package/app/db.py +6234 -0
- package/app/defect.py +670 -0
- package/app/defect_check.py +323 -0
- package/app/defect_drafts.py +612 -0
- package/app/defect_dto.py +149 -0
- package/app/defect_fields.py +248 -0
- package/app/defect_form.py +124 -0
- package/app/defect_links.py +107 -0
- package/app/defect_local_text.py +103 -0
- package/app/defect_references.py +164 -0
- package/app/defect_where.py +147 -0
- package/app/ecosystem.py +51 -0
- package/app/executors.py +660 -0
- package/app/feeds.py +1231 -0
- package/app/guard.py +164 -0
- package/app/hub_block_builder.py +200 -0
- package/app/hub_block_version.py +220 -0
- package/app/hub_defects.py +4469 -0
- package/app/hub_effects.py +421 -0
- package/app/hub_entity_versions.py +108 -0
- package/app/hub_import.py +2054 -0
- package/app/hub_onboarding.py +114 -0
- package/app/hub_ops.py +330 -0
- package/app/hub_pull.py +1195 -0
- package/app/hub_state.py +255 -0
- package/app/hub_status.py +237 -0
- package/app/hub_sync.py +619 -0
- package/app/hub_sync_api.py +241 -0
- package/app/hub_sync_compare.py +1054 -0
- package/app/hub_sync_contract.py +75 -0
- package/app/hub_template_model.py +74 -0
- package/app/hub_text_scale.py +159 -0
- package/app/journal.py +250 -0
- package/app/llm.py +850 -0
- package/app/llm_chat.py +596 -0
- package/app/llm_http.py +319 -0
- package/app/llm_messages.py +401 -0
- package/app/llm_net.py +764 -0
- package/app/llm_ollama.py +571 -0
- package/app/lockfile.py +505 -0
- package/app/logsafe.py +54 -0
- package/app/main.py +367 -0
- package/app/mask_display.py +132 -0
- package/app/masking.py +814 -0
- package/app/metrics.py +194 -0
- package/app/model_traffic.py +519 -0
- package/app/models.py +483 -0
- package/app/navigation.py +121 -0
- package/app/osv.py +279 -0
- package/app/package_identity.py +189 -0
- package/app/package_transition.py +824 -0
- package/app/profile_gate.py +71 -0
- package/app/prompts.py +1108 -0
- package/app/provider_keys.py +189 -0
- package/app/providers.py +511 -0
- package/app/routes/__init__.py +10 -0
- package/app/routes/api.py +153 -0
- package/app/routes/capec.py +186 -0
- package/app/routes/common.py +407 -0
- package/app/routes/components.py +1499 -0
- package/app/routes/cwe.py +168 -0
- package/app/routes/decision_selected.py +153 -0
- package/app/routes/defect_add.py +223 -0
- package/app/routes/defect_card_routes.py +363 -0
- package/app/routes/defect_selected.py +342 -0
- package/app/routes/feeds.py +155 -0
- package/app/routes/findings.py +2736 -0
- package/app/routes/hub.py +402 -0
- package/app/routes/hub_bulk.py +288 -0
- package/app/routes/hub_defect_routes.py +1945 -0
- package/app/routes/hub_status_routes.py +1132 -0
- package/app/routes/hub_sync_routes.py +463 -0
- package/app/routes/journal.py +132 -0
- package/app/routes/projects.py +1601 -0
- package/app/routes/providers.py +336 -0
- package/app/routes/references.py +26 -0
- package/app/routes/runs.py +219 -0
- package/app/routes/sca.py +2722 -0
- package/app/routes/settings.py +163 -0
- package/app/run_errors.py +151 -0
- package/app/sca.py +1662 -0
- package/app/sca_contract.py +1289 -0
- package/app/sca_research.py +1089 -0
- package/app/sca_research_net.py +1007 -0
- package/app/sca_text.py +965 -0
- package/app/serve.py +70 -0
- package/app/settings_store.py +262 -0
- package/app/static/app.css +2802 -0
- package/app/static/app.js +3772 -0
- package/app/static/capec-license.txt +9 -0
- package/app/static/favicon.svg +1 -0
- package/app/static/fonts/Golos-Text_DemiBold.woff2 +0 -0
- package/app/static/fonts/Golos-Text_Regular.woff2 +0 -0
- package/app/static/fonts/OFL.txt +90 -0
- package/app/static/navigation.js +234 -0
- package/app/static/observability.js +121 -0
- package/app/static/theme.js +49 -0
- package/app/storage/__init__.py +16 -0
- package/app/storage/local_state.py +246 -0
- package/app/storage/migrate.py +110 -0
- package/app/storage/migrations/postgresql/0001_baseline.sql +896 -0
- package/app/storage/migrations/postgresql/0002_feeds_and_secrets.sql +55 -0
- package/app/storage/migrations/postgresql/0003_project_mask_display.sql +5 -0
- package/app/storage/migrations/postgresql/0004_package_identity.sql +36 -0
- package/app/storage/postgresql.py +573 -0
- package/app/storage/schema.py +619 -0
- package/app/storage/sql.py +57 -0
- package/app/storage/tools.py +254 -0
- package/app/telemetry.py +307 -0
- package/app/templates/base.html +91 -0
- package/app/templates/capec/context.html +3 -0
- package/app/templates/capec/detail.html +27 -0
- package/app/templates/capec/index.html +128 -0
- package/app/templates/components/_archive.html +11 -0
- package/app/templates/components/archived.html +19 -0
- package/app/templates/components/batch.html +35 -0
- package/app/templates/components/detail.html +332 -0
- package/app/templates/components/index.html +338 -0
- package/app/templates/components/research_preview.html +80 -0
- package/app/templates/components/research_run.html +54 -0
- package/app/templates/cwe/bdu.html +56 -0
- package/app/templates/cwe/detail.html +233 -0
- package/app/templates/cwe/index.html +97 -0
- package/app/templates/error.html +8 -0
- package/app/templates/feeds/index.html +65 -0
- package/app/templates/findings/card.html +639 -0
- package/app/templates/findings/decision_selected.html +41 -0
- package/app/templates/findings/defect_add.html +46 -0
- package/app/templates/findings/defect_selected.html +47 -0
- package/app/templates/findings/list.html +153 -0
- package/app/templates/findings/send_selected.html +53 -0
- package/app/templates/findings/trace.html +72 -0
- package/app/templates/journal/detail.html +19 -0
- package/app/templates/journal/index.html +19 -0
- package/app/templates/macros.html +440 -0
- package/app/templates/navigation-fields.html +1 -0
- package/app/templates/navigation.html +11 -0
- package/app/templates/projects/_identity_summary.html +42 -0
- package/app/templates/projects/defect_card.html +153 -0
- package/app/templates/projects/defect_create_preview.html +17 -0
- package/app/templates/projects/defect_fields_diff.html +6 -0
- package/app/templates/projects/defect_fields_form.html +40 -0
- package/app/templates/projects/defect_references.html +17 -0
- package/app/templates/projects/defect_sync_preview.html +28 -0
- package/app/templates/projects/defect_update_actions.html +6 -0
- package/app/templates/projects/defect_update_preview.html +24 -0
- package/app/templates/projects/defects.html +126 -0
- package/app/templates/projects/delete.html +31 -0
- package/app/templates/projects/external.html +61 -0
- package/app/templates/projects/folders.html +64 -0
- package/app/templates/projects/hub_accepted.html +10 -0
- package/app/templates/projects/hub_assignment.html +50 -0
- package/app/templates/projects/hub_pending.html +20 -0
- package/app/templates/projects/hub_pending_list.html +17 -0
- package/app/templates/projects/hub_state_note.html +23 -0
- package/app/templates/projects/hub_step_note.html +5 -0
- package/app/templates/projects/hub_sync.html +105 -0
- package/app/templates/projects/hub_sync_confirm.html +32 -0
- package/app/templates/projects/hub_sync_worker.html +5 -0
- package/app/templates/projects/hub_text_rules.html +64 -0
- package/app/templates/projects/identity_report.html +74 -0
- package/app/templates/projects/list.html +90 -0
- package/app/templates/projects/project.html +433 -0
- package/app/templates/reference-missing.html +14 -0
- package/app/templates/runs/run.html +166 -0
- package/app/templates/sca/card.html +476 -0
- package/app/templates/sca/index.html +321 -0
- package/app/templates/settings/hub_url.html +31 -0
- package/app/templates/settings/index.html +216 -0
- package/app/templates/settings/provider.html +229 -0
- package/app/templates/settings/providers.html +37 -0
- package/app/templates/worklists.html +52 -0
- package/app/textsafe.py +117 -0
- package/app/timing.py +245 -0
- package/app/triage.py +1743 -0
- package/app/view.py +430 -0
- package/app/worklists.py +204 -0
- package/examples/demo/demo-hub-report-v2.xlsx +0 -0
- package/examples/demo/demo-hub-report.xlsx +0 -0
- package/examples/demo/repos/billing-core/pom.xml +30 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/Invoice.java +9 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceRepository.java +51 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceStatus.java +11 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/config/DatabaseSettings.java +18 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/payment/PaymentTokenService.java +35 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/web/InvoiceExportController.java +57 -0
- package/examples/demo/repos/catalog-api/catalog_api/__init__.py +1 -0
- package/examples/demo/repos/catalog-api/catalog_api/products.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/tasks.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/views.py +17 -0
- package/examples/demo/repos/catalog-api/requirements.txt +3 -0
- package/npm/build.json +5 -0
- package/npm/cli.js +346 -0
- package/npm/files.manifest +224 -0
- package/npm/lib/binding.js +64 -0
- package/npm/lib/cluster.js +330 -0
- package/npm/lib/env.js +88 -0
- package/npm/lib/fsx.js +125 -0
- package/npm/lib/http.js +53 -0
- package/npm/lib/metrics.js +73 -0
- package/npm/lib/paths.js +150 -0
- package/npm/lib/pg.js +351 -0
- package/npm/lib/proc.js +101 -0
- package/npm/lib/python.js +133 -0
- package/npm/lib/stand.js +46 -0
- package/npm/lib/supervisor.js +1141 -0
- package/npm/lib/version.js +21 -0
- package/npm/requirements.txt +476 -0
- package/npm-shrinkwrap.json +111 -0
- package/package.json +37 -4
package/app/context.py
ADDED
|
@@ -0,0 +1,1451 @@
|
|
|
1
|
+
"""Срез кода вокруг находки: папка репозитория, поиск файла, чтение, маскирование, объемлющий метод, сверка
|
|
2
|
+
строки из выгрузки со строкой файла.
|
|
3
|
+
|
|
4
|
+
Репозитории только читаются: никаких команд в них не запускается. Папка репозитория и файл должны лежать внутри
|
|
5
|
+
корня (resolve_repo, find_file): выход через «..», абсолютный путь или символическую ссылку – отказ. Проверка пути
|
|
6
|
+
и чтение не разделены (_read_inside): файл сначала открывается, а проверяется уже открытый дескриптор, и читается
|
|
7
|
+
не больше предела размера – подмена файла или папки ссылкой между проверкой и чтением наружу не выводит.
|
|
8
|
+
|
|
9
|
+
Если кода из репозитория нет (папка не задана, файла нет, файл слишком велик или двоичный, строка за пределами
|
|
10
|
+
файла), контекстом служит строка кода из выгрузки (поле snippet находки, колонка Source code) – статус
|
|
11
|
+
'export_line_only'. Сверка фрагмента из выгрузки со строкой файла и её соседями (export_line_check)
|
|
12
|
+
помогает найти место срабатывания, но сама по себе не доказывает смену кода после сканирования.
|
|
13
|
+
"""
|
|
14
|
+
|
|
15
|
+
from __future__ import annotations
|
|
16
|
+
|
|
17
|
+
import bisect
|
|
18
|
+
import codecs
|
|
19
|
+
import hashlib
|
|
20
|
+
import html
|
|
21
|
+
import os
|
|
22
|
+
import re
|
|
23
|
+
import stat
|
|
24
|
+
import threading
|
|
25
|
+
import time
|
|
26
|
+
from collections import OrderedDict
|
|
27
|
+
from dataclasses import replace
|
|
28
|
+
from pathlib import Path
|
|
29
|
+
from typing import NamedTuple
|
|
30
|
+
|
|
31
|
+
from app.masking import (PLACEHOLDER_RE, count_placeholders, is_credential_finding, mask_all_literals,
|
|
32
|
+
mask_literal_token, mask_text, recording_active, secret_assignment_before)
|
|
33
|
+
from app.models import CodeContext, Finding
|
|
34
|
+
|
|
35
|
+
LINE_LIMIT = 400 # строки длиннее (минифицированный код) обрезаются до стольких знаков
|
|
36
|
+
# Файлы больше не читаются: файл маскируется целиком, а это до десятков секунд на мегабайт (строки вида
|
|
37
|
+
# password=… подряд). Исходники такого размера – почти всегда код из генераторов или собранный код.
|
|
38
|
+
MAX_FILE_BYTES = 2 * 1024 * 1024
|
|
39
|
+
MASK_CACHE_FILES = 16 # маскированный текст стольких последних файлов хранится в памяти
|
|
40
|
+
MASK_CACHE_CHARS = 40_000_000 # …но не больше стольких знаков вместе
|
|
41
|
+
HEADER_LIMIT = 2000 # заголовок блока длиннее не разбирается как сигнатура
|
|
42
|
+
SIGNATURE_LIMIT = 300 # предел длины сигнатуры объемлющего метода
|
|
43
|
+
CUT_MARK = " …[обрезано]"
|
|
44
|
+
MAX_INDEX_FILES = 300_000 # поиск файла по окончанию пути: файлов в индексе репозитория не больше
|
|
45
|
+
MAX_INDEX_DIRS = 100_000 # …папок не больше
|
|
46
|
+
INDEX_SECONDS = 20.0 # …и не дольше стольких секунд
|
|
47
|
+
INDEX_TTL = 120.0 # секунд: индекс файлов репозитория переиспользуется
|
|
48
|
+
SKIP_DIRS = {".git", ".hg", ".svn", "node_modules", "bower_components", ".venv", "venv", "__pycache__", ".idea", ".vs",
|
|
49
|
+
".gradle", "target"}
|
|
50
|
+
|
|
51
|
+
LANGUAGES = {
|
|
52
|
+
".java": "java", ".kt": "kotlin", ".kts": "kotlin", ".scala": "scala", ".groovy": "groovy", ".gradle": "groovy",
|
|
53
|
+
".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".vue": "javascript",
|
|
54
|
+
".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
|
|
55
|
+
".py": "python", ".pyw": "python", ".cs": "csharp", ".go": "go", ".php": "php", ".rb": "ruby",
|
|
56
|
+
".swift": "swift", ".rs": "rust", ".c": "c", ".h": "c", ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp",
|
|
57
|
+
".hpp": "cpp", ".hh": "cpp", ".jsp": "jsp", ".cshtml": "razor", ".html": "html", ".htm": "html",
|
|
58
|
+
".xml": "xml", ".sql": "sql", ".json": "json", ".yml": "yaml", ".yaml": "yaml", ".properties": "properties",
|
|
59
|
+
".sh": "shell", ".ps1": "powershell",
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
def language_of(path: str) -> str:
|
|
64
|
+
"""Язык файла по расширению ("" – неизвестен)."""
|
|
65
|
+
return LANGUAGES.get(os.path.splitext(str(path))[1].lower(), "")
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
def norm_path(value: str) -> str:
|
|
69
|
+
"""Путь: прямые слэши, без «./», ведущего «/» и двойных слэшей. «..» не раскрывается."""
|
|
70
|
+
s = str(value or "").strip().replace("\\", "/")
|
|
71
|
+
return "/".join(part for part in s.split("/") if part not in ("", "."))
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
# ============================================================================ границы: корень и репозиторий
|
|
75
|
+
|
|
76
|
+
_DRIVE = re.compile(r"^[A-Za-z]:")
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def _is_inside(path: str, folder: str) -> bool:
|
|
80
|
+
"""path – это folder или лежит внутри неё (пути уже раскрыты realpath; без учёта регистра на Windows)."""
|
|
81
|
+
p = os.path.normcase(path)
|
|
82
|
+
f = os.path.normcase(folder).rstrip("\\/")
|
|
83
|
+
return p == f or p.startswith(f + os.sep) or (os.altsep is not None and p.startswith(f + os.altsep))
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
def resolve_repo(repos_root: Path, folder: str) -> Path:
|
|
87
|
+
"""Папка внутри корня repos_root -> абсолютный путь (символические ссылки раскрыты).
|
|
88
|
+
|
|
89
|
+
folder – путь от корня, с прямыми или обратными слэшами; "" или "." – сам корень. Абсолютный путь, диск («C:»),
|
|
90
|
+
сетевой путь, сегмент «..», двоеточие и управляющие символы в пути, выход за корень через символическую ссылку –
|
|
91
|
+
ValueError. Существование папки не проверяется.
|
|
92
|
+
"""
|
|
93
|
+
text = str(folder or "").strip()
|
|
94
|
+
if any(ord(ch) < 32 for ch in text):
|
|
95
|
+
raise ValueError("В пути к папке недопустимые символы.")
|
|
96
|
+
norm = text.replace("\\", "/")
|
|
97
|
+
if norm.startswith("/") or _DRIVE.match(norm):
|
|
98
|
+
raise ValueError("Путь к папке должен быть относительным – от корня папки с репозиториями.")
|
|
99
|
+
parts = [p for p in norm.split("/") if p not in ("", ".")]
|
|
100
|
+
if any(p == ".." for p in parts):
|
|
101
|
+
raise ValueError("Путь к папке не должен выходить за пределы корня папки с репозиториями («..»).")
|
|
102
|
+
if any(":" in p for p in parts):
|
|
103
|
+
raise ValueError("В пути к папке не должно быть двоеточия.")
|
|
104
|
+
root = os.path.realpath(str(repos_root))
|
|
105
|
+
target = os.path.realpath(os.path.join(root, *parts)) if parts else root
|
|
106
|
+
if not _is_inside(target, root):
|
|
107
|
+
raise ValueError("Папка ведёт за пределы корня папки с репозиториями (символическая ссылка?).")
|
|
108
|
+
return Path(target)
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
# ============================================================================ ревизия клона
|
|
112
|
+
|
|
113
|
+
_COMMIT = re.compile(r"[0-9a-f]{40}(?:[0-9a-f]{24})?") # SHA-1 или SHA-256
|
|
114
|
+
_REF = re.compile(r"refs/[A-Za-z0-9._/-]{1,240}")
|
|
115
|
+
MAX_PACKED_REFS_BYTES = 50 * 1024 * 1024
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
def _git_text(git_dir: str, path: str, limit: int = 4096) -> str | None:
|
|
119
|
+
"""Небольшой служебный файл git: не ссылка, на самом деле лежит внутри git_dir (проверяется открытый файл,
|
|
120
|
+
поэтому и промежуточные папки наружу не уводят), не больше limit байт; иначе None."""
|
|
121
|
+
try:
|
|
122
|
+
if _is_link_or_junction(path):
|
|
123
|
+
return None
|
|
124
|
+
raw = _read_inside(os.path.realpath(git_dir), path, limit)[0]
|
|
125
|
+
except (OSError, _ReadRefused):
|
|
126
|
+
return None
|
|
127
|
+
return raw.decode("ascii", errors="replace")
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def clone_revision(repo_dir: Path | None) -> str:
|
|
131
|
+
"""Ревизия клона git – хеш коммита, на котором стоит рабочая копия (HEAD): HEAD с хешем или ссылка на ветку
|
|
132
|
+
(файл ссылки либо packed-refs). Не клон, .git – файл (worktree) или ссылка, ревизию не прочитать – "": такие
|
|
133
|
+
папки по ревизии не отслеживаются. Читаются только файлы внутри .git самого клона."""
|
|
134
|
+
if repo_dir is None:
|
|
135
|
+
return ""
|
|
136
|
+
git = os.path.join(str(repo_dir), ".git")
|
|
137
|
+
if _is_link_or_junction(git) or not os.path.isdir(git):
|
|
138
|
+
return ""
|
|
139
|
+
head = (_git_text(git, os.path.join(git, "HEAD")) or "").strip()
|
|
140
|
+
if _COMMIT.fullmatch(head):
|
|
141
|
+
return head # отсоединённый HEAD
|
|
142
|
+
if not head.startswith("ref:"):
|
|
143
|
+
return ""
|
|
144
|
+
ref = head[4:].strip()
|
|
145
|
+
if not _REF.fullmatch(ref) or ".." in ref.split("/"):
|
|
146
|
+
return ""
|
|
147
|
+
value = (_git_text(git, os.path.join(git, *ref.split("/"))) or "").strip()
|
|
148
|
+
if _COMMIT.fullmatch(value):
|
|
149
|
+
return value
|
|
150
|
+
packed = _git_text(git, os.path.join(git, "packed-refs"), MAX_PACKED_REFS_BYTES) or ""
|
|
151
|
+
for line in packed.splitlines():
|
|
152
|
+
commit, _, name = line.partition(" ")
|
|
153
|
+
if name.strip() == ref and _COMMIT.fullmatch(commit):
|
|
154
|
+
return commit
|
|
155
|
+
return ""
|
|
156
|
+
|
|
157
|
+
|
|
158
|
+
_INDEX_LOCK = threading.Lock()
|
|
159
|
+
_INDEX_CACHE: dict[str, tuple[float, dict[str, list[str]], bool]] = {}
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
def _is_link_or_junction(path: str) -> bool:
|
|
163
|
+
"""Символическая ссылка или точка повторного анализа Windows (точка соединения и т. п.)."""
|
|
164
|
+
try:
|
|
165
|
+
st = os.lstat(path)
|
|
166
|
+
except OSError:
|
|
167
|
+
return True
|
|
168
|
+
return os.path.islink(path) or bool(getattr(st, "st_reparse_tag", 0))
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
def _file_index(root: str) -> tuple[dict[str, list[str]], bool]:
|
|
172
|
+
"""({имя файла в нижнем регистре: [пути от корня репозитория]}, индекс полный).
|
|
173
|
+
|
|
174
|
+
Обход ограничен: не больше MAX_INDEX_FILES файлов, MAX_INDEX_DIRS папок и INDEX_SECONDS секунд; служебные папки
|
|
175
|
+
(SKIP_DIRS), символические ссылки и точки соединения не обходятся, каждая папка – один раз. Если предел
|
|
176
|
+
достигнут или папку не удалось прочитать, индекс неполный: по нему нельзя утверждать, что совпадение
|
|
177
|
+
единственное. Индекс живёт INDEX_TTL секунд."""
|
|
178
|
+
now = time.monotonic()
|
|
179
|
+
with _INDEX_LOCK:
|
|
180
|
+
cached = _INDEX_CACHE.get(root)
|
|
181
|
+
if cached and now - cached[0] < INDEX_TTL:
|
|
182
|
+
return cached[1], cached[2]
|
|
183
|
+
index: dict[str, list[str]] = {}
|
|
184
|
+
files_seen, dirs_seen, complete = 0, 0, True
|
|
185
|
+
norm_root = os.path.normcase(root)
|
|
186
|
+
visited = {norm_root}
|
|
187
|
+
stack = [(root, "")]
|
|
188
|
+
while stack and complete:
|
|
189
|
+
folder, rel_folder = stack.pop()
|
|
190
|
+
try:
|
|
191
|
+
with os.scandir(folder) as entries: # папка читается по одной записи: предел проверяется сразу
|
|
192
|
+
for entry in entries:
|
|
193
|
+
if time.monotonic() - now > INDEX_SECONDS:
|
|
194
|
+
complete = False
|
|
195
|
+
break
|
|
196
|
+
rel = f"{rel_folder}/{entry.name}" if rel_folder else entry.name
|
|
197
|
+
if entry.is_dir(follow_symlinks=False):
|
|
198
|
+
if entry.name in SKIP_DIRS or _is_link_or_junction(entry.path):
|
|
199
|
+
continue
|
|
200
|
+
real = os.path.normcase(os.path.realpath(entry.path))
|
|
201
|
+
if real in visited or not _is_inside(real, norm_root):
|
|
202
|
+
continue
|
|
203
|
+
visited.add(real)
|
|
204
|
+
dirs_seen += 1
|
|
205
|
+
if dirs_seen > MAX_INDEX_DIRS:
|
|
206
|
+
complete = False
|
|
207
|
+
break
|
|
208
|
+
stack.append((entry.path, rel))
|
|
209
|
+
else:
|
|
210
|
+
files_seen += 1
|
|
211
|
+
if files_seen > MAX_INDEX_FILES:
|
|
212
|
+
complete = False
|
|
213
|
+
break
|
|
214
|
+
index.setdefault(entry.name.lower(), []).append(rel)
|
|
215
|
+
except OSError: # папка не прочитана: о файлах в ней ничего не известно
|
|
216
|
+
complete = False
|
|
217
|
+
with _INDEX_LOCK:
|
|
218
|
+
if len(_INDEX_CACHE) >= 32:
|
|
219
|
+
_INDEX_CACHE.clear()
|
|
220
|
+
_INDEX_CACHE[root] = (now, index, complete)
|
|
221
|
+
return index, complete
|
|
222
|
+
|
|
223
|
+
|
|
224
|
+
def _inside_file(root: str, rel: str) -> Path | None:
|
|
225
|
+
"""Файл rel от корня root -> абсолютный путь, если это файл и он не ведёт за пределы корня; иначе None."""
|
|
226
|
+
real = os.path.realpath(os.path.join(root, *rel.split("/")))
|
|
227
|
+
return Path(real) if _is_inside(real, root) and os.path.isfile(real) else None
|
|
228
|
+
|
|
229
|
+
|
|
230
|
+
def file_presence(repo_dir: Path | None, rel_path: str) -> str:
|
|
231
|
+
"""Есть ли файл находки в репозитории – по тем же правилам, что find_file: "found" – найден однозначно,
|
|
232
|
+
"missing" – подтверждённо нет (обход полный, подходящих файлов нет), "unknown" – не определить: несколько
|
|
233
|
+
подходящих файлов или обход репозитория неполный. Файл не читается."""
|
|
234
|
+
parts = [p for p in str(rel_path or "").strip().replace("\\", "/").split("/") if p not in ("", ".")]
|
|
235
|
+
if not parts or repo_dir is None:
|
|
236
|
+
return "missing"
|
|
237
|
+
root = os.path.realpath(str(repo_dir))
|
|
238
|
+
if not os.path.isdir(root):
|
|
239
|
+
return "missing"
|
|
240
|
+
if not any(p == ".." or ":" in p for p in parts) and os.path.isfile(os.path.join(root, *parts)):
|
|
241
|
+
return "found" if _inside_file(root, "/".join(parts)) is not None else "missing"
|
|
242
|
+
index, complete = _file_index(root)
|
|
243
|
+
if not complete:
|
|
244
|
+
return "unknown"
|
|
245
|
+
same_name = index.get(parts[-1].lower(), [])
|
|
246
|
+
for k in range(len(parts), 0, -1):
|
|
247
|
+
tail = "/".join(parts[-k:]).lower()
|
|
248
|
+
hits = [p for p in same_name if p.lower() == tail or p.lower().endswith("/" + tail)]
|
|
249
|
+
if len(hits) > 1:
|
|
250
|
+
return "unknown"
|
|
251
|
+
if len(hits) == 1:
|
|
252
|
+
return "found" if _inside_file(root, hits[0]) is not None else "missing"
|
|
253
|
+
return "missing"
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
def find_file(repo_dir: Path, rel_path: str) -> Path | None:
|
|
257
|
+
"""Файл находки в репозитории -> абсолютный путь или None.
|
|
258
|
+
|
|
259
|
+
1. Путь как есть.
|
|
260
|
+
2. Иначе – по окончанию пути среди файлов репозитория: нужно единственное совпадение по самому длинному
|
|
261
|
+
окончанию из двух и более частей пути (так находится и путь с лишним началом, например путь сборки
|
|
262
|
+
builds/app/src/A.java) или единственный файл с таким именем. Несколько подходящих файлов – None.
|
|
263
|
+
Обход репозитория ограничен (_file_index): если предел достигнут или часть папок не прочитана, по окончанию
|
|
264
|
+
пути файл не ищется – единственность совпадения не доказать.
|
|
265
|
+
Файлы в служебных папках (SKIP_DIRS) находятся только по точному пути. Файл, который через символическую ссылку
|
|
266
|
+
ведёт за пределы репозитория, не возвращается.
|
|
267
|
+
"""
|
|
268
|
+
parts = [p for p in str(rel_path or "").strip().replace("\\", "/").split("/") if p not in ("", ".")]
|
|
269
|
+
if not parts or repo_dir is None:
|
|
270
|
+
return None
|
|
271
|
+
root = os.path.realpath(str(repo_dir))
|
|
272
|
+
if not os.path.isdir(root):
|
|
273
|
+
return None
|
|
274
|
+
if not any(p == ".." or ":" in p for p in parts) and os.path.isfile(os.path.join(root, *parts)):
|
|
275
|
+
return _inside_file(root, "/".join(parts))
|
|
276
|
+
index, complete = _file_index(root)
|
|
277
|
+
if not complete:
|
|
278
|
+
return None # по неполному индексу единственность совпадения не доказать
|
|
279
|
+
same_name = index.get(parts[-1].lower(), [])
|
|
280
|
+
for k in range(len(parts), 0, -1):
|
|
281
|
+
tail = "/".join(parts[-k:]).lower()
|
|
282
|
+
hits = [p for p in same_name if p.lower() == tail or p.lower().endswith("/" + tail)]
|
|
283
|
+
if len(hits) > 1:
|
|
284
|
+
return None
|
|
285
|
+
if len(hits) == 1: # при k = 1 это единственный файл с таким именем
|
|
286
|
+
return _inside_file(root, hits[0])
|
|
287
|
+
return None
|
|
288
|
+
|
|
289
|
+
|
|
290
|
+
# ============================================================================ чтение файла
|
|
291
|
+
|
|
292
|
+
class _ReadRefused(Exception):
|
|
293
|
+
"""Файл не читается: status – статус среза ('too_large' или 'file_missing'), reason – причина по-русски."""
|
|
294
|
+
|
|
295
|
+
def __init__(self, status: str, reason: str) -> None:
|
|
296
|
+
super().__init__(reason)
|
|
297
|
+
self.status = status
|
|
298
|
+
self.reason = reason
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
# Только чтение; O_BINARY – без перевода строк в Windows; O_NOFOLLOW – последняя часть пути не ссылка (там, где ОС
|
|
302
|
+
# это умеет); O_NONBLOCK – канал (FIFO), подложенный вместо файла, открывается сразу, а не ждёт писателя, и затем
|
|
303
|
+
# отсеивается проверкой дескриптора.
|
|
304
|
+
_OPEN_FLAGS = (os.O_RDONLY | getattr(os, "O_BINARY", 0) | getattr(os, "O_NOINHERIT", 0) | getattr(os, "O_CLOEXEC", 0)
|
|
305
|
+
| getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0) | getattr(os, "O_NOCTTY", 0))
|
|
306
|
+
_READ_CHUNK = 1024 * 1024
|
|
307
|
+
|
|
308
|
+
|
|
309
|
+
def _open_file(path: str) -> int:
|
|
310
|
+
"""Дескриптор файла, открытого только для чтения (_OPEN_FLAGS)."""
|
|
311
|
+
return os.open(path, _OPEN_FLAGS)
|
|
312
|
+
|
|
313
|
+
|
|
314
|
+
def _opened_path(fd: int) -> str | None:
|
|
315
|
+
"""Путь открытого файла по его дескриптору, как его знает ядро (Linux: /proc/self/fd); узнать нельзя – None."""
|
|
316
|
+
try:
|
|
317
|
+
target = os.readlink(f"/proc/self/fd/{fd}")
|
|
318
|
+
except (OSError, ValueError):
|
|
319
|
+
return None
|
|
320
|
+
return target[:-len(" (deleted)")] if target.endswith(" (deleted)") else target
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
def _read_at_most(fd: int, limit: int) -> bytes:
|
|
324
|
+
"""Не больше limit + 1 байт из открытого файла: лишний байт значит, что файл больше предела (вырос после
|
|
325
|
+
проверки размера), и дальше он не читается."""
|
|
326
|
+
chunks, size = [], 0
|
|
327
|
+
while size <= limit:
|
|
328
|
+
chunk = os.read(fd, min(_READ_CHUNK, limit + 1 - size))
|
|
329
|
+
if not chunk:
|
|
330
|
+
break
|
|
331
|
+
chunks.append(chunk)
|
|
332
|
+
size += len(chunk)
|
|
333
|
+
return b"".join(chunks)
|
|
334
|
+
|
|
335
|
+
|
|
336
|
+
def _read_inside(root: str, path: str, limit: int) -> tuple[bytes, os.stat_result, bool, str]:
|
|
337
|
+
"""Файл внутри папки root (уже раскрытой realpath) -> (байты, сведения о файле, файл не менялся во время
|
|
338
|
+
чтения, настоящий путь файла).
|
|
339
|
+
|
|
340
|
+
Сначала файл открывается, затем проверяется открытый дескриптор: это обычный файл, и лежит он на самом деле
|
|
341
|
+
внутри root – по пути открытого файла, который знает ядро (Linux), а где ОС его не даёт – по раскрытому заново
|
|
342
|
+
пути внутри root, который должен вести к тому же файлу (устройство и номер файла, os.path.samestat). Подмена
|
|
343
|
+
файла или промежуточной папки ссылкой между поиском файла и чтением поэтому не выводит чтение наружу. Читается
|
|
344
|
+
не больше limit + 1 байт: файл, выросший после проверки размера, целиком не читается.
|
|
345
|
+
|
|
346
|
+
Не обычный файл или файл вне root – _ReadRefused('file_missing'); больше limit байт – _ReadRefused('too_large');
|
|
347
|
+
сбой открытия или чтения – OSError."""
|
|
348
|
+
fd = _open_file(path)
|
|
349
|
+
try:
|
|
350
|
+
st = os.fstat(fd)
|
|
351
|
+
if not stat.S_ISREG(st.st_mode):
|
|
352
|
+
raise _ReadRefused("file_missing", "это не обычный файл – не читается")
|
|
353
|
+
real = _opened_path(fd)
|
|
354
|
+
if real is not None:
|
|
355
|
+
inside = _is_inside(real, root)
|
|
356
|
+
else:
|
|
357
|
+
real = os.path.realpath(path)
|
|
358
|
+
inside = _is_inside(real, root) and os.path.samestat(st, os.stat(real))
|
|
359
|
+
if not inside:
|
|
360
|
+
raise _ReadRefused("file_missing", "файл ведёт за пределы репозитория или подменён во время чтения – "
|
|
361
|
+
"не читается")
|
|
362
|
+
if st.st_size > limit:
|
|
363
|
+
raise _ReadRefused("too_large", "файл больше предела размера")
|
|
364
|
+
raw = _read_at_most(fd, limit)
|
|
365
|
+
if len(raw) > limit:
|
|
366
|
+
raise _ReadRefused("too_large", "файл вырос во время чтения и стал больше предела размера")
|
|
367
|
+
after = os.fstat(fd)
|
|
368
|
+
stable = (after.st_size, after.st_mtime_ns) == (st.st_size, st.st_mtime_ns) and len(raw) == st.st_size
|
|
369
|
+
return raw, st, stable, real
|
|
370
|
+
finally:
|
|
371
|
+
os.close(fd)
|
|
372
|
+
|
|
373
|
+
|
|
374
|
+
def decode_source(raw: bytes) -> str | None:
|
|
375
|
+
"""Байты файла -> текст (UTF-8 с BOM или без, UTF-16 с BOM, иначе cp1251); двоичный файл -> None.
|
|
376
|
+
|
|
377
|
+
CRLF заменяется на LF; одиночный CR и прочие разделители не трогаются: номера строк должны совпадать
|
|
378
|
+
с номерами в отчёте анализатора.
|
|
379
|
+
"""
|
|
380
|
+
if raw.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
|
|
381
|
+
text = raw.decode("utf-16", errors="replace")
|
|
382
|
+
elif b"\x00" in raw[:8192]:
|
|
383
|
+
return None
|
|
384
|
+
else:
|
|
385
|
+
try:
|
|
386
|
+
text = raw.decode("utf-8-sig")
|
|
387
|
+
except UnicodeDecodeError:
|
|
388
|
+
text = raw.decode("cp1251", errors="replace")
|
|
389
|
+
return text.replace("\r\n", "\n")
|
|
390
|
+
|
|
391
|
+
|
|
392
|
+
def _split_lines(text: str) -> list[str]:
|
|
393
|
+
lines = text.split("\n") if text else []
|
|
394
|
+
if text.endswith("\n"):
|
|
395
|
+
lines.pop()
|
|
396
|
+
return lines
|
|
397
|
+
|
|
398
|
+
|
|
399
|
+
# ============================================================================ объемлющий метод: простые эвристики
|
|
400
|
+
|
|
401
|
+
# Комментарии и строковые литералы по языкам. Перед поиском блоков они заменяются пробелами (длина текста и
|
|
402
|
+
# переводы строк сохраняются), чтобы скобки и слова внутри них не сбивали разбор. Незакрытый комментарий или
|
|
403
|
+
# литерал продолжается до конца текста (однострочный литерал – до конца строки): так разбор линейный даже на
|
|
404
|
+
# тексте из одних «/*» или кавычек.
|
|
405
|
+
_C_COMMENT = r"//[^\n]*|/\*[\s\S]*?(?:\*/|\Z)"
|
|
406
|
+
_DQ = r'"(?:\\.|[^"\\\n])*(?:"|\\?(?=\n)|\\?\Z)'
|
|
407
|
+
_SQ = r"'(?:\\.|[^'\\\n])*(?:'|\\?(?=\n)|\\?\Z)"
|
|
408
|
+
_TRIPLE_DQ = r'"""(?:\\[\s\S]|(?!""")[^\\])*(?:"""|\\?\Z)' # экранированная кавычка литерал не заканчивает
|
|
409
|
+
_TRIPLE_SQ = r"'''(?:\\[\s\S]|(?!''')[^\\])*(?:'''|\\?\Z)"
|
|
410
|
+
_BACKTICK = r"`(?:\\[\s\S]|[^`\\])*(?:`|\\?\Z)"
|
|
411
|
+
_CS_VERBATIM = r'(?:@\$?|\$@)"(?:""|[^"])*(?:"|\Z)'
|
|
412
|
+
# Сырые строки: C++ R"метка(…)метка" и Rust r#"…"#. Единственная группа в своём разборщике – для \1.
|
|
413
|
+
_CPP_RAW = r'(?<![\w])(?:u8|[uUL])?R"([^()\\\s]{0,16})\((?:[\s\S]*?\)\1"|[\s\S]*\Z)'
|
|
414
|
+
_RUST_RAW = r'(?<![\w])b?r(#*)"(?:[\s\S]*?"\1|[\s\S]*\Z)'
|
|
415
|
+
_RUST_CHAR = r"'(?:\\(?:x[0-9a-fA-F]{2}|u\{[0-9a-fA-F]{1,6}\}|.)|[^'\\\n])'" # символ, а не время жизни 'a
|
|
416
|
+
_HASH = r"#[^\n]*"
|
|
417
|
+
_COMMENT_START = ("//", "/*", "#")
|
|
418
|
+
_LEXER_PARTS = {
|
|
419
|
+
"java": (_C_COMMENT, _TRIPLE_DQ, _DQ, _SQ),
|
|
420
|
+
"kotlin": (_C_COMMENT, _TRIPLE_DQ, _DQ, _SQ),
|
|
421
|
+
"scala": (_C_COMMENT, _TRIPLE_DQ, _DQ, _SQ),
|
|
422
|
+
"groovy": (_C_COMMENT, _TRIPLE_DQ, _TRIPLE_SQ, _DQ, _SQ),
|
|
423
|
+
"javascript": (_C_COMMENT, _BACKTICK, _DQ, _SQ),
|
|
424
|
+
"typescript": (_C_COMMENT, _BACKTICK, _DQ, _SQ),
|
|
425
|
+
"csharp": (_C_COMMENT, _CS_VERBATIM, _TRIPLE_DQ, _DQ, _SQ),
|
|
426
|
+
"go": (_C_COMMENT, _BACKTICK, _DQ, _SQ),
|
|
427
|
+
"php": (_C_COMMENT, _HASH, _DQ, _SQ),
|
|
428
|
+
"c": (_C_COMMENT, _DQ, _SQ),
|
|
429
|
+
"cpp": (_C_COMMENT, _CPP_RAW, _DQ, _SQ),
|
|
430
|
+
"swift": (_C_COMMENT, _TRIPLE_DQ, _DQ),
|
|
431
|
+
"rust": (_C_COMMENT, _RUST_RAW, _RUST_CHAR, _DQ),
|
|
432
|
+
"python": (_TRIPLE_DQ, _TRIPLE_SQ, _DQ, _SQ, _HASH),
|
|
433
|
+
}
|
|
434
|
+
_LEXERS = {language: re.compile("|".join(parts)) for language, parts in _LEXER_PARTS.items()}
|
|
435
|
+
# Только литералы языка, без комментариев: для тела уже выделенного комментария у находки о секрете (ADR-0117) –
|
|
436
|
+
# «//» и «#» внутри него не комментарий, и многострочный литерал после них разбирается целиком
|
|
437
|
+
_LITERAL_LEXERS = {language: re.compile("|".join(p for p in parts if p not in (_C_COMMENT, _HASH)))
|
|
438
|
+
for language, parts in _LEXER_PARTS.items()}
|
|
439
|
+
# Разборщики только для поиска комментариев при сверке фрагмента (ADR-0082): в JS/TS литерал регулярного
|
|
440
|
+
# выражения разбирается раньше комментария, иначе «/https?:\/\//» дал бы ложное начало «//». Литерал узнаётся по
|
|
441
|
+
# предыдущему значимому знаку или слову: после оператора, открывающей скобки, «=>», return, typeof и т. п. и в
|
|
442
|
+
# начале строки; после «}», «)», «]», имени и числа «/» – деление.
|
|
443
|
+
_JS_REGEX_BEFORE = "|".join([r"\A", r"(?<=[=(,:;!&|?{\[\n])", r"(?<==>)"]
|
|
444
|
+
+ [rf"(?<=\b{word})" for word in ("return", "typeof", "instanceof", "case", "throw",
|
|
445
|
+
"yield", "await", "void", "delete", "in", "of",
|
|
446
|
+
"new", "else", "do")])
|
|
447
|
+
_JS_REGEX = rf"(?:{_JS_REGEX_BEFORE})[ \t]*/(?![*/])(?:\\.|\[(?:\\.|[^\]\\\n])*\]|[^/\\\n\[])+/[a-z]*"
|
|
448
|
+
# Строки с переносом через «\» в конце строки (Python, JS): литерал продолжается, «#» и «//» в нём не комментарий
|
|
449
|
+
_DQ_CONT = r'"(?:\\[\s\S]|[^"\\\n])*(?:"|(?=\n)|\\?\Z)'
|
|
450
|
+
_SQ_CONT = r"'(?:\\[\s\S]|[^'\\\n])*(?:'|(?=\n)|\\?\Z)"
|
|
451
|
+
_PHP_HASH = r"#(?!\[)[^\n]*" # «#[» в PHP 8 – атрибут, а не комментарий
|
|
452
|
+
# _LEXERS не меняются: от них зависят blank_code и сигнатура метода, а значит и отпечаток case_hash
|
|
453
|
+
_COMMENT_LEXERS = {language: re.compile("|".join(parts)) for language, parts in {
|
|
454
|
+
"javascript": (_JS_REGEX, _C_COMMENT, _BACKTICK, _DQ_CONT, _SQ_CONT),
|
|
455
|
+
"typescript": (_JS_REGEX, _C_COMMENT, _BACKTICK, _DQ_CONT, _SQ_CONT),
|
|
456
|
+
"python": (_TRIPLE_DQ, _TRIPLE_SQ, _DQ_CONT, _SQ_CONT, _HASH),
|
|
457
|
+
"php": (_C_COMMENT, _PHP_HASH, _DQ, _SQ),
|
|
458
|
+
}.items()}
|
|
459
|
+
# Языки программирования: в их коде КЛЮЧ=значение – присваивание, а не строка .env (см. masking.mask_text).
|
|
460
|
+
CODE_LANGUAGES = frozenset({"java", "kotlin", "scala", "groovy", "javascript", "typescript", "python", "csharp", "go",
|
|
461
|
+
"php", "ruby", "swift", "rust", "c", "cpp", "jsp", "razor"})
|
|
462
|
+
BRACE_LANGUAGES = {"java", "kotlin", "scala", "groovy", "javascript", "typescript", "csharp", "go", "php", "c", "cpp",
|
|
463
|
+
"swift", "rust"}
|
|
464
|
+
|
|
465
|
+
# Языки, где функцию объявляет ключевое слово; в остальных (Java, C#, C/C++, методы JS/TS) – разбор заголовка.
|
|
466
|
+
_FUNCTION_KEYWORD = {"go": "func", "kotlin": "fun", "swift": "func", "rust": "fn", "scala": "def", "php": "function"}
|
|
467
|
+
_CONTROL_WORDS = frozenset(("if for foreach while switch catch synchronized using lock fixed return new else do try "
|
|
468
|
+
"finally when select case default sizeof typeof nameof checked unchecked await yield "
|
|
469
|
+
"throw with assert").split())
|
|
470
|
+
# Объявление типа или пространства имён: модификаторы и аннотации, затем ключевое слово (public final class Foo,
|
|
471
|
+
# export default class, data class, type User struct, declare module, companion object). Такой блок – граница поиска:
|
|
472
|
+
# строка в его теле, но не в методе – поле или инициализатор.
|
|
473
|
+
_TYPE_DECLARATION = re.compile(
|
|
474
|
+
r"(?:@[\w.]+(?:\([^)]*\))?\s*|\[[^\]]*\]\s*|type\s+\w+\s+|(?:public|private|protected|internal|static|final|"
|
|
475
|
+
r"abstract|sealed|partial|export|default|declare|data|open|inner|annotation|companion|readonly|unsafe|pub|case|"
|
|
476
|
+
r"enum|value|inline)\s+)*"
|
|
477
|
+
r"(?:class|interface|enum|record|struct|namespace|module|object|trait|impl|extension|protocol|@interface)\b")
|
|
478
|
+
# Слова, которые перед списком параметров означают объявление типа, а не метод: record Point(int x), class Foo(val x).
|
|
479
|
+
_TYPE_WORDS = re.compile(r"(?<![\w$@])(?:class|interface|enum|record|struct)(?![\w$])|@interface")
|
|
480
|
+
_IDENT_CALL = re.compile(r"([A-Za-z_$][\w$]*)\s*(?:<[^()]*>)?\s*\(") # имя(… или имя<T>(…
|
|
481
|
+
_ANNOTATION = re.compile(r"@[\w$.]+\s*")
|
|
482
|
+
_TOKEN = re.compile(r"[\w$]+|\s+|.", re.S)
|
|
483
|
+
# Что может стоять после списка параметров метода до «{».
|
|
484
|
+
_SUFFIX_OK = re.compile(
|
|
485
|
+
r"\s*(?:throws\s+[\w$.,\s<>?]+" # Java: throws IOException
|
|
486
|
+
r"|:\s*(?:base|this)\s*\(.*\)" # C#: вызов конструктора базового класса
|
|
487
|
+
r"|where\s.+" # C#: ограничения обобщённых параметров
|
|
488
|
+
# C++: const, override, &, && … «&+(?!&)» забирает всю серию «&» сразу: иначе разбор строки из множества «&»
|
|
489
|
+
# перебирает все её разбиения.
|
|
490
|
+
r"|(?:(?:const|override|final|noexcept|volatile)\s*|&+(?!&)\s*)+"
|
|
491
|
+
r"|->\s*[^{};=]+" # C++: тип результата после ->
|
|
492
|
+
r"|:\s*[^{};=]+" # TypeScript: тип результата
|
|
493
|
+
r")?\s*", re.S)
|
|
494
|
+
|
|
495
|
+
|
|
496
|
+
def blank_code(text: str, language: str) -> str:
|
|
497
|
+
"""Текст той же длины, где комментарии и строковые литералы заменены пробелами (переводы строк на месте)."""
|
|
498
|
+
lexer = _LEXERS.get(language)
|
|
499
|
+
if lexer is None:
|
|
500
|
+
return text
|
|
501
|
+
return lexer.sub(lambda m: re.sub(r"[^\n]", " ", m.group(0)), text)
|
|
502
|
+
|
|
503
|
+
|
|
504
|
+
def _skip_group(text: str, i: int, open_ch: str = "(", close_ch: str = ")") -> int | None:
|
|
505
|
+
"""Индекс за парной закрывающей скобкой для открывающей в позиции i; пары нет – None."""
|
|
506
|
+
depth = 0
|
|
507
|
+
for j in range(i, len(text)):
|
|
508
|
+
if text[j] == open_ch:
|
|
509
|
+
depth += 1
|
|
510
|
+
elif text[j] == close_ch:
|
|
511
|
+
depth -= 1
|
|
512
|
+
if depth == 0:
|
|
513
|
+
return j + 1
|
|
514
|
+
return None
|
|
515
|
+
|
|
516
|
+
|
|
517
|
+
def _call_parts(header: str):
|
|
518
|
+
"""«public <T> T name(параметры) throws X» -> (начало, имя, параметры, хвост) или None.
|
|
519
|
+
|
|
520
|
+
Аннотации Java (@Name(...)) и атрибуты C# ([...]) в начало не входят; список параметров должен закрываться.
|
|
521
|
+
"""
|
|
522
|
+
i, prefix = 0, []
|
|
523
|
+
while i < len(header):
|
|
524
|
+
if header[i] == "@":
|
|
525
|
+
m = _ANNOTATION.match(header, i)
|
|
526
|
+
i = m.end() if m else i + 1
|
|
527
|
+
if i < len(header) and header[i] == "(":
|
|
528
|
+
i = _skip_group(header, i)
|
|
529
|
+
if i is None:
|
|
530
|
+
return None
|
|
531
|
+
continue
|
|
532
|
+
if header[i] == "[":
|
|
533
|
+
i = _skip_group(header, i, "[", "]")
|
|
534
|
+
if i is None:
|
|
535
|
+
return None
|
|
536
|
+
continue
|
|
537
|
+
m = _IDENT_CALL.match(header, i)
|
|
538
|
+
if m:
|
|
539
|
+
open_paren = m.end() - 1
|
|
540
|
+
close = _skip_group(header, open_paren)
|
|
541
|
+
if close is None:
|
|
542
|
+
return None
|
|
543
|
+
return "".join(prefix).strip(), m.group(1), header[open_paren:close], header[close:]
|
|
544
|
+
m = _TOKEN.match(header, i)
|
|
545
|
+
prefix.append(m.group())
|
|
546
|
+
i = m.end()
|
|
547
|
+
return None
|
|
548
|
+
|
|
549
|
+
|
|
550
|
+
def _is_method(header: str) -> bool:
|
|
551
|
+
"""Заголовок метода в стиле Java, C#, C/C++ или метода класса JS/TS (не if/for/catch, не new Foo() {, не лямбда)."""
|
|
552
|
+
parts = _call_parts(header)
|
|
553
|
+
if parts is None:
|
|
554
|
+
return False
|
|
555
|
+
prefix, name, _params, suffix = parts
|
|
556
|
+
words = prefix.split()
|
|
557
|
+
if name in _CONTROL_WORDS or (words and words[-1] in _CONTROL_WORDS):
|
|
558
|
+
return False
|
|
559
|
+
if _TYPE_WORDS.search(prefix) or "=" in prefix:
|
|
560
|
+
return False
|
|
561
|
+
return bool(_SUFFIX_OK.fullmatch(suffix))
|
|
562
|
+
|
|
563
|
+
|
|
564
|
+
def is_function_header(header: str, language: str) -> bool:
|
|
565
|
+
"""Текст перед «{» (комментарии и строки уже убраны) объявляет функцию или метод."""
|
|
566
|
+
keyword = _FUNCTION_KEYWORD.get(language)
|
|
567
|
+
if keyword:
|
|
568
|
+
return re.search(r"(?<![\w$])" + keyword + r"(?![\w$])", header) is not None
|
|
569
|
+
if language in ("javascript", "typescript"):
|
|
570
|
+
if re.search(r"(?<![\w$])function(?![\w$])", header) or header.endswith("=>"):
|
|
571
|
+
return True
|
|
572
|
+
return _is_method(header)
|
|
573
|
+
|
|
574
|
+
|
|
575
|
+
def _short(text: str, limit: int = SIGNATURE_LIMIT) -> str:
|
|
576
|
+
text = " ".join(str(text).split())
|
|
577
|
+
return text if len(text) <= limit else text[:limit] + "…"
|
|
578
|
+
|
|
579
|
+
|
|
580
|
+
def _line_starts(text: str) -> list[int]:
|
|
581
|
+
starts = [0]
|
|
582
|
+
starts.extend(m.end() for m in re.finditer("\n", text))
|
|
583
|
+
return starts
|
|
584
|
+
|
|
585
|
+
|
|
586
|
+
_CONTINUES = (",", "(", "[", "=", "+", "-", "*", "/", "&", "|", "?", ":", ".", "=>")
|
|
587
|
+
|
|
588
|
+
|
|
589
|
+
def _signature_start(blank: str, start: int, opening: int) -> int:
|
|
590
|
+
"""Начало сигнатуры в заголовке блока: без ведущих законченных строк, которые остались от кода без «;»
|
|
591
|
+
(package main в Go, const x = f() в JS). Строки аннотаций (@…) и атрибутов ([…]) остаются: в них бывает
|
|
592
|
+
маршрут обработчика."""
|
|
593
|
+
pos = start
|
|
594
|
+
content_end = start + len(blank[start:opening].rstrip()) # за ним до «{» только пробелы и переводы строк
|
|
595
|
+
while True:
|
|
596
|
+
nl = blank.find("\n", pos, opening)
|
|
597
|
+
if nl < 0 or nl + 1 >= content_end:
|
|
598
|
+
return pos
|
|
599
|
+
line = blank[pos:nl].strip()
|
|
600
|
+
complete = not line or (line.count("(") == line.count(")") and line.count("[") == line.count("]")
|
|
601
|
+
and not line.startswith(("@", "[")) and not line.endswith(_CONTINUES))
|
|
602
|
+
if not complete:
|
|
603
|
+
return pos
|
|
604
|
+
pos = nl + 1
|
|
605
|
+
|
|
606
|
+
|
|
607
|
+
def code_blocks(text: str, language: str) -> list[tuple[int, int, int, str, str]]:
|
|
608
|
+
"""Блоки {…} файла: [(смещение заголовка, первая строка заголовка, строка «}», вид, сигнатура)].
|
|
609
|
+
|
|
610
|
+
Вид – "func" (метод или функция), "class" (класс, интерфейс, пространство имён) или "other" (if, for, лямбда
|
|
611
|
+
Java, литерал объекта…). Заголовок – текст от предыдущих «;», «{» или «}» до «{» блока.
|
|
612
|
+
"""
|
|
613
|
+
blank = blank_code(text, language)
|
|
614
|
+
starts = _line_starts(text)
|
|
615
|
+
raw, stack, last = [], [], -1
|
|
616
|
+
for m in re.finditer(r"[{};]", blank):
|
|
617
|
+
pos, ch = m.start(), m.group()
|
|
618
|
+
if ch == "{":
|
|
619
|
+
stack.append((last + 1, pos))
|
|
620
|
+
elif ch == "}" and stack:
|
|
621
|
+
raw.append(stack.pop() + (pos,))
|
|
622
|
+
last = pos
|
|
623
|
+
raw.extend((head, opening, len(blank)) for head, opening in stack) # незакрытые – до конца файла
|
|
624
|
+
blocks = []
|
|
625
|
+
for head, opening, close in raw:
|
|
626
|
+
h = head
|
|
627
|
+
while h < opening and (blank[h].isspace() or blank[h] in ")],;"):
|
|
628
|
+
h += 1
|
|
629
|
+
clean = " ".join(blank[h:opening].split())
|
|
630
|
+
if len(clean) > HEADER_LIMIT: # минифицированный код или выражение на сотни строк – не заголовок метода
|
|
631
|
+
kind = "other"
|
|
632
|
+
elif is_function_header(clean, language):
|
|
633
|
+
kind = "func"
|
|
634
|
+
elif _TYPE_DECLARATION.match(clean):
|
|
635
|
+
kind = "class"
|
|
636
|
+
else:
|
|
637
|
+
kind = "other"
|
|
638
|
+
signature = ""
|
|
639
|
+
if kind == "func":
|
|
640
|
+
h = _signature_start(blank, h, opening)
|
|
641
|
+
while h < opening and blank[h].isspace():
|
|
642
|
+
h += 1
|
|
643
|
+
signature = _short(text[h:opening])
|
|
644
|
+
blocks.append((h, bisect.bisect_right(starts, h), bisect.bisect_right(starts, close), kind, signature))
|
|
645
|
+
return blocks
|
|
646
|
+
|
|
647
|
+
|
|
648
|
+
_PY_DEF = re.compile(r"[ \t]*(?:async[ \t]+)?def[ \t]+\w")
|
|
649
|
+
_PY_CLASS = re.compile(r"[ \t]*class[ \t]+\w")
|
|
650
|
+
|
|
651
|
+
|
|
652
|
+
def _indent(line: str) -> int:
|
|
653
|
+
return len(line) - len(line.lstrip(" \t"))
|
|
654
|
+
|
|
655
|
+
|
|
656
|
+
def _python_signature(blank_lines: list[str], lines: list[str], i: int) -> str:
|
|
657
|
+
"""def и его параметры до «:» (сигнатура бывает на нескольких строках)."""
|
|
658
|
+
parts, depth = [], 0
|
|
659
|
+
for j in range(i, min(i + 15, len(lines))):
|
|
660
|
+
parts.append(lines[j].strip())
|
|
661
|
+
b = blank_lines[j]
|
|
662
|
+
depth += sum(b.count(c) for c in "([{") - sum(b.count(c) for c in ")]}")
|
|
663
|
+
if depth <= 0 and b.rstrip().endswith(":"):
|
|
664
|
+
break
|
|
665
|
+
return _short(" ".join(parts).rstrip().rstrip(":"))
|
|
666
|
+
|
|
667
|
+
|
|
668
|
+
def python_enclosing(blank_lines: list[str], lines: list[str], line: int) -> tuple[str, int | None]:
|
|
669
|
+
"""Объемлющая функция Python по отступам: (сигнатура, номер строки def) или ("", None)."""
|
|
670
|
+
idx = line - 1
|
|
671
|
+
if _PY_DEF.match(blank_lines[idx]):
|
|
672
|
+
return _python_signature(blank_lines, lines, idx), line
|
|
673
|
+
target = _indent(blank_lines[idx])
|
|
674
|
+
for i in range(idx - 1, -1, -1):
|
|
675
|
+
text = blank_lines[i]
|
|
676
|
+
if not text.strip():
|
|
677
|
+
continue # пустые строки, комментарии и тела многострочных строк
|
|
678
|
+
indent = _indent(text)
|
|
679
|
+
if indent < target:
|
|
680
|
+
if _PY_DEF.match(text):
|
|
681
|
+
return _python_signature(blank_lines, lines, i), i + 1
|
|
682
|
+
if _PY_CLASS.match(text) or indent == 0:
|
|
683
|
+
return "", None # строка на уровне класса или модуля
|
|
684
|
+
target = indent
|
|
685
|
+
return "", None
|
|
686
|
+
|
|
687
|
+
|
|
688
|
+
def enclosing_of(text: str, language: str, line: int) -> tuple[str, int | None]:
|
|
689
|
+
"""Сигнатура объемлющего метода или функции для строки и номер первой строки её заголовка; нет – ("", None)."""
|
|
690
|
+
lines = _split_lines(text)
|
|
691
|
+
if not 1 <= line <= len(lines):
|
|
692
|
+
return "", None
|
|
693
|
+
if language == "python":
|
|
694
|
+
blank_lines = _split_lines(blank_code(text, "python"))
|
|
695
|
+
blank_lines += [""] * (len(lines) - len(blank_lines))
|
|
696
|
+
return python_enclosing(blank_lines, lines, line)
|
|
697
|
+
if language not in BRACE_LANGUAGES:
|
|
698
|
+
return "", None
|
|
699
|
+
around = [b for b in code_blocks(text, language) if b[1] <= line <= b[2]]
|
|
700
|
+
for _head, first, _last, kind, signature in sorted(around, reverse=True): # изнутри наружу
|
|
701
|
+
if kind == "func":
|
|
702
|
+
return signature, first
|
|
703
|
+
if kind == "class":
|
|
704
|
+
return "", None # строка в теле класса, но не в методе (поле, инициализатор)
|
|
705
|
+
return "", None
|
|
706
|
+
|
|
707
|
+
|
|
708
|
+
# ============================================================================ срез
|
|
709
|
+
|
|
710
|
+
def _clip(text: str, limit: int = LINE_LIMIT) -> str:
|
|
711
|
+
return text if len(text) <= limit else text[:limit] + CUT_MARK
|
|
712
|
+
|
|
713
|
+
|
|
714
|
+
def _window(lines: list[str], line: int, before: int, after: int, max_chars: int,
|
|
715
|
+
sig_line: int | None) -> tuple[int, int, list[str], list[str]]:
|
|
716
|
+
"""Окно вокруг строки line -> (первая, последняя, строки окна, заметки).
|
|
717
|
+
|
|
718
|
+
Окно – before строк до и after после; если объемлющий метод начинается выше окна и срез с ним укладывается
|
|
719
|
+
в max_chars, окно расширяется до его заголовка. Длинные строки обрезаются (строка срабатывания – до
|
|
720
|
+
max_chars/2), лишнее сверх max_chars срезается с дальнего от строки срабатывания края."""
|
|
721
|
+
n = len(lines)
|
|
722
|
+
width = max(5, len(str(n)))
|
|
723
|
+
start, end = max(1, line - before), min(n, line + after)
|
|
724
|
+
first = sig_line if sig_line and sig_line < start else start
|
|
725
|
+
rendered = {}
|
|
726
|
+
for k in range(first, end + 1):
|
|
727
|
+
rendered[k] = _clip(lines[k - 1], max(LINE_LIMIT, max_chars // 2) if k == line else LINE_LIMIT)
|
|
728
|
+
|
|
729
|
+
def cost(k):
|
|
730
|
+
return len(rendered[k]) + width + 5 # метка, номер, «| » и перевод строки
|
|
731
|
+
|
|
732
|
+
total = sum(cost(k) for k in range(start, end + 1))
|
|
733
|
+
if first < start:
|
|
734
|
+
above = sum(cost(k) for k in range(first, start))
|
|
735
|
+
if total + above <= max_chars:
|
|
736
|
+
total += above
|
|
737
|
+
start = first
|
|
738
|
+
window = (start, end)
|
|
739
|
+
while total > max_chars and (start < line or end > line):
|
|
740
|
+
if line - start >= end - line:
|
|
741
|
+
total -= cost(start)
|
|
742
|
+
start += 1
|
|
743
|
+
else:
|
|
744
|
+
total -= cost(end)
|
|
745
|
+
end -= 1
|
|
746
|
+
notes = []
|
|
747
|
+
if (start, end) != window:
|
|
748
|
+
notes.append(f"срез сокращён до {max_chars} знаков: строки {start}–{end}")
|
|
749
|
+
cut = sum(1 for k in range(start, end + 1) if rendered[k].endswith(CUT_MARK))
|
|
750
|
+
if cut:
|
|
751
|
+
notes.append(f"длинные строки обрезаны: {cut}")
|
|
752
|
+
return start, end, [rendered[k] for k in range(start, end + 1)], notes
|
|
753
|
+
|
|
754
|
+
|
|
755
|
+
EXPORT_LINE_RADIUS = 5
|
|
756
|
+
# Версия сверки фрагмента: 1 – вхождение в любую сторону (ADR-0076); 2 – точное совпадение отдельно от частичного
|
|
757
|
+
# и закомментированного (ADR-0082). Срезы с меньшей версией пересчитываются только для показа и промпта.
|
|
758
|
+
EXPORT_LINE_CHECK_VERSION = 2
|
|
759
|
+
_ENTITY = re.compile(r"&(?:quot|apos|amp|lt|gt|#\d{1,7}|#x[0-9a-fA-F]{1,6});")
|
|
760
|
+
# Директивы препроцессора и подобные строки на «#» – код, а не комментарий (для языков без разборщика)
|
|
761
|
+
_HASH_DIRECTIVE = re.compile(r"#\s*(?:include|define|undef|if|ifdef|ifndef|elif|else|endif|pragma|import|error|warning|"
|
|
762
|
+
r"line|region|endregion)\b|#!|#\[")
|
|
763
|
+
_MARKUP_COMMENT = re.compile(r"<!--[\s\S]*?(?:-->|\Z)")
|
|
764
|
+
_MARKUP_LANGUAGES = frozenset({"html", "xml", "jsp", "vue", "svelte", "razor"})
|
|
765
|
+
# Фрагмент, который сам начинается с комментария, – выгруженный комментарий: сверяется со строкой целиком
|
|
766
|
+
_COMMENT_OPENERS = ("//", "/*", "<!--", "--", "#")
|
|
767
|
+
# Ступени сверки одной строки: точное вхождение, только в комментарии, частичное совпадение
|
|
768
|
+
_EXACT, _COMMENTED, _PARTIAL = "exact", "commented", "partial"
|
|
769
|
+
|
|
770
|
+
|
|
771
|
+
def _normalize_line(text: str) -> str:
|
|
772
|
+
return "".join(html.unescape(text).split())
|
|
773
|
+
|
|
774
|
+
|
|
775
|
+
def _export_fragments(snippet: str) -> list[str]:
|
|
776
|
+
return [part for line in html.unescape(snippet).splitlines() if (part := "".join(line.split()))]
|
|
777
|
+
|
|
778
|
+
|
|
779
|
+
def _export_parts(snippet: str) -> list[tuple[str, str]]:
|
|
780
|
+
"""Значимые строки выгрузки без пробелов (от трёх знаков) и начало каждой, если Hub обрезал строку многоточием.
|
|
781
|
+
|
|
782
|
+
Начало берётся, когда до многоточия не меньше 20 знаков со свёрнутыми пробелами (правило ADR-0076)."""
|
|
783
|
+
parts = []
|
|
784
|
+
for line in html.unescape(snippet).splitlines():
|
|
785
|
+
part = "".join(line.split())
|
|
786
|
+
if len(part) < 3:
|
|
787
|
+
continue
|
|
788
|
+
spaced = " ".join(line.split())
|
|
789
|
+
cut = part[:-3] if part.endswith("...") else part[:-1] if part.endswith("…") else ""
|
|
790
|
+
old_cut = spaced[:-3] if spaced.endswith("...") else spaced[:-1] if spaced.endswith("…") else ""
|
|
791
|
+
parts.append((part, cut if len(cut) >= 3 and len(old_cut.rstrip()) >= 20 else ""))
|
|
792
|
+
return parts
|
|
793
|
+
|
|
794
|
+
|
|
795
|
+
def _comment_body(raw: str) -> str | None:
|
|
796
|
+
"""Языки без разборщика: текст строки-комментария целиком, если вся строка – комментарий, иначе None.
|
|
797
|
+
|
|
798
|
+
Узнаются строки, начинающиеся с //, /*, <!--, «-- », «* » и «#» (кроме директив препроцессора)."""
|
|
799
|
+
text = html.unescape(raw).strip()
|
|
800
|
+
if text.startswith(("//", "/*", "<!--")) or text.startswith("-- ") or text == "--":
|
|
801
|
+
return text
|
|
802
|
+
if text.startswith("* ") or text == "*" or text.startswith("*/"):
|
|
803
|
+
return text
|
|
804
|
+
if text.startswith("#") and not _HASH_DIRECTIVE.match(text):
|
|
805
|
+
return text
|
|
806
|
+
return None
|
|
807
|
+
|
|
808
|
+
|
|
809
|
+
def _split_comments(lines: list[str], language: str = "") -> list[tuple[str, str]]:
|
|
810
|
+
"""Каждая строка -> (код без комментариев, текст комментариев); переводы строк и позиции сохраняются.
|
|
811
|
+
|
|
812
|
+
Для языков с разборщиком (`_LEXERS`) комментарии находятся им: блочные – через несколько строк, строковые
|
|
813
|
+
литералы комментариями не считаются (адрес «http://…» в кавычках – код), «//» в Python – деление. Для разметки –
|
|
814
|
+
<!-- -->. Для остальных языков комментарием считается только строка целиком (`_comment_body`). Срез, который
|
|
815
|
+
начинается внутри блочного комментария, разобрать с его начала нельзя – это ограничение."""
|
|
816
|
+
lexer = _COMMENT_LEXERS.get(language) or _LEXERS.get(language)
|
|
817
|
+
if lexer is None and language not in _MARKUP_LANGUAGES:
|
|
818
|
+
out = []
|
|
819
|
+
for raw in lines:
|
|
820
|
+
body = _comment_body(raw)
|
|
821
|
+
out.append(("", raw) if body is not None else (raw, ""))
|
|
822
|
+
return out
|
|
823
|
+
text = "\n".join(lines)
|
|
824
|
+
mark = bytearray(len(text))
|
|
825
|
+
if lexer is not None:
|
|
826
|
+
for m in lexer.finditer(text):
|
|
827
|
+
if m.group(0).startswith(_COMMENT_START):
|
|
828
|
+
mark[m.start():m.end()] = b"\x01" * (m.end() - m.start())
|
|
829
|
+
if language in _MARKUP_LANGUAGES:
|
|
830
|
+
for m in _MARKUP_COMMENT.finditer(text):
|
|
831
|
+
mark[m.start():m.end()] = b"\x01" * (m.end() - m.start())
|
|
832
|
+
out, pos = [], 0
|
|
833
|
+
for raw in lines:
|
|
834
|
+
flags = mark[pos:pos + len(raw)]
|
|
835
|
+
code = "".join(" " if flags[i] else ch for i, ch in enumerate(raw))
|
|
836
|
+
comment = "".join(ch if flags[i] else " " for i, ch in enumerate(raw))
|
|
837
|
+
out.append((code, comment))
|
|
838
|
+
pos += len(raw) + 1
|
|
839
|
+
return out
|
|
840
|
+
|
|
841
|
+
|
|
842
|
+
def _line_grade(part: str, cut: str, raw: str, code: str, comment: str) -> str | None:
|
|
843
|
+
"""Ступень совпадения одной значимой строки фрагмента (без пробелов) со строкой файла.
|
|
844
|
+
|
|
845
|
+
exact – фрагмент входит в код строки (Hub часто выгружает часть строки), совпадает начало обрезанного фрагмента
|
|
846
|
+
или фрагмент сам начинается с комментария и входит в строку; commented – фрагмент есть только в комментарии
|
|
847
|
+
этой строки; partial – код строки короче фрагмента и входит в него (совпала лишь часть фрагмента)."""
|
|
848
|
+
whole = _normalize_line(raw)
|
|
849
|
+
if len(part) < 3 or len(whole) < 3:
|
|
850
|
+
return None
|
|
851
|
+
code_n, comment_n = _normalize_line(code), _normalize_line(comment)
|
|
852
|
+
|
|
853
|
+
def has(text: str) -> bool:
|
|
854
|
+
return bool(text) and (part in text or bool(cut and text.startswith(cut)))
|
|
855
|
+
|
|
856
|
+
if has(code_n):
|
|
857
|
+
return _EXACT
|
|
858
|
+
if has(whole) and (not has(comment_n) or (part.startswith(_COMMENT_OPENERS) and comment_n.startswith(part))):
|
|
859
|
+
return _EXACT # фрагмент, захвативший и код, и комментарий после него, или выгруженный сам комментарий
|
|
860
|
+
if has(comment_n):
|
|
861
|
+
return _COMMENTED
|
|
862
|
+
return _PARTIAL if len(code_n) >= 3 and code_n in part else None
|
|
863
|
+
|
|
864
|
+
|
|
865
|
+
def _same_line(export_line: str, file_line: str) -> bool:
|
|
866
|
+
"""Любая значимая строка выгрузки входит в строку кода (не в комментарий), без пробелов и HTML-сущностей."""
|
|
867
|
+
(code, comment), = _split_comments([file_line])
|
|
868
|
+
return any(_line_grade(part, cut, file_line, code, comment) == _EXACT for part, cut in _export_parts(export_line))
|
|
869
|
+
|
|
870
|
+
|
|
871
|
+
def _visible_grade(part: str, code: str, comment: str, cut: str = "") -> str | None:
|
|
872
|
+
"""Сохранённая строка с метками маскирования: доказательством служит только видимый участок, не метка;
|
|
873
|
+
участок в коде – exact, только в комментарии – commented. Начало обрезанного фрагмента (cut) сверяется с
|
|
874
|
+
видимым началом строки – до первой метки."""
|
|
875
|
+
if len(part) < 3:
|
|
876
|
+
return None
|
|
877
|
+
for text, kind in ((code, _EXACT), (comment, _COMMENTED)):
|
|
878
|
+
visible = ["".join(piece.split()) for piece in PLACEHOLDER_RE.sub("\0", html.unescape(text)).split("\0")]
|
|
879
|
+
if any(part in piece for piece in visible) or (cut and visible[0].startswith(cut)):
|
|
880
|
+
return kind
|
|
881
|
+
return None
|
|
882
|
+
|
|
883
|
+
|
|
884
|
+
def check_export_fragment(snippet: str, lines: list[str], start_line: int, target_line: int | None, *,
|
|
885
|
+
masked: bool = False, language: str = "") -> tuple[str, int | None]:
|
|
886
|
+
"""Сверка фрагмента из выгрузки рядом со строкой сканера (ADR-0076, ADR-0082).
|
|
887
|
+
|
|
888
|
+
match/near – фрагмент найден в коде: однострочный входит в код строки в окне ±5, многострочный – все его значимые
|
|
889
|
+
строки подряд (короткие строки файла между ними пропускаются), и блок задевает окно ±5; commented – найден
|
|
890
|
+
только в комментариях (у многострочного – все строки, хотя бы одна в комментарии); partial – совпала лишь часть
|
|
891
|
+
фрагмента. Из нескольких мест – ближайшее к строке сканера, при равном расстоянии – ниже. Для сохранённого
|
|
892
|
+
среза скрытые значения не служат доказательством совпадения или несовпадения."""
|
|
893
|
+
if target_line is None or start_line < 1:
|
|
894
|
+
return "n/a", None
|
|
895
|
+
if not _export_fragments(snippet):
|
|
896
|
+
return "no_export_line", None
|
|
897
|
+
parts = _export_parts(snippet)
|
|
898
|
+
if not parts:
|
|
899
|
+
return "short_export_line", None
|
|
900
|
+
split = _split_comments(lines, language)
|
|
901
|
+
rows = [(start_line + i, raw, split[i][0], split[i][1]) for i, raw in enumerate(lines)]
|
|
902
|
+
hidden = False
|
|
903
|
+
|
|
904
|
+
def grade(part: tuple[str, str], row) -> str | None:
|
|
905
|
+
nonlocal hidden
|
|
906
|
+
_, raw, code, comment = row
|
|
907
|
+
if masked and count_placeholders(raw):
|
|
908
|
+
hidden = True
|
|
909
|
+
return _visible_grade(part[0], code, comment, part[1])
|
|
910
|
+
return _line_grade(part[0], part[1], raw, code, comment)
|
|
911
|
+
|
|
912
|
+
def distance(first: int, last: int) -> int:
|
|
913
|
+
return 0 if first <= target_line <= last else min(abs(first - target_line), abs(last - target_line))
|
|
914
|
+
|
|
915
|
+
best: dict[str, tuple[tuple[int, int], int]] = {} # ступень -> ((расстояние, -номер), место)
|
|
916
|
+
|
|
917
|
+
def offer(kind: str, first: int, last: int, at: int) -> None:
|
|
918
|
+
key = (distance(first, last), -at)
|
|
919
|
+
if kind not in best or key < best[kind][0]:
|
|
920
|
+
best[kind] = (key, at)
|
|
921
|
+
|
|
922
|
+
in_window = [i for i, row in enumerate(rows) if abs(row[0] - target_line) <= EXPORT_LINE_RADIUS]
|
|
923
|
+
if len(parts) == 1:
|
|
924
|
+
for i in in_window:
|
|
925
|
+
found = grade(parts[0], rows[i])
|
|
926
|
+
if found:
|
|
927
|
+
offer(found, rows[i][0], rows[i][0], rows[i][0])
|
|
928
|
+
else:
|
|
929
|
+
for i, row in enumerate(rows): # начало блока – где угодно: пропуски коротких строк его удлиняют
|
|
930
|
+
kinds, j, todo = [], i, list(parts)
|
|
931
|
+
while todo and j < len(rows):
|
|
932
|
+
if j > i and len(_normalize_line(rows[j][1])) < 3:
|
|
933
|
+
j += 1
|
|
934
|
+
continue
|
|
935
|
+
found = grade(todo[0], rows[j])
|
|
936
|
+
if found not in (_EXACT, _COMMENTED):
|
|
937
|
+
break
|
|
938
|
+
kinds.append(found)
|
|
939
|
+
todo.pop(0)
|
|
940
|
+
j += 1
|
|
941
|
+
if not todo:
|
|
942
|
+
first, last = row[0], rows[j - 1][0]
|
|
943
|
+
if distance(first, last) <= EXPORT_LINE_RADIUS:
|
|
944
|
+
at = target_line if first <= target_line <= last else first
|
|
945
|
+
offer(_EXACT if all(k == _EXACT for k in kinds) else _COMMENTED, first, last, at)
|
|
946
|
+
for i in in_window: # неполный многострочный фрагмент: место, где совпала хотя бы одна его строка
|
|
947
|
+
if any(grade(part, rows[i]) for part in parts):
|
|
948
|
+
offer(_PARTIAL, rows[i][0], rows[i][0], rows[i][0])
|
|
949
|
+
for kind, check in ((_EXACT, ""), (_COMMENTED, "commented"), (_PARTIAL, "partial")):
|
|
950
|
+
if kind in best:
|
|
951
|
+
at = best[kind][1]
|
|
952
|
+
return (check or ("match" if at == target_line else "near")), at
|
|
953
|
+
return ("masked_export_line" if hidden else "differs"), None
|
|
954
|
+
|
|
955
|
+
|
|
956
|
+
def legacy_export_check(snippet: str, lines: list[str], start_line: int,
|
|
957
|
+
target_line: int | None) -> tuple[str, int | None]:
|
|
958
|
+
"""Сверка версии 1 (0.8.2, ADR-0076) по коду до маскирования – только для отпечатка случая: чтобы уточнение
|
|
959
|
+
сверки (ADR-0082) не меняло case_hash неизменного кода и не снимало «Проверено»."""
|
|
960
|
+
if target_line is None or start_line < 1:
|
|
961
|
+
return "n/a", None
|
|
962
|
+
fragments = _export_fragments(snippet)
|
|
963
|
+
if not fragments:
|
|
964
|
+
return "no_export_line", None
|
|
965
|
+
if not any(len(part) >= 3 for part in fragments):
|
|
966
|
+
return "short_export_line", None
|
|
967
|
+
candidates = [(start_line + i, text) for i, text in enumerate(lines)
|
|
968
|
+
if abs(start_line + i - target_line) <= EXPORT_LINE_RADIUS]
|
|
969
|
+
candidates.sort(key=lambda row: (abs(row[0] - target_line), -row[0]))
|
|
970
|
+
for number, text in candidates:
|
|
971
|
+
if _legacy_same_line(snippet, text):
|
|
972
|
+
return ("match" if number == target_line else "near"), number
|
|
973
|
+
return "differs", None
|
|
974
|
+
|
|
975
|
+
|
|
976
|
+
def _legacy_same_line(export_line: str, file_line: str) -> bool:
|
|
977
|
+
"""Правило версии 1: любая значимая строка выгрузки входит в строку файла или содержит её."""
|
|
978
|
+
theirs = _normalize_line(file_line)
|
|
979
|
+
if len(theirs) < 3:
|
|
980
|
+
return False
|
|
981
|
+
for part in html.unescape(export_line).splitlines():
|
|
982
|
+
spaced = " ".join(part.split())
|
|
983
|
+
mine = "".join(part.split())
|
|
984
|
+
if len(mine) < 3:
|
|
985
|
+
continue
|
|
986
|
+
if mine in theirs or theirs in mine:
|
|
987
|
+
return True
|
|
988
|
+
cut = mine[:-3] if mine.endswith("...") else mine[:-1] if mine.endswith("…") else ""
|
|
989
|
+
old_cut = spaced[:-3] if spaced.endswith("...") else spaced[:-1] if spaced.endswith("…") else ""
|
|
990
|
+
if len(cut) >= 3 and len(old_cut.rstrip()) >= 20 and theirs.startswith(cut):
|
|
991
|
+
return True
|
|
992
|
+
return False
|
|
993
|
+
|
|
994
|
+
|
|
995
|
+
def export_fragment_scope(snippet: str, text: str) -> str:
|
|
996
|
+
"""Что совпало на найденной строке: line – строка целиком, part – часть строки, lines – многострочный фрагмент."""
|
|
997
|
+
parts = _export_parts(snippet)
|
|
998
|
+
if len(parts) > 1:
|
|
999
|
+
return "lines"
|
|
1000
|
+
return "line" if parts and _normalize_line(text) == parts[0][0] else "part"
|
|
1001
|
+
|
|
1002
|
+
|
|
1003
|
+
def export_fragment_view(f: Finding, ctx: CodeContext) -> CodeContext:
|
|
1004
|
+
"""Пересчёт сверки прежних версий только для показа и промпта; исходный срез и его case_hash не меняются.
|
|
1005
|
+
|
|
1006
|
+
Срез версии 1 уже искал вхождение в обе стороны: уточнить можно только найденное совпадение. Его строка со
|
|
1007
|
+
скрытыми значениями совпадение не опровергает – тогда прежний результат остаётся."""
|
|
1008
|
+
if ctx.status != "ok" or ctx.export_line_check_version >= EXPORT_LINE_CHECK_VERSION:
|
|
1009
|
+
return ctx
|
|
1010
|
+
if ctx.export_line_check_version >= 1:
|
|
1011
|
+
if ctx.export_line_check not in ("match", "near"):
|
|
1012
|
+
return ctx
|
|
1013
|
+
old = ctx.text_at(ctx.export_line_at)
|
|
1014
|
+
if not old or count_placeholders(old):
|
|
1015
|
+
return ctx
|
|
1016
|
+
language = ctx.language or str(f.language or "").casefold()
|
|
1017
|
+
check, at = check_export_fragment(str(f.snippet or ""), ctx.lines, ctx.start_line, _line_of(f), masked=True,
|
|
1018
|
+
language=language)
|
|
1019
|
+
note = "; ".join(part for part in ctx.note.split("; ")
|
|
1020
|
+
if "не совпадает со строкой из выгрузки" not in part)
|
|
1021
|
+
# Сверка версии 1 уже сделана по коду до маскирования – она и остаётся в отпечатке (case_hash не меняется).
|
|
1022
|
+
# У срезов версии 0 в отпечатке нет export_line_at: их отпечаток по представлению не воспроизводится.
|
|
1023
|
+
hashed = {"hash_check": ctx.export_line_check, "hash_check_at": ctx.export_line_at} \
|
|
1024
|
+
if ctx.export_line_check_version >= 1 else {}
|
|
1025
|
+
return replace(ctx, export_line_check=check, export_line_at=at,
|
|
1026
|
+
export_line_check_version=EXPORT_LINE_CHECK_VERSION, note=note, **hashed)
|
|
1027
|
+
|
|
1028
|
+
|
|
1029
|
+
DISPLAY_LINES = 200 # окно показа в карточке: строк до и после строки сканера (ADR-0087)…
|
|
1030
|
+
DISPLAY_MAX = 400 # …и не больше строк всего
|
|
1031
|
+
DISPLAY_CHARS = 80000
|
|
1032
|
+
|
|
1033
|
+
|
|
1034
|
+
class Display(NamedTuple):
|
|
1035
|
+
"""Контекст показа (ADR-0087): срез ctx и исполняемый код его строк по разбору исходного файла с начала (code –
|
|
1036
|
+
номер строки -> код без комментариев и многострочных литералов; только при сверке окна модели differs и только для
|
|
1037
|
+
строк, показанных без изменений)."""
|
|
1038
|
+
ctx: CodeContext
|
|
1039
|
+
code: dict[int, str]
|
|
1040
|
+
|
|
1041
|
+
|
|
1042
|
+
def display_context(repo_dir: Path | None, f: Finding, ctx: CodeContext, *, mask_key: bytes | None = None,
|
|
1043
|
+
no_repo_note: str = "") -> Display | None:
|
|
1044
|
+
"""Контекст показа для карточки (ADR-0087): из того же клона и с тем же маскированием, что окно модели ctx, до
|
|
1045
|
+
DISPLAY_LINES строк до и после строки сканера и не больше DISPLAY_MAX строк, окно модели – целиком. Только если
|
|
1046
|
+
тот же файл и язык, на месте окна модели – те же строки по тем же номерам, и показ шире окна модели; иначе None,
|
|
1047
|
+
и карточка показывает окно модели. Нигде не сохраняется и в отпечатки не входит: сверка, промпт и вердикт
|
|
1048
|
+
остаются по окну модели."""
|
|
1049
|
+
if ctx.status != "ok" or not ctx.lines or ctx.start_line < 1 or len(ctx.lines) >= DISPLAY_MAX:
|
|
1050
|
+
return None
|
|
1051
|
+
# разбор для поиска сдвига – по тому же содержимому файла, из которого построен показ: прочитан до и после
|
|
1052
|
+
source = _source_bytes(repo_dir, ctx.file) if ctx.export_line_check == "differs" else None
|
|
1053
|
+
wide = build_context(repo_dir, f, before=DISPLAY_LINES, after=DISPLAY_LINES, max_chars=DISPLAY_CHARS,
|
|
1054
|
+
mask_key=mask_key, no_repo_note=no_repo_note)
|
|
1055
|
+
if (wide.status != "ok" or wide.start_line < 1 or len(wide.lines) <= len(ctx.lines) or wide.file != ctx.file
|
|
1056
|
+
or wide.language != ctx.language):
|
|
1057
|
+
return None
|
|
1058
|
+
offset = ctx.start_line - wide.start_line
|
|
1059
|
+
if offset < 0 or wide.lines[offset:offset + len(ctx.lines)] != ctx.lines:
|
|
1060
|
+
return None
|
|
1061
|
+
# ±DISPLAY_LINES от строки сканера (build_context расширяет окно до заголовка метода), окно модели – целиком,
|
|
1062
|
+
# всего не больше DISPLAY_MAX: лишнее срезается с дальнего от строки сканера края
|
|
1063
|
+
line = _line_of(f) or ctx.target_line or ctx.start_line
|
|
1064
|
+
first = min(ctx.start_line, max(wide.start_line, line - DISPLAY_LINES))
|
|
1065
|
+
last = max(ctx.end_line, min(wide.end_line, line + DISPLAY_LINES))
|
|
1066
|
+
while last - first + 1 > DISPLAY_MAX:
|
|
1067
|
+
if first < ctx.start_line and (line - first >= last - line or last <= ctx.end_line):
|
|
1068
|
+
first += 1
|
|
1069
|
+
else:
|
|
1070
|
+
last -= 1
|
|
1071
|
+
lines = wide.lines[first - wide.start_line:last - wide.start_line + 1]
|
|
1072
|
+
if len(lines) <= len(ctx.lines):
|
|
1073
|
+
return None
|
|
1074
|
+
shown = replace(wide, lines=lines, start_line=first, end_line=last, export_line_check=ctx.export_line_check,
|
|
1075
|
+
export_line_at=ctx.export_line_at)
|
|
1076
|
+
code: dict[int, str] = {}
|
|
1077
|
+
if source is not None and _source_bytes(repo_dir, ctx.file) == source: # файл между чтениями не менялся
|
|
1078
|
+
code = _code_parts(source, shown)
|
|
1079
|
+
return Display(shown, code)
|
|
1080
|
+
|
|
1081
|
+
|
|
1082
|
+
def _source_bytes(repo_dir: Path | None, rel: str) -> bytes | None:
|
|
1083
|
+
"""Содержимое файла находки в клоне (те же проверки пути и размера, что у build_context) или None."""
|
|
1084
|
+
try:
|
|
1085
|
+
root = os.path.realpath(str(repo_dir))
|
|
1086
|
+
path = find_file(Path(root), rel)
|
|
1087
|
+
if path is None:
|
|
1088
|
+
return None
|
|
1089
|
+
return _read_inside(root, str(path), MAX_FILE_BYTES)[0]
|
|
1090
|
+
except (_ReadRefused, OSError):
|
|
1091
|
+
return None
|
|
1092
|
+
|
|
1093
|
+
|
|
1094
|
+
def shift_code_lines(repo_dir: Path | None, ctx: CodeContext) -> dict[int, str]:
|
|
1095
|
+
"""Код строк среза для поиска сдвига (export_fragment_shift) по текущему файлу клона; не прочитан – пусто."""
|
|
1096
|
+
source = _source_bytes(repo_dir, ctx.file)
|
|
1097
|
+
return _code_parts(source, ctx) if source is not None else {}
|
|
1098
|
+
|
|
1099
|
+
|
|
1100
|
+
def _code_parts(source: bytes, ctx: CodeContext) -> dict[int, str]:
|
|
1101
|
+
"""Исполняемый код строк среза по разбору исходного файла с начала: без комментариев и без содержимого
|
|
1102
|
+
многострочных литералов (блочный комментарий или текстовый блок, начатый выше среза, учитывается). Только для
|
|
1103
|
+
строк, которые оператор видит без изменений: строка со скрытыми значениями или обрезанная доказательством не
|
|
1104
|
+
служит. Файл не текст или разбор для языка недостоверен – пусто."""
|
|
1105
|
+
plain = decode_source(source)
|
|
1106
|
+
if plain is None:
|
|
1107
|
+
return {}
|
|
1108
|
+
lines = _split_lines(plain)[:ctx.end_line]
|
|
1109
|
+
code = _executable_code(lines, ctx.language)
|
|
1110
|
+
if code is None:
|
|
1111
|
+
return {}
|
|
1112
|
+
return {ctx.start_line + k: code[ctx.start_line + k - 1] for k, shown in enumerate(ctx.lines)
|
|
1113
|
+
if ctx.start_line + k - 1 < len(lines) and lines[ctx.start_line + k - 1] == shown}
|
|
1114
|
+
|
|
1115
|
+
|
|
1116
|
+
def window_code_lines(ctx: CodeContext) -> dict[int, str]:
|
|
1117
|
+
"""Исполняемый код строк среза по разбору самого среза – когда файла нет (срез из базы, ADR-0087): строки со
|
|
1118
|
+
скрытыми значениями не служат доказательством; комментарий или литерал, начатый выше среза, не учитывается."""
|
|
1119
|
+
if any(count_placeholders(line) for line in ctx.lines):
|
|
1120
|
+
return {} # маскирование могло скрыть открытие или закрытие комментария – разбор среза недостоверен
|
|
1121
|
+
code = _executable_code(list(ctx.lines), ctx.language)
|
|
1122
|
+
return {ctx.start_line + k: line for k, line in enumerate(code)} if code is not None else {}
|
|
1123
|
+
|
|
1124
|
+
|
|
1125
|
+
# языки, где многострочные литералы (обычные строки с переводом строки, heredoc) разборщик не видит
|
|
1126
|
+
_SHIFT_UNSUPPORTED = frozenset({"php"})
|
|
1127
|
+
|
|
1128
|
+
|
|
1129
|
+
def _executable_code(lines: list[str], language: str = "") -> list[str] | None:
|
|
1130
|
+
"""Каждая строка -> её код без комментариев и без содержимого многострочных литералов (текстовые блоки, тройные
|
|
1131
|
+
кавычки, шаблонные строки): текст внутри них – не исполняемый код. Однострочные литералы остаются: фрагменты
|
|
1132
|
+
выгрузки их содержат. Позиции и переводы строк сохраняются, как в _split_comments. None – разбор для языка
|
|
1133
|
+
недостоверен: разборщика нет (многострочные комментарии и литералы не видны) или в многострочном шаблоне JS/TS
|
|
1134
|
+
есть выражение ${…} (вложенные шаблоны плоский разбор не различает)."""
|
|
1135
|
+
lexer = _COMMENT_LEXERS.get(language) or _LEXERS.get(language)
|
|
1136
|
+
if (lexer is None and language not in _MARKUP_LANGUAGES) or language in _SHIFT_UNSUPPORTED:
|
|
1137
|
+
return None
|
|
1138
|
+
if language in ("c", "cpp") and any(line.rstrip().endswith("\\") for line in lines):
|
|
1139
|
+
return None # продолжение строки через «\» – комментарий или литерал переходит на следующую строку
|
|
1140
|
+
text = "\n".join(lines)
|
|
1141
|
+
mark = bytearray(len(text))
|
|
1142
|
+
if lexer is not None:
|
|
1143
|
+
for m in lexer.finditer(text):
|
|
1144
|
+
token = m.group(0)
|
|
1145
|
+
if token.startswith("`") and "${" in token:
|
|
1146
|
+
return None # выражения и вложенные шаблоны JS/TS плоский разбор не различает
|
|
1147
|
+
if token.startswith("/*") and "/*" in token[2:]:
|
|
1148
|
+
return None # вложенные блочные комментарии (Kotlin, Rust, Swift, Scala) плоский разбор не видит
|
|
1149
|
+
if token.startswith(_COMMENT_START) or "\n" in token:
|
|
1150
|
+
mark[m.start():m.end()] = b"\x01" * (m.end() - m.start())
|
|
1151
|
+
if language in _MARKUP_LANGUAGES:
|
|
1152
|
+
for m in _MARKUP_COMMENT.finditer(text):
|
|
1153
|
+
mark[m.start():m.end()] = b"\x01" * (m.end() - m.start())
|
|
1154
|
+
out, pos = [], 0
|
|
1155
|
+
for raw in lines:
|
|
1156
|
+
flags = mark[pos:pos + len(raw)]
|
|
1157
|
+
out.append("".join(" " if flags[i] else ch for i, ch in enumerate(raw)))
|
|
1158
|
+
pos += len(raw) + 1
|
|
1159
|
+
return out
|
|
1160
|
+
|
|
1161
|
+
|
|
1162
|
+
def export_fragment_shift(f: Finding, ctx: CodeContext, code: dict[int, str] | None = None) -> int | None:
|
|
1163
|
+
"""Только для показа (ADR-0086): при сверке differs – строка, где фрагмент из выгрузки найден в показанном коде
|
|
1164
|
+
дальше окна ±5 (ближайшая к строке сканера, при равном расстоянии – ниже), иначе None.
|
|
1165
|
+
|
|
1166
|
+
Проверка строже сверки в окне: каждая значимая строка фрагмента целиком входит в код строки (не в комментарий),
|
|
1167
|
+
многострочный фрагмент – все строки подряд (короткие строки файла между ними пропускаются); начало фрагмента,
|
|
1168
|
+
обрезанного многоточием, и выгруженный комментарий доказательством не служат. Скрытые значения среза не служат
|
|
1169
|
+
доказательством. Сверка среза, промпт, отпечатки и ограничение уверенности не меняются: модель разбирала код
|
|
1170
|
+
вокруг строки сканера. code – код строк по разбору файла с начала (Display.code): фрагмент должен входить и в
|
|
1171
|
+
него, иначе строка внутри блочного комментария, начатого выше среза, сошла бы за код."""
|
|
1172
|
+
line = _line_of(f)
|
|
1173
|
+
if ctx.status != "ok" or ctx.export_line_check != "differs" or not ctx.lines or line is None:
|
|
1174
|
+
return None
|
|
1175
|
+
parts = [part for part, cut in _export_parts(str(f.snippet or "")) if not cut]
|
|
1176
|
+
if not parts or len(parts) != len(_export_parts(str(f.snippet or ""))):
|
|
1177
|
+
return None # обрезанный многоточием фрагмент целиком не сверить
|
|
1178
|
+
if code is not None and not code:
|
|
1179
|
+
return None # разбор файла с начала не получен: строку внутри комментария от кода не отличить
|
|
1180
|
+
file_code = code
|
|
1181
|
+
split = (_split_comments(ctx.lines, ctx.language or str(f.language or "").casefold()) if file_code is None
|
|
1182
|
+
else [("", "")] * len(ctx.lines))
|
|
1183
|
+
|
|
1184
|
+
def exact(part: str, i: int) -> bool:
|
|
1185
|
+
raw, (window_code, _) = ctx.lines[i], split[i]
|
|
1186
|
+
if file_code is not None:
|
|
1187
|
+
# код строки по разбору исходного файла с начала; строки со скрытыми значениями или обрезанные в нём нет
|
|
1188
|
+
return ctx.start_line + i in file_code and part in _normalize_line(file_code[ctx.start_line + i])
|
|
1189
|
+
if count_placeholders(raw):
|
|
1190
|
+
return _visible_grade(part, window_code, "") == _EXACT
|
|
1191
|
+
return part in _normalize_line(window_code)
|
|
1192
|
+
|
|
1193
|
+
best: tuple[tuple[int, int], int] | None = None
|
|
1194
|
+
for i in range(len(ctx.lines)):
|
|
1195
|
+
j, todo = i, list(parts)
|
|
1196
|
+
while todo and j < len(ctx.lines):
|
|
1197
|
+
if j > i and len(_normalize_line(ctx.lines[j])) < 3:
|
|
1198
|
+
j += 1
|
|
1199
|
+
continue
|
|
1200
|
+
if not exact(todo[0], j):
|
|
1201
|
+
break
|
|
1202
|
+
todo.pop(0)
|
|
1203
|
+
j += 1
|
|
1204
|
+
if todo:
|
|
1205
|
+
continue
|
|
1206
|
+
first, last = ctx.start_line + i, ctx.start_line + j - 1
|
|
1207
|
+
inside = first <= line <= last
|
|
1208
|
+
at = line if inside else first
|
|
1209
|
+
key = (0 if inside else min(abs(first - line), abs(last - line)), -at)
|
|
1210
|
+
if best is None or key < best[0]:
|
|
1211
|
+
best = (key, at)
|
|
1212
|
+
return best[1] if best is not None and best[0][0] > EXPORT_LINE_RADIUS else None
|
|
1213
|
+
|
|
1214
|
+
|
|
1215
|
+
def _line_of(f: Finding) -> int | None:
|
|
1216
|
+
"""Номер строки находки: положительное целое или None."""
|
|
1217
|
+
return f.line if isinstance(f.line, int) and not isinstance(f.line, bool) and f.line >= 1 else None
|
|
1218
|
+
|
|
1219
|
+
|
|
1220
|
+
def _export_only(f: Finding, status: str, reason: str, file: str, language: str, key: bytes | None,
|
|
1221
|
+
credential: bool, notes: list[str], max_chars: int) -> CodeContext:
|
|
1222
|
+
"""Кода из репозитория нет (reason – почему): контекст – строка кода из выгрузки, если она есть.
|
|
1223
|
+
|
|
1224
|
+
HTML-сущности в строке из выгрузки (" и т. п.) раскрываются до маскирования, иначе значение в «кавычках»
|
|
1225
|
+
не узнать. Строка маскируется тем же ключом (у находки о секрете – все литералы, ADR-0117) и укладывается
|
|
1226
|
+
в max_chars."""
|
|
1227
|
+
line = _line_of(f)
|
|
1228
|
+
snippet = str(f.snippet or "").strip("\n")
|
|
1229
|
+
if not snippet.strip():
|
|
1230
|
+
return CodeContext(status=status, file=file, language=language, start_line=0, end_line=0,
|
|
1231
|
+
target_line=line, lines=[], enclosing="", export_line_check="n/a", masked={},
|
|
1232
|
+
note="; ".join(notes + [f"{reason}; строки кода в выгрузке тоже нет"]))
|
|
1233
|
+
if _ENTITY.search(snippet):
|
|
1234
|
+
snippet = html.unescape(snippet)
|
|
1235
|
+
parts = snippet.split("\n")
|
|
1236
|
+
if key is not None:
|
|
1237
|
+
# у находки о секрете – все литералы метками (hide), сама строка не скрывается (ADR-0117)
|
|
1238
|
+
parts = mask_source_text("\n".join(parts), language, key, hide=credential).split("\n")
|
|
1239
|
+
parts = [_clip(part.strip() if k == 0 else part.rstrip(), max(LINE_LIMIT, max_chars // 2) if k == 0 else LINE_LIMIT)
|
|
1240
|
+
for k, part in enumerate(parts)]
|
|
1241
|
+
width = max(5, len(str((line or 0) + len(parts))))
|
|
1242
|
+
kept, total = [], 0
|
|
1243
|
+
for part in parts:
|
|
1244
|
+
total += len(part) + width + 5
|
|
1245
|
+
if kept and total > max_chars:
|
|
1246
|
+
break
|
|
1247
|
+
kept.append(part)
|
|
1248
|
+
start = line or 0
|
|
1249
|
+
end = start + len(kept) - 1 if start else 0
|
|
1250
|
+
note = f"{reason}: видна только строка кода из выгрузки, без окружения"
|
|
1251
|
+
if len(kept) < len(parts):
|
|
1252
|
+
note += f"; строка из выгрузки сокращена до {max_chars} знаков"
|
|
1253
|
+
if credential and key is not None:
|
|
1254
|
+
note += "; находка о секрете в коде: строки в кавычках заменены метками"
|
|
1255
|
+
return CodeContext(status="export_line_only", file=file, language=language, start_line=start, end_line=end,
|
|
1256
|
+
target_line=line, lines=kept, enclosing="", export_line_check="n/a",
|
|
1257
|
+
masked=count_placeholders("\n".join(kept)) if key is not None else {},
|
|
1258
|
+
note="; ".join(notes + [note]))
|
|
1259
|
+
|
|
1260
|
+
|
|
1261
|
+
_MASK_LOCK = threading.Lock()
|
|
1262
|
+
_MASK_CACHE: OrderedDict[tuple, str] = OrderedDict()
|
|
1263
|
+
|
|
1264
|
+
|
|
1265
|
+
def clear_mask_cache() -> None:
|
|
1266
|
+
with _MASK_LOCK:
|
|
1267
|
+
_MASK_CACHE.clear()
|
|
1268
|
+
|
|
1269
|
+
|
|
1270
|
+
def _masked_file(real: str, plain: str, language: str, key: bytes, hide: bool, st: os.stat_result | None) -> str:
|
|
1271
|
+
"""Весь текст файла после маскирования; повторный вызов для того же файла (настоящий путь, устройство и номер
|
|
1272
|
+
файла, размер, время изменения), языка, режима и ключа берётся из памяти: у файла бывают десятки находок,
|
|
1273
|
+
а карточку открывают снова и снова.
|
|
1274
|
+
|
|
1275
|
+
real – настоящий путь прочитанного файла (_read_inside); st – сведения об открытом файле, одинаковые до и после
|
|
1276
|
+
чтения plain. None – файл меняли во время чтения: память не используется совсем, ни для поиска, ни для записи."""
|
|
1277
|
+
cache_key = None
|
|
1278
|
+
if st is not None:
|
|
1279
|
+
cache_key = ((os.path.normcase(real), st.st_dev, st.st_ino, st.st_size, st.st_mtime_ns), language, hide,
|
|
1280
|
+
hashlib.sha256(key).hexdigest())
|
|
1281
|
+
with _MASK_LOCK:
|
|
1282
|
+
# показ без масок восстанавливает значения меток (бэклог 111): для этого метки выдаются заново
|
|
1283
|
+
cached = None if recording_active() else _MASK_CACHE.get(cache_key)
|
|
1284
|
+
if cached is not None:
|
|
1285
|
+
_MASK_CACHE.move_to_end(cache_key)
|
|
1286
|
+
return cached
|
|
1287
|
+
text = mask_source_text(plain, language, key, hide=hide)
|
|
1288
|
+
if cache_key is not None and len(text) <= MASK_CACHE_CHARS:
|
|
1289
|
+
with _MASK_LOCK:
|
|
1290
|
+
_MASK_CACHE[cache_key] = text
|
|
1291
|
+
_MASK_CACHE.move_to_end(cache_key)
|
|
1292
|
+
while (len(_MASK_CACHE) > MASK_CACHE_FILES
|
|
1293
|
+
or sum(len(v) for v in _MASK_CACHE.values()) > MASK_CACHE_CHARS):
|
|
1294
|
+
_MASK_CACHE.popitem(last=False)
|
|
1295
|
+
return text
|
|
1296
|
+
|
|
1297
|
+
|
|
1298
|
+
def mask_source_text(text: str, language: str, key: bytes, hide: bool = False) -> str:
|
|
1299
|
+
"""Единое маскирование исходного текста из файла и из строки выгрузки."""
|
|
1300
|
+
text = _hide_literals(text, language, key, secrets_only=not hide)
|
|
1301
|
+
return mask_text(text, key, env_style=language not in CODE_LANGUAGES)[0]
|
|
1302
|
+
|
|
1303
|
+
|
|
1304
|
+
def _hide_literals(text: str, language: str, key: bytes, secrets_only: bool = False) -> str:
|
|
1305
|
+
"""Строковые литералы по разметке языка (в том числе многострочные и сырые) -> плейсхолдеры; кавычки
|
|
1306
|
+
и переводы строк на месте. Комментарии: при secrets_only=True не трогаются; при secrets_only=False строки
|
|
1307
|
+
в кавычках внутри комментария тоже заменяются (ADR-0117: закомментированная строка `// pwd = "…"` у находки
|
|
1308
|
+
о секрете раньше скрывалась целиком, теперь – только её значение).
|
|
1309
|
+
|
|
1310
|
+
secrets_only=False – все литералы (находка о секрете в коде; для языка без разборщика – однострочные литералы);
|
|
1311
|
+
secrets_only=True – только литералы, присвоенные ключу со словом-секретом (password = R"(…)", token = `…`), и их
|
|
1312
|
+
продолжения – соседние литералы через пробелы, переводы строк или «+» ("часть" "часть", "часть" + "часть"):
|
|
1313
|
+
так значение скрывается целиком при любом синтаксисе строки, а не только в простых кавычках."""
|
|
1314
|
+
lexer = _LEXERS.get(language)
|
|
1315
|
+
if lexer is None:
|
|
1316
|
+
return text if secrets_only else mask_all_literals(text, key)[0]
|
|
1317
|
+
previous = {"end": -1, "secret": False} # последний литерал: где кончился и был ли значением секрета
|
|
1318
|
+
|
|
1319
|
+
def joined(start: int) -> bool:
|
|
1320
|
+
"""Между предыдущим литералом-секретом и позицией start только пробелы, «+» или «\\» в конце строки."""
|
|
1321
|
+
return previous["secret"] and text[previous["end"]:start].strip() in ("", "+", "\\")
|
|
1322
|
+
|
|
1323
|
+
def hide_in_comment(token: str) -> str:
|
|
1324
|
+
"""Литералы внутри комментария (ADR-0117): тело разбирается разборщиком только литералов языка
|
|
1325
|
+
(_LITERAL_LEXERS), без рекурсии – «//» и «#» внутри тела не комментарий, поэтому многострочные литералы
|
|
1326
|
+
(текстовые блоки, сырые строки) и после них становятся метками целиком; границы комментария на месте,
|
|
1327
|
+
число строк не меняется (mask_literal_token хранит переводы строк)."""
|
|
1328
|
+
opener = next(s for s in _COMMENT_START if token.startswith(s))
|
|
1329
|
+
closer = "*/" if opener == "/*" and len(token) >= 4 and token.endswith("*/") else ""
|
|
1330
|
+
body = token[len(opener):len(token) - len(closer)]
|
|
1331
|
+
return opener + _LITERAL_LEXERS[language].sub(lambda m: mask_literal_token(m.group(0), key), body) + closer
|
|
1332
|
+
|
|
1333
|
+
def repl(m):
|
|
1334
|
+
token = m.group(0)
|
|
1335
|
+
if token.startswith(_COMMENT_START):
|
|
1336
|
+
if secrets_only and previous["secret"]:
|
|
1337
|
+
if joined(m.start()): # "часть" /* … */ "часть": комментарий склейку не прерывает
|
|
1338
|
+
previous["end"] = m.end()
|
|
1339
|
+
else: # склейка закончилась: дальше срезы между литералами не нужны
|
|
1340
|
+
previous["secret"] = False
|
|
1341
|
+
return token if secrets_only else hide_in_comment(token)
|
|
1342
|
+
if secrets_only:
|
|
1343
|
+
continued = joined(m.start())
|
|
1344
|
+
secret = continued or secret_assignment_before(text[max(0, m.start() - 200):m.start()])
|
|
1345
|
+
previous.update(end=m.end(), secret=secret)
|
|
1346
|
+
if not secret:
|
|
1347
|
+
return token
|
|
1348
|
+
return mask_literal_token(token, key)
|
|
1349
|
+
|
|
1350
|
+
return lexer.sub(repl, text)
|
|
1351
|
+
|
|
1352
|
+
|
|
1353
|
+
def build_context(repo_dir: Path | None, f: Finding, before: int = 40, after: int = 40, max_chars: int = 14000,
|
|
1354
|
+
mask_key: bytes | None = None, no_repo_note: str = "") -> CodeContext:
|
|
1355
|
+
"""Срез кода вокруг находки.
|
|
1356
|
+
|
|
1357
|
+
repo_dir – папка репозитория (уже проверенная resolve_repo) или None; файл ищется find_file. С mask_key весь
|
|
1358
|
+
файл маскируется до вырезания среза (секреты и ПДн -> плейсхолдеры, число строк не меняется); у находки
|
|
1359
|
+
о секрете в коде все строковые литералы среза, включая строку срабатывания и комментарии, – плейсхолдерами
|
|
1360
|
+
(ADR-0117), сама строка видна. Без mask_key код отдаётся как есть (например, для показа человеку).
|
|
1361
|
+
|
|
1362
|
+
Статусы: 'ok' – срез из файла; 'export_line_only' – кода из репозитория нет, контекст – строка из выгрузки;
|
|
1363
|
+
без строки в выгрузке – 'no_repo' (папки нет), 'file_missing' (файла нет, он найден неоднозначно или строка
|
|
1364
|
+
за пределами файла), 'too_large', 'binary'. Почему – в reason и note; no_repo_note уточняет отсутствие клона.
|
|
1365
|
+
|
|
1366
|
+
max_chars меньше 500 считается равным 500: строка срабатывания всегда остаётся в срезе (длинная – обрезанной
|
|
1367
|
+
до max(400, max_chars/2) знаков).
|
|
1368
|
+
"""
|
|
1369
|
+
before, after = max(0, int(before)), max(0, int(after))
|
|
1370
|
+
max_chars = max(500, int(max_chars))
|
|
1371
|
+
rel = norm_path(f.file)
|
|
1372
|
+
language = language_of(rel) or str(f.language or "").strip().lower()
|
|
1373
|
+
credential = is_credential_finding(f.rule, f.cwe)
|
|
1374
|
+
notes: list[str] = []
|
|
1375
|
+
|
|
1376
|
+
def fallback(status: str, reason: str, note: str, file: str = rel) -> CodeContext:
|
|
1377
|
+
ctx = _export_only(f, status, note, file, language, mask_key, credential, notes, max_chars)
|
|
1378
|
+
ctx.reason = reason
|
|
1379
|
+
return ctx
|
|
1380
|
+
|
|
1381
|
+
if repo_dir is None:
|
|
1382
|
+
return fallback("no_repo", "no_repo", no_repo_note or "папка репозитория для кодовой базы не задана")
|
|
1383
|
+
root = os.path.realpath(str(repo_dir))
|
|
1384
|
+
if not os.path.isdir(root):
|
|
1385
|
+
return fallback("no_repo", "no_repo", "папка репозитория не найдена")
|
|
1386
|
+
if not rel:
|
|
1387
|
+
return fallback("file_missing", "missing", "в находке не указан файл")
|
|
1388
|
+
path = find_file(Path(root), rel)
|
|
1389
|
+
if path is None:
|
|
1390
|
+
if file_presence(Path(root), rel) == "missing":
|
|
1391
|
+
return fallback("file_missing", "missing", "файла нет в клоне")
|
|
1392
|
+
return fallback("file_missing", "ambiguous", "файл найден в клоне не однозначно "
|
|
1393
|
+
"(несколько подходящих файлов или обход клона не завершён)")
|
|
1394
|
+
found = os.path.relpath(str(path), root).replace(os.sep, "/")
|
|
1395
|
+
language = language_of(found) or language
|
|
1396
|
+
if found != rel:
|
|
1397
|
+
notes.append(f"файл найден по пути {found}")
|
|
1398
|
+
try:
|
|
1399
|
+
# открытый файл проверяется до чтения, читается не больше предела; по сведениям о нём кэшируется
|
|
1400
|
+
# маскированный текст
|
|
1401
|
+
raw, st, stable, real = _read_inside(root, str(path), MAX_FILE_BYTES)
|
|
1402
|
+
except _ReadRefused as e:
|
|
1403
|
+
if e.status == "too_large":
|
|
1404
|
+
return fallback("too_large", "too_large",
|
|
1405
|
+
f"файл больше {MAX_FILE_BYTES // (1024 * 1024)} МБ – не читается", found)
|
|
1406
|
+
return fallback("file_missing", "unreadable", e.reason, found)
|
|
1407
|
+
except OSError:
|
|
1408
|
+
return fallback("file_missing", "unreadable", "файл не прочитан (нет доступа?)", found)
|
|
1409
|
+
plain = decode_source(raw)
|
|
1410
|
+
if plain is None:
|
|
1411
|
+
return fallback("binary", "binary", "двоичный файл – не читается", found)
|
|
1412
|
+
# Весь файл маскируется до вырезания среза: иначе ключ на границе среза или обрезанный токен не узнать.
|
|
1413
|
+
# У находки о секрете сама строка – секрет: значения всех литералов скрываются первыми, по разметке языка
|
|
1414
|
+
# (до общих правил, которые могли бы разрезать сырую строку R"(…)" или r#"…"#), и до обрезки длинных строк.
|
|
1415
|
+
hide = credential and mask_key is not None
|
|
1416
|
+
text = plain
|
|
1417
|
+
if mask_key is not None:
|
|
1418
|
+
text = _masked_file(real, plain, language, mask_key, hide, st if stable else None)
|
|
1419
|
+
lines = _split_lines(text)
|
|
1420
|
+
line = _line_of(f)
|
|
1421
|
+
if not lines:
|
|
1422
|
+
return fallback("file_missing", "empty", "файл пуст", found)
|
|
1423
|
+
if line is not None and line > len(lines):
|
|
1424
|
+
return fallback("file_missing", "line_out_of_range",
|
|
1425
|
+
f"строка {line} за пределами файла (в файле {len(lines)} строк): репозиторий, "
|
|
1426
|
+
"похоже, не на коммите скана", found)
|
|
1427
|
+
check = hash_check = "n/a"
|
|
1428
|
+
export_line_at = hash_check_at = None
|
|
1429
|
+
if line is None:
|
|
1430
|
+
notes.append("в находке нет номера строки: показано начало файла")
|
|
1431
|
+
signature, sig_line = "", None
|
|
1432
|
+
start, end, window, cut = _window(lines, 1, 0, before + after, max_chars, None)
|
|
1433
|
+
else:
|
|
1434
|
+
source_lines = _split_lines(plain)
|
|
1435
|
+
check, export_line_at = check_export_fragment(str(f.snippet or ""), source_lines, 1, line,
|
|
1436
|
+
language=language)
|
|
1437
|
+
hash_check, hash_check_at = legacy_export_check(str(f.snippet or ""), source_lines, 1, line)
|
|
1438
|
+
signature, sig_line = enclosing_of(text, language, line)
|
|
1439
|
+
if hide: # у находки о секрете все литералы среза – метки (mask_source_text с hide); строка срабатывания
|
|
1440
|
+
# целиком не скрывается (ADR-0117); сигнатура метода – тоже без литералов
|
|
1441
|
+
signature = mask_all_literals(signature, mask_key)[0]
|
|
1442
|
+
start, end, window, cut = _window(lines, line, before, after, max_chars, sig_line)
|
|
1443
|
+
notes.extend(cut)
|
|
1444
|
+
if hide:
|
|
1445
|
+
notes.append("находка о секрете в коде: строки в кавычках заменены метками")
|
|
1446
|
+
masked = count_placeholders("\n".join(window + [signature])) if mask_key is not None else {}
|
|
1447
|
+
return CodeContext(status="ok", file=found, language=language, start_line=start, end_line=end,
|
|
1448
|
+
target_line=line if line is not None and start <= line <= end else None, lines=window,
|
|
1449
|
+
enclosing=signature, export_line_check=check, masked=masked, note="; ".join(notes),
|
|
1450
|
+
export_line_at=export_line_at, export_line_check_version=EXPORT_LINE_CHECK_VERSION,
|
|
1451
|
+
hash_check=hash_check, hash_check_at=hash_check_at)
|