Merge pull request #4313 from minrk/remove-math-space

remove strip_math_space, not usefull anymore with recent version of pandoc.

IPython/nbconvert/exporters/templateexporter.py

@@ -1,316 +1,315 b''
 """This module defines Exporter, a highly configurable converter
 that uses Jinja2 to export notebook files into different formats.
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import os
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader, TemplateNotFound
 
 # IPython imports
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Dict, Any
 from IPython.utils.importstring import import_item
 from IPython.utils import py3compat, text
 
 from IPython.nbconvert import filters
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': text.indent,
         'markdown2html': filters.markdown2html,
         'ansi2html': filters.ansi2html,
         'filter_data_type': filters.DataTypeFilter,
         'get_lines': filters.get_lines,
         'highlight2html': filters.highlight2html,
         'highlight2latex': filters.highlight2latex,
         'ipython2python': filters.ipython2python,
         'posix_path': filters.posix_path,
         'markdown2latex': filters.markdown2latex,
         'markdown2rst': filters.markdown2rst,
         'comment_lines': filters.comment_lines,
         'strip_ansi': filters.strip_ansi,
         'strip_dollars': filters.strip_dollars,
         'strip_files_prefix': filters.strip_files_prefix,
         'html2text' : filters.html2text,
         'add_anchor': filters.add_anchor,
         'ansi2latex': filters.ansi2latex,
-        'strip_math_space': filters.strip_math_space,
         'wrap_text': filters.wrap_text,
         'escape_latex': filters.escape_latex,
         'citation2latex': filters.citation2latex,
         'path2url': filters.path2url,
         'add_prompts': filters.add_prompts,
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TemplateExporter(Exporter):
     """
     Exports notebooks into other file formats.  Uses Jinja 2 templating engine
     to output new formats.  Inherit from this class if you are creating a new
     template type along with new filters/preprocessors.  If the filters/
     preprocessors provided by default suffice, there is no need to inherit from
     this class.  Instead, override the template_file and file_extension
     traits via a config file.
 
     {filters}
     """
     
     # finish the docstring
     __doc__ = __doc__.format(filters = '- '+'\n    - '.join(default_filters.keys()))
 
 
     template_file = Unicode(u'default',
             config=True,
             help="Name of the template file to use")
     def _template_file_changed(self, name, old, new):
         if new == 'default':
             self.template_file = self.default_template
         else:
             self.template_file = new
         self.template = None
         self._load_template()
     
     default_template = Unicode(u'')
     template = Any()
     environment = Any()
 
     template_path = List(['.'], config=True)
     def _template_path_changed(self, name, old, new):
         self._load_template()
 
     default_template_path = Unicode(
         os.path.join("..", "templates"), 
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "skeleton"), 
         help="Path where the template skeleton files are located.") 
 
     #Jinja block definitions
     jinja_comment_block_start = Unicode("", config=True)
     jinja_comment_block_end = Unicode("", config=True)
     jinja_variable_block_start = Unicode("", config=True)
     jinja_variable_block_end = Unicode("", config=True)
     jinja_logic_block_start = Unicode("", config=True)
     jinja_logic_block_end = Unicode("", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tpl", config=True)
 
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
 
 
     def __init__(self, config=None, extra_loaders=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
         config : config
             User configuration instance.
         extra_loaders : list[of Jinja Loaders]
             ordered list of Jinja loader to find templates. Will be tried in order
             before the default FileSystem ones.
         template : str (optional, kw arg)
             Template to use when exporting.
         """
         if not config:
             config = self.default_config
         
         super(Exporter, self).__init__(config=config, **kw)
 
         #Init
         self._init_template()
         self._init_environment(extra_loaders=extra_loaders)
         self._init_preprocessors()
         self._init_filters()
 
 
     def _load_template(self):
         """Load the Jinja template object from the template file
         
         This is a no-op if the template attribute is already defined,
         or the Jinja environment is not setup yet.
         
         This is triggered by various trait changes that would change the template.
         """
         if self.template is not None:
             return
         # called too early, do nothing
         if self.environment is None:
             return
         # Try different template names during conversion.  First try to load the
         # template by name with extension added, then try loading the template
         # as if the name is explicitly specified, then try the name as a 
         # 'flavor', and lastly just try to load the template by module name.
         module_name = self.__module__.rsplit('.', 1)[-1]
         try_names = []
         if self.template_file:
             try_names.extend([
                 self.template_file + self.template_extension,
                 self.template_file,
                 module_name + '_' + self.template_file + self.template_extension,
             ])
         try_names.append(module_name + self.template_extension)
         for try_name in try_names:
             self.log.debug("Attempting to load template %s", try_name)
             try:
                 self.template = self.environment.get_template(try_name)
             except (TemplateNotFound, IOError):
                 pass
             except Exception as e:
                 self.log.warn("Unexpected exception loading template: %s", try_name, exc_info=True)
             else:
                 self.log.info("Loaded template %s", try_name)
                 break
     
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : Notebook node
         resources : dict (**kw) 
             of additional resources that can be accessed read/write by 
             preprocessors and filters.
         """
         nb_copy, resources = super(TemplateExporter, self).from_notebook_node(nb, resources, **kw)
 
         self._load_template()
 
         if self.template is not None:
             output = self.template.render(nb=nb_copy, resources=resources)
         else:
             raise IOError('template file "%s" could not be found' % self.template_file)
         return output, resources
 
 
     def register_filter(self, name, jinja_filter):
         """
         Register a filter.
         A filter is a function that accepts and acts on one string.  
         The filters are accesible within the Jinja templating engine.
     
         Parameters
         ----------
         name : str
             name to give the filter in the Jinja engine
         filter : filter
         """
         if jinja_filter is None:
             raise TypeError('filter')
         isclass = isinstance(jinja_filter, type)
         constructed = not isclass
 
         #Handle filter's registration based on it's type
         if constructed and isinstance(jinja_filter, py3compat.string_types):
             #filter is a string, import the namespace and recursively call
             #this register_filter method
             filter_cls = import_item(jinja_filter)
             return self.register_filter(name, filter_cls)
         
         if constructed and hasattr(jinja_filter, '__call__'):
             #filter is a function, no need to construct it.
             self.environment.filters[name] = jinja_filter
             return jinja_filter
 
         elif isclass and isinstance(jinja_filter, MetaHasTraits):
             #filter is configurable.  Make sure to pass in new default for 
             #the enabled flag if one was specified.
             filter_instance = jinja_filter(parent=self)
             self.register_filter(name, filter_instance )
 
         elif isclass:
             #filter is not configurable, construct it
             filter_instance = jinja_filter()
             self.register_filter(name, filter_instance)
 
         else:
             #filter is an instance of something without a __call__ 
             #attribute.  
             raise TypeError('filter')
 
         
     def _init_template(self):
         """
         Make sure a template name is specified.  If one isn't specified, try to
         build one from the information we know.
         """
         self._template_file_changed('template_file', self.template_file, self.template_file)
         
 
     def _init_environment(self, extra_loaders=None):
         """
         Create the Jinja templating environment.
         """
         here = os.path.dirname(os.path.realpath(__file__))
         loaders = []
         if extra_loaders:
             loaders.extend(extra_loaders)
 
         paths = self.template_path
         paths.extend([os.path.join(here, self.default_template_path),
                       os.path.join(here, self.template_skeleton_path)])
         loaders.append(FileSystemLoader(paths))
 
         self.environment = Environment(
             loader= ChoiceLoader(loaders),
             extensions=JINJA_EXTENSIONS
             )
         
         #Set special Jinja2 syntax that will not conflict with latex.
         if self.jinja_logic_block_start:
             self.environment.block_start_string = self.jinja_logic_block_start
         if self.jinja_logic_block_end:
             self.environment.block_end_string = self.jinja_logic_block_end
         if self.jinja_variable_block_start:
             self.environment.variable_start_string = self.jinja_variable_block_start
         if self.jinja_variable_block_end:
             self.environment.variable_end_string = self.jinja_variable_block_end
         if self.jinja_comment_block_start:
             self.environment.comment_start_string = self.jinja_comment_block_start
         if self.jinja_comment_block_end:
             self.environment.comment_end_string = self.jinja_comment_block_end
 
     
     def _init_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Add default filters to the Jinja2 environment
         for key, value in default_filters.items():
             self.register_filter(key, value)
 
         #Load user filters.  Overwrite existing filters if need be.
         if self.filters:
             for key, user_filter in self.filters.items():
                 self.register_filter(key, user_filter)

IPython/nbconvert/filters/latex.py

@@ -1,123 +1,63 b''
 """Latex filters.
 
 Module of useful filters for processing Latex within Jinja latex templates.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import re
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 LATEX_RE_SUBS = (
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 # Latex substitutions for escaping latex.
 # see: http://stackoverflow.com/questions/16259923/how-can-i-escape-latex-special-characters-inside-django-templates
 
 LATEX_SUBS = {
     '&':  r'\&',
     '%':  r'\%',
     '$':  r'\$',
     '#':  r'\#',
     '_':  r'\_',
     '{':  r'\{',
     '}':  r'\}',
     '~':  r'\textasciitilde{}',
     '^':  r'\^{}',
     '\\': r'\textbackslash{}',
 }
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
-__all__ = ['escape_latex',
-           'strip_math_space']
+__all__ = ['escape_latex']
 
 def escape_latex(text):
     """
     Escape characters that may conflict with latex.
 
     Parameters
     ----------
     text : str
         Text containing characters that may conflict with Latex
     """
     text = ''.join(LATEX_SUBS.get(c, c) for c in text)
     for pattern, replacement in LATEX_RE_SUBS:
         text = pattern.sub(replacement, text)
 
     return text
-    
-    
-def strip_math_space(text):
-    """
-    Remove the space between latex math commands and enclosing $ symbols.
-    This filter is important because latex isn't as flexible as the notebook
-    front end when it comes to flagging math using ampersand symbols.
-    
-    Parameters
-    ----------
-    text : str
-        Text to filter.
-    """
-
-    # First, scan through the markdown looking for $.  If
-    # a $ symbol is found, without a preceding \, assume
-    # it is the start of a math block.  UNLESS that $ is
-    # not followed by another within two math_lines.
-    math_regions = []
-    math_lines = 0
-    within_math = False
-    math_start_index = 0
-    ptext = ''
-    last_character = ""
-    skip = False
-    for index, char in enumerate(text):
-
-        #Make sure the character isn't preceeded by a backslash
-        if (char == "$" and last_character != "\\"):
-
-            # Close the math region if this is an ending $
-            if within_math:
-                within_math = False
-                skip = True
-                ptext = ptext+'$'+text[math_start_index+1:index].strip()+'$'
-                math_regions.append([math_start_index, index+1])
-            else:
-
-                # Start a new math region
-                within_math = True
-                math_start_index = index
-                math_lines = 0
-
-        # If we are in a math region, count the number of lines parsed.
-        # Cancel the math region if we find two line breaks!
-        elif char == "\n":
-            if within_math:
-                math_lines += 1
-                if math_lines > 1:
-                    within_math = False
-                    ptext = ptext+text[math_start_index:index]
 
-        # Remember the last character so we can easily watch
-        # for backslashes
-        last_character = char
-        if not within_math and not skip:
-            ptext = ptext+char
-        if skip:
-            skip = False
-    return ptext

IPython/nbconvert/filters/tests/test_latex.py

@@ -1,66 +1,45 b''
 """
 Module with tests for Latex
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from ...tests.base import TestsBase
-from ..latex import escape_latex, strip_math_space
+from ..latex import escape_latex
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestLatex(TestsBase):
 
 
     def test_escape_latex(self):
         """escape_latex test"""
         tests = [
             (r'How are \you doing today?', r'How are \textbackslash{}you doing today?'),
             (r'\escapechar=`\A\catcode`\|=0 |string|foo', r'\textbackslash{}escapechar=`\textbackslash{}A\textbackslash{}catcode`\textbackslash{}|=0 |string|foo'),
             (r'# $ % & ~ _ ^ \ { }', r'\# \$ \% \& \textasciitilde{} \_ \^{} \textbackslash{} \{ \}'),
             ('...', r'\ldots'),
             ('','')]
 
         for test in tests:
             self._try_escape_latex(test[0], test[1])
 
 
     def _try_escape_latex(self, test, result):
         """Try to remove latex from string"""
         self.assertEqual(escape_latex(test), result)
 
 
-    def test_strip_math_space(self):
-        """strip_math_space test"""
-        tests = [
-            ('$e$','$e$'),
-            ('$ e $','$e$'),
-            ('xxx$e^i$yyy','xxx$e^i$yyy'),
-            ('xxx$ e^i $yyy','xxx$e^i$yyy'),
-            ('xxx$e^i $yyy','xxx$e^i$yyy'),
-            ('xxx$ e^i$yyy','xxx$e^i$yyy'),
-            ('\$ e $ e $','\$ e $e$'),
-            ('','')]
-
-        for test in tests:
-            self._try_strip_math_space(test[0], test[1])
-
-
-    def _try_strip_math_space(self, test, result):
-        """
-        Try to remove spaces between dollar symbols and contents correctly
-        """
-        self.assertEqual(strip_math_space(test), result)

IPython/nbconvert/preprocessors/latex.py

@@ -1,74 +1,47 b''
 """Module that allows latex output notebooks to be conditioned before
 they are converted.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
-import os
 
-# Third-party import, needed for Pygments latex definitions.
-from pygments.formatters import LatexFormatter
-
-# ipy imports
-from .base import (Preprocessor)
-from IPython.nbconvert import filters
+from .base import Preprocessor
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class LatexPreprocessor(Preprocessor):
-    """
-    Converter for latex destined documents.
+    """Preprocessor for latex destined documents.
+    
+    Mainly populates the `latex` key in the resources dict,
+    adding definitions for pygments highlight styles.
     """
 
     def preprocess(self, nb, resources):
-        """
-        Preprocessing to apply on each notebook.
+        """Preprocessing to apply on each notebook.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             preprocessors to pass variables into the Jinja engine.
         """
-        # Generate Pygments definitions for Latex 
-        resources["latex"] = {}
-        resources["latex"]["pygments_definitions"] = LatexFormatter().get_style_defs()
-        return super(LatexPreprocessor, self).preprocess(nb, resources)
-
-
-    def preprocess_cell(self, cell, resources, index):
-        """
-        Apply a transformation on each cell,
-        
-        Parameters
-        ----------
-        cell : NotebookNode cell
-            Notebook cell being processed
-        resources : dictionary
-            Additional resources used in the conversion process.  Allows
-            preprocessors to pass variables into the Jinja engine.
-        index : int
-            Modified index of the cell being processed (see base.py)
-        """
+        # Generate Pygments definitions for Latex
+        from pygments.formatters import LatexFormatter
         
-        #If the cell is a markdown cell, preprocess the ampersands used to
-        #remove the space between them and their contents.  Latex will complain
-        #if spaces exist between the ampersands and the math content.  
-        #See filters.latex.rm_math_space for more information.
-        if hasattr(cell, "source") and cell.cell_type == "markdown":
-            cell.source = filters.strip_math_space(cell.source)
-        return cell, resources
+        resources.setdefault("latex", {})
+        resources["latex"].setdefault("pygments_definitions", LatexFormatter().get_style_defs())
+        return nb, resources

IPython/nbconvert/preprocessors/tests/test_latex.py

@@ -1,51 +1,51 b''
 """
 Module with tests for the latex preprocessor
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from .base import PreprocessorTestsBase
 from ..latex import LatexPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestLatex(PreprocessorTestsBase):
     """Contains test functions for latex.py"""
 
 
     def build_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = LatexPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
     def test_constructor(self):
         """Can a LatexPreprocessor be constructed?"""
         self.build_preprocessor()
         
 
     def test_output(self):
         """Test the output of the LatexPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
         preprocessor = self.build_preprocessor()
         nb, res = preprocessor(nb, res)
 
         # Make sure the code cell wasn't modified.
         self.assertEqual(nb.worksheets[0].cells[0].input, '$ e $')
 
-        # Verify that the markdown cell was processed.
-        self.assertEqual(nb.worksheets[0].cells[1].source, '$e$')
+        # Verify that the markdown cell wasn't processed.
+        self.assertEqual(nb.worksheets[0].cells[1].source, '$ e $')

IPython/nbconvert/templates/html_basic.tpl

@@ -1,148 +1,148 b''
 {%- extends 'display_priority.tpl' -%}
 
 
 {% block codecell %}
 <div class="cell border-box-sizing code_cell vbox">
 {{ super() }}
 </div>
 {%- endblock codecell %}
 
 {% block input_group -%}
 <div class="input hbox">
 {{ super() }}
 </div>
 {% endblock input_group %}
 
 {% block output_group %}
 <div class="vbox output_wrapper">
 <div class="output vbox">
 {{ super() }}
 </div>
 </div>
 {% endblock output_group %}
 
 {% block in_prompt -%}
 <div class="prompt input_prompt">
 In&nbsp;[{{ cell.prompt_number }}]:
 </div>
 {%- endblock in_prompt %}
 
 {# 
   output_prompt doesn't do anything in HTML,
   because there is a prompt div in each output area (see output block)
 #}
 {% block output_prompt %}
 {% endblock output_prompt %}
 
 {% block input %}
 <div class="input_area box-flex1">
 {{ cell.input | highlight2html(metadata=cell.metadata) }}
 </div>
 {%- endblock input %}
 
 {% block output %}
 <div class="hbox output_area">
 {%- if output.output_type == 'pyout' -%}
     <div class="prompt output_prompt">
     Out[{{ cell.prompt_number }}]:
 {%- else -%}
     <div class="prompt">
 {%- endif -%}
     </div>
 {{ super() }}
 </div>
 {% endblock output %}
 
 {% block markdowncell scoped %}
 <div class="text_cell_render border-box-sizing rendered_html">
-{{ cell.source | strip_math_space | markdown2html | strip_files_prefix }}
+{{ cell.source  | markdown2html | strip_files_prefix }}
 </div>
 {%- endblock markdowncell %}
 
 {% block headingcell scoped %}
 <div class="text_cell_render border-box-sizing rendered_html">
-{{ ("#" * cell.level + cell.source) | replace('\n', ' ') | strip_math_space | markdown2html | strip_files_prefix | add_anchor }}
+{{ ("#" * cell.level + cell.source) | replace('\n', ' ')  | markdown2html | strip_files_prefix | add_anchor }}
 </div>
 {% endblock headingcell %}
 
 {% block rawcell scoped %}
 {{ cell.source }}
 {% endblock rawcell %}
 
 {% block unknowncell scoped %}
 unknown type  {{ cell.type }}
 {% endblock unknowncell %}
 
 {% block pyout -%}
 <div class="box-flex1 output_subarea output_pyout">
 {% block data_priority scoped %}
 {{ super() }}
 {% endblock %}
 </div>
 {%- endblock pyout %}
 
 {% block stream_stdout -%}
 <div class="box-flex1 output_subarea output_stream output_stdout">
 <pre>
 {{ output.text | ansi2html }}
 </pre>
 </div>
 {%- endblock stream_stdout %}
 
 {% block stream_stderr -%}
 <div class="box-flex1 output_subarea output_stream output_stderr">
 <pre>
 {{ output.text | ansi2html }}
 </pre>
 </div>
 {%- endblock stream_stderr %}
 
 {% block data_svg -%}
 {{ output.svg }}
 {%- endblock data_svg %}
 
 {% block data_html -%}
 <div class="output_html rendered_html">
 {{ output.html }}
 </div>
 {%- endblock data_html %}
 
 {% block data_png %}
 <img src="data:image/png;base64,{{ output.png }}">
 {%- endblock data_png %}
 
 {% block data_jpg %}
 <img src="data:image/jpeg;base64,{{ output.jpeg }}">
 {%- endblock data_jpg %}
 
 {% block data_latex %}
 {{ output.latex }}
 {%- endblock data_latex %}
 
 {% block pyerr -%}
 <div class="box-flex1 output_subarea output_pyerr">
 <pre>{{ super() }}</pre>
 </div>
 {%- endblock pyerr %}
 
 {%- block traceback_line %}
 {{ line | ansi2html }}
 {%- endblock traceback_line %}
 
 {%- block data_text %}
 <pre>
 {{ output.text | ansi2html }}
 </pre>
 {%- endblock -%}
 
 {%- block data_javascript %}
 <script type="text/javascript">
 {{ output.javascript }}
 </script>
 {%- endblock -%}
 
 {%- block display_data scoped -%}
 <div class="box-flex1 output_subarea output_display_data">
 {{ super() }}
 </div>
 {%- endblock display_data -%}
  No newline at end of file