Add Recipemanager that loads recipes from YAML
This commit is contained in:
JonShard
@@ -0,0 +1,384 @@
|
||||
@tool
|
||||
class_name YAMLSyntaxParser extends RefCounted
|
||||
|
||||
## Token types
|
||||
enum TokenType {
|
||||
TEXT, # For keys only
|
||||
COMMENT, # Comments
|
||||
SYMBOL, # Structural elements like :, -, >, |, &, *, [, ], {, }
|
||||
STRING, # String values (default for unmatched values)
|
||||
NUMBER, # Numeric values
|
||||
KEYWORD, # Booleans, null, merge keys, tags
|
||||
DOCUMENT_SEPARATOR, # New document separator
|
||||
}
|
||||
|
||||
var re_patterns := {
|
||||
"merge_key": RegEx.create_from_string("^\\s*<<:\\s*\\*[^\\s]+"),
|
||||
"multiline_indicator": RegEx.create_from_string("(>|\\|-?)\\s*$"),
|
||||
"array_item": RegEx.create_from_string("^(\\s*-(?:\\s*-)*\\s*)(.*)$"),
|
||||
"key_value": RegEx.create_from_string("^\\s*([^:]+):(.*)$"),
|
||||
|
||||
# Scalar patterns
|
||||
"quoted_string": RegEx.create_from_string("^(['\"])(?:\\\\.|[^\\\\])*\\1$"),
|
||||
"number": RegEx.create_from_string("^(?:0[xX][0-9a-fA-F]+|0[oO][0-7]+|0[bB][0-1]+|[-+]?(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][-+]?\\d+)?)$"),
|
||||
"boolean": RegEx.create_from_string("^(true|false)$"),
|
||||
"nullish": RegEx.create_from_string("^(null|~)$"),
|
||||
"special": RegEx.create_from_string("^(\\.inf|\\.nan)$"),
|
||||
|
||||
# YAML functionality
|
||||
"anchor": RegEx.create_from_string("^\\s*&([^\\s]+)"),
|
||||
"alias": RegEx.create_from_string("^\\s*\\*([^\\s]+)"),
|
||||
"tag": RegEx.create_from_string("!(?:![\\w\\-\\.]+|[^\\s\\[\\]{}'\"`]+)"),
|
||||
"top_level_tag": RegEx.create_from_string("^\\s*(!(?:![\\w\\-\\.]+|[^\\s\\[\\]{}'\"`]+))\\s*(.*)$"),
|
||||
"document_separator": RegEx.create_from_string("^---$")
|
||||
}
|
||||
|
||||
class ParserState:
|
||||
var in_string: bool = false
|
||||
var string_char: String = ""
|
||||
var stack: Array = [] # For nested flow collections
|
||||
var token_start: int = -1
|
||||
var colors: Dictionary = {}
|
||||
|
||||
func push(char: String) -> void:
|
||||
stack.push_back(char)
|
||||
|
||||
func pop() -> String:
|
||||
return stack.pop_back() if not stack.is_empty() else ""
|
||||
|
||||
func peek() -> String:
|
||||
return stack.back() if not stack.is_empty() else ""
|
||||
|
||||
## Provides colors to the syntax highlighter
|
||||
class ColorProvider:
|
||||
# Default theme colors
|
||||
var theme: Dictionary = {
|
||||
"text": Color(0.8025, 0.81, 0.8225, 1),
|
||||
"comment": Color(0.8025, 0.81, 0.8225, 0.5),
|
||||
"symbol": Color(0.67, 0.79, 1, 1),
|
||||
"string": Color(1, 0.93, 0.63, 1),
|
||||
"number": Color(0.63, 1, 0.88, 1),
|
||||
"keyword": Color(1, 0.44, 0.52, 1),
|
||||
"document_separator": Color(0.8025, 0.81, 0.8225, 0.5)
|
||||
}
|
||||
|
||||
func _init():
|
||||
update_theme()
|
||||
|
||||
## Updates the theme colors from Godot Editor settings
|
||||
func update_theme() -> void:
|
||||
# Only inside the Godot Editor
|
||||
if !Engine.is_editor_hint():
|
||||
return
|
||||
|
||||
# Read theme from editor settings
|
||||
var settings = EditorInterface.get_editor_settings()
|
||||
theme = {
|
||||
"text": settings.get_setting("text_editor/theme/highlighting/text_color"),
|
||||
"comment": settings.get_setting("text_editor/theme/highlighting/comment_color"),
|
||||
"symbol": settings.get_setting("text_editor/theme/highlighting/symbol_color"),
|
||||
"string": settings.get_setting("text_editor/theme/highlighting/string_color"),
|
||||
"number": settings.get_setting("text_editor/theme/highlighting/number_color"),
|
||||
"keyword": settings.get_setting("text_editor/theme/highlighting/keyword_color"),
|
||||
"document_separator": settings.get_setting("text_editor/theme/highlighting/comment_color"),
|
||||
}
|
||||
|
||||
## Get color for tokens
|
||||
func get_color_for_type(type: TokenType) -> Color:
|
||||
match type:
|
||||
YAMLSyntaxParser.TokenType.TEXT: return theme.text
|
||||
YAMLSyntaxParser.TokenType.COMMENT: return theme.comment
|
||||
YAMLSyntaxParser.TokenType.SYMBOL: return theme.symbol
|
||||
YAMLSyntaxParser.TokenType.STRING: return theme.string
|
||||
YAMLSyntaxParser.TokenType.NUMBER: return theme.number
|
||||
YAMLSyntaxParser.TokenType.KEYWORD: return theme.keyword
|
||||
YAMLSyntaxParser.TokenType.DOCUMENT_SEPARATOR: return theme.document_separator
|
||||
_: return theme.string # Default fallback is string color
|
||||
|
||||
## Highlight a line of YAML
|
||||
func highlight_line(text: String, color_provider: ColorProvider = ColorProvider.new()) -> Dictionary:
|
||||
var comment_pos := _find_comment_start(text)
|
||||
var content := text if comment_pos == -1 else text.substr(0, comment_pos).rstrip(" \t")
|
||||
var colors := {}
|
||||
|
||||
if content.strip_edges():
|
||||
colors = _highlight_line_content(content, color_provider)
|
||||
|
||||
if comment_pos != -1:
|
||||
colors[comment_pos] = {"color": color_provider.get_color_for_type(TokenType.COMMENT)}
|
||||
|
||||
return _sort_colors(colors)
|
||||
|
||||
# Find the beginning position of a comment
|
||||
func _find_comment_start(text: String) -> int:
|
||||
var in_string := false
|
||||
var string_char := ""
|
||||
|
||||
for i in range(text.length()):
|
||||
var char := text[i]
|
||||
|
||||
if not in_string:
|
||||
if char in ['"', "'"] and (i == 0 or text[i - 1] != '\\'):
|
||||
in_string = true
|
||||
string_char = char
|
||||
elif char == '#' and (i == 0 or text[i - 1] == ' ' or text[i - 1] == '\t'):
|
||||
return i
|
||||
else:
|
||||
if char == string_char and (i == 0 or text[i - 1] != '\\'):
|
||||
in_string = false
|
||||
string_char = ""
|
||||
|
||||
return -1
|
||||
|
||||
# Highlight line content
|
||||
func _highlight_line_content(text: String, color_provider: ColorProvider) -> Dictionary:
|
||||
# Handle document separator
|
||||
var separator_match: RegExMatch = re_patterns.document_separator.search(text)
|
||||
if separator_match:
|
||||
return {0: {"color": color_provider.get_color_for_type(TokenType.DOCUMENT_SEPARATOR)}}
|
||||
|
||||
# Handle merge keys
|
||||
var merge_match: RegExMatch = re_patterns.merge_key.search(text)
|
||||
if merge_match:
|
||||
return {
|
||||
merge_match.get_start(0): {"color": color_provider.get_color_for_type(TokenType.KEYWORD)}
|
||||
}
|
||||
|
||||
# Check for top-level tags
|
||||
var tag_match: RegExMatch = re_patterns.top_level_tag.search(text)
|
||||
if tag_match:
|
||||
var colors := {}
|
||||
# Color just the tag part as keyword (red)
|
||||
_add_color(color_provider, colors, tag_match.get_start(1), tag_match.get_end(1), TokenType.KEYWORD)
|
||||
|
||||
# Process any remaining content after the tag
|
||||
var remaining = tag_match.get_string(2).strip_edges()
|
||||
if remaining:
|
||||
var remaining_start = text.find(remaining, tag_match.get_end(1))
|
||||
if remaining_start != -1:
|
||||
if remaining.begins_with("{") or remaining.begins_with("["):
|
||||
colors.merge(_parse_flow_style(color_provider, remaining, remaining_start))
|
||||
else:
|
||||
_add_scalar_color(color_provider, colors, remaining, remaining_start)
|
||||
return colors
|
||||
|
||||
# Handle array items
|
||||
var array_match: RegExMatch = re_patterns.array_item.search(text)
|
||||
if array_match:
|
||||
var colors := {}
|
||||
|
||||
# Color the entire dash section as symbols
|
||||
_add_color(color_provider, colors, array_match.get_start(1), array_match.get_end(1), TokenType.SYMBOL)
|
||||
|
||||
# Process the content after the dashes
|
||||
var content: String = array_match.get_string(2).strip_edges()
|
||||
if content:
|
||||
var content_start: int = array_match.get_start(2)
|
||||
if content.begins_with("[") or content.begins_with("{"):
|
||||
colors.merge(_parse_flow_style(color_provider, content, content_start))
|
||||
else:
|
||||
_add_scalar_color(color_provider, colors, content, content_start)
|
||||
return colors
|
||||
|
||||
# Handle regular key-value pairs
|
||||
var key_value_match: RegExMatch = re_patterns.key_value.search(text)
|
||||
if key_value_match:
|
||||
return _parse_key_value(color_provider, text, key_value_match)
|
||||
|
||||
# Handle flow-style collections at the root level
|
||||
if "[" in text or "{" in text:
|
||||
return _parse_flow_style(color_provider, text, 0)
|
||||
|
||||
# Handle multi-line string indicators
|
||||
var multiline_match: RegExMatch = re_patterns.multiline_indicator.search(text)
|
||||
if multiline_match:
|
||||
var colors := {}
|
||||
# Color the indicator (> or |) as symbol
|
||||
_add_color(color_provider, colors, multiline_match.get_start(1), multiline_match.get_end(1), TokenType.SYMBOL)
|
||||
return colors
|
||||
|
||||
# Default case: treat as string content (for multi-line string content)
|
||||
if text.strip_edges():
|
||||
return {0: {"color": color_provider.get_color_for_type(TokenType.STRING)}}
|
||||
|
||||
return {}
|
||||
|
||||
# Parse flow collections
|
||||
func _parse_flow_style(color_provider: ColorProvider, text: String, offset: int) -> Dictionary:
|
||||
var state := ParserState.new()
|
||||
var pos := 0
|
||||
|
||||
while pos < text.length():
|
||||
var char := text[pos]
|
||||
|
||||
# Handle string literals
|
||||
if char in ['"', "'"] and (pos == 0 or text[pos - 1] != '\\'):
|
||||
if not state.in_string:
|
||||
state.in_string = true
|
||||
state.string_char = char
|
||||
state.token_start = pos
|
||||
elif char == state.string_char:
|
||||
state.in_string = false
|
||||
_add_color(color_provider, state.colors, offset + state.token_start, offset + pos + 1, TokenType.STRING)
|
||||
state.token_start = -1
|
||||
|
||||
# Handle flow collection brackets when not in string
|
||||
elif not state.in_string:
|
||||
if char in ['[', '{']:
|
||||
state.push(char)
|
||||
_add_color(color_provider, state.colors, offset + pos, offset + pos + 1, TokenType.SYMBOL)
|
||||
state.token_start = pos + 1
|
||||
|
||||
elif char in [']', '}']:
|
||||
var matching := '[' if char == ']' else '{'
|
||||
if state.peek() == matching:
|
||||
state.pop()
|
||||
if state.token_start != -1:
|
||||
var token := text.substr(state.token_start, pos - state.token_start).strip_edges()
|
||||
if token:
|
||||
_add_scalar_color(color_provider, state.colors, token, offset + state.token_start)
|
||||
_add_color(color_provider, state.colors, offset + pos, offset + pos + 1, TokenType.SYMBOL)
|
||||
state.token_start = -1
|
||||
|
||||
elif char in [':', ',']:
|
||||
if state.token_start != -1:
|
||||
var token := text.substr(state.token_start, pos - state.token_start).strip_edges()
|
||||
if token:
|
||||
if char == ':':
|
||||
# All map keys should be text colored, regardless of content
|
||||
_add_color(color_provider, state.colors, offset + state.token_start, offset + pos, TokenType.TEXT)
|
||||
else:
|
||||
_add_scalar_color(color_provider, state.colors, token, offset + state.token_start)
|
||||
_add_color(color_provider, state.colors, offset + pos, offset + pos + 1, TokenType.SYMBOL)
|
||||
state.token_start = pos + 1
|
||||
|
||||
elif char != ' ' and state.token_start == -1:
|
||||
state.token_start = pos
|
||||
|
||||
pos += 1
|
||||
|
||||
# Handle any remaining token
|
||||
if state.token_start != -1 and state.token_start < pos:
|
||||
var token := text.substr(state.token_start, pos - state.token_start).strip_edges()
|
||||
if token:
|
||||
# Check if this is a key in a map context
|
||||
if not state.stack.is_empty() and state.stack.back() == '{' and ':' in text.substr(pos):
|
||||
_add_color(color_provider, state.colors, offset + state.token_start, offset + pos, TokenType.TEXT)
|
||||
else:
|
||||
_add_scalar_color(color_provider, state.colors, token, offset + state.token_start)
|
||||
|
||||
return state.colors
|
||||
|
||||
# Parse dictionary key and value
|
||||
func _parse_key_value(color_provider: ColorProvider, text: String, match: RegExMatch) -> Dictionary:
|
||||
var colors := {}
|
||||
|
||||
# Color the key
|
||||
_add_color(color_provider, colors, match.get_start(1), match.get_end(1), TokenType.TEXT)
|
||||
|
||||
# Color the colon
|
||||
_add_color(color_provider,colors, match.get_end(1), match.get_end(1) + 1, TokenType.SYMBOL)
|
||||
|
||||
# Get and process the value if present
|
||||
var value := match.get_string(2).strip_edges()
|
||||
if value:
|
||||
var value_start := text.find(value, match.get_end(1))
|
||||
if value_start != -1:
|
||||
# First check for and handle any tags
|
||||
var tag_match: RegExMatch = re_patterns.tag.search(value)
|
||||
if tag_match:
|
||||
_add_color(color_provider, colors, value_start + tag_match.get_start(0),
|
||||
value_start + tag_match.get_end(0), TokenType.KEYWORD)
|
||||
# Get remaining content after tag
|
||||
var after_tag := value.substr(tag_match.get_end(0)).strip_edges()
|
||||
if after_tag:
|
||||
var after_tag_start = text.find(after_tag, value_start + tag_match.get_end(0))
|
||||
if after_tag_start != -1:
|
||||
# Now check for multiline indicator in remaining content
|
||||
var indicator_match: RegExMatch = re_patterns.multiline_indicator.search(after_tag)
|
||||
if indicator_match:
|
||||
_add_color(color_provider, colors, after_tag_start + indicator_match.get_start(1), after_tag_start + indicator_match.get_end(1), TokenType.SYMBOL)
|
||||
elif after_tag.begins_with("{") or after_tag.begins_with("["):
|
||||
# Process flow style collections after the tag
|
||||
colors.merge(_parse_flow_style(color_provider, after_tag, after_tag_start))
|
||||
else:
|
||||
# Process normal scalar after the tag
|
||||
_add_scalar_color(color_provider, colors, after_tag, after_tag_start)
|
||||
return colors
|
||||
|
||||
# If no tag, check for multiline indicator in full value
|
||||
var indicator_match: RegExMatch = re_patterns.multiline_indicator.search(value)
|
||||
if indicator_match:
|
||||
_add_color(color_provider, colors, value_start + indicator_match.get_start(1), value_start + indicator_match.get_end(1), TokenType.SYMBOL)
|
||||
elif value.begins_with("[") or value.begins_with("{"):
|
||||
colors.merge(_parse_flow_style(color_provider, value, value_start))
|
||||
else:
|
||||
_add_scalar_color(color_provider, colors, value, value_start)
|
||||
return colors
|
||||
|
||||
# Colors for scalar values
|
||||
func _add_scalar_color(color_provider: ColorProvider, colors: Dictionary, token: String, start_index: int) -> void:
|
||||
# Handle empty or whitespace-only tokens
|
||||
token = token.strip_edges()
|
||||
if token.is_empty():
|
||||
return
|
||||
|
||||
# Check for quoted strings first
|
||||
if re_patterns.quoted_string.search(token):
|
||||
_add_color(color_provider, colors, start_index, start_index + token.length(), TokenType.STRING)
|
||||
return # Important: return early to prevent parsing tags inside strings
|
||||
|
||||
# Check for tags
|
||||
var tag_match: RegExMatch = re_patterns.tag.search(token)
|
||||
if tag_match:
|
||||
var tag_start := tag_match.get_start(0)
|
||||
var tag_end := tag_match.get_end(0)
|
||||
|
||||
# Only color the tag portion
|
||||
_add_color(color_provider, colors, start_index + tag_start, start_index + tag_end, TokenType.KEYWORD)
|
||||
|
||||
# Process any remaining content after the tag
|
||||
if tag_end < token.length():
|
||||
var remaining := token.substr(tag_end).strip_edges()
|
||||
if remaining:
|
||||
var remaining_start = start_index + token.find(remaining, tag_end)
|
||||
if remaining_start != -1:
|
||||
if remaining.begins_with("{") or remaining.begins_with("["):
|
||||
colors.merge(_parse_flow_style(color_provider, remaining, remaining_start))
|
||||
else:
|
||||
# Apply appropriate coloring for the remaining content
|
||||
if re_patterns.number.search(remaining):
|
||||
_add_color(color_provider, colors, remaining_start, remaining_start + remaining.length(), TokenType.NUMBER)
|
||||
elif re_patterns.boolean.search(remaining) or re_patterns.nullish.search(remaining) or re_patterns.special.search(remaining):
|
||||
_add_color(color_provider, colors, remaining_start, remaining_start + remaining.length(), TokenType.KEYWORD)
|
||||
else:
|
||||
_add_color(color_provider, colors, remaining_start, remaining_start + remaining.length(), TokenType.STRING)
|
||||
return
|
||||
|
||||
# Rest of the scalar checks for non-tag content
|
||||
elif re_patterns.number.search(token):
|
||||
_add_color(color_provider, colors, start_index, start_index + token.length(), TokenType.NUMBER)
|
||||
elif re_patterns.boolean.search(token) or re_patterns.nullish.search(token) or re_patterns.special.search(token):
|
||||
_add_color(color_provider, colors, start_index, start_index + token.length(), TokenType.KEYWORD)
|
||||
elif re_patterns.anchor.search(token) or re_patterns.alias.search(token):
|
||||
_add_color(color_provider, colors, start_index, start_index + token.length(), TokenType.SYMBOL)
|
||||
else:
|
||||
# Default fallback is string color
|
||||
_add_color(color_provider, colors, start_index, start_index + token.length(), TokenType.STRING)
|
||||
|
||||
# Add color for a type
|
||||
func _add_color(color_provider: ColorProvider, colors: Dictionary, start: int, end: int, type: TokenType) -> void:
|
||||
colors[start] = {"color": color_provider.get_color_for_type(type)}
|
||||
|
||||
# Sort the colors dictionary by index
|
||||
func _sort_colors(colors: Dictionary) -> Dictionary:
|
||||
# Get all indices as an array
|
||||
var indices := colors.keys()
|
||||
indices.sort() # Sort indices in ascending order
|
||||
|
||||
# Create new dictionary with sorted indices
|
||||
var sorted_colors := {}
|
||||
for idx in indices:
|
||||
sorted_colors[idx] = colors[idx]
|
||||
|
||||
return sorted_colors
|
||||
Reference in New Issue
Block a user