STY: s/CheckpointManager/Checkpoints

It's easy to confuse CheckpointManager and ContentsManager.

IPython/html/services/contents/checkpoints.py

@@ -8,7 +8,7 b' Classes for managing Checkpoints.'
 from IPython.config.configurable import LoggingConfigurable
 
 
-class CheckpointManager(LoggingConfigurable):
+class Checkpoints(LoggingConfigurable):
     """
     Base class for managing checkpoints for a ContentsManager.
 
@@ -51,20 +51,25 b' class CheckpointManager(LoggingConfigurable):'
             self.delete_checkpoint(checkpoint['id'], path)
 
 
-class GenericCheckpointMixin(object):
+class GenericCheckpointsMixin(object):
     """
-    Helper for creating CheckpointManagers that can be used with any
+    Helper for creating Checkpoints subclasses that can be used with any
     ContentsManager.
 
-    Provides an implementation of `create_checkpoint` and `restore_checkpoint`
-    in terms of the following operations:
+    Provides a ContentsManager-agnostic implementation of `create_checkpoint`
+    and `restore_checkpoint` in terms of the following operations:
 
     create_file_checkpoint(self, content, format, path)
     create_notebook_checkpoint(self, nb, path)
     get_checkpoint(self, checkpoint_id, path, type)
 
-    **Any** valid CheckpointManager implementation should also be valid when
-    this mixin is applied.
+    To create a generic CheckpointManager, add this mixin to a class that
+    implement the above three methods plus the remaining Checkpoints API
+    methods:
+
+    delete_checkpoint(self, checkpoint_id, path)
+    list_checkpoints(self, path)
+    rename_checkpoint(self, checkpoint_id, old_path, new_path)
     """
 
     def create_checkpoint(self, contents_mgr, path):

IPython/html/services/contents/filecheckpoints.py

@@ -1,5 +1,5 b''
 """
-File-based CheckpointManagers.
+File-based Checkpoints implementations.
 """
 import os
 import shutil
@@ -7,8 +7,8 b' import shutil'
 from tornado.web import HTTPError
 
 from .checkpoints import (
-    CheckpointManager,
-    GenericCheckpointMixin,
+    Checkpoints,
+    GenericCheckpointsMixin,
 )
 from .fileio import FileManagerMixin
 
@@ -18,12 +18,12 b' from IPython.utils.py3compat import getcwd'
 from IPython.utils.traitlets import Unicode
 
 
-class FileCheckpointManager(FileManagerMixin, CheckpointManager):
+class FileCheckpoints(FileManagerMixin, Checkpoints):
     """
-    A CheckpointManager that caches checkpoints for files in adjacent
+    A Checkpoints that caches checkpoints for files in adjacent
     directories.
 
-    Only works with FileContentsManager.  Use GenericFileCheckpointManager if
+    Only works with FileContentsManager.  Use GenericFileCheckpoints if
     you want file-based checkpoints with another ContentsManager.
     """
 
@@ -136,10 +136,9 b' class FileCheckpointManager(FileManagerMixin, CheckpointManager):'
         )
 
 
-class GenericFileCheckpointManager(GenericCheckpointMixin,
-                                   FileCheckpointManager):
+class GenericFileCheckpoints(GenericCheckpointsMixin, FileCheckpoints):
     """
-    Local filesystem CheckpointManager that works with any conforming
+    Local filesystem Checkpoints that works with any conforming
     ContentsManager.
     """
     def create_file_checkpoint(self, content, format, path):

IPython/html/services/contents/fileio.py

@@ -30,7 +30,7 b' class FileManagerMixin(object):'
     Provides facilities for reading, writing, and copying both notebooks and
     generic files.
 
-    Shared by FileContentsManager and FileCheckpointManager.
+    Shared by FileContentsManager and FileCheckpoints.
 
     Note
     ----

IPython/html/services/contents/filemanager.py

@@ -11,7 +11,7 b' import mimetypes'
 
 from tornado import web
 
-from .filecheckpoints import FileCheckpointManager
+from .filecheckpoints import FileCheckpoints
 from .fileio import FileManagerMixin
 from .manager import ContentsManager
 
@@ -121,8 +121,8 b' class FileContentsManager(FileManagerMixin, ContentsManager):'
         if not os.path.isdir(new):
             raise TraitError("%r is not a directory" % new)
 
-    def _checkpoint_manager_class_default(self):
-        return FileCheckpointManager
+    def _checkpoints_class_default(self):
+        return FileCheckpoints
 
     def is_hidden(self, path):
         """Does the API style path correspond to a hidden directory or file?
@@ -383,7 +383,7 b' class FileContentsManager(FileManagerMixin, ContentsManager):'
                 self.check_and_sign(nb, path)
                 self._save_notebook(os_path, nb)
                 # One checkpoint should always exist for notebooks.
-                if not self.checkpoint_manager.list_checkpoints(path):
+                if not self.checkpoints.list_checkpoints(path):
                     self.create_checkpoint(path)
             elif model['type'] == 'file':
                 # Missing format will be handled internally by _save_file.
@@ -421,7 +421,7 b' class FileContentsManager(FileManagerMixin, ContentsManager):'
             # Don't delete non-empty directories.
             # A directory containing only leftover checkpoints is
             # considered empty.
-            cp_dir = getattr(self.checkpoint_manager, 'checkpoint_dir', None)
+            cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
             for entry in listing:
                 if entry != cp_dir:
                     raise web.HTTPError(400, u'Directory %s not empty' % os_path)

IPython/html/services/contents/manager.py

@@ -11,7 +11,7 b' import re'
 
 from tornado.web import HTTPError
 
-from .checkpoints import CheckpointManager
+from .checkpoints import Checkpoints
 from IPython.config.configurable import LoggingConfigurable
 from IPython.nbformat import sign, validate, ValidationError
 from IPython.nbformat.v4 import new_notebook
@@ -107,14 +107,14 b' class ContentsManager(LoggingConfigurable):'
             except Exception:
                 self.log.error("Pre-save hook failed on %s", path, exc_info=True)
 
-    checkpoint_manager_class = Type(CheckpointManager, config=True)
-    checkpoint_manager = Instance(CheckpointManager, config=True)
-    checkpoint_manager_kwargs = Dict(allow_none=False, config=True)
+    checkpoints_class = Type(Checkpoints, config=True)
+    checkpoints = Instance(Checkpoints, config=True)
+    checkpoints_kwargs = Dict(allow_none=False, config=True)
 
-    def _checkpoint_manager_default(self):
-        return self.checkpoint_manager_class(**self.checkpoint_manager_kwargs)
+    def _checkpoints_default(self):
+        return self.checkpoints_class(**self.checkpoints_kwargs)
 
-    def _checkpoint_manager_kwargs_default(self):
+    def _checkpoints_kwargs_default(self):
         return dict(
             parent=self,
             log=self.log,
@@ -223,12 +223,12 b' class ContentsManager(LoggingConfigurable):'
     def delete(self, path):
         """Delete a file/directory and any associated checkpoints."""
         self.delete_file(path)
-        self.checkpoint_manager.delete_all_checkpoints(path)
+        self.checkpoints.delete_all_checkpoints(path)
 
     def rename(self, old_path, new_path):
         """Rename a file and any checkpoints associated with that file."""
         self.rename_file(old_path, new_path)
-        self.checkpoint_manager.rename_all_checkpoints(old_path, new_path)
+        self.checkpoints.rename_all_checkpoints(old_path, new_path)
 
     def update(self, model, path):
         """Update the file's path
@@ -453,16 +453,16 b' class ContentsManager(LoggingConfigurable):'
     # Part 3: Checkpoints API
     def create_checkpoint(self, path):
         """Create a checkpoint."""
-        return self.checkpoint_manager.create_checkpoint(self, path)
+        return self.checkpoints.create_checkpoint(self, path)
 
     def restore_checkpoint(self, checkpoint_id, path):
         """
         Restore a checkpoint.
         """
-        self.checkpoint_manager.restore_checkpoint(self, checkpoint_id, path)
+        self.checkpoints.restore_checkpoint(self, checkpoint_id, path)
 
     def list_checkpoints(self, path):
-        return self.checkpoint_manager.list_checkpoints(path)
+        return self.checkpoints.list_checkpoints(path)
 
     def delete_checkpoint(self, checkpoint_id, path):
-        return self.checkpoint_manager.delete_checkpoint(checkpoint_id, path)
+        return self.checkpoints.delete_checkpoint(checkpoint_id, path)

IPython/html/services/contents/tests/test_contents_api.py

@@ -13,7 +13,7 b' pjoin = os.path.join'
 
 import requests
 
-from ..filecheckpoints import GenericFileCheckpointManager
+from ..filecheckpoints import GenericFileCheckpoints
 
 from IPython.config import Config
 from IPython.html.utils import url_path_join, url_escape, to_os_path
@@ -593,7 +593,7 b' class APITest(NotebookTestBase):'
         """
         Temporarily patch the root dir of our checkpoint manager.
         """
-        cpm = self.notebook.contents_manager.checkpoint_manager
+        cpm = self.notebook.contents_manager.checkpoints
         old_dirname = cpm.root_dir
         cpm.root_dir = dirname
         try:
@@ -603,7 +603,7 b' class APITest(NotebookTestBase):'
 
     def test_checkpoints_separate_root(self):
         """
-        Test that FileCheckpointManager functions correctly even when it's
+        Test that FileCheckpoints functions correctly even when it's
         using a different root dir from FileContentsManager.  This also keeps
         the implementation honest for use with ContentsManagers that don't map
         models to the filesystem
@@ -621,9 +621,16 b' class APITest(NotebookTestBase):'
 
 class GenericFileCheckpointsAPITest(APITest):
     """
-    Run the tests from APITest with GenericFileCheckpointManager.
+    Run the tests from APITest with GenericFileCheckpoints.
     """
-
     config = Config()
-    config.FileContentsManager.checkpoint_manager_class = \
-        GenericFileCheckpointManager
+    config.FileContentsManager.checkpoints_class = GenericFileCheckpoints
+
+    def test_config_did_something(self):
+
+        self.assertIsInstance(
+            self.notebook.contents_manager.checkpoints,
+            GenericFileCheckpoints,
+        )
+
+

IPython/html/services/contents/tests/test_manager.py

@@ -84,7 +84,7 b' class TestFileContentsManager(TestCase):'
             root = td
             os.mkdir(os.path.join(td, subd))
             fm = FileContentsManager(root_dir=root)
-            cpm = fm.checkpoint_manager
+            cpm = fm.checkpoints
             cp_dir = cpm.checkpoint_path(
                 'cp', 'test.ipynb'
             )