formatitko/formatitko.py

#!/usr/bin/env python3


from panflute import *
import re
import sys
from typing import List

# Import local files
from whitespace import *
from command import *
from util import *
from context import *

from mj_show import show

def executeCommand(source, element: Element, ctx: Context) -> List[Element]:
	mode = 'empty'
	text = ""
	content = []
	def print(s: str=""):
		nonlocal mode, text
		if mode == 'elements':
			raise SyntaxError("Cannot use `print` and `appendChild` in one command at the same time.")
		mode = 'text'
		text += s
	
	def println(s: str=""):
		print(s+"\n")

	def appendChild(e: Element):
		nonlocal mode, content
		if mode == 'text':
			raise SyntaxError("Cannot use `print` and `appendChild` in one command at the same time.")
		mode = 'elements'
		content.append(e)
	
	def appendChildren(l: List[Element]):
		for e in l:
			appendChild(e)

	exec(source)

	if mode == 'text':
		return convert_text(text)
	if mode == 'elements':
		return content

	return []

def transform(e: Element, context: Context) -> Element: # Returns next sibling element to transform
	"""Transform the AST, making format-agnostic changes."""
	
	if isinstance(e, Whitespace) and bavlna(e):
		e = NBSP()

	if hasattr(e, "attributes"):
		# `if` attribute. Only show this element if flag is set.
		if "if" in e.attributes:
			if not context.is_flag_set(e.attributes["if"]):
				return nullify(e)
		# `ifn` attribute. Only show this element if flag is NOT set
		if "ifn" in e.attributes:
			if context.is_flag_set(e.attributes["ifn"]):
				return nullify(e)
		
		# `c` attribute. Execute a command with the name saved in this attribute.
		if (isinstance(e, Div) or isinstance(e, Span)) and "c" in e.attributes:
			if isinstance(e, Div):
				e = BlockCommand(*e.content, identifier=e.identifier, classes=e.classes, attributes=e.attributes)
			else:
				e = InlineCommand(*e.content, identifier=e.identifier, classes=e.classes, attributes=e.attributes)
		
		# `partial` attribute.
		# This is for including content from files with their own flags
		# and commands without affecting the state of the current
		# document.
		if (isinstance(e, Div)) and "partial" in e.attributes:
			includedDoc = import_md(open(e.attributes["partial"], "r").read())
			nContext = Context(includedDoc, context)
			includedDoc = includedDoc.walk(transform, nContext)
			e = Div(*includedDoc.content)
	
	# Execute python code inside source code block
	if isinstance(e, CodeBlock) and hasattr(e, "classes") and "python" in e.classes and "run" in e.classes:
		e = executeCommand(e.text, None, context)
	
	## Command defines
	# possible TODO: def/longdef?
	if isinstance(e, CodeBlock) and hasattr(e, "classes") and "python" in e.classes and hasattr(e, "attributes"):
		if "define" in e.attributes:
			if not context.get_command(e.attributes["define"]):
				context.set_command(e.attributes["define"], compile(e.text, '<string>', 'exec'))
				return nullify(e)
			else:
				raise NameError(f"Command already defined: '{e.attributes['define']}'")
		if "redefine" in e.attributes:
			context.set_command(e.attributes["redefine"], compile(e.text, '<string>', 'exec'))
			return nullify(e)
	
	## Shorthands
	if isinstance(e, Span) and len(e.content) == 1 and isinstance(e.content[0], Str):
		## Handle special command shorthand [!commandname]{}
		if re.match(r"^![\w.]+$", e.content[0].text):
			e = InlineCommand(identifier=e.identifier, classes=e.classes, attributes={**e.attributes, "c": e.content[0].text[1:]})
	
		## Handle import [#path/file.md]{}
		# This is the exact opposite of include. We take the commands
		# and flags but drop the content.
		elif re.match(r"^#.+$", e.content[0].text):
			importedDoc = import_md(open(e.content[0].text[1:], "r").read())
			importedDoc.walk(transform, context)
			return nullify(e)

	## Execute commands
	# Walk transforms the children first, then the root element,
	# so the content of the element the command receives is
	# already transformed.
	if isinstance(e, Command):
		if not context.get_command(e.attributes["c"]):
			raise NameError(f"Command not defined '{e.attributes['c']}'.")
		e = e.replaceSelf(executeCommand(context.get_command(e.attributes["c"]), e, context))
		e.walk(transform, context)
	
	return e

doc = import_md(open(sys.argv[1], "r").read())



print(show(doc))
context = Context(doc)
doc = doc.walk(transform, context)
print("---------------------")
#print(show(doc))
print(convert_text(doc, input_format="panflute", output_format="markdown"))