Merge pull request #5957 from damianavila/fragments

IPython slides: fragments are now in a linear flow and include next "-" cells.

IPython/nbconvert/postprocessors/serve.py

@@ -1,112 +1,112 b''
 """PostProcessor for serving reveal.js HTML slideshows."""
 from __future__ import print_function
 #-----------------------------------------------------------------------------
 #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 webbrowser
 
 from tornado import web, ioloop, httpserver
 from tornado.httpclient import AsyncHTTPClient
 
 from IPython.utils.traitlets import Bool, Unicode, Int
 
 from .base import PostProcessorBase
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ProxyHandler(web.RequestHandler):
     """handler the proxies requests from a local prefix to a CDN"""
     @web.asynchronous
     def get(self, prefix, url):
         """proxy a request to a CDN"""
         proxy_url = "/".join([self.settings['cdn'], url])
         client = self.settings['client']
         client.fetch(proxy_url, callback=self.finish_get)
     
     def finish_get(self, response):
         """finish the request"""
         # copy potentially relevant headers
         for header in ["Content-Type", "Cache-Control", "Date", "Last-Modified", "Expires"]:
             if header in response.headers:
                 self.set_header(header, response.headers[header])
         self.finish(response.body)
 
 class ServePostProcessor(PostProcessorBase):
     """Post processor designed to serve files
     
     Proxies reveal.js requests to a CDN if no local reveal.js is present
     """
 
 
     open_in_browser = Bool(True, config=True,
         help="""Should the browser be opened automatically?"""
     )
-    reveal_cdn = Unicode("https://cdn.jsdelivr.net/reveal.js/2.5.0", config=True,
+    reveal_cdn = Unicode("https://cdn.jsdelivr.net/reveal.js/2.6.2", config=True,
         help="""URL for reveal.js CDN."""
     )
     reveal_prefix = Unicode("reveal.js", config=True, help="URL prefix for reveal.js")
     ip = Unicode("127.0.0.1", config=True, help="The IP address to listen on.")
     port = Int(8000, config=True, help="port for the server to listen on.")
 
     def postprocess(self, input):
         """Serve the build directory with a webserver."""
         dirname, filename = os.path.split(input)
         handlers = [
             (r"/(.+)", web.StaticFileHandler, {'path' : dirname}),
             (r"/", web.RedirectHandler, {"url": "/%s" % filename})
         ]
         
         if ('://' in self.reveal_prefix or self.reveal_prefix.startswith("//")):
             # reveal specifically from CDN, nothing to do
             pass
         elif os.path.isdir(os.path.join(dirname, self.reveal_prefix)):
             # reveal prefix exists
             self.log.info("Serving local %s", self.reveal_prefix)
         else:
             self.log.info("Redirecting %s requests to %s", self.reveal_prefix, self.reveal_cdn)
             handlers.insert(0, (r"/(%s)/(.*)" % self.reveal_prefix, ProxyHandler))
         
         app = web.Application(handlers,
             cdn=self.reveal_cdn,
             client=AsyncHTTPClient(),
         )
         # hook up tornado logging to our logger
         try:
             from tornado import log
             log.app_log = self.log
         except ImportError:
             # old tornado (<= 3), ignore
             pass
     
         http_server = httpserver.HTTPServer(app)
         http_server.listen(self.port, address=self.ip)
         url = "http://%s:%i/%s" % (self.ip, self.port, filename)
         print("Serving your slides at %s" % url)
         print("Use Control-C to stop this server")
         if self.open_in_browser:
             webbrowser.open(url, new=2)
         try:
             ioloop.IOLoop.instance().start()
         except KeyboardInterrupt:
             print("\nInterrupted")
 
 def main(path):
     """allow running this module to serve the slides"""
     server = ServePostProcessor()
     server(path)
     
 if __name__ == '__main__':
     import sys
     main(sys.argv[1])

IPython/nbconvert/preprocessors/revealhelp.py

@@ -1,63 +1,75 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
 #-----------------------------------------------------------------------------
 
 from .base import Preprocessor
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class RevealHelpPreprocessor(Preprocessor):
 
     url_prefix = Unicode('reveal.js', config=True,
                          help="""The URL prefix for reveal.js.
                          This can be a a relative URL for a local copy of reveal.js,
                          or point to a CDN.
                          
                          For speaker notes to work, a local reveal.js prefix must be used.
                          """
     )
 
     def preprocess(self, nb, resources):
         """
         Called once to 'preprocess' contents of the notebook.
 
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             preprocessors to pass variables into the Jinja engine.
         """
 
         for worksheet in nb.worksheets:
             for index, cell in enumerate(worksheet.cells):
 
                 #Make sure the cell has slideshow metadata.
                 cell.metadata.slide_type = cell.get('metadata', {}).get('slideshow', {}).get('slide_type', '-')
 
-                #Get the slide type.  If type is start of subslide or slide,
+                #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'
-
+                #Prevent the rendering of "do nothing" cells before fragments
+                #Group fragments passing frag_number to the data-fragment-index
+                if cell.metadata.slide_type in ['fragment']:
+                    worksheet.cells[index].metadata.frag_number = index
+                    i = 1
+                    while i < len(worksheet.cells) - index:
+                        worksheet.cells[index + i].metadata.frag_helper = 'fragment_end'
+                        worksheet.cells[index + i].metadata.frag_number = index
+                        i += 1
+                #Restart the slide_helper when the cell status is changed
+                #to other types.
+                if cell.metadata.slide_type in ['-', 'skip', 'notes', 'fragment']:
+                    worksheet.cells[index - 1].metadata.slide_helper = '-'
 
         if not isinstance(resources['reveal'], dict):
             resources['reveal'] = {}
         resources['reveal']['url_prefix'] = self.url_prefix
         return nb, resources

IPython/nbconvert/preprocessors/tests/test_revealhelp.py

@@ -1,93 +1,94 b''
 """
 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 PreprocessorTestsBase
 from ..revealhelp import RevealHelpPreprocessor
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Testrevealhelp(PreprocessorTestsBase):
     """Contains test functions for revealhelp.py"""
 
     def build_notebook(self):
-        """Build a reveal slides notebook in memory for use with tests.  
+        """Build a reveal slides notebook in memory for use with tests.
         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_preprocessor(self):
         """Make an instance of a preprocessor"""
         preprocessor = RevealHelpPreprocessor()
         preprocessor.enabled = True
         return preprocessor
 
 
     def test_constructor(self):
         """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()
         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 preprocessor """
         nb = self.build_notebook()
         res = self.build_resources()
         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
 
         # Make sure slide end is only applied to the cells preceeding slide 
         # cells.
-        assert 'slide_helper' not in cells[1].metadata
+        assert 'slide_helper' in cells[1].metadata
+        self.assertEqual(cells[1].metadata['slide_helper'], '-')
 
         # 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/templates/html/slides_reveal.tpl

@@ -1,197 +1,203 b''
 {%- extends 'basic.tpl' -%}
 {% from 'mathjax.tpl' import mathjax %}
 
 {%- block any_cell scoped -%}
 {%- if cell.metadata.slide_type in ['slide'] -%}
     <section>
     <section>
     {{ super() }}
 {%- elif cell.metadata.slide_type in ['subslide'] -%}
     <section>
     {{ super() }}
 {%- elif cell.metadata.slide_type in ['-'] -%}
-    {{ super() }}
+    {%- if cell.metadata.frag_helper in ['fragment_end'] -%}
+        <div class="fragment" data-fragment-index="{{ cell.metadata.frag_number }}">
+        {{ super() }}
+        </div>
+    {%- else -%}
+        {{ super() }}
+    {%- endif -%}
 {%- elif cell.metadata.slide_type in ['skip'] -%}
     <div style=display:none>
     {{ super() }}
     </div>
 {%- elif cell.metadata.slide_type in ['notes'] -%}
     <aside class="notes">
     {{ super() }}
     </aside>
 {%- elif cell.metadata.slide_type in ['fragment'] -%}
-    <div class="fragment">
+    <div class="fragment" data-fragment-index="{{ cell.metadata.frag_number }}">
     {{ super() }}
     </div>
 {%- endif -%}
 {%- if cell.metadata.slide_helper in ['subslide_end'] -%}
     </section>
 {%- elif cell.metadata.slide_helper in ['slide_end'] -%}
     </section>
     </section>
 {%- endif -%}
 {%- endblock any_cell -%}
 
 {% block header %}
 <!DOCTYPE html>
 <html>
 <head>
 
 <meta charset="utf-8" />
 <meta http-equiv="X-UA-Compatible" content="chrome=1" />
 
 <meta name="apple-mobile-web-app-capable" content="yes" />
 <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
 
 <title>{{resources['metadata']['name']}} slides</title>
 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
 
 <!-- General and theme style sheets -->
 <link rel="stylesheet" href="{{resources.reveal.url_prefix}}/css/reveal.css">
 <link rel="stylesheet" href="{{resources.reveal.url_prefix}}/css/theme/simple.css" id="theme">
 
 <!-- For syntax highlighting -->
 <link rel="stylesheet" href="{{resources.reveal.url_prefix}}/lib/css/zenburn.css">
 
 <!-- If the query includes 'print-pdf', include the PDF print sheet -->
 <script>
 if( window.location.search.match( /print-pdf/gi ) ) {
         var link = document.createElement( 'link' );
         link.rel = 'stylesheet';
         link.type = 'text/css';
         link.href = '{{resources.reveal.url_prefix}}/css/print/pdf.css';
         document.getElementsByTagName( 'head' )[0].appendChild( link );
 }
 
 </script>
 
 <!--[if lt IE 9]>
 <script src="{{resources.reveal.url_prefix}}/lib/js/html5shiv.js"></script>
 <![endif]-->
 
 <!-- Get Font-awesome from cdn -->
 <link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome.css">
 
 {% for css in resources.inlining.css -%}
     <style type="text/css">
     {{ css }}
     </style>
 {% endfor %}
 
 <style type="text/css">
 /* Overrides of notebook CSS for static HTML export */
 html {
   overflow-y: auto;
 }
 .reveal {
   font-size: 160%;
 }
 .reveal pre {
   width: inherit;
   padding: 0.4em;
   margin: 0px;
   font-family: monospace, sans-serif;
   font-size: 80%;
   box-shadow: 0px 0px 0px rgba(0, 0, 0, 0);
 }
 .reveal section img {
   border: 0px solid black;
   box-shadow: 0 0 10px rgba(0, 0, 0, 0);
 }
 .reveal i {
   font-style: normal;
   font-family: FontAwesome;
   font-size: 2em;
 }
 .reveal .slides {
   text-align: left;
 }
 .reveal.fade {
   opacity: 1;
 }
 .reveal .progress {
   position: static;
 }
 div.input_area {
   padding: 0.06em;
 }
 div.code_cell {
   background-color: transparent;
 }
 div.prompt {
   width: 11ex;
   padding: 0.4em;
   margin: 0px;
   font-family: monospace, sans-serif;
   font-size: 80%;
   text-align: right;
 }
 div.output_area pre {
   font-family: monospace, sans-serif;
   font-size: 80%;
 }
 div.output_prompt {
   /* 5px right shift to account for margin in parent container */
   margin: 5px 5px 0 0;
 }
 .rendered_html p {
   text-align: inherit;
 }
 </style>
 
 <!-- Custom stylesheet, it must be in the same directory as the html file -->
 <link rel="stylesheet" href="custom.css">
 
 </head>
 {% endblock header%}
 
 
 {% block body %}
 <body>
 <div class="reveal">
 <div class="slides">
 {{ super() }}
 </div>
 </div>
 
 <script src="{{resources.reveal.url_prefix}}/lib/js/head.min.js"></script>
 
 <script src="{{resources.reveal.url_prefix}}/js/reveal.js"></script>
 
 <script>
 
 // Full list of configuration options available here: https://github.com/hakimel/reveal.js#configuration
 Reveal.initialize({
 controls: true,
 progress: true,
 history: true,
 
 theme: Reveal.getQueryHash().theme, // available themes are in /css/theme
 transition: Reveal.getQueryHash().transition || 'linear', // default/cube/page/concave/zoom/linear/none
 
 // Optional libraries used to extend on reveal.js
 dependencies: [
 { src: "{{resources.reveal.url_prefix}}/lib/js/classList.js", condition: function() { return !document.body.classList; } },
 { src: "{{resources.reveal.url_prefix}}/plugin/notes/notes.js", async: true, condition: function() { return !!document.body.classList; } }
 ]
 });
 </script>
 
 <!-- Loading mathjax macro -->
 {{ mathjax() }}
 
 <script>
 Reveal.addEventListener( 'slidechanged', function( event ) {
   window.scrollTo(0,0);
   MathJax.Hub.Rerender(event.currentSlide);
 });
 </script>
 
 </body>
 {% endblock body %}
 
 {% block footer %}
 </html>
 {% endblock footer %}
  No newline at end of file