Merge pull request #3507 from minrk/html

fix HTML capitalization in nbconvert exporter classes

IPython/nbconvert/exporters/__init__.py

@@ -1,10 +1,10 b''
-from .basichtml import BasicHtmlExporter
+from .basichtml import BasicHTMLExporter
 from .export import *
 from .exporter import Exporter
-from .fullhtml import FullHtmlExporter
+from .fullhtml import FullHTMLExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RstExporter
 from .sphinx_howto import SphinxHowtoExporter
 from .sphinx_manual import SphinxManualExporter

IPython/nbconvert/exporters/basichtml.py

@@ -1,55 +1,55 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
 
-from ..transformers.csshtmlheader import CSSHtmlHeaderTransformer
+from ..transformers.csshtmlheader import CSSHTMLHeaderTransformer
 
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class BasicHtmlExporter(Exporter):
+class BasicHTMLExporter(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/
     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"
         )
 
     template_file = Unicode(
             'basichtml', config=True,
             help="Name of the template file to use")
 
 
     def _register_transformers(self):
         """
         Register all of the transformers needed for this exporter.
         """
         
         #Register the transformers of the base class.
-        super(BasicHtmlExporter, self)._register_transformers()
+        super(BasicHTMLExporter, self)._register_transformers()
         
-        #Register CSSHtmlHeaderTransformer transformer
-        self.register_transformer(CSSHtmlHeaderTransformer)
+        #Register CSSHTMLHeaderTransformer transformer
+        self.register_transformer(CSSHTMLHeaderTransformer)
                     

IPython/nbconvert/exporters/export.py

@@ -1,225 +1,225 b''
 """
 Module containing single call export functions.
 """
 #-----------------------------------------------------------------------------
 # 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 functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
 
 from .exporter import Exporter
-from .basichtml import BasicHtmlExporter
-from .fullhtml import FullHtmlExporter
+from .basichtml import BasicHTMLExporter
+from .fullhtml import FullHTMLExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .python_armor import PythonArmorExporter
 from .reveal import RevealExporter
 from .rst import RstExporter
 from .sphinx_howto import SphinxHowtoExporter
 from .sphinx_manual import SphinxManualExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 def DocDecorator(f):    
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : Notebook node
     config : config
         User configuration instance.
     transformers : list[of transformer]
         Custom transformers to apply to the notebook prior to engaging
         the Jinja template engine.  Any transformers specified here 
         will override existing transformers if a naming conflict
         occurs.
     filters : list[of filter]
         Custom filters to make accessible to the Jinja templates.  Any
         filters specified here will override existing filters if a
         naming conflict occurs.
         
     Returns
     ----------
     tuple- output, resources, exporter_instance
     output : str
         Jinja 2 output.  This is the resulting converted notebook.
     resources : dictionary
         Dictionary of resources used prior to and during the conversion 
         process.
     exporter_instance : Exporter
         Instance of the Exporter class used to export the document.  Useful
         to caller because it provides a 'file_extension' property which
         specifies what extension the output should be saved as."""
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_sphinx_manual',
     'export_sphinx_howto',
     'export_basic_html',
     'export_full_html',
     'export_latex',
     'export_markdown',
     'export_python',
     'export_python_armor',
     'export_reveal',
     'export_rst',
     'export_by_name'
 ]
 
 @DocDecorator
 def export(exporter_type, nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object using specific exporter class.
     
     exporter_type : Exporter class type
         Class type of the exporter that should be used.  This method
         will initialize it's own instance of the class.  It is
         ASSUMED that the class type provided exposes a
         constructor (__init__) with the same signature as the
         base Exporter class.}
     """
     
     #Check arguments
     if exporter_type is None:
         raise TypeError("Exporter is None")
     elif not issubclass(exporter_type, Exporter):
         raise TypeError("Exporter type does not inherit from Exporter (base)")
     
     if nb is None:
         raise TypeError("nb is None")
     
     #Create the exporter
     exporter_instance = exporter_type(preprocessors=transformers, 
                                       jinja_filters=filters, config=config)
 
     #Try to convert the notebook using the appropriate conversion function.
     if isinstance(nb, NotebookNode):
         output, resources = exporter_instance.from_notebook_node(nb)
     elif isinstance(nb, basestring):
         output, resources = exporter_instance.from_filename(nb)
     else:
         output, resources = exporter_instance.from_file(nb)
     return output, resources, exporter_instance
 
 
 @DocDecorator
 def export_sphinx_manual(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Sphinx Manual LaTeX
     """
     return export(SphinxManualExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_sphinx_howto(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Sphinx HowTo LaTeX
     """
     return export(SphinxHowtoExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_basic_html(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Basic HTML
     """
-    return export(BasicHtmlExporter, nb, config, transformers, filters)
+    return export(BasicHTMLExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_full_html(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Full HTML
     """
-    return export(FullHtmlExporter, nb, config, transformers, filters)
+    return export(FullHTMLExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_latex(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to LaTeX
     """
     return export(LatexExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_markdown(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Markdown
     """
     return export(MarkdownExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_python(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Python
     """
     return export(PythonExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_python_armor(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Python (Armor)
     """
     return export(PythonArmorExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_reveal(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to Reveal
     """
     return export(RevealExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_rst(nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to RST
     """
     return export(RstExporter, nb, config, transformers, filters)
 
 
 @DocDecorator
 def export_by_name(template_name, nb, config=None, transformers=None, filters=None):
     """
     Export a notebook object to a template type by its name.  Reflection
     (Inspect) is used to find the template's corresponding explicit export
     method defined in this module.  That method is then called directly.
     
     template_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + template_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, config, transformers, filters)
     else:
         return None
 

IPython/nbconvert/exporters/fullhtml.py

@@ -1,39 +1,39 b''
 """
 Exporter for exporting full HTML documents.
 """
 
 #-----------------------------------------------------------------------------
 # 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 .basichtml import BasicHtmlExporter
+from .basichtml import BasicHTMLExporter
 from IPython.config import Config
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class FullHtmlExporter(BasicHtmlExporter):
+class FullHTMLExporter(BasicHTMLExporter):
     """
     Exports a full HTML document.
     """
 
     template_file = Unicode(
             'fullhtml', config=True,
             help="Name of the template file to use")
 
     @property
     def default_config(self):
-        c = Config({'CSSHtmlHeaderTransformer':{'enabled':True}})
-        c.merge(super(FullHtmlExporter,self).default_config)
+        c = Config({'CSSHTMLHeaderTransformer':{'enabled':True}})
+        c.merge(super(FullHTMLExporter,self).default_config)
         return c

IPython/nbconvert/exporters/reveal.py

@@ -1,54 +1,54 b''
 """
 Reveal 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.config import Config
 
-from .basichtml import BasicHtmlExporter
+from .basichtml import BasicHTMLExporter
 from IPython.nbconvert import transformers
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class RevealExporter(BasicHtmlExporter):
+class RevealExporter(BasicHTMLExporter):
     """
     Exports a Reveal slide show (.HTML) which may be rendered in a web browser.
     """
     
     file_extension = Unicode(
         'reveal.html', config=True, 
         help="Extension of the file that should be written to disk")
 
     template_file = Unicode(
             'reveal', config=True,
             help="Name of the template file to use")
     
     def _register_transformers(self):
         """
         Register all of the transformers needed for this exporter.
         """
         
         #Register the transformers of the base class.
         super(RevealExporter, self)._register_transformers()
         
         #Register reveal help transformer
         self.register_transformer(transformers.RevealHelpTransformer)
 
     @property
     def default_config(self):
-        c = Config({'CSSHtmlHeaderTransformer':{'enabled':True}})
+        c = Config({'CSSHTMLHeaderTransformer':{'enabled':True}})
         c.merge(super(RevealExporter,self).default_config)
         return c

IPython/nbconvert/transformers/csshtmlheader.py

@@ -1,105 +1,105 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 .activatable import ActivatableTransformer
         
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-class CSSHtmlHeaderTransformer(ActivatableTransformer):
+class CSSHTMLHeaderTransformer(ActivatableTransformer):
     """
     Transformer used to pre-process notebook for HTML output.  Adds IPython notebook
     front-end CSS and Pygments CSS to HTML output.
     """
 
     header = []
 
     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(CSSHTMLHeaderTransformer, self).__init__(config=config, **kw)
 
         if self.enabled :
             self._regen_header()
 
 
     def __call__(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.
         """
         
         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.
         try:
             with io.open(sheet_filename, encoding='utf-8') as file:
                 file_text = file.read()
                 header.append(file_text)
         except IOError:
             
             # New version of IPython with style.min.css, pass
             pass
 
         #Add pygments CSS
         pygments_css = HtmlFormatter().get_style_defs('.highlight')
         header.append(pygments_css)
 
         #Set header        
         self.header = header