def test_combined_0(self):
lw = latexwalker.LatexWalker(r'\cmd{ab}c*')
s = MacroStandardArgsParser('{*[{*')
parsing_state = lw.make_parsing_state()
(argd, p, l) = s.parse_args(lw,
len(r'\cmd'),
parsing_state=parsing_state)
self.assertPMAEqual(
argd,
ParsedMacroArgs(argspec='{*[{*',
argnlist=[
LatexGroupNode(
parsing_state=parsing_state,
delimiters=('{', '}'),
nodelist=[
LatexCharsNode(
parsing_state=parsing_state,
chars='ab',
pos=5,
len=2)
],
pos=4,
len=4), None, None,
LatexCharsNode(parsing_state=parsing_state,
chars='c',
pos=8,
len=1),
LatexCharsNode(parsing_state=parsing_state,
chars='*',
pos=9,
len=1)
]))
def test_star_0(self):
lw = latexwalker.LatexWalker(r'\cmd xyz')
s = MacroStandardArgsParser('*')
(argd, p, l) = s.parse_args(lw, len(r'\cmd'))
self.assertPMAEqual(
argd,
ParsedMacroArgs(argspec='*', argnlist=[ None ])
)
def test_marg_1(self):
lw = latexwalker.LatexWalker(r'\cmd ab')
s = MacroStandardArgsParser('{')
parsing_state = lw.make_parsing_state()
(argd, p, l) = s.parse_args(lw, len(r'\cmd'), parsing_state=parsing_state)
self.assertPMAEqual(
argd,
ParsedMacroArgs(argspec='{', argnlist=[
LatexCharsNode(parsing_state=parsing_state,
chars='a',
pos=len(r'\cmd')+1,len=1)
])
)
def test_oarg_0(self):
lw = latexwalker.LatexWalker(r'\cmd[ab] xyz')
s = MacroStandardArgsParser('[')
parsing_state = lw.make_parsing_state()
(argd, p, l) = s.parse_args(lw, len(r'\cmd'), parsing_state=parsing_state)
self.assertPMAEqual(
argd,
ParsedMacroArgs(argspec='[', argnlist=[
LatexGroupNode(
parsing_state=parsing_state,
delimiters=('[', ']'),
nodelist=[
LatexCharsNode(parsing_state=parsing_state,
chars='ab',
pos=5,len=2)
],
pos=4,len=4)
])
)
def test_marg_0(self):
lw = latexwalker.LatexWalker(r'{ab}')
s = MacroStandardArgsParser('{')
parsing_state = lw.make_parsing_state()
(argd, p, l) = s.parse_args(lw, 0, parsing_state=parsing_state)
self.assertPMAEqual(
argd,
ParsedMacroArgs(
argspec='{',
argnlist=[ LatexGroupNode(
parsing_state=parsing_state,
delimiters=('{','}'),
nodelist=[
LatexCharsNode(parsing_state=parsing_state,
chars='ab',
pos=1,len=2)
],
pos=0,len=4)
])
)
def nc_parse_args(self, nc_what, ncargspec, w, pos, parsing_state=None):
if parsing_state is None:
parsing_state = w.make_parsing_state()
# prepare a parsing state where no macros are known, they are all to be
# kept as single tokens. The argument placeholder # is recognized as
# "special".
toks_latex_context = LatexContextDb() # completely empty context.
#empty_latex_context.set_unknown_macro_spec(MacroSpec(''))
#empty_latex_context.set_unknown_environment_spec(EnvironmentSpec(''))
#empty_latex_context.set_unknown_specials_spec(SpecialsSpec(''))
toks_latex_context.add_context_category(
'arg_placeholder',
specials=[
# single argument, will be 1...9|#
SpecialsSpec('#', args_parser=MacroStandardArgsParser('{'))
])
toks_parsing_state = parsing_state.sub_context(
latex_context=toks_latex_context)
argnlist = []
p = pos
for argt in ncargspec:
if argt in ('{', '[', '*'):
(stdpa, np, nl) = \
MacroStandardArgsParser(argt).parse_args(w, p, parsing_state=parsing_state)
assert len(stdpa.argnlist) == 1
p = np + nl
argnlist.append(stdpa.argnlist[0])
elif argt is NCArgMacroName:
(node, nodepos, nodelen) = \
w.get_latex_expression(p, parsing_state=toks_parsing_state)
if node.isNodeType(latexwalker.LatexMacroNode):
node._ncarg_the_macro_name = node.macroname
elif node.isNodeType(latexwalker.LatexGroupNode):
if len(node.nodelist) != 1 or \
not node.nodelist[0].isNodeType(latexwalker.LatexMacroNode):
raise latexwalker.LatexWalkerParseError(
"Expected single LaTeX command name as argument, got ‘{}’"
.format(node.to_latex()))
node._ncarg_the_macro_name = node.nodelist[0].macroname
else:
raise latexwalker.LatexWalkerParseError(
"Unexpected argument ‘{}’, was expecting a single LaTeX command"
.format(node.to_latex()))
p = nodepos + nodelen
argnlist.append(node)
elif argt is NCArgBracedTokens:
tok = w.get_token(p,
environments=False,
parsing_state=toks_parsing_state)
if tok.tok != 'brace_open':
raise latexwalker.LatexWalkerError(
"Expected open brace ‘{’ for LaTeX definition body, got ‘%s’"
% (tok.tok), )
# ok, we indeed have an open brace s
(node, nodepos, nodelen) = \
w.get_latex_braced_group(tok.pos, brace_type='{',
parsing_state=toks_parsing_state)
p = nodepos + nodelen
argnlist.append(node)
# elif argt is NCDefArgsSignature:
# def_args_sig_pos = p
# def_toks = []
# while True:
# tok = w.get_token(p, environments=False, parsing_state=toks_parsing_state)
# if tok.tok == 'brace_open':
# break
# if tok.tok == 'comment':
# # still skip comments
# continue
# p = tok.pos + tok.len
# def_toks.append(tok)
# # keep the definition string as a chars node-- but that's really
# # just a plain placeholder that will only be used when we need
# # to convert the argument back to LaTeX code.
# node = w.make_node(latexwalker.LatexCharsNode,
# parsing_state=toks_parsing_state,
# chars=w.s[def_args_sig_pos:p],
# pos=def_args_sig_pos, len=p - def_args_sig_pos)
# # the real, useful information however is stored in a custom
# # attribute that we set on the node
# node._ncarg_def_toks = def_toks
# argnlist.append( node )
else:
raise latexwalker.LatexWalkerError(
"Unknown macro argument kind for macro: {!r}".format(argt))
new_def = NCNewMacroDefinition(
nc_what=nc_what,
ncmacrotype=self.ncmacrotype,
ncargspec=ncargspec,
argnlist=argnlist,
)
return (new_def, pos, p - pos)
from console import *
from pylatexenc.latexwalker import *
from pylatexenc.macrospec import MacroSpec, MacroStandardArgsParser, LatexContextDb
import re
# Der LatexWalker muss wissen, dass `\subject` genau ein Argument bekommt.
latex_context = get_default_latex_context_db()
macros = [
MacroSpec('subject', args_parser=MacroStandardArgsParser(argspec='{'))
]
# macros += [MacroSpec('author', args_parser=MacroStandardArgsParser(argspec='{'))]
macros += [
MacroSpec('href', args_parser=MacroStandardArgsParser(argspec='{{'))
]
latex_context.add_context_category('foo', macros=macros)
def parse_href(node):
"""Extrahiert (href, name) aus einem `\href`-Makro."""
argnlist = node.nodeargd.argnlist
assert len(argnlist[0].nodelist) == 1
href_node = argnlist[0].nodelist[0]
assert href_node.isNodeType(LatexCharsNode)
name_node = argnlist[1].nodelist[0]
assert name_node.isNodeType(LatexCharsNode)
return href_node.chars, name_node.chars
def is_node_interesting(node):
import subprocess
logger = logging.getLogger(__name__)
from pylatexenc.macrospec import MacroSpec, MacroStandardArgsParser
from pylatexenc import latexwalker
from latexpp.fix import BaseFix
from .usepackage import node_get_usepackage # for detecting \usepackage{cleveref}
_REFCMDS = {
'ref': {
'ref': {
'macro': MacroSpec('ref',
args_parser=MacroStandardArgsParser('*{')),
'label_args': [1]
},
'pageref': {
'macro':
MacroSpec('pageref', args_parser=MacroStandardArgsParser('*{')),
'label_args': [1]
},
},
'ams-eqref': {
'eqref': {
'macro': MacroSpec('eqref',
args_parser=MacroStandardArgsParser('*{')),
'label_args': [1]
},
},
