310 lines
20 KiB
Python
310 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""Repository-owned icon review tool (Python 3.11+, standard library only).
|
|
|
|
--serve [PORT] Loopback review app, default http://127.0.0.1:8770/
|
|
--summary Discovery counts, no generated source files
|
|
--csv Write target/icon-inventory.csv
|
|
--notes Open artwork feedback
|
|
--resolve ID... Clear feedback after an intentional redraw; protect newer notes manually
|
|
--out FILE Self-contained static review page (default target/icon-status.html)
|
|
|
|
Read assets/icons/ui/STYLE_GUIDE.md before editing artwork. SVGs are authoritative.
|
|
Every discovered non-final icon is Open; no inventory file controls discovery.
|
|
"""
|
|
import sys, os, re, glob, html, json, hashlib, collections, tomllib, uuid, datetime
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
D = os.path.dirname(HERE) # .../assets/icons/ui/design
|
|
ROOT = os.path.abspath(os.path.join(D, '..', '..', '..', '..'))
|
|
REVIEW = D + '/review.json'
|
|
REQUESTS = os.path.join(ROOT, 'target', 'codex-icon-review', 'inbox')
|
|
args = sys.argv[1:]
|
|
SERVER_REV = uuid.uuid4().hex if '--serve' in args else ''
|
|
out_path = args[args.index('--out') + 1] if '--out' in args else os.path.join(ROOT, 'target', 'icon-status.html')
|
|
|
|
sys.path.insert(0, HERE)
|
|
import review_state
|
|
import icon_palette
|
|
load_review = review_state.load
|
|
master_hash = review_state.master_hash
|
|
|
|
def art_rev():
|
|
h = hashlib.sha256()
|
|
h.update(SERVER_REV.encode()) # A backend restart must refresh already-open review tabs too.
|
|
paths = glob.glob(D + '/svg/*/*.svg') + glob.glob(HERE + '/review/*')
|
|
paths += glob.glob(ROOT + '/crates/engine/src/**/*.rs', recursive=True)
|
|
paths += glob.glob(ROOT + '/crates/ui-egui/src/**/*.rs', recursive=True)
|
|
paths += glob.glob(HERE + '/*.py')
|
|
paths += [D + '/palette.toml', D + '/aliases.toml', __file__]
|
|
for path in sorted(paths):
|
|
st = os.stat(path)
|
|
h.update(('%s %d %d;' % (os.path.relpath(path, ROOT), st.st_mtime_ns, st.st_size)).encode())
|
|
return h.hexdigest()[:16]
|
|
|
|
|
|
def ui_icon_names(source):
|
|
"""Literal icon arguments, including the pattern and line-type UI wrappers."""
|
|
names = set()
|
|
for call in re.finditer(r'icons::paint[a-z_]*\((.*?);', source, re.S):
|
|
names.update(re.findall(r'"([a-z][a-z0-9_]*)"', call.group(1)))
|
|
for call in re.finditer(r'\bpattern_toggle\([^;]*?\);', source, re.S):
|
|
# The icon is the fourth argument; the first strings are accessible labels.
|
|
icon = re.match(r'pattern_toggle\(\s*\w+\s*,\s*(?:"[^"]*"|\w+)\s*,\s*"[^"]*"\s*,\s*"([a-z][a-z0-9_]*)"', call.group())
|
|
if icon: names.add(icon.group(1))
|
|
for table in re.finditer(r'for\s*\(i,\s*\(label,\s*icon,\s*tip\)\)\s*in\s*\[(.*?)\]\s*\.iter\(', source, re.S):
|
|
names.update(re.findall(r'\("[^"]*",\s*"([a-z][a-z0-9_]*)",\s*"[^"]*"\)', table.group(1)))
|
|
return names
|
|
|
|
def scan():
|
|
"""Everything derived from the repo: rows, summary."""
|
|
pal = tomllib.load(open(D + '/palette.toml', 'rb'))
|
|
alias_raw = tomllib.load(open(D + '/aliases.toml', 'rb')).get('alias', {})
|
|
global unassigned
|
|
unassigned = []
|
|
masters = {}
|
|
for f in sorted(glob.glob(D + '/svg/*/*.svg')):
|
|
fam = os.path.basename(os.path.dirname(f)); n = os.path.basename(f)[:-4]
|
|
if fam != 'small': masters[n] = (fam, f)
|
|
uses = collections.defaultdict(list) # id -> command ids and "ui:<file>"
|
|
where = collections.defaultdict(list) # id -> [(tab, panel, command)]
|
|
for f in glob.glob(ROOT + '/crates/engine/src/**/*.rs', recursive=True):
|
|
t = open(f, encoding='utf-8').read()
|
|
ms = list(re.finditer(r'(?:CommandSpec::new|planned!)\(\s*"([^"]+)"\s*,\s*"([^"]*)"', t))
|
|
for i, m in enumerate(ms):
|
|
end = ms[i + 1].start() if i + 1 < len(ms) else len(t)
|
|
chunk = t[m.end():end]
|
|
ic = re.search(r'\.icon\(\s*"([^"]+)"', chunk)
|
|
if ic:
|
|
uses[ic.group(1)].append(m.group(1))
|
|
at = re.search(r'\.at\(\s*"([^"]+)"\s*,\s*"([^"]+)"', chunk)
|
|
if at: where[ic.group(1)].append((at.group(1), at.group(2), m.group(1)))
|
|
else: unassigned.append(m.group(1))
|
|
for f in glob.glob(ROOT + '/crates/ui-egui/src/**/*.rs', recursive=True):
|
|
t = open(f, encoding='utf-8').read()
|
|
for name in ui_icon_names(t):
|
|
uses[name].append('ui:' + os.path.relpath(f, ROOT + '/crates/ui-egui/src'))
|
|
mk = ROOT + '/assets/icons/ui/source/markers.rs'
|
|
if os.path.exists(mk):
|
|
for name in re.findall(r'=> "(c_[a-z_]+)"', open(mk, encoding='utf-8').read()): uses[name].append('ui:sketch constraint glyph')
|
|
def alias_of(n):
|
|
return icon_palette.resolve(pal, alias_raw, n)
|
|
targets = {alias_of(a)[0] for a in alias_raw}
|
|
rows = []
|
|
for n in sorted(set(uses) | set(masters) | set(alias_raw)):
|
|
m, acc = alias_of(n)
|
|
if m in masters and n != 'placeholder': status = 'done'
|
|
else: status, m = 'placeholder', 'placeholder'
|
|
cmds = [u for u in uses.get(n, []) if not u.startswith('ui:')]
|
|
rows.append(dict(id=n, status=status, master=m, accent=acc, commands=len(cmds), example=cmds[0] if cmds else '',
|
|
ui=sorted({u[3:] for u in uses.get(n, []) if u.startswith('ui:')}), unused=not uses.get(n),
|
|
where=where.get(n, []), alias_target=n in targets))
|
|
cnt = collections.Counter(r['status'] for r in rows if r['id'] != 'placeholder')
|
|
cmd_cnt = collections.Counter()
|
|
for r in rows:
|
|
if r['id'] != 'placeholder': cmd_cnt[r['status']] += r['commands']
|
|
summary = '%d discovered icon ids · %d with artwork · %d missing · %d assigned commands.' % (sum(cnt.values()), cnt['done'], cnt['placeholder'], sum(cmd_cnt.values()))
|
|
if unassigned: summary += ' %d commands have no icon assignment.' % len(unassigned)
|
|
return rows, masters, pal, summary
|
|
|
|
if '--resolve' in args:
|
|
ids = [a for a in args[args.index('--resolve') + 1:] if not a.startswith('--')]
|
|
cleared = review_state.resolve(ids)
|
|
print('cleared notes: ' + (' '.join(cleared) or 'none'))
|
|
sys.exit(0)
|
|
|
|
rows, masters, pal, summary = scan()
|
|
print(summary)
|
|
if '--check' in args: sys.exit(1 if unassigned or any(r['status'] == 'placeholder' and r['id'] != 'placeholder' for r in rows) else 0)
|
|
if '--summary' in args and '--csv' not in args: sys.exit(0)
|
|
|
|
if '--notes' in args:
|
|
rv = load_review(); n = 0
|
|
valid = review_state.valid_final(rv)
|
|
for r in rows:
|
|
note = rv['notes'].get(r['id'])
|
|
if note and r['id'] not in valid:
|
|
n += 1; print('\n%s (master %s%s)\n %s' % (r['id'], r['master'], ', ' + r['accent'] + ' accent' if r['accent'] else '', note.replace('\n', '\n ')))
|
|
print('\n%d icon(s) with notes to work on; %d final of %d.' % (n, len(rv['final']), len([r for r in rows if r['id'] != 'placeholder'])))
|
|
sys.exit(0)
|
|
|
|
if '--csv' in args:
|
|
csv_path = os.path.join(ROOT, 'target', 'icon-inventory.csv')
|
|
os.makedirs(os.path.dirname(csv_path), exist_ok=True)
|
|
with open(csv_path, 'w', encoding='utf-8') as f:
|
|
f.write('icon,status,master,accent,commands,example_command,used_by_ui\n')
|
|
for r in rows:
|
|
if r['id'] == 'placeholder': continue
|
|
f.write('%s,%s,%s,%s,%d,%s,"%s"\n' % (r['id'], r['status'], r['master'] if r['status'] != 'placeholder' else '', r['accent'], r['commands'], r['example'], ';'.join(r['ui'])))
|
|
print('wrote', os.path.relpath(csv_path, ROOT))
|
|
|
|
# --- grouping: toolbar tab / panel, else where the app shows the icon -------------------------
|
|
TABS = ['SOLID', 'SURFACE', 'MESH', 'SHEET METAL', 'PLASTIC', 'RENDER', 'SKETCH']
|
|
PANELS = ['CREATE', 'MODIFY', 'ASSEMBLE', 'POSITION', 'CONFIGURE', 'CONSTRUCT', 'CONSTRAINTS', 'SETUP', 'SCENE', 'IMAGE', 'INSPECT', 'INSERT', 'SELECT', 'FINISH SKETCH']
|
|
UI_NAMES = {'browser.rs': 'Browser', 'timeline.rs': 'Timeline', 'timeline_left.rs': 'Timeline', 'context_menu.rs': 'Context menus', 'update.rs': 'Update banner',
|
|
'sketch constraint glyph': 'Sketch constraint glyphs'}
|
|
def rank(l, v): return l.index(v) if v in l else len(l)
|
|
def group_of(r):
|
|
if r['where']:
|
|
tab, panel, _ = min(r['where'], key=lambda w: (rank(TABS, w[0]), rank(PANELS, w[1])))
|
|
return (rank(TABS, tab), rank(PANELS, panel), tab, panel)
|
|
if r['ui']:
|
|
names = sorted({UI_NAMES.get(u, u.replace('.rs', '').replace('_', ' ').title()) for u in r['ui']})
|
|
return (50, 0, 'IN THE APP', ' · '.join(names))
|
|
if r['commands']: return (60, 0, 'MENUS & PALETTE', 'commands without a toolbar button')
|
|
if r['alias_target']: return (65, 0, 'SHARED MASTERS', 'used through aliases')
|
|
return (70, 0, 'UNUSED', 'no app use yet')
|
|
|
|
def themed(svg, theme, accent, pal, vision='off', live=False, namespace=''):
|
|
return icon_palette.themed(svg, pal, theme, accent, vision, live, namespace)
|
|
|
|
def palette_state():
|
|
path = D + '/palette.toml'
|
|
return {'revision': icon_palette.revision(path), 'tokens': icon_palette.tokens(tomllib.load(open(path, 'rb')))}
|
|
|
|
def build_page(serving):
|
|
rows, masters, pal, summary = scan()
|
|
rv = load_review()
|
|
valid = review_state.valid_final(rv)
|
|
shown = [r for r in rows if r['id'] != 'placeholder']
|
|
shown.sort(key=lambda r: (group_of(r), r['id']))
|
|
cards = []; last = None; tabs_seen = []
|
|
protected = collections.defaultdict(list)
|
|
for name in valid: protected[review_state.master_of(name)].append(name)
|
|
for r in shown:
|
|
g = group_of(r)
|
|
if last is None or g[:2] != last[:2]:
|
|
first_of_tab = last is None or g[2] != last[2]
|
|
if first_of_tab and g[2] not in tabs_seen: tabs_seen.append(g[2])
|
|
txt = (g[2] + ' ▸ ' + g[3]) if first_of_tab else g[3]
|
|
cards.append('<i class="gm%s" data-tab="%s" title="%s">%s</i>' % (' tab' if first_of_tab else '', html.escape(g[2]), html.escape(g[2] + ' ▸ ' + g[3]), html.escape(txt)))
|
|
last = g
|
|
missing = r['status'] == 'placeholder'
|
|
svg_f = open(masters[r['master']][1], encoding='utf-8').read() if r['master'] in masters else '<svg viewBox="0 0 64 64"><title>Missing artwork</title><path d="M10 10L54 10L54 54L10 54Z" fill="none" stroke="currentColor" stroke-width="2.55" stroke-dasharray="3 5"/></svg>'
|
|
small = glob.glob(D + '/svg/small/' + r['master'] + '.svg')
|
|
small_svg = open(small[0], encoding='utf-8').read() if small else None
|
|
inner = ''
|
|
for vision in icon_palette.VISIONS:
|
|
inner += '<span class="vision vision-' + vision + '">'
|
|
for theme, cls in [('light', 'al'), ('dark', 'ad')]:
|
|
scope = 'review-' + r['id'] + '-' + vision + '-' + theme
|
|
inner += '<span class="' + cls + '">' + themed(svg_f, theme, r['accent'], pal, vision, live=True, namespace=scope + '-full') + '</span>'
|
|
if small_svg:
|
|
inner += '<span class="' + ('sl' if theme == 'light' else 'sd') + '">' + themed(small_svg, theme, r['accent'], pal, vision, live=True, namespace=scope + '-small') + '</span>'
|
|
inner += '</span>'
|
|
src = ('= ' + r['master']) if r['master'] != r['id'] else ''
|
|
tip = '; '.join('%s ▸ %s: %s' % w for w in r['where']) or ', '.join(r['ui']) or ('%d command(s)' % r['commands'])
|
|
extra = ((' <i class="acc">%s accent</i>' % r['accent']) if r['accent'] else '') + (' <i class="st">%s</i>' % r['status'] if r['status'] != 'done' else '')
|
|
if r['id'] not in valid and protected[r['master']]:
|
|
extra += ' <span class="shared" title="Accepted as ' + html.escape(', '.join(protected[r['master']])) + '; reopen that alias before requesting a redraw">shared artwork accepted</span>'
|
|
if r['id'] in rv['final'] and r['id'] not in valid: extra += ' <i class="st">changed since acceptance</i>'
|
|
cards.append('<div class="card" data-id="%s" data-accent="%s" data-tab="%s" data-k="%s" title="%s" data-missing="%s"><div class="art%s">%s</div><div class="meta"><b>%s</b>%s%s<br><small>%s</small></div>'
|
|
'<button class="ck" title="Accept as final" aria-label="Accept %s as final" %s>✓</button><button class="nt" title="Notes">✎</button></div>' % (
|
|
html.escape(r['id']), html.escape(r['accent']), html.escape(g[2]), html.escape(r['id'] + ' ' + r['example'] + ' ' + r['accent'] + ' ' + g[3].lower()), html.escape(tip), 'true' if missing else 'false',
|
|
' hs' if small_svg else '', inner, html.escape(r['id']), ('<span class="src"> ' + html.escape(src) + '</span>') if src else '', extra, html.escape(r['example'] or ', '.join(r['ui']) or ''), html.escape(r['id']), 'disabled' if missing else ''))
|
|
tabchips = ''.join('<button class="chip" data-tab="%s">%s</button>' % (html.escape(t), html.escape(t.title())) for t in tabs_seen)
|
|
state = json.dumps({'final': sorted(valid), 'notes': rv['notes'], 'serving': serving, 'rev': art_rev(), 'palette': palette_state(), 'hashes': {r['id']: master_hash(r['master']) for r in shown if r['status'] != 'placeholder'}}).replace('<', r'\u003c')
|
|
return load_template().replace('@@PALETTE_CSS@@', icon_palette.palette_css(pal) + '\n' + icon_palette.review_css(pal, live=True)).replace('@@GUIDE@@', '/guide' if serving else os.path.basename(out_path) + '.guide.html').replace('@@WARNINGS@@', ('Unassigned commands: ' + html.escape(', '.join(unassigned))) if unassigned else '').replace('@@SUMMARY@@', html.escape(summary)).replace('@@CARDS@@', ''.join(cards)).replace('@@TABS@@', tabchips).replace('@@STATE@@', state)
|
|
|
|
WEB = os.path.join(HERE, 'review')
|
|
def load_template():
|
|
template = open(os.path.join(WEB, 'index.html'), encoding='utf-8').read()
|
|
return template.replace('@@CSS@@', open(os.path.join(WEB, 'review.css'), encoding='utf-8').read()).replace('@@JS@@', open(os.path.join(WEB, 'review.js'), encoding='utf-8').read())
|
|
|
|
|
|
def build_guide():
|
|
sys.path.insert(0, os.path.join(HERE, 'author'))
|
|
from bases import examples
|
|
rows, masters, pal, _ = scan()
|
|
by_id = {r['id']: r for r in rows}
|
|
catalogue = tomllib.load(open(D + '/references.toml', 'rb'))
|
|
sections = '<h2>Canonical bases</h2><div class="examples">'
|
|
for label, svg in examples().items():
|
|
sections += '<article><b>' + label + '</b>' + themed(svg, 'light', '', pal) + '</article>'
|
|
sections += '</div>'
|
|
for category in catalogue['category'].values():
|
|
sections += '<h2>' + html.escape(category['label']) + '</h2><p>' + html.escape(category['rule']) + '</p><div class="examples">'
|
|
for name in category['icons']:
|
|
row = by_id[name]; svg = open(masters[row['master']][1], encoding='utf-8').read()
|
|
sections += '<article><b>' + name + '</b><div class="light">' + themed(svg, 'light', row['accent'], pal, namespace='guide-' + category['label'].replace(' ', '-') + '-' + name + '-light') + '</div><div class="dark">' + themed(svg, 'dark', row['accent'], pal, namespace='guide-' + category['label'].replace(' ', '-') + '-' + name + '-dark') + '</div></article>'
|
|
sections += '</div>'
|
|
template = open(os.path.join(WEB, 'guide.html'), encoding='utf-8').read()
|
|
return template.replace('@@EXAMPLES@@', sections)
|
|
|
|
|
|
if '--serve' in args:
|
|
import http.server
|
|
port = int(args[args.index('--serve') + 1]) if len(args) > args.index('--serve') + 1 and args[args.index('--serve') + 1].isdigit() else 8770
|
|
_r = load_review(); review_state.save(_r['final'], _r['notes']) # fills in missing hashes
|
|
class H(http.server.BaseHTTPRequestHandler):
|
|
def log_message(self, *a): pass
|
|
def _send(self, code, body, ctype):
|
|
b = body.encode(); self.send_response(code); self.send_header('Content-Type', ctype); self.send_header('Content-Length', str(len(b))); self.send_header('Cache-Control', 'no-store'); self.end_headers(); self.wfile.write(b)
|
|
def do_GET(self):
|
|
if self.path.split('?')[0] in ('/', '/index.html'): self._send(200, build_page(True), 'text/html; charset=utf-8')
|
|
elif self.path.split('?')[0] == '/api/review': self._send(200, json.dumps({'final': sorted(review_state.valid_final()), 'notes': load_review()['notes'], 'rev': art_rev()}), 'application/json')
|
|
elif self.path.split('?')[0] == '/api/palette': self._send(200, json.dumps(palette_state()), 'application/json')
|
|
elif self.path.split('?')[0] == '/guide': self._send(200, build_guide(), 'text/html; charset=utf-8')
|
|
else: self._send(404, 'not found', 'text/plain')
|
|
def do_POST(self):
|
|
with review_state.LOCK: self._post()
|
|
def _post(self):
|
|
if self.path not in ('/api/review', '/api/export', '/api/palette'): return self._send(404, 'not found', 'text/plain')
|
|
try:
|
|
n = int(self.headers.get('Content-Length', '0'))
|
|
if n <= 0 or n > 4_000_000: raise ValueError('invalid request size')
|
|
inc = json.loads(self.rfile.read(n))
|
|
if self.path == '/api/palette':
|
|
icon_palette.save_colours(D + '/palette.toml', inc.get('revision'), inc.get('changes'))
|
|
return self._send(200, json.dumps({'ok': True, **palette_state()}), 'application/json')
|
|
base = inc.get('base')
|
|
if not isinstance(base, dict): raise ValueError('stale page: reload it')
|
|
cur = load_review(); old = cur['final']
|
|
# three-way merge: apply what this page changed since the state it last saw (`base`) onto the file as it is now
|
|
bf = set(base.get('final', [])); cf = set(inc.get('final', []))
|
|
added = cf - bf
|
|
if added:
|
|
available = {r['id'] for r in scan()[0] if r['status'] != 'placeholder'}
|
|
if not added <= available: raise ValueError('missing artwork cannot be accepted')
|
|
if inc.get('rev') != art_rev(): raise ValueError('artwork changed: reload before accepting it')
|
|
final = (set(old) | added) - (bf - cf)
|
|
notes = dict(cur['notes']); bn = base.get('notes', {}); cn = inc.get('notes', {})
|
|
for k in set(bn) | set(cn):
|
|
if bn.get(k, '') != cn.get(k, ''):
|
|
if cn.get(k, '').strip(): notes[k] = cn[k]
|
|
else: notes.pop(k, None)
|
|
review_state.save({i: '' if i in added else old.get(i, '') for i in final}, notes)
|
|
res = {'ok': True}
|
|
if self.path == '/api/export':
|
|
r = load_review(); valid = review_state.valid_final(r)
|
|
protected = {review_state.master_of(i) for i in valid}
|
|
todo = sorted(i for i in r['notes'] if i not in valid and review_state.master_of(i) not in protected)
|
|
res['sent'] = len(todo)
|
|
if todo:
|
|
os.makedirs(REQUESTS, exist_ok=True)
|
|
request_id = uuid.uuid4().hex
|
|
path = os.path.join(REQUESTS, request_id + '.json')
|
|
# Publish a complete snapshot atomically so the chat never reads half a request.
|
|
with open(path + '.tmp', 'w') as f:
|
|
json.dump({'version': 1, 'id': request_id,
|
|
'created_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),
|
|
'notes': {i: r['notes'][i] for i in todo}}, f, indent=1)
|
|
f.write('\n')
|
|
os.replace(path + '.tmp', path)
|
|
res['request_id'] = request_id
|
|
self._send(200, json.dumps(res), 'application/json')
|
|
except Exception as e:
|
|
self._send(400, json.dumps({'ok': False, 'error': str(e)}), 'application/json')
|
|
srv = http.server.ThreadingHTTPServer(('127.0.0.1', port), H)
|
|
print('review page: http://127.0.0.1:%d (saves %s; Ctrl-C to stop)' % (port, os.path.relpath(REVIEW, ROOT)))
|
|
try: srv.serve_forever()
|
|
except KeyboardInterrupt: pass
|
|
sys.exit(0)
|
|
|
|
page = build_page(False)
|
|
os.makedirs(os.path.dirname(out_path), exist_ok=True)
|
|
open(out_path, 'w', encoding='utf-8').write(page)
|
|
if os.path.exists(D + '/references.toml'):
|
|
guide = build_guide().replace('href="/"', 'href="' + html.escape(os.path.basename(out_path)) + '"')
|
|
open(out_path + '.guide.html', 'w', encoding='utf-8').write(guide)
|
|
print('wrote', os.path.relpath(out_path, ROOT), '(%d KB)' % (len(page) // 1024))
|