feat(848-8): 바뀐 자리 표시 2 단계 — 서버 바탕 문서(층바탕) · 칸 단위 맞댐 테두리 · 칸 · 줄 되돌림 · 빠진 줄 되살림

- 읽기 답 `층바탕` = {위: 위 층 문서, 빌더?: 기초 손고침 때 빌더 문서} — M01 기초 = 빌더가 지을 문서 · M02 SK = 그 기초 지금 문서(옵션 값 = 파생과 같게 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(`처음`) · 파일 안 씀
- 화면 = 다 그린 뒤 한 번 훑어 칸마다 부품 `setUiDiff`(나 = 파랑 · 위 = 주황) — 옵션 가로 · 공식 값 · 식 글 · 표 값 · 단위 · 금액 줄 자원 · 이름 · 단가 식 · 수량 · 단위 · 비목 · 그룹 이름 · 글 줄 · 더한 줄 · 차례 바뀐 줄 = 줄 틀 · 빠진 줄 = 그룹 머리 [되살림 n]
- 칸 [↶] · 줄 [↶] · 되살림 = 캐시 → [저장] · 읽기 계정 = 테두리만
- 저장 — 따로 사본을 다 되돌려 위 층과 같으면 파생으로(고침 흔적 0 · 끊음 · 기계 고침 있으면 그대로 · 옛 끊음 안 실음)
- 덮인 기계 칸 「원래 값 —」(836-1 부터) = 연결 기록에 작업량만 얹은 셈을 한 번 더 — 덮음 없는 정본 값이 실림(M01 · M02)
- 시험 test_848_8_diff — 수식 문서 1,520 장 고침 없이 표시 0 · 칸 · 줄 · 층 · 서버 바탕 · 파생 복귀 · 덮음 기록

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 23:30:41 +09:00
co-authored by Claude Opus 5.5
parent 05fcb45776
commit 9875480b97
10 changed files with 815 additions and 8 deletions
+32
View File
@@ -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;
+175
View File
@@ -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<HTMLElement>(".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<HTMLElement>("[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<HTMLElement>(".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<HTMLElement>(".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<HTMLElement>(".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);
});
}
+9 -1
View File
@@ -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 = <T>(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()) {
+12
View File
@@ -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"],
+9 -2
View File
@@ -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:
+11 -1
View File
@@ -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 = ""
+63 -4
View File
@@ -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)
+298
View File
@@ -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<string, DiffMark>;
/** 지금 금액 줄 → 줄 틀(더한 줄 · 차례 바뀐 줄) */
lines: Map<number, DiffKind>;
/** 지금 항목 → 빠진 줄(`src` 문서 금액 차례) */
gone: Map<number, { diff: DiffKind; src: StackDoc; at: number[] }>;
/** 지금 금액 줄 → 위 층 금액 줄(-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<string, unknown> = {};
for (const k of Object.keys(x).sort()) {
const v = canon((x as Record<string, unknown>)[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<string, DocVar> =>
new Map((d.변수 ?? []).map((v) => [varId(v), v]));
const stepsOf = (d: FormulaDoc): Map<string, string> =>
new Map((d.식 ?? []).map((l) => [String(l.기호 ?? ""), String(l.식 ?? "")]));
/** 칸 경로 값(`v:` = {연결, 식, 이름} · 없는 기호 = undefined) */
function valueAt(vars: Map<string, DocVar>, steps: Map<string, string>, 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<string, unknown>)[f];
/** 금액 줄 짝 — 지금 차례 → 위 층 차례(-1 = 없음) */
export function matchLines(now: MoneyLine[], up: MoneyLine[]): number[] {
const pool = new Map<string, number[]>();
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<number> {
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<number>();
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<number, number> => {
const out = new Map<number, number>();
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<string, DiffMark>();
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<number, DiffKind>();
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<number, { diff: DiffKind; src: StackDoc; at: number[] }>();
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 = <T>(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<typeof valueAt>);
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<string, unknown>)[k];
else (l as Record<string, unknown>)[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<typeof valueAt>): 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 });
}
}
+67
View File
@@ -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));
}
+139
View File
@@ -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 # 덮인 칸의 정본 값까지 실림