Add relpath option to FilesWriter

IPython/nbconvert/writers/files.py

@@ -1,111 +1,123 b''
 """Contains writer for writing nbconvert output to filesystem."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import io
 import os
 import glob
 
 from IPython.utils.traitlets import Unicode
 from IPython.utils.path import link_or_copy, ensure_dir_exists
 from IPython.utils.py3compat import unicode_type
 
 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""")
 
+    relpath = Unicode(
+        "", config=True, 
+        help="""When copying files that the notebook depends on, copy them in
+        relation to this path, such that the destination filename will be
+        os.path.relpath(filename, relpath).""")
+
 
     # Make sure that the output directory exists.
     def _build_directory_changed(self, name, old, new):
         if new:
             ensure_dir_exists(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:
             self.log.info("Making directory %s", path)
             ensure_dir_exists(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
             # 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):
 
+                        # compute the relative path for the filename
+                        if self.relpath:
+                            dest_filename = os.path.relpath(matching_filename, self.relpath)
+                        else:
+                            dest_filename = matching_filename
+
                         # Make sure folder exists.
-                        dest = os.path.join(self.build_directory, matching_filename)
+                        dest = os.path.join(self.build_directory, dest_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)
             if isinstance(output, unicode_type):
                 with io.open(dest, 'w', encoding='utf-8') as f:
                     f.write(output)
             else:
                 with io.open(dest, 'wb') as f:
                     f.write(output)
                 
             return dest

IPython/nbconvert/writers/tests/test_files.py

@@ -1,203 +1,238 b''
 """
 Module with tests for files
 """
 
 #-----------------------------------------------------------------------------
 # 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 sys
 import os
 
 from ...tests.base import TestsBase
 from ..files import FilesWriter
 from IPython.utils.py3compat import PY3
 
 if PY3:
     from io import StringIO
 else:
     from StringIO import StringIO
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Testfiles(TestsBase):
     """Contains test functions for files.py"""
 
     def test_basic_output(self):
         """Is FilesWriter basic output correct?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
     def test_ext(self):
         """Does the FilesWriter add the correct extension to the output?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'output_extension': '.txt'}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isfile('z.txt')
             with open('z.txt', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
 
     def test_extract(self):
         """Can FilesWriter write extracted figures correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join('z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_builddir(self):
         """Can FilesWriter write to a build dir correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join(writer.build_directory, 'z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_links(self):
         """Can the FilesWriter handle linked files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test file
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('d')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = [os.path.join('sub', 'c')]
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the linked file was copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             dest = os.path.join(path, 'c')
             assert os.path.isfile(dest)
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'd')
 
     def test_glob(self):
         """Can the FilesWriter handle globbed files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test files
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('e')
             with open(os.path.join('sub', 'd'), 'w') as f:
                 f.write('e')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = ['sub/*']
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the globbed files were copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             for filename in ['c', 'd']:
                 dest = os.path.join(path, filename)
                 assert os.path.isfile(dest)
                 with open(dest, 'r') as f:
                     output = f.read()
                     self.assertEqual(output, 'e')
+
+    def test_relpath(self):
+        """Can the FilesWriter handle relative paths for linked files correctly?"""
+
+        # Work in a temporary directory.
+        with self.create_temp_cwd():
+
+            # Create test file
+            os.mkdir('sub')
+            with open(os.path.join('sub', 'c'), 'w') as f:
+                f.write('d')
+
+            # Create the resoruces dictionary
+            res = {}
+
+            # Create files writer, test output
+            writer = FilesWriter()
+            writer.files = [os.path.join('sub', 'c')]
+            writer.build_directory = u'build'
+            writer.relpath = 'sub'
+            writer.write(u'y', res, notebook_name="z")
+
+            # Check the output of the file
+            assert os.path.isdir(writer.build_directory)
+            dest = os.path.join(writer.build_directory, 'z')
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, u'y')
+
+            # Check to make sure the linked file was copied
+            dest = os.path.join(writer.build_directory, 'c')
+            assert os.path.isfile(dest)
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, 'd')