From 9875480b973c8ba554b73b41537b4f1c4e6b3054 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 16 Nov 2026 23:30:41 +0900 Subject: [PATCH] =?UTF-8?q?feat(848-8):=20=EB=B0=94=EB=80=90=20=EC=9E=90?= =?UTF-8?q?=EB=A6=AC=20=ED=91=9C=EC=8B=9C=202=20=EB=8B=A8=EA=B3=84=20?= =?UTF-8?q?=E2=80=94=20=EC=84=9C=EB=B2=84=20=EB=B0=94=ED=83=95=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C(=EC=B8=B5=EB=B0=94=ED=83=95)=20=C2=B7=20=EC=B9=B8=20?= =?UTF-8?q?=EB=8B=A8=EC=9C=84=20=EB=A7=9E=EB=8C=90=20=ED=85=8C=EB=91=90?= =?UTF-8?q?=EB=A6=AC=20=C2=B7=20=EC=B9=B8=20=C2=B7=20=EC=A4=84=20=EB=90=98?= =?UTF-8?q?=EB=8F=8C=EB=A6=BC=20=C2=B7=20=EB=B9=A0=EC=A7=84=20=EC=A4=84=20?= =?UTF-8?q?=EB=90=98=EC=82=B4=EB=A6=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 읽기 답 `층바탕` = {위: 위 층 문서, 빌더?: 기초 손고침 때 빌더 문서} — M01 기초 = 빌더가 지을 문서 · M02 SK = 그 기초 지금 문서(옵션 값 = 파생과 같게 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(`처음`) · 파일 안 씀 - 화면 = 다 그린 뒤 한 번 훑어 칸마다 부품 `setUiDiff`(나 = 파랑 · 위 = 주황) — 옵션 가로 · 공식 값 · 식 글 · 표 값 · 단위 · 금액 줄 자원 · 이름 · 단가 식 · 수량 · 단위 · 비목 · 그룹 이름 · 글 줄 · 더한 줄 · 차례 바뀐 줄 = 줄 틀 · 빠진 줄 = 그룹 머리 [되살림 n] - 칸 [↶] · 줄 [↶] · 되살림 = 캐시 → [저장] · 읽기 계정 = 테두리만 - 저장 — 따로 사본을 다 되돌려 위 층과 같으면 파생으로(고침 흔적 0 · 끊음 · 기계 고침 있으면 그대로 · 옛 끊음 안 실음) - 덮인 기계 칸 「원래 값 —」(836-1 부터) = 연결 기록에 작업량만 얹은 셈을 한 번 더 — 덮음 없는 정본 값이 실림(M01 · M02) - 시험 test_848_8_diff — 수식 문서 1,520 장 고침 없이 표시 0 · 칸 · 줄 · 층 · 서버 바탕 · 파생 복귀 · 덮음 기록 Co-Authored-By: Claude Opus 5.5 --- A00_Common/line_stack.css | 32 +++ A00_Common/line_stack_diff.ts | 175 ++++++++++++ A00_Common/line_stack_screen.ts | 10 +- A00_Common/line_stack_text.ts | 12 + M01_MasterData/M01_MasterData_Doc.py | 11 +- M02_MasterTemplete/M02_Doc_Screen.py | 12 +- M02_MasterTemplete/M02_Doc_Sk_Path.py | 67 ++++- common_util/common_util_line_stack_diff.ts | 298 +++++++++++++++++++++ resources/tester/helper_848_8_diff.cjs | 67 +++++ resources/tester/test_848_8_diff.py | 139 ++++++++++ 10 files changed, 815 insertions(+), 8 deletions(-) create mode 100644 A00_Common/line_stack_diff.ts create mode 100644 common_util/common_util_line_stack_diff.ts create mode 100644 resources/tester/helper_848_8_diff.cjs create mode 100644 resources/tester/test_848_8_diff.py diff --git a/A00_Common/line_stack.css b/A00_Common/line_stack.css index 5afa6f18e..122fd3b0a 100644 --- a/A00_Common/line_stack.css +++ b/A00_Common/line_stack.css @@ -436,6 +436,27 @@ font-size: 1.05em; } +/* 바뀐 자리(848-8 · 요구 889) — 더한 · 차례 바뀐 줄 = 손잡이 쪽 줄 틀 · 식 글 = 칸 테두리(나 = 파랑 굵은 선 · 위 = 주황 점선) */ +.lstk-line[data-diff="mine"] { + border-inline-start: 3px solid var(--color-info); +} + +.lstk-line[data-diff="upper"] { + border-inline-start: 3px dashed var(--color-warning); +} + +.lstk-expr[data-diff] { + border: 1px solid var(--color-info); + border-radius: var(--radius-sm); + box-shadow: inset 0 0 0 1px var(--color-info); +} + +.lstk-expr[data-diff="upper"] { + border-style: dashed; + border-color: var(--color-warning); + box-shadow: none; +} + /* 짝 강조(679 · 684) — 왼쪽 카드 · 그룹 머리 · 오른쪽 줄 = 같은 바탕 채우기 */ .lstk-line.is-pair, .lstk-item.is-pair > .lstk-ihead, @@ -466,6 +487,17 @@ min-width: 8em; } +/* 848-8 옵션 칸 + 되돌림 = 한 칸 */ +.lstk-dpair { + display: inline-flex; + align-items: flex-end; + gap: var(--spacing-4); +} + +.lstk-dpair > .ui-field { + min-width: 8em; +} + /* 827-1 기계 창 — 왼쪽 찾기 | 오른쪽 기계 양식 */ .lstk-mwin { display: grid; diff --git a/A00_Common/line_stack_diff.ts b/A00_Common/line_stack_diff.ts new file mode 100644 index 000000000..b659b43e8 --- /dev/null +++ b/A00_Common/line_stack_diff.ts @@ -0,0 +1,175 @@ +/* ============================================================================= + * line_stack_diff.ts + * 바뀐 자리 표시 2 단계(PLAN 848-8 · 요구 889) — 줄 쌓기 왼쪽 · 옵션 가로를 다 그린 뒤 한 번 훑어 칸마다 「바뀜」 상태를 닮 + * 지도 = `common_util_line_stack_diff.docDiff`(지금 문서 대 서버 `층바탕.위` · 그 위 `층바탕.빌더`) + * 칸 = 옵션 가로 · 공식 묶음 값 · 식 글 · 표 값 · 단위 · 금액 줄 이름(자원) · 이름 · 단가 식 · 수량 · 단위 · 비목 · 그룹 이름 · 글 줄 + * 테두리 = 부품 `setUiDiff`(나 = 파랑 굵은 선 · 위 = 주황 점선) · 풍선 = 「원래 값 …」(위 = 「기초 고치기 전 …」) · + * 칸 되돌림 = 칸 옆 작은 [↶](나 · 되돌릴 값 있을 때) · 줄 되돌림 = 줄 끝 [↶] · 더한 줄 · 차례 바뀐 줄 = 줄 틀(손잡이 쪽 선) · + * 빠진 줄 = 그룹 머리 [되살림 n](테두리 상태 단추) · 고침 = 부른 쪽 `change`(캐시 · [저장] 때 서버가 다시 셈) + * `edit` 없음(읽기 계정 · 저장 전 문서) = 테두리 · 풍선만 + * ========================================================================== */ + +import { createButton, createIconButton, setUiDiff } from "@ui/ui_template_button"; +import { eqText } from "@ui/ui_template_equation"; +import { el } from "@ui/ui_template_elements"; +import { varId, type DocVar } from "../common_util/common_util_formula_doc"; +import { + docDiff, + LINE_FIELDS, + resetPath, + restoreLines, + type DiffKind, + type DiffMark, +} from "../common_util/common_util_line_stack_diff"; +import { ownedOf, type StackDoc, type StackItem } from "../common_util/common_util_line_stack"; +import { machineText } from "./formula_doc_options"; +import { lt } from "./line_stack_text"; + +export interface DiffHooks { + head: HTMLElement; + left: HTMLElement; + doc: StackDoc; + items: StackItem[]; + /** 위 층 문서 · 그 위(빌더 — 기초 손고침 · SK 만) */ + up: StackDoc; + top?: StackDoc | null; + edit: boolean; + change: (fn: (d: StackDoc, items: StackItem[]) => void) => void; + name: (key: string) => string; +} + +/** 되돌릴 값 글 — 식 › 값 › 표 칸 › 자원 이름 */ +function say(h: DiffHooks, was: unknown): string { + if (was === undefined || was === null || was === "") return "—"; + if (typeof was !== "object") return machineText(was, () => undefined) ?? eqText(was as never); + const w = was as { 식?: string; 연결?: DocVar["연결"]; 이름?: string; 규격?: string }; + if ("규격" in w || ("이름" in w && !("연결" in w) && !("식" in w))) + return `${w.이름 ?? ""} ${w.규격 ?? ""}`.trim() || "—"; + if (w.식) return w.식; + const l = w.연결; + if (l?.값 !== undefined && l.값 !== null) return say(h, l.값); + if (l?.표) return [lt("Tbl"), ...Object.values(l.조건 ?? {}), l.칸].filter(Boolean).join(" · "); + if (l?.키) return w.이름 || h.name(l.키) || l.키; + return w.이름 || "—"; +} + +export function applyDiff(h: DiffHooks): void { + const g = docDiff(h.doc, h.up, h.top); + const tip = (m: DiffMark): string => + `${lt(m.diff === "mine" ? "Ctl_Was" : "Diff_Upper_Was")} ${say(h, m.was)}`; + /** 칸 묶음 → 가장 센 표시(나 › 위) */ + const pick = (paths: string[]): [string, DiffMark][] => + paths.flatMap((p) => (g.marks.get(p) ? [[p, g.marks.get(p)!] as [string, DiffMark]] : [])); + const top = (got: [string, DiffMark][]): DiffMark | undefined => + got.find(([, m]) => m.diff === "mine")?.[1] ?? got[0]?.[1]; + const back = (got: [string, DiffMark][], title: string): HTMLElement | null => { + const mine = got.filter(([, m]) => m.diff === "mine" && m.back); + if (!h.edit || !mine.length) return null; + const b = createIconButton({ + icon: "undo", + title, + size: 24, + onClick: () => h.change((d, items) => mine.forEach(([p, m]) => resetPath(d, items, p, m.was))), // prettier-ignore + }); + b.dataset.diffBack = mine.map(([p]) => p).join(" "); + return b; + }; + /** 칸(입력 · 고르기 · 단추)에 테두리 · 풍선 · 곁에 [↶] */ + const mark = (node: Element | null, paths: string[], after: Element | null = node): void => { + if (!(node instanceof HTMLElement)) return; + const got = pick(paths); + const m = top(got); + const field = node.matches(".ui-input, .ui-select, .ui-btn, .lstk-expr") + ? node + : (node.querySelector(".ui-input, .ui-select, .ui-btn") ?? node); + setUiDiff(field, m?.diff ?? null); + if (!m) return; + field.title = `${field.title ? `${field.title} — ` : ""}${tip(m)}`; + const b = back(got, `${tip(m)} — ${lt("Diff_Back")}`); + if (b && after) after.insertAdjacentElement("afterend", b); + }; + + // ── 옵션 가로 ── + const byKey = new Map((h.doc.변수 ?? []).map((v) => [v.열쇠, varId(v)])); + h.head.querySelectorAll("[data-option]").forEach((f) => { + const id = byKey.get(f.dataset.option); + if (!id) return; + mark(f, [`v:${id}`]); + const b = f.nextElementSibling; + if (b instanceof HTMLElement && b.dataset.diffBack) { + const pair = el("span", { className: "lstk-dpair" }); // 칸 + [↶] 한 칸(옵션 가로 칸 폭) + f.replaceWith(pair); + pair.append(f, b); + } + }); + + // ── 공식 묶음(값 · 식 글 · 표 값 · 고침 칸) ── + h.left.querySelectorAll(".lstk-frow[data-sym]").forEach((row) => { + const id = row.dataset.sym!; + if (row.classList.contains("is-open")) { + const [, expr, unit] = row.querySelectorAll(":scope > .ui-field"); + mark(expr ?? null, [`v:${id}`]); + mark(unit ?? null, [`u:${id}`]); + return; + } + const at = [ + row.querySelector(":scope > .ui-field"), + row.querySelector(":scope > .lstk-expr"), + row.querySelector(`[data-table-pick]`), + ].filter(Boolean) as Element[]; + at.forEach((x, k) => mark(x, [`v:${id}`], k === at.length - 1 ? x : null)); + }); + + // ── 금액 줄 · 글 줄 ── + const owned = ownedOf(h.doc); + h.left.querySelectorAll(".lstk-line[data-loc]").forEach((card) => { + const [k, j] = card.dataset.loc!.split(".").map(Number); + const line = h.items[k]?.줄[j]; + if (line?.꼴 === "글") return mark(card.querySelector(".ui-field"), [`g:${k}.${j}`]); + if (line?.꼴 !== "금액") return; + const i = line.i; + const own = owned.get(i); + const qty = String(h.doc.금액?.[i]?.수량 ?? ""); + const by = (label: string): Element | null => + card.querySelector(`:scope > .ui-field [aria-label="${CSS.escape(label)}"]`)?.closest(".ui-field") ?? null; // prettier-ignore + const qs = (q: string): Element | null => card.querySelector(`:scope > ${q}`); + const sym = h.doc.변수?.some((v) => varId(v) === qty) ? [`v:${qty}`] : []; + mark(qs("[data-repick]"), [...(own ? [`v:${own}`] : []), `m:${i}:이름`]); + mark(by(lt("Name")), [`m:${i}:이름`]); + mark(by(lt("Price")), [`m:${i}:단가`]); + mark(qs(".lstk-qty > [data-qty]"), [`m:${i}:수량`, ...sym], qs(".lstk-qty")); + mark(qs(".lstk-upick .ui-btn"), [`m:${i}:단위`], qs(".lstk-upick")); + mark(qs(".ui-field select"), [`m:${i}:비목`]); + setUiDiff(card, g.lines.get(i) ?? null); + const all = pick([...LINE_FIELDS.map((f) => `m:${i}:${f}`), ...(own ? [`v:${own}`] : [])]); + const fields = new Set(all.filter(([, m]) => m.diff === "mine" && m.back).map(([p]) => (p === `v:${own}` ? `m:${i}:이름` : p))); // prettier-ignore + const lb = fields.size > 1 ? back(all, lt("Diff_Line_Back")) : null; // 칸 둘 넘게 고친 줄 + if (lb) { + lb.dataset.diffLine = String(i); + card.querySelector(":scope > .lstk-x")?.insertAdjacentElement("beforebegin", lb); + } + }); + + // ── 그룹 머리 — 이름 · 빠진 줄 되살림 ── + h.left.querySelectorAll(".lstk-item[data-loc]").forEach((box) => { + const k = Number(box.dataset.loc); + const head = box.querySelector(":scope > .lstk-ihead"); + if (!head) return; + mark(head.querySelector(":scope > .ui-field"), [`t:${k}`]); + const gone = g.gone.get(k); + if (!gone) return; + const what = gone.at.map((b) => String(gone.src.금액?.[b]?.이름 ?? "—")).join(" · "); + const b = createButton({ + label: `${lt("Diff_Gone")} ${gone.at.length}`, + variant: "ghost", + size: 24, + iconStart: "undo", + disabled: !h.edit, + onClick: () => h.change((d, items) => restoreLines(d, items, gone.src, gone.at, k)), + }); + setUiDiff(b, gone.diff satisfies DiffKind); + b.title = `${lt(gone.diff === "mine" ? "Diff_Gone_Tip" : "Diff_Gone_Up")} — ${what}`; + b.dataset.diffGone = String(k); + head.querySelector(":scope > .ui-row-menu")?.insertAdjacentElement("beforebegin", b); + }); +} diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 71fff1227..a71402e4d 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -17,6 +17,7 @@ * 저장 전 문서(`memory` · 836-5 · 불러오기 미리 보기) = 빈 키 + 서버에 문서째(`본`) 읽음 · 왼쪽 줄 쌓기는 보기만(inert) · 디스크 쓰기 0 * 층(848-3) — SK 읽기 · 미리 셈 답 `위덮음`(① 기초 고침) 을 셈 · 산출근거 · 제어 구역에 얹음(`layeredCover` · 화면 셈 = 서버 셈) · * M01 기초 = 시스템 관리자에게 제어 구역 엶 · 머리 [초기화] = 그 기초 기계 고침 전부 걷고 저장(확인창 목록) + * 바뀐 자리(848-8) — 읽기 답 `층바탕`(위 층 · 빌더 문서)과 칸 단위로 맞대 테두리 · 칸 · 줄 되돌림(`line_stack_diff.ts`) * ========================================================================== */ import { API_BASE_URL } from "@config/config_frontend"; @@ -69,6 +70,7 @@ import { ft } from "./formula_doc_text"; import { addTaken, type Taken } from "../common_util/common_util_line_stack_copy"; import { machineWork } from "../common_util/common_util_line_stack_work"; import type { Layer } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch"; +import { applyDiff } from "./line_stack_diff"; import { buildEdit } from "./line_stack_edit"; import { openMachineWindow, type CopyAnswer, type MachineCtx } from "./line_stack_machine"; import { dropPath } from "../common_util/common_util_formula_doc_cover_drop"; @@ -104,6 +106,8 @@ interface Loaded { 판?: string; /** 848-1 ① 위 층 고침(SK · 프로젝트 밖 = 지금 기초 것) */ 위덮음?: Cover; + /** 848-8 바뀐 자리 바탕 — 위 층 문서 · 빌더 문서(기초 손고침) */ + 층바탕?: { 위?: StackDoc; 빌더?: StackDoc }; } const clone = (v: T): T => JSON.parse(JSON.stringify(v)) as T; @@ -138,6 +142,7 @@ export function createStackScreen(opt: StackScreenOptions) { let mark: CopyMark | undefined; let version = ""; let upper: Cover | null = null; // 848-3 ① 위 층 고침 + let layer: Loaded["층바탕"] = undefined; // 848-8 바뀐 자리 바탕(읽기 · 저장 답 · 없으면 그대로) let seq = 0; let asked = ""; let ctl: AbortController | null = null; @@ -411,6 +416,8 @@ export function createStackScreen(opt: StackScreenOptions) { : []), ); left.inert = !!mem(); // 저장 전 문서 = 보기만(고침은 저장 뒤) + if (layer?.위) + applyDiff({ head, left, doc, items, up: layer.위, top: layer.빌더, edit: edit() && !mem(), change, name: (k) => cache.names.get(k) ?? "" }); // prettier-ignore right.replaceChildren( items.length || doc.결과 ? buildOut(doc, answer, { @@ -441,6 +448,7 @@ export function createStackScreen(opt: StackScreenOptions) { mark = got.사본; version = got.판 ?? ""; upper = got.위덮음 ?? null; + if (got.층바탕) layer = got.층바탕; }; /** 848-3 M01 기초 [초기화] — 기계 고침 목록 확인 → 걷고 저장(서버 정본 · 저장 안 한 고침이 있으면 먼저) */ @@ -557,7 +565,7 @@ export function createStackScreen(opt: StackScreenOptions) { asked = ""; cache = createDocCache(); tables.clear(); - [cut, mark, version] = [{}, undefined, ""]; + [cut, mark, version, layer] = [{}, undefined, "", undefined]; draw(); if (!next) { if (mem()) { diff --git a/A00_Common/line_stack_text.ts b/A00_Common/line_stack_text.ts index 3c382019b..ef1217300 100644 --- a/A00_Common/line_stack_text.ts +++ b/A00_Common/line_stack_text.ts @@ -104,6 +104,18 @@ const TEXT = { ], Ctl_Was: ["원래 값", "Original"], Ctl_Back: ["원래 값", "Original"], + Diff_Upper_Was: ["기초에서 바뀜 — 바꾸기 전", "Changed in base — before"], + Diff_Back: ["누르면 되돌림(캐시 · [저장] 때 반영)", "Revert (saved on [Save])"], + Diff_Line_Back: [ + "이 줄 고침 전부를 위 층 값으로(캐시 · [저장] 때 반영)", + "Revert all edits of this line (saved on [Save])", + ], + Diff_Gone: ["되살림", "Restore"], + Diff_Gone_Tip: ["위 층에 있고 여기서 뺀 줄", "Lines removed here"], + Diff_Gone_Up: [ + "기초에서 뺀 줄(되살리면 내 고침)", + "Lines removed in base (restoring is your edit)", + ], Ctl_Bad: ["0 이상 수만 넣을 수 있음", "Enter a number 0 or more"], Ctl_Crew_Qty: ["인원", "Persons"], Ctl_Per_Day: ["인/일", "per day"], diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 62c84cb3e..e273dd7af 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -4,7 +4,8 @@ 셈 = `master_doc_calc.calc`(파이썬 정본 · TS 짝 `common_util_formula_doc_calc.ts`) · 연결 기록 = `master_doc_record.Rec` — 셈이 쓴 요소 값 · 표 · 단가산출 문서를 화면 캐시로 실음 (화면은 같은 계산기로 즉시 셈 · 캐시에 없는 연결만 뒤에서 미리 셈). -- 읽기 {키} → {문서, 셈, 연결, 파일, 새} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) +- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 층바탕?} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) · + 층바탕(848-8) = {위: 빌더가 지을 문서} — 화면이 칸 단위로 맞대 시스템 관리자 고침 테두리(읽기만 · 파일 안 씀) - 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음 - 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음) · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면 @@ -67,6 +68,10 @@ def _run(doc: dict, given: dict | None = None) -> dict: rec = mr.Rec(links) rec.prefetch(doc) answer = mc.calc(doc, rec, _dec(given or {})) + # 848-8 덮인 칸의 정본 값도 기록(제어 구역 「원래 값」) — 작업량만 얹음 + if cover := mcv.cover_of(doc): + work = {k: {"작업량": v["작업량"]} for k, v in cover.items() if "작업량" in (v or {})} + mc.calc(doc, rec, _dec(given or {}), cover=work) # 셈 답은 위 · 기록만 return {"셈": answer, "연결": rec.out()} @@ -88,7 +93,9 @@ def read(key: str) -> dict: row = store.logic(key)["logic"] # 없는 키 = 404 found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) out = _run(found) - return {"문서": found, **out, "파일": _where(key) or "", "새": fresh} + up = None if fresh else built(key) + more = {"층바탕": {"위": up}} if up is not None else {} + return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, **more} def preview(doc: dict, given: dict | None = None) -> dict: diff --git a/M02_MasterTemplete/M02_Doc_Screen.py b/M02_MasterTemplete/M02_Doc_Screen.py index 58b0a4357..ced36e410 100644 --- a/M02_MasterTemplete/M02_Doc_Screen.py +++ b/M02_MasterTemplete/M02_Doc_Screen.py @@ -30,14 +30,24 @@ def record(copy: dict) -> dict[str, Any]: import master_doc_record as mr # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤 rec = mr.Rec(dc.ml.Links(dc.over(copy), dc.docs_of(copy))) + cover = dc.cover_of(copy) try: rec.prefetch(copy["문서"]) - dc.mc.calc(copy["문서"], rec, cover=dc.cover_of(copy)) # ① + ②(848-1) + dc.mc.calc(copy["문서"], rec, cover=cover) # ① + ②(848-1) + # 848-8 덮인 칸의 정본 값도 기록(제어 구역 「원래 값」) — 작업량만 얹어 같은 기계를 부름 + if cover: + dc.mc.calc(copy["문서"], rec, cover=work_only(cover)) except dc._ERR: # 셈 틀림 = 셈 답 표지(`dc.run`) — 기록은 모은 데까지 pass return rec.out() +def work_only(cover: dict) -> dict: + """덮음에서 작업량(기계 고정 · 식 · 변수)만 — 값 · 조종원 · 잡품 덮음 뺌(848-8).""" + work = dc.mw.WORK + return {k: {work: v[work]} for k, v in cover.items() if isinstance(v, dict) and work in v} + + class LinksBody(BaseModel): 갈래: str 검색: str = "" diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 79a0f516c..572ccaa34 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -12,6 +12,7 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} 저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`). 위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② · 저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`). +바뀐 자리 바탕(848-8) = 읽기 답 칸 `층바탕`(`layers` · 화면이 칸 단위로 맞대 테두리 · 칸 되돌림). """ from __future__ import annotations @@ -101,10 +102,36 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: return json.loads(json.dumps(dc.ml._norm(body), ensure_ascii=False, default=str)) +def layers(copy: dict, sk: dict) -> dict[str, Any]: + """848-8 바뀐 자리 바탕 — {위: 위 층 문서, 빌더?: 기초가 손고침이면 빌더 문서} · 모름 = 빈 묶음. + 위 층 = 그 기초 문서(지금 · 덮음 · 손고침 표지 뺌 · 옵션 값 = 파생과 같게 옛 로직 줄 기본) · + 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) · 읽기만(파일 안 씀).""" + if dim.is_imported(sk): + up = copy.get(renew.FIRST) if copy.get("따로") else copy.get("문서") + out = {"위": up} if up else {} + else: + key = str((sk.get("바탕") or {}).get("로직") or "") + live = dc.folder().get(key) if key else None + if live is None: + return {} + out = {"위": {k: v for k, v in live.items() if k not in (mcv.COVER, mcv.HAND)}} + if live.get(mcv.HAND): + from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 + + if (top := m01.built(key)) is not None: + out["빌더"] = top + out = json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) # 사본 + auto = dc.given_of(skc.whole_(), key, {}) # `derive` 와 같은 옵션 값 + for doc in out.values(): + dsk._set_values(doc, auto) + return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) + + def read(key: str) -> dict[str, Any]: - """읽기 — {문서, 부름, 끊음, 셈, 사본, 판}.""" + """읽기 — {문서, 부름, 끊음, 셈, 사본, 판, 층바탕}.""" got = _file(key) - out = {**answer(current(got["문서"]), got["문서"]), "판": got["판"]} + copy = current(got["문서"]) + out = {**answer(copy, got["문서"]), "판": got["판"], "층바탕": layers(copy, got["문서"])} out["사본"]["갱신"] = renew.notes(got["문서"]) # 836-2 열 때 알림(지울 고침) return out @@ -112,7 +139,8 @@ def read(key: str) -> dict[str, Any]: def read_memory(sk: Any) -> dict[str, Any]: """저장 전 문서 읽기(836-5) — 몸 `본` 그대로 셈 · {read 꼴 · 판 = 빈 글} · 디스크 쓰기 0.""" doc = _mem(sk) - return {**answer(current(doc), doc), "판": ""} + copy = current(doc) + return {**answer(copy, doc), "판": "", "층바탕": layers(copy, doc)} def _mem(raw: Any) -> dict: @@ -210,6 +238,37 @@ def _preview(key: str, body: dict) -> dict[str, Any]: return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) +_NOT_DOC = ("키", "이름", mcv.COVER, mcv.HAND) # 파생 견줌에서 뺄 문서 칸 + + +def _bare(doc: Any) -> str: + """파생 견줌 지문 — 문서 칸 그대로(변수 · 식 줄 차례 무시 · 키 · 이름 · 덮음 뺌).""" + d = {k: v for k, v in (doc or {}).items() if k not in _NOT_DOC} + d["변수"] = sorted(d.get("변수") or [], key=lambda v: dc.md.var_id(v)) + d["식"] = sorted(d.get("식") or [], key=lambda x: str(x.get("기호") or "")) + return dc.fp(d) + + +def plain(mine: dict, sk: dict) -> dict: + """848-8 — 따로 사본을 다 되돌려 위 층과 같아지면 파생으로(고침 흔적 0) — 끊음 · 기계 고침 없고 + 문서가 지금 파생 문서와 같음(글 · 차림까지 · 가져온 식 = 불러올 때 문서 `처음`) · 아니면 그대로.""" + doc = mine.get("문서") or {} + if mine.get("끊음") or not mine.get("따로") or doc.get(mcv.COVER): + return mine + if dim.is_imported(sk): + first = mine.get(renew.FIRST) + same = first is not None and _bare(first) == _bare(doc) + return {k: v for k, v in mine.items() if k not in ("따로", renew.FIRST)} if same else mine + drop = ("따로", "문서", "끊음", renew.FIRST, mcv.COVER) + head = {k: v for k, v in (sk.get(dsk.KEY) or {}).items() if k not in drop} + try: + got = current({**sk, dsk.KEY: head}) if head else None + except store.StoreError: + return mine + same = got and not got.get("따로") and _bare(got.get("문서")) == _bare(doc) + return got if same else mine + + def _rows(copy: dict) -> set[str]: return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]} @@ -245,7 +304,7 @@ def _save(key: str, body: dict, got: dict) -> dict[str, Any]: raw = {**_basis(got["문서"], body), **({skc.JOB: job} if job else {})} token = None if job != skc.REGEN and (body.get("문서") is not None or body.get("끊음") is not None): - mine = edited(current(got["문서"], job), body, key, got["문서"]) + mine = plain(edited(current(got["문서"], job), body, key, got["문서"]), got["문서"]) token = dsk.SAVING.set({"키": key, "사본": mine}) try: store.write(sd.KIND, key, got["판"], raw) diff --git a/common_util/common_util_line_stack_diff.ts b/common_util/common_util_line_stack_diff.ts new file mode 100644 index 000000000..de9cfa9b6 --- /dev/null +++ b/common_util/common_util_line_stack_diff.ts @@ -0,0 +1,298 @@ +/* ============================================================================= + * common_util_line_stack_diff.ts + * 바뀐 자리 지도(PLAN 848-8 · 요구 889) — 지금 문서를 위 층 문서와 칸 단위로 맞댐 · 화면 · DOM · fetch 없음(시험이 Node 로 돌림) + * 위 층(서버 읽기 답 `층바탕.위`) = M01 기초 = 빌더가 지은 문서 · M02 단가산출 = 그 기초 문서(지금) · 가져온 식 = 불러올 때 문서 + * 그 위(`층바탕.빌더` · SK 만) = 기초가 손고침일 때 빌더 문서 — 기초에서 관리자가 바꾼 칸(주황) + * 칸 경로 = `v:<기호>`(값 정의 — 연결 · 식 줄 · 이름 · 옵션 · 공식 값 · 표 값 · 자원) · `u:<기호>`(단위) · + * `m:<금액 줄>:<이름 | 단가 | 수량 | 단위 | 비목>` · `t:<항목>`(제목) · `g:<항목>.<줄>`(글 줄) + * 금액 줄 짝 = 단가 글(같으면 차례대로) › 남은 줄은 이름 · 줄 틀 = 더한 줄 · 차례 바뀐 줄 · 빠진 줄 = 항목마다 되살림 목록 + * 견줌 = 수 · 수 글 같음 · 빈 칸 = 없음 · 글 사이 띄어쓰기 무시(표시 탓 다름 0) + * 되돌림 = 칸 하나(`resetPath`) · 빠진 줄 되살림(`restoreLines` — 그 줄이 부르는 기호까지) — 부른 쪽 `change` 안에서 + * ========================================================================== */ + +import { + names, + varId, + type DocVar, + type FormulaDoc, + type MoneyLine, +} from "./common_util_formula_doc"; +import { + newVar, + nodeOf, + stackOf, + usesOf, + type StackDoc, + type StackItem, +} from "./common_util_line_stack"; + +export type DiffKind = "mine" | "upper"; +/** 칸 표시 — `was` = 되돌릴 값(나) · 바꾸기 전 값(위) · `back` = 되돌릴 값이 있음 */ +export interface DiffMark { + diff: DiffKind; + was: unknown; + back: boolean; +} +export interface DocDiff { + marks: Map; + /** 지금 금액 줄 → 줄 틀(더한 줄 · 차례 바뀐 줄) */ + lines: Map; + /** 지금 항목 → 빠진 줄(`src` 문서 금액 차례) */ + gone: Map; + /** 지금 금액 줄 → 위 층 금액 줄(-1 = 더한 줄) */ + match: number[]; +} + +export const LINE_FIELDS = ["이름", "단가", "수량", "단위", "비목"] as const; +type Line = MoneyLine & { 규격?: string }; + +/** 견줌 꼴 — 수 글 = 수 · 빈 값 = undefined · 글 띄어쓰기 뺌 · 묶음 칸 차례 정렬 */ +export function canon(x: unknown): unknown { + if (x === null || x === undefined) return undefined; + if (typeof x === "string") { + const t = x.replace(/\s+/g, ""); + if (!t) return undefined; + const n = Number(t.replace(/,/g, "")); + return /^-?[\d,]*\.?\d+$/.test(t) && Number.isFinite(n) ? n : t; + } + if (Array.isArray(x)) return x.length ? x.map(canon) : undefined; + if (typeof x === "object") { + const out: Record = {}; + for (const k of Object.keys(x).sort()) { + const v = canon((x as Record)[k]); + if (v !== undefined) out[k] = v; + } + return Object.keys(out).length ? out : undefined; + } + return x; +} +export const same = (a: unknown, b: unknown): boolean => + JSON.stringify(canon(a)) === JSON.stringify(canon(b)); + +const varsOf = (d: FormulaDoc): Map => + new Map((d.변수 ?? []).map((v) => [varId(v), v])); +const stepsOf = (d: FormulaDoc): Map => + new Map((d.식 ?? []).map((l) => [String(l.기호 ?? ""), String(l.식 ?? "")])); + +/** 칸 경로 값(`v:` = {연결, 식, 이름} · 없는 기호 = undefined) */ +function valueAt(vars: Map, steps: Map, id: string) { + const v = vars.get(id); + const s = steps.get(id); + return v || s !== undefined + ? { 변수: !!v || undefined, 연결: v?.연결, 식: s, 이름: v?.이름 } + : undefined; +} +const lineVal = (l: Line | undefined, f: string): unknown => + !l + ? undefined + : f === "이름" + ? { 이름: l.이름, 규격: l.규격 } + : (l as Record)[f]; + +/** 금액 줄 짝 — 지금 차례 → 위 층 차례(-1 = 없음) */ +export function matchLines(now: MoneyLine[], up: MoneyLine[]): number[] { + const pool = new Map(); + up.forEach((l, j) => { + const k = JSON.stringify(canon(l.단가)); + pool.set(k, [...(pool.get(k) ?? []), j]); + }); + const out = now.map((l) => pool.get(JSON.stringify(canon(l.단가)))?.shift() ?? -1); + const free = up.map((_, j) => j).filter((j) => !out.includes(j)); + now.forEach((l, i) => { + if (out[i] >= 0 || canon(l.이름) === undefined) return; + const at = free.findIndex((j) => same(up[j].이름, l.이름)); + if (at >= 0) out[i] = free.splice(at, 1)[0]; + }); + return out; +} + +/** 차례가 바뀐 짝 줄 — 가장 긴 오름 차례에 안 든 것 */ +function movedOf(match: number[]): Set { + const at = match.map((b, i) => [b, i]).filter(([b]) => b >= 0); + const len: number[] = []; + const prev: number[] = []; + at.forEach(([b], k) => { + len[k] = 1; + prev[k] = -1; + for (let p = 0; p < k; p++) + if (at[p][0] < b && len[p] + 1 > len[k]) [len[k], prev[k]] = [len[p] + 1, p]; + }); + const keep = new Set(); + for (let k = len.indexOf(Math.max(0, ...len)); k >= 0; k = prev[k]) keep.add(at[k][1]); + return new Set(at.map(([, i]) => i).filter((i) => !keep.has(i))); +} + +const itemOfLine = (items: StackItem[]): Map => { + const out = new Map(); + items.forEach((it, k) => it.줄.forEach((l) => l.꼴 === "금액" && out.set(l.i, k))); + return out; +}; + +/** 지금 항목 → 위 층 항목(그 항목 금액 줄의 짝 · 없으면 같은 차례) */ +function itemsMatch(now: StackItem[], up: StackItem[], match: number[]): number[] { + const upOf = itemOfLine(up); + const out = now.map((it) => { + const l = it.줄.find((x) => x.꼴 === "금액" && match[x.i] >= 0); + return l && l.꼴 === "금액" ? (upOf.get(match[l.i]) ?? -1) : -1; + }); + out.forEach((b, k) => { + if (b < 0 && k < up.length && !out.includes(k)) out[k] = k; + }); + return out; +} + +/** 지금 문서 대 위 층 · (있으면) 그 위 — 바뀐 자리 지도 */ +export function docDiff(now: StackDoc, up: StackDoc, top?: StackDoc | null): DocDiff { + const out = mineDiff(now, up); + if (!top) return out; + const t = mineDiff(up, top); // 위 층 좌표 — 위 층에서 바뀐 칸 + const put = (p: string, m: DiffMark | undefined): void => { + if (m && !out.marks.has(p)) out.marks.set(p, { diff: "upper", was: m.was, back: false }); + }; + for (const [p, m] of t.marks) if (/^[vu]:/.test(p)) put(p, m); + const ni = stackOf(now); + const im = itemsMatch(ni, stackOf(up), out.match); + out.match.forEach((b, i) => { + if (b < 0) return; + for (const f of LINE_FIELDS) put(`m:${i}:${f}`, t.marks.get(`m:${b}:${f}`)); + if (t.lines.has(b) && !out.lines.has(i)) out.lines.set(i, "upper"); + }); + const back = new Set(matchLines(now.금액 ?? [], top.금액 ?? [])); // 되살린 줄 = 빠짐 아님 + im.forEach((b, k) => { + if (b < 0) return; + put(`t:${k}`, t.marks.get(`t:${b}`)); + const at = (t.gone.get(b)?.at ?? []).filter((x) => !back.has(x)); + if (at.length && !out.gone.has(k)) out.gone.set(k, { diff: "upper", src: top, at }); + }); + return out; +} + +function mineDiff(now: StackDoc, up: StackDoc): DocDiff { + const marks = new Map(); + const mark = (p: string, a: unknown, b: unknown): void => { + if (!same(a, b)) marks.set(p, { diff: "mine", was: b, back: canon(b) !== undefined }); + }; + const [nv, uv, ns, us] = [varsOf(now), varsOf(up), stepsOf(now), stepsOf(up)]; + for (const id of new Set([...nv.keys(), ...ns.keys()])) { + mark(`v:${id}`, valueAt(nv, ns, id), valueAt(uv, us, id)); + if (uv.has(id) || nv.get(id)?.단위) mark(`u:${id}`, nv.get(id)?.단위, uv.get(id)?.단위); + } + const [nl, ul] = [(now.금액 ?? []) as Line[], (up.금액 ?? []) as Line[]]; + const match = matchLines(nl, ul); + const lines = new Map(); + match.forEach((b, i) => { + if (b < 0) return void lines.set(i, "mine"); + for (const f of LINE_FIELDS) mark(`m:${i}:${f}`, lineVal(nl[i], f), lineVal(ul[b], f)); + }); + for (const i of movedOf(match)) lines.set(i, "mine"); + const [ni, ui] = [stackOf(now), stackOf(up)]; + const im = itemsMatch(ni, ui, match); + ni.forEach((it, k) => { + const b = ui[im[k]]; + mark(`t:${k}`, it.제목, b?.제목); + const was = (b?.줄 ?? []).filter((l) => l.꼴 === "글"); + let n = 0; + it.줄.forEach( + (l, j) => l.꼴 === "글" && mark(`g:${k}.${j}`, l.글, (was[n++] as { 글?: string })?.글), + ); + }); + const gone = new Map(); + const upOf = itemOfLine(ui); + ul.forEach((_, b) => { + if (match.includes(b) || !ni.length) return; + const bi = upOf.get(b) ?? 0; + const k = im.includes(bi) ? im.indexOf(bi) : Math.min(bi, ni.length - 1); + const g = gone.get(k) ?? { diff: "mine" as DiffKind, src: up, at: [] }; + g.at.push(b); + gone.set(k, g); + }); + return { marks, lines, gone, match }; +} + +// ── 되돌림(부른 쪽 `change` 안 · 문서 · 차림을 고침) ── +const clone = (v: T): T => JSON.parse(JSON.stringify(v)) as T; + +/** 칸 하나를 `was` 로(경로 꼴 그대로) */ +export function resetPath(d: StackDoc, items: StackItem[], path: string, was: unknown): void { + const [kind, rest] = [path.slice(0, 1), path.slice(2)]; + if (kind === "v") return setValue(d, rest, was as ReturnType); + if (kind === "u") { + const v = (d.변수 ?? []).find((x) => varId(x) === rest); + if (v && canon(was) === undefined) delete v.단위; + else if (v) v.단위 = String(was); + return; + } + if (kind === "m") { + const [i, f] = [Number(rest.split(":")[0]), rest.split(":")[1]]; + const l = (d.금액 ?? [])[i] as Line | undefined; + if (!l) return; + const put = (k: string, x: unknown): void => { + if (x === undefined || x === null) delete (l as Record)[k]; + else (l as Record)[k] = clone(x); + }; + if (f === "이름") { + const w = (was ?? {}) as { 이름?: string; 규격?: string }; + put("이름", w.이름); + put("규격", w.규격); + } else put(f, was); + return; + } + if (kind === "t" && items[Number(rest)]) items[Number(rest)].제목 = String(was ?? ""); + if (kind === "g") { + const [k, j] = rest.split(".").map(Number); + const l = items[k]?.줄[j]; + if (l?.꼴 === "글") l.글 = String(was ?? ""); + } +} + +function setValue(d: StackDoc, id: string, was: ReturnType): void { + d.변수 = (d.변수 ?? []).filter((x) => varId(x) !== id || was?.변수); + let v = d.변수.find((x) => varId(x) === id); + if (was?.변수 && !v) d.변수.push((v = newVar(id, undefined))); + if (v) { + if (was?.연결 === undefined) delete v.연결; + else v.연결 = clone(was.연결); + if (was?.이름 === undefined) delete v.이름; + else v.이름 = was.이름; + } + d.식 = (d.식 ?? []).filter((l) => String(l.기호 ?? "") !== id); + if (was?.식 !== undefined) d.식.push({ 기호: id, 식: was.식 }); +} + +/** 빠진 줄 되살림 — `src` 금액 줄 `at` 을 항목 `k` 에(앞 짝 줄 뒤) · 그 줄이 부르는 기호 중 없는 것도 */ +export function restoreLines( + d: StackDoc, + items: StackItem[], + src: StackDoc, + at: number[], + k: number, +): void { + const it = items[k]; + if (!it) return; + const have = new Set([...varsOf(d).keys(), ...stepsOf(d).keys()]); + const uses = usesOf(src); + const [sv, ss] = [varsOf(src), stepsOf(src)]; + const pull = (id: string): void => { + if (have.has(id) || (!sv.has(id) && !ss.has(id))) return; + have.add(id); + if (sv.has(id)) (d.변수 ??= []).push(clone(sv.get(id)!)); + if (ss.has(id)) (d.식 ??= []).push({ 기호: id, 식: ss.get(id)! }); + (uses.get(id) ?? []).forEach(pull); + }; + const match = matchLines(d.금액 ?? [], src.금액 ?? []); + for (const b of [...at].sort((x, y) => x - y)) { + const line = clone((src.금액 ?? [])[b]); + if (!line) continue; + for (const t of [line.수량, line.단가]) { + const n = nodeOf(t); + if (n) names(n).forEach(pull); + } + const n = (d.금액 ??= []).push(line) - 1; + match[n] = b; + let p = 0; // 앞 짝 줄 뒤 + it.줄.forEach((l, j) => { + if (l.꼴 === "금액" && match[l.i] >= 0 && match[l.i] < b) p = j + 1; + }); + it.줄.splice(p, 0, { 꼴: "금액", i: n }); + } +} diff --git a/resources/tester/helper_848_8_diff.cjs b/resources/tester/helper_848_8_diff.cjs new file mode 100644 index 000000000..67ddc73f5 --- /dev/null +++ b/resources/tester/helper_848_8_diff.cjs @@ -0,0 +1,67 @@ +/* 848-8 바뀐 자리 지도 헬퍼 — common_util_line_stack_diff.ts 를 트랜스파일해 Node 로 돌림. + * stdin = {전수: [{키, 문서, 위}]} → [{키, 표시: [경로…]}](문서 → 줄 쌓기 → 문서 왕복 뒤 위 층과 맞댐 · 표시 있는 것만) + * | {문서, 위, 빌더?, 고침: [{꼴: "칸", 경로, 값} | {꼴: "되돌림", 경로} | {꼴: "줄뺌", 줄} | {꼴: "옮김", 항목, 줄, 곳} + * | {꼴: "되살림", 항목} | {꼴: "줄되돌림", 줄}]} + * → 걸음마다(고침 없음 = 연 그대로 한 번) {표시: {경로: [나|위, was, back]}, 줄틀: {줄: 나|위}, 빠짐: {항목: [나|위, [줄…]]}, 문서} + */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); + +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(at, box.exports); + const need = (p) => + p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p); + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const root = path.join(__dirname, "..", "..", "common_util"); +const df = load(path.join(root, "common_util_line_stack_diff.ts")); +const ls = load(path.join(root, "common_util_line_stack.ts")); + +const clone = (v) => JSON.parse(JSON.stringify(v)); +const sum = (g) => ({ + 표시: Object.fromEntries([...g.marks].map(([p, m]) => [p, [m.diff, m.was ?? null, m.back]])), + 줄틀: Object.fromEntries(g.lines), + 빠짐: Object.fromEntries([...g.gone].map(([k, x]) => [k, [x.diff, x.at]])), +}); + +const ask = JSON.parse(fs.readFileSync(0, "utf8")); +if (ask.전수) { + const out = []; + for (const c of ask.전수) { + const d = ls.docOf(clone(c.문서), ls.stackOf(c.문서)); + const g = df.docDiff(d, c.위 ?? c.문서); + const bad = [...g.marks.keys(), ...[...g.lines.keys()].map((i) => `줄${i}`), ...[...g.gone.keys()].map((k) => `빠짐${k}`)]; // prettier-ignore + if (bad.length) out.push({ 키: c.키, 표시: bad.slice(0, 8) }); + } + process.stdout.write(JSON.stringify(out)); +} else { + let doc = clone(ask.문서); + const steps = ask.고침.length ? [] : [sum(df.docDiff(doc, ask.위, ask.빌더))]; // 고침 없음 = 열 때 표시 + for (const s of ask.고침) { + const g = df.docDiff(doc, ask.위, ask.빌더); + const items = ls.stackOf(doc); + if (s.꼴 === "칸") df.resetPath(doc, items, s.경로, s.값); + if (s.꼴 === "되돌림") df.resetPath(doc, items, s.경로, g.marks.get(s.경로).was); + if (s.꼴 === "줄되돌림") + for (const [p, m] of g.marks) + if (p.startsWith(`m:${s.줄}:`) && m.back) df.resetPath(doc, items, p, m.was); + if (s.꼴 === "줄뺌") + items.forEach((it) => (it.줄 = it.줄.filter((l) => !(l.꼴 === "금액" && l.i === s.줄)))); + if (s.꼴 === "옮김") ls.moveLine(items, s.항목, s.줄, s.항목, s.곳); + if (s.꼴 === "되살림") { + const x = g.gone.get(s.항목); + df.restoreLines(doc, items, x.src, x.at, s.항목); + } + doc = ls.docOf(doc, items); + steps.push({ ...sum(df.docDiff(doc, ask.위, ask.빌더)), 문서: doc }); + } + process.stdout.write(JSON.stringify(steps)); +} diff --git a/resources/tester/test_848_8_diff.py b/resources/tester/test_848_8_diff.py new file mode 100644 index 000000000..0e18e069d --- /dev/null +++ b/resources/tester/test_848_8_diff.py @@ -0,0 +1,139 @@ +"""848-8 바뀐 자리 표시 2 단계(요구 889 · 요구서_889 5 장) — 칸 단위 바탕 지도 · 칸 · 줄 되돌림 · 파생 복귀. + +짝 = `common_util/common_util_line_stack_diff.ts`(화면 테두리 · [↶] · [되살림]) · 서버 읽기 답 `층바탕` +(`M02_Doc_Sk_Path.layers` · `M01_MasterData_Doc.read`) · 저장 `plain`(위 층과 같아지면 파생 · 흔적 0). +① 전수 — 수식 문서 1,520 장을 줄 쌓기로 차려 되굳혀도 위 층(제 문서)과 표시 0. +② 칸 — 옵션 · 수량 고침 = 나 · [↶] 되돌림 = 표시 0 · 줄 뺌 = 그룹 [되살림] · 되살림 = 처음 문서와 같음 · 차례 = 줄 틀. +③ 층 — 기초에서 바꾼 칸(빌더 대 기초) = 위(주황 · 되돌림 없음) · 내가 또 고치면 나 · 기초가 뺀 줄 되살림 = 빠짐 없음. +④ 서버 — SK 읽기 `층바탕.위` = 그 기초 문서(옵션 = 파생과 같음 → 고침 없는 SK 표시 0) · 고침 저장 = 따로 · + 다 되돌려 저장 = 파생(따로 없음) · 덮인 기계 칸이 있어도 기록에 덮음 없는 셈의 연결이 다 실림(「원래 값」). +""" + +import copy as cp +import importlib +import json +import os +import subprocess + +from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠 + +ml = importlib.import_module("master_doc_link") +mcv = importlib.import_module("master_doc_cover") +HERE = os.path.dirname(os.path.abspath(__file__)) +NO = "0201-0070" # 굴착기(무한궤도) 0.7㎥ — GF000099 기계 + + +def _node(ask): + proc = subprocess.run( + ["node", os.path.join(HERE, "helper_848_8_diff.cjs")], + input=json.dumps(ask, ensure_ascii=False), + capture_output=True, + text=True, + encoding="utf-8", + ) + assert proc.returncode == 0, proc.stderr[-2000:] + return json.loads(proc.stdout) + + +def _js(d): + return json.loads(json.dumps(ml._norm(d), ensure_ascii=False, default=str)) + + +def _sample(): + return _js(ml.load_all()["GC000994"]) # 인력 셋 · 기계 셋 · 옵션 · 표 값 + + +def test_전수_고침_없으면_표시_0(): + cases = [{"키": k, "문서": _js(d)} for k, d in ml.load_all().items()] + assert len(cases) >= 1500 + assert _node({"전수": cases}) == [] + + +def test_칸_줄_되돌림(): + d = _sample() + opt = d["변수"][0] + oid = "S_지반구분" + other = next(x for x in opt["연결"]["목록"] if x != opt["연결"]["값"]) + want = {"변수": True, "연결": {**opt["연결"], "값": other}, "이름": opt["이름"]} + steps = [ + {"꼴": "칸", "경로": f"v:{oid}", "값": want}, + {"꼴": "칸", "경로": "m:1:수량", "값": "9"}, + {"꼴": "줄뺌", "줄": 2}, + {"꼴": "되돌림", "경로": f"v:{oid}"}, + {"꼴": "되돌림", "경로": "m:1:수량"}, + {"꼴": "되살림", "항목": 0}, + {"꼴": "옮김", "항목": 0, "줄": 1, "곳": 4}, + ] + got = _node({"문서": d, "위": d, "고침": steps}) + assert got[0]["표시"][f"v:{oid}"][:3:2] == ["mine", True] + assert got[1]["표시"]["m:1:수량"] == ["mine", d["금액"][1]["수량"], True] + assert got[2]["빠짐"] == {"0": ["mine", [2]]} + assert f"v:{oid}" not in got[3]["표시"] + assert got[4]["표시"] == {} and got[4]["빠짐"] == {"0": ["mine", [2]]} + assert got[5] == {**got[5], "표시": {}, "줄틀": {}, "빠짐": {}} # 되살림 = 처음과 같음 + assert sorted(x["이름"] for x in got[5]["문서"]["금액"]) == sorted(x["이름"] for x in d["금액"]) + assert list(got[6]["줄틀"].values()) == ["mine"] # 차례 바뀐 줄 하나 + + +def test_층_위에서_바꾼_칸(): + top = _sample() + top["금액"][1]["수량"] = "Q_특별인부" + up = cp.deepcopy(top) + up["금액"][1]["수량"] = "Q_특별인부 × 1.1" + del up["금액"][4] # 공기압축기 줄 — 기초에서 뺌 + got = _node( + { + "문서": up, + "위": up, + "빌더": top, + "고침": [ + {"꼴": "칸", "경로": "m:1:수량", "값": "Q_특별인부 × 1.1"}, + {"꼴": "칸", "경로": "m:1:수량", "값": "5"}, + {"꼴": "되돌림", "경로": "m:1:수량"}, + {"꼴": "되살림", "항목": 2}, + ], + } + ) + assert got[0]["표시"] == {"m:1:수량": ["upper", "Q_특별인부", False]} + assert list(got[0]["빠짐"].values()) == [["upper", [4]]] + assert got[1]["표시"]["m:1:수량"] == ["mine", "Q_특별인부 × 1.1", True] + assert got[2]["표시"]["m:1:수량"][0] == "upper" + assert got[3]["빠짐"] == {} and list(got[3]["줄틀"].values()) == ["mine"] + + +def test_서버_바탕_지도_파생_복귀_덮음_기록(tmp_path, monkeypatch): + from M02_MasterTemplete import M02_Doc_Screen as screen + from M02_MasterTemplete import M02_Doc_Sk_Path as path + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_MasterTemplete_Store as store + from resources.tester.test_m02_labor_ref import world as make + + me = make.__wrapped__(tmp_path, monkeypatch)["personal"] + with store.at(me): + body = {"이름": "sub3임시 바탕", "단위": "㎥", "바탕": {"로직": "GF000099"}, "더한줄": []} + key = refs.create("sangeun", body)["이름"] + first = path.read(key) + assert set(first["층바탕"]) == {"위"} # 기초 손고침 없음 = 빌더 없음 + shown = _node({"문서": first["문서"], "위": first["층바탕"]["위"], "고침": []})[0] + assert shown == {"표시": {}, "줄틀": {}, "빠짐": {}} + + doc = cp.deepcopy(first["문서"]) + doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 2" + path.save(key, {"문서": doc, "판": first["판"]}) + mid = path.read(key) + assert store.read("sangeun", key)["문서"]["수식"].get("따로") + assert mid["셈"]["계"] != first["셈"]["계"] + path.save(key, {"문서": first["문서"], "판": mid["판"]}) + back = store.read("sangeun", key)["문서"]["수식"] + assert not back.get("따로") and "처음" not in back + assert path.read(key)["셈"]["계"] == first["셈"]["계"] + + doc = cp.deepcopy(first["문서"]) + doc[mcv.COVER] = {NO: {"값": {"가격": 900000}}} + now = path.read(key) + path.save(key, {"문서": doc, "판": now["판"]}) + copy = path.current(store.read("sangeun", key)["문서"]) + keys = lambda rec: {json.dumps(x["p"], sort_keys=True, default=str) for x in rec["요소"]} # noqa: E731 + covered = keys(screen.record(copy)) + bare = keys(screen.record({**copy, "문서": {k: v for k, v in copy["문서"].items() if k != mcv.COVER}})) # fmt: skip + assert bare <= covered and len(bare) > 0 # 덮인 칸의 정본 값까지 실림