141 lines
5.1 KiB
Python
141 lines
5.1 KiB
Python
import color, method, mode
|
|
from lex import Grammar, Rule, PatternRule, RegionRule
|
|
|
|
class PatternGroupRule(PatternRule):
|
|
def __init__(self, name, *args):
|
|
assert args and len(args) % 2 == 0
|
|
i = 0
|
|
pairs = []
|
|
while i < len(args):
|
|
tokname, pattern = args[i], args[i+1]
|
|
pairs.append((tokname, re.compile(pattern, self.reflags)))
|
|
i += 2
|
|
Rule.__init__(self, name)
|
|
self.pairs = tuple(pairs)
|
|
def match(self, lexer, parent):
|
|
(x, y) = (lexer.x, lexer.y)
|
|
matches = []
|
|
for (tokname, tokre) in self.pairs:
|
|
if y >= len(lexer.lines):
|
|
return []
|
|
line = self.get_line(lexer, y)
|
|
m = tokre.match(line, x)
|
|
if m:
|
|
x += len(m.group(0))
|
|
if x >= len(line):
|
|
x = 0
|
|
y += 1
|
|
matches.append((tokname, m))
|
|
else:
|
|
return []
|
|
assert len(matches) == len(self.pairs)
|
|
return matches
|
|
def lex(self, lexer, parent, matches):
|
|
if matches:
|
|
for (tokname, m) in matches:
|
|
yield self.make_token(lexer, m.group(0), tokname, parent, m.groupdict())
|
|
raise StopIteration
|
|
|
|
class StringGrammar1(Grammar):
|
|
rules = [
|
|
PatternRule(r'data', r'[^"&]+'),
|
|
PatternRule(r'escaped', r'&[a-z]+;'),
|
|
]
|
|
class StringGrammar2(Grammar):
|
|
rules = [
|
|
PatternRule(r'data', r"[^'&]+"),
|
|
PatternRule(r'escaped', r'&[a-z]+;'),
|
|
]
|
|
|
|
class CDataGrammar(Grammar):
|
|
rules = [PatternRule(r'data', r'(?:[^\]]|\](?!\])|\]\](?!>))+')]
|
|
class CommentGrammar(Grammar):
|
|
rules = [PatternRule(r'data', r'(?:[^-]|-(?!-)|--(?!>))+')]
|
|
class MetadataGrammar(Grammar):
|
|
rules = [PatternRule(r'data', r'(?:[^?]|\?(?!>))+')]
|
|
|
|
class TagGrammar(Grammar):
|
|
rules = [
|
|
PatternRule(r'attrname', r'[a-zA-Z_][a-zA-Z0-9_]+(?==)'),
|
|
PatternRule(r'namespace', r'[a-zA-Z_]+(?=:)'),
|
|
PatternRule(r'name', r'[a-zA-Z_][a-zA-Z0-9_]*'),
|
|
PatternRule(r'delimiter', r'[/=]'),
|
|
RegionRule(r'string', r'"', StringGrammar1, r'"'),
|
|
RegionRule(r'string', r"'", StringGrammar2, r"'"),
|
|
PatternRule(r'spaces', r' +'),
|
|
PatternRule(r'eol', r'\n'),
|
|
]
|
|
|
|
class XMLGrammar(Grammar):
|
|
rules = [
|
|
# TODO: how does cdata work again?
|
|
PatternRule(r'data', r'[^<& \n]+'),
|
|
PatternRule(r'spaces', r' +'),
|
|
RegionRule(r'comment', r'<!--', CommentGrammar, r'-->'),
|
|
RegionRule(r'xml_cdata', r'<!\[CDATA\[', CDataGrammar, r'\]\]>'),
|
|
RegionRule(r'xml_tag', r'<(?![?!])', TagGrammar, r'/?>'),
|
|
PatternRule(r'xml_entity', r'&[a-z]+;'),
|
|
PatternRule(r'eol', r'\n'),
|
|
RegionRule(r'xml_metadata', r'<\?', MetadataGrammar, r'\?>'),
|
|
]
|
|
|
|
class XmlValidate(method.shell.Exec):
|
|
'''Valid the buffer's contents as valid XML.'''
|
|
show_success = True
|
|
args = []
|
|
def _execute(self, w, **vargs):
|
|
self._doit(w, w.buffer.path, 'xmlwf %(path)r', cmdname='xml-validate')
|
|
|
|
class XmlCreateTag(method.Method):
|
|
'''Create an opening and closing tag'''
|
|
args = [method.Argument('tagname', prompt="Tag Name: ", help="Create an open/close tag pair")]
|
|
def _execute(self, w, **vargs):
|
|
t = vargs['tagname']
|
|
w.insert_string_at_cursor("<%s>" % t)
|
|
p = w.logical_cursor()
|
|
w.insert_string_at_cursor("</%s>" % t)
|
|
w.goto(p)
|
|
|
|
class XmlCreateComment(method.Method):
|
|
'''Create an opening and closing tag'''
|
|
def _execute(self, w, **vargs):
|
|
w.insert_string_at_cursor("<!-- ")
|
|
p = w.logical_cursor()
|
|
w.insert_string_at_cursor(" -->")
|
|
w.goto(p)
|
|
|
|
class XmlCreateCdata(method.Method):
|
|
'''Create an opening and closing tag'''
|
|
def _execute(self, w, **vargs):
|
|
w.insert_string_at_cursor("<![CDATA[")
|
|
p = w.logical_cursor()
|
|
w.insert_string_at_cursor("]]>")
|
|
w.goto(p)
|
|
|
|
class XML(mode.Fundamental):
|
|
name = 'XML'
|
|
extensions = ['.xml', '.xml.in', '.xsl', '.xsd']
|
|
grammar = XMLGrammar
|
|
colors = {
|
|
'xml_metadata.start': ('magenta', 'default', 'bold'),
|
|
'xml_metadata.data': ('magenta', 'default', 'bold'),
|
|
'xml_metadata.end': ('magenta', 'default', 'bold'),
|
|
'xml_tag.start': ('default', 'default', 'bold'),
|
|
'xml_tag.namespace': ('magenta', 'default', 'bold'),
|
|
'xml_tag.name': ('blue', 'default', 'bold'),
|
|
'xml_tag.attrname': ('cyan', 'default', 'bold'),
|
|
'xml_tag.string.start': ('green', 'default', 'bold'),
|
|
'xml_tag.string.null': ('green', 'default', 'bold'),
|
|
'xml_tag.string.end': ('green', 'default', 'bold'),
|
|
'xml_tag.end': ('default', 'default', 'bold'),
|
|
'xml_entity': ('magenta', 'default', 'bold'),
|
|
'xml_cdata.start': ('magenta', 'default', 'bold'),
|
|
'xml_cdata.data': ('green', 'default', 'bold'),
|
|
'xml_cdata.end': ('magenta', 'default', 'bold'),
|
|
}
|
|
actions = [XmlValidate, XmlCreateTag, XmlCreateComment, XmlCreateCdata]
|
|
_bindings = {
|
|
'xml-create-tag': ('M-t',),
|
|
}
|
|
install = XML.install
|