layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/79-check-typography.js

@@ -0,0 +1,303 @@
+/*
+ * Auftrag A-7.6 (Sitzung 9) – check_typography: Verstoesse gegen allgemeine
+ * Satzregeln finden und melden, nie aendern. Die Regeln kommen als Daten
+ * (args.rule_rows, aus rules/typography-rules.json, vom Server nach Sprache
+ * und Kennungen ausgewaehlt): kind grep = InDesign-GREP-Suche (Mechanik
+ * von find_replace dry_run), kind lines = Pruefung auf den Zeilen eines
+ * Rahmens (idcFrameLineData aus 78-frame-lines.js).
+ */
+
+var IDC_SEVERITY_RANK = { info: 0, warning: 1, error: 2 };
+
+function idcRuleIdsOf(rows) {
+  var ids = [], i;
+  for (i = 0; i < rows.length; i++) {
+    if (!idcInList(ids, rows[i].id)) { ids.push(rows[i].id); }
+  }
+  return ids;
+}
+
+function idcInList(list, value) {
+  var i;
+  for (i = 0; i < list.length; i++) { if (list[i] === value) { return true; } }
+  return false;
+}
+
+/* Textrahmen des Pruefbereichs: Dokumentseiten (und auf Wunsch Musterseiten), ohne gesperrte Ebenen (auf Wunsch mit). */
+function idcFramesInScope(doc, scope, frame, story, includeMasters, includeLocked) {
+  var out = [], i, items, item, layer, locked;
+  if (scope === 'frame') { return [frame]; }
+  if (scope === 'story') {
+    try {
+      items = story.textContainers;
+      for (i = 0; i < items.length; i++) { out.push(IDC.concrete(items[i])); }
+    } catch (e0) { out = [frame]; }
+    return out;
+  }
+  try { items = doc.allPageItems; } catch (e1) { items = []; }
+  for (i = 0; i < items.length; i++) {
+    item = IDC.concrete(items[i]);
+    if (!IDC.isTextFrame(item)) { continue; }
+    if (!includeMasters && IDC.isOnParentSpread(item)) { continue; }
+    if (!includeLocked) {
+      locked = false;
+      try { layer = item.itemLayer; locked = layer !== null && layer !== undefined && layer.locked === true; } catch (e2) { locked = false; }
+      if (locked) { continue; }
+    }
+    out.push(item);
+  }
+  return out;
+}
+
+/* Fundstelle einer GREP-Suche als Finding. */
+function idcGrepFinding(doc, rule, match) {
+  var entry = idcDescribeMatch(doc, match);
+  var story = null, storyLength = null, from, to, snippet = entry.text, contextText;
+  var length = 0;
+  try { length = Number(match.characters.length); } catch (e0) { length = entry.text === null ? 0 : entry.text.length; }
+  try { story = match.parentStory; storyLength = Number(story.characters.length); } catch (e1) { story = null; }
+  if (story !== null && entry.index !== null && storyLength !== null) {
+    from = Math.max(0, entry.index - 15);
+    to = Math.min(storyLength - 1, entry.index + length + 14);
+    try {
+      contextText = String(story.characters.itemByRange(from, to).contents);
+      snippet = contextText.replace(/[\r\n]/g, '\u00b6');
+    } catch (e2) { snippet = entry.text; }
+  }
+  return {
+    rule_id: rule.id,
+    severity: rule.severity,
+    category: rule.category,
+    message: rule.message,
+    story_id: entry.story_id,
+    frame_id: entry.frame_id,
+    page_id: entry.page_id,
+    page_name: entry.page_name,
+    start_index: entry.index,
+    end_index: entry.index === null ? null : entry.index + length,
+    snippet: snippet,
+    suggestion: rule.suggestion
+  };
+}
+
+function idcMatchInTable(match) {
+  var parent = null, name;
+  try { parent = match.parent; } catch (e0) { return false; }
+  if (parent === null || parent === undefined) { return false; }
+  name = IDC.className(parent);
+  return name === 'Cell' || name === 'Table';
+}
+
+function idcRunGrepRule(doc, target, rule, args, findings, state) {
+  var found, i, options = app.findChangeGrepOptions;
+  try {
+    app.findGrepPreferences = NothingEnum.NOTHING;
+    app.changeGrepPreferences = NothingEnum.NOTHING;
+    idcSetFindOptions(options, { include_master_pages: args.include_master_pages === true, include_locked_layers: args.include_locked_layers === true });
+    app.findGrepPreferences.findWhat = rule.pattern;
+    found = target.findGrep();
+  } catch (e) {
+    state.failed.push({ rule_id: rule.id, error: String(e.message ? e.message : e), pattern: rule.pattern });
+    try { app.findGrepPreferences = NothingEnum.NOTHING; } catch (e1) { /* egal */ }
+    return;
+  }
+  try { app.findGrepPreferences = NothingEnum.NOTHING; } catch (e2) { /* egal */ }
+  for (i = 0; i < found.length; i++) {
+    if (idcMatchInTable(found[i])) { state.tables_skipped += 1; continue; }
+    idcPush(findings, state, idcGrepFinding(doc, rule, found[i]));
+  }
+}
+
+function idcLineFinding(rule, data, column, line, extraMessage) {
+  return {
+    rule_id: rule.id,
+    severity: rule.severity,
+    category: rule.category,
+    message: extraMessage ? rule.message + ' – ' + extraMessage : rule.message,
+    story_id: data.story_id,
+    frame_id: data.frame_id,
+    page_id: data.page_id,
+    page_name: data.page_name,
+    start_index: line === null ? null : line.start_index,
+    end_index: line === null ? null : line.end_index,
+    snippet: line === null ? null : (line.text === undefined ? null : line.text),
+    suggestion: rule.suggestion,
+    column_index: column === null ? null : column.column_index,
+    line_index: line === null ? null : line.index
+  };
+}
+
+/* Alle Regeln laufen immer; der Deckel max_findings greift erst bei der Ausgabe.
+   Gesammelt wird bis zur festen Obergrenze IDC_FINDINGS_CEILING, damit ein
+   grosses Dokument den Aufruf nicht sprengt (zaehlt weiter als dropped). */
+var IDC_FINDINGS_CEILING = 5000;
+
+function idcPush(findings, state, finding) {
+  if (findings.length >= IDC_FINDINGS_CEILING) { state.dropped += 1; return; }
+  findings.push(finding);
+}
+
+function idcRunLineRule(rule, data, args, findings, state) {
+  var c, column, lines, i, run, runStart, maxHyphens, minChars, first, last, text, prev;
+  maxHyphens = idcGiven(args.max_consecutive_hyphens) ? args.max_consecutive_hyphens : 3;
+  minChars = idcGiven(args.min_last_line_chars) ? args.min_last_line_chars : 0;
+
+  if (rule.check === 'column_first_baselines_differ') {
+    prev = null;
+    for (c = 0; c < data.columns.length; c++) {
+      column = data.columns[c];
+      if (column.line_count === 0 || column.first_baseline_mm === null) { continue; }
+      if (prev !== null && Math.abs(column.first_baseline_mm - prev.first_baseline_mm) > 0.1) {
+        idcPush(findings, state, idcLineFinding(rule, data, column, column.lines[0],
+          'column ' + prev.column_index + ' starts at ' + prev.first_baseline_mm + ' mm, column ' + column.column_index + ' at ' + column.first_baseline_mm + ' mm'));
+      }
+      prev = column;
+    }
+    return;
+  }
+
+  for (c = 0; c < data.columns.length; c++) {
+    column = data.columns[c];
+    lines = column.lines;
+    if (lines.length === 0) { continue; }
+    first = lines[0];
+    last = lines[lines.length - 1];
+    if (rule.check === 'widow') {
+      if (column.starts_with_last_line_of_paragraph) { idcPush(findings, state, idcLineFinding(rule, data, column, first, null)); }
+    } else if (rule.check === 'orphan') {
+      if (column.ends_with_first_line_of_paragraph) { idcPush(findings, state, idcLineFinding(rule, data, column, last, null)); }
+    } else if (rule.check === 'heading_at_column_end') {
+      if (last.is_first_line_of_paragraph && last.is_last_line_of_paragraph && !last.is_empty
+        && last.paragraph_index !== null && last.paragraph_index < data.paragraph_count - 1) {
+        idcPush(findings, state, idcLineFinding(rule, data, column, last, null));
+      }
+    } else if (rule.check === 'empty_line_at_column_start') {
+      if (column.starts_with_empty_line) { idcPush(findings, state, idcLineFinding(rule, data, column, first, null)); }
+    } else if (rule.check === 'single_word_last_line') {
+      for (i = 0; i < lines.length; i++) {
+        if (!lines[i].is_last_line_of_paragraph || lines[i].is_empty || lines[i].paragraph_line_count === null || lines[i].paragraph_line_count < 2) { continue; }
+        text = lines[i].text === undefined ? '' : lines[i].text;
+        if (lines[i].word_count === 1 || (minChars > 0 && text.length < minChars)) {
+          idcPush(findings, state, idcLineFinding(rule, data, column, lines[i], lines[i].word_count === 1 ? 'single word' : text.length + ' characters'));
+        }
+      }
+    } else if (rule.check === 'hyphen_ladder') {
+      run = 0;
+      runStart = 0;
+      for (i = 0; i <= lines.length; i++) {
+        if (i < lines.length && lines[i].ends_with_hyphen) {
+          if (run === 0) { runStart = i; }
+          run += 1;
+        } else {
+          if (run > maxHyphens) {
+            idcPush(findings, state, idcLineFinding(rule, data, column, lines[runStart], run + ' hyphenated lines in a row (lines ' + runStart + '–' + (i - 1) + ')'));
+          }
+          run = 0;
+        }
+      }
+    }
+  }
+}
+
+IDC.register('check_typography', { needs_document: true, read_only: true, ruler: 'spread' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var scope = idcGiven(args.scope) ? String(args.scope) : 'document';
+    var rows = IDC.isArray(args.rule_rows) ? args.rule_rows : [];
+    var unknown = IDC.isArray(args.unknown_rule_ids) ? args.unknown_rule_ids : [];
+    var maxFindings = idcGiven(args.max_findings) ? args.max_findings : 500;
+    var severityMin = idcGiven(args.severity_min) ? String(args.severity_min) : 'info';
+    var frame = null, story = null, frames, target, i, r, rule, findings = [], state, counts = {}, out, kept = [], data, framesChecked = 0;
+    var grepRules = [], lineRules = [];
+
+    if (scope !== 'document' && scope !== 'frame' && scope !== 'story') {
+      IDC.fail('invalid_argument', 'scope must be document, frame or story.', { scope: scope });
+    }
+    if (unknown.length > 0) {
+      IDC.fail('invalid_argument', 'Unknown rule id(s): ' + unknown.join(', ') + '.', { unknown: unknown, available: idcRuleIdsOf(rows) });
+    }
+    if (typeof maxFindings !== 'number' || maxFindings < 1 || maxFindings > 2000 || Math.floor(maxFindings) !== maxFindings) {
+      IDC.fail('invalid_argument', 'max_findings must be a whole number between 1 and 2000.', { max_findings: args.max_findings });
+    }
+    if (!IDC.hasOwn(IDC_SEVERITY_RANK, severityMin)) {
+      IDC.fail('invalid_argument', 'severity_min must be info, warning or error.', { severity_min: severityMin });
+    }
+    if (scope !== 'document') {
+      frame = idcTextFrameArg(doc, args, 'frame_id').item;
+      story = idcStoryOf(frame);
+    }
+    if (rows.length === 0) {
+      ctx.warn('No rule selected for locale ' + (idcGiven(args.locale) ? args.locale : 'de') + '; nothing was checked.');
+    }
+    for (r = 0; r < rows.length; r++) {
+      if (rows[r].kind === 'grep') { grepRules.push(rows[r]); }
+      else if (rows[r].kind === 'lines') { lineRules.push(rows[r]); }
+    }
+
+    state = { max: maxFindings, truncated: false, failed: [], tables_skipped: 0, dropped: 0 };
+
+    /* Zeichenregeln: eine GREP-Suche je Regel ueber das Ziel. */
+    if (grepRules.length > 0) {
+      if (scope === 'document') { target = doc; }
+      else if (scope === 'story') { target = story; }
+      else {
+        try { target = frame.texts.item(0); } catch (e0) { target = null; }
+        if (target === null || target === undefined) { target = story; }
+      }
+      for (r = 0; r < grepRules.length; r++) {
+        idcRunGrepRule(doc, target, grepRules[r], args, findings, state);
+      }
+    }
+
+    /* Umbruchregeln: je Rahmen die Zeilen lesen, dann jede Regel darauf. */
+    if (lineRules.length > 0) {
+      frames = idcFramesInScope(doc, scope, frame, story, args.include_master_pages === true, args.include_locked_layers === true);
+      for (i = 0; i < frames.length; i++) {
+        var frameStory;
+        try { frameStory = frames[i].parentStory; } catch (e1) { continue; }
+        if (frameStory === null || frameStory === undefined) { continue; }
+        data = idcFrameLineData(doc, frames[i], frameStory, true, 5000, null);
+        framesChecked += 1;
+        for (r = 0; r < lineRules.length; r++) {
+          idcRunLineRule(lineRules[r], data, args, findings, state);
+        }
+      }
+    }
+
+    /* Schwere filtern, zaehlen (counts zaehlt alles), dann erst den Deckel anlegen. */
+    for (i = 0; i < findings.length; i++) {
+      if (IDC_SEVERITY_RANK[findings[i].severity] < IDC_SEVERITY_RANK[severityMin]) { continue; }
+      counts[findings[i].rule_id] = (counts[findings[i].rule_id] || 0) + 1;
+      if (kept.length >= maxFindings) { state.dropped += 1; continue; }
+      kept.push(findings[i]);
+    }
+    if (state.dropped > 0) { state.truncated = true; }
+    for (r = 0; r < state.failed.length; r++) {
+      ctx.warn('Rule ' + state.failed[r].rule_id + ' could not run – InDesign rejected the GREP pattern: ' + state.failed[r].error);
+    }
+    if (state.tables_skipped > 0) {
+      ctx.warn('tables_skipped: ' + state.tables_skipped + ' match(es) inside tables were not reported (table cells are not checked in this version).');
+    }
+    if (state.truncated) {
+      ctx.warn('Output cut at max_findings ' + maxFindings + ': ' + state.dropped + ' further finding(s) not listed (truncated true). All rules were run; counts is complete.');
+    }
+
+    out = {
+      scope: scope,
+      locale: idcGiven(args.locale) ? String(args.locale) : 'de',
+      frame_id: frame === null ? null : Number(frame.id),
+      story_id: story === null ? null : Number(story.id),
+      findings: kept,
+      finding_count: kept.length,
+      findings_dropped: state.dropped,
+      counts: counts,
+      rules_checked: idcRuleIdsOf(rows),
+      rules_failed: state.failed,
+      frames_checked: framesChecked,
+      tables_skipped: state.tables_skipped,
+      severity_min: severityMin,
+      truncated: state.truncated
+    };
+    return out;
+  });