replace 'transformer' with 'preprocessor'

IPython/nbconvert/__init__.py

@@ -1,7 +1,7 b''
 """Utilities for converting notebooks to and from different formats."""
 
 from .exporters import *
 import filters
-import transformers
+import preprocessors
 import post_processors
 import writers

IPython/nbconvert/exporters/exporter.py

@@ -1,518 +1,518 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 io
 import os
 import inspect
 import copy
 import collections
 import datetime
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader, TemplateNotFound
 
 # IPython imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, DottedObjectName, Unicode, List, Dict, Any
 from IPython.utils.importstring import import_item
 from IPython.utils.text import indent
 from IPython.utils import py3compat
 
-from IPython.nbconvert import transformers as nbtransformers
+from IPython.nbconvert import preprocessors as nbpreprocessors
 from IPython.nbconvert import filters
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': 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,
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class Exporter(LoggingConfigurable):
     """
     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/transformers.  If the filters/
-    transformers provided by default suffice, there is no need to inherit from
+    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()
 
     file_extension = Unicode(
         'txt', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     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)
 
-    #Configurability, allows the user to easily add filters and transformers.
-    transformers = List(config=True,
-        help="""List of transformers, by name or namespace, to enable.""")
+    #Configurability, allows the user to easily add filters and preprocessors.
+    preprocessors = List(config=True,
+        help="""List of preprocessors, by name or namespace, to enable.""")
 
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
 
-    default_transformers = List([nbtransformers.coalesce_streams,
-                                 nbtransformers.SVG2PDFTransformer,
-                                 nbtransformers.ExtractOutputTransformer,
-                                 nbtransformers.CSSHTMLHeaderTransformer,
-                                 nbtransformers.RevealHelpTransformer,
-                                 nbtransformers.LatexTransformer,
-                                 nbtransformers.SphinxTransformer],
+    default_preprocessors = List([nbpreprocessors.coalesce_streams,
+                                 nbpreprocessors.SVG2PDFPreprocessor,
+                                 nbpreprocessors.ExtractOutputPreprocessor,
+                                 nbpreprocessors.CSSHTMLHeaderPreprocessor,
+                                 nbpreprocessors.RevealHelpPreprocessor,
+                                 nbpreprocessors.LatexPreprocessor,
+                                 nbpreprocessors.SphinxPreprocessor],
         config=True,
-        help="""List of transformers available by default, by name, namespace, 
+        help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     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_transformers()
+        self._init_preprocessors()
         self._init_filters()
 
 
     @property
     def default_config(self):
         return Config()
     
     def _config_changed(self, name, old, new):
         """When setting config, make sure to start with our default_config"""
         c = self.default_config
         if new:
             c.merge(new)
         if c != old:
             self.config = c
         super(Exporter, self)._config_changed(name, old, c)
         
 
     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 
-            transformers and filters.
+            preprocessors and filters.
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
 
         # Preprocess
-        nb_copy, resources = self._transform(nb_copy, resources)
+        nb_copy, resources = self._preprocess(nb_copy, resources)
 
         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 from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         #Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime("%B %d, %Y")
         
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources,**kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
-    def register_transformer(self, transformer, enabled=False):
+    def register_preprocessor(self, preprocessor, enabled=False):
         """
-        Register a transformer.
-        Transformers are classes that act upon the notebook before it is
-        passed into the Jinja templating engine.  Transformers are also
+        Register a preprocessor.
+        Preprocessors are classes that act upon the notebook before it is
+        passed into the Jinja templating engine.  Preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
     
         Parameters
         ----------
-        transformer : transformer
+        preprocessor : preprocessor
         """
-        if transformer is None:
-            raise TypeError('transformer')
-        isclass = isinstance(transformer, type)
+        if preprocessor is None:
+            raise TypeError('preprocessor')
+        isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
-        #Handle transformer's registration based on it's type
-        if constructed and isinstance(transformer, py3compat.string_types):
-            #Transformer is a string, import the namespace and recursively call
-            #this register_transformer method
-            transformer_cls = import_item(transformer)
-            return self.register_transformer(transformer_cls, enabled)
+        #Handle preprocessor's registration based on it's type
+        if constructed and isinstance(preprocessor, py3compat.string_types):
+            #Preprocessor is a string, import the namespace and recursively call
+            #this register_preprocessor method
+            preprocessor_cls = import_item(preprocessor)
+            return self.register_preprocessor(preprocessor_cls, enabled)
         
-        if constructed and hasattr(transformer, '__call__'):
-            #Transformer is a function, no need to construct it.
-            #Register and return the transformer.
+        if constructed and hasattr(preprocessor, '__call__'):
+            #Preprocessor is a function, no need to construct it.
+            #Register and return the preprocessor.
             if enabled:
-                transformer.enabled = True
-            self._transformers.append(transformer)
-            return transformer
+                preprocessor.enabled = True
+            self._preprocessors.append(preprocessor)
+            return preprocessor
 
-        elif isclass and isinstance(transformer, MetaHasTraits):
-            #Transformer is configurable.  Make sure to pass in new default for 
+        elif isclass and isinstance(preprocessor, MetaHasTraits):
+            #Preprocessor is configurable.  Make sure to pass in new default for 
             #the enabled flag if one was specified.
-            self.register_transformer(transformer(parent=self), enabled)
+            self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
-            #Transformer is not configurable, construct it
-            self.register_transformer(transformer(), enabled)
+            #Preprocessor is not configurable, construct it
+            self.register_preprocessor(preprocessor(), enabled)
 
         else:
-            #Transformer is an instance of something without a __call__ 
+            #Preprocessor is an instance of something without a __call__ 
             #attribute.  
-            raise TypeError('transformer')
+            raise TypeError('preprocessor')
 
 
     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_transformers(self):
+    def _init_preprocessors(self):
         """
-        Register all of the transformers needed for this exporter, disabled
+        Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
-        self._transformers = []
+        self._preprocessors = []
 
-        #Load default transformers (not necessarly enabled by default).
-        if self.default_transformers:
-            for transformer in self.default_transformers:
-                self.register_transformer(transformer)
+        #Load default preprocessors (not necessarly enabled by default).
+        if self.default_preprocessors:
+            for preprocessor in self.default_preprocessors:
+                self.register_preprocessor(preprocessor)
 
-        #Load user transformers.  Enable by default.
-        if self.transformers:
-            for transformer in self.transformers:
-                self.register_transformer(transformer, enabled=True)
+        #Load user preprocessors.  Enable by default.
+        if self.preprocessors:
+            for preprocessor in self.preprocessors:
+                self.register_preprocessor(preprocessor, enabled=True)
  
 
     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)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources 
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']: 
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
         
 
-    def _transform(self, nb, resources):
+    def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the 
     
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
-            can be accessed read/write by transformers
+            can be accessed read/write by preprocessors
             and filters.
         """
         
         # Do a copy.deepcopy first, 
-        # we are never safe enough with what the transformers could do.
+        # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
-        #Run each transformer on the notebook.  Carry the output along
-        #to each transformer
-        for transformer in self._transformers:
-            nbc, resc = transformer(nbc, resc)
+        #Run each preprocessor on the notebook.  Carry the output along
+        #to each preprocessor
+        for preprocessor in self._preprocessors:
+            nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/html.py

@@ -1,52 +1,52 b''
 """
 Exporter that exports Basic HTML.
 """
 
 #-----------------------------------------------------------------------------
 # 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 IPython.utils.traitlets import Unicode, List
 
-from IPython.nbconvert import transformers
+from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class HTMLExporter(Exporter):
     """
     Exports a basic HTML document.  This exporter assists with the export of
     HTML.  Inherit from it if you are writing your own HTML template and need
-    custom transformers/filters.  If you don't need custom transformers/
+    custom preprocessors/filters.  If you don't need custom preprocessors/
     filters, just change the 'template_file' config option.  
     """
     
     file_extension = Unicode(
         'html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     default_template = Unicode('full', config=True, help="""Flavor of the data 
         format to use.  I.E. 'full' or 'basic'""")
 
     @property
     def default_config(self):
         c = Config({
-            'CSSHTMLHeaderTransformer':{
+            'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 }          
             })
         c.merge(super(HTMLExporter,self).default_config)
         return c

IPython/nbconvert/exporters/latex.py

@@ -1,91 +1,91 b''
 """
 Exporter that allows Latex Jinja templates to work.  Contains logic to
 appropriately prepare IPYNB files for export to LaTeX.  Including but 
 not limited to escaping LaTeX, fixing math region tags, using special
 tags to circumvent Jinja/Latex syntax conflicts.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 
 # IPython imports
 from IPython.utils.traitlets import Unicode, List
 from IPython.config import Config
 
-from IPython.nbconvert import filters, transformers
+from IPython.nbconvert import filters, preprocessors
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class LatexExporter(Exporter):
     """
     Exports to a Latex template.  Inherit from this class if your template is
     LaTeX based and you need custom tranformers/filters.  Inherit from it if 
     you are writing your own HTML template and need custom tranformers/filters.  
     If you don't need custom tranformers/filters, just change the 
     'template_file' config option.  Place your template in the special "/latex" 
     subfolder of the "../templates" folder.
     """
     
     file_extension = Unicode(
         'tex', config=True, 
         help="Extension of the file that should be written to disk")
 
     default_template = Unicode('article', config=True, help="""Template of the 
         data format to use.  I.E. 'full' or 'basic'""")
 
     #Latex constants
     default_template_path = Unicode(
         os.path.join("..", "templates", "latex"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "latex", "skeleton"), config=True,
         help="Path where the template skeleton files are located.") 
 
     #Special Jinja2 syntax that will not conflict when exporting latex.
     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(".tplx", config=True)
 
 
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['latex', 'pdf', 'png', 'jpg', 'svg', 'jpeg', 'text']
                 },
-             'ExtractOutputTransformer': {
+             'ExtractOutputPreprocessor': {
                     'enabled':True
                  },
-             'SVG2PDFTransformer': {
+             'SVG2PDFPreprocessor': {
                     'enabled':True
                  },
-             'LatexTransformer': {
+             'LatexPreprocessor': {
                     'enabled':True
                  },
-             'SphinxTransformer': {
+             'SphinxPreprocessor': {
                     'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c

IPython/nbconvert/exporters/rst.py

@@ -1,38 +1,38 b''
 """
 Exporter for exporting notebooks to restructured text.
 """
 #-----------------------------------------------------------------------------
 # 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 IPython.utils.traitlets import Unicode
 from IPython.config import Config
 
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class RSTExporter(Exporter):
     """
     Exports restructured text documents.
     """
     
     file_extension = Unicode(
         'rst', config=True, 
         help="Extension of the file that should be written to disk")
 
     @property
     def default_config(self):
-        c = Config({'ExtractOutputTransformer':{'enabled':True}})
+        c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(RSTExporter,self).default_config)
         return c

IPython/nbconvert/exporters/slides.py

@@ -1,52 +1,52 b''
 """
 Contains slide show exporter
 """
 
 #-----------------------------------------------------------------------------
 # 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 IPython.utils.traitlets import Unicode
 
-from IPython.nbconvert import transformers
+from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SlidesExporter(Exporter):
     """
     Exports slides
     """
     
     file_extension = Unicode(
         'slides.html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     default_template = Unicode('reveal', config=True, help="""Template of the 
         data format to use.  I.E. 'reveal'""")
 
     @property
     def default_config(self):
         c = Config({
-            'CSSHTMLHeaderTransformer':{
+            'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 },
-            'RevealHelpTransformer':{
+            'RevealHelpPreprocessor':{
                 'enabled':True,
                 },                
             })
         c.merge(super(SlidesExporter,self).default_config)
         return c

IPython/nbconvert/exporters/tests/cheese.py

@@ -1,48 +1,48 b''
 """
-Contains CheeseTransformer
+Contains CheesePreprocessor
 """
 #-----------------------------------------------------------------------------
 # 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 ...transformers.base import Transformer
+from ...preprocessors.base import Preprocessor
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class CheeseTransformer(Transformer):
+class CheesePreprocessor(Preprocessor):
     """
     Adds a cheese tag to the resources object
     """
 
 
     def __init__(self, **kw):
         """
         Public constructor
         """
-        super(CheeseTransformer, self).__init__(**kw)
+        super(CheesePreprocessor, self).__init__(**kw)
 
 
-    def transform(self, nb, resources):
+    def preprocess(self, nb, resources):
         """
-        Sphinx transformation to apply on each notebook.
+        Sphinx preprocessing to apply on each notebook.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         """
         resources['cheese'] = 'real'
         return nb, resources

IPython/nbconvert/exporters/tests/test_exporter.py

@@ -1,108 +1,108 b''
 """
 Module with tests for exporter.py
 """
 
 #-----------------------------------------------------------------------------
 # 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 IPython.config import Config
 
 from .base import ExportersTestsBase
-from .cheese import CheeseTransformer
+from .cheese import CheesePreprocessor
 from ..exporter import Exporter
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestExporter(ExportersTestsBase):
     """Contains test functions for exporter.py"""
 
 
     def test_constructor(self):
         """
         Can an Exporter be constructed?
         """
         Exporter()
 
 
     def test_export(self):
         """
         Can an Exporter export something?
         """
         exporter = self._make_exporter()
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     def test_extract_outputs(self):
         """
-        If the ExtractOutputTransformer is enabled, are outputs extracted?
+        If the ExtractOutputPreprocessor is enabled, are outputs extracted?
         """
-        config = Config({'ExtractOutputTransformer': {'enabled': True}})
+        config = Config({'ExtractOutputPreprocessor': {'enabled': True}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert isinstance(resources['outputs'], dict)
         assert len(resources['outputs']) > 0
 
 
-    def test_transformer_class(self):
+    def test_preprocessor_class(self):
         """
-        Can a transformer be added to the transformers list by class type?
+        Can a preprocessor be added to the preprocessors list by class type?
         """
-        config = Config({'Exporter': {'transformers': [CheeseTransformer]}})
+        config = Config({'Exporter': {'preprocessors': [CheesePreprocessor]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
-    def test_transformer_instance(self):
+    def test_preprocessor_instance(self):
         """
-        Can a transformer be added to the transformers list by instance?
+        Can a preprocessor be added to the preprocessors list by instance?
         """
-        config = Config({'Exporter': {'transformers': [CheeseTransformer()]}})
+        config = Config({'Exporter': {'preprocessors': [CheesePreprocessor()]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
-    def test_transformer_dottedobjectname(self):
+    def test_preprocessor_dottedobjectname(self):
         """
-        Can a transformer be added to the transformers list by dotted object name?
+        Can a preprocessor be added to the preprocessors list by dotted object name?
         """
-        config = Config({'Exporter': {'transformers': ['IPython.nbconvert.exporters.tests.cheese.CheeseTransformer']}})
+        config = Config({'Exporter': {'preprocessors': ['IPython.nbconvert.exporters.tests.cheese.CheesePreprocessor']}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
-    def test_transformer_via_method(self):
+    def test_preprocessor_via_method(self):
         """
-        Can a transformer be added via the Exporter convenience method?
+        Can a preprocessor be added via the Exporter convenience method?
         """
         exporter = self._make_exporter()
-        exporter.register_transformer(CheeseTransformer, enabled=True)
+        exporter.register_preprocessor(CheesePreprocessor, enabled=True)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
         assert resources['cheese'] == 'real'
 
 
     def _make_exporter(self, config=None):
         #Create the exporter instance, make sure to set a template name since
         #the base Exporter doesn't have a template associated with it.
         exporter = Exporter(config=config, template_file='python')
-        return exporter        
  No newline at end of file
+        return exporter        

IPython/nbconvert/nbconvertapp.py

@@ -1,322 +1,322 b''
 #!/usr/bin/env python
 """NBConvert is a utility for conversion of .ipynb files.
 
 Command-line interface for the NbConvert conversion utility.
 """
 #-----------------------------------------------------------------------------
 #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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 from __future__ import print_function
 
 import logging
 import sys
 import os
 import glob
 
 # From IPython
 from IPython.core.application import BaseIPythonApplication, base_aliases, base_flags
 from IPython.config import catch_config_error, Configurable
 from IPython.utils.traitlets import (
     Unicode, List, Instance, DottedObjectName, Type, CaselessStrEnum,
 )
 from IPython.utils.importstring import import_item
 from IPython.utils.text import dedent
 
 from .exporters.export import get_export_names, exporter_map
-from IPython.nbconvert import exporters, transformers, writers, post_processors
+from IPython.nbconvert import exporters, preprocessors, writers, post_processors
 from .utils.base import NbConvertBase
 from .utils.exceptions import ConversionException
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 class DottedOrNone(DottedObjectName):
     """
     A string holding a valid dotted object name in Python, such as A.b3._c
     Also allows for None type."""
     
     default_value = u''
 
     def validate(self, obj, value):
         if value is not None and len(value) > 0:
             return super(DottedOrNone, self).validate(obj, value)
         else:
             return value
             
 nbconvert_aliases = {}
 nbconvert_aliases.update(base_aliases)
 nbconvert_aliases.update({
     'to' : 'NbConvertApp.export_format',
     'template' : 'Exporter.template_file',
     'writer' : 'NbConvertApp.writer_class',
     'post': 'NbConvertApp.post_processor_class',
     'output': 'NbConvertApp.output_base',
     'offline-slides': 'RevealHelpTransformer.url_prefix',
     'slide-notes': 'RevealHelpTransformer.speaker_notes'
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'stdout' : (
         {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
         "Write notebook output to stdout instead of files."
         )
 })
 
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert to and from notebook file type (*.ipynb)"""
 
     name = 'ipython-nbconvert'
     aliases = nbconvert_aliases
     flags = nbconvert_flags
     
     def _log_level_default(self):
         return logging.INFO
     
     def _classes_default(self):
         classes = [NbConvertBase]
-        for pkg in (exporters, transformers, writers):
+        for pkg in (exporters, preprocessors, writers):
             for name in dir(pkg):
                 cls = getattr(pkg, name)
                 if isinstance(cls, type) and issubclass(cls, Configurable):
                     classes.append(cls)
         return classes
 
     description = Unicode(
         u"""This application is used to convert notebook files (*.ipynb)
         to various other formats.
 
         WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.""")
 
     output_base = Unicode('', config=True, help='''overwrite base name use for output files.
             can only  be use when converting one notebook at a time.
             ''')
 
     examples = Unicode(u"""
         The simplest way to use nbconvert is
         
         > ipython nbconvert mynotebook.ipynb
         
         which will convert mynotebook.ipynb to the default format (probably HTML).
         
         You can specify the export format with `--to`.
         Options include {0}
         
         > ipython nbconvert --to latex mynotebook.ipnynb
 
         Both HTML and LaTeX support multiple output templates. LaTeX includes
         'basic', 'book', and 'article'.  HTML includes 'basic' and 'full'.  You 
         can specify the flavor of the format used.
 
         > ipython nbconvert --to html --template basic mynotebook.ipynb
         
         You can also pipe the output to stdout, rather than a file
         
         > ipython nbconvert mynotebook.ipynb --stdout
 
         A post-processor can be used to compile a PDF
 
         > ipython nbconvert mynotebook.ipynb --to latex --post PDF
         
         You can get (and serve) a Reveal.js-powered slideshow
         
         > ipython nbconvert myslides.ipynb --to slides --post serve
         
         Multiple notebooks can be given at the command line in a couple of 
         different ways:
   
         > ipython nbconvert notebook*.ipynb
         > ipython nbconvert notebook1.ipynb notebook2.ipynb
         
         or you can specify the notebooks list in a config file, containing::
         
             c.NbConvertApp.notebooks = ["my_notebook.ipynb"]
         
         > ipython nbconvert --config mycfg.py
         """.format(get_export_names()))
 
     # Writer specific variables
     writer = Instance('IPython.nbconvert.writers.base.WriterBase',  
                       help="""Instance of the writer class used to write the 
                       results of the conversion.""")
     writer_class = DottedObjectName('FilesWriter', config=True, 
                                     help="""Writer class used to write the 
                                     results of the conversion""")
     writer_aliases = {'fileswriter': 'IPython.nbconvert.writers.files.FilesWriter',
                       'debugwriter': 'IPython.nbconvert.writers.debug.DebugWriter',
                       'stdoutwriter': 'IPython.nbconvert.writers.stdout.StdoutWriter'}
     writer_factory = Type()
 
     def _writer_class_changed(self, name, old, new):
         if new.lower() in self.writer_aliases:
             new = self.writer_aliases[new.lower()]
         self.writer_factory = import_item(new)
 
     # Post-processor specific variables
     post_processor = Instance('IPython.nbconvert.post_processors.base.PostProcessorBase',  
                       help="""Instance of the PostProcessor class used to write the 
                       results of the conversion.""")
 
     post_processor_class = DottedOrNone(config=True, 
                                     help="""PostProcessor class used to write the 
                                     results of the conversion""")
     post_processor_aliases = {'pdf': 'IPython.nbconvert.post_processors.pdf.PDFPostProcessor',
                               'serve': 'IPython.nbconvert.post_processors.serve.ServePostProcessor'}
     post_processor_factory = Type()
 
     def _post_processor_class_changed(self, name, old, new):
         if new.lower() in self.post_processor_aliases:
             new = self.post_processor_aliases[new.lower()]
         if new:
             self.post_processor_factory = import_item(new)
 
 
     # Other configurable variables
     export_format = CaselessStrEnum(get_export_names(),
         default_value="html",
         config=True,
         help="""The export format to be used."""
     )
 
     notebooks = List([], config=True, help="""List of notebooks to convert.
                      Wildcards are supported.
                      Filenames passed positionally will be added to the list.
                      """)
 
     @catch_config_error
     def initialize(self, argv=None):
         super(NbConvertApp, self).initialize(argv)
         self.init_syspath()
         self.init_notebooks()
         self.init_writer()
         self.init_post_processor()
 
 
 
     def init_syspath(self):
         """
         Add the cwd to the sys.path ($PYTHONPATH)
         """
         sys.path.insert(0, os.getcwd())
         
 
     def init_notebooks(self):
         """Construct the list of notebooks.
         If notebooks are passed on the command-line,
         they override notebooks specified in config files.
         Glob each notebook to replace notebook patterns with filenames.
         """
 
         # Specifying notebooks on the command-line overrides (rather than adds)
         # the notebook list
         if self.extra_args:
             patterns = self.extra_args
         else:
             patterns = self.notebooks
 
         # Use glob to replace all the notebook patterns with filenames.
         filenames = []
         for pattern in patterns:
             
             # Use glob to find matching filenames.  Allow the user to convert 
             # notebooks without having to type the extension.
             globbed_files = glob.glob(pattern)
             globbed_files.extend(glob.glob(pattern + '.ipynb'))
             if not globbed_files:
                 self.log.warn("pattern %r matched no files", pattern)
 
             for filename in globbed_files:
                 if not filename in filenames:
                     filenames.append(filename)
         self.notebooks = filenames
 
     def init_writer(self):
         """
         Initialize the writer (which is stateless)
         """
         self._writer_class_changed(None, self.writer_class, self.writer_class)
         self.writer = self.writer_factory(parent=self)
 
     def init_post_processor(self):
         """
         Initialize the post_processor (which is stateless)
         """
         self._post_processor_class_changed(None, self.post_processor_class, 
             self.post_processor_class)
         if self.post_processor_factory:
             self.post_processor = self.post_processor_factory(parent=self)
 
     def start(self):
         """
         Ran after initialization completed
         """
         super(NbConvertApp, self).start()
         self.convert_notebooks()
 
     def convert_notebooks(self):
         """
         Convert the notebooks in the self.notebook traitlet
         """
         # Export each notebook
         conversion_success = 0
 
         if self.output_base != '' and len(self.notebooks) > 1:
             self.log.error(
             """UsageError: --output flag or `NbConvertApp.output_base` config option
             cannot be used when converting multiple notebooks.
             """)
             self.exit(1)
         
         exporter = exporter_map[self.export_format](config=self.config)
 
         for notebook_filename in self.notebooks:
             self.log.info("Converting notebook %s to %s", notebook_filename, self.export_format)
 
             # Get a unique key for the notebook and set it in the resources object.
             basename = os.path.basename(notebook_filename)
             notebook_name = basename[:basename.rfind('.')]
             if self.output_base:
                 notebook_name = self.output_base
             resources = {}
             resources['unique_key'] = notebook_name
             resources['output_files_dir'] = '%s_files' % notebook_name
             self.log.info("Support files will be in %s", os.path.join(resources['output_files_dir'], ''))
 
             # Try to export
             try:
                 output, resources = exporter.from_filename(notebook_filename, resources=resources)
             except ConversionException as e:
                 self.log.error("Error while converting '%s'", notebook_filename,
                       exc_info=True)
                 self.exit(1)
             else:
                 write_resultes = self.writer.write(output, resources, notebook_name=notebook_name)
 
                 #Post-process if post processor has been defined.
                 if hasattr(self, 'post_processor') and self.post_processor:
                     self.post_processor(write_resultes)
                 conversion_success += 1
 
         # If nothing was converted successfully, help the user.
         if conversion_success == 0:
             self.print_help()
             sys.exit(-1)
             
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance

IPython/nbconvert/transformers/__init__.py

@@ -1,12 +1,12 b''
-# Class base Transformers
-from .base import Transformer
-from .convertfigures import ConvertFiguresTransformer
-from .svg2pdf import SVG2PDFTransformer
-from .extractoutput import ExtractOutputTransformer
-from .revealhelp import RevealHelpTransformer
-from .latex import LatexTransformer
-from .sphinx import SphinxTransformer
-from .csshtmlheader import CSSHTMLHeaderTransformer
+# Class base Preprocessors
+from .base import Preprocessor
+from .convertfigures import ConvertFiguresPreprocessor
+from .svg2pdf import SVG2PDFPreprocessor
+from .extractoutput import ExtractOutputPreprocessor
+from .revealhelp import RevealHelpPreprocessor
+from .latex import LatexPreprocessor
+from .sphinx import SphinxPreprocessor
+from .csshtmlheader import CSSHTMLHeaderPreprocessor
 
-# decorated function Transformers
+# decorated function Preprocessors
 from .coalescestreams import coalesce_streams

IPython/nbconvert/transformers/base.py

@@ -1,110 +1,110 b''
 """
-Module that re-groups transformer that would be applied to ipynb files
+Module that re-groups preprocessor that would be applied to ipynb files
 before going through the templating machinery.
 
 It exposes a convenient class to inherit from to access configurability.
 """
 #-----------------------------------------------------------------------------
 # 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 ..utils.base import NbConvertBase
 from IPython.utils.traitlets import Bool
 
 #-----------------------------------------------------------------------------
 # Classes and Functions
 #-----------------------------------------------------------------------------
 
-class Transformer(NbConvertBase):
-    """ A configurable transformer
+class Preprocessor(NbConvertBase):
+    """ A configurable preprocessor
 
     Inherit from this class if you wish to have configurability for your
-    transformer.
+    preprocessor.
 
     Any configurable traitlets this class exposed will be configurable in profiles
     using c.SubClassName.atribute=value
 
-    you can overwrite :meth:`transform_cell` to apply a transformation independently on each cell
-    or :meth:`transform` if you prefer your own logic. See corresponding docstring for informations.
+    you can overwrite :meth:`preprocess_cell` to apply a preprocessation independently on each cell
+    or :meth:`preprocess` if you prefer your own logic. See corresponding docstring for informations.
 
     Disabled by default and can be enabled via the config by
-        'c.YourTransformerName.enabled = True'
+        'c.YourPreprocessorName.enabled = True'
     """
     
     enabled = Bool(False, config=True)
 
     def __init__(self, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
         
-        super(Transformer, self).__init__(**kw)
+        super(Preprocessor, self).__init__(**kw)
 
        
     def __call__(self, nb, resources):
         if self.enabled:
-            return self.transform(nb,resources)
+            return self.preprocess(nb,resources)
         else:
             return nb, resources
 
 
-    def transform(self, nb, resources):
+    def preprocess(self, nb, resources):
         """
-        Transformation to apply on each notebook.
+        preprocessation to apply on each notebook.
         
         You should return modified nb, resources.
-        If you wish to apply your transform on each cell, you might want to 
-        overwrite transform_cell method instead.
+        If you wish to apply your preprocess on each cell, you might want to 
+        overwrite preprocess_cell method instead.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         """
-        self.log.debug("Applying transform: %s", self.__class__.__name__)
+        self.log.debug("Applying preprocess: %s", self.__class__.__name__)
         try :
             for worksheet in nb.worksheets:
                 for index, cell in enumerate(worksheet.cells):
-                    worksheet.cells[index], resources = self.transform_cell(cell, resources, index)
+                    worksheet.cells[index], resources = self.preprocess_cell(cell, resources, index)
             return nb, resources
         except NotImplementedError:
             raise NotImplementedError('should be implemented by subclass')
 
 
-    def transform_cell(self, cell, resources, index):
+    def preprocess_cell(self, cell, resources, index):
         """
-        Overwrite if you want to apply a transformation on each cell.  You 
+        Overwrite if you want to apply a preprocessation on each cell.  You 
         should return modified cell and resource dictionary.
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         index : int
             Index of the cell being processed
         """
 
         raise NotImplementedError('should be implemented by subclass')
         return cell, resources
 

IPython/nbconvert/transformers/coalescestreams.py

@@ -1,75 +1,75 b''
 """Module that allows latex output notebooks to be conditioned before
 they are converted.  Exposes a decorator (@cell_preprocessor) in
 addition to the coalesce_streams pre-proccessor.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def cell_preprocessor(function):
     """
     Wrap a function to be executed on all cells of a notebook
     
     Wrapped Parameters
     ----------
     cell : NotebookNode cell
         Notebook cell being processed
     resources : dictionary
         Additional resources used in the conversion process.  Allows
-        transformers to pass variables into the Jinja engine.
+        preprocessors to pass variables into the Jinja engine.
     index : int
         Index of the cell being processed
     """
     
     def wrappedfunc(nb, resources):
         for worksheet in nb.worksheets :
             for index, cell in enumerate(worksheet.cells):
                 worksheet.cells[index], resources = function(cell, resources, index)
         return nb, resources
     return wrappedfunc
 
 
 @cell_preprocessor
 def coalesce_streams(cell, resources, index):
     """
     Merge consecutive sequences of stream output into single stream
     to prevent extra newlines inserted at flush calls
     
     Parameters
     ----------
     cell : NotebookNode cell
         Notebook cell being processed
     resources : dictionary
         Additional resources used in the conversion process.  Allows
         transformers to pass variables into the Jinja engine.
     index : int
         Index of the cell being processed
     """
     
     outputs = cell.get('outputs', [])
     if not outputs:
         return cell, resources
     
     last = outputs[0]
     new_outputs = [last]
     
     for output in outputs[1:]:
         if (output.output_type == 'stream' and
             last.output_type == 'stream' and
             last.stream == output.stream
         ):
             last.text += output.text
         else:
             new_outputs.append(output)
         last = output
 
     cell.outputs = new_outputs
     return cell, resources

IPython/nbconvert/transformers/convertfigures.py

@@ -1,64 +1,64 b''
-"""Module containing a transformer that converts outputs in the notebook from 
+"""Module containing a preprocessor that converts outputs in the notebook from 
 one format to another.
 """
 #-----------------------------------------------------------------------------
 # 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 Transformer
+from .base import Preprocessor
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class ConvertFiguresTransformer(Transformer):
+class ConvertFiguresPreprocessor(Preprocessor):
     """
     Converts all of the outputs in a notebook from one format to another.
     """
 
     from_format = Unicode(config=True, help='Format the converter accepts')
     to_format = Unicode(config=True, help='Format the converter writes')
 
     def __init__(self, **kw):
         """
         Public constructor
         """
-        super(ConvertFiguresTransformer, self).__init__(**kw)
+        super(ConvertFiguresPreprocessor, self).__init__(**kw)
 
 
     def convert_figure(self, data_format, data):
         raise NotImplementedError()
 
 
-    def transform_cell(self, cell, resources, cell_index):
+    def preprocess_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each cell,
         
         See base.py
         """
 
         # Loop through all of the datatypes of the outputs in the cell.
         for index, cell_out in enumerate(cell.get('outputs', [])):
             for data_type, data in cell_out.items():
                 # this must run *before* extract outputs,
                 # so figure_name and filename do not exist
                 self._convert_figure(cell_out, resources, data_type, data)
         return cell, resources
 
 
     def _convert_figure(self, cell_out, resources, data_type, data):
         """
         Convert a figure and output the results to the cell output
         """
         if not self.to_format in cell_out and data_type == self.from_format:
             data = self.convert_figure(data_type, data)
             cell_out[self.to_format] = data

IPython/nbconvert/transformers/csshtmlheader.py

@@ -1,106 +1,106 b''
 """Module that pre-processes the notebook for export to HTML.
 """
 #-----------------------------------------------------------------------------
 # 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 os
 import io
 
 from pygments.formatters import HtmlFormatter
 
 from IPython.utils import path
 
-from .base import Transformer
+from .base import Preprocessor
 
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class CSSHTMLHeaderTransformer(Transformer):
+class CSSHTMLHeaderPreprocessor(Preprocessor):
     """
-    Transformer used to pre-process notebook for HTML output.  Adds IPython notebook
+    Preprocessor used to pre-process notebook for HTML output.  Adds IPython notebook
     front-end CSS and Pygments CSS to HTML output.
     """
 
     header = []
 
     highlight_class = Unicode('.highlight', config=True,
                               help="CSS highlight class identifier")
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
         
-        super(CSSHTMLHeaderTransformer, self).__init__(config=config, **kw)
+        super(CSSHTMLHeaderPreprocessor, self).__init__(config=config, **kw)
 
         if self.enabled :
             self._regen_header()
 
 
-    def transform(self, nb, resources):
+    def preprocess(self, nb, resources):
         """Fetch and add CSS to the resource dictionary
 
         Fetch CSS from IPython and Pygments to add at the beginning
         of the html files.  Add this css in resources in the 
         "inlining.css" key
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         """
         
         resources['inlining'] = {}
         resources['inlining']['css'] = self.header
         
         return nb, resources
 
 
     def _regen_header(self):
         """ 
         Fills self.header with lines of CSS extracted from IPython 
         and Pygments.
         """
         
         #Clear existing header.
         header = []
         
         #Construct path to IPy CSS
         sheet_filename = os.path.join(path.get_ipython_package_dir(), 
             'html', 'static', 'style', 'style.min.css')
         
         #Load style CSS file.
         with io.open(sheet_filename, encoding='utf-8') as file:
             file_text = file.read()
             header.append(file_text)
 
         #Add pygments CSS
         formatter = HtmlFormatter()
         pygments_css = formatter.get_style_defs(self.highlight_class)
         header.append(pygments_css)
 
         #Set header        
         self.header = header
 

IPython/nbconvert/transformers/extractoutput.py

@@ -1,102 +1,102 b''
-"""Module containing a transformer that extracts all of the outputs from the
+"""Module containing a preprocessor that extracts all of the outputs from the
 notebook file.  The extracted outputs are returned in the 'resources' dictionary.
 """
 #-----------------------------------------------------------------------------
 # 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 base64
 import sys
 import os
 
 from IPython.utils.traitlets import Unicode
-from .base import Transformer
+from .base import Preprocessor
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class ExtractOutputTransformer(Transformer):
+class ExtractOutputPreprocessor(Preprocessor):
     """
     Extracts all of the outputs from the notebook file.  The extracted 
     outputs are returned in the 'resources' dictionary.
     """
 
     output_filename_template = Unicode(
         "{unique_key}_{cell_index}_{index}.{extension}", config=True)
 
 
-    def transform_cell(self, cell, resources, cell_index):
+    def preprocess_cell(self, cell, resources, cell_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
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         cell_index : int
             Index of the cell being processed (see base.py)
         """
 
         #Get the unique key from the resource dict if it exists.  If it does not 
         #exist, use 'output' as the default.  Also, get files directory if it
         #has been specified
         unique_key = resources.get('unique_key', 'output')
         output_files_dir = resources.get('output_files_dir', None)
         
         #Make sure outputs key exists
         if not isinstance(resources['outputs'], dict):
             resources['outputs'] = {}
             
         #Loop through all of the outputs in the cell
         for index, out in enumerate(cell.get('outputs', [])):
 
             #Get the output in data formats that the template is interested in.
             for out_type in self.display_data_priority:
                 if out.hasattr(out_type): 
                     data = out[out_type]
 
                     #Binary files are base64-encoded, SVG is already XML
                     if out_type in ('png', 'jpg', 'jpeg', 'pdf'):
 
                         # data is b64-encoded as text (str, unicode)
                         # decodestring only accepts bytes
                         data = py3compat.cast_bytes(data)
                         data = base64.decodestring(data)
                     elif sys.platform == 'win32':
                         data = data.replace('\n', '\r\n').encode("UTF-8")
                     else:
                         data = data.encode("UTF-8")
                     
                     #Build an output name
                     filename = self.output_filename_template.format( 
                                     unique_key=unique_key,
                                     cell_index=cell_index,
                                     index=index,
                                     extension=out_type)
 
                     #On the cell, make the figure available via 
                     #   cell.outputs[i].svg_filename  ... etc (svg in example)
                     # Where
                     #   cell.outputs[i].svg  contains the data
                     if output_files_dir is not None:
                         filename = os.path.join(output_files_dir, filename)
                     out[out_type + '_filename'] = filename
 
                     #In the resources, make the figure available via
                     #   resources['outputs']['filename'] = data
                     resources['outputs'][filename] = data
 
         return cell, resources

IPython/nbconvert/transformers/latex.py

@@ -1,53 +1,53 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
 
 # Our own imports
-# Needed to override transformer
-from .base import (Transformer)
+# Needed to override preprocessor
+from .base import (Preprocessor)
 from IPython.nbconvert import filters
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class LatexTransformer(Transformer):
+class LatexPreprocessor(Preprocessor):
     """
     Converter for latex destined documents.
     """
 
-    def transform_cell(self, cell, resources, index):
+    def preprocess_cell(self, cell, resources, index):
         """
-        Apply a transformation on each cell,
+        Apply a preprocessation on each cell,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         index : int
             Modified index of the cell being processed (see base.py)
         """
         
         #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

IPython/nbconvert/transformers/revealhelp.py

@@ -1,94 +1,94 b''
 """Module that pre-processes the notebook for export via Reveal.
 """
 #-----------------------------------------------------------------------------
 # 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 os
 import urllib2
 
-from .base import Transformer
+from .base import Preprocessor
 from IPython.utils.traitlets import Unicode, Bool
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class RevealHelpTransformer(Transformer):
+class RevealHelpPreprocessor(Preprocessor):
 
     url_prefix = Unicode('//cdn.jsdelivr.net/reveal.js/2.4.0',
                          config=True,
                          help="""If you want to use a local reveal.js library,
                          use 'url_prefix':'reveal.js' in your config object.""")
 
     speaker_notes = Bool(False, 
                          config=True, 
                          help="""If you want to use the speaker notes 
                          set this to True.""")
 
-    def transform(self, nb, resources):
+    def preprocess(self, nb, resources):
         """
-        Called once to 'transform' contents of the notebook.
+        Called once to 'preprocess' contents of the notebook.
 
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         """
 
         for worksheet in nb.worksheets :
             for index, cell in enumerate(worksheet.cells):
 
                 #Make sure the cell has slideshow metadata.
                 cell.metadata.align_type = cell.get('metadata', {}).get('slideshow', {}).get('align_type', 'Left')
                 cell.metadata.slide_type = cell.get('metadata', {}).get('slideshow', {}).get('slide_type', '-')
 
                 #Get the slide type.  If type is start of subslide or slide,
                 #end the last subslide/slide.
                 if cell.metadata.slide_type in ['slide']:
                     worksheet.cells[index - 1].metadata.slide_helper = 'slide_end'
                 if cell.metadata.slide_type in ['subslide']:
                     worksheet.cells[index - 1].metadata.slide_helper = 'subslide_end'
 
 
         if not isinstance(resources['reveal'], dict):
             resources['reveal'] = {}
         resources['reveal']['url_prefix'] = self.url_prefix
         resources['reveal']['notes_prefix'] = self.url_prefix
 
         cdn = 'http://cdn.jsdelivr.net/reveal.js/2.4.0'
         local = 'local'
         html_path = 'plugin/notes/notes.html'
         js_path = 'plugin/notes/notes.js'
 
         html_infile = os.path.join(cdn, html_path)
         js_infile = os.path.join(cdn, js_path)
         html_outfile = os.path.join(local, html_path)
         js_outfile = os.path.join(local, js_path)
 
         if self.speaker_notes:
             if 'outputs' not in resources:
                 resources['outputs'] = {}
             resources['outputs'][html_outfile] = self.notes_helper(html_infile)
             resources['outputs'][js_outfile] = self.notes_helper(js_infile)
             resources['reveal']['notes_prefix'] = local
 
         return nb, resources
 
     def notes_helper(self, infile):
         """Helper function to get the content from an url."""
 
         content = urllib2.urlopen(infile).read()
 
         return content

IPython/nbconvert/transformers/sphinx.py

@@ -1,264 +1,264 b''
 """Module that allows custom Sphinx parameters to be set on the notebook and
 on the 'other' object passed into Jinja.  Called prior to Jinja conversion
 process.
 """
 #-----------------------------------------------------------------------------
 # 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.path
 
 # Used to set the default date to today's date 
 from datetime import date 
 
 # Third-party imports
 # Needed for Pygments latex definitions.
 from pygments.formatters import LatexFormatter
 
 # Our own imports
 # Configurable traitlets
 from IPython.utils.traitlets import Unicode, Bool
 
-# Needed to override transformer
-from .base import (Transformer)
+# Needed to override preprocessor
+from .base import (Preprocessor)
 
 from IPython.nbconvert.utils import console  
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class SphinxTransformer(Transformer):
+class SphinxPreprocessor(Preprocessor):
     """
-    Sphinx utility transformer.
+    Sphinx utility preprocessor.
 
-    This transformer is used to set variables needed by the latex to build
+    This preprocessor is used to set variables needed by the latex to build
     Sphinx stylized templates.
     """
     
     interactive = Bool(False, config=True, help="""
         Allows you to define whether or not the Sphinx exporter will prompt
         you for input during the conversion process.  If this is set to false,
         the author, version, release, date, and chapter_style traits should
         be set.
         """)
     
     author = Unicode("Unknown Author", config=True, help="Author name")
     
     version = Unicode("", config=True, help="""
         Version number
         You can leave this blank if you do not want to render a version number.
         Example: "1.0.0"
         """)
     
     release = Unicode("", config=True, help="""
         Release name
         You can leave this blank if you do not want to render a release name.
         Example: "Rough Draft"
         """)
     
     publish_date = Unicode("", config=True, help="""
         Publish date
         This is the date to render on the document as the publish date.
         Leave this blank to default to todays date.  
         Example: "June 12, 1990"
         """)
     
     chapter_style = Unicode("Bjarne", config=True, help="""
         Sphinx chapter style
         This is the style to use for the chapter headers in the document.
         You may choose one of the following:
             "Bjarne"    (default)
             "Lenny"
             "Glenn"
             "Conny"
             "Rejne"
             "Sonny"    (used for international documents)
         """)
     
     output_style = Unicode("notebook", config=True, help="""
         Nbconvert Ipython
         notebook input/output formatting style.
         You may choose one of the following:
             "simple     (recommended for long code segments)"
             "notebook"  (default)
         """)
     
     center_output = Bool(False, config=True, help="""
         Optional attempt to center all output.  If this is false, no additional
         formatting is applied.
         """)
     
     use_headers = Bool(True, config=True, help="""
         Whether not a header should be added to the document.
         """)
     
     #Allow the user to override the title of the notebook (useful for
     #fancy document titles that the file system doesn't support.)
     overridetitle = Unicode("", config=True, help="")
 
     
-    def transform(self, nb, resources):
+    def preprocess(self, nb, resources):
         """
-        Sphinx transformation to apply on each notebook.
+        Sphinx preprocessing to apply on each notebook.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
-            transformers to pass variables into the Jinja engine.
+            preprocessors to pass variables into the Jinja engine.
         """
         # import sphinx here, so that sphinx is not a dependency when it's not used
         import sphinx
          
         # TODO: Add versatile method of additional notebook metadata.  Include
         #       handling of multiple files.  For now use a temporay namespace,
         #       '_draft' to signify that this needs to change.
         if not isinstance(resources["sphinx"], dict):
             resources["sphinx"] = {}
 
         if self.interactive:
             
             # Prompt the user for additional meta data that doesn't exist currently
             # but would be usefull for Sphinx.
             resources["sphinx"]["author"] = self._prompt_author()
             resources["sphinx"]["version"] = self._prompt_version()
             resources["sphinx"]["release"] = self._prompt_release()
             resources["sphinx"]["date"] = self._prompt_date()
             
             # Prompt the user for the document style.
             resources["sphinx"]["chapterstyle"] = self._prompt_chapter_title_style()
             resources["sphinx"]["outputstyle"] = self._prompt_output_style()
             
             # Small options
             resources["sphinx"]["centeroutput"] = console.prompt_boolean("Do you want to center the output? (false)", False)
             resources["sphinx"]["header"] = console.prompt_boolean("Should a Sphinx document header be used? (true)", True)
         else:
             
             # Try to use the traitlets.
             resources["sphinx"]["author"] = self.author
             resources["sphinx"]["version"] = self.version
             resources["sphinx"]["release"] = self.release
             
             # Use todays date if none is provided.
             if self.publish_date:
                 resources["sphinx"]["date"] = self.publish_date
             elif len(resources['metadata']['modified_date'].strip()) == 0:
                 resources["sphinx"]["date"] = date.today().strftime("%B %-d, %Y")
             else:
                 resources["sphinx"]["date"] = resources['metadata']['modified_date']
             
             # Sphinx traitlets.
             resources["sphinx"]["chapterstyle"] = self.chapter_style
             resources["sphinx"]["outputstyle"] = self.output_style
             resources["sphinx"]["centeroutput"] = self.center_output
             resources["sphinx"]["header"] = self.use_headers
             
         # Find and pass in the path to the Sphinx dependencies.
         resources["sphinx"]["texinputs"] = os.path.realpath(os.path.join(sphinx.package_dir, "texinputs"))
         
         # Generate Pygments definitions for Latex 
         resources["sphinx"]["pygment_definitions"] = self._generate_pygments_latex_def()
         
         if not (self.overridetitle == None or len(self.overridetitle.strip()) == 0):
             resources['metadata']['name'] = self.overridetitle
         
         # End
         return nb, resources 
     
     
     def _generate_pygments_latex_def(self):
         """
         Generate the pygments latex definitions that allows pygments
         to work in latex.
         """
         
         return LatexFormatter().get_style_defs()       
     
     
     def _prompt_author(self):
         """
         Prompt the user to input an Author name
         """
         return  console.input("Author name: ")
     
     
     def _prompt_version(self):
         """
         prompt the user to enter a version number
         """
         return  console.input("Version (ie ""1.0.0""): ")
     
     
     def _prompt_release(self):
         """
         Prompt the user to input a release name
         """
         
         return  console.input("Release Name (ie ""Rough draft""): ")
     
     
     def _prompt_date(self, resources):
         """
         Prompt the user to enter a date
         """
         
         if resources['metadata']['modified_date']:
             default_date = resources['metadata']['modified_date']
         else:
             default_date = date.today().strftime("%B %-d, %Y")
             
         user_date = console.input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date
         return user_date
     
     
     def _prompt_output_style(self):
         """
         Prompts the user to pick an IPython output style.
         """
         
         # Dictionary of available output styles
         styles = {1: "simple",
                   2: "notebook"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(recommended for long code segments)",
                     2: "(default)"}
         
         return console.prompt_dictionary(styles, default_style=2, menu_comments=comments)
     
     
     def _prompt_chapter_title_style(self):
         """
         Prompts the user to pick a Sphinx chapter style
         """
         
         # Dictionary of available Sphinx styles
         styles = {1: "Bjarne",
                   2: "Lenny",
                   3: "Glenn",
                   4: "Conny",
                   5: "Rejne",
                   6: "Sonny"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(default)",
                     6: "(for international documents)"}
         
         return console.prompt_dictionary(styles, menu_comments=comments)
 

IPython/nbconvert/transformers/svg2pdf.py

@@ -1,95 +1,95 b''
-"""Module containing a transformer that converts outputs in the notebook from 
+"""Module containing a preprocessor that converts outputs in the notebook from 
 one format to another.
 """
 #-----------------------------------------------------------------------------
 # 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 base64
 import io
 import os
 import sys
 import subprocess
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import Unicode
 
-from .convertfigures import ConvertFiguresTransformer
+from .convertfigures import ConvertFiguresPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 INKSCAPE_APP = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape'
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class SVG2PDFTransformer(ConvertFiguresTransformer):
+class SVG2PDFPreprocessor(ConvertFiguresPreprocessor):
     """
     Converts all of the outputs in a notebook from SVG to PDF.
     """
 
     from_format = Unicode('svg', config=True, help='Format the converter accepts')
     to_format = Unicode('pdf', config=False, help='Format the converter writes')
     
     command = Unicode(config=True,
         help="""The command to use for converting SVG to PDF
         
         This string is a template, which will be formatted with the keys
         to_filename and from_filename.
         
         The conversion call must read the SVG from {from_flename},
         and write a PDF to {to_filename}.
         """)
     
     def _command_default(self):
         return self.inkscape + \
                ' --without-gui --export-pdf="{to_filename}" "{from_filename}"'
     
     inkscape = Unicode(config=True, help="The path to Inkscape, if necessary")
     def _inkscape_default(self):
         if sys.platform == "darwin":
             if os.path.isfile(INKSCAPE_APP):
                 return INKSCAPE_APP
         return "inkscape"
 
 
     def convert_figure(self, data_format, data):
         """
         Convert a single SVG figure to PDF.  Returns converted data.
         """
 
         #Work in a temporary directory
         with TemporaryDirectory() as tmpdir:
             
             #Write fig to temp file
             input_filename = os.path.join(tmpdir, 'figure.' + data_format)
             # SVG data is unicode text
             with io.open(input_filename, 'w', encoding='utf8') as f:
                 f.write(data)
 
             #Call conversion application
             output_filename = os.path.join(tmpdir, 'figure.pdf')
             shell = self.command.format(from_filename=input_filename, 
                                    to_filename=output_filename)
             subprocess.call(shell, shell=True) #Shell=True okay since input is trusted.
 
             #Read output from drive
             # return value expects a filename
             if os.path.isfile(output_filename):
                 with open(output_filename, 'rb') as f:
                     # PDF is a nb supported binary, data type, so base64 encode.
                     return base64.encodestring(f.read())
             else:
                 raise TypeError("Inkscape svg to png conversion failed")

IPython/nbconvert/transformers/tests/base.py

@@ -1,53 +1,53 b''
 """
-Module with utility functions for transformer tests
+Module with utility functions for preprocessor tests
 """
 
 #-----------------------------------------------------------------------------
 # 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 IPython.nbformat import current as nbformat
 
 from ...tests.base import TestsBase
 from ...exporters.exporter import ResourcesDict
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TransformerTestsBase(TestsBase):
-    """Contains test functions transformer tests"""
+class PreprocessorTestsBase(TestsBase):
+    """Contains test functions preprocessor tests"""
 
 
     def build_notebook(self):
-        """Build a notebook in memory for use with transformer tests"""
+        """Build a notebook in memory for use with preprocessor tests"""
 
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a"),
                    nbformat.new_output(output_type="text", output_text="b"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="c"),
                    nbformat.new_output(output_type="stream", stream="stdout", output_text="d"),
                    nbformat.new_output(output_type="stream", stream="stderr", output_text="e"),
                    nbformat.new_output(output_type="stream", stream="stderr", output_text="f"),
                    nbformat.new_output(output_type="png", output_png=b'Zw==')] #g
         
         cells=[nbformat.new_code_cell(input="$ e $", prompt_number=1,outputs=outputs),
                nbformat.new_text_cell('markdown', source="$ e $")]
         worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
 
         return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
 
 
     def build_resources(self):
         """Build an empty resources dictionary."""
         
         res = ResourcesDict()
         res['metadata'] = ResourcesDict()
-        return res
  No newline at end of file
+        return res

IPython/nbconvert/transformers/tests/test_coalescestreams.py

@@ -1,38 +1,38 b''
 """
-Module with tests for the coalescestreams transformer
+Module with tests for the coalescestreams 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 TransformerTestsBase
+from .base import PreprocessorTestsBase
 from ..coalescestreams import coalesce_streams
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TestCoalesceStreams(TransformerTestsBase):
+class TestCoalesceStreams(PreprocessorTestsBase):
     """Contains test functions for coalescestreams.py"""
 
     def test_coalesce_streams(self):
-        """coalesce_streams transformer output test"""
+        """coalesce_streams preprocessor output test"""
         nb = self.build_notebook()
         res = self.build_resources()
         nb, res = coalesce_streams(nb, res)
         outputs = nb.worksheets[0].cells[0].outputs
         self.assertEqual(outputs[0].text, "a")
         self.assertEqual(outputs[1].output_type, "text")
         self.assertEqual(outputs[2].text, "cd")
         self.assertEqual(outputs[3].text, "ef")
-    
  No newline at end of file
+    

IPython/nbconvert/transformers/tests/test_csshtmlheader.py

@@ -1,47 +1,47 b''
 """
-Module with tests for the csshtmlheader transformer
+Module with tests for the csshtmlheader 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 TransformerTestsBase
-from ..csshtmlheader import CSSHTMLHeaderTransformer
+from .base import PreprocessorTestsBase
+from ..csshtmlheader import CSSHTMLHeaderPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TestCSSHTMLHeader(TransformerTestsBase):
+class TestCSSHTMLHeader(PreprocessorTestsBase):
     """Contains test functions for csshtmlheader.py"""
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = CSSHTMLHeaderTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = CSSHTMLHeaderPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
 
     def test_constructor(self):
-        """Can a CSSHTMLHeaderTransformer be constructed?"""
-        self.build_transformer()
+        """Can a CSSHTMLHeaderPreprocessor be constructed?"""
+        self.build_preprocessor()
     
 
     def test_output(self):
-        """Test the output of the CSSHTMLHeaderTransformer"""
+        """Test the output of the CSSHTMLHeaderPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
-        assert 'css' in res['inlining'] 
  No newline at end of file
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
+        assert 'css' in res['inlining'] 

IPython/nbconvert/transformers/tests/test_extractoutput.py

@@ -1,62 +1,62 b''
 """
-Module with tests for the extractoutput transformer
+Module with tests for the extractoutput 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 TransformerTestsBase
-from ..extractoutput import ExtractOutputTransformer
+from .base import PreprocessorTestsBase
+from ..extractoutput import ExtractOutputPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TestExtractOutput(TransformerTestsBase):
+class TestExtractOutput(PreprocessorTestsBase):
     """Contains test functions for extractoutput.py"""
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = ExtractOutputTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = ExtractOutputPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
 
     def test_constructor(self):
-        """Can a ExtractOutputTransformer be constructed?"""
-        self.build_transformer()
+        """Can a ExtractOutputPreprocessor be constructed?"""
+        self.build_preprocessor()
     
 
     def test_output(self):
-        """Test the output of the ExtractOutputTransformer"""
+        """Test the output of the ExtractOutputPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
 
         # Check if text was extracted.
         assert 'text_filename' in nb.worksheets[0].cells[0].outputs[1]
         text_filename = nb.worksheets[0].cells[0].outputs[1]['text_filename']
 
         # Check if png was extracted.
         assert 'png_filename' in nb.worksheets[0].cells[0].outputs[6]
         png_filename = nb.worksheets[0].cells[0].outputs[6]['png_filename']
 
         # Verify text output
         assert text_filename in res['outputs']
         self.assertEqual(res['outputs'][text_filename], b'b')
 
         # Verify png output
         assert png_filename in res['outputs']
         self.assertEqual(res['outputs'][png_filename], b'g')

IPython/nbconvert/transformers/tests/test_latex.py

@@ -1,51 +1,51 b''
 """
-Module with tests for the latex transformer
+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 TransformerTestsBase
-from ..latex import LatexTransformer
+from .base import PreprocessorTestsBase
+from ..latex import LatexPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TestLatex(TransformerTestsBase):
+class TestLatex(PreprocessorTestsBase):
     """Contains test functions for latex.py"""
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = LatexTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = LatexPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
     def test_constructor(self):
-        """Can a LatexTransformer be constructed?"""
-        self.build_transformer()
+        """Can a LatexPreprocessor be constructed?"""
+        self.build_preprocessor()
         
 
     def test_output(self):
-        """Test the output of the LatexTransformer"""
+        """Test the output of the LatexPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        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$')

IPython/nbconvert/transformers/tests/test_revealhelp.py

@@ -1,94 +1,94 b''
 """
-Module with tests for the revealhelp transformer
+Module with tests for the revealhelp 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 IPython.nbformat import current as nbformat
 
-from .base import TransformerTestsBase
-from ..revealhelp import RevealHelpTransformer
+from .base import PreprocessorTestsBase
+from ..revealhelp import RevealHelpPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class Testrevealhelp(TransformerTestsBase):
+class Testrevealhelp(PreprocessorTestsBase):
     """Contains test functions for revealhelp.py"""
 
     def build_notebook(self):
         """Build a reveal slides notebook in memory for use with tests.  
-        Overrides base in TransformerTestsBase"""
+        Overrides base in PreprocessorTestsBase"""
 
         outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a")]
         
         slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
         subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
 
         cells=[nbformat.new_code_cell(input="", prompt_number=1, outputs=outputs),
                nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
                nbformat.new_code_cell(input="", prompt_number=2, outputs=outputs),
                nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
                nbformat.new_text_cell('markdown', source="", metadata=subslide_metadata)]
         worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
 
         return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = RevealHelpTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = RevealHelpPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
 
     def test_constructor(self):
-        """Can a RevealHelpTransformer be constructed?"""
-        self.build_transformer()
+        """Can a RevealHelpPreprocessor be constructed?"""
+        self.build_preprocessor()
     
 
     def test_reveal_attribute(self):
         """Make sure the reveal url_prefix resources is set"""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
         assert 'reveal' in res
         assert  'url_prefix' in res['reveal']
 
 
     def test_reveal_output(self):
-        """Make sure that the reveal transformer """
+        """Make sure that the reveal preprocessor """
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
         cells = nb.worksheets[0].cells
         
         # Make sure correct metadata tags are available on every cell.
         for cell in cells:
             assert 'slide_type' in cell.metadata
             assert 'align_type' in cell.metadata
 
         # Make sure slide end is only applied to the cells preceeding slide 
         # cells.
         assert 'slide_helper' not in cells[1].metadata
 
         # Verify 'slide-end'
         assert 'slide_helper' in cells[0].metadata
         self.assertEqual(cells[0].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[2].metadata
         self.assertEqual(cells[2].metadata['slide_helper'], 'slide_end')
         assert 'slide_helper' in cells[3].metadata
         self.assertEqual(cells[3].metadata['slide_helper'], 'subslide_end')

IPython/nbconvert/transformers/tests/test_sphinx.py

@@ -1,57 +1,57 b''
 """
-Module with tests for the sphinx transformer
+Module with tests for the sphinx 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 TransformerTestsBase
-from ..sphinx import SphinxTransformer
+from .base import PreprocessorTestsBase
+from ..sphinx import SphinxPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class TestSphinx(TransformerTestsBase):
+class TestSphinx(PreprocessorTestsBase):
     """Contains test functions for sphinx.py"""
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = SphinxTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = SphinxPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
 
     def test_constructor(self):
-        """Can a SphinxTransformer be constructed?"""
-        self.build_transformer()
+        """Can a SphinxPreprocessor be constructed?"""
+        self.build_preprocessor()
     
 
     def test_resources(self):
-        """Make sure the SphinxTransformer adds the appropriate resources to the
+        """Make sure the SphinxPreprocessor adds the appropriate resources to the
         resources dict."""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
         assert "author" in res['sphinx']
         assert "version" in res['sphinx']
         assert "release" in res['sphinx']
         assert "date" in res['sphinx']
         assert "chapterstyle" in res['sphinx']
         assert "outputstyle" in res['sphinx']
         assert "centeroutput" in res['sphinx']
         assert "header" in res['sphinx']
         assert "texinputs" in res['sphinx']
         assert "pygment_definitions" in res['sphinx']

IPython/nbconvert/transformers/tests/test_svg2pdf.py

@@ -1,90 +1,90 b''
 """
-Module with tests for the svg2pdf transformer
+Module with tests for the svg2pdf 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 IPython.testing import decorators as dec
 from IPython.nbformat import current as nbformat
 
-from .base import TransformerTestsBase
-from ..svg2pdf import SVG2PDFTransformer
+from .base import PreprocessorTestsBase
+from ..svg2pdf import SVG2PDFPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
-class Testsvg2pdf(TransformerTestsBase):
+class Testsvg2pdf(PreprocessorTestsBase):
     """Contains test functions for svg2pdf.py"""
 
     simple_svg = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!-- Created with Inkscape (http://www.inkscape.org/) -->
 <svg
    xmlns:svg="http://www.w3.org/2000/svg"
    xmlns="http://www.w3.org/2000/svg"
    version="1.0"
    x="0.00000000"
    y="0.00000000"
    width="500.00000"
    height="500.00000"
    id="svg2">
   <defs
      id="defs4" />
   <g
      id="layer1">
     <rect
        width="300.00000"
        height="300.00000"
        x="100.00000"
        y="100.00000"
        style="opacity:1.0000000;fill:none;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#000000;stroke-width:8.0000000;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.00000000;stroke-opacity:1.0000000"
        id="rect5719" />
   </g>
 </svg>"""
 
     def build_notebook(self):
         """Build a reveal slides notebook in memory for use with tests.  
-        Overrides base in TransformerTestsBase"""
+        Overrides base in PreprocessorTestsBase"""
 
         outputs = [nbformat.new_output(output_type="svg", output_svg=self.simple_svg)]
         
         slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
         subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
 
         cells=[nbformat.new_code_cell(input="", prompt_number=1, outputs=outputs)]
         worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
 
         return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
 
 
-    def build_transformer(self):
-        """Make an instance of a transformer"""
-        transformer = SVG2PDFTransformer()
-        transformer.enabled = True
-        return transformer
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = SVG2PDFPreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
 
 
     def test_constructor(self):
-        """Can a SVG2PDFTransformer be constructed?"""
-        self.build_transformer()
+        """Can a SVG2PDFPreprocessor be constructed?"""
+        self.build_preprocessor()
 
 
     @dec.onlyif_cmds_exist('inkscape')
     def test_output(self):
-        """Test the output of the SVG2PDFTransformer"""
+        """Test the output of the SVG2PDFPreprocessor"""
         nb = self.build_notebook()
         res = self.build_resources()
-        transformer = self.build_transformer()
-        nb, res = transformer(nb, res)
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
         assert 'svg' in nb.worksheets[0].cells[0].outputs[0]

IPython/nbconvert/writers/files.py

@@ -1,115 +1,115 b''
 """
 Contains writer for writing nbconvert output to filesystem.
 """
 #-----------------------------------------------------------------------------
 #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 io
 import os
 import glob
 
 from IPython.utils.traitlets import Unicode
 from IPython.utils.path import link_or_copy
 
 from .base import WriterBase
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class FilesWriter(WriterBase):
     """Consumes nbconvert output and produces files."""
 
 
     build_directory = Unicode("", config=True,
                               help="""Directory to write output to.  Leave blank
                               to output to the current directory""")
 
 
     # Make sure that the output directory exists.
     def _build_directory_changed(self, name, old, new):
         if new and not os.path.isdir(new):
             os.makedirs(new)
 
 
     def __init__(self, **kw):
         super(FilesWriter, self).__init__(**kw)
         self._build_directory_changed('build_directory', self.build_directory, 
                                       self.build_directory)
     
     def _makedir(self, path):
         """Make a directory if it doesn't already exist"""
         if path and not os.path.isdir(path):
             self.log.info("Making directory %s", path)
             os.makedirs(path)
 
     def write(self, output, resources, notebook_name=None, **kw):
             """
             Consume and write Jinja output to the file system.  Output directory
             is set via the 'build_directory' variable of this instance (a 
             configurable).
 
             See base for more...
             """
 
             # Verify that a notebook name is provided.
             if notebook_name is None:
                 raise TypeError('notebook_name')
 
             # Pull the extension and subdir from the resources dict.
             output_extension = resources.get('output_extension', None)
 
             # Write all of the extracted resources to the destination directory.
             # NOTE: WE WRITE EVERYTHING AS-IF IT'S BINARY.  THE EXTRACT FIG
-            # TRANSFORMER SHOULD HANDLE UNIX/WINDOWS LINE ENDINGS...
+            # PREPROCESSOR SHOULD HANDLE UNIX/WINDOWS LINE ENDINGS...
             for filename, data in resources.get('outputs', {}).items():
 
                 # Determine where to write the file to
                 dest = os.path.join(self.build_directory, filename)
                 path = os.path.dirname(dest)
                 self._makedir(path)
 
                 # Write file
                 self.log.debug("Writing %i bytes to support file %s", len(data), dest)
                 with io.open(dest, 'wb') as f:
                     f.write(data)
 
             # Copy referenced files to output directory
             if self.build_directory:
                 for filename in self.files:
 
                     # Copy files that match search pattern
                     for matching_filename in glob.glob(filename):
 
                         # Make sure folder exists.
                         dest = os.path.join(self.build_directory, filename)
                         path = os.path.dirname(dest)
                         self._makedir(path)
 
                         # Copy if destination is different.
                         if not os.path.normpath(dest) == os.path.normpath(matching_filename):
                             self.log.info("Linking %s -> %s", matching_filename, dest)
                             link_or_copy(matching_filename, dest)
 
             # Determine where to write conversion results.
             if output_extension is not None:
                 dest = notebook_name + '.' + output_extension
             else:
                 dest = notebook_name
             if self.build_directory:
                 dest = os.path.join(self.build_directory, dest)
 
             # Write conversion results.
             self.log.info("Writing %i bytes to %s", len(output), dest)
             with io.open(dest, 'w', encoding='utf-8') as f:
                 f.write(output)
-            return dest
  No newline at end of file
+            return dest

docs/source/whatsnew/development.rst

@@ -1,16 +1,16 b''
 =====================
  Development version
 =====================
 
 This document describes in-flight development work.
 
 
 Backwards incompatible changes
 ------------------------------
 
 * Python 2.6 and 3.2 are no longer supported: the minimum required
   Python versions are now 2.7 and 3.3.
-* The `call` methods for nbconvert transformers has been renamed to
-  `transform`.
+* The Transformer classes have been renamed to Preprocessor in nbconvert and
+  their `call` methods for them have been renamed to `preprocess`.
 * The `call` methods of nbconvert post-processsors have been renamed to
   `postprocess`.