Files
MDHelper/mdhelper/style_catalog.py
T

176 lines
8.4 KiB
Python

"""Semantic style identities, inheritance and Markdown usage, independent of widgets."""
from __future__ import annotations
from dataclasses import dataclass
from copy import deepcopy
from .table_style import TABLE_ONLY_FIELDS
@dataclass(frozen=True)
class StyleDefinition:
key: str
name: str
kind: str
syntax: str
base: str = ''
DEFINITIONS = (
StyleDefinition('paragraph', '正文', 'paragraph', '普通段落'),
*(StyleDefinition(f'h{i}', f'标题 {i}', 'paragraph', '#' * i + ' 标题') for i in range(1, 7)),
StyleDefinition('list', '列表基准', 'paragraph', '所有列表项'),
StyleDefinition('blockquote', '引用', 'paragraph', '> 引用'),
StyleDefinition('code', '代码基准', 'paragraph', '兼容原代码设置'),
StyleDefinition('table', '表格基准', 'table', 'Markdown 表格'),
StyleDefinition('list_bullet', '无序列表', 'paragraph', '- 列表', 'list'),
StyleDefinition('list_ordered', '有序列表', 'paragraph', '1. 列表', 'list'),
StyleDefinition('list_task', '任务列表', 'paragraph', '- [ ] 任务', 'list'),
StyleDefinition('code_block', '代码块', 'paragraph', '围栏代码 / 缩进代码', 'code'),
StyleDefinition('table_head', '表头文字', 'paragraph', '表格表头'),
StyleDefinition('table_cell', '单元格文字', 'paragraph', '表格单元格'),
StyleDefinition('strong', '加粗', 'character', '**文字**'),
StyleDefinition('emphasis', '强调', 'character', '*文字*'),
StyleDefinition('strike', '删除线', 'character', '~~文字~~'),
StyleDefinition('link', '超链接', 'character', '[文字](地址)'),
StyleDefinition('inline_code', '行内代码', 'character', '`代码`'),
)
CATALOG = {item.key: item for item in DEFINITIONS}
KINDS = {'paragraph': '段落', 'character': '字符', 'table': '表格'}
CHARACTER_FIELDS = {'chinese_font_family', 'english_font_family', 'font_size', 'font_size_unit',
'bold', 'italic', 'font_color', 'letter_spacing', 'underline', 'strike', 'background_color'}
CHARACTER_DEFAULTS = {'strong': {'bold': True}, 'emphasis': {'italic': True}, 'strike': {'strike': True},
'link': {'font_color': '#0563c1', 'underline': True},
'inline_code': {'english_font_family': 'Consolas'}}
def normalize_metadata(value):
result = {}
if not isinstance(value, dict): return result
for key, item in value.items():
if key not in CATALOG or not isinstance(item, dict): continue
clean = {}
if isinstance(item.get('name'), str) and item['name'].strip(): clean['name'] = item['name'].strip()[:80]
base = item.get('based_on')
if base == '' or isinstance(base, str) and base in CATALOG and CATALOG[base].kind == CATALOG[key].kind and base != key:
clean['based_on'] = base
if clean: result[key] = clean
# Imported cycles are repaired without throwing away independent formatting.
for key in list(result):
seen, current = set(), key
while current:
if current in seen:
result[key]['based_on'] = ''
break
seen.add(current)
current = result.get(current, {}).get('based_on', CATALOG[current].base)
return result
def style_name(key, rules=None):
return normalize_metadata((rules or {}).get('_metadata')).get(key, {}).get('name', CATALOG[key].name)
def parent_style(key, rules):
return normalize_metadata(rules.get('_metadata')).get(key, {}).get('based_on', CATALOG[key].base)
def legacy_base(key, rules):
"""Absent metadata keeps old cross-type bases; explicit detachment does not."""
metadata = normalize_metadata(rules.get('_metadata')).get(key, {})
if 'based_on' in metadata: return ''
return {'inline_code': 'code', 'table_head': 'table', 'table_cell': 'table'}.get(key, '')
def explicit_rules(rules):
"""Resolve authored declarations only; absent character fields inherit their paragraph."""
rules = rules if isinstance(rules, dict) else {}
metadata = normalize_metadata(rules.get('_metadata'))
result = {}
def resolve(key):
if key in result: return result[key]
base = metadata.get(key, {}).get('based_on', CATALOG[key].base)
own = rules.get(key, {})
own = own if isinstance(own, dict) else {}
inherited = dict(resolve(base)) if base else {}
if base and CATALOG[key].kind == 'character':
inherited = {**CHARACTER_DEFAULTS.get(base, {}), **inherited}
if key in ('table_head', 'table_cell') and not base and legacy_base(key, rules):
legacy = rules.get('table') if isinstance(rules.get('table'), dict) else {}
inherited.update({k: v for k, v in legacy.items() if k not in TABLE_ONLY_FIELDS})
if key == 'inline_code' and not base and legacy_base(key, rules):
legacy = resolve('code')
inherited.update({k: v for k, v in legacy.items() if k in CHARACTER_FIELDS})
inherited.update(own)
if CATALOG[key].kind == 'character': inherited = {k: v for k, v in inherited.items() if k in CHARACTER_FIELDS}
result[key] = inherited
return inherited
for key in CATALOG: resolve(key)
return result
def character_declarations(rules, effective):
"""Include a deliberately selected code ancestor, without imposing legacy defaults.
Old code settings only override authored fields. Selecting a paragraph base
for code also selects that base's defaults, as it does for code blocks.
"""
explicit = explicit_rules(rules)
result = {}
def resolve(key):
if key in result: return result[key]
base = parent_style(key, rules)
inherited = {**CHARACTER_DEFAULTS.get(base, {}), **resolve(base)} if base else dict(explicit[key])
if key == 'inline_code' and legacy_base(key, rules) and parent_style('code', rules):
inherited.update({k: v for k, v in effective['code'].items() if k in CHARACTER_FIELDS})
own = rules.get(key, {})
result[key] = {**inherited, **{k: v for k, v in own.items() if k in CHARACTER_FIELDS}} if isinstance(own, dict) else inherited
return result[key]
for key, definition in CATALOG.items():
if definition.kind == 'character': resolve(key)
return result
@dataclass(frozen=True)
class StyleRegion:
start: int
end: int
style: str
characters: tuple[str, ...] = ()
def token_regions(tokens):
regions, used, stack = [], set(), []
inline_styles = {'strong_open': 'strong', 'em_open': 'emphasis', 's_open': 'strike',
'link_open': 'link', 'code_inline': 'inline_code'}
for index, token in enumerate(tokens):
if token.nesting == -1:
if stack: stack.pop()
continue
contexts = [kind for kind, _ in stack]
if token.type == 'blockquote_open': used.add('blockquote')
target = None
if token.type == 'heading_open': target = token.tag
elif token.type in ('fence', 'code_block'): target = 'code_block'
elif token.type == 'table_open': target = 'table'
elif token.type in ('th_open', 'td_open'): target = 'table_head' if token.type == 'th_open' else 'table_cell'
elif token.type == 'list_item_open':
target = 'list_task' if 'task-list-item' in (token.attrGet('class') or '') else next(
('list_ordered' if kind == 'ordered_list_open' else 'list_bullet' for kind, _ in reversed(stack)
if kind in ('ordered_list_open', 'bullet_list_open')), 'list_bullet')
elif token.type == 'paragraph_open':
target = next((style for _, style in reversed(stack) if style in ('list_bullet', 'list_ordered', 'list_task', 'table_head', 'table_cell')), None)
target = target or ('blockquote' if 'blockquote_open' in contexts else 'paragraph')
if token.nesting == 1: stack.append((token.type, target))
if target:
used.add(target)
children = tokens[index + 1].children if index + 1 < len(tokens) and tokens[index + 1].type == 'inline' else []
characters = tuple(dict.fromkeys(inline_styles[c.type] for c in children or [] if c.type in inline_styles))
used.update(characters)
if token.map: regions.append(StyleRegion(token.map[0], token.map[1], target, characters))
return regions, used
def document_styles(source):
from .markdown_renderer import MarkdownRenderer
from pathlib import Path
return token_regions(MarkdownRenderer(Path.cwd()).markdown.parse(source, {}))