From 52d441e3a9d8f9971999a850a9aee10da6acec9e Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 28 Sep 2026 22:20:35 +0900 Subject: [PATCH] =?UTF-8?q?fix(spreadsheet):=20=EC=B9=B8=20=EB=8B=A4?= =?UTF-8?q?=EB=A3=A8=EA=B8=B0=20=EC=A0=84=EC=88=98=20=EC=A0=90=EA=B2=80=20?= =?UTF-8?q?=ED=9D=A0=2011=20=EA=B3=A0=EC=B9=A8=20=E2=80=94=20=EA=B3=A0?= =?UTF-8?q?=EB=A6=84=20=ED=85=8C=EB=91=90=EB=A6=AC=20=C2=B7=20=EC=B1=84?= =?UTF-8?q?=EC=9A=B0=EA=B8=B0=20=EC=86=90=EC=9E=A1=EC=9D=B4=20=C2=B7=20?= =?UTF-8?q?=ED=8B=80=EA=B3=A0=EC=A0=95=20=EB=B9=88=20=EB=9D=A0=20=C2=B7=20?= =?UTF-8?q?=EC=9E=85=EB=A0=A5=20=ED=98=95=EC=8B=9D=20=C2=B7=20=EC=9E=98?= =?UTF-8?q?=EB=9D=BC=20=EB=B6=99=EC=9D=B4=EA=B8=B0=20=EC=98=AE=EA=B9=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 격자: 고름을 옮겨도 옛 활성 칸 파란 테두리가 남던 것 · 채우기 손잡이가 범위 오른아래가 아니라 활성 칸 모서리에 있던 것(여러 범위 · 읽기 전용 카드에서는 손잡이 없음) · 틀 고정 뒤 본문 판 아래 · 오른 끝(틀 고정 크기만큼)이 안 그려져 비던 것(보이는 행열을 틀 고정만큼 밀어 잼) · 오류 칸 글자색을 테마 토큰으로(어두운 테마 대비 2.7 → 5.0) - 입력: `50%` → 0% 형식 · `1,234.5` → #,##0.0 형식을 함께 붙임(엑셀 · 되돌리기 한 번) · 식의 함수 · 참조 · 참거짓을 대문자로 · 닫는 괄호만 모자라면 채움 · 「식이 덜 끝남」 알림 글 - 클립보드: 잘라낸 칸을 같은 문서에 처음 붙이면 `옮기기` 로 — 그 칸을 가리키던 식도 따라감 (전에는 식이 0 · 빈 칸을 가리킴) · 그 사이 잘라낸 자리에 새로 쓰면 보통 붙여넣기 - 시험: test_spreadsheet_saved_values.py(면적 · 재료 저장본 102 권 서버 재계산 = 저장 계산값) · d_input 에 형식 · 대문자 · 괄호 규칙 · ORCA M02 면적산출 편집 창 목록 38 항목 재실행 통과 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BYN9gMie8e6pXzSxJNb6Xt --- .../spreadsheet/spreadsheet_clipboard.ts | 80 ++++++++++++++++--- A00_Common/spreadsheet/spreadsheet_editor.ts | 69 +++++++++++++++- A00_Common/spreadsheet/spreadsheet_grid.css | 2 +- A00_Common/spreadsheet/spreadsheet_grid.ts | 54 +++++++++---- A00_Common/spreadsheet/spreadsheet_parser.ts | 2 +- .../spreadsheet/helper_spreadsheet_d.cjs | 6 ++ .../spreadsheet/test_spreadsheet_d_input.py | 17 ++++ .../test_spreadsheet_saved_values.py | 50 ++++++++++++ 8 files changed, 249 insertions(+), 31 deletions(-) create mode 100644 resources/tester/spreadsheet/test_spreadsheet_saved_values.py diff --git a/A00_Common/spreadsheet/spreadsheet_clipboard.ts b/A00_Common/spreadsheet/spreadsheet_clipboard.ts index 93b3f1bc..46a6b556 100644 --- a/A00_Common/spreadsheet/spreadsheet_clipboard.ts +++ b/A00_Common/spreadsheet/spreadsheet_clipboard.ts @@ -3,10 +3,9 @@ * 복사 · 잘라내기 · 붙여넣기 — `copy` · `cut` · `paste` 사건만(허락 창 없음 · navigator.clipboard 안 씀). * 형 · 수식 살리기 규칙은 `spreadsheet_types.ts` `ClipBlock` 머리. 잘라내기 = 복사 + `내용지움`(누른 순간 * 바로 지움) · 붙여넣기 = `칸` 명령(식은 A `moveFormula` · 구글 R1C1 은 `r1c1ToA1`) + 서식 · 병합 명령 - * 묶음(칸 하나하나). ⚠ 잘라내기는 OS 클립보드를 거치는 비동기 사건(다른 창 · 다른 앱에 붙일 수 있음)이라 - * `옮기기` 명령(같은 문서 안에서 그 칸을 가리키던 다른 식도 따라감) 은 못 씀 — 잘라낸 칸을 가리키던 - * 다른 칸의 식은 안 따라옴(엑셀의 「점선 테두리 유지 · 붙일 때만 지움」 도 아님). 편집 중 - * (`ctx.editor.editing()`)이면 사건을 편집기에 맡김. + * 묶음(칸 하나하나). 잘라낸 것을 같은 문서에 처음 붙이면(클립보드 HTML 의 `aislo-cut` 표 · 그 사이 잘라낸 + * 자리에 새로 안 씀) 지운 칸을 되살려 `옮기기` 명령으로 — 그 칸을 가리키던 다른 식도 따라감(엑셀). + * 다른 앱 · 두 번째 붙여넣기는 보통 붙여넣기. 편집 중(`ctx.editor.editing()`)이면 사건을 편집기에 맡김. * * 이음(D `spreadsheet.ts` 잇는 자리) — `attachClipboard(ctx)` 한 번 부름(반환 `root` 없음 · 안 붙여도 됨). * `ctx.root` 의 copy/cut/paste 사건을 직접 받으므로 그 요소가 포커스를 받을 수 있어야 함 @@ -14,7 +13,7 @@ * ========================================================================== */ import { showToast } from "@ui/ui_template_elements"; -import { colName, parseRange, toA1 } from "./spreadsheet_address"; +import { colName, parseA1, parseRange, toA1 } from "./spreadsheet_address"; import { formatValue } from "./spreadsheet_numfmt"; import { moveFormula, r1c1ToA1 } from "./spreadsheet_refshift"; import { st } from "./spreadsheet_text"; @@ -514,23 +513,79 @@ function pasteBlock(ctx: SpreadsheetContext, block: ClipBlock, at: CellAddress): ctx.dispatch(commands.length === 1 ? commands[0] : { 종류: "묶음", 명령: commands }); } +/** A1 칸이 범위 안인가 */ +function inside(rg: CellRange, a1: string): boolean { + const p = parseA1(a1); + return !!p && p.r >= rg.r0 && p.r <= rg.r1 && p.c >= rg.c0 && p.c <= rg.c1; +} + +interface PendingCut { + token: string; + sheet: string; + range: CellRange; + /** 지우기 전 칸 — 같은 문서에 붙일 때 되살려 `옮기기` 로 넘김 */ + cells: Record; +} + +/** 병합을 가르는지(통째로 든 병합은 됨) — `옮기기` 명령과 같은 규칙 */ +function cutsMerge(sheet: Sheet, rg: CellRange): boolean { + return (sheet.병합 ?? []) + .map((m) => parseRange(m)) + .some((m) => !!m && rangesOverlap(m, rg) && !rangeContains(rg, m)); +} + /** `ctx.root` 의 copy · cut · paste 를 받음(root null) */ export function attachClipboard(ctx: SpreadsheetContext): PartHandle { - function onCopy(ev: ClipboardEvent): void { - if (ctx.editor.editing()) return; + /** 마지막 잘라내기 — 같은 문서에 붙이면 칸을 옮김(그 칸을 가리키던 식도 따라감 · 엑셀) */ + let cut: PendingCut | null = null; + + function write(ev: ClipboardEvent, prefix = ""): void { const range = activeRange(ctx); const { html, text } = blockToClipboard(ctx.book, ctx.selection.시트, range, (r, c) => ctx.engine.value(ctx.selection.시트, r, c), ); - ev.clipboardData?.setData("text/html", html); + ev.clipboardData?.setData("text/html", prefix + html); ev.clipboardData?.setData("text/plain", text); ev.preventDefault(); } + function onCopy(ev: ClipboardEvent): void { + if (ctx.editor.editing()) return; + cut = null; + write(ev); + } + function onCut(ev: ClipboardEvent): void { if (ctx.editor.editing() || ctx.readOnly) return; - onCopy(ev); - ctx.dispatch({ 종류: "내용지움", 시트: ctx.selection.시트, 범위: [activeRange(ctx)] }); + const range = activeRange(ctx); + const sheet = ctx.sheet(); + const cells: Record = {}; + for (const [a1, cell] of Object.entries(sheet.칸)) + if (inside(range, a1)) cells[a1] = structuredClone(cell); + const token = Math.random().toString(36).slice(2); + write(ev, ``); + cut = { token, sheet: sheet.id, range, cells }; + ctx.dispatch({ 종류: "내용지움", 시트: sheet.id, 범위: [range] }); + } + + /** 잘라낸 칸을 같은 문서 안으로 — 되살린 뒤 `옮기기`(한 번에 되돌림) · 못 하면 false(보통 붙여넣기) */ + function pasteCut(pending: PendingCut, at: CellAddress): boolean { + const src = ctx.book.시트.find((s) => s.id === pending.sheet); + if (!src) return false; + const { r0, c0, r1, c1 } = pending.range; + for (const [a1, cell] of Object.entries(src.칸)) + if (inside(pending.range, a1) && (cell.값 !== undefined || cell.식 !== undefined)) + return false; // 잘라낸 뒤 그 자리에 새로 씀 + const dst = { r0: at.r, c0: at.c, r1: at.r + r1 - r0, c1: at.c + c1 - c0 }; + if (cutsMerge(src, pending.range) || cutsMerge(ctx.sheet(), dst)) return false; + ctx.dispatch({ + 종류: "묶음", + 명령: [ + { 종류: "칸", 시트: src.id, 칸: pending.cells }, + { 종류: "옮기기", 시트: src.id, 범위: pending.range, 대상시트: ctx.selection.시트, ...at }, + ], + }); + return true; } function onPaste(ev: ClipboardEvent): void { @@ -538,6 +593,11 @@ export function attachClipboard(ctx: SpreadsheetContext): PartHandle { const html = ev.clipboardData?.getData("text/html") ?? ""; const text = ev.clipboardData?.getData("text/plain") ?? ""; const at = ctx.selection.활성; + const pending = cut; + if (pending && html.includes(``)) { + cut = null; // 엑셀처럼 한 번만 옮김 — 다음부터는 보통 붙여넣기 + if (pasteCut(pending, at)) return void ev.preventDefault(); + } const block = parseClipboard(html, text, at); if (!block) { showToast(st("ClipboardPasteFailed"), "error"); diff --git a/A00_Common/spreadsheet/spreadsheet_editor.ts b/A00_Common/spreadsheet/spreadsheet_editor.ts index 86d1a14e..8cf4f81a 100644 --- a/A00_Common/spreadsheet/spreadsheet_editor.ts +++ b/A00_Common/spreadsheet/spreadsheet_editor.ts @@ -15,7 +15,8 @@ import type { FuncHelp } from "./spreadsheet_func_help"; import { parseFormula, tokenize } from "./spreadsheet_parser"; import { cellsOf, move, selectCell } from "./spreadsheet_selection"; import { checkValue, findValidation } from "./spreadsheet_validation"; -import type { Cell, CellAddress, CellStyle, Sheet } from "./spreadsheet_types"; +import { cellStyleAt } from "./spreadsheet_cellstyle"; +import type { Cell, CellAddress, CellStyle, Command, Sheet } from "./spreadsheet_types"; import type { CellBox, EditorHandle, @@ -89,6 +90,39 @@ export function textToCell(text: string, old?: Cell): Cell | null { return { ...base, 값: text }; } +/** 친 모양대로 숫자 형식(엑셀) — `50%` → `0%` · `12.5%` → `0.0%` · `1,234.5` → `#,##0.0` · 아니면 null */ +export function typedFormat(text: string): string | null { + const t = text.trim(); + if (parseNumber(t) === null || /e/i.test(t)) return null; + const dec = /\.(\d+)/.exec(t)?.[1].length ?? 0; + const frac = dec ? "." + "0".repeat(dec) : ""; + if (t.endsWith("%")) return `0${frac}%`; + if (t.includes(",")) return `#,##0${frac}`; + return null; +} + +/** 식 글(앞 `=` 뺌) — 함수 · 참조 · 참거짓을 대문자로(엑셀) · 시트 이름 · 글 · 정의된 이름은 그대로 */ +export function upperFormula(body: string): string { + return tokenize(body) + .map((t) => { + if (t.kind === "func" || t.kind === "bool") return t.text.toUpperCase(); + if (t.kind !== "ref") return t.text; + const bang = t.text.lastIndexOf("!") + 1; + return t.text.slice(0, bang) + t.text.slice(bang).toUpperCase(); + }) + .join(""); +} + +/** 닫는 괄호만 모자란 식이면 채운 식(엑셀 자동 고침) · 아니면 null */ +export function closeParens(value: string): string | null { + let depth = 0; + for (const t of tokenize(value.slice(1))) + if (t.kind === "paren") depth += t.text === "(" ? 1 : -1; + if (depth <= 0) return null; + const fixed = value + ")".repeat(depth); + return parseFormula(fixed).ok ? fixed : null; +} + /** 칸 → 편집 글(식은 `=` 붙임 · 수처럼 읽힐 글은 `'` 붙임) */ export function cellToText(cell: Cell | undefined): string { if (!cell) return ""; @@ -360,7 +394,10 @@ export function createEditor(ctx: SpreadsheetContext): Editor { /** 칸에 적음 — 식이 틀렸거나(인자 수 등) 유효성(sub4) 「막음」 을 어기면 안 적고 false(편집 그대로 · 엑셀처럼 다시 치게) */ function write(cells: CellAddress[], value: string, from: CellAddress): boolean { if (!st) return true; - const parsed = value.length > 1 && value[0] === "=" ? parseFormula(value) : null; + const isFormula = value.length > 1 && value[0] === "="; + if (isFormula && !parseFormula(value).ok) value = closeParens(value) ?? value; + const parsed = isFormula ? parseFormula(value) : null; + if (parsed?.ok) value = "=" + upperFormula(value.slice(1)); if (parsed && !parsed.ok) { showToast(parsed.message, "error"); const node = src(); @@ -389,7 +426,33 @@ export function createEditor(ctx: SpreadsheetContext): Editor { out[key] = next; } for (const m of warn) showToast(m, "warning"); - if (Object.keys(out).length) ctx.dispatch({ 종류: "칸", 시트: sheet.id, 칸: out }); + if (!Object.keys(out).length) return true; + const cellCmd: Command = { 종류: "칸", 시트: sheet.id, 칸: out }; + const fmt = isFormula ? null : typedFormat(value); + // `%` 는 글 형식(`@`) · 이미 % 형식만 빼고 바꿈 · 천 단위 쉼표는 일반 형식일 때만(엑셀) + const takes = (code?: string): boolean => + !code || + /^(general|g\/표준)$/i.test(code) || + (fmt!.endsWith("%") && !code.includes("%") && code.trim() !== "@"); + const fmtAt = fmt + ? cells.filter((a) => takes(cellStyleAt(ctx.book, sheet, a.r, a.c).형식)) + : []; + ctx.dispatch( + fmtAt.length + ? { + 종류: "묶음", + 명령: [ + cellCmd, + { + 종류: "서식", + 시트: sheet.id, + 범위: fmtAt.map((a) => ({ r0: a.r, c0: a.c, r1: a.r, c1: a.c })), + 바꿀: { 형식: fmt! }, + }, + ], + } + : cellCmd, + ); return true; } diff --git a/A00_Common/spreadsheet/spreadsheet_grid.css b/A00_Common/spreadsheet/spreadsheet_grid.css index 9dd2d789..3dca48a5 100644 --- a/A00_Common/spreadsheet/spreadsheet_grid.css +++ b/A00_Common/spreadsheet/spreadsheet_grid.css @@ -185,7 +185,7 @@ } .aislo-cell.is-error { - color: #c00; + color: var(--color-danger, #c00); } /* 오류 칸 — 엑셀 오류 검사 초록 세모(왼 위 · sub3 오류 까닭은 title 풍선). */ diff --git a/A00_Common/spreadsheet/spreadsheet_grid.ts b/A00_Common/spreadsheet/spreadsheet_grid.ts index 99811a22..22c28a0c 100644 --- a/A00_Common/spreadsheet/spreadsheet_grid.ts +++ b/A00_Common/spreadsheet/spreadsheet_grid.ts @@ -652,16 +652,19 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle { const scrollW = Math.max(0, w - headColW() - frozenW); const scrollH = Math.max(0, h - headRowH() - frozenH); const frozenColsVisible = visibleIndices(colGeo, 0, frozenCols - 1); - const scrollColFrom = Math.max(frozenCols, colGeo.indexAt(paneBR.scrollLeft)); - const scrollColTo = Math.min(extent.cols - 1, colGeo.indexAt(paneBR.scrollLeft + scrollW) + 1); + // 본문 판 스크롤 0 = 틀고정 바로 다음 칸(`offset(frozen)`) — 그만큼 더해 재야 오른 · 아래 끝이 안 빔. + const left = paneBR.scrollLeft + frozenW; + const top = paneBR.scrollTop + frozenH; + const scrollColFrom = Math.max(frozenCols, colGeo.indexAt(left)); + const scrollColTo = Math.min(extent.cols - 1, colGeo.indexAt(left + scrollW) + 1); const scrollColsVisible = visibleIndices( colGeo, scrollColFrom, Math.max(scrollColFrom, scrollColTo), ); const frozenRowsVisible = visibleIndices(rowGeo, 0, frozenRows - 1); - const scrollRowFrom = Math.max(frozenRows, rowGeo.indexAt(paneBR.scrollTop)); - const scrollRowTo = Math.min(extent.rows - 1, rowGeo.indexAt(paneBR.scrollTop + scrollH) + 1); + const scrollRowFrom = Math.max(frozenRows, rowGeo.indexAt(top)); + const scrollRowTo = Math.min(extent.rows - 1, rowGeo.indexAt(top + scrollH) + 1); const scrollRowsVisible = visibleIndices( rowGeo, scrollRowFrom, @@ -821,14 +824,32 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle { node.style.borderWidth = i === 0 ? "2px" : "1px"; selLayer!.append(node); } - const active = overlayBoxOf(sel.활성.r, sel.활성.c); + // 활성 칸 테두리 — 칸 다시 그리기(`renderRowOfCells`) 없이 고름만 바뀌어도 옛 칸에 남지 않게. + const activeKey = `${sel.활성.r},${sel.활성.c}`; + const anchor = merges.get(activeKey); + const activeAddr = toA1(anchor?.r0 ?? sel.활성.r, anchor?.c0 ?? sel.활성.c); + for (const el of root.querySelectorAll(".aislo-cell.is-selected")) + if (el.dataset.addr !== activeAddr) el.classList.remove("is-selected"); + for (const el of root.querySelectorAll(`.aislo-cell[data-addr="${activeAddr}"]`)) + el.classList.add("is-selected"); + const handleAt = fillHandleCell(); + if (!handleAt) return; + const corner = overlayBoxOf(handleAt.r, handleAt.c); const handle = document.createElement("div"); handle.className = "aislo-grid__fill-handle"; - handle.style.left = `${active.x + active.w - 4}px`; - handle.style.top = `${active.y + active.h - 4}px`; + handle.style.left = `${corner.x + corner.w - 4}px`; + handle.style.top = `${corner.y + corner.h - 4}px`; selLayer!.append(handle); } + /** 채우기 손잡이 자리 — 고른 범위 오른아래 칸(엑셀) · 범위가 여럿이거나 읽기 전용이면 없음. */ + function fillHandleCell(): { r: number; c: number } | null { + const sel = ctx.selection; + if (ctx.readOnly || !sel || sel.범위.length !== 1) return null; + const g = sel.범위[0]; + return { r: g.r1, c: g.c1 }; + } + function setRefHighlights(list: RefHighlight[]): void { let refLayer = overlay.querySelector(".aislo-grid__ref-layer"); if (!refLayer) { @@ -883,12 +904,11 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle { const c = colGeo.indexAt(contentX); const r = rowGeo.indexAt(contentY); const sel = ctx.selection; - if (sel && sel.시트 === ctx.sheet().id) { - const active = boxOf(sel.활성.r, sel.활성.c); - const screen = screenBoxOf(sel.활성.r, sel.활성.c); - void active; + const handleAt = sel && sel.시트 === ctx.sheet().id ? fillHandleCell() : null; + if (handleAt) { + const screen = screenBoxOf(handleAt.r, handleAt.c); if (Math.abs(x - (screen.x + screen.w)) <= 5 && Math.abs(y - (screen.y + screen.h)) <= 5) { - return { kind: "fillHandle", r: sel.활성.r, c: sel.활성.c }; + return { kind: "fillHandle", r: handleAt.r, c: handleAt.c }; } } return { kind: "cell", r, c }; @@ -917,11 +937,13 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle { function visibleRange(): CellRange { const scrollW = Math.max(0, root.clientWidth - headColW() - frozenW); const scrollH = Math.max(0, root.clientHeight - headRowH() - frozenH); + const left = paneBR.scrollLeft + frozenW; + const top = paneBR.scrollTop + frozenH; return { - r0: rowGeo.indexAt(paneBR.scrollTop), - c0: colGeo.indexAt(paneBR.scrollLeft), - r1: Math.min(extent.rows - 1, rowGeo.indexAt(paneBR.scrollTop + scrollH)), - c1: Math.min(extent.cols - 1, colGeo.indexAt(paneBR.scrollLeft + scrollW)), + r0: rowGeo.indexAt(top), + c0: colGeo.indexAt(left), + r1: Math.min(extent.rows - 1, rowGeo.indexAt(top + scrollH)), + c1: Math.min(extent.cols - 1, colGeo.indexAt(left + scrollW)), }; } diff --git a/A00_Common/spreadsheet/spreadsheet_parser.ts b/A00_Common/spreadsheet/spreadsheet_parser.ts index c673d333..0f87aa8d 100644 --- a/A00_Common/spreadsheet/spreadsheet_parser.ts +++ b/A00_Common/spreadsheet/spreadsheet_parser.ts @@ -184,7 +184,7 @@ export function parseFormula(formula: string): ParseResult { }; const primary = (): FormulaNode => { const t = peek(); - if (!t) throw new Fail("식이 끝남", text.length); + if (!t) throw new Fail("식이 덜 끝남", text.length); p++; switch (t.kind) { case "number": diff --git a/resources/tester/spreadsheet/helper_spreadsheet_d.cjs b/resources/tester/spreadsheet/helper_spreadsheet_d.cjs index 527b4e66..505a7af1 100644 --- a/resources/tester/spreadsheet/helper_spreadsheet_d.cjs +++ b/resources/tester/spreadsheet/helper_spreadsheet_d.cjs @@ -69,6 +69,12 @@ const out = { (t) => ed.textToCell(t, { 서식: 4 }), ), textToCellNoStyle: ed.textToCell("", {}), + // 친 모양대로 숫자 형식 · 식 대문자 · 닫는 괄호 채움(엑셀) + typedFormat: ["50%", "12.5%", "1,234.5", "1,000", "7", "abc", "1e3%"].map(ed.typedFormat), + upperFormula: ["sum(a1:b2)+round(c3,0)", "'시트 a'!a1*true", '"abc"&a1', "내이름*2"].map( + ed.upperFormula, + ), + closeParens: ["=(1+2", "=SUM(1,ROUND(2,0", "=1+", "=(1+2)", '=")"&(1'].map(ed.closeParens), cellToText: [ { 값: "=12" }, { 값: "12" }, diff --git a/resources/tester/spreadsheet/test_spreadsheet_d_input.py b/resources/tester/spreadsheet/test_spreadsheet_d_input.py index ad128f05..74c1c7db 100644 --- a/resources/tester/spreadsheet/test_spreadsheet_d_input.py +++ b/resources/tester/spreadsheet/test_spreadsheet_d_input.py @@ -111,3 +111,20 @@ def test_abs_cycle_and_fold(r): def test_links_follow_rows_cols(r): # 행 넣기 → 밀림 · 연결 칸 열 지움 → 빠짐 · 되돌리기 → 제자리 assert r["links"] == ["L:B7,W:D5", "L:B7", "L:B7,W:D5", "L:B5,W:D3", "D1"] + + +def test_typed_format(r): + assert r["typedFormat"] == ["0%", "0.0%", "#,##0.0", "#,##0", None, None, None] + + +def test_upper_formula(r): + assert r["upperFormula"] == [ + "SUM(A1:B2)+ROUND(C3,0)", + "'시트 a'!A1*TRUE", + '"abc"&A1', + "내이름*2", + ] + + +def test_close_parens(r): + assert r["closeParens"] == ["=(1+2)", "=SUM(1,ROUND(2,0))", None, None, '=")"&(1)'] diff --git a/resources/tester/spreadsheet/test_spreadsheet_saved_values.py b/resources/tester/spreadsheet/test_spreadsheet_saved_values.py new file mode 100644 index 00000000..0b0cc9f8 --- /dev/null +++ b/resources/tester/spreadsheet/test_spreadsheet_saved_values.py @@ -0,0 +1,50 @@ +"""저장 뒤 식 · 값 유지 — M02 면적산출 · 재료산출 저장본을 서버 엔진으로 다시 풀면 저장된 `계산값` 과 같음. + +읽기만 함(저장본을 고치지 않음). 저장 때 서버가 적은 값과 지금 엔진 풀이가 어긋나면 화면을 다시 열 때 +값이 달라 보임. +""" + +import json +import shutil +from pathlib import Path + +import pytest + +from common_util import common_util_spreadsheet as spreadsheet + +ROOT = Path(__file__).resolve().parents[3] +FOLDER = ROOT / "resources" / "master_template" + +pytestmark = pytest.mark.skipif(shutil.which("node") is None, reason="node 가 없음") + + +def _books() -> list[tuple[str, dict]]: + out = [] + for kind in ("area", "material"): + for path in sorted((FOLDER / kind).glob("[!.]*.json")): + book = json.loads(path.read_text(encoding="utf-8")) + if isinstance(book, dict) and book.get("시트"): + out.append((f"{kind}/{path.stem}", book)) + return out + + +def test_저장본_서버_재계산_같음(): + books = _books() + assert any("계산값" in b for _, b in books), "계산값 있는 저장본이 없음" + fresh = spreadsheet.recalc_workbooks([b for _, b in books]) + diffs = [] + for (name, book), values in zip(books, fresh): + if "계산값" not in book: + continue # 옛 저장본 — 풀리기만 하면 됨 + saved = book["계산값"] + for sheet, cells in values.items(): + for addr, v in cells.items(): + if saved.get(sheet, {}).get(addr) != v: + diffs.append( + f"{name} {sheet}!{addr}: 저장 {saved.get(sheet, {}).get(addr)} · 지금 {v}" + ) + for sheet, cells in saved.items(): + for addr in cells: + if addr not in values.get(sheet, {}): + diffs.append(f"{name} {sheet}!{addr}: 저장에만 있음") + assert not diffs, "\n".join(diffs[:30])