Refactor code generation

Author: wnbaum

addons/block_code/code_generation/ast_list.gd

@@ -0,0 +1,37 @@
+extends Object
+
+const Types = preload("res://addons/block_code/types/types.gd")
+const BlockAST = preload("res://addons/block_code/code_generation/block_ast.gd")
+
+var array: Array[ASTPair]
+
+
+class ASTPair:
+	var ast: BlockAST
+	var canvas_position: Vector2
+
+	func _init(p_ast: BlockAST, p_canvas_position: Vector2):
+		ast = p_ast
+		canvas_position = p_canvas_position
+
+
+func _init():
+	array = []
+
+
+func append(ast: BlockAST, canvas_position: Vector2):
+	array.append(ASTPair.new(ast, canvas_position))
+
+
+func clear():
+	array.clear()
+
+
+func get_top_level_nodes_of_type(block_type: Types.BlockType) -> Array[BlockAST]:
+	var asts: Array[BlockAST] = []
+
+	for ast_pair in array:
+		if ast_pair.ast.root.data.type == block_type:
+			asts.append(ast_pair.ast)
+
+	return asts

addons/block_code/code_generation/block_ast.gd

@@ -0,0 +1,118 @@
+extends Object
+
+const BlockAST = preload("res://addons/block_code/code_generation/block_ast.gd")
+const Types = preload("res://addons/block_code/types/types.gd")
+
+var root: ASTNode
+
+
+class ASTNode:
+	var data  #: BlockDefinition
+	var children: Array[ASTNode]
+	var arguments: Dictionary  # String, ASTValueNode
+
+	func _init():
+		children = []
+		arguments = {}
+
+	func get_code_block() -> String:
+		var code_block: String = data.code_template  # get multiline code_template from block definition
+
+		# insert args
+
+		# check if args match an overload in the resource
+
+		for arg_name in arguments:
+			# Use parentheses to be safe
+			var argument = arguments[arg_name]
+			var code_string: String
+			if argument is ASTValueNode:
+				code_string = argument.get_code()
+			else:
+				code_string = BlockAST.raw_input_to_code_string(argument)
+
+			code_block = code_block.replace("{%s}" % arg_name, code_string)
+
+		return code_block
+
+	func get_code(depth: int) -> String:
+		var code: String = ""
+
+		# append code block
+		var code_block := get_code_block()
+		code_block = code_block.indent("\t".repeat(depth))
+
+		code += code_block + "\n"
+
+		# fill empty entry and control blocks with pass
+		if children.is_empty() and (data.type == Types.BlockType.ENTRY || data.type == Types.BlockType.CONTROL):
+			code += "pass\n".indent("\t".repeat(depth + 1))
+
+		for child in children:
+			code += child.get_code(depth + 1)
+
+		return code
+
+
+class ASTValueNode:
+	var data  #: BlockDefinition
+	var arguments: Dictionary  # String, ASTValueNode
+
+	func _init():
+		arguments = {}
+
+	func get_code() -> String:
+		var code: String = data.code_template  # get code_template from block definition
+
+		# check if args match an overload in the resource
+
+		for arg_name in arguments:
+			# Use parentheses to be safe
+			var argument = arguments[arg_name]
+			var code_string: String
+			if argument is ASTValueNode:
+				code_string = argument.get_code()
+			else:
+				code_string = BlockAST.raw_input_to_code_string(argument)
+
+			code = code.replace("{%s}" % arg_name, code_string)
+
+		return "(%s)" % code
+
+
+func get_code() -> String:
+	return root.get_code(0)
+
+
+func _to_string():
+	return to_string_recursive(root, 0)
+
+
+func to_string_recursive(node: ASTNode, depth: int) -> String:
+	var string: String = "%s %s\n" % ["-".repeat(depth), node.data.display_template]
+
+	for c in node.children:
+		string += to_string_recursive(c, depth + 1)
+
+	return string
+
+
+static func raw_input_to_code_string(input) -> String:
+	match typeof(input):
+		TYPE_STRING:
+			# HACK: don't include quotes around NIL strings
+			if input.ends_with("__nil__"):
+				return input.trim_suffix("__nil__")
+			return "'%s'" % input.replace("\\", "\\\\").replace("'", "\\'")
+		TYPE_VECTOR2:
+			return "Vector2%s" % str(input)
+		TYPE_COLOR:
+			return "Color%s" % str(input)
+		TYPE_OBJECT:
+			if input is OptionData:
+				var option_data := input as OptionData
+				return option_data.items[option_data.selected]
+		_:
+			return "%s" % input
+
+	return ""

addons/block_code/code_generation/blocks_catalog.gd

@@ -7,28 +7,8 @@ static var _catalog: Dictionary
 
 
 static func setup():
-	if _catalog:
-		return
-
-	_catalog = {}
-	var block_definition: BlockDefinition = BlockDefinition.new()
-	block_definition.name = &"ready_block"
-	block_definition.type = Types.BlockType.ENTRY
-	block_definition.display_template = "On Ready"
-	block_definition.code_template = "func _ready():"
-	block_definition.description = 'Attached blocks will be executed once when the node is "ready"'
-	block_definition.category = "Lifecycle"
-	_catalog[&"ready_block"] = block_definition
-
-	block_definition = BlockDefinition.new()
-	block_definition.name = &"print"
-	block_definition.type = Types.BlockType.STATEMENT
-	block_definition.display_template = "print {text: STRING}"
-	block_definition.code_template = "print({text})"
-	block_definition.defaults = {"text": "Hello"}
-	block_definition.description = "Print the text to output"
-	block_definition.category = "Log"
-	_catalog[&"print"] = block_definition
+	# Move dynamic block definitions here?
+	pass
 
 
 static func get_block(block_name: StringName):