Merge branch 'master' into feature/lyla/honoresponse

cms/djangoapps/auth/authz.py

+import logging
+import sys
+
+from django.contrib.auth.models import User, Group
+from django.core.exceptions import PermissionDenied
+
+from xmodule.modulestore import Location
+
+# define a couple of simple roles, we just need ADMIN and EDITOR now for our purposes
+ADMIN_ROLE_NAME = 'admin'
+EDITOR_ROLE_NAME = 'editor'
+
+# we're just making a Django group for each location/role combo
+# to do this we're just creating a Group name which is a formatted string
+# of those two variables
+def get_course_groupname_for_role(location, role):
+    loc = Location(location)
+    groupname = loc.course_id  + ':' + role
+    return groupname
+
+def get_users_in_course_group_by_role(location, role):
+    groupname = get_course_groupname_for_role(location, role)
+    group = Group.objects.get(name=groupname)
+    return group.user_set.all()
+
+
+'''
+Create all permission groups for a new course and subscribe the caller into those roles
+'''
+def create_all_course_groups(creator, location):
+    create_new_course_group(creator, location, ADMIN_GROUP_NAME)
+    create_new_course_group(creator, location, EDITOR_GROUP_NAME)
+
+
+def create_new_course_group(creator, location, role):
+    groupname = get_course_groupname_for_role(location, role)
+    (group, created) =Group.get_or_create(name=groupname)
+    if created:
+        group.save()
+
+    creator.groups.add(group)
+    creator.save()
+
+    return
+
+
+def add_user_to_course_group(caller, user, location, role):
+    # only admins can add/remove other users
+    if not is_user_in_course_group_role(caller, location, ADMIN_ROLE_NAME):
+        raise PermissionDenied
+
+    if user.is_active and user.is_authenticated:
+        groupname = get_course_groupname_for_role(location, role)
+
+        group = Group.objects.get(name=groupname)
+        user.groups.add(group)
+        user.save()
+        return True
+
+    return False
+
+
+def get_user_by_email(email):
+    user = None
+    # try to look up user, return None if not found
+    try:
+        user = User.objects.get(email=email)
+    except:
+        pass
+
+    return user
+
+
+def remove_user_from_course_group(caller, user, location, role):
+    # only admins can add/remove other users
+    if not is_user_in_course_group_role(caller, location, ADMIN_ROLE_NAME):
+        raise PermissionDenied
+
+    # see if the user is actually in that role, if not then we don't have to do anything
+    if is_user_in_course_group_role(user, location, role) == True:
+        groupname = get_course_groupname_for_role(location, role)
+
+        group = Group.objects.get(name=groupname)
+        user.groups.remove(group)
+        user.save()
+
+
+def is_user_in_course_group_role(user, location, role):
+    if user.is_active and user.is_authenticated:
+        return user.groups.filter(name=get_course_groupname_for_role(location,role)).count() > 0
+
+    return False
+
+    

cms/djangoapps/contentstore/utils.py

+from xmodule.modulestore import Location
+from xmodule.modulestore.django import modulestore
+
+'''
+cdodge: for a given Xmodule, return the course that it belongs to
+NOTE: This makes a lot of assumptions about the format of the course location
+Also we have to assert that this module maps to only one course item - it'll throw an
+assert if not
+'''
+def get_course_location_for_item(location):
+    item_loc = Location(location)
+
+    # check to see if item is already a course, if so we can skip this
+    if item_loc.category != 'course':
+        # @hack! We need to find the course location however, we don't
+        # know the 'name' parameter in this context, so we have
+        # to assume there's only one item in this query even though we are not specifying a name
+        course_search_location = ['i4x', item_loc.org, item_loc.course, 'course', None]
+        courses = modulestore().get_items(course_search_location)
+
+        # make sure we found exactly one match on this above course search
+        found_cnt = len(courses)
+        if found_cnt == 0:
+            raise BaseException('Could not find course at {0}'.format(course_search_location))
+
+        if found_cnt > 1:
+            raise BaseException('Found more than one course at {0}. There should only be one!!!'.format(course_search_location))
+
+        location = courses[0].location
+
+    return location

cms/envs/common.py

@@ -118,6 +118,7 @@ TEMPLATE_LOADERS = (
 )
 
 MIDDLEWARE_CLASSES = (
+    'contentserver.middleware.StaticContentServer',
     'django.middleware.cache.UpdateCacheMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
@@ -130,7 +131,7 @@ MIDDLEWARE_CLASSES = (
     'track.middleware.TrackMiddleware',
     'mitxmako.middleware.MakoMiddleware',
 
-    'django.middleware.transaction.TransactionMiddleware',
+    'django.middleware.transaction.TransactionMiddleware'
 )
 
 ############################ SIGNAL HANDLERS ################################
@@ -324,6 +325,7 @@ INSTALLED_APPS = (
 
     # For CMS
     'contentstore',
+    'auth',
     'github_sync',
     'student',  # misleading name due to sharing with lms
 

cms/envs/dev.py

@@ -28,6 +28,17 @@ MODULESTORE = {
     }
 }
 
+# cdodge: This is the specifier for the MongoDB (using GridFS) backed static content store
+# This is for static content for courseware, not system static content (e.g. javascript, css, edX branding, etc)
+CONTENTSTORE = {
+    'ENGINE': 'xmodule.contentstore.mongo.MongoContentStore',
+    'OPTIONS': {
+        'host': 'localhost',
+        'db' : 'xcontent',
+    }
+}
+
+
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',

cms/templates/course_index.html

@@ -10,5 +10,7 @@
   <section class="main-content">
   </section>
 
+  <%include file="widgets/upload_assets.html"/>
+
 </section>
 </%block>

cms/templates/manage_users.html

+<%inherit file="base.html" />
+<%block name="title">Course Editor Manager</%block>
+<%include file="widgets/header.html"/>
+
+<%block name="content">
+<section class="main-container">
+
+  <h2>Course Editors</h2>
+  <ul>
+    % for user in editors:
+    <li>${user.email} (${user.username})</li>
+    % endfor
+  </ul>
+
+  <form action="add_user" id="addEditorsForm">
+    <label>email:&nbsp;</label><input type="text" name="email" placeholder="email@example.com..." />
+    <input type="submit" value="add editor" />
+  </form>
+  <div id="result"></div>
+
+<script>
+  $("#addEditorsForm").submit(function(event) {
+  event.preventDefault();
+  var $form = $(this),
+  email = $form.find('input[name="email"]').val(),
+  url = $form.attr('action');
+  $.post(url, {email:email},
+  function(data) {
+  if(data['Status'] != 'OK')
+  $("#result").empty().append(data['ErrMsg']);
+  else
+  location.reload();
+  });
+  });
+</script>
+
+</section>
+</%block>

cms/templates/widgets/upload_assets.html

+<section>
+  <div class="assset-upload">
+    You can upload file assets (such as images) to reference in your courseware
+    <form action="${upload_asset_callback_url}" method="post" enctype="multipart/form-data">
+      <input type="file" name="file">
+      <input type="submit" value="Upload File">
+    </form>
+    <div class="progress" style="position:relative; width:400px; border: 1px solid #ddd; padding: 1px; border-radius: 3px;">
+      <div class="bar" style="background-color: #B4F5B4; width:0%; height:20px; border-radius: 3px;"></div>
+      <div class="percent">0%</div>
+    </div>
+
+    <div id="status"></div>
+  </div>
+
+</section>
+
+<script src="http://malsup.github.com/jquery.form.js"></script>
+<script>
+(function() {
+    
+var bar = $('.bar');
+var percent = $('.percent');
+var status = $('#status');
+   
+$('form').ajaxForm({
+    beforeSend: function() {
+        status.empty();
+        var percentVal = '0%';
+        bar.width(percentVal)
+        percent.html(percentVal);
+    },
+    uploadProgress: function(event, position, total, percentComplete) {
+        var percentVal = percentComplete + '%';
+        bar.width(percentVal)
+        percent.html(percentVal);
+    },
+complete: function(xhr) {
+status.html(xhr.responseText);
+}
+}); 
+
+})();       
+</script>

cms/urls.py

@@ -17,7 +17,16 @@ urlpatterns = ('',
         'contentstore.views.course_index', name='course_index'),
     url(r'^github_service_hook$', 'github_sync.views.github_post_receive'),
     url(r'^preview/modx/(?P<preview_id>[^/]*)/(?P<location>.*?)/(?P<dispatch>[^/]*)$',
-        'contentstore.views.preview_dispatch', name='preview_dispatch')
+        'contentstore.views.preview_dispatch', name='preview_dispatch'),
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/course/(?P<coursename>[^/]+)/upload_asset$', 
+        'contentstore.views.upload_asset', name='upload_asset'),
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/course/(?P<name>[^/]+)/manage_users$',
+        'contentstore.views.manage_users', name='manage_users'),
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/course/(?P<name>[^/]+)/add_user$',
+        'contentstore.views.add_user', name='add_user'),
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/course/(?P<name>[^/]+)/remove_user$',
+        'contentstore.views.remove_user', name='remove_user')
+
 )
 
 # User creation and updating views

common/djangoapps/cache_toolbox/core.py

@@ -107,3 +107,15 @@ def instance_key(model, instance_or_pk):
         model._meta.module_name,
         getattr(instance_or_pk, 'pk', instance_or_pk),
     )
+
+def content_key(filename):
+    return 'content:%s' % (filename)
+
+def set_cached_content(content):
+    cache.set(content_key(content.filename), content)
+
+def get_cached_content(filename):
+    return cache.get(content_key(filename))
+
+def del_cached_content(filename):
+    cache.delete(content_key(filename))

common/djangoapps/contentserver/middleware.py

+import logging
+import time
+
+from django.http import HttpResponse, Http404, HttpResponseNotModified
+
+from xmodule.contentstore.django import contentstore
+from xmodule.contentstore.content import StaticContent, XASSET_LOCATION_TAG
+from cache_toolbox.core import get_cached_content, set_cached_content
+from xmodule.exceptions import NotFoundError
+
+
+class StaticContentServer(object):
+    def process_request(self, request):
+        # look to see if the request is prefixed with 'c4x' tag
+        if request.path.startswith('/' + XASSET_LOCATION_TAG):
+
+            # first look in our cache so we don't have to round-trip to the DB
+            content = get_cached_content(request.path)
+            if content is None:
+                # nope, not in cache, let's fetch from DB
+                try:
+                    content = contentstore().find(request.path)
+                except NotFoundError:
+                    raise Http404
+
+                # since we fetched it from DB, let's cache it going forward
+                set_cached_content(content)
+            else:
+                # @todo: we probably want to have 'cache hit' counters so we can
+                # measure the efficacy of our caches
+                pass
+
+            # see if the last-modified at hasn't changed, if not return a 302 (Not Modified)
+
+            # convert over the DB persistent last modified timestamp to a HTTP compatible
+            # timestamp, so we can simply compare the strings
+            last_modified_at_str = content.last_modified_at.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
+            # see if the client has cached this content, if so then compare the
+            # timestamps, if they are the same then just return a 304 (Not Modified)
+            if 'HTTP_IF_MODIFIED_SINCE' in request.META:
+                if_modified_since = request.META['HTTP_IF_MODIFIED_SINCE']
+                if if_modified_since == last_modified_at_str:
+                    return HttpResponseNotModified()
+
+            response = HttpResponse(content.data, content_type=content.content_type)
+            response['Last-Modified'] = last_modified_at_str
+
+            return response

common/djangoapps/external_auth/djangostore.py

+"""A openid store using django cache"""
+
+from openid.store.interface import OpenIDStore
+from openid.store import nonce
+
+from django.core.cache import cache
+
+import logging
+import time
+
+DEFAULT_ASSOCIATIONS_TIMEOUT = 60
+DEFAULT_NONCE_TIMEOUT = 600
+
+ASSOCIATIONS_KEY_PREFIX = 'openid.provider.associations.'
+NONCE_KEY_PREFIX = 'openid.provider.nonce.'
+
+log = logging.getLogger('DjangoOpenIDStore')
+
+
+def get_url_key(server_url):
+    key = ASSOCIATIONS_KEY_PREFIX + server_url
+    return key
+
+
+def get_nonce_key(server_url, timestamp, salt):
+    key = '{prefix}{url}.{ts}.{salt}'.format(prefix=NONCE_KEY_PREFIX,
+                                             url=server_url,
+                                             ts=timestamp,
+                                             salt=salt)
+    return key
+
+
+class DjangoOpenIDStore(OpenIDStore):
+    def __init__(self):
+        log.info('DjangoStore cache:' + str(cache.__class__))
+
+    def storeAssociation(self, server_url, assoc):
+        key = get_url_key(server_url)
+
+        log.info('storeAssociation {0}'.format(key))
+
+        associations = cache.get(key, {})
+        associations[assoc.handle] = assoc
+
+        cache.set(key, associations, DEFAULT_ASSOCIATIONS_TIMEOUT)
+
+    def getAssociation(self, server_url, handle=None):
+        key = get_url_key(server_url)
+
+        log.info('getAssociation {0}'.format(key))
+
+        associations = cache.get(key, {})
+
+        assoc = None
+
+        if handle is None:
+            # get best association
+            valid_assocs = [a for a in associations if a.getExpiresIn() > 0]
+            if valid_assocs:
+                valid_assocs.sort(lambda a: a.getExpiresIn(), reverse=True)
+                assoc = valid_assocs.sort[0]
+        else:
+            assoc = associations.get(handle)
+
+        # check expiration and remove if it has expired
+        if assoc and assoc.getExpiresIn() <= 0:
+            if handle is None:
+                cache.delete(key)
+            else:
+                associations.pop(handle)
+                cache.set(key, associations, DEFAULT_ASSOCIATIONS_TIMEOUT)
+            assoc = None
+
+        return assoc
+
+    def removeAssociation(self, server_url, handle):
+        key = get_url_key(server_url)
+
+        log.info('removeAssociation {0}'.format(key))
+
+        associations = cache.get(key, {})
+
+        removed = False
+
+        if associations:
+            if handle is None:
+                cache.delete(key)
+                removed = True
+            else:
+                assoc = associations.pop(handle)
+                if assoc:
+                    cache.set(key, associations, DEFAULT_ASSOCIATIONS_TIMEOUT)
+                    removed = True
+
+        return removed
+
+    def useNonce(self, server_url, timestamp, salt):
+        key = get_nonce_key(server_url, timestamp, salt)
+
+        log.info('useNonce {0}'.format(key))
+
+        if abs(timestamp - time.time()) > nonce.SKEW:
+            return False
+
+        anonce = cache.get(key)
+
+        found = False
+
+        if anonce is None:
+            cache.set(key, '-', DEFAULT_NONCE_TIMEOUT)
+            found = False
+        else:
+            found = True
+
+        return found
+
+    def cleanupNonces(self):
+        # not necesary, keys will timeout
+        return 0
+
+    def cleanupAssociations(self):
+        # not necesary, keys will timeout
+        return 0

common/djangoapps/external_auth/views.py

@@ -7,6 +7,7 @@ import string
 import fnmatch
 
 from external_auth.models import ExternalAuthMap
+from external_auth.djangostore import DjangoOpenIDStore
 
 from django.conf import settings
 from django.contrib.auth import REDIRECT_FIELD_NAME, authenticate, login
@@ -30,7 +31,6 @@ from openid.consumer.consumer import SUCCESS
 
 from openid.server.server import Server
 from openid.server.trustroot import TrustRoot
-from openid.store.filestore import FileOpenIDStore
 from openid.extensions import ax, sreg
 
 import student.views as student_views
@@ -271,10 +271,7 @@ def get_xrds_url(resource, request):
     """
     Return the XRDS url for a resource
     """
-    host = request.META['HTTP_HOST']
-
-    if not host.endswith('edx.org'):
-        return None
+    host = request.get_host()
 
     location = host + '/openid/provider/' + resource + '/'
 
@@ -296,6 +293,8 @@ def add_openid_simple_registration(request, response, data):
                 sreg_data['email'] = data['email']
             elif field == 'fullname' and 'fullname' in data:
                 sreg_data['fullname'] = data['fullname']
+            elif field == 'nickname' and 'nickname' in data:
+                sreg_data['nickname'] = data['nickname']
 
         # construct sreg response
         sreg_response = sreg.SRegResponse.extractResponse(sreg_request,
@@ -400,7 +399,7 @@ def provider_login(request):
         return default_render_failure(request, "Invalid OpenID request")
 
     # initialize store and server
-    store = FileOpenIDStore('/tmp/openid_provider')
+    store = DjangoOpenIDStore()
     server = Server(store, endpoint)
 
     # handle OpenID request
@@ -489,13 +488,22 @@ def provider_login(request):
             url = endpoint + urlquote(user.username)
             response = openid_request.answer(True, None, url)
 
-            return provider_respond(server,
-                                    openid_request,
-                                    response,
-                                    {
-                                        'fullname': profile.name,
-                                        'email': user.email
-                                    })
+            # TODO: for CS50 we are forcibly returning the username
+            # instead of fullname. In the OpenID simple registration
+            # extension, we don't have to return any fields we don't
+            # want to, even if they were marked as required by the
+            # Consumer. The behavior of what to do when there are
+            # missing fields is up to the Consumer. The proper change
+            # should only return the username, however this will likely
+            # break the CS50 client. Temporarily we will be returning
+            # username filling in for fullname in addition to username 
+            # as sreg nickname.
+            results = {
+                'nickname': user.username,
+                'email': user.email,
+                'fullname': user.username
+                }
+            return provider_respond(server, openid_request, response, results)
 
         request.session['openid_error'] = True
         msg = "Login failed - Account not active for user {0}".format(username)

common/djangoapps/status/__init__.py

+

common/djangoapps/status/status.py

+"""
+A tiny app that checks for a status message.
+"""
+
+from django.conf import settings
+import json
+import logging
+import os
+import sys
+
+log = logging.getLogger(__name__)
+
+def get_site_status_msg(course_id):
+    """
+    Look for a file settings.STATUS_MESSAGE_PATH.  If found, read it,
+    parse as json, and do the following:
+
+    * if there is a key 'global', include that in the result list.
+    * if course is not None, and there is a key for course.id, add that to the result list.
+    * return "<br/>".join(result)
+
+    Otherwise, return None.
+
+    If something goes wrong, returns None.  ("is there a status msg?" logic is
+    not allowed to break the entire site).
+    """
+    try:
+        if os.path.isfile(settings.STATUS_MESSAGE_PATH):
+            with open(settings.STATUS_MESSAGE_PATH) as f:
+                content = f.read()
+        else:
+            return None
+
+        status_dict = json.loads(content)
+        msg = status_dict.get('global', None)
+        if course_id in status_dict:
+            msg = msg + "<br>" if msg else ''
+            msg += status_dict[course_id]
+
+        return msg
+    except:
+        log.exception("Error while getting a status message.")
+        return None

common/djangoapps/status/tests.py

+from django.conf import settings
+from django.test import TestCase
+import os
+from override_settings import override_settings
+from tempfile import NamedTemporaryFile
+
+from status import get_site_status_msg
+
+# Get a name where we can put test files
+TMP_FILE = NamedTemporaryFile(delete=False)
+TMP_NAME = TMP_FILE.name
+# Close it--we just want the path.
+TMP_FILE.close()
+
+
+@override_settings(STATUS_MESSAGE_PATH=TMP_NAME)
+class TestStatus(TestCase):
+    """Test that the get_site_status_msg function does the right thing"""
+
+    no_file = None
+
+    invalid_json = """{
+        "global" : "Hello, Globe",
+        }"""
+
+    global_only = """{
+        "global" : "Hello, Globe"
+        }"""
+
+    toy_only = """{
+        "edX/toy/2012_Fall" : "A toy story"
+        }"""
+
+    global_and_toy = """{
+        "global" : "Hello, Globe",
+        "edX/toy/2012_Fall" : "A toy story"
+        }"""
+
+
+    # json to use, expected results for course=None (e.g. homepage),
+    # for toy course, for full course.  Note that get_site_status_msg
+    # is supposed to return global message even if course=None.  The
+    # template just happens to not display it outside the courseware
+    # at the moment...
+    checks = [
+        (no_file, None, None, None),
+        (invalid_json, None, None, None),
+        (global_only, "Hello, Globe", "Hello, Globe", "Hello, Globe"),
+        (toy_only, None, "A toy story", None),
+        (global_and_toy, "Hello, Globe", "Hello, Globe<br>A toy story", "Hello, Globe"),
+        ]
+
+    def setUp(self):
+        """
+        Fake course ids, since we don't have to have full django
+        settings (common tests run without the lms settings imported)
+        """
+        self.full_id = 'edX/full/2012_Fall'
+        self.toy_id = 'edX/toy/2012_Fall'
+
+    def create_status_file(self, contents):
+        """
+        Write contents to settings.STATUS_MESSAGE_PATH.
+        """
+        with open(settings.STATUS_MESSAGE_PATH, 'w') as f:
+            f.write(contents)
+
+    def remove_status_file(self):
+        """Delete the status file if it exists"""
+        if os.path.exists(settings.STATUS_MESSAGE_PATH):
+            os.remove(settings.STATUS_MESSAGE_PATH)
+
+    def tearDown(self):
+        self.remove_status_file()
+
+    def test_get_site_status_msg(self):
+        """run the tests"""
+        for (json_str, exp_none, exp_toy, exp_full) in self.checks:
+
+            self.remove_status_file()
+            if json_str:
+                self.create_status_file(json_str)
+
+            print "checking results for {0}".format(json_str)
+            print "course=None:"
+            self.assertEqual(get_site_status_msg(None), exp_none)
+            print "course=toy:"
+            self.assertEqual(get_site_status_msg(self.toy_id), exp_toy)
+            print "course=full:"
+            self.assertEqual(get_site_status_msg(self.full_id), exp_full)

common/djangoapps/student/management/commands/set_staff.py

+from django.contrib.auth.models import User
+from django.core.management.base import BaseCommand, CommandError
+import re
+
+
+class Command(BaseCommand):
+
+    args = '<user/email user/email ...>'
+    help = """
+    This command will set isstaff to true for one or more users.
+    Lookup by username or email address, assumes usernames
+    do not look like email addresses.
+    """
+
+    def handle(self, *args, **kwargs):
+
+        if len(args) < 1:
+            print Command.help
+            return
+
+        for user in args:
+
+            if re.match('[^@]+@[^@]+\.[^@]+', user):
+                try:
+                    v = User.objects.get(email=user)
+                except:
+                    raise CommandError("User {0} does not exist".format(
+                        user))
+            else:
+                try:
+                    v = User.objects.get(username=user)
+                except:
+                    raise CommandError("User {0} does not exist".format(
+                        user))
+
+            v.is_staff = True
+            v.save()

common/lib/capa/capa/calc.py

@@ -48,7 +48,7 @@ general_whitespace = re.compile('[^\w]+')
 
 
 def check_variables(string, variables):
-    '''  Confirm the only variables in string are defined.
+    '''Confirm the only variables in string are defined.
 
     Pyparsing uses a left-to-right parser, which makes the more
     elegant approach pretty hopeless.
@@ -56,7 +56,8 @@ def check_variables(string, variables):
     achar = reduce(lambda a,b:a|b ,map(Literal,alphas)) # Any alphabetic character
     undefined_variable = achar + Word(alphanums)
     undefined_variable.setParseAction(lambda x:UndefinedVariable("".join(x)).raiseself())
-    varnames = varnames | undefined_variable'''
+    varnames = varnames | undefined_variable
+    '''
     possible_variables = re.split(general_whitespace, string)  # List of all alnums in string
     bad_variables = list()
     for v in possible_variables:
@@ -71,7 +72,8 @@ def check_variables(string, variables):
 
 
 def evaluator(variables, functions, string, cs=False):
-    ''' Evaluate an expression. Variables are passed as a dictionary
+    '''
+    Evaluate an expression. Variables are passed as a dictionary
     from string to value. Unary functions are passed as a dictionary
     from string to function. Variables must be floats.
     cs: Case sensitive
@@ -108,6 +110,7 @@ def evaluator(variables, functions, string, cs=False):
 
     if string.strip() == "":
         return float('nan')
+
     ops = {"^": operator.pow,
             "*": operator.mul,
             "/": operator.truediv,
@@ -169,14 +172,19 @@ def evaluator(variables, functions, string, cs=False):
     def func_parse_action(x):
         return [all_functions[x[0]](x[1])]
 
-    number_suffix = reduce(lambda a, b: a | b, map(Literal, suffixes.keys()), NoMatch())  # SI suffixes and percent
+    # SI suffixes and percent
+    number_suffix = reduce(lambda a, b: a | b, map(Literal, suffixes.keys()), NoMatch())
     (dot, minus, plus, times, div, lpar, rpar, exp) = map(Literal, ".-+*/()^")
 
     number_part = Word(nums)
-    inner_number = (number_part + Optional("." + number_part)) | ("." + number_part)  # 0.33 or 7 or .34
-    number = Optional(minus | plus) + inner_number + \
-        Optional(CaselessLiteral("E") + Optional("-") + number_part) + \
-        Optional(number_suffix)  # 0.33k or -17
+
+    # 0.33 or 7 or .34
+    inner_number = (number_part + Optional("." + number_part)) | ("." + number_part)
+
+    # 0.33k or -17
+    number = (Optional(minus | plus) + inner_number
+              + Optional(CaselessLiteral("E") + Optional("-") + number_part)
+              + Optional(number_suffix))
     number = number.setParseAction(number_parse_action)  # Convert to number
 
     # Predefine recursive variables
@@ -201,9 +209,11 @@ def evaluator(variables, functions, string, cs=False):
         varnames.setParseAction(lambda x: map(lambda y: all_variables[y], x))
     else:
         varnames = NoMatch()
+
     # Same thing for functions.
     if len(all_functions) > 0:
-        funcnames = sreduce(lambda x, y: x | y, map(lambda x: CasedLiteral(x), all_functions.keys()))
+        funcnames = sreduce(lambda x, y: x | y,
+                            map(lambda x: CasedLiteral(x), all_functions.keys()))
         function = funcnames + lpar.suppress() + expr + rpar.suppress()
         function.setParseAction(func_parse_action)
     else:

common/lib/capa/capa/chem/__init__.py

+

common/lib/capa/capa/correctmap.py

@@ -5,23 +5,26 @@
 
 
 class CorrectMap(object):
-    '''
+    """
     Stores map between answer_id and response evaluation result for each question
     in a capa problem.  The response evaluation result for each answer_id includes
     (correctness, npoints, msg, hint, hintmode).
 
     - correctness : either 'correct' or 'incorrect'
     - npoints     : None, or integer specifying number of points awarded for this answer_id
-    - msg         : string (may have HTML) giving extra message response (displayed below textline or textbox)
-    - hint        : string (may have HTML) giving optional hint (displayed below textline or textbox, above msg)
+    - msg         : string (may have HTML) giving extra message response
+                    (displayed below textline or textbox)
+    - hint        : string (may have HTML) giving optional hint
+                    (displayed below textline or textbox, above msg)
     - hintmode    : one of (None,'on_request','always') criteria for displaying hint
     - queuestate  : Dict {key:'', time:''} where key is a secret string, and time is a string dump
                     of a DateTime object in the format '%Y%m%d%H%M%S'. Is None when not queued
 
     Behaves as a dict.
-    '''
+    """
     def __init__(self, *args, **kwargs):
-        self.cmap = dict()		# start with empty dict
+        # start with empty dict
+        self.cmap = dict()
         self.items = self.cmap.items
         self.keys = self.cmap.keys
         self.set(*args, **kwargs)
@@ -33,7 +36,15 @@ class CorrectMap(object):
         return self.cmap.__iter__()
 
     # See the documentation for 'set_dict' for the use of kwargs
-    def set(self, answer_id=None, correctness=None, npoints=None, msg='', hint='', hintmode=None, queuestate=None, **kwargs):
+    def set(self,
+            answer_id=None,
+            correctness=None,
+            npoints=None,
+            msg='',
+            hint='',
+            hintmode=None,
+            queuestate=None, **kwargs):
+
         if answer_id is not None:
             self.cmap[answer_id] = {'correctness': correctness,
                                     'npoints': npoints,
@@ -56,12 +67,13 @@ class CorrectMap(object):
         '''
         Set internal dict of CorrectMap to provided correct_map dict
 
-        correct_map is saved by LMS as a plaintext JSON dump of the correctmap dict. This means that
-        when the definition of CorrectMap (e.g. its properties) are altered, existing correct_map dict
-        not coincide with the newest CorrectMap format as defined by self.set.
+        correct_map is saved by LMS as a plaintext JSON dump of the correctmap dict. This
+        means that when the definition of CorrectMap (e.g. its properties) are altered,
+        an existing correct_map dict not coincide with the newest CorrectMap format as
+        defined by self.set.
 
         For graceful migration, feed the contents of each correct map to self.set, rather than
-        making a direct copy of the given correct_map dict. This way, the common keys between 
+        making a direct copy of the given correct_map dict. This way, the common keys between
         the incoming correct_map dict and the new CorrectMap instance will be written, while
         mismatched keys will be gracefully ignored.
 
@@ -69,14 +81,20 @@ class CorrectMap(object):
             If correct_map is a one-level dict, then convert it to the new dict of dicts format.
         '''
         if correct_map and not (type(correct_map[correct_map.keys()[0]]) == dict):
-            self.__init__()	                                  # empty current dict
-            for k in correct_map: self.set(k, correct_map[k]) # create new dict entries
+            # empty current dict
+            self.__init__()
+
+            # create new dict entries
+            for k in correct_map:
+                self.set(k, correct_map[k])
         else:
             self.__init__()
-            for k in correct_map: self.set(k, **correct_map[k])
+            for k in correct_map:
+                self.set(k, **correct_map[k])
 
     def is_correct(self, answer_id):
-        if answer_id in self.cmap: return self.cmap[answer_id]['correctness'] == 'correct'
+        if answer_id in self.cmap:
+            return self.cmap[answer_id]['correctness'] == 'correct'
         return None
 
     def is_queued(self, answer_id):
@@ -94,14 +112,18 @@ class CorrectMap(object):
             return npoints
         elif self.is_correct(answer_id):
             return 1
-        return 0 # if not correct and no points have been assigned, return 0
+         # if not correct and no points have been assigned, return 0
+        return 0
 
     def set_property(self, answer_id, property, value):
-        if answer_id in self.cmap: self.cmap[answer_id][property] = value
-        else: self.cmap[answer_id] = {property: value}
+        if answer_id in self.cmap:
+            self.cmap[answer_id][property] = value
+        else:
+            self.cmap[answer_id] = {property: value}
 
     def get_property(self, answer_id, property, default=None):
-        if answer_id in self.cmap: return self.cmap[answer_id].get(property, default)
+        if answer_id in self.cmap:
+            return self.cmap[answer_id].get(property, default)
         return default
 
     def get_correctness(self, answer_id):

common/lib/capa/capa/eia.py

-""" Standard resistor codes.
+"""
+Standard resistor codes.
 http://en.wikipedia.org/wiki/Electronic_color_code
 """
 E6 = [10, 15, 22, 33, 47, 68]
+
 E12 = [10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82]
+
 E24 = [10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82, 11, 13, 16, 20, 24, 30, 36, 43, 51, 62, 75, 91]
+
 E48 = [100, 121, 147, 178, 215, 261, 316, 383, 464, 562, 681, 825, 105, 127, 154, 187, 226, 274, 332, 402, 487, 590, 715, 866, 110, 133, 162, 196, 237, 287, 348, 422, 511, 619, 750, 909, 115, 140, 169, 205, 249, 301, 365, 442, 536, 649, 787, 953]
+
 E96 = [100, 121, 147, 178, 215, 261, 316, 383, 464, 562, 681, 825, 102, 124, 150, 182, 221, 267, 324, 392, 475, 576, 698, 845, 105, 127, 154, 187, 226, 274, 332, 402, 487, 590, 715, 866, 107, 130, 158, 191, 232, 280, 340, 412, 499, 604, 732, 887, 110, 133, 162, 196, 237, 287, 348, 422, 511, 619, 750, 909, 113, 137, 165, 200, 243, 294, 357, 432, 523, 634, 768, 931, 115, 140, 169, 205, 249, 301, 365, 442, 536, 649, 787, 953, 118, 143, 174, 210, 255, 309, 374, 453, 549, 665, 806, 976]
+
 E192 = [100, 121, 147, 178, 215, 261, 316, 383, 464, 562, 681, 825, 101, 123, 149, 180, 218, 264, 320, 388, 470, 569, 690, 835, 102, 124, 150, 182, 221, 267, 324, 392, 475, 576, 698, 845, 104, 126, 152, 184, 223, 271, 328, 397, 481, 583, 706, 856, 105, 127, 154, 187, 226, 274, 332, 402, 487, 590, 715, 866, 106, 129, 156, 189, 229, 277, 336, 407, 493, 597, 723, 876, 107, 130, 158, 191, 232, 280, 340, 412, 499, 604, 732, 887, 109, 132, 160, 193, 234, 284, 344, 417, 505, 612, 741, 898, 110, 133, 162, 196, 237, 287, 348, 422, 511, 619, 750, 909, 111, 135, 164, 198, 240, 291, 352, 427, 517, 626, 759, 920, 113, 137, 165, 200, 243, 294, 357, 432, 523, 634, 768, 931, 114, 138, 167, 203, 246, 298, 361, 437, 530, 642, 777, 942, 115, 140, 169, 205, 249, 301, 365, 442, 536, 649, 787, 953, 117, 142, 172, 208, 252, 305, 370, 448, 542, 657, 796, 965, 118, 143, 174, 210, 255, 309, 374, 453, 549, 665, 806, 976, 120, 145, 176, 213, 258, 312, 379, 459, 556, 673, 816, 988]

common/lib/capa/capa/templates/chemicalequationinput.html

+<section id="chemicalequationinput_${id}" class="chemicalequationinput">
+    <div class="script_placeholder" data-src="${previewer}"/>
+
+    % if status == 'unsubmitted':
+    <div class="unanswered" id="status_${id}">
+    % elif status == 'correct':
+    <div class="correct" id="status_${id}">
+    % elif status == 'incorrect':
+    <div class="incorrect" id="status_${id}">
+    % elif status == 'incomplete':
+    <div class="incorrect" id="status_${id}">
+    % endif
+
+  <input type="text" name="input_${id}" id="input_${id}" value="${value|h}"
+   % if size:
+   size="${size}"
+   % endif
+   />
+
+      <p class="status">
+        % if status == 'unsubmitted':
+        unanswered
+        % elif status == 'correct':
+        correct
+        % elif status == 'incorrect':
+        incorrect
+        % elif status == 'incomplete':
+        incomplete
+        % endif
+      </p>
+
+      <div id="input_${id}_preview" class="equation">
+      </div>
+      
+  <p id="answer_${id}" class="answer"></p>
+
+% if status in ['unsubmitted', 'correct', 'incorrect', 'incomplete']:
+</div>
+% endif
+</section>

common/lib/capa/capa/templates/choicegroup.html

 <form class="choicegroup capa_inputtype" id="inputtype_${id}">
-  % if state == 'unsubmitted':
-  <span class="unanswered" style="display:inline-block;" id="status_${id}"></span>
-  % elif state == 'correct': 
-  <span class="correct" id="status_${id}"></span>
-  % elif state == 'incorrect':
-  <span class="incorrect" id="status_${id}"></span>
-  % elif state == 'incomplete':
-  <span class="incorrect" id="status_${id}"></span>
-  % endif
+  <div class="indicator_container">
+    % if state == 'unsubmitted':
+    <span class="unanswered" style="display:inline-block;" id="status_${id}"></span>
+    % elif state == 'correct': 
+    <span class="correct" id="status_${id}"></span>
+    % elif state == 'incorrect':
+    <span class="incorrect" id="status_${id}"></span>
+    % elif state == 'incomplete':
+    <span class="incorrect" id="status_${id}"></span>
+    % endif
+  </div>
 
   <fieldset>
     % for choice_id, choice_description in choices:

common/lib/capa/capa/templates/crystallography.html

+<% doinline = "inline" if inline else "" %>
+
+<section id="textinput_${id}" class="textinput ${doinline}" >
+     <div id="holder" style="width:${width};height:${height}"></div>
+    <div class="script_placeholder" data-src="/static/js/raphael.js"></div><div class="script_placeholder" data-src="/static/js/sylvester.js"></div><div class="script_placeholder" data-src="/static/js/underscore-min.js"></div>
+    <div class="script_placeholder" data-src="/static/js/crystallography.js"></div>
+
+
+    % if state == 'unsubmitted':
+    <div class="unanswered ${doinline}" id="status_${id}">
+    % elif state == 'correct':
+    <div class="correct ${doinline}" id="status_${id}">
+    % elif state == 'incorrect':
+    <div class="incorrect ${doinline}" id="status_${id}">
+    % elif state == 'incomplete':
+    <div class="incorrect ${doinline}" id="status_${id}">
+    % endif
+    % if hidden:
+      <div style="display:none;" name="${hidden}" inputid="input_${id}" />
+    % endif
+
+  <input type="text" name="input_${id}" id="input_${id}" value="${value}"
+   % if size:
+   size="${size}"
+   % endif
+   % if hidden:
+    style="display:none;"
+   % endif
+   />
+
+      <p class="status">
+        % if state == 'unsubmitted':
+        unanswered
+        % elif state == 'correct':
+        correct
+        % elif state == 'incorrect':
+        incorrect
+        % elif state == 'incomplete':
+        incomplete
+        % endif
+      </p>
+
+  <p id="answer_${id}" class="answer"></p>
+
+  % if msg:
+      <span class="message">${msg|n}</span>
+  % endif
+% if state in ['unsubmitted', 'correct', 'incorrect', 'incomplete'] or hidden:
+</div>
+% endif
+</section>

common/lib/capa/capa/templates/textbox.html

@@ -5,8 +5,6 @@
        % endif
   >${value|h}</textarea>
 
-  <span id="answer_${id}"></span>
-
   <div class="grader-status">
     % if state == 'unsubmitted':
       <span class="unanswered" style="display:inline-block;" id="status_${id}">Unanswered</span>
@@ -26,6 +24,8 @@
     <p class="debug">${state}</p>
   </div>
 
+  <span id="answer_${id}"></span>
+
   <div class="external-grader-message">
     ${msg|n}
   </div>
@@ -42,7 +42,12 @@
         lineWrapping: true,
         indentUnit: "${tabsize}",
         tabSize: "${tabsize}",
-        indentWithTabs: true,
+        indentWithTabs: false,
+        extraKeys: {
+            "Tab": function(cm) {
+                cm.replaceSelection("${' '*tabsize}", "end");
+            }
+        },
         smartIndent: false
       });
     });

common/lib/capa/capa/tests/__init__.py

+import fs
+import fs.osfs
+import os
+
+from mock import Mock
+
+TEST_DIR = os.path.dirname(os.path.realpath(__file__))
+
+test_system = Mock(
+    ajax_url='courses/course_id/modx/a_location',
+    track_function=Mock(),
+    get_module=Mock(),
+    render_template=Mock(),
+    replace_urls=Mock(),
+    user=Mock(),
+    filestore=fs.osfs.OSFS(os.path.join(TEST_DIR, "test_files")),
+    debug=True,
+    xqueue={'interface':None, 'callback_url':'/', 'default_queuename': 'testqueue', 'waittime': 10},
+    node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
+    anonymous_student_id = 'student'
+)

common/lib/capa/capa/tests/test_inputtypes.py

+"""
+Tests of input types (and actually responsetypes too)
+"""
+
+from datetime import datetime
+import json
+from mock import Mock
+from nose.plugins.skip import SkipTest
+import os
+import unittest
+
+from . import test_system
+from capa import inputtypes
+
+from lxml import etree
+
+def tst_render_template(template, context):
+    """
+    A test version of render to template.  Renders to the repr of the context, completely ignoring the template name.
+    """
+    return repr(context)
+
+
+system = Mock(render_template=tst_render_template)
+
+class OptionInputTest(unittest.TestCase):
+    '''
+    Make sure option inputs work
+    '''
+    def test_rendering_new(self):
+        xml = """<optioninput options="('Up','Down')" id="sky_input" correct="Up"/>"""
+        element = etree.fromstring(xml)
+
+        value = 'Down'
+        status = 'answered'
+        context = inputtypes._optioninput(element, value, status, test_system.render_template)
+        print 'context: ', context
+
+        expected = {'value': 'Down',
+                    'options': [('Up', 'Up'), ('Down', 'Down')],
+                    'state': 'answered',
+                    'msg': '',
+                    'inline': '',
+                    'id': 'sky_input'}
+
+        self.assertEqual(context, expected)
+
+
+    def test_rendering(self):
+        xml_str = """<optioninput options="('Up','Down')" id="sky_input" correct="Up"/>"""
+        element = etree.fromstring(xml_str)
+
+        state = {'value': 'Down',
+                 'id': 'sky_input',
+                 'status': 'answered'}
+        option_input = inputtypes.OptionInput(system, element, state)
+
+        context = option_input._get_render_context()
+
+        expected = {'value': 'Down',
+                    'options': [('Up', 'Up'), ('Down', 'Down')],
+                    'state': 'answered',
+                    'msg': '',
+                    'inline': '',
+                    'id': 'sky_input'}
+
+        self.assertEqual(context, expected)
+

common/lib/capa/capa/util.py

@@ -11,7 +11,7 @@ def compare_with_tolerance(v1, v2, tol):
 
      - v1    :  student result (number)
      - v2    :  instructor result (number)
-     - tol   :  tolerance (string or number)
+     - tol   :  tolerance (string representing a number)
 
     '''
     relative = tol.endswith('%')
@@ -53,8 +53,4 @@ def is_file(file_to_test):
     '''
     Duck typing to check if 'file_to_test' is a File object
     '''
-    is_file = True
-    for method in ['read', 'name']:
-        if not hasattr(file_to_test, method):
-            is_file = False
-    return is_file 
+    return all(hasattr(file_to_test, method) for method in ['read', 'name'])

common/lib/capa/capa/xqueue_interface.py

@@ -12,7 +12,7 @@ dateformat = '%Y%m%d%H%M%S'
 
 def make_hashkey(seed):
     '''
-    Generate a string key by hashing 
+    Generate a string key by hashing
     '''
     h = hashlib.md5()
     h.update(str(seed))
@@ -20,27 +20,27 @@ def make_hashkey(seed):
 
 
 def make_xheader(lms_callback_url, lms_key, queue_name):
-    '''
+    """
     Generate header for delivery and reply of queue request.
 
     Xqueue header is a JSON-serialized dict:
         { 'lms_callback_url': url to which xqueue will return the request (string),
-          'lms_key': secret key used by LMS to protect its state (string), 
+          'lms_key': secret key used by LMS to protect its state (string),
           'queue_name': designate a specific queue within xqueue server, e.g. 'MITx-6.00x' (string)
         }
-    '''
+    """
     return json.dumps({ 'lms_callback_url': lms_callback_url,
                         'lms_key': lms_key,
                         'queue_name': queue_name })
 
 
 def parse_xreply(xreply):
-    '''
+    """
     Parse the reply from xqueue. Messages are JSON-serialized dict:
         { 'return_code': 0 (success), 1 (fail)
           'content': Message from xqueue (string)
         }
-    '''
+    """
     try:
         xreply = json.loads(xreply)
     except ValueError, err:
@@ -61,11 +61,11 @@ class XQueueInterface(object):
         self.url  = url
         self.auth = django_auth
         self.session = requests.session(auth=requests_auth)
-        
+
     def send_to_queue(self, header, body, files_to_upload=None):
-        '''
+        """
         Submit a request to xqueue.
-        
+
         header: JSON-serialized dict in the format described in 'xqueue_interface.make_xheader'
 
         body: Serialized data for the receipient behind the queueing service. The operation of
@@ -74,14 +74,16 @@ class XQueueInterface(object):
         files_to_upload: List of file objects to be uploaded to xqueue along with queue request
 
         Returns (error_code, msg) where error_code != 0 indicates an error
-        '''
+        """
         # Attempt to send to queue
         (error, msg) = self._send_to_queue(header, body, files_to_upload)
 
-        if error and (msg == 'login_required'): # Log in, then try again
+        # Log in, then try again
+        if error and (msg == 'login_required'):
             self._login()
             if files_to_upload is not None:
-                for f in files_to_upload: # Need to rewind file pointers
+                # Need to rewind file pointers
+                for f in files_to_upload:
                     f.seek(0)
             (error, msg) = self._send_to_queue(header, body, files_to_upload)
 
@@ -91,18 +93,18 @@ class XQueueInterface(object):
     def _login(self):
         payload = { 'username': self.auth['username'],
                     'password': self.auth['password'] }
-        return self._http_post(self.url+'/xqueue/login/', payload)
+        return self._http_post(self.url + '/xqueue/login/', payload)
 
 
     def _send_to_queue(self, header, body, files_to_upload):
         payload = {'xqueue_header': header,
                    'xqueue_body'  : body}
-        files = {} 
+        files = {}
         if files_to_upload is not None:
             for f in files_to_upload:
                 files.update({ f.name: f })
 
-        return self._http_post(self.url+'/xqueue/submit/', payload, files=files)
+        return self._http_post(self.url + '/xqueue/submit/', payload, files=files)
 
 
     def _http_post(self, url, data, files=None):
@@ -111,7 +113,7 @@ class XQueueInterface(object):
         except requests.exceptions.ConnectionError, err:
             log.error(err)
             return (1, 'cannot connect to server')
-        
+
         if r.status_code not in [200]:
             return (1, 'unexpected HTTP status code [%d]' % r.status_code)
 

common/lib/xmodule/xmodule/capa_module.py

@@ -10,6 +10,7 @@ import sys
 
 from datetime import timedelta
 from lxml import etree
+from lxml.html import rewrite_links
 from pkg_resources import resource_string
 
 from capa.capa_problem import LoncapaProblem
@@ -75,9 +76,13 @@ class CapaModule(XModule):
     '''
     icon_class = 'problem'
 
-    js = {'coffee': [resource_string(__name__, 'js/src/capa/display.coffee')],
+    js = {'coffee': [resource_string(__name__, 'js/src/capa/display.coffee'),
+                     resource_string(__name__, 'js/src/collapsible.coffee'),
+                     resource_string(__name__, 'js/src/javascript_loader.coffee'),
+                    ],
           'js': [resource_string(__name__, 'js/src/capa/imageinput.js'),
                  resource_string(__name__, 'js/src/capa/schematic.js')]}
+
     js_module_name = "Problem"
     css = {'scss': [resource_string(__name__, 'css/capa/display.scss')]}
 
@@ -128,6 +133,11 @@ class CapaModule(XModule):
         if self.rerandomize == 'never':
             self.seed = 1
         elif self.rerandomize == "per_student" and hasattr(self.system, 'id'):
+            # TODO: This line is badly broken:
+            # (1) We're passing student ID to xmodule.
+            # (2) There aren't bins of students.  -- we only want 10 or 20 randomizations, and want to assign students
+            # to these bins, and may not want cohorts.  So e.g. hash(your-id, problem_id) % num_bins.
+            #     - analytics really needs small number of bins.
             self.seed = system.id
         else:
             self.seed = None
@@ -332,6 +342,15 @@ class CapaModule(XModule):
             html = '<div id="problem_{id}" class="problem" data-url="{ajax_url}">'.format(
                 id=self.location.html_id(), ajax_url=self.system.ajax_url) + html + "</div>"
 
+        # cdodge: OK, we have to do two rounds of url reference subsitutions
+        # one which uses the 'asset library' that is served by the contentstore and the
+        # more global /static/ filesystem based static content.
+        # NOTE: rewrite_content_links is defined in XModule
+        # This is a bit unfortunate and I'm sure we'll try to considate this into
+        # a one step process.
+        html = rewrite_links(html, self.rewrite_content_links)
+
+        # now do the substitutions which are filesystem based, e.g. '/static/' prefixes
         return self.system.replace_urls(html, self.metadata['data_dir'])
 
     def handle_ajax(self, dispatch, get):
@@ -605,12 +624,14 @@ class CapaModule(XModule):
         if self.closed():
             event_info['failure'] = 'closed'
             self.system.track_function('reset_problem_fail', event_info)
-            return "Problem is closed"
+            return {'success': False,
+                    'error': "Problem is closed"}
 
         if not self.lcp.done:
             event_info['failure'] = 'not_done'
             self.system.track_function('reset_problem_fail', event_info)
-            return "Refresh the page and make an attempt before resetting."
+            return {'success': False,
+                    'error': "Refresh the page and make an attempt before resetting."}
 
         self.lcp.do_reset()
         if self.rerandomize in ["always", "onreset"]:
@@ -638,14 +659,13 @@ class CapaDescriptor(RawDescriptor):
 
     stores_state = True
     has_score = True
+    template_dir_name = 'problem'
 
     # Capa modules have some additional metadata:
     # TODO (vshnayder): do problems have any other metadata?  Do they
     # actually use type and points?
     metadata_attributes = RawDescriptor.metadata_attributes + ('type', 'points')
 
-    template_dir_name = 'problem'
-
     # VS[compat]
     # TODO (cpennington): Delete this method once all fall 2012 course are being
     # edited in the cms

common/lib/xmodule/xmodule/contentstore/content.py

+XASSET_LOCATION_TAG = 'c4x'
+XASSET_SRCREF_PREFIX = 'xasset:'
+
+class StaticContent(object):
+    def __init__(self, filename, name, content_type, data, last_modified_at=None):
+        self.filename = filename
+        self.name = name
+        self.content_type = content_type
+        self.data = data
+        self.last_modified_at = last_modified_at
+
+    @staticmethod
+    def compute_location_filename(org, course, name):
+        return '/{0}/{1}/{2}/asset/{3}'.format(XASSET_LOCATION_TAG, org, course, name)
+
+'''
+Abstraction for all ContentStore providers (e.g. MongoDB)
+'''
+class ContentStore(object):
+    def save(self, content):
+        raise NotImplementedError
+
+    def find(self, filename):
+        raise NotImplementedError
+
+            

common/lib/xmodule/xmodule/contentstore/django.py

+from __future__ import absolute_import
+from importlib import import_module
+from os import environ
+
+from django.conf import settings
+
+_CONTENTSTORE = None
+
+def load_function(path):
+    """
+    Load a function by name.
+
+    path is a string of the form "path.to.module.function"
+    returns the imported python object `function` from `path.to.module`
+    """
+    module_path, _, name = path.rpartition('.')
+    return getattr(import_module(module_path), name)
+
+
+def contentstore():
+    global _CONTENTSTORE
+
+    if _CONTENTSTORE is None:
+        class_ = load_function(settings.CONTENTSTORE['ENGINE'])
+        options = {}
+        options.update(settings.CONTENTSTORE['OPTIONS'])
+        _CONTENTSTORE = class_(**options)
+
+    return _CONTENTSTORE

common/lib/xmodule/xmodule/contentstore/mongo.py

+from pymongo import Connection
+import gridfs
+from gridfs.errors import NoFile
+
+import sys
+import logging
+
+from .content import StaticContent, ContentStore
+from xmodule.exceptions import NotFoundError
+
+
+class MongoContentStore(ContentStore):
+    def __init__(self, host, db, port=27017):
+        logging.debug( 'Using MongoDB for static content serving at host={0} db={1}'.format(host,db))
+        _db = Connection(host=host, port=port)[db]
+        self.fs = gridfs.GridFS(_db)
+
+    def save(self, content):
+        with self.fs.new_file(filename=content.filename, content_type=content.content_type, displayname=content.name) as fp:
+            fp.write(content.data)
+            return content
+        
+    
+    def find(self, filename):
+        try:
+            with self.fs.get_last_version(filename) as fp:
+                return StaticContent(fp.filename, fp.displayname, fp.content_type, fp.read(), fp.uploadDate)
+        except NoFile:
+            raise NotFoundError()
+
+
+        

common/lib/xmodule/xmodule/css/capa/display.scss

@@ -38,22 +38,27 @@ section.problem {
   .choicegroup {
     @include clearfix;
 
-    label.choicegroup_correct:after {
-      content: url('../images/correct-icon.png');
+    label.choicegroup_correct{
+      text:after{
+        content: url('../images/correct-icon.png');
+      }
     }
 
-    > span {
-      padding-right: 20px;
+    min-width:100px;
+    width: auto !important;
+    width: 100px;
+
+    .indicator_container {
       float: left;
-      background-position: 0 0  !important;
+      width: 25px;
+      margin-right: 15px;
     }
 
     fieldset {
       @include box-sizing(border-box);
-      float: left;
       border-left: 1px solid #ddd;
       padding-left: 20px;
-      margin: 20px 0;
+      margin: 0px 0px 20px;
     }
 
     input[type="radio"],
@@ -294,7 +299,7 @@ section.problem {
   form.option-input {
     margin: -10px 0 20px;
     padding-bottom: 20px;
-    
+
     select {
       margin-right: flex-gutter();
     }
@@ -411,6 +416,12 @@ section.problem {
     line-height: 18px;
     resize: both;
 
+    .cm-tab {
+        background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAMCAYAAAAkuj5RAAAAAXNSR0IArs4c6QAAAGFJREFUSMft1LsRQFAQheHPowAKoACx3IgEKtaEHujDjORSgWTH/ZOdnZOcM/sgk/kFFWY0qV8foQwS4MKBCS3qR6ixBJvElOobYAtivseIE120FaowJPN75GMu8j/LfMwNjh4HUpwg4LUAAAAASUVORK5CYII=);
+        background-position: right;
+        background-repeat: no-repeat;
+    }
+
     pre {
       @include border-radius(0);
       border-radius: 0;
@@ -561,7 +572,7 @@ section.problem {
         }
       }
 
-      section {
+      > section {
         padding: 9px;
       }
     }
@@ -611,4 +622,70 @@ section.problem {
       }
     }
   }
+
+  .external-grader-message {
+    section {
+      padding-left: 20px;
+      background-color: #FAFAFA;
+      color: #2C2C2C;
+      font-family: monospace;
+      font-size: 1em;
+
+      .shortform {
+        font-weight: bold;
+      }
+
+      .longform {
+        padding: 0px;
+        margin: 0px;
+
+        .result-errors {
+          margin: 5px;
+          padding: 10px 10px 10px 40px;
+          background: url('../images/incorrect-icon.png') center left no-repeat;
+          li {
+            color: #B00;
+            }
+        }
+
+        .result-output {
+          margin: 5px;
+          padding: 20px 0px 15px 50px;
+          border-top: 1px solid #DDD;
+          border-left: 20px solid #FAFAFA;
+
+          h4 {
+            font-family: monospace;
+            font-size: 1em;
+          }
+
+          dl {
+            margin: 0px;
+          }
+
+          dt {
+            margin-top: 20px;
+          }
+
+          dd {
+            margin-left: 24pt;
+          }
+        }
+
+        .result-correct {
+          background: url('../images/correct-icon.png') left 20px no-repeat;
+          .result-actual-output {
+            color: #090;
+          }
+        }
+
+        .result-incorrect {
+          background: url('../images/incorrect-icon.png') left 20px no-repeat;
+          .result-actual-output {
+            color: #B00;
+          }
+        }
+      }
+    }
+  }
 }

common/lib/xmodule/xmodule/editing_module.py

 from pkg_resources import resource_string
-from lxml import etree
 from xmodule.mako_module import MakoModuleDescriptor
 import logging
 

common/lib/xmodule/xmodule/graders.py

 import abc
+import inspect
 import json
 import logging
+import random
 import sys
 
 from collections import namedtuple
@@ -102,6 +104,15 @@ def aggregate_scores(scores, section_name="summary"):
     return all_total, graded_total
 
 
+def invalid_args(func, argdict):
+    """
+    Given a function and a dictionary of arguments, returns a set of arguments
+    from argdict that aren't accepted by func
+    """
+    args, varargs, keywords, defaults = inspect.getargspec(func)
+    if keywords: return set()  # All accepted
+    return set(argdict) - set(args)
+
 def grader_from_conf(conf):
     """
     This creates a CourseGrader from a configuration (such as in course_settings.py).
@@ -121,14 +132,21 @@ def grader_from_conf(conf):
         try:
             if 'min_count' in subgraderconf:
                 #This is an AssignmentFormatGrader
-                subgrader = AssignmentFormatGrader(**subgraderconf)
-                subgraders.append((subgrader, subgrader.category, weight))
+                subgrader_class = AssignmentFormatGrader
             elif 'name' in subgraderconf:
                 #This is an SingleSectionGrader
-                subgrader = SingleSectionGrader(**subgraderconf)
-                subgraders.append((subgrader, subgrader.category, weight))
+                subgrader_class = SingleSectionGrader
             else:
                 raise ValueError("Configuration has no appropriate grader class.")
+            
+            bad_args = invalid_args(subgrader_class.__init__, subgraderconf)
+            if len(bad_args) > 0:
+                log.warning("Invalid arguments for a subgrader: %s", bad_args)
+                for key in bad_args:
+                    del subgraderconf[key]
+            
+            subgrader = subgrader_class(**subgraderconf)
+            subgraders.append((subgrader, subgrader.category, weight))
 
         except (TypeError, ValueError) as error:
             # Add info and re-raise
@@ -184,7 +202,7 @@ class CourseGrader(object):
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
-    def grade(self, grade_sheet):
+    def grade(self, grade_sheet, generate_random_scores=False):
         raise NotImplementedError
 
 
@@ -204,13 +222,13 @@ class WeightedSubsectionsGrader(CourseGrader):
     def __init__(self, sections):
         self.sections = sections
 
-    def grade(self, grade_sheet):
+    def grade(self, grade_sheet, generate_random_scores=False):
         total_percent = 0.0
         section_breakdown = []
         grade_breakdown = []
 
         for subgrader, category, weight in self.sections:
-            subgrade_result = subgrader.grade(grade_sheet)
+            subgrade_result = subgrader.grade(grade_sheet, generate_random_scores)
 
             weightedPercent = subgrade_result['percent'] * weight
             section_detail = "{0} = {1:.1%} of a possible {2:.0%}".format(category, weightedPercent, weight)
@@ -237,7 +255,7 @@ class SingleSectionGrader(CourseGrader):
         self.short_label = short_label or name
         self.category = category or name
 
-    def grade(self, grade_sheet):
+    def grade(self, grade_sheet, generate_random_scores=False):
         foundScore = None
         if self.type in grade_sheet:
             for score in grade_sheet[self.type]:
@@ -245,12 +263,19 @@ class SingleSectionGrader(CourseGrader):
                     foundScore = score
                     break
 
-        if foundScore:
-            percent = foundScore.earned / float(foundScore.possible)
+        if foundScore or generate_random_scores:
+            if generate_random_scores:	# for debugging!
+                earned = random.randint(2,15)
+                possible = random.randint(earned, 15)
+            else: # We found the score
+                earned = foundScore.earned
+                possible = foundScore.possible
+                
+            percent = earned / float(possible)
             detail = "{name} - {percent:.0%} ({earned:.3n}/{possible:.3n})".format(name=self.name,
                                                                         percent=percent,
-                                                                        earned=float(foundScore.earned),
-                                                                        possible=float(foundScore.possible))
+                                                                        earned=float(earned),
+                                                                        possible=float(possible))
 
         else:
             percent = 0.0
@@ -274,6 +299,9 @@ class AssignmentFormatGrader(CourseGrader):
     min_count defines how many assignments are expected throughout the course. Placeholder
     scores (of 0) will be inserted if the number of matching sections in the course is < min_count.
     If there number of matching sections in the course is > min_count, min_count will be ignored.
+    
+    show_only_average is to suppress the display of each assignment in this grader and instead
+    only show the total score of this grader in the breakdown.
 
     category should be presentable to the user, but may not appear. When the grade breakdown is
     displayed, scores from the same category will be similar (for example, by color).
@@ -283,17 +311,22 @@ class AssignmentFormatGrader(CourseGrader):
 
     short_label is similar to section_type, but shorter. For example, for Homework it would be
     "HW".
+    
+    starting_index is the first number that will appear. For example, starting_index=3 and
+    min_count = 2 would produce the labels "Assignment 3", "Assignment 4"
 
     """
-    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None):
+    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None, show_only_average=False, starting_index=1):
         self.type = type
         self.min_count = min_count
         self.drop_count = drop_count
         self.category = category or self.type
         self.section_type = section_type or self.type
         self.short_label = short_label or self.type
+        self.show_only_average = show_only_average
+        self.starting_index = starting_index
 
-    def grade(self, grade_sheet):
+    def grade(self, grade_sheet, generate_random_scores=False):
         def totalWithDrops(breakdown, drop_count):
             #create an array of tuples with (index, mark), sorted by mark['percent'] descending
             sorted_breakdown = sorted(enumerate(breakdown), key=lambda x: -x[1]['percent'])
@@ -315,20 +348,30 @@ class AssignmentFormatGrader(CourseGrader):
         scores = grade_sheet.get(self.type, [])
         breakdown = []
         for i in range(max(self.min_count, len(scores))):
-            if i < len(scores):
-                percentage = scores[i].earned / float(scores[i].possible)
-                summary = "{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})".format(index=i + 1,
+            if i < len(scores) or generate_random_scores:
+                if generate_random_scores:	# for debugging!
+                    earned = random.randint(2,15)
+                    possible = random.randint(earned, 15)                    
+                    section_name = "Generated"
+                    
+                else:
+                    earned = scores[i].earned
+                    possible = scores[i].possible
+                    section_name = scores[i].section
+                
+                percentage = earned / float(possible)
+                summary = "{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})".format(index=i + self.starting_index,
                                                                 section_type=self.section_type,
-                                                                name=scores[i].section,
+                                                                name=section_name,
                                                                 percent=percentage,
-                                                                earned=float(scores[i].earned),
-                                                                possible=float(scores[i].possible))
+                                                                earned=float(earned),
+                                                                possible=float(possible))
             else:
                 percentage = 0
-                summary = "{section_type} {index} Unreleased - 0% (?/?)".format(index=i + 1, section_type=self.section_type)
-
-            short_label = "{short_label} {index:02d}".format(index=i + 1, short_label=self.short_label)
+                summary = "{section_type} {index} Unreleased - 0% (?/?)".format(index=i + self.starting_index, section_type=self.section_type)
 
+            short_label = "{short_label} {index:02d}".format(index=i + self.starting_index, short_label=self.short_label)
+            
             breakdown.append({'percent': percentage, 'label': short_label, 'detail': summary, 'category': self.category})
 
         total_percent, dropped_indices = totalWithDrops(breakdown, self.drop_count)
@@ -338,8 +381,12 @@ class AssignmentFormatGrader(CourseGrader):
 
         total_detail = "{section_type} Average = {percent:.0%}".format(percent=total_percent, section_type=self.section_type)
         total_label = "{short_label} Avg".format(short_label=self.short_label)
+        
+        if self.show_only_average:
+            breakdown = []
+        
         breakdown.append({'percent': total_percent, 'label': total_label, 'detail': total_detail, 'category': self.category, 'prominent': True})
-
+        
         return {'percent': total_percent,
                 'section_breakdown': breakdown,
                 #No grade_breakdown here

common/lib/xmodule/xmodule/html_module.py

@@ -4,20 +4,33 @@ import logging
 import os
 import sys
 from lxml import etree
+from lxml.html import rewrite_links
 from path import path
 
-from .x_module import XModule, Template
+from .x_module import XModule
+from pkg_resources import resource_string
 from .xml_module import XmlDescriptor, name_to_pathname
 from .editing_module import EditingDescriptor
 from .stringify import stringify_children
 from .html_checker import check_html
+from xmodule.modulestore import Location
+
+from xmodule.contentstore.content import XASSET_SRCREF_PREFIX, StaticContent
 
 log = logging.getLogger("mitx.courseware")
 
 
 class HtmlModule(XModule):
+    js = {'coffee': [resource_string(__name__, 'js/src/javascript_loader.coffee'),
+                     resource_string(__name__, 'js/src/collapsible.coffee'),
+                     resource_string(__name__, 'js/src/html/display.coffee')
+                    ]
+         }
+    js_module_name = "HTMLModule"
+    
     def get_html(self):
-        return self.html
+        # cdodge: perform link substitutions for any references to course static content (e.g. images)
+        return rewrite_links(self.html, self.rewrite_content_links)
 
     def __init__(self, system, location, definition, descriptor,
                  instance_state=None, shared_state=None, **kwargs):
@@ -26,6 +39,7 @@ class HtmlModule(XModule):
         self.html = self.definition['data']
 
 
+
 class HtmlDescriptor(XmlDescriptor, EditingDescriptor):
     """
     Module for putting raw html in a course
@@ -35,6 +49,9 @@ class HtmlDescriptor(XmlDescriptor, EditingDescriptor):
     filename_extension = "xml"
     template_dir_name = "html"
 
+    js = {'coffee': [resource_string(__name__, 'js/src/html/edit.coffee')]}
+    js_module_name = "HTMLEditingDescriptor"
+
     # VS[compat] TODO (cpennington): Delete this method once all fall 2012 course
     # are being edited in the cms
     @classmethod

common/lib/xmodule/xmodule/js/src/capa/display.coffee

@@ -26,6 +26,9 @@ class @Problem
     @$('section.action input.show').click @show
     @$('section.action input.save').click @save
 
+    # Collapsibles
+    Collapsible.setCollapsibles(@el)
+
     # Dynamath
     @$('input.math').keyup(@refreshMath)
     @$('input.math').each (index, element) =>
@@ -60,7 +63,7 @@ class @Problem
       @new_queued_items = $(response.html).find(".xqueue")
       if @new_queued_items.length isnt @num_queued_items
         @el.html(response.html)
-        @executeProblemScripts () =>
+        JavascriptLoader.executeModuleScripts @el, () =>
           @setupInputTypes()
           @bind()
       
@@ -74,18 +77,19 @@ class @Problem
   render: (content) ->
     if content
       @el.html(content)
-      @executeProblemScripts () =>
+      JavascriptLoader.executeModuleScripts @el, () =>
         @setupInputTypes()
         @bind()
         @queueing()
     else
       $.postWithPrefix "#{@url}/problem_get", (response) =>
         @el.html(response.html)
-        @executeProblemScripts () =>
+        JavascriptLoader.executeModuleScripts @el, () =>
           @setupInputTypes()
           @bind()
           @queueing()
 
+
   # TODO add hooks for problem types here by inspecting response.html and doing
   # stuff if a div w a class is found
 
@@ -99,50 +103,6 @@ class @Problem
         if setupMethod?
           @inputtypeDisplays[id] = setupMethod(inputtype)
 
-  executeProblemScripts: (callback=null) ->
-
-    placeholders = @el.find(".script_placeholder")
-
-    if placeholders.length == 0
-      callback()
-      return
-
-    completed      = (false for i in [1..placeholders.length])
-    callbackCalled = false
-
-    # This is required for IE8 support.
-    completionHandlerGeneratorIE = (index) =>
-      return () ->
-        if (this.readyState == 'complete' || this.readyState == 'loaded')
-          #completionHandlerGenerator.call(self, index)()
-          completionHandlerGenerator(index)()
-
-    completionHandlerGenerator = (index) =>
-      return () =>
-        allComplete = true
-        completed[index] = true
-        for flag in completed
-          if not flag
-            allComplete = false
-            break
-        if allComplete and not callbackCalled
-          callbackCalled = true
-          callback() if callback?
-
-    placeholders.each (index, placeholder) ->
-      s = document.createElement('script')
-      s.setAttribute('src', $(placeholder).attr("data-src"))
-      s.setAttribute('type', "text/javascript")
-
-      s.onload             = completionHandlerGenerator(index)
-
-      # s.onload does not fire in IE8; this does.
-      s.onreadystatechange = completionHandlerGeneratorIE(index)
-
-      # Need to use the DOM elements directly or the scripts won't execute
-      # properly.
-      $('head')[0].appendChild(s)
-      $(placeholder).remove()
 
   ###
   # 'check_fd' uses FormData to allow file submissions in the 'problem_check' dispatch,
@@ -374,10 +334,13 @@ class @Problem
   inputtypeShowAnswerMethods:
     choicegroup: (element, display, answers) =>
       element = $(element)
-      for key, value of answers
-        element.find('input').attr('disabled', 'disabled')
-        for choice in value
-          element.find("label[for='input_#{key}_#{choice}']").addClass 'choicegroup_correct'
+
+      element.find('input').attr('disabled', 'disabled')
+
+      input_id = element.attr('id').replace(/inputtype_/,'')
+      answer = answers[input_id]
+      for choice in answer
+        element.find("label[for='input_#{input_id}_#{choice}']").addClass 'choicegroup_correct'
 
     javascriptinput: (element, display, answers) =>
       answer_id = $(element).attr('id').split("_")[1...].join("_")

common/lib/xmodule/xmodule/js/src/collapsible.coffee

+class @Collapsible
+
+  # Set of library functions that provide a simple way to add collapsible
+  # functionality to elements. 
+
+  # setCollapsibles:
+  #   Scan element's content for generic collapsible containers
+  @setCollapsibles: (el) =>
+    ###
+    el: container
+    ###
+    el.find('.longform').hide()
+    el.find('.shortform').append('<a href="#" class="full">See full output</a>')
+    el.find('.collapsible header + section').hide()
+    el.find('.full').click @toggleFull
+    el.find('.collapsible header a').click @toggleHint
+
+  @toggleFull: (event) =>
+    event.preventDefault()
+    $(event.target).parent().siblings().slideToggle()
+    $(event.target).parent().parent().toggleClass('open')
+    if $(event.target).text() == 'See full output'
+      new_text = 'Hide output'
+    else
+      new_text = 'See full ouput'
+    $(event.target).text(new_text)
+
+  @toggleHint: (event) =>
+    event.preventDefault()
+    $(event.target).parent().siblings().slideToggle()
+    $(event.target).parent().parent().toggleClass('open')

common/lib/xmodule/xmodule/js/src/html/display.coffee

+class @HTMLModule
+
+  constructor: (@element) ->
+    @el = $(@element)
+    JavascriptLoader.executeModuleScripts(@el)
+    Collapsible.setCollapsibles(@el)
+
+  $: (selector) ->
+    $(selector, @el)

common/lib/xmodule/xmodule/js/src/html/edit.coffee

+class @HTMLEditingDescriptor
+  constructor: (@element) ->
+    @edit_box = CodeMirror.fromTextArea($(".edit-box", @element)[0], {
+      mode: "text/html"
+    })
+
+  save: -> @edit_box.getValue()

common/lib/xmodule/xmodule/js/src/javascript_loader.coffee

+class @JavascriptLoader
+
+  # Set of library functions that provide common interface for javascript loading
+  # for all module types. All functionality provided by JavascriptLoader should take
+  # place at module scope, i.e. don't run jQuery over entire page
+
+  # executeModuleScripts:
+  #   Scan the module ('el') for "script_placeholder"s, then:
+  #     1) Fetch each script from server
+  #     2) Explicitly attach the script to the <head> of document
+  #     3) Explicitly wait for each script to be loaded
+  #     4) Return to callback function when all scripts loaded
+  @executeModuleScripts: (el, callback=null) ->
+
+    placeholders = el.find(".script_placeholder")
+
+    if placeholders.length == 0
+      callback() if callback?
+      return
+
+    # TODO: Verify the execution order of multiple placeholders
+    completed      = (false for i in [1..placeholders.length])
+    callbackCalled = false
+
+    # This is required for IE8 support.
+    completionHandlerGeneratorIE = (index) =>
+      return () ->
+        if (this.readyState == 'complete' || this.readyState == 'loaded')
+          #completionHandlerGenerator.call(self, index)()
+          completionHandlerGenerator(index)()
+
+    completionHandlerGenerator = (index) =>
+      return () =>
+        allComplete = true
+        completed[index] = true
+        for flag in completed
+          if not flag
+            allComplete = false
+            break
+        if allComplete and not callbackCalled
+          callbackCalled = true
+          callback() if callback?
+
+    # Keep a map of what sources we're loaded from, and don't do it twice.
+    loaded = {}
+    placeholders.each (index, placeholder) ->
+      # TODO: Check if the script already exists in DOM. If so, (1) copy it
+      #         into memory; (2) delete the DOM script element; (3) reappend it.
+      #       This would prevent memory bloat and save a network request.
+      src = $(placeholder).attr("data-src")
+      if src not of loaded
+        loaded[src] = true
+        s = document.createElement('script')
+        s.setAttribute('src', src)
+        s.setAttribute('type', "text/javascript")
+  
+        s.onload             = completionHandlerGenerator(index)
+
+        # s.onload does not fire in IE8; this does.
+        s.onreadystatechange = completionHandlerGeneratorIE(index)
+
+        # Need to use the DOM elements directly or the scripts won't execute
+        # properly.
+        $('head')[0].appendChild(s)
+      else
+        # just call the completion callback directly, without reloading the file
+        completionHandlerGenerator(index)()
+      $(placeholder).remove()
+        
+      

common/lib/xmodule/xmodule/seq_module.py

@@ -9,7 +9,6 @@ from xmodule.x_module import XModule
 from xmodule.progress import Progress
 from xmodule.exceptions import NotFoundError
 from pkg_resources import resource_string
-from .editing_module import EditingDescriptor
 
 log = logging.getLogger("mitx.common.lib.seq_module")
 

common/lib/xmodule/xmodule/templates/html/everything.yaml

-<h1>Heading of document</h1>
-<h2>First subheading</h2>
-<p>This is a paragraph. It will take care of line breaks for you.</p><p>HTML only parses the location
+---
+metadata:
+      display_name: Announcement
 
-of tags for inserting line breaks into your doc, not 
-line
-breaks
-you
-add
-yourself.
-</p>
-
-<h2>Links</h2>
-<p>You can refer to other parts of the internet with a <a href="http://www.wikipedia.org/"> link</a>, to other parts of your course by prepending your link with <a href="/course/Week_0">/course/</a></p>
-<p>Now a list:</p>
-<ul>
-<li>An item</li>
-<li>Another item</li>
-<li>And yet another</li>
-</ul>
-<p>This list has an ordering </p>
-<ol>
-<li>An item</li>
-<li>Another item</li>
-<li>Yet another item</li>
-</ol>
-<p> Note, we have a lot of standard edX styles, so please try to avoid any custom styling, and make sure that you make a note of any custom styling that you do yourself so that we can incorporate it into 
-tools that other people can use. </p>
\ No newline at end of file
+data: |
+      <h1>Heading of document</h1>
+      <h2>First subheading</h2>
+      <p>This is a paragraph. It will take care of line breaks for you.</p><p>HTML only parses the location
+      
+      of tags for inserting line breaks into your doc, not 
+      line
+      breaks
+      you
+      add
+      yourself.
+      </p>
+      <h2>Links</h2>
+      <p>You can refer to other parts of the internet with a <a href="http://www.wikipedia.org/"> link</a>, to other parts of your course by prepending your link with <a href="/course/Week_0">/course/</a></p>
+      <p>Now a list:</p>
+      <ul>
+      <li>An item</li>
+      <li>Another item</li>
+      <li>And yet another</li>
+      </ul>
+      <p>This list has an ordering </p>
+      <ol>
+      <li>An item</li>
+      <li>Another item</li>
+      <li>Yet another item</li>
+      </ol>
+      <p> Note, we have a lot of standard edX styles, so please try to avoid any custom styling, and make sure that you make a note of any custom styling that you do yourself so that we can incorporate it into 
+      tools that other people can use. </p>
+children: []

common/lib/xmodule/xmodule/templates/problem/circuitschematic.yaml

+---
+metadata:
+    display_name: Circuit Schematic
+data: |
+ <!-- Logic gate: cjt 2/13/12 -->
+    
+    <problem>
+      <startouttext />
+      Your goal for this lab is to design a circuit that implements a
+      <!-- \overline doesn't seem to render correctly -->
+      3-input logic gate that implements \(Z = \lnot{(C(A+B))}\) where the
+      \(\lnot\) symbol stands for logical negation. This function is
+      enumerated in the following truth table:
+      
+      <center><pre>
+      C B A | Z
+      =========
+      0 0 0 | 1
+      0 0 1 | 1
+      0 1 0 | 1
+      0 1 1 | 1
+      1 0 0 | 1
+      1 0 1 | 0
+      1 1 0 | 0
+      1 1 1 | 0
+      </pre></center>
+      
+      The schematic diagram below includes the resistive pullup for the logic
+      gate and some voltage sources that serve as the power supply and 
+      generators for the signals that will be the inputs to the gate.
+      The voltage sources generate the three input signals (A, B and C), timed so that all
+      possible combinations of the inputs will be generated over a \(4\mu s\)
+      interval.
+      
+      <br/><br/>Please add the appropriate pulldown network of mosfet
+      switches connected to node Z to implement the truth table above, with
+      \(R_{ON}\) of the mosfets chosen so that \(V_{ol}\) of the logic gate is less than
+      \(0.25V\) for any combination of inputs.  In the schematic tool, the mosfet
+      model has \(V_{th} = 0.5V\), so \(V_{ol} \lt 0.25V\)
+      will ensure that when the output of the logic gate is 0, if it is used
+      as the input to some other logic gate, the mosfet to which
+      it connects will be off.
+      
+      <br/><br/>On <A href="/book-shifted/305">page 305</A> of the text we
+      see from Equation (6) that \(R_{ON} = R_n \frac{L}{W}\).  In the
+      schematic tool, the mosfet model has \(R_n \approx 26.5k\Omega\) when
+      using a \(3V\) power supply.  To adjust \(R_{ON}\), double click the
+      mosfet and select an appropriate value for the W/L parameter.  For
+      example, setting a mosfet's W/L to 10 would result in \(R_{ON} =
+      2.65k\Omega\).
+      
+      <br/><br/>Note that the "Plot offset" property of the scope probes
+      on the A, B and C signals has been set so that the plots will not
+      overlap, making it easier to see what's happening.
+      
+      <br/><br/>Please do not change the voltages of the voltage sources or the
+      resistance of the pullup resistor.
+      
+      <endouttext />
+      
+      <schematicresponse>
+    <center>
+    <schematic height="500" width="600" parts="g,n,s" analyses="dc,tran"
+        submit_analyses="{&quot;tran&quot;:[[&quot;Z&quot;,0.0000004,0.0000009,0.0000014,0.0000019,0.0000024,0.0000029,0.0000034,0.000039]]}"
+        initial_value="[[&quot;w&quot;,[112,96,128,96]],[&quot;w&quot;,[256,96,240,96]],[&quot;w&quot;,[192,96,240,96]],[&quot;s&quot;,[240,96,0],{&quot;color&quot;:&quot;cyan&quot;,&quot;offset&quot;:&quot;&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:3},[&quot;Z&quot;]],[&quot;w&quot;,[32,224,192,224]],[&quot;w&quot;,[96,48,192,48]],[&quot;L&quot;,[256,96,3],{&quot;label&quot;:&quot;Z&quot;,&quot;_json_&quot;:6},[&quot;Z&quot;]],[&quot;r&quot;,[192,48,0],{&quot;name&quot;:&quot;Rpullup&quot;,&quot;r&quot;:&quot;10K&quot;,&quot;_json_&quot;:7},[&quot;1&quot;,&quot;Z&quot;]],[&quot;w&quot;,[32,144,32,192]],[&quot;w&quot;,[32,224,32,192]],[&quot;w&quot;,[48,192,32,192]],[&quot;w&quot;,[32,96,32,144]],[&quot;w&quot;,[48,144,32,144]],[&quot;w&quot;,[32,48,32,96]],[&quot;w&quot;,[48,96,32,96]],[&quot;w&quot;,[32,48,48,48]],[&quot;g&quot;,[32,224,0],{&quot;_json_&quot;:16},[&quot;0&quot;]],[&quot;v&quot;,[96,192,1],{&quot;name&quot;:&quot;VC&quot;,&quot;value&quot;:&quot;square(3,0,250K)&quot;,&quot;_json_&quot;:17},[&quot;C&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,144,1],{&quot;name&quot;:&quot;VB&quot;,&quot;value&quot;:&quot;square(3,0,500K)&quot;,&quot;_json_&quot;:18},[&quot;B&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,96,1],{&quot;name&quot;:&quot;VA&quot;,&quot;value&quot;:&quot;square(3,0,1000K)&quot;,&quot;_json_&quot;:19},[&quot;A&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,48,1],{&quot;name&quot;:&quot;Vpwr&quot;,&quot;value&quot;:&quot;dc(3)&quot;,&quot;_json_&quot;:20},[&quot;1&quot;,&quot;0&quot;]],[&quot;L&quot;,[96,96,2],{&quot;label&quot;:&quot;A&quot;,&quot;_json_&quot;:21},[&quot;A&quot;]],[&quot;w&quot;,[96,96,104,96]],[&quot;L&quot;,[96,144,2],{&quot;label&quot;:&quot;B&quot;,&quot;_json_&quot;:23},[&quot;B&quot;]],[&quot;w&quot;,[96,144,104,144]],[&quot;L&quot;,[96,192,2],{&quot;label&quot;:&quot;C&quot;,&quot;_json_&quot;:25},[&quot;C&quot;]],[&quot;w&quot;,[96,192,104,192]],[&quot;w&quot;,[192,96,192,112]],[&quot;s&quot;,[112,96,0],{&quot;color&quot;:&quot;red&quot;,&quot;offset&quot;:&quot;15&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:28},[&quot;A&quot;]],[&quot;w&quot;,[104,96,112,96]],[&quot;s&quot;,[112,144,0],{&quot;color&quot;:&quot;green&quot;,&quot;offset&quot;:&quot;10&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:30},[&quot;B&quot;]],[&quot;w&quot;,[104,144,112,144]],[&quot;w&quot;,[128,144,112,144]],[&quot;s&quot;,[112,192,0],{&quot;color&quot;:&quot;blue&quot;,&quot;offset&quot;:&quot;5&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:33},[&quot;C&quot;]],[&quot;w&quot;,[104,192,112,192]],[&quot;w&quot;,[128,192,112,192]],[&quot;view&quot;,0,0,2,&quot;5&quot;,&quot;10&quot;,&quot;10MEG&quot;,null,&quot;100&quot;,&quot;4us&quot;]]"
+       />
+    </center>
+ <answer type="loncapa/python">
+   # for a schematic response, submission[i] is the json representation
+   # of the diagram and analysis results for the i-th schematic tag
+   
+   def get_tran(json,signal):
+     for element in json:
+       if element[0] == 'transient':
+         return element[1].get(signal,[])
+     return []
+   
+   def get_value(at,output):
+     for (t,v) in output:
+       if at == t: return v
+     return None
+   
+   output = get_tran(submission[0],'Z')
+   okay = True
+   
+   # output should be 1, 1, 1, 1, 1, 0, 0, 0
+   if get_value(0.0000004,output) &lt; 2.7: okay = False;
+   if get_value(0.0000009,output) &lt; 2.7: okay = False;
+   if get_value(0.0000014,output) &lt; 2.7: okay = False;
+   if get_value(0.0000019,output) &lt; 2.7: okay = False;
+   if get_value(0.0000024,output) &lt; 2.7: okay = False;
+   if get_value(0.0000029,output) &gt; 0.25: okay = False;
+   if get_value(0.0000034,output) &gt; 0.25: okay = False;
+   if get_value(0.0000039,output) &gt; 0.25: okay = False;
+   
+   correct = ['correct' if okay else 'incorrect']
+   
+ </answer>
+      </schematicresponse>
+      
+      <startouttext />
+      
+      When your circuit is ready for testing, run a \(4\mu s\) transient
+      simulation to verify correct functionality and appropriate \(V_{ol}\)
+      when the output of the gate is logic 0.  To submit, please click
+      CHECK.  The checker will be verifying the voltage of the
+      output node at several different times, so you'll earn a checkmark
+      only <i>after</i> you've performed the transient simulation so that
+      the checker will have a waveform to check!
+      
+      <br/><br/>Hint: you'll only need 3 mosfet switches to implement the gate.
+      
+      <br/><br/>When the gate is correctly implemented, the plot produced by the transient
+      analysis should like similar to the following figure.
+      
+      <center>
+ <img src="/static/Lab3_1.png"/>
+ <br/>Figure 1.  Example plot output
+      </center>
+      
+      <br/><br/>Food for thought: You'll notice there are little spikes,
+      sometimes called <i>glitches</i>, in the output waveform (see the
+      bottom cyan-colored waveform in Figure 1).  These only occur when the
+      A and B inputs are changing simultaneously and the C input is high.
+      Can you explain why?  Think about what is happening in the pulldown
+      circuitry at the time the glitches occur.
+      
+      <endouttext />
+      
+    </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/customgrader.yaml

+---
+metadata:
+    display_name: Custom Grader
+data: |
+ <problem>
+ <text>
+   <h2>Example: Custom Response Problem</h2>
+   
+   <p>
+     A custom response problem accepts one or more lines of text input from the
+     student, and evaluates the inputs for correctness based on evaluation using a 
+     python script embedded within the problem.
+   </p>
+   
+   <script type="loncapa/python">def test_add(expect,ans):
+        (a1,a2) = map(float,ans)
+        return (a1+a2)==10
+     
+   </script>
+   
+   <text>
+     Enter two integers which sum to 10: <br/>
+     <customresponse cfn="test_add">
+              <textline size="40" correct_answer="3"/><br/>
+              <textline size="40" correct_answer="7"/>
+     </customresponse>
+   </text>
+   
+ </text>
+ </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/forumularesponse.yaml

+---
+metadata:
+    display_name: Formula Repsonse
+data: |
+ <problem>
+ <text>
+   <h2>Example: Formula Response Problem</h2>
+   
+   <p>
+     A formula response problem accepts a line of text input from the
+     student, and evaluates the input for correctness based on numerical sampling of 
+     the symbolic formula which is given.
+   </p>
+   
+   <p>
+     The answer is correct if it is within a specified numerical tolerance
+     of the expected answer.
+   </p>
+   
+   <p>This kind of response checking can handle symbolic expressions, but places an extra burden
+     on the problem author to specify the allowed variables in the expression, and the
+     numerical ranges over which the variables must be sampled to test for correctness.</p>
+   
+   <script type="loncapa/python">I = "m*c^2"</script>
+   
+   <text>
+     <br/>
+     Give an equation for the relativistic energy of an object with mass m.  Explicitly indicate multiplication with a <tt>*</tt> symbol.<br/>
+   </text>
+   <formularesponse type="cs" samples="m,c@1,2:3,4#10" answer="$I">
+         <responseparam description="Numerical Tolerance" type="tolerance"
+      default="0.00001" name="tol" /> 
+         <br/><text>E =</text> <textline size="40" math="1" />    
+          </formularesponse>
+   
+ </text>
+ </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/imageresponse.yaml

+---
+metadata:
+    display_name: Image Response
+data: |
+ <problem>
+      <text>
+ <h2>Example: Image Response Problem</h2>
+ 
+ <p>
+   When teaching conventionally, a common check for understanding is to ask the student to point 
+   at something which satisfies a set of contraints. This use case is captured in the imageresponse. 
+   An image response problem presents an image for the student.  Input is
+   given by the location of mouse clicks on the image. Correctness of input can only be evaluated based on expected dimensions of a rectangle.
+   
+ </p>
+ 
+ <text>
+   Click on the cow in this image:
+   <imageresponse>
+     <imageinput src="/static/cow.png" width="715" height="511" rectangle="(404,150)-(715,480)" />
+   </imageresponse>
+ </text>
+      </text>
+ </problem>
+    
+children: []

common/lib/xmodule/xmodule/templates/problem/multiplechoice.yaml

+---
+metadata:
+    display_name: Multiple Choice
+data: |
+ <problem>
+      <text>
+ <h2>Example: Multiple Choice Response Problem</h2>
+ 
+ <p>
+   A multiple choice response problem presents radio buttons for student 
+   input.  <!-->One or more of the choice may be correct.-->  Correctness of
+   input is evaluated based on expected answers specified within each
+   "choice" stanza.
+ </p>
+ 
+ <p>Select the correct choice.  Grass is:</p>
+ <multiplechoiceresponse direction="vertical" randomize="yes">
+   <choicegroup type="MultipleChoice">
+            <choice location="random" correct="false" name="red">Red</choice>
+            <choice location="random" correct="true" name="green">Green</choice>
+            <choice location="random" correct="false" name="yellow">Yellow</choice>
+            <choice location="bottom" correct="false" name="blue">Blue</choice>
+   </choicegroup>
+ </multiplechoiceresponse>
+      </text>
+ </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/numericalresponse.yaml

+---
+metadata:
+    display_name: Numerical Response
+data: |
+ <problem>
+      <text>
+ <h2>Example: Numerical Response Problem</h2>
+ 
+ <p>
+   A numerical response problem accepts a line of text input from the
+   student, and evaluates the input for correctness based on its
+   numerical value.  
+ </p>
+ 
+ <p>
+   The answer is correct if it is within a specified numerical tolerance
+   of the expected answer.
+ </p>
+ 
+ <p>Enter the numerical value of Pi:
+   <numericalresponse answer="3.14159">
+            <responseparam type="tolerance" default="5%" name="tol" description="Numerical Tolerance" />
+            <textline />
+   </numericalresponse>
+ </p>
+      </text>
+ </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/optionresponse.yaml

+---
+metadata:
+    display_name: Option Response
+data: |
+    <problem>
+      <text>
+        <h2>Example: Option Response Problem</h2>
+        <p>
+          An option response problem presents option boxes for students to select from.  Correctness of input is evaluated based
+          on which option is defined as correct in the optioninput statement.  
+        </p>
+        <p>Select the correct options:</p>
+        <optionresponse direction="vertical" randomize="yes">
+        <p><text class="inline">The location of the sky is: </text><optioninput inline="1" options="('Up','Down')" correct="Up"></optioninput></p>
+        <p><text>The location of the earth is: </text><optioninput options="('Up','Down')" correct="Down"></optioninput></p>
+        </optionresponse>
+      </text>
+    </problem>
+children: []

common/lib/xmodule/xmodule/templates/problem/string_response.yaml

+---
+metadata:
+    display_name: String Response
+data: |
+    <problem >
+      <text>
+    <h2>Example: String Response Problem</h2>
+    <p>
+      
+      A string response problem accepts a line of text input from the
+      student, and evaluates the input for correctness based on an expected
+      answer within each input box. 
+      
+      The answer is correct if it is the expected answer.
+    </p>
+      </text>
+      
+      <span style="display:inline">
+    <p style="display:inline">Which US state has Lansing as its capital? &#160; &#160;</p>
+    <stringresponse answer="Michigan" type="ci">
+      <textline size="20" inline="1"/>
+      <hintgroup>
+        <stringhint answer="wisconsin" type="cs" name="wisc">
+        </stringhint>
+        <stringhint answer="minnesota" type="cs" name="minn">
+        </stringhint>
+        <hintpart on="wisc">
+          <text>The state capital of Wisconsin is Madison.</text>
+        </hintpart>
+        <hintpart on="minn">
+          <text>The state capital of Minnesota is St. Paul.</text>
+        </hintpart>
+        <hintpart on="default">
+          <text>The state you are looking for is also known as the 'Great Lakes State'</text>
+        </hintpart>     
+      </hintgroup>
+    </stringresponse>
+      </span>
+      
+    </problem>
+children: []

common/lib/xmodule/xmodule/templates/sequence/with_video.yaml

 ---
 metadata:
     display_name: Sequence with Video
+    data_dir: a_made_up_name
 data: ''
 children:
     - 'i4x://edx/templates/video/default'

common/lib/xmodule/xmodule/templates/video/default.yaml

 ---
 metadata:
-    display_name: edX Intro
+    display_name: default
+    data_dir: a_made_up_name
 data: |
   <video  youtube="0.75:JMD_ifUUfsU,1.0:OEoXaMPEzfM,1.25:AKqURZnYqpk,1.50:DYpADpL7jAY"/>
 children: []

common/lib/xmodule/xmodule/tests/test_progress.py

+"""Module progress tests"""
+
+import unittest
+
+from xmodule.progress import Progress
+from xmodule import x_module
+
+from . import i4xs
+
+class ProgressTest(unittest.TestCase):
+    ''' Test that basic Progress objects work.  A Progress represents a
+    fraction between 0 and 1.
+    '''
+    not_started = Progress(0, 17)
+    part_done = Progress(2, 6)
+    half_done = Progress(3, 6)
+    also_half_done = Progress(1, 2)
+    done = Progress(7, 7)
+
+    def test_create_object(self):
+        # These should work:
+        p = Progress(0, 2)
+        p = Progress(1, 2)
+        p = Progress(2, 2)
+
+        p = Progress(2.5, 5.0)
+        p = Progress(3.7, 12.3333)
+
+        # These shouldn't
+        self.assertRaises(ValueError, Progress, 0, 0)
+        self.assertRaises(ValueError, Progress, 2, 0)
+        self.assertRaises(ValueError, Progress, 1, -2)
+
+        self.assertRaises(TypeError, Progress, 0, "all")
+        # check complex numbers just for the heck of it :)
+        self.assertRaises(TypeError, Progress, 2j, 3)
+
+    def test_clamp(self):
+        self.assertEqual((2, 2), Progress(3, 2).frac())
+        self.assertEqual((0, 2), Progress(-2, 2).frac())
+
+    def test_frac(self):
+        p = Progress(1, 2)
+        (a, b) = p.frac()
+        self.assertEqual(a, 1)
+        self.assertEqual(b, 2)
+
+    def test_percent(self):
+        self.assertEqual(self.not_started.percent(), 0)
+        self.assertAlmostEqual(self.part_done.percent(), 33.33333333333333)
+        self.assertEqual(self.half_done.percent(), 50)
+        self.assertEqual(self.done.percent(), 100)
+
+        self.assertEqual(self.half_done.percent(), self.also_half_done.percent())
+
+    def test_started(self):
+        self.assertFalse(self.not_started.started())
+
+        self.assertTrue(self.part_done.started())
+        self.assertTrue(self.half_done.started())
+        self.assertTrue(self.done.started())
+
+    def test_inprogress(self):
+        # only true if working on it
+        self.assertFalse(self.done.inprogress())
+        self.assertFalse(self.not_started.inprogress())
+
+        self.assertTrue(self.part_done.inprogress())
+        self.assertTrue(self.half_done.inprogress())
+
+    def test_done(self):
+        self.assertTrue(self.done.done())
+        self.assertFalse(self.half_done.done())
+        self.assertFalse(self.not_started.done())
+
+    def test_str(self):
+        self.assertEqual(str(self.not_started), "0/17")
+        self.assertEqual(str(self.part_done), "2/6")
+        self.assertEqual(str(self.done), "7/7")
+
+    def test_ternary_str(self):
+        self.assertEqual(self.not_started.ternary_str(), "none")
+        self.assertEqual(self.half_done.ternary_str(), "in_progress")
+        self.assertEqual(self.done.ternary_str(), "done")
+
+    def test_to_js_status(self):
+        '''Test the Progress.to_js_status_str() method'''
+
+        self.assertEqual(Progress.to_js_status_str(self.not_started), "none")
+        self.assertEqual(Progress.to_js_status_str(self.half_done), "in_progress")
+        self.assertEqual(Progress.to_js_status_str(self.done), "done")
+        self.assertEqual(Progress.to_js_status_str(None), "NA")
+
+    def test_to_js_detail_str(self):
+        '''Test the Progress.to_js_detail_str() method'''
+        f = Progress.to_js_detail_str
+        for p in (self.not_started, self.half_done, self.done):
+            self.assertEqual(f(p), str(p))
+        # But None should be encoded as NA
+        self.assertEqual(f(None), "NA")
+
+    def test_add(self):
+        '''Test the Progress.add_counts() method'''
+        p = Progress(0, 2)
+        p2 = Progress(1, 3)
+        p3 = Progress(2, 5)
+        pNone = None
+        add = lambda a, b: Progress.add_counts(a, b).frac()
+
+        self.assertEqual(add(p, p), (0, 4))
+        self.assertEqual(add(p, p2), (1, 5))
+        self.assertEqual(add(p2, p3), (3, 8))
+
+        self.assertEqual(add(p2, pNone), p2.frac())
+        self.assertEqual(add(pNone, p2), p2.frac())
+
+    def test_equality(self):
+        '''Test that comparing Progress objects for equality
+        works correctly.'''
+        p = Progress(1, 2)
+        p2 = Progress(2, 4)
+        p3 = Progress(1, 2)
+        self.assertTrue(p == p3)
+        self.assertFalse(p == p2)
+
+        # Check != while we're at it
+        self.assertTrue(p != p2)
+        self.assertFalse(p != p3)
+
+
+class ModuleProgressTest(unittest.TestCase):
+    ''' Test that get_progress() does the right thing for the different modules
+    '''
+    def test_xmodule_default(self):
+        '''Make sure default get_progress exists, returns None'''
+        xm = x_module.XModule(i4xs, 'a://b/c/d/e', None, {})
+        p = xm.get_progress()
+        self.assertEqual(p, None)

common/lib/xmodule/xmodule/video_module.py

@@ -31,12 +31,23 @@ class VideoModule(XModule):
         self.youtube = xmltree.get('youtube')
         self.position = 0
         self.show_captions = xmltree.get('show_captions', 'true')
+        self.source = self._get_source(xmltree)
 
         if instance_state is not None:
             state = json.loads(instance_state)
             if 'position' in state:
                 self.position = int(float(state['position']))
 
+    def _get_source(self, xmltree):
+        # find the first valid source
+        source = None
+        for element in xmltree.findall('source'):
+            src = element.get('src')
+            if src:
+                source = src
+                break
+        return source
+
     def handle_ajax(self, dispatch, get):
         '''
         Handle ajax calls to this video.
@@ -73,6 +84,7 @@ class VideoModule(XModule):
             'streams': self.video_list(),
             'id': self.location.html_id(),
             'position': self.position,
+            'source': self.source,
             'display_name': self.display_name,
             # TODO (cpennington): This won't work when we move to data that isn't on the filesystem
             'data_dir': self.metadata['data_dir'],
@@ -82,6 +94,5 @@ class VideoModule(XModule):
 
 class VideoDescriptor(RawDescriptor):
     module_class = VideoModule
-    
     stores_state = True
     template_dir_name = "video"

common/lib/xmodule/xmodule/x_module.py

@@ -12,6 +12,8 @@ from pkg_resources import resource_listdir, resource_string, resource_isdir
 from xmodule.modulestore import Location
 from xmodule.timeparse import parse_time
 
+from xmodule.contentstore.content import StaticContent, XASSET_SRCREF_PREFIX
+
 log = logging.getLogger('mitx.' + __name__)
 
 
@@ -317,6 +319,20 @@ class XModule(HTMLSnippet):
             get is a dictionary-like object '''
         return ""
 
+    # cdodge: added to support dynamic substitutions of 
+    # links for courseware assets (e.g. images). <link> is passed through from lxml.html parser
+    def rewrite_content_links(self, link):
+        # see if we start with our format, e.g. 'xasset:<filename>'
+        if link.startswith(XASSET_SRCREF_PREFIX):
+            # yes, then parse out the name
+            name = link[len(XASSET_SRCREF_PREFIX):]
+            loc = Location(self.location)
+            # resolve the reference to our internal 'filepath' which
+            link = StaticContent.compute_location_filename(loc.org, loc.course, name)
+
+        return link
+
+
 
 def policy_key(location):
     """

common/static/js/capa/README

+These files really should be in the capa module, but we don't have a way to load js from there at the moment.  (TODO)

common/static/js/capa/chemical_equation_preview.js

+(function () {
+    update = function() {
+        function create_handler(saved_div) {
+            return (function(response) {
+                if (response.error) {
+                    saved_div.html("<span class='error'>" + response.error + "</span>");
+                } else {
+                    saved_div.html(response.preview);
+                }
+            });
+        }
+
+        prev_id = "#" + this.id + "_preview";
+        preview_div = $(prev_id)
+
+        $.get("/preview/chemcalc/", {"formula" : this.value}, create_handler(preview_div));
+    }
+
+    inputs = $('.chemicalequationinput input');
+    // update on load
+    inputs.each(update); 
+    // and on every change
+    inputs.bind("input", update);
+}).call(this);

create-dev-env.sh

@@ -13,13 +13,13 @@ ouch() {
     printf '\E[31m'
 
     cat<<EOL
-    
+
     !! ERROR !!
 
-    The last command did not complete successfully, 
+    The last command did not complete successfully,
     For more details or trying running the
-    script again with the -v flag.  
-    
+    script again with the -v flag.
+
     Output of the script is recorded in $LOG
 
 EOL
@@ -27,18 +27,18 @@ EOL
 
 }
 error() {
-      printf '\E[31m'; echo "$@"; printf '\E[0m' 
+      printf '\E[31m'; echo "$@"; printf '\E[0m'
 }
 output() {
-      printf '\E[36m'; echo "$@"; printf '\E[0m' 
+      printf '\E[36m'; echo "$@"; printf '\E[0m'
 }
 usage() {
     cat<<EO
 
     Usage: $PROG [-c] [-v] [-h]
-    
+
             -c        compile scipy and numpy
-            -s        give access to global site-packages for virtualenv 
+            -s        give access to global site-packages for virtualenv
             -v        set -x + spew
             -h        this
 
@@ -49,7 +49,7 @@ EO
 info() {
 
     cat<<EO
-    MITx base dir : $BASE 
+    MITx base dir : $BASE
     Python dir : $PYTHON_DIR
     Ruby dir : $RUBY_DIR
     Ruby ver : $RUBY_VER
@@ -59,11 +59,11 @@ EO
 
 clone_repos() {
     cd "$BASE"
-    
+
     if [[ -d "$BASE/mitx/.git" ]]; then
         output "Pulling mitx"
         cd "$BASE/mitx"
-        git pull 
+        git pull
     else
         output "Cloning mitx"
         if [[ -d "$BASE/mitx" ]]; then
@@ -71,13 +71,13 @@ clone_repos() {
         fi
         git clone git@github.com:MITx/mitx.git
     fi
-     
+
     if [[ ! -d "$BASE/mitx/askbot/.git" ]]; then
         output "Cloning askbot as a submodule of mitx"
         cd "$BASE/mitx"
         git submodule update --init
     fi
-    
+
     # By default, dev environments start with a copy of 6.002x
     cd "$BASE"
     mkdir -p "$BASE/data"
@@ -85,14 +85,14 @@ clone_repos() {
     if [[ -d "$BASE/data/$REPO/.git" ]]; then
         output "Pulling $REPO"
         cd "$BASE/data/$REPO"
-        git pull 
+        git pull
     else
         output "Cloning $REPO"
         if [[ -d "$BASE/data/$REPO" ]]; then
             mv "$BASE/data/$REPO" "${BASE}/data/$REPO.bak.$$"
         fi
 	cd "$BASE/data"
-        git clone git@github.com:MITx/$REPO 
+        git clone git@github.com:MITx/$REPO
     fi
 }
 
@@ -118,8 +118,8 @@ if [[ $? != 0 ]]; then
     exit 1
 fi
 eval set -- "$ARGS"
-while true; do 
-    case $1 in 
+while true; do
+    case $1 in
         -c)
             compile=true
             shift
@@ -159,16 +159,16 @@ cat<<EO
   To compile scipy and numpy from source use the -c option
 
   !!! Do not run this script from an existing virtualenv !!!
-  
+
   If you are in a ruby/python virtualenv please start a new
-  shell. 
+  shell.
 
 EO
 info
 output "Press return to begin or control-C to abort"
 read dummy
 
-# log all stdout and stderr 
+# log all stdout and stderr
 exec > >(tee $LOG)
 exec 2>&1
 
@@ -193,7 +193,7 @@ case `uname -s` in
             maya|lisa|natty|oneiric|precise)
                 output "Installing ubuntu requirements"
                 sudo apt-get -y update
-                sudo apt-get -y install $APT_PKGS 
+                sudo apt-get -y install $APT_PKGS
                 clone_repos
                 ;;
             *)
@@ -203,11 +203,11 @@ case `uname -s` in
         esac
         ;;
     Darwin)
-    
+
         if [[ ! -w /usr/local ]]; then
             cat<<EO
-   
-        You need to be able to write to /usr/local for 
+
+        You need to be able to write to /usr/local for
         the installation of brew and brew packages.
 
         Either make sure the group you are in (most likely 'staff')
@@ -221,13 +221,13 @@ EO
 
         fi
 
-        command -v brew &>/dev/null || { 
+        command -v brew &>/dev/null || {
             output "Installing brew"
             /usr/bin/ruby <(curl -fsSkL raw.github.com/mxcl/homebrew/go)
-        } 
+        }
         command -v git &>/dev/null || {
             output "Installing git"
-            brew install git 
+            brew install git
         }
 
         clone_repos
@@ -241,17 +241,21 @@ EO
         for pkg in $(cat $BREW_FILE); do
             grep $pkg <(brew list) &>/dev/null || {
                 output "Installing $pkg"
-                brew install $pkg  
+                brew install $pkg
             }
         done
+
+        # paths where brew likes to install python scripts
+        PATH=/usr/local/share/python:/usr/local/bin:$PATH
+
         command -v pip &>/dev/null || {
             output "Installing pip"
-            sudo easy_install pip  
+            easy_install pip
         }
 
         if ! grep -Eq ^1.7 <(virtualenv --version 2>/dev/null); then
             output "Installing virtualenv >1.7"
-            sudo pip install 'virtualenv>1.7' virtualenvwrapper
+            pip install 'virtualenv>1.7' virtualenvwrapper
         fi
 
         command -v coffee &>/dev/null || {
@@ -267,18 +271,10 @@ EO
 esac
 
 output "Installing rvm and ruby"
-curl -sL get.rvm.io | bash -s stable
+curl -sL get.rvm.io | bash -s -- --version 1.15.7
 source $RUBY_DIR/scripts/rvm
-# skip the intro 
+# skip the intro
 LESS="-E" rvm install $RUBY_VER
-if [[ $systempkgs ]]; then
-    virtualenv --system-site-packages "$PYTHON_DIR"
-else
-    # default behavior for virtualenv>1.7 is 
-    # --no-site-packages
-    virtualenv  "$PYTHON_DIR"
-fi
-source $PYTHON_DIR/bin/activate
 output "Installing gem bundler"
 gem install bundler
 output "Installing ruby packages"
@@ -287,6 +283,16 @@ cd $BASE/mitx  || true
 bundle install
 
 cd $BASE
+if [[ $systempkgs ]]; then
+    virtualenv --system-site-packages "$PYTHON_DIR"
+else
+    # default behavior for virtualenv>1.7 is
+    # --no-site-packages
+    virtualenv  "$PYTHON_DIR"
+fi
+
+# change to mitx python virtualenv
+source $PYTHON_DIR/bin/activate
 
 if [[ -n $compile ]]; then
     output "Downloading numpy and scipy"
@@ -297,39 +303,54 @@ if [[ -n $compile ]]; then
     rm -f numpy.tar.gz scipy.tar.gz
     output "Compiling numpy"
     cd "$BASE/numpy-${NUMPY_VER}"
-    python setup.py install 
+    python setup.py install
     output "Compiling scipy"
     cd "$BASE/scipy-${SCIPY_VER}"
-    python setup.py install 
+    python setup.py install
     cd "$BASE"
     rm -rf numpy-${NUMPY_VER} scipy-${SCIPY_VER}
 fi
 
+case `uname -s` in
+    Darwin)
+        # on mac os x get the latest distribute and pip
+        curl http://python-distribute.org/distribute_setup.py | python
+        pip install -U pip
+        # need latest pytz before compiling numpy and scipy
+        pip install -U pytz
+        pip install numpy
+        # fixes problem with scipy on 10.8
+        pip install -e git+https://github.com/scipy/scipy#egg=scipy-dev
+        ;;
+esac
+
 output "Installing MITx pre-requirements"
-pip install -r mitx/pre-requirements.txt 
+pip install -r mitx/pre-requirements.txt
 # Need to be in the mitx dir to get the paths to local modules right
 output "Installing MITx requirements"
 cd mitx
-pip install -r requirements.txt 
+pip install -r requirements.txt
 output "Installing askbot requirements"
-pip install -r askbot/askbot_requirements.txt 
-pip install -r askbot/askbot_requirements_dev.txt 
-
+pip install -r askbot/askbot_requirements.txt
+pip install -r askbot/askbot_requirements_dev.txt
 
 mkdir "$BASE/log" || true
 mkdir "$BASE/db" || true
 
+output "Fixing your git default settings"
+git config --global push.default current
+
 cat<<END
    Success!!
 
-   To start using Django you will need to activate the local Python 
+   To start using Django you will need to activate the local Python
    and Ruby environment (at this time rvm only supports bash) :
 
         $ source $RUBY_DIR/scripts/rvm
         $ source $PYTHON_DIR/bin/activate
-  
+
    To initialize Django
-        
+
         $ cd $BASE/mitx
         $ rake django-admin[syncdb]
         $ rake django-admin[migrate]
@@ -337,21 +358,20 @@ cat<<END
    To start the Django on port 8000
 
         $ rake lms
-   
+
    Or to start Django on a different <port#>
 
-        $ rake django-admin[runserver,lms,dev,<port#>]   
+        $ rake django-admin[runserver,lms,dev,<port#>]
 
-  If the Django development server starts properly you 
+  If the  Django development server starts properly you
   should see:
 
       Development server is running at http://127.0.0.1:<port#>/
       Quit the server with CONTROL-C.
 
-  Connect your browser to http://127.0.0.1:<port#> to 
+  Connect your browser to http://127.0.0.1:<port#> to
   view the Django site.
 
 
 END
 exit 0
-

doc/course_grading.md

+# Course Grading
+
+This document is written to help professors understand how a final grade for a
+course is computed.
+
+Course grading is the process of taking all of the problems scores for a student
+in a course and generating a final score (and corresponding letter grade). This 
+grading process can be split into two phases - totaling sections and section 
+weighting.
+
+## Totaling sections
+
+The process of totaling sections is to get a percentage score (between 0.0 and
+1.0) for every section in the course. A section is any module that is a direct
+child of a chapter. For example, psets, labs, and sequences are all common
+sections. Only the *percentage* on the section will be available to compute the
+final grade, *not* the final number of points earned / possible.
+
+
+**For a section to be included in the final grade, the policies file must set
+graded = True for the section.**
+
+For each section, the grading function retrieves all problems within the
+section. The section percentage is computed as (total points earned) / (total
+points possible).
+
+
+### Weighting Problems
+In some cases, one might want to give weights to problems within a section. For
+example, a final exam might contain 4 questions each worth 1 point by default.
+This means each question would by default have the same weight. If one wanted
+the first problem to be worth 50% of the final exam, the policy file could specify
+weights of 30, 10, 10, and 10 to the 4 problems, respectively.
+
+Note that the default weight of a problem **is not 1.** The default weight of a
+problem is the module's max_grade.
+
+## Section Weighting
+
+Once each section has a percentage score, we must total those sections into a
+final grade. Of course, not every section has equal weight in the final grade.
+The policies for weighting sections into a final grade are specified in the
+grading_policy.json file.
+
+The grading_policy.json file specifies several sub-graders that are each given
+a weight and factored into the final grade. There are currently two types of
+sub-graders, section format graders and single section graders.
+
+We will use this simple example of a grader with one section format grader and
+one single section grader.
+
+
+    "GRADER" : [
+        {
+          "type" : "Homework",
+          "min_count" : 12,
+          "drop_count" : 2,
+          "short_label" : "HW",
+          "weight" : 0.4
+        },
+        {
+          "type" : "Final",
+          "name" : "Final Exam",
+          "short_label" : "Final",
+          "weight" : 0.6
+        }
+    ]
+
+### Section Format Graders
+
+A section format grader grades a set of sections with the same format, as
+defined in the course policy file. To make a vertical named Homework1 be graded
+by the Homework section format grader, the following definition would be in the
+course policy file.
+
+
+    "vertical/Homework1": {
+        "display_name": "Homework 1", 
+        "graded": true, 
+        "format": "Homework"
+    },
+
+
+In the example above, the section format grader declares that it will expect to
+find at least 12 sections with the format "Homework". It will drop the lowest 2.
+All of the homework assignments will have equal weight, relative to each other 
+(except, of course, for the assignments that are dropped).
+
+This format supports forecasting the number of homework assignments. For
+example, if the course only has 3 homeworks written, but the section format
+grader has been told to expect 12, the missing 9 will have an assumed 0% and
+will still show up in the grade breakdown.
+
+A section format grader will also show the average of that section in the grade
+breakdown (shown on the Progress page, gradebook, etc.).
+
+
+### Single Section Graders
+
+A single section grader grades exactly that - a single section. If a section
+is found with a matching format and display name then the score of that section
+is used. If not, a score of 0% is assumed.
+
+
+### Combining sub-graders
+
+The final grade is computed by taking the score and weight of each sub grader.
+In the above example, homework will be 40% of the final grade. The final exam
+will be 60% of the final grade.
+
+## Displaying the final grade
+
+The final grade is then rounded up to the nearest percentage point. This is so
+the system can consistently display a percentage without worrying whether the
+displayed percentage has been rounded up or down (potentially misleading the
+student). The formula for the rounding is
+
+    rounded_percent = round(computed_percent * 100 + 0.05) / 100
+
+The grading policy file also specifies the cutoffs for the grade levels. A
+grade is either A, B, or C. If the student does not reach the cutoff threshold
+for a C grade then the student has not earned a grade and will not be eligible
+for a certificate. Letter grades are only awarded to students who have
+completed the course. There is no notion of a failing letter grade.
+
+
+
+

doc/xml-format.md

@@ -143,6 +143,7 @@ That's basically all there is to the organizational structure.  Read the next se
 * `chapter` -- top level organization unit of a course.   The courseware display code currently expects the top level `course` element to contain only chapters, though there is no philosophical reason why this is required, so we may change it to properly display non-chapters at the top level.
 * `course` -- top level tag.  Contains everything else.
 * `customtag` -- render an html template, filling in some parameters, and return the resulting html.  See below for details.
+* `discussion` -- Inline discussion forum
 * `html` -- a reference to an html file.
 * `error`  -- don't put these in by hand :)   The internal representation of content that has an error, such as malformed xml or some broken invariant.  You may see this in the xml once the CMS is in use...
 * `problem` -- a problem.  See elsewhere in edx4edx for documentation on the format.
@@ -171,6 +172,33 @@ When we see `<customtag impl="special" animal="unicorn" hat="blue"/>`, we will:
 
 Since `customtag` is already a pointer, there is generally no need to put it into a separate file--just use it in place: <customtag url_name="my_custom_tag" impl="blah" attr1="..."/>
 
+### `discussion`
+
+The discussion tag embeds an inline discussion module. The XML format is:
+```
+<discussion for="Course overview" id="6002x_Fall_2012_Overview" discussion_category="Week 1 / Overview" />
+``` 
+The meaning of each attribute is as follows:
+* `for`: A string that describes the discussion. Purely for descriptive purposes (to the student).
+* `id`: The identifier that the discussion forum service uses to refer to this inline discussion module. Since the `id` must be unique and lives in a common namespace with all other courses, the preferred convention is to use `<course_name>_<course_run>_<descriptor>` as in the above example. The `id` should be "machine-friendly", e.g. use alphanumeric characters, underscores. Do **not** use a period (e.g. `6.002x_Fall_2012_Overview`).
+* `discussion_category`: The inline module will be indexed in the main "Discussion" tab of the course. The inline discussions are organized into a directory-like hierarchy. Note that the forward slash indicates depth, as in conventional filesytems. In the above example, this discussion module will show up in the following "directory":
+```
+Week 1 / Overview / Course overview
+```
+
+Further discussion on `discussion_category`:
+Note that the `for` tag has been appended to the end of the `discussion_category`. This can often lead into deeply nested subforums, which may not be intended. In the above example, if we were to use instead:
+
+```
+<discussion for="Course overview" id="6002x_Fall_2012_Overview" discussion_category="Week 1" />
+``` 
+
+this discussion module would show up in the main forums as:
+```
+Week 1 / Course overview
+```
+
+which is more succinct.
 
 ### `html`
 

lms/djangoapps/courseware/access.py

@@ -106,7 +106,7 @@ def _has_access_course_desc(user, course, action):
         NOTE: this is not checking whether user is actually enrolled in the course.
         """
         # delegate to generic descriptor check to check start dates
-        return _has_access_descriptor(user, course, action)
+        return _has_access_descriptor(user, course, 'load')
 
     def can_enroll():
         """

lms/djangoapps/courseware/grades.py

@@ -201,7 +201,7 @@ def grade(student, request, course, student_module_cache=None, keep_raw_scores=F
 
         totaled_scores[section_format] = format_scores
 
-    grade_summary = course.grader.grade(totaled_scores)
+    grade_summary = course.grader.grade(totaled_scores, generate_random_scores=settings.GENERATE_PROFILE_SCORES)
 
     # We round the grade here, to make sure that the grade is an whole percentage and
     # doesn't get displayed differently than it gets grades
@@ -253,7 +253,7 @@ def progress_summary(student, request, course, student_module_cache):
 
     Arguments:
         student: A User object for the student to grade
-        course: An XModule containing the course to grade
+        course: A Descriptor containing the course to grade
         student_module_cache: A StudentModuleCache initialized with all
              instance_modules for the student
     
@@ -329,9 +329,15 @@ def progress_summary(student, request, course, student_module_cache):
 def get_score(course_id, user, problem_descriptor, module_creator, student_module_cache):
     """
     Return the score for a user on a problem, as a tuple (correct, total).
+    e.g. (5,7) if you got 5 out of 7 points.
+
+    If this problem doesn't have a score, or we couldn't load it, returns (None,
+    None).
 
     user: a Student object
-    problem: an XModule
+    problem_descriptor: an XModuleDescriptor
+    module_creator: a function that takes a descriptor, and returns the corresponding XModule for this user.
+           Can return None if user doesn't have access, or if something else went wrong.
     cache: A StudentModuleCache
     """
     if not (problem_descriptor.stores_state and problem_descriptor.has_score):
@@ -339,14 +345,16 @@ def get_score(course_id, user, problem_descriptor, module_creator, student_modul
         return (None, None)
 
     correct = 0.0
-    
+
     instance_module = student_module_cache.lookup(
         course_id, problem_descriptor.category, problem_descriptor.location.url())
-    
+
     if not instance_module:
         # If the problem was not in the cache, we need to instantiate the problem.
-        # Otherwise, the max score (cached in instance_module) won't be available 
+        # Otherwise, the max score (cached in instance_module) won't be available
         problem = module_creator(problem_descriptor)
+        if problem is None:
+            return (None, None)
         instance_module = get_instance_module(course_id, user, problem, student_module_cache)
 
     # If this problem is ungraded/ungradable, bail
@@ -361,7 +369,7 @@ def get_score(course_id, user, problem_descriptor, module_creator, student_modul
         weight = getattr(problem_descriptor, 'weight', None)
         if weight is not None:
             if total == 0:
-                log.exception("Cannot reweight a problem with zero weight. Problem: " + str(instance_module))
+                log.exception("Cannot reweight a problem with zero total points. Problem: " + str(instance_module))
                 return (correct, total)
             correct = correct * weight / total
             total = weight

lms/djangoapps/courseware/module_render.py

 import hashlib
 import json
 import logging
+import pyparsing
 import sys
 
 from django.conf import settings
@@ -13,6 +14,7 @@ from django.views.decorators.csrf import csrf_exempt
 from requests.auth import HTTPBasicAuth
 
 from capa.xqueue_interface import XQueueInterface
+from capa.chem import chemcalc
 from courseware.access import has_access
 from mitxmako.shortcuts import render_to_string
 from models import StudentModule, StudentModuleCache
@@ -29,7 +31,7 @@ from xmodule_modifiers import replace_course_urls, replace_static_urls, add_hist
 log = logging.getLogger("mitx.courseware")
 
 
-if settings.XQUEUE_INTERFACE['basic_auth'] is not None:
+if settings.XQUEUE_INTERFACE.get('basic_auth') is not None:
     requests_auth = HTTPBasicAuth(*settings.XQUEUE_INTERFACE['basic_auth'])
 else:
     requests_auth = None
@@ -435,6 +437,10 @@ def modx_dispatch(request, dispatch, location, course_id):
     # Don't track state for anonymous users (who don't have student modules)
     if instance_module is not None:
         oldgrade = instance_module.grade
+        # The max grade shouldn't change under normal circumstances, but
+        # sometimes the problem changes with the same name but a new max grade.
+        # This updates the module if that happens.
+        old_instance_max_grade = instance_module.max_grade
         old_instance_state = instance_module.state
         old_shared_state = shared_module.state if shared_module is not None else None
 
@@ -452,9 +458,12 @@ def modx_dispatch(request, dispatch, location, course_id):
     # Don't track state for anonymous users (who don't have student modules)
     if instance_module is not None:
         instance_module.state = instance.get_instance_state()
+        instance_module.max_grade=instance.max_score()
         if instance.get_score():
             instance_module.grade = instance.get_score()['score']
-        if instance_module.grade != oldgrade or instance_module.state != old_instance_state:
+        if (instance_module.grade != oldgrade or
+            instance_module.state != old_instance_state or
+            instance_module.max_grade != old_instance_max_grade):
             instance_module.save()
 
     if shared_module is not None:
@@ -464,3 +473,42 @@ def modx_dispatch(request, dispatch, location, course_id):
 
     # Return whatever the module wanted to return to the client/caller
     return HttpResponse(ajax_return)
+
+def preview_chemcalc(request):
+    """
+    Render an html preview of a chemical formula or equation.  The fact that
+    this is here is a bit of hack.  See the note in lms/urls.py about why it's
+    here. (Victor is to blame.)
+
+    request should be a GET, with a key 'formula' and value 'some formula string'.
+
+    Returns a json dictionary:
+    {
+       'preview' : 'the-preview-html' or ''
+       'error' : 'the-error' or ''
+    }
+    """
+    if request.method != "GET":
+        raise Http404
+
+    result = {'preview': '',
+              'error': '' }
+    formula = request.GET.get('formula')
+    if formula is None:
+        result['error'] = "No formula specified."
+
+        return HttpResponse(json.dumps(result))
+
+    try:
+        result['preview'] = chemcalc.render_to_html(formula)
+    except pyparsing.ParseException as p:
+        result['error'] = "Couldn't parse formula: {0}".format(p)
+    except Exception:
+        # this is unexpected, so log
+        log.warning("Error while previewing chemical formula", exc_info=True)
+        result['error'] = "Error while rendering preview"
+
+    return HttpResponse(json.dumps(result))
+
+
+