def test_simple_1(self):
lpp = helpers.MockLPP()
lpp.install_fix(
macro_subst.Subst(macros={
'abc':
r'\textbf{ABC}',
'xyz':
dict(argspec='*[{',
repl=r'\chapter%(1)s[{Opt title: %(2)s}]{Title: %(3)s}')
},
environments={'equation*': r'\[%(body)s\]'}))
self.assertEqual(
lpp.execute(r"""
Hello guys. Just testin': \abc.
\xyz*{Yo}
\begin{equation*}
\alpha = \beta
\end{equation*}
\xyz[Hey]{Ya}
"""), r"""
Hello guys. Just testin': \textbf{ABC}.
\chapter*[{Opt title: }]{Title: Yo}
\[
\alpha = \beta
\]
\chapter[{Opt title: Hey}]{Title: Ya}
""")
def test_no_collapse(self):
latex = r"""Line with % comment here
\begin{stuff}
% line comment on its own
% and a second line
stuff...
\end{stuff}
Also a \itshape% comment after a macro
% and also a second line
some italic text."""
lpp = helpers.MockLPP()
lpp.install_fix(comments.RemoveComments(collapse=False))
self.assertEqual(
lpp.execute(latex), r"""Line with %
\begin{stuff}
%
%
stuff...
\end{stuff}
Also a \itshape%
%
some italic text.""")
def test_preprocess_00b(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(latexwalker.LatexMacroNode
) and n.macroname == 'testmacro':
return r'\newmacro {}'
return None
latex = r"""Test: \testmacro% a comment
Text and \`accent and \textbf{bold text} and $\vec b$ more stuff for Fran\c cois
\begin{enumerate}[(i)]
\item Hi there! % here goes a comment
\item[a] Hello! @@@
\end{enumerate}
Indeed thanks to \cite[Lemma 3]{Author}, we know that...
Also: {\itshape some italic text}."""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist[0:3])
self.assertEqual((newnodelist[0], newnodelist[3]),
(nodelist[0], nodelist[2]))
self.assertEqual(
(newnodelist[1].macroname, newnodelist[1].nodeargd.argnlist,
newnodelist[1].macro_post_space, newnodelist[2].nodelist),
(r'newmacro', [], ' ', []))
def test_preprocess_01(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(latexwalker.LatexMacroNode
) and n.macroname == 'testmacro':
return r'\newmacro {}'
return None
latex = r"""Test: \testmacro% a comment"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
self.assertEqual(len(newnodelist), 4)
self.assertEqual((newnodelist[0], newnodelist[3]),
(nodelist[0], nodelist[2]))
self.assertEqual(
(newnodelist[1].macroname, newnodelist[1].nodeargd.argnlist,
newnodelist[1].macro_post_space, newnodelist[2].nodelist),
(r'newmacro', [], ' ', []))
def test_preprocess_macroarg(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(
latexwalker.LatexMacroNode) and n.macroname == 'hello':
return r'Hello !'
return None
latex = r"""\textbf\hello"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
self.assertEqual(len(newnodelist), 1)
self.assertTrue(newnodelist[0].isNodeType(latexwalker.LatexMacroNode))
m = newnodelist[0]
self.assertEqual(len(m.nodeargd.argnlist), 1)
g = m.nodeargd.argnlist[0]
self.assertTrue(g.isNodeType(latexwalker.LatexGroupNode))
self.assertEqual(len(g.nodelist), 1)
c = g.nodelist[0]
self.assertTrue(c.isNodeType(latexwalker.LatexCharsNode))
self.assertEqual(c.chars, "Hello !")
def test_simple_1b(self):
# test that collapsing comments do respect the post-space of the last
# comment
latex = r"""Line with % comment here
\begin{stuff}
% line comment on its own
% and a second line
stuff...
\end{stuff}
Also a \itshape% comment after a macro
% and also a second line
some italic text."""
lpp = helpers.MockLPP()
lpp.install_fix(comments.RemoveComments())
self.assertEqual(
lpp.execute(latex), r"""Line with %
\begin{stuff}
%
stuff...
\end{stuff}
Also a \itshape%
some italic text.""")
def test_preprocess_recursively(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(latexwalker.LatexMacroNode
) and n.macroname == 'textbf':
if n.nodeargd is None or not n.nodeargd.argnlist \
or not n.nodeargd.argnlist[0]:
return None
return r'\myboldtext {' \
+ self.preprocess_contents_latex(n.nodeargd.argnlist[0]) + '}'
if n.isNodeType(latexwalker.LatexEnvironmentNode) \
and n.environmentname == 'enumerate':
if n.nodeargd is None or not n.nodeargd.argnlist or not n.nodeargd.argnlist[
0]:
return r'\mystuff{' + self.preprocess_contents_latex(
n.nodelist) + '}'
return r'\mystuff[' + self.preprocess_arg_latex(n, 0) \
+ ']{' + self.preprocess_latex(n.nodelist) + '}'
return None
latex = r"""
\begin{enumerate}[\textbf{recursive} replacement]text text\end{enumerate}"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
newlatex = "".join(nn.to_latex() for nn in newnodelist)
self.assertEqual(
newlatex, r"""
\mystuff[\myboldtext {recursive} replacement]{text text}""")
def test_preprocess_macrospace(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(
latexwalker.LatexMacroNode) and n.macroname == 'rho':
return r'\hat\sigma'
return None
latex = r"""The projected state $P_k\rho P_{k'}$"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
self.assertEqual(len(newnodelist), 2)
self.assertEqual(newnodelist[0], nodelist[0])
self.assertTrue(newnodelist[1].isNodeType(latexwalker.LatexMathNode))
self.assertEqual(len(newnodelist[1].nodelist), 4)
self.assertEqual(
(newnodelist[1].nodelist[0], newnodelist[1].nodelist[2]),
(nodelist[1].nodelist[0], nodelist[1].nodelist[2]))
m1 = newnodelist[1].nodelist[1]
self.assertEqual((m1.macroname, m1.macro_post_space,
m1.nodeargd.argnlist[0].macroname,
m1.nodeargd.argnlist[0].macro_post_space),
(r'hat', '', r'sigma', ' '))
def test_simple(self):
lpp = helpers.MockLPP()
lpp.install_fix(usepackage.RemovePkgs(['phfparen', 'mymacros']))
self.assertEqual(
lpp.execute(r"""
\documentclass{article}
\usepackage{amsmath}
\usepackage{phfparen}
\usepackage[someoptions,moreoptions]{mymacros}%
\begin{document}
Hello world.
\end{document}
"""), r"""
\documentclass{article}
\usepackage{amsmath}
%
\begin{document}
Hello world.
\end{document}
""")
def test_simple(self):
mock_files = {
# list of files that "exist"
"mymacros.sty": "%test",
"cleveref.sty": "%test",
}
usepackage.os_path = helpers.FakeOsPath(list(mock_files.keys()))
lpp = helpers.MockLPP(mock_files)
lpp.install_fix(usepackage.CopyLocalPkgs())
lpp.execute(r"""
\documentclass{article}
\usepackage{amsmath}
\usepackage{phfparen}
\usepackage[someoptions,moreoptions]{mymacros}%
\usepackage{cleveref}
\begin{document}
Hello world.
\end{document}
""")
self.assertEqual(lpp.copied_files, [
('mymacros.sty', '/TESTOUT/mymacros.sty'),
('cleveref.sty', '/TESTOUT/cleveref.sty'),
])
def test_simple(self):
latex = r"""
\documentclass[11pt]{article}
\newcommand{\a}{Albert Einstein}
\newcommand\max[1]{Max #1}
\begin{document}
\a{} and \max{Planck} both thought a lot about quantum mechanics.
\end{document}
"""
lpp = helpers.MockLPP()
fix = newcommand.Expand(leave_newcommand=True)
lpp.install_fix( fix )
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\newcommand{\a}{Albert Einstein}
\newcommand\max[1]{Max #1}
\begin{document}
Albert Einstein{} and Max Planck both thought a lot about quantum mechanics.
\end{document}
"""
)
def test_macro_blacklist(self):
latex = r"""
\documentclass[11pt]{article}
\newcommand{\a}{Albert Einstein}
\newcommand\b{Bbbb}
\newcommand\bob{Bobbby}
\newcommand\max[1]{Max #1}
\renewcommand\thepage{\roman{page}}
\begin{document}
\a{} and \max{Planck} both thought a lot about quantum mechanics. Some B's by \bob: \b.
\end{document}
"""
lpp = helpers.MockLPP()
fix = newcommand.Expand(leave_newcommand=False, macro_blacklist_patterns=[r'b$', r'^the'])
lpp.install_fix( fix )
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\newcommand\b{Bbbb}
\newcommand\bob{Bobbby}
\renewcommand\thepage{\roman{page}}
\begin{document}
Albert Einstein{} and Max Planck both thought a lot about quantum mechanics. Some B's by \bob: \b.
\end{document}
"""
)
def test_newcommand_cmds(self):
latex = r"""
\documentclass[11pt]{article}
\newcommand{\a}{Albert Einstein}
\renewcommand\thepage{$-$ \roman{page} $-$}
\providecommand\max[1]{Max #1}
\begin{document}
\a{} and \max{Planck} both thought a lot about quantum mechanics.
\end{document}
"""
lpp = helpers.MockLPP()
fix = newcommand.Expand(newcommand_cmds=['newcommand', 'providecommand'],
leave_newcommand=False)
lpp.install_fix( fix )
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\renewcommand\thepage{$-$ \roman{page} $-$}
\begin{document}
Albert Einstein{} and Max Planck both thought a lot about quantum mechanics.
\end{document}
"""
)
def test_simple(self):
latex = r"""
\bibalias{alias1}{target1}
\bibalias{alias2}{target2}
\begin{document}
Some text~\cite{alias1,target3} and see also~\citep{alias2}.
\bibliography{mybib1,bib2}
\end{document}
"""
lpp = helpers.MockLPP(
mock_files={
'TESTDOC.bbl':
r"\relax\bibdata{XYZ}\bibcite{mybib1}{24}" # etc. this is random stuff here
})
lpp.install_fix(bib.CopyAndInputBbl())
lpp.install_fix(bib.ApplyAliases())
self.assertEqual(
lpp.execute(latex), r"""
\begin{document}
Some text~\cite{target1,target3} and see also~\citep{target2}.
\input{TESTMAIN.bbl}
\end{document}
""")
self.assertEqual(lpp.copied_files,
[('TESTDOC.bbl', '/TESTOUT/TESTMAIN.bbl')])
def test_recursive(self):
lpp = helpers.MockLPP()
lpp.install_fix(
macro_subst.Subst(macros={
'ket':
dict(argspec='{', repl=r'\lvert{%(1)s}\rangle'),
'rhostate':
r'\hat\rho',
}, ))
self.assertEqual(lpp.execute(r"""\ket\rhostate"""),
r"""\lvert{\hat\rho}\rangle""")
def test_simple_eqref_with_hyperref(self):
latex = r"""
\documentclass[11pt]{article}
\usepackage{amsmath}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\usepackage{hyperref}
\begin{document}
Equation~\eqref{eq:test}:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
lpp = helpers.MockLPP()
fix = ref.ExpandRefs(only_ref_types='ams-eqref', debug_latex_output=True)
fix._get_doc_preamble = fix._get_doc_preamble_recomposed
fix._get_auxfile_contents = lambda: hyperref_aux_preamble + r"""
\newlabel{eq:test}{{1}{1}{}{equation.0.1}{}}
"""
lpp.install_fix( fix )
# NOTE: KEEP \protect's in output, because the substitution might happen
# somewhere fragile.
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\usepackage{amsmath}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\usepackage{hyperref}
\begin{document}
Equation~\protect \textup {\mathsurround \z@ \protect \normalfont (\ignorespaces \protect \hyperref [eq:test]{1}\unskip \@@italiccorr )}:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
)
def test_simple(self):
input.os_path = helpers.FakeOsPath([
# list of files that "exist"
'chapter1.tex',
'chapter2.latex',
])
ei = input.EvalInput()
ei._read_file_contents = lambda fn: {
'chapter1.tex':
r"""
\chapter[first]{Chapter uno}
This is the \emph{contents} of ``Chapter 1.''
""",
'chapter2.latex':
r"""\chapter{The second of chapters}
Here is the \textbf{contents} of ``Chapter 2!''
""",
}.get(fn)
lpp = helpers.MockLPP()
lpp.install_fix(ei)
self.assertEqual(
lpp.execute(r"""
Hello, this might be an introduction:
\[ a + b = c\ . \]
\input{chapter1.tex}
\include{chapter2}
"""), r"""
Hello, this might be an introduction:
\[ a + b = c\ . \]
\chapter[first]{Chapter uno}
This is the \emph{contents} of ``Chapter 1.''
\clearpage
\chapter{The second of chapters}
Here is the \textbf{contents} of ``Chapter 2!''
""")
self.assertEqual(lpp.copied_files, [])
def test_simple(self):
lpp = helpers.MockLPP()
lpp.install_fix( deps.CopyFiles(['a.sty', 'b.clo', 'fig/myfig.jpg']) )
lpp.execute("")
self.assertEqual(
lpp.copied_files,
[
('a.sty', '/TESTOUT/a.sty'),
('b.clo', '/TESTOUT/b.clo'),
('fig/myfig.jpg', '/TESTOUT/fig/myfig.jpg'),
]
)
def test_simple_ref_with_hyperref_nolink(self):
latex = r"""
\documentclass[11pt]{article}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\usepackage{hyperref}
\begin{document}
Equation~(\ref{eq:test}) [Eq.~(\ref*{eq:test}) without link]:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
lpp = helpers.MockLPP()
fix = ref.ExpandRefs(only_ref_types='ref', make_hyperlinks=False, debug_latex_output=True)
fix._get_doc_preamble = fix._get_doc_preamble_recomposed
fix._get_auxfile_contents = lambda: hyperref_aux_preamble + r"""
\newlabel{eq:test}{{1}{1}{}{equation.0.1}{}}
"""
lpp.install_fix( fix )
# NOTE: KEEP \protect's in output, because the substitution might happen
# somewhere fragile.
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\usepackage{hyperref}
\begin{document}
Equation~(1) [Eq.~(1) without link]:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
)
def test_preprocess_recursively_2(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(latexwalker.LatexMacroNode
) and n.macroname == 'textbf':
if n.nodeargd is None or not n.nodeargd.argnlist \
or not n.nodeargd.argnlist[0]:
return None
return r'\myboldtext {' + self.preprocess_arg_latex(
n, 0) + '}'
if n.isNodeType(latexwalker.LatexEnvironmentNode) \
and n.environmentname == 'enumerate':
if n.nodeargd is None or not n.nodeargd.argnlist or not n.nodeargd.argnlist[
0]:
return r'\mystuff{' + self.preprocess_latex(
n.nodelist) + '}'
return r'\mystuff[' + self.preprocess_arg_latex(n, 0) \
+ ']{' + self.preprocess_latex(n.nodelist) + '}'
return None
latex = r"""
\begin{enumerate}
\item Some \textbf{BOLD \textbf{text} AND MORE} and more.
\item And a sublist:
\begin{enumerate}[\textbf{recursive} replacement]
\item[\textbf{in \textbf{macro} optional argument}]
\end{enumerate}
\item And in math mode $a\textbf{v} = \textbf{w+\textbf{z}+x}$
\end{enumerate}
"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
newlatex = "".join(nn.to_latex() for nn in newnodelist)
self.assertEqual(
newlatex, r"""
\mystuff{
\item Some \myboldtext {BOLD \myboldtext {text} AND MORE} and more.
\item And a sublist:
\mystuff[\myboldtext {recursive} replacement]{
\item[\myboldtext {in \myboldtext {macro} optional argument}]
}
\item And in math mode $a\myboldtext {v} = \myboldtext {w+\myboldtext {z}+x}$
}
""")
def test_simple_ref(self):
latex = r"""
\documentclass[11pt]{article}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\begin{document}
Equation~(\ref{eq:test}) on page~\pageref{eq:test} reads:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
lpp = helpers.MockLPP()
fix = ref.ExpandRefs(only_ref_types='ref', debug_latex_output=True)
fix._get_doc_preamble = fix._get_doc_preamble_recomposed
fix._get_auxfile_contents = lambda: r"""
\relax
\newlabel{eq:test}{{1}{1}}
"""
lpp.install_fix( fix )
# NOTE: KEEP \protect's in output, because the substitution might happen
# somewhere fragile.
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\usepackage{amsthm}
\newtheorem{lemma}{Lemma}
\begin{document}
Equation~(1) on page~1 reads:
\begin{equation}
\label{eq:test}
a + b = c\ .
\end{equation}
\end{document}
"""
)
def test_newenvironment(self):
latex = r"""
\documentclass[11pt]{article}
\newcommand\Albert{Albert E.}
\newenvironment{testenviron}[2][x]{\texttt{testenviron<#1>{#2}}}{\texttt{endtestenviron}}
\begin{document}
Hello.
\begin{testenviron}\textasciitilde
Environment \textbf{body}, with an equation:
\begin{equation}
x = y + z\ .
\end{equation}
(Not by \Albert.)
\end{testenviron}
\end{document}
"""
lpp = helpers.MockLPP()
fix = newcommand.Expand(newcommand_cmds=['newenvironment'])
lpp.install_fix( fix )
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\newcommand\Albert{Albert E.}
\begin{document}
Hello.
{\texttt{testenviron<x>{\textasciitilde
}}Environment \textbf{body}, with an equation:
\begin{equation}
x = y + z\ .
\end{equation}
(Not by \Albert.)
\texttt{endtestenviron}}
\end{document}
"""
)
def test_leave_percent(self):
latex = r"""Line with % comment here
some text.
% line comment on its own
% and a second line
Also a \itshape% comment after a macro
% and also a second line
some italic text."""
lpp = helpers.MockLPP()
lpp.install_fix(comments.RemoveComments(leave_percent=False))
self.assertEqual(
lpp.execute(latex), r"""Line with some text.
Also a \itshape some italic text.""")
def test_simple_2(self):
figures.os_path = helpers.FakeOsPath([
# list of files that "exist"
'fig/intro.png',
'my_diagram.jpg',
'v088338-1993.out.eps',
'fignew/results schematic.pdf',
'fignew/results schematic 2.jpg'
])
lpp = helpers.MockLPP()
lpp.install_fix( figures.CopyAndRenameFigs(
start_fig_counter=9,
fig_rename='fig/{fig_counter}/{orig_fig_basename}{fig_ext}',
) )
self.assertEqual(
lpp.execute(r"""
\includegraphics[width=\textwidth]{fig/intro}
\includegraphics[width=\textwidth]{my_diagram.jpg}
\includegraphics{fignew/results schematic}
\includegraphics{v088338-1993.out}
"""),
r"""
\includegraphics[width=\textwidth]{fig/9/intro.png}
\includegraphics[width=\textwidth]{fig/10/my_diagram.jpg}
\includegraphics{fig/11/results schematic.pdf}
\includegraphics{fig/12/v088338-1993.out.eps}
"""
)
self.assertEqual(
lpp.copied_files,
[
('fig/intro.png', '/TESTOUT/fig/9/intro.png'),
('my_diagram.jpg', '/TESTOUT/fig/10/my_diagram.jpg'),
('fignew/results schematic.pdf', '/TESTOUT/fig/11/results schematic.pdf'),
('v088338-1993.out.eps', '/TESTOUT/fig/12/v088338-1993.out.eps'),
]
)
def test_simple(self):
input.os_path = helpers.FakeOsPath([
# list of files that "exist"
'chapter1.tex',
'chapter2.latex',
])
mock_files = {
'chapter1.tex':
r"""
\chapter[first]{Chapter uno}
This is the \emph{contents} of ``Chapter 1.''
""",
'chapter2.latex':
r"""\chapter{The second of chapters}
Here is the \textbf{contents} of ``Chapter 2!''
""",
}
lpp = helpers.MockLPP(mock_files=mock_files)
lpp.install_fix(input.CopyInputDeps())
self.assertEqual(
lpp.execute(r"""
Hello, this might be an introduction:
\[ a + b = c\ . \]
\input{chapter1.tex}
\include{chapter2}
"""), r"""
Hello, this might be an introduction:
\[ a + b = c\ . \]
\input{chapter1.tex}
\include{chapter2}
""") # no change
self.assertEqual(lpp.wrote_executed_files, mock_files)
def test_environment_blacklist(self):
latex = r"""
\documentclass[11pt]{article}
\newenvironment{testenviron}[2][x]{\texttt{testenviron<#1>{#2}}}{\texttt{endtestenviron}}
\newenvironment{minienviron}{begin}{end}
\begin{document}
Hello.
\begin{testenviron}{Z}
Environment \textbf{body}, with an inner environment:
\begin{minienviron}
Hi!
\end{minienviron}
\end{testenviron}
\end{document}
"""
lpp = helpers.MockLPP()
fix = newcommand.Expand(environment_blacklist_patterns=[r'm([a-z])n\1'])
lpp.install_fix( fix )
self.assertEqual(
lpp.execute(latex),
r"""
\documentclass[11pt]{article}
\newenvironment{minienviron}{begin}{end}
\begin{document}
Hello.
{\texttt{testenviron<x>{Z}}
Environment \textbf{body}, with an inner environment:
\begin{minienviron}
Hi!
\end{minienviron}
\texttt{endtestenviron}}
\end{document}
"""
)
def test_simple_1(self):
latex = r"""Line with % comment here
% line comment on its own
% and a second line
Also a \itshape% comment after a macro
% and also a second line
some italic text."""
lpp = helpers.MockLPP()
lpp.install_fix(comments.RemoveComments())
self.assertEqual(
lpp.execute(latex), r"""Line with %
%
Also a \itshape%
some italic text.""")
def test_simple(self):
lpp = helpers.MockLPP()
lpp.install_fix(
preamble.AddPreamble(preamble=r"""
% use this package:
\usepackage{mycoolpackage}
% also keep these definitions:
\newcommand\hello[2][world]{Hello #1. #2}
"""))
self.assertEqual(
lpp.execute(r"""
\documentclass{article}
\usepackage{amsmath}
\begin{document}
Hello world.
\end{document}
"""), r"""
\documentclass{article}
\usepackage{amsmath}
%%%
% use this package:
\usepackage{mycoolpackage}
% also keep these definitions:
\newcommand\hello[2][world]{Hello #1. #2}
%%%
\begin{document}
Hello world.
\end{document}
""")
def test_simple_1(self):
figures.os_path = helpers.FakeOsPath([
# list of files that "exist"
'fig/intro.png',
'my_diagram.jpg',
'v088338-1993.out.eps',
'fignew/results schematic.pdf',
'fignew/results schematic 2.jpg'
])
lpp = helpers.MockLPP()
lpp.install_fix( figures.CopyAndRenameFigs() )
self.assertEqual(
lpp.execute(r"""
\includegraphics[width=\textwidth]{fig/intro}
\includegraphics[width=\textwidth]{my_diagram.jpg}
\includegraphics{fignew/results schematic}
\includegraphics{v088338-1993.out}
"""),
r"""
\includegraphics[width=\textwidth]{fig-01.png}
\includegraphics[width=\textwidth]{fig-02.jpg}
\includegraphics{fig-03.pdf}
\includegraphics{fig-04.eps}
"""
)
self.assertEqual(
lpp.copied_files,
[
('fig/intro.png', '/TESTOUT/fig-01.png'),
('my_diagram.jpg', '/TESTOUT/fig-02.jpg'),
('fignew/results schematic.pdf', '/TESTOUT/fig-03.pdf'),
('v088338-1993.out.eps', '/TESTOUT/fig-04.eps'),
]
)
def test_preprocess_recursively_3(self):
class MyFix(BaseFix):
def fix_node(self, n, **kwargs):
if n.isNodeType(latexwalker.LatexMacroNode):
#print("Try fix ", n)
if n.macroname == 'ket':
if n.nodeargd is None or not n.nodeargd.argnlist \
or not n.nodeargd.argnlist[0]:
return None
return r'| {' + self.preprocess_arg_latex(
n, 0) + r'} \rangle'
if n.macroname == r'rhostate':
return r'\hat\rho'
return None
latex = r"""\ket\rhostate"""
lpp = helpers.MockLPP()
myfix = MyFix()
lpp.install_fix(myfix)
lw = lpp.make_latex_walker(latex)
nodelist = lw.get_latex_nodes()[0]
newnodelist = myfix.preprocess(nodelist)
newlatex = "".join(nn.to_latex() for nn in newnodelist)
self.assertEqual(newlatex, r"""| {\hat\rho} \rangle""")
