Adding rst and heading cells to the notebook format.

IPython/nbformat/v2/nbbase.py

@@ -1,179 +1,189 b''
 """The basic dict based notebook format.
 
 The Python representation of a notebook is a nested structure of
 dictionary subclasses that support attribute access
 (IPython.utils.ipstruct.Struct). The functions in this module are merely
 helpers to build the structs in the right form.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class NotebookNode(Struct):
     pass
 
 
 def from_dict(d):
     if isinstance(d, dict):
         newd = NotebookNode()
         for k,v in d.items():
             newd[k] = from_dict(v)
         return newd
     elif isinstance(d, (tuple, list)):
         return [from_dict(i) for i in d]
     else:
         return d
 
 
 def new_output(output_type=None, output_text=None, output_png=None,
     output_html=None, output_svg=None, output_latex=None, output_json=None,
     output_javascript=None, output_jpeg=None, prompt_number=None,
     etype=None, evalue=None, traceback=None):
     """Create a new code cell with input and output"""
     output = NotebookNode()
     if output_type is not None:
         output.output_type = unicode(output_type)
 
     if output_type != 'pyerr':
         if output_text is not None:
             output.text = unicode(output_text)
         if output_png is not None:
             output.png = bytes(output_png)
         if output_jpeg is not None:
             output.jpeg = bytes(output_jpeg)
         if output_html is not None:
             output.html = unicode(output_html)
         if output_svg is not None:
             output.svg = unicode(output_svg)
         if output_latex is not None:
             output.latex = unicode(output_latex)
         if output_json is not None:
             output.json = unicode(output_json)
         if output_javascript is not None:
             output.javascript = unicode(output_javascript)
 
     if output_type == u'pyout':
         if prompt_number is not None:
             output.prompt_number = int(prompt_number)
 
     if output_type == u'pyerr':
         if etype is not None:
             output.etype = unicode(etype)
         if evalue is not None:
             output.evalue = unicode(evalue)
         if traceback is not None:
             output.traceback = [unicode(frame) for frame in list(traceback)]
 
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None,
     language=u'python', collapsed=False):
     """Create a new code cell with input and output"""
     cell = NotebookNode()
     cell.cell_type = u'code'
     if language is not None:
         cell.language = unicode(language)
     if input is not None:
         cell.input = unicode(input)
     if prompt_number is not None:
         cell.prompt_number = int(prompt_number)
     if outputs is None:
         cell.outputs = []
     else:
         cell.outputs = outputs
     if collapsed is not None:
         cell.collapsed = bool(collapsed)
 
     return cell
 
 def new_text_cell(cell_type, source=None, rendered=None):
     """Create a new text cell."""
     cell = NotebookNode()
     if source is not None:
         cell.source = unicode(source)
     if rendered is not None:
         cell.rendered = unicode(rendered)
     cell.cell_type = cell_type
     return cell
 
 
+def new_heading_cell(source=None, level=1):
+    """Create a new section cell with a given integer level."""
+    cell = NotebookNode()
+    cell.cell_type = u'heading'
+    if source is not None:
+        cell.source = unicode(source)
+    cell.level = int(level)
+    return cell
+
+
 def new_worksheet(name=None, cells=None):
     """Create a worksheet by name with with a list of cells."""
     ws = NotebookNode()
     if name is not None:
         ws.name = unicode(name)
     if cells is None:
         ws.cells = []
     else:
         ws.cells = list(cells)
     return ws
 
 
 def new_notebook(metadata=None, worksheets=None):
     """Create a notebook by name, id and a list of worksheets."""
     nb = NotebookNode()
     nb.nbformat = 2
     if worksheets is None:
         nb.worksheets = []
     else:
         nb.worksheets = list(worksheets)
     if metadata is None:
         nb.metadata = new_metadata()
     else:
         nb.metadata = NotebookNode(metadata)
     return nb
 
 
 def new_metadata(name=None, authors=None, license=None, created=None,
     modified=None, gistid=None):
     """Create a new metadata node."""
     metadata = NotebookNode()
     if name is not None:
         metadata.name = unicode(name)
     if authors is not None:
         metadata.authors = list(authors)
     if created is not None:
         metadata.created = unicode(created)
     if modified is not None:
         metadata.modified = unicode(modified)
     if license is not None:
         metadata.license = unicode(license)
     if gistid is not None:
         metadata.gistid = unicode(gistid)
     return metadata
 
 def new_author(name=None, email=None, affiliation=None, url=None):
     """Create a new author."""
     author = NotebookNode()
     if name is not None:
         author.name = unicode(name)
     if email is not None:
         author.email = unicode(email)
     if affiliation is not None:
         author.affiliation = unicode(affiliation)
     if url is not None:
         author.url = unicode(url)
     return author
 

IPython/nbformat/v2/nbpy.py

@@ -1,150 +1,200 b''
 """Read and write notebooks as regular .py files.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import re
 from .rwbase import NotebookReader, NotebookWriter
-from .nbbase import new_code_cell, new_text_cell, new_worksheet, new_notebook
+from .nbbase import (
+    new_code_cell, new_text_cell, new_worksheet,
+    new_notebook, new_heading_cell
+)
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 _encoding_declaration_re = re.compile(r"^#.*coding[:=]\s*([-\w.]+)")
 
 class PyReaderError(Exception):
     pass
 
 
 class PyReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         return self.to_notebook(s,**kwargs)
 
     def to_notebook(self, s, **kwargs):
         lines = s.splitlines()
         cells = []
         cell_lines = []
+        kwargs = {}
         state = u'codecell'
         for line in lines:
             if line.startswith(u'# <nbformat>') or _encoding_declaration_re.match(line):
                 pass
             elif line.startswith(u'# <codecell>'):
-                cell = self.new_cell(state, cell_lines)
+                cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'codecell'
                 cell_lines = []
+                kwargs = {}
             elif line.startswith(u'# <htmlcell>'):
-                cell = self.new_cell(state, cell_lines)
+                cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'htmlcell'
                 cell_lines = []
+                kwargs = {}
             elif line.startswith(u'# <markdowncell>'):
-                cell = self.new_cell(state, cell_lines)
+                cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'markdowncell'
                 cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <rstcell>'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                state = u'rstcell'
+                cell_lines = []
+                kwargs = {}
+            elif line.startswith(u'# <headingcell'):
+                cell = self.new_cell(state, cell_lines, **kwargs)
+                if cell is not None:
+                    cells.append(cell)
+                    cell_lines = []
+                m = re.match(r'# <headingcell level=(?P<level>\d)>',line)
+                if m is not None:
+                    state = u'headingcell'
+                    kwargs = {}
+                    kwargs['level'] = int(m.group('level'))
+                else:
+                    state = u'codecell'
+                    kwargs = {}
+                    cell_lines = []
             else:
                 cell_lines.append(line)
         if cell_lines and state == u'codecell':
             cell = self.new_cell(state, cell_lines)
             if cell is not None:
                 cells.append(cell)
         ws = new_worksheet(cells=cells)
         nb = new_notebook(worksheets=[ws])
         return nb
 
-    def new_cell(self, state, lines):
+    def new_cell(self, state, lines, **kwargs):
         if state == u'codecell':
             input = u'\n'.join(lines)
             input = input.strip(u'\n')
             if input:
                 return new_code_cell(input=input)
         elif state == u'htmlcell':
             text = self._remove_comments(lines)
             if text:
                 return new_text_cell(u'html',source=text)
         elif state == u'markdowncell':
             text = self._remove_comments(lines)
             if text:
                 return new_text_cell(u'markdown',source=text)
+        elif state == u'rstcell':
+            text = self._remove_comments(lines)
+            if text:
+                return new_text_cell(u'rst',source=text)
+        elif state == u'headingcell':
+            text = self._remove_comments(lines)
+            level = kwargs.get('level',1)
+            if text:
+                return new_heading_cell(source=text,level=level)
 
     def _remove_comments(self, lines):
         new_lines = []
         for line in lines:
             if line.startswith(u'#'):
                 new_lines.append(line[2:])
             else:
                 new_lines.append(line)
         text = u'\n'.join(new_lines)
         text = text.strip(u'\n')
         return text
 
     def split_lines_into_blocks(self, lines):
         if len(lines) == 1:
             yield lines[0]
             raise StopIteration()
         import ast
         source = '\n'.join(lines)
         code = ast.parse(source)
         starts = [x.lineno-1 for x in code.body]
         for i in range(len(starts)-1):
             yield '\n'.join(lines[starts[i]:starts[i+1]]).strip('\n')
         yield '\n'.join(lines[starts[-1]:]).strip('\n')
 
 
 class PyWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
         lines = [u'# -*- coding: utf-8 -*-']
         lines.extend([u'# <nbformat>2</nbformat>',''])
         for ws in nb.worksheets:
             for cell in ws.cells:
                 if cell.cell_type == u'code':
                     input = cell.get(u'input')
                     if input is not None:
                         lines.extend([u'# <codecell>',u''])
                         lines.extend(input.splitlines())
                         lines.append(u'')
                 elif cell.cell_type == u'html':
                     input = cell.get(u'source')
                     if input is not None:
                         lines.extend([u'# <htmlcell>',u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
                 elif cell.cell_type == u'markdown':
                     input = cell.get(u'source')
                     if input is not None:
                         lines.extend([u'# <markdowncell>',u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
+                elif cell.cell_type == u'rst':
+                    input = cell.get(u'source')
+                    if input is not None:
+                        lines.extend([u'# <rstcell>',u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
+                elif cell.cell_type == u'heading':
+                    input = cell.get(u'source')
+                    level = cell.get(u'level',1)
+                    if input is not None:
+                        lines.extend([u'# <headingcell level=%s>' % level,u''])
+                        lines.extend([u'# ' + line for line in input.splitlines()])
+                        lines.append(u'')
         lines.append('')
         return unicode('\n'.join(lines))
 
 
 _reader = PyReader()
 _writer = PyWriter()
 
 reads = _reader.reads
 read = _reader.read
 to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes
 

IPython/nbformat/v2/rwbase.py

@@ -1,165 +1,169 b''
 """Base classes and utilities for readers and writers.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from base64 import encodestring, decodestring
 import pprint
 
 from IPython.utils.py3compat import str_to_bytes
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def restore_bytes(nb):
     """Restore bytes of image data from unicode-only formats.
     
     Base64 encoding is handled elsewhere.  Bytes objects in the notebook are
     always b64-encoded. We DO NOT encode/decode around file formats.
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 for output in cell.outputs:
                     if 'png' in output:
                         output.png = str_to_bytes(output.png, 'ascii')
                     if 'jpeg' in output:
                         output.jpeg = str_to_bytes(output.jpeg, 'ascii')
     return nb
 
 # output keys that are likely to have multiline values
 _multiline_outputs = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
 
 def rejoin_lines(nb):
     """rejoin multiline text into strings
     
     For reversing effects of ``split_lines(nb)``.
     
     This only rejoins lines that have been split, so if text objects were not split
     they will pass through unchanged.
     
     Used when reading JSON files that may have been passed through split_lines.
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 if 'input' in cell and isinstance(cell.input, list):
                     cell.input = u'\n'.join(cell.input)
                 for output in cell.outputs:
                     for key in _multiline_outputs:
                         item = output.get(key, None)
                         if isinstance(item, list):
                             output[key] = u'\n'.join(item)
+            elif cell.cell_type == 'heading':
+                pass
             else: # text cell
                 for key in ['source', 'rendered']:
                     item = cell.get(key, None)
                     if isinstance(item, list):
                         cell[key] = u'\n'.join(item)
     return nb
 
 
 def split_lines(nb):
     """split likely multiline text into lists of strings
     
     For file output more friendly to line-based VCS. ``rejoin_lines(nb)`` will
     reverse the effects of ``split_lines(nb)``.
     
     Used when writing JSON files.
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 if 'input' in cell and isinstance(cell.input, basestring):
                     cell.input = cell.input.splitlines()
                 for output in cell.outputs:
                     for key in _multiline_outputs:
                         item = output.get(key, None)
                         if isinstance(item, basestring):
                             output[key] = item.splitlines()
+            elif cell.cell_type == 'heading':
+                pass
             else: # text cell
                 for key in ['source', 'rendered']:
                     item = cell.get(key, None)
                     if isinstance(item, basestring):
                         cell[key] = item.splitlines()
     return nb
 
 # b64 encode/decode are never actually used, because all bytes objects in
 # the notebook are already b64-encoded, and we don't need/want to double-encode
 
 def base64_decode(nb):
     """Restore all bytes objects in the notebook from base64-encoded strings.
     
     Note: This is never used
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 for output in cell.outputs:
                     if 'png' in output:
                         if isinstance(output.png, unicode):
                             output.png = output.png.encode('ascii')
                         output.png = decodestring(output.png)
                     if 'jpeg' in output:
                         if isinstance(output.jpeg, unicode):
                             output.jpeg = output.jpeg.encode('ascii')
                         output.jpeg = decodestring(output.jpeg)
     return nb
 
 
 def base64_encode(nb):
     """Base64 encode all bytes objects in the notebook.
     
     These will be b64-encoded unicode strings
     
     Note: This is never used
     """
     for ws in nb.worksheets:
         for cell in ws.cells:
             if cell.cell_type == 'code':
                 for output in cell.outputs:
                     if 'png' in output:
                         output.png = encodestring(output.png).decode('ascii')
                     if 'jpeg' in output:
                         output.jpeg = encodestring(output.jpeg).decode('ascii')
     return nb
 
 
 class NotebookReader(object):
     """A class for reading notebooks."""
 
     def reads(self, s, **kwargs):
         """Read a notebook from a string."""
         raise NotImplementedError("loads must be implemented in a subclass")
 
     def read(self, fp, **kwargs):
         """Read a notebook from a file like object"""
         return self.read(fp.read(), **kwargs)
 
 
 class NotebookWriter(object):
     """A class for writing notebooks."""
 
     def writes(self, nb, **kwargs):
         """Write a notebook to a string."""
         raise NotImplementedError("loads must be implemented in a subclass")
 
     def write(self, nb, fp, **kwargs):
         """Write a notebook to a file like object"""
         return fp.write(self.writes(nb,**kwargs))
 
 
 

IPython/nbformat/v2/tests/nbexamples.py

@@ -1,109 +1,127 b''
 import os
 from base64 import encodestring
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
-    new_metadata, new_author
+    new_metadata, new_author, new_heading_cell
 )
 
 # some random base64-encoded *bytes*
 png = encodestring(os.urandom(5))
 jpeg = encodestring(os.urandom(6))
 
 ws = new_worksheet(name='worksheet1')
 
 ws.cells.append(new_text_cell(
     u'html',
     source='Some NumPy Examples',
     rendered='Some NumPy Examples'
 ))
 
 
 ws.cells.append(new_code_cell(
     input='import numpy',
     prompt_number=1,
     collapsed=False
 ))
 
 ws.cells.append(new_text_cell(
     u'markdown',
     source='A random array',
     rendered='A random array'
 ))
 
+ws.cells.append(new_text_cell(
+    u'rst',
+    source='A random array',
+))
+
+ws.cells.append(new_heading_cell(
+    u'My Heading',
+    level=2
+))
+
 ws.cells.append(new_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2,
     collapsed=True
 ))
 
 ws.cells.append(new_code_cell(
     input='print a',
     prompt_number=3,
     collapsed=False,
     outputs=[new_output(
         output_type=u'pyout',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=png,
         output_jpeg=jpeg,
         output_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;',
         prompt_number=3
     ),new_output(
         output_type=u'display_data',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=png,
         output_jpeg=jpeg,
         output_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;'
     ),new_output(
         output_type=u'pyerr',
         etype=u'NameError',
         evalue=u'NameError was here',
         traceback=[u'frame 0', u'frame 1', u'frame 2']
     )]
 ))
 
 authors = [new_author(name='Bart Simpson',email='[e-mail]',
            affiliation=u'Fox',url=u'http://www.fox.com')]
 md = new_metadata(name=u'My Notebook',license=u'BSD',created=u'8601_goes_here',
     modified=u'8601_goes_here',gistid=u'21341231',authors=authors)
 
 nb0 = new_notebook(
     worksheets=[ws, new_worksheet(name='worksheet2')],
     metadata=md
 )
 
 nb0_py = """# -*- coding: utf-8 -*-
 # <nbformat>2</nbformat>
 
 # <htmlcell>
 
 # Some NumPy Examples
 
 # <codecell>
 
 import numpy
 
 # <markdowncell>
 
 # A random array
 
+# <rstcell>
+
+# A random array
+
+# <headingcell level=2>
+
+# My Heading
+
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # <codecell>
 
 print a
 
 """
 
 

IPython/nbformat/v2/tests/test_json.py

@@ -1,34 +1,34 b''
 import pprint
 from unittest import TestCase
 
 from ..nbjson import reads, writes
 from .nbexamples import nb0
 
 
 class TestJSON(TestCase):
 
     def test_roundtrip(self):
         s = writes(nb0)
-#        print
-#        print pprint.pformat(nb0,indent=2)
-#        print
-#        print pprint.pformat(reads(s),indent=2)
-#        print
-#        print s
+        # print
+        # print pprint.pformat(nb0,indent=2)
+        # print
+        # print pprint.pformat(reads(s),indent=2)
+        # print
+        # print s
         self.assertEquals(reads(s),nb0)
     
     def test_roundtrip_nosplit(self):
         """Ensure that multiline blobs are still readable"""
         # ensures that notebooks written prior to splitlines change
         # are still readable.
         s = writes(nb0, split_lines=False)
         self.assertEquals(reads(s),nb0)
 
     def test_roundtrip_split(self):
         """Ensure that splitting multiline blocks is safe"""
         # This won't differ from test_roundtrip unless the default changes
         s = writes(nb0, split_lines=True)
         self.assertEquals(reads(s),nb0)
 
 
 

IPython/nbformat/v2/tests/test_nbbase.py

@@ -1,113 +1,134 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
-    new_author, new_metadata
+    new_author, new_metadata, new_heading_cell
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
         self.assertEquals(cc.cell_type,u'code')
         self.assertEquals(u'input' not in cc, True)
         self.assertEquals(u'prompt_number' not in cc, True)
         self.assertEquals(cc.outputs, [])
         self.assertEquals(cc.collapsed, False)
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0, collapsed=True)
         cc.outputs = [new_output(output_type=u'pyout',
             output_svg=u'foo',output_text=u'10',prompt_number=0)]
         self.assertEquals(cc.input, u'a=10')
         self.assertEquals(cc.prompt_number, 0)
         self.assertEquals(cc.language, u'python')
         self.assertEquals(cc.outputs[0].svg, u'foo')
         self.assertEquals(cc.outputs[0].text, u'10')
         self.assertEquals(cc.outputs[0].prompt_number, 0)
         self.assertEquals(cc.collapsed, True)
 
     def test_pyerr(self):
         o = new_output(output_type=u'pyerr', etype=u'NameError',
             evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
         )
         self.assertEquals(o.output_type, u'pyerr')
         self.assertEquals(o.etype, u'NameError')
         self.assertEquals(o.evalue, u'Name not found')
         self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
         self.assertEquals(tc.cell_type, u'html')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_html_cell(self):
         tc = new_text_cell(u'html', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
         self.assertEquals(tc.cell_type, u'markdown')
         self.assertEquals(u'source' not in tc, True)
         self.assertEquals(u'rendered' not in tc, True)
 
     def test_markdown_cell(self):
         tc = new_text_cell(u'markdown', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
+    def test_empty_rst_cell(self):
+        tc = new_text_cell(u'rst')
+        self.assertEquals(tc.cell_type, u'rst')
+        self.assertEquals(u'source' not in tc, True)
+        self.assertEquals(u'rendered' not in tc, True)
+
+    def test_rst_cell(self):
+        tc = new_text_cell(u'rst', 'hi', 'hi')
+        self.assertEquals(tc.source, u'hi')
+        self.assertEquals(tc.rendered, u'hi')
+
+    def test_empty_heading_cell(self):
+        tc = new_heading_cell()
+        self.assertEquals(tc.cell_type, u'heading')
+        self.assertEquals(u'source' not in tc, True)
+
+    def test_heading_cell(self):
+        tc = new_heading_cell(u'My Heading', level=2)
+        self.assertEquals(tc.source, u'My Heading')
+        self.assertEquals(tc.level, 2)
+
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
         self.assertEquals(ws.cells,[])
         self.assertEquals(u'name' not in ws, True)
 
     def test_worksheet(self):
         cells = [new_code_cell(), new_text_cell(u'html')]
         ws = new_worksheet(cells=cells,name=u'foo')
         self.assertEquals(ws.cells,cells)
         self.assertEquals(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
         self.assertEquals(nb.worksheets, [])
         self.assertEquals(nb.metadata, NotebookNode())
         self.assertEquals(nb.nbformat,2)
 
     def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         metadata = new_metadata(name=u'foo')
         nb = new_notebook(metadata=metadata,worksheets=worksheets)
         self.assertEquals(nb.metadata.name,u'foo')
         self.assertEquals(nb.worksheets,worksheets)
         self.assertEquals(nb.nbformat,2)
 
 class TestMetadata(TestCase):
 
     def test_empty_metadata(self):
         md = new_metadata()
         self.assertEquals(u'name' not in md, True)
         self.assertEquals(u'authors' not in md, True)
         self.assertEquals(u'license' not in md, True)
         self.assertEquals(u'saved' not in md, True)
         self.assertEquals(u'modified' not in md, True)
         self.assertEquals(u'gistid' not in md, True)
 
     def test_metadata(self):
         authors = [new_author(name='Bart Simpson',email='[e-mail]')]
         md = new_metadata(name=u'foo',license=u'BSD',created=u'today',
             modified=u'now',gistid=u'21341231',authors=authors)
         self.assertEquals(md.name, u'foo')
         self.assertEquals(md.license, u'BSD')
         self.assertEquals(md.created, u'today')
         self.assertEquals(md.modified, u'now')
         self.assertEquals(md.gistid, u'21341231')
         self.assertEquals(md.authors, authors)