New implementation for reveal option in nbconvert bypassing markdown step. The structure behind the implementaion follows the discussion in IPEP 9

converters/reveal.py

@@ -1,227 +1,339 b''
-from converters.markdown import ConverterMarkdown
-from IPython.utils.text import indent, dedent
-from converters.utils import highlight, remove_ansi
-import io
+from __future__ import absolute_import
+
+from converters.html import ConverterHTML
+from converters.utils import text_cell#, output_container
+from converters.utils import highlight, coalesce_streams#, ansi2html
+
+#from IPython.utils import path
+#from IPython.utils.text import indent, dedent
+from markdown import markdown
 import os
+import io
 import itertools
 
-class ConverterReveal(ConverterMarkdown):
-    """
-    Convert a notebook to a html slideshow.
-
-    It generates a static html slideshow based in markdown and reveal.js.
-    The delimiters for each slide, subslide, and fragment are retrieved
-    from the 'slideshow' metadata.
-    """
-
-    def __init__(self, infile, highlight_source=False, show_prompts=True,
-                 inline_prompt=True):
-        super(ConverterReveal, self).__init__(infile)
-        self.highlight_source = highlight_source
-        self.show_prompts = show_prompts
-        self.inline_prompt = inline_prompt
-
-    def switch_meta(self, m_list):
-        "sort order m_list to [new_section, new_subsection, new_fragment]"
-        if len(m_list) > 1:
-        # do not sort when m_list = [new_subsection, new_fragment]
-            if not (len(m_list) == 2 and m_list[1] == [u'new_fragment = True']):
-                m_list[0], m_list[1] = m_list[1], m_list[0]
-        return m_list
-
-    def meta2str(self, meta):
-        "transform metadata dict (containing slides delimiters) to string "
-        try:
-            meta_tuple = meta[u'slideshow'].items()
-        except KeyError as e:
-            meta_tuple = ()  # if there is not slideshow metadata
-        meta_list = [[x + ' = ' + unicode(y)] for x, y in meta_tuple]
-        meta_list = self.switch_meta(meta_list)
-        return u'\n'.join(list(itertools.chain(*meta_list)))
 
+class ConverterReveal(ConverterHTML):
+    #"""
+    #Convert a notebook to a html slideshow.
+
+    #It generates a static html slideshow based in markdown and reveal.js.
+    #The delimiters for each slide, subslide, and fragment are retrieved
+    #from the 'slideshow' metadata.
+    #"""
+
+    #def __init__(self):
+        #super(ConverterReveal, self).__init__()
+
+    #extension = 'html'
+    #blank_symbol = ' '
+
+    #def in_tag(self, tag, src, attrs=None):
+        #"""Return a list of elements bracketed by the given tag"""
+        #attr_s = '' if attrs is None else \
+                 #' '.join("%s=%s" % (attr, value)
+                          #for attr, value in attrs.iteritems())
+        #return ['<%s %s>' % (tag, attr_s), src, '</%s>' % tag]
+
+    #def _ansi_colored(self, text):
+        #return ['<pre>%s</pre>' % ansi2html(text)]
+
+    #def _stylesheet(self, fname):
+        #with io.open(fname, encoding='utf-8') as f:
+            #s = f.read()
+        #return self.in_tag('style', s, dict(type='"text/css"'))
+
+    #def _out_prompt(self, output):
+        #if output.output_type == 'pyout':
+            #content = 'Out[%s]:' % self._get_prompt_number(output)
+        #else:
+            #content = ''
+        #return ['<div class="prompt output_prompt">%s</div>' % content]
+
+    #def header_body(self):
+        #"""Return the body of the header as a list of strings."""
+
+        #from pygments.formatters import HtmlFormatter
+
+        #header = []
+        #static = os.path.join(path.get_ipython_package_dir(),
+        #'frontend', 'html', 'notebook', 'static',
+        #)
+        #here = os.path.split(os.path.realpath(__file__))[0]
+        #css = os.path.join(static, 'css')
+        #for sheet in [
+            ## do we need jquery and prettify?
+            ## os.path.join(static, 'jquery', 'css', 'themes', 'base',
+            ## 'jquery-ui.min.css'),
+            ## os.path.join(static, 'prettify', 'prettify.css'),
+            #os.path.join(css, 'boilerplate.css'),
+            #os.path.join(css, 'fbm.css'),
+            #os.path.join(css, 'notebook.css'),
+            #os.path.join(css, 'renderedhtml.css'),
+            ## our overrides:
+            #os.path.join(here, '..', 'css', 'static_html.css'),
+        #]:
+            #header.extend(self._stylesheet(sheet))
+
+        ## pygments css
+        #pygments_css = HtmlFormatter().get_style_defs('.highlight')
+        #header.extend(['<meta charset="UTF-8">'])
+        #header.extend(self.in_tag('style', pygments_css,
+                                  #dict(type='"text/css"')))
+
+        ## TODO: this should be allowed to use local mathjax:
+        #header.extend(self.in_tag('script', '', {'type': '"text/javascript"',
+            #'src': '"https://c328740.ssl.cf1.rackcdn.com/mathjax/'
+                   #'latest/MathJax.js?config=TeX-AMS_HTML"',
+        #}))
+        #with io.open(os.path.join(here, '..', 'js', 'initmathjax.js'),
+                     #encoding='utf-8') as f:
+            #header.extend(self.in_tag('script', f.read(),
+                                      #{'type': '"text/javascript"'}))
+        #return header
+
+    #def optional_header(self):
+        #return ['<html>', '<head>'] + self.header_body() + \
+          #['</head>', '<body>']
+
+    #def optional_footer(self):
+        #return ['</body>', '</html>']
+
+    @text_cell
     def render_heading(self, cell):
+        marker = cell.level
         return [self.meta2str(cell.metadata),
-            '{0} {1}'.format('#' * cell.level, cell.source), '']
+                u'<h{1}>\n  {0}\n</h{1}>'.format(cell.source, marker)]
 
     def render_code(self, cell):
         if not cell.input:
             return []
+
         lines = []
         meta_code = self.meta2str(cell.metadata)
         lines.extend([meta_code])
-        lines.extend(['<!-- hack -->'])  # to be proper parsed         
+
+        lines.extend(['<div class="cell border-box-sizing code_cell vbox">'])
+
+        lines.append('<div class="input hbox">')
         n = self._get_prompt_number(cell)
-        if self.show_prompts and not self.inline_prompt:
-            lines.extend(['*In[%s]:*' % n, ''])
-        if self.show_prompts and self.inline_prompt:
-            prompt = 'In[%s]: ' % n
-            input_lines = cell.input.split('\n')
-            src = (prompt + input_lines[0] + '\n' +
-                   indent('\n'.join(input_lines[1:]), nspaces=len(prompt)))
-        else:
-            src = cell.input
-        src = highlight(src) if self.highlight_source else indent(src)
-        lines.extend([src, ''])
-        if cell.outputs and self.show_prompts and not self.inline_prompt:
-            lines.extend(['*Out[%s]:*' % n, ''])
-        for output in cell.outputs:
-            conv_fn = self.dispatch(output.output_type)
-            lines.extend(conv_fn(output))
-        #lines.append('')
+        lines.append(
+            '<div class="prompt input_prompt">In&nbsp;[%s]:</div>' % n
+        )
+        lines.append('<div class="input_area box-flex1">')
+        lines.append(highlight(cell.input))
+        lines.append('</div>')  # input_area
+        lines.append('</div>')  # input
+
+        if cell.outputs:
+            lines.append('<div class="vbox output_wrapper">')
+            lines.append('<div class="output vbox">')
+
+            for output in coalesce_streams(cell.outputs):
+                conv_fn = self.dispatch(output.output_type)
+                lines.extend(conv_fn(output))
+
+            lines.append('</div>')  # output
+            lines.append('</div>')  # output_wrapper
+
+        lines.append('</div>')  # cell
+
         return lines
 
+    @text_cell
     def render_markdown(self, cell):
-        return [self.meta2str(cell.metadata), cell.source, '']
+        return [self.meta2str(cell.metadata), markdown(cell.source)]
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
-            return [indent(self.meta2str(cell.metadata)),
-                indent(cell.source), '']
+            return [self.in_tag('pre', self.meta2str(cell.metadata)),
+                    self.in_tag('pre', cell.source)]  # testing
         else:
-            return [self.meta2str(cell.metadata), cell.source, '']
+            return [self.meta2str(cell.metadata), cell.source]
+
+    #@output_container
+    #def render_pyout(self, output):
+        #for fmt in ['html', 'latex', 'png', 'jpeg', 'svg', 'text']:
+            #if fmt in output:
+                #conv_fn = self.dispatch_display_format(fmt)
+                #return conv_fn(output)
+        #return []
+
+    #render_display_data = render_pyout
+
+    #@output_container
+    #def render_stream(self, output):
+        #return self._ansi_colored(output.text)
 
-    def render_pyout(self, output):
-        for fmt in ['html', 'latex', 'png', 'jpeg', 'svg', 'text']:
-            if fmt in output:
-                conv_fn = self.dispatch_display_format(fmt)
-                return conv_fn(output)
-        return []
+    #@output_container
+    #def render_pyerr(self, output):
+        ## Note: a traceback is a *list* of frames.
+        ## lines = []
 
-    def render_pyerr(self, output):
-        # Note: a traceback is a *list* of frames.
-        return [indent(remove_ansi('\n'.join(output.traceback))), '']
+        ## stb =
+        #return self._ansi_colored('\n'.join(output.traceback))
 
-    def _img_lines(self, img_file):
-        return ['![](%s)' % img_file, '']
+    #def _img_lines(self, img_file):
+        #return ['<img src="%s">' % img_file, '</img>']
 
-    def render_display_format_png(self, output):
-        return ['<img src="data:image/png;base64,%s"></img>' % output.png, '']
+    #def _unknown_lines(self, data):
+        #return ['<h2>Warning:: Unknown cell</h2>'] + self.in_tag('pre', data)
 
-    def render_display_format_svg(self, output):
-        return [output.svg, '']
+    #def render_display_format_png(self, output):
+        #return ['<img src="data:image/png;base64,%s"></img>' % output.png]
 
-    def render_display_format_jpeg(self, output):
-        return ['<img src="data:image/jpeg;base64,%s"></img>' % output.jpeg, '']
+    #def render_display_format_svg(self, output):
+        #return [output.svg]
 
-    def render_display_format_text(self, output):
-        return [indent(output.text), '']
+    #def render_display_format_jpeg(self, output):
+        #return ['<img src="data:image/jpeg;base64,%s"></img>' % output.jpeg]
 
-    def _unknown_lines(self, data):
-        return ['Warning: Unknown cell', data, '']
+    #def render_display_format_text(self, output):
+        #return self._ansi_colored(output.text)
 
-    def render_display_format_html(self, output):
-        return [dedent(output.html), '']
+    #def render_display_format_html(self, output):
+        #return [output.html]
 
-    def render_display_format_latex(self, output):
-        return ['LaTeX::', indent(output.latex), '']
+    #def render_display_format_latex(self, output):
+        #return [output.latex]
 
-    def render_display_format_json(self, output):
-        return ['JSON:', indent(output.json), '']
+    #def render_display_format_json(self, output):
+        ## html ignores json
+        #return []
 
-    def render_display_format_javascript(self, output):
-        return ['JavaScript:', indent(output.javascript), '']
+    #def render_display_format_javascript(self, output):
+        #return [output.javascript]
+
+    def meta2str(self, meta):
+        "transform metadata dict (containing slides delimiters) to string "
+        try:
+            meta_tuple = meta[u'slideshow'].items()
+        except KeyError as e:  # if there is not slideshow metadata
+            meta_tuple = [(u'slide_type', u'untouched')]
+        meta_list = [[x + ' = ' + unicode(y)] for x, y in meta_tuple]
+        return u'\n'.join(list(itertools.chain(*meta_list)))
 
     def convert(self, cell_separator='\n'):
         """
         Specific method to converts notebook to a string representation.
 
         Parameters
         ----------
         cell_separator : string
           Character or string to join cells with. Default is "\n"
 
         Returns
         -------
         out : string
         """
 
         lines = []
         lines.extend(self.optional_header())
         begin = ['<div class="reveal"><div class="slides">']
         lines.extend(begin)
-        slides_list = self.build_slides(cell_separator)
+        slides_list = self.build_slides()
         lines.extend(slides_list)
         end = ['</div></div>']
         lines.extend(end)
         lines.extend(self.optional_footer())
         return u'\n'.join(lines)
 
-    def build_slides(self, cell_separator='\n'):
-        "build the slides structure from text list and delimiters"
+    def clean_text(self, cell_separator='\n'):
+        "clean and reorganize the text list to be slided"
         text = self.main_body(cell_separator)
-        delim_false = [u'new_section = False',
-                       u'new_subsection = False',
-                       u'new_fragment = False']
-        text = [x for x in text if not x in delim_false]
-        left = '<section data-markdown><script type="text/template">'
-        right = '</script></section>'
-        # build lists representing each slide delimited by new_section
+        self.delim = [u'slide_type = untouched',
+                      u'slide_type = -',
+                      u'slide_type = header_slide',
+                      u'slide_type = slide',
+                      u'slide_type = fragment',
+                      u'slide_type = skip']
+        text_cell_render = \
+            u'<div class="text_cell_render border-box-sizing rendered_html">'
+        for i, j in enumerate(text):
+            if j in self.delim and text[i - 1] == text_cell_render:
+                if j == self.delim[0]:
+                    text[i - 1] = self.delim[0]
+                elif j == self.delim[1]:
+                    text[i - 1] = self.delim[1]
+                elif j == self.delim[2]:
+                    text[i - 1] = self.delim[2]
+                elif j == self.delim[3]:
+                    text[i - 1] = self.delim[3]
+                elif j == self.delim[4]:
+                    text[i - 1] = self.delim[4]
+                else:
+                    text[i - 1] = self.delim[5]
+                text[i] = text_cell_render
+        text[0] = u'slide_type = header_slide'  # defensive code
+        text.append(u'slide_type = untouched')  # to end search of skipped
+        return text
+
+    def build_slides(self):
+        "build the slides structure from text list and delimiters"
+        text = self.clean_text()
+        left = '<section>'
+        right = '</section>'
+        set_delim = self.delim[:5]
+        #elimination of skipped cells
+        for i, j in enumerate(text):
+            if j == u'slide_type = skip':
+                text.pop(i)
+                while not text[i] in set_delim:
+                    text.pop(i)
+        # elimination of none names
+        for i, j in enumerate(text):
+            if j in [u'slide_type = untouched', u'slide_type = -']:
+                text.pop(i)
+        #generation of slides as a list of list
         slides = [list(x[1]) for x in itertools.groupby(text,
-            lambda x: x == u'new_section = True') if not x[0]]
+            lambda x: x == u'slide_type = header_slide') if not x[0]]
         for slide in slides:
-            slide.insert(0, u'')  # for proper interline in html file
             slide.insert(0, left)
             slide.append(right)
-            # build each vertical slide delimited by new_subsection
-            if slide[2] == u'new_subsection = True':
-                slide.pop(2)
+            # encapsulation of each fragment
+            for i, j in enumerate(slide):
+                if j == u'slide_type = fragment':
+                    slide.pop(i)
+                    slide[i] = slide[i][:4] + ' class="fragment"' + slide[i][4:]
+            # encapsulation of each nested slide
+            if u'slide_type = slide' in slide:
                 slide.insert(0, '<section>')
                 slide.append('</section>')
-                for i, j in enumerate(slide):
-                    if j == u'new_subsection = True':
-                        slide[i] = right + left
-                        slide.insert(i + 1, u'')  # for proper interline
-            #defensive: if user do not begin new_subsection with a new_section
-            elif slide[4] == u'new_subsection = True':
-                slide[4] = right
-                slide.insert(5, u'')  # for proper interline
-                slide.insert(5, left)
-                slide.insert(5, '<section>')
-                slide.append('</section>')
-                for i, j in enumerate(slide):
-                    if j == u'new_subsection = True':
-                        slide[i] = right + left
-                        slide.insert(i + 1, u'')  # for proper interline
-            # build each fragment delimited by new_fragment
             for i, j in enumerate(slide):
-                if j == u'new_fragment = True':
-                    slide[i] = '<p class="fragment">'
-                    slide[i + 2] = '</p>'
-                    slide.insert(i + 3, u'')  # for proper interline
+                if j == u'slide_type = slide':
+                    slide[i] = right + left
         return list(itertools.chain(*slides))
 
     def save(self, outfile=None, encoding=None):
         "read and parse notebook into self.nb"
         if outfile is None:
             outfile = self.outbase + '_slides.' + 'html'
         if encoding is None:
             encoding = self.default_encoding
         with io.open(outfile, 'w', encoding=encoding) as f:
             f.write(self.output)
         return os.path.abspath(outfile)
 
     def template_read(self):
         "read the reveal_template.html"
         here = os.path.split(os.path.realpath(__file__))[0]
         reveal_template = os.path.join(here, '..', 'templates',
             'reveal_base.html')
         with io.open(reveal_template, 'r', encoding='utf-8') as f:
             template = f.readlines()
         template = [s.strip() for s in template]
         return template
 
     def template_split(self):
         "split the reveal_template.html in header and footer lists"
         temp = self.template_read()
         splitted_temp = [list(x[1]) for x in itertools.groupby(temp,
             lambda x: x == u'%slides%') if not x[0]]
         return splitted_temp
 
     def optional_header(self):
         optional_header_body = self.template_split()
         return optional_header_body[0]
 
     def optional_footer(self):
         optional_footer_body = self.template_split()
-        return optional_footer_body[1]
-
+        return optional_footer_body[1]
  No newline at end of file