Merge pull request #425 from MITx/feature/bridger/new_wiki

Feature/bridger/new wiki

common/lib/mitxmako/mitxmako/makoloader.py

@@ -0,0 +1,63 @@
+
+from django.template.base import TemplateDoesNotExist
+from django.template.loader import make_origin, get_template_from_string
+from django.template.loaders.filesystem import Loader as FilesystemLoader
+from django.template.loaders.app_directories import Loader as AppDirectoriesLoader
+
+from mitxmako.template import Template
+
+class MakoLoader(object):
+    """
+    This is a Django loader object which will load the template as a
+    Mako template if the first line is "## mako". It is based off BaseLoader
+    in django.template.loader.
+    """
+    
+    is_usable = False
+
+    def __init__(self, base_loader):
+        # base_loader is an instance of a BaseLoader subclass
+        self.base_loader = base_loader
+    
+    def __call__(self, template_name, template_dirs=None):
+        return self.load_template(template_name, template_dirs)
+
+    def load_template(self, template_name, template_dirs=None):
+        source, display_name = self.load_template_source(template_name, template_dirs)
+        
+        if source.startswith("## mako\n"):
+            # This is a mako template
+            template = Template(text=source, uri=template_name)
+            return template, None
+        else:
+            # This is a regular template
+            origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
+            try:
+                template = get_template_from_string(source, origin, template_name)
+                return template, None
+            except TemplateDoesNotExist:
+                # If compiling the template we found raises TemplateDoesNotExist, back off to
+                # returning the source and display name for the template we were asked to load.
+                # This allows for correct identification (later) of the actual template that does
+                # not exist.
+                return source, display_name
+    
+    def load_template_source(self, template_name, template_dirs=None):
+        # Just having this makes the template load as an instance, instead of a class.
+        return self.base_loader.load_template_source(template_name, template_dirs)
+
+    def reset(self):
+        self.base_loader.reset()
+    
+
+class MakoFilesystemLoader(MakoLoader):
+    is_usable = True
+    
+    def __init__(self):
+        MakoLoader.__init__(self, FilesystemLoader())
+        
+class MakoAppDirectoriesLoader(MakoLoader):
+    is_usable = True
+    
+    def __init__(self):
+        MakoLoader.__init__(self, AppDirectoriesLoader())

common/lib/mitxmako/mitxmako/template.py

@@ -12,18 +12,48 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+from django.conf import settings
 from mako.template import Template as MakoTemplate
 
-from . import middleware
+from mitxmako import middleware
 
-django_variables = ['lookup', 'template_dirs', 'output_encoding',
+django_variables = ['lookup', 'output_encoding',
                     'module_directory', 'encoding_errors']
 
-
+# TODO: We should make this a Django Template subclass that simply has the MakoTemplate inside of it? (Intead of inheriting from MakoTemplate)
 class Template(MakoTemplate):
+    """
+    This bridges the gap between a Mako template and a djano template. It can
+    be rendered like it is a django template because the arguments are transformed
+    in a way that MakoTemplate can understand.
+    """
+    
     def __init__(self, *args, **kwargs):
         """Overrides base __init__ to provide django variable overrides"""
         if not kwargs.get('no_django', False):
             overrides = dict([(k, getattr(middleware, k, None),) for k in django_variables])
+            overrides['lookup'] = overrides['lookup']['main']
             kwargs.update(overrides)
         super(Template, self).__init__(*args, **kwargs)
+    
+    
+    def render(self, context_instance):
+        """
+        This takes a render call with a context (from Django) and translates
+        it to a render call on the mako template.
+        """
+        # collapse context_instance to a single dictionary for mako
+        context_dictionary = {}
+        
+        # In various testing contexts, there might not be a current request context.
+        if middleware.requestcontext is not None:
+            for d in middleware.requestcontext:
+                context_dictionary.update(d)
+        for d in context_instance:
+            context_dictionary.update(d)
+        context_dictionary['settings'] = settings
+        context_dictionary['MITX_ROOT_URL'] = settings.MITX_ROOT_URL
+        context_dictionary['django_context'] = context_instance
+                
+        return super(Template, self).render(**context_dictionary)
+        

common/lib/mitxmako/mitxmako/templatetag_helpers.py

@@ -0,0 +1,53 @@
+from django.template import loader
+from django.template.base import Template, Context
+from django.template.loader import get_template, select_template
+
+def django_template_include(file_name, mako_context):
+    """
+    This can be used within a mako template to include a django template
+    in the way that a django-style {% include %} does. Pass it context
+    which can be the mako context ('context') or a dictionary.
+    """
+    
+    dictionary = dict( mako_context )
+    return loader.render_to_string(file_name, dictionary=dictionary)
+
+
+def render_inclusion(func, file_name, takes_context, django_context, *args, **kwargs):
+    """
+    This allows a mako template to call a template tag function (written
+    for django templates) that is an "inclusion tag". These functions are
+    decorated with @register.inclusion_tag.
+    
+    -func: This is the function that is registered as an inclusion tag.
+    You must import it directly using a python import statement.
+    -file_name: This is the filename of the template, passed into the
+    @register.inclusion_tag statement.
+    -takes_context: This is a parameter of the @register.inclusion_tag.
+    -django_context: This is an instance of the django context. If this
+    is a mako template rendered through the regular django rendering calls,
+    a copy of the django context is available as 'django_context'.
+    -*args and **kwargs are the arguments to func.
+    """
+    
+    if takes_context:
+        args = [django_context] + list(args)
+    
+    _dict = func(*args, **kwargs)
+    if isinstance(file_name, Template):
+        t = file_name
+    elif not isinstance(file_name, basestring) and is_iterable(file_name):
+        t = select_template(file_name)
+    else:
+        t = get_template(file_name)
+        
+    nodelist = t.nodelist
+    
+    new_context = Context(_dict)
+    csrf_token = django_context.get('csrf_token', None)
+    if csrf_token is not None:
+        new_context['csrf_token'] = csrf_token
+    
+    return nodelist.render(new_context)
+    
+

common/lib/xmodule/xmodule/course_module.py

@@ -147,7 +147,7 @@ class CourseDescriptor(SequenceDescriptor):
         return self.location.course
 
     @property
-    def wiki_namespace(self):
+    def wiki_slug(self):
         return self.location.course
 
     @property