Merge branch 'master' of github.com:edx/mitx into fix/cdodge/textbooks-not-exporting

cms/djangoapps/contentstore/views.py

@@ -72,7 +72,7 @@ log = logging.getLogger(__name__)
 COMPONENT_TYPES = ['customtag', 'discussion', 'html', 'problem', 'video']
 
 OPEN_ENDED_COMPONENT_TYPES = ["combinedopenended", "peergrading"]
-ADVANCED_COMPONENT_TYPES = ['annotatable'] + OPEN_ENDED_COMPONENT_TYPES
+ADVANCED_COMPONENT_TYPES = ['annotatable', 'word_cloud'] + OPEN_ENDED_COMPONENT_TYPES
 ADVANCED_COMPONENT_CATEGORY = 'advanced'
 ADVANCED_COMPONENT_POLICY_KEY = 'advanced_modules'
 

common/lib/xmodule/setup.py

@@ -52,6 +52,7 @@ setup(
             "graphical_slider_tool = xmodule.gst_module:GraphicalSliderToolDescriptor",
             "annotatable = xmodule.annotatable_module:AnnotatableDescriptor",
             "foldit = xmodule.foldit_module:FolditDescriptor",
+            "word_cloud = xmodule.word_cloud_module:WordCloudDescriptor",
             "hidden = xmodule.hidden_module:HiddenDescriptor",
             "raw = xmodule.raw_module:RawDescriptor",
         ],

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

+.input-cloud {
+    margin: 5px;
+}
+
+.result_cloud_section {
+    display: none;
+    width: 0px;
+    height: 0px;
+}
+
+.result_cloud_section.active {
+    display: block;
+    width: 635px;
+    height: auto;
+    margin-left: auto;
+    margin-right: auto;
+}
+.your_words{
+    font-size: 0.85em;
+    display: block;
+}
\ No newline at end of file

common/lib/xmodule/xmodule/js/src/word_cloud/d3.layout.cloud.js

+/*
+ * Word cloud layout by Jason Davies
+ * https://github.com/jasondavies/d3-cloud
+ * 
+ *
+ * Copyright (c) 2012, Jason Davies.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *   * Redistributions of source code must retain the above copyright notice, this
+ *     list of conditions and the following disclaimer.
+ * 
+ *   * Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ * 
+ *   * The name Jason Davies may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL JASON DAVIES BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+(function(exports) {
+  function cloud() {
+    var size = [256, 256],
+        text = cloudText,
+        font = cloudFont,
+        fontSize = cloudFontSize,
+        fontStyle = cloudFontNormal,
+        fontWeight = cloudFontNormal,
+        rotate = cloudRotate,
+        padding = cloudPadding,
+        spiral = archimedeanSpiral,
+        words = [],
+        timeInterval = Infinity,
+        event = d3.dispatch("word", "end"),
+        timer = null,
+        cloud = {};
+
+    cloud.start = function() {
+      var board = zeroArray((size[0] >> 5) * size[1]),
+          bounds = null,
+          n = words.length,
+          i = -1,
+          tags = [],
+          data = words.map(function(d, i) {
+            d.text = text.call(this, d, i);
+            d.font = font.call(this, d, i);
+            d.style = fontStyle.call(this, d, i);
+            d.weight = fontWeight.call(this, d, i);
+            d.rotate = rotate.call(this, d, i);
+            d.size = ~~fontSize.call(this, d, i);
+            d.padding = cloudPadding.call(this, d, i);
+            return d;
+          }).sort(function(a, b) { return b.size - a.size; });
+
+      if (timer) clearInterval(timer);
+      timer = setInterval(step, 0);
+      step();
+
+      return cloud;
+
+      function step() {
+        var start = +new Date,
+            d;
+        while (+new Date - start < timeInterval && ++i < n && timer) {
+          d = data[i];
+          d.x = (size[0] * (Math.random() + .5)) >> 1;
+          d.y = (size[1] * (Math.random() + .5)) >> 1;
+          cloudSprite(d, data, i);
+          if (place(board, d, bounds)) {
+            tags.push(d);
+            event.word(d);
+            if (bounds) cloudBounds(bounds, d);
+            else bounds = [{x: d.x + d.x0, y: d.y + d.y0}, {x: d.x + d.x1, y: d.y + d.y1}];
+            // Temporary hack
+            d.x -= size[0] >> 1;
+            d.y -= size[1] >> 1;
+          }
+        }
+        if (i >= n) {
+          cloud.stop();
+          event.end(tags, bounds);
+        }
+      }
+    }
+
+    cloud.stop = function() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      return cloud;
+    };
+
+    cloud.timeInterval = function(x) {
+      if (!arguments.length) return timeInterval;
+      timeInterval = x == null ? Infinity : x;
+      return cloud;
+    };
+
+    function place(board, tag, bounds) {
+      var perimeter = [{x: 0, y: 0}, {x: size[0], y: size[1]}],
+          startX = tag.x,
+          startY = tag.y,
+          maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]),
+          s = spiral(size),
+          dt = Math.random() < .5 ? 1 : -1,
+          t = -dt,
+          dxdy,
+          dx,
+          dy;
+
+      while (dxdy = s(t += dt)) {
+        dx = ~~dxdy[0];
+        dy = ~~dxdy[1];
+
+        if (Math.min(dx, dy) > maxDelta) break;
+
+        tag.x = startX + dx;
+        tag.y = startY + dy;
+
+        if (tag.x + tag.x0 < 0 || tag.y + tag.y0 < 0 ||
+            tag.x + tag.x1 > size[0] || tag.y + tag.y1 > size[1]) continue;
+        // TODO only check for collisions within current bounds.
+        if (!bounds || !cloudCollide(tag, board, size[0])) {
+          if (!bounds || collideRects(tag, bounds)) {
+            var sprite = tag.sprite,
+                w = tag.width >> 5,
+                sw = size[0] >> 5,
+                lx = tag.x - (w << 4),
+                sx = lx & 0x7f,
+                msx = 32 - sx,
+                h = tag.y1 - tag.y0,
+                x = (tag.y + tag.y0) * sw + (lx >> 5),
+                last;
+            for (var j = 0; j < h; j++) {
+              last = 0;
+              for (var i = 0; i <= w; i++) {
+                board[x + i] |= (last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);
+              }
+              x += sw;
+            }
+            delete tag.sprite;
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    cloud.words = function(x) {
+      if (!arguments.length) return words;
+      words = x;
+      return cloud;
+    };
+
+    cloud.size = function(x) {
+      if (!arguments.length) return size;
+      size = [+x[0], +x[1]];
+      return cloud;
+    };
+
+    cloud.font = function(x) {
+      if (!arguments.length) return font;
+      font = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.fontStyle = function(x) {
+      if (!arguments.length) return fontStyle;
+      fontStyle = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.fontWeight = function(x) {
+      if (!arguments.length) return fontWeight;
+      fontWeight = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.rotate = function(x) {
+      if (!arguments.length) return rotate;
+      rotate = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.text = function(x) {
+      if (!arguments.length) return text;
+      text = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.spiral = function(x) {
+      if (!arguments.length) return spiral;
+      spiral = spirals[x + ""] || x;
+      return cloud;
+    };
+
+    cloud.fontSize = function(x) {
+      if (!arguments.length) return fontSize;
+      fontSize = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.padding = function(x) {
+      if (!arguments.length) return padding;
+      padding = d3.functor(x);
+      return cloud;
+    };
+
+    return d3.rebind(cloud, event, "on");
+  }
+
+  function cloudText(d) {
+    return d.text;
+  }
+
+  function cloudFont() {
+    return "serif";
+  }
+
+  function cloudFontNormal() {
+    return "normal";
+  }
+
+  function cloudFontSize(d) {
+    return Math.sqrt(d.value);
+  }
+
+  function cloudRotate() {
+    return (~~(Math.random() * 6) - 3) * 30;
+  }
+
+  function cloudPadding() {
+    return 1;
+  }
+
+  // Fetches a monochrome sprite bitmap for the specified text.
+  // Load in batches for speed.
+  function cloudSprite(d, data, di) {
+    if (d.sprite) return;
+    c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);
+    var x = 0,
+        y = 0,
+        maxh = 0,
+        n = data.length;
+    di--;
+    while (++di < n) {
+      d = data[di];
+      c.save();
+      c.font = d.style + " " + d.weight + " " + ~~((d.size + 1) / ratio) + "px " + d.font;
+      var w = c.measureText(d.text + "m").width * ratio,
+          h = d.size << 1;
+      if (d.rotate) {
+        var sr = Math.sin(d.rotate * cloudRadians),
+            cr = Math.cos(d.rotate * cloudRadians),
+            wcr = w * cr,
+            wsr = w * sr,
+            hcr = h * cr,
+            hsr = h * sr;
+        w = (Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f) >> 5 << 5;
+        h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));
+      } else {
+        w = (w + 0x1f) >> 5 << 5;
+      }
+      if (h > maxh) maxh = h;
+      if (x + w >= (cw << 5)) {
+        x = 0;
+        y += maxh;
+        maxh = 0;
+      }
+      if (y + h >= ch) break;
+      c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);
+      if (d.rotate) c.rotate(d.rotate * cloudRadians);
+      c.fillText(d.text, 0, 0);
+      c.restore();
+      d.width = w;
+      d.height = h;
+      d.xoff = x;
+      d.yoff = y;
+      d.x1 = w >> 1;
+      d.y1 = h >> 1;
+      d.x0 = -d.x1;
+      d.y0 = -d.y1;
+      x += w;
+    }
+    var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,
+        sprite = [];
+    while (--di >= 0) {
+      d = data[di];
+      var w = d.width,
+          w32 = w >> 5,
+          h = d.y1 - d.y0,
+          p = d.padding;
+      // Zero the buffer
+      for (var i = 0; i < h * w32; i++) sprite[i] = 0;
+      x = d.xoff;
+      if (x == null) return;
+      y = d.yoff;
+      var seen = 0,
+          seenRow = -1;
+      for (var j = 0; j < h; j++) {
+        for (var i = 0; i < w; i++) {
+          var k = w32 * j + (i >> 5),
+              m = pixels[((y + j) * (cw << 5) + (x + i)) << 2] ? 1 << (31 - (i % 32)) : 0;
+          if (p) {
+            if (j) sprite[k - w32] |= m;
+            if (j < w - 1) sprite[k + w32] |= m;
+            m |= (m << 1) | (m >> 1);
+          }
+          sprite[k] |= m;
+          seen |= m;
+        }
+        if (seen) seenRow = j;
+        else {
+          d.y0++;
+          h--;
+          j--;
+          y++;
+        }
+      }
+      d.y1 = d.y0 + seenRow;
+      d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32);
+    }
+  }
+
+  // Use mask-based collision detection.
+  function cloudCollide(tag, board, sw) {
+    sw >>= 5;
+    var sprite = tag.sprite,
+        w = tag.width >> 5,
+        lx = tag.x - (w << 4),
+        sx = lx & 0x7f,
+        msx = 32 - sx,
+        h = tag.y1 - tag.y0,
+        x = (tag.y + tag.y0) * sw + (lx >> 5),
+        last;
+    for (var j = 0; j < h; j++) {
+      last = 0;
+      for (var i = 0; i <= w; i++) {
+        if (((last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0))
+            & board[x + i]) return true;
+      }
+      x += sw;
+    }
+    return false;
+  }
+
+  function cloudBounds(bounds, d) {
+    var b0 = bounds[0],
+        b1 = bounds[1];
+    if (d.x + d.x0 < b0.x) b0.x = d.x + d.x0;
+    if (d.y + d.y0 < b0.y) b0.y = d.y + d.y0;
+    if (d.x + d.x1 > b1.x) b1.x = d.x + d.x1;
+    if (d.y + d.y1 > b1.y) b1.y = d.y + d.y1;
+  }
+
+  function collideRects(a, b) {
+    return a.x + a.x1 > b[0].x && a.x + a.x0 < b[1].x && a.y + a.y1 > b[0].y && a.y + a.y0 < b[1].y;
+  }
+
+  function archimedeanSpiral(size) {
+    var e = size[0] / size[1];
+    return function(t) {
+      return [e * (t *= .1) * Math.cos(t), t * Math.sin(t)];
+    };
+  }
+
+  function rectangularSpiral(size) {
+    var dy = 4,
+        dx = dy * size[0] / size[1],
+        x = 0,
+        y = 0;
+    return function(t) {
+      var sign = t < 0 ? -1 : 1;
+      // See triangular numbers: T_n = n * (n + 1) / 2.
+      switch ((Math.sqrt(1 + 4 * sign * t) - sign) & 3) {
+        case 0:  x += dx; break;
+        case 1:  y += dy; break;
+        case 2:  x -= dx; break;
+        default: y -= dy; break;
+      }
+      return [x, y];
+    };
+  }
+
+  // TODO reuse arrays?
+  function zeroArray(n) {
+    var a = [],
+        i = -1;
+    while (++i < n) a[i] = 0;
+    return a;
+  }
+
+  var cloudRadians = Math.PI / 180,
+      cw = 1 << 11 >> 5,
+      ch = 1 << 11,
+      canvas,
+      ratio = 1;
+
+  if (typeof document !== "undefined") {
+    canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    ratio = Math.sqrt(canvas.getContext("2d").getImageData(0, 0, 1, 1).data.length >> 2);
+    canvas.width = (cw << 5) / ratio;
+    canvas.height = ch / ratio;
+  } else {
+    // node-canvas support
+    var Canvas = require("canvas");
+    canvas = new Canvas(cw << 5, ch);
+  }
+
+  var c = canvas.getContext("2d"),
+      spirals = {
+        archimedean: archimedeanSpiral,
+        rectangular: rectangularSpiral
+      };
+  c.fillStyle = "red";
+  c.textAlign = "center";
+
+  exports.cloud = cloud;
+})(typeof exports === "undefined" ? d3.layout || (d3.layout = {}) : exports);

common/lib/xmodule/xmodule/js/src/word_cloud/logme.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('logme', [], function () {
+    var debugMode;
+
+    // debugMode can be one of the following:
+    //
+    //     true - All messages passed to logme will be written to the internal
+    //            browser console.
+    //     false - Suppress all output to the internal browser console.
+    //
+    // Obviously, if anywhere there is a direct console.log() call, we can't do
+    // anything about it. That's why use logme() - it will allow to turn off
+    // the output of debug information with a single change to a variable.
+    debugMode = true;
+
+    return logme;
+
+    /*
+     * function: logme
+     *
+     * A helper function that provides logging facilities. We don't want
+     * to call console.log() directly, because sometimes it is not supported
+     * by the browser. Also when everything is routed through this function.
+     * the logging output can be easily turned off.
+     *
+     * logme() supports multiple parameters. Each parameter will be passed to
+     * console.log() function separately.
+     *
+     */
+    function logme() {
+        var i;
+
+        if (
+            (typeof debugMode === 'undefined') ||
+            (debugMode !== true) ||
+            (typeof window.console === 'undefined')
+        ) {
+            return;
+        }
+
+        for (i = 0; i < arguments.length; i++) {
+            window.console.log(arguments[i]);
+        }
+    } // End-of: function logme
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/word_cloud/word_cloud.js

+window.WordCloud = function (el) {
+    RequireJS.require(['WordCloudMain'], function (WordCloudMain) {
+        new WordCloudMain(el);
+    });
+};

common/lib/xmodule/xmodule/js/src/word_cloud/word_cloud_main.js

+/**
+ * @file The main module definition for Word Cloud XModule.
+ *
+ *  Defines a constructor function which operates on a DOM element. Either show the user text inputs so
+ *  he can enter words, or render his selected words along with the word cloud representing the top words.
+ *
+ *  @module WordCloudMain
+ *
+ *  @exports WordCloudMain
+ *
+ *  @requires logme
+ *
+ *  @external d3, $, RequireJS
+ */
+
+(function (requirejs, require, define) {
+define('WordCloudMain', ['logme'], function (logme) {
+
+    /**
+     * @function WordCloudMain
+     *
+     * This function will process all the attributes from the DOM element passed, taking all of
+     * the configuration attributes. It will either then attach a callback handler for the click
+     * event on the button in the case when the user needs to enter words, or it will call the
+     * appropriate mehtod to generate and render a word cloud from user's enetered words along with
+     * all of the other words.
+     *
+     * @constructor
+     *
+     * @param {jQuery} el DOM element where the word cloud will be processed and created.
+     */
+    var WordCloudMain = function (el) {
+        var _this = this;
+
+        this.wordCloudEl = $(el).find('.word_cloud');
+
+        // Get the URL to which we will post the users words.
+        this.ajax_url = this.wordCloudEl.data('ajax-url');
+
+        // Dimensions of the box where the word cloud will be drawn.
+        this.width = 635;
+        this.height = 635;
+
+        // Hide WordCloud container before Ajax request done
+        this.wordCloudEl.hide();
+
+        // Retriveing response from the server as an AJAX request. Attach a callback that will
+        // be fired on server's response.
+        $.postWithPrefix(
+            _this.ajax_url + '/' + 'get_state', null,
+            function (response) {
+                if (response.status !== 'success') {
+                    logme('ERROR: ' + response.error);
+
+                    return;
+                }
+
+                _this.configJson = response;
+            }
+        )
+        .done(function () {
+            // Show WordCloud container after Ajax request done
+            _this.wordCloudEl.show();
+
+            if (_this.configJson && _this.configJson.submitted) {
+                _this.showWordCloud(_this.configJson);
+
+                return;
+            }
+        });
+
+        $(el).find('input.save').on('click', function () {
+            _this.submitAnswer();
+        });
+    }; // End-of: var WordCloudMain = function (el) {
+
+    /**
+     * @function submitAnswer
+     *
+     * Callback to be executed when the user eneter his words. It will send user entries to the
+     * server, and upon receiving correct response, will call the function to generate the
+     * word cloud.
+     */
+    WordCloudMain.prototype.submitAnswer = function () {
+        var _this = this,
+            data = {'student_words': []};
+
+        // Populate the data to be sent to the server with user's words.
+        this.wordCloudEl.find('input.input-cloud').each(function (index, value) {
+            data.student_words.push($(value).val());
+        });
+
+        // Send the data to the server as an AJAX request. Attach a callback that will
+        // be fired on server's response.
+        $.postWithPrefix(
+            _this.ajax_url + '/' + 'submit', $.param(data),
+            function (response) {
+                if (response.status !== 'success') {
+                    logme('ERROR: ' + response.error);
+
+                    return;
+                }
+
+                _this.showWordCloud(response);
+            }
+        );
+
+    }; // End-of: WordCloudMain.prototype.submitAnswer = function () {
+
+    /**
+     * @function showWordCloud
+     *
+     * @param {object} response The response from the server that contains the user's entered words
+     * along with all of the top words.
+     *
+     * This function will set up everything for d3 and launch the draw method. Among other things,
+     * iw will determine maximum word size.
+     */
+    WordCloudMain.prototype.showWordCloud = function (response) {
+        var words,
+            _this = this,
+            maxSize, minSize, scaleFactor, maxFontSize, minFontSize;
+
+        this.wordCloudEl.find('.input_cloud_section').hide();
+
+        words = response.top_words;
+        maxSize = 0;
+        minSize = 10000;
+        scaleFactor = 1;
+        maxFontSize = 200;
+        minFontSize = 15;
+
+        // Find the word with the maximum percentage. I.e. the most popular word.
+        $.each(words, function (index, word) {
+            if (word.size > maxSize) {
+                maxSize = word.size;
+            }
+            if (word.size < minSize) {
+                minSize = word.size;
+            }
+        });
+
+        // Find the longest word, and calculate the scale appropriately. This is
+        // required so that even long words fit into the drawing area.
+        //
+        // This is a fix for: if the word is very long and/or big, it is discarded by
+        // for unknown reason.
+        $.each(words, function (index, word) {
+            var tempScaleFactor = 1.0,
+                size = ((word.size / maxSize) * maxFontSize);
+
+            if (size * 0.7 * word.text.length > _this.width) {
+                tempScaleFactor = ((_this.width / word.text.length) / 0.7) / size;
+            }
+
+            if (scaleFactor > tempScaleFactor) {
+                scaleFactor = tempScaleFactor;
+            }
+        });
+
+        // Update the maximum font size based on the longest word.
+        maxFontSize *= scaleFactor;
+
+        // Generate the word cloud.
+        d3.layout.cloud().size([this.width, this.height])
+            .words(words)
+            .rotate(function () {
+                return Math.floor((Math.random() * 2) * 90);
+            })
+            .font('Impact')
+            .fontSize(function (d) {
+                var size = (d.size / maxSize) * maxFontSize;
+
+                size = size >= minFontSize ? size : minFontSize;
+
+                return size;
+            })
+            .on('end', function (words, bounds) {
+                // Draw the word cloud.
+                _this.drawWordCloud(response, words, bounds);
+            })
+            .start();
+    }; // End-of: WordCloudMain.prototype.showWordCloud = function (response) {
+
+    /**
+     * @function drawWordCloud
+     *
+     * This function will be called when d3 has finished initing the state for our word cloud,
+     * and it is ready to hand off the process to the drawing routine. Basically set up everything
+     * necessary for the actual drwing of the words.
+     *
+     * @param {object} response The response from the server that contains the user's entered words
+     * along with all of the top words.
+     *
+     * @param {array} words An array of objects. Each object must have two properties. One property
+     * is 'text' (the actual word), and the other property is 'size' which represents the number that the
+     * word was enetered by the students.
+     *
+     * @param {array} bounds An array of two objects. First object is the top-left coordinates of the bounding
+     * box where all of the words fir, second object is the bottom-right coordinates of the bounding box. Each
+     * coordinate object contains two properties: 'x', and 'y'.
+     */
+    WordCloudMain.prototype.drawWordCloud = function (response, words, bounds) {
+            // Color words in different colors.
+        var fill = d3.scale.category20(),
+
+            // Will be populated by words the user enetered.
+            studentWordsKeys = [],
+
+            // Comma separated string of user enetered words.
+            studentWordsStr,
+
+            // By default we do not scale.
+            scale = 1,
+
+            // Caсhing of DOM element
+            cloudSectionEl = this.wordCloudEl.find('.result_cloud_section'),
+
+            // Needed for caсhing of d3 group elements
+            groupEl;
+
+        // If bounding rectangle is given, scale based on the bounding box of all the words.
+        if (bounds) {
+            scale = 0.5 * Math.min(
+                this.width / Math.abs(bounds[1].x - this.width / 2),
+                this.width / Math.abs(bounds[0].x - this.width / 2),
+                this.height / Math.abs(bounds[1].y - this.height / 2),
+                this.height / Math.abs(bounds[0].y - this.height / 2)
+            );
+        }
+
+        $.each(response.student_words, function (word, stat) {
+            var percent = (response.display_student_percents) ? ' ' + (Math.round(100 * (stat / response.total_count))) + '%' : '';
+
+            studentWordsKeys.push('<strong>' + word + '</strong>' + percent);
+        });
+        studentWordsStr = '' + studentWordsKeys.join(', ');
+
+        cloudSectionEl
+            .addClass('active')
+            .find('.your_words').html(studentWordsStr)
+            .find('.total_num_words').html(response.total_count);
+
+        $(cloudSectionEl.attr('id') + ' .word_cloud').empty();
+
+        // Actual drawing of word cloud.
+        groupEl = d3.select('#' + cloudSectionEl.attr('id') + ' .word_cloud').append('svg')
+                .attr('width', this.width)
+                .attr('height', this.height)
+                .append('g')
+                .attr('transform', 'translate(' + (0.5 * this.width) + ',' + (0.5 * this.height) + ')')
+                .selectAll('text')
+                .data(words)
+                .enter().append('g');
+
+        groupEl
+            .append('title')
+            .text(function (d) {
+                var res = '';
+
+                $.each(response.top_words, function(index, value){
+                    if (value.text === d.text) {
+                        res = value.percent + '%';
+
+                        return;
+                    }
+                });
+
+                return res;
+            });
+
+        groupEl
+            .append('text')
+            .style('font-size', function (d) {
+                return d.size + 'px';
+            })
+            .style('font-family', 'Impact')
+            .style('fill', function (d, i) {
+                return fill(i);
+            })
+            .attr('text-anchor', 'middle')
+            .attr('transform', function (d) {
+                return 'translate(' + [d.x, d.y] + ')rotate(' + d.rotate + ')scale(' + scale + ')';
+            })
+            .text(function (d) {               
+                return d.text;
+            });
+    }; // End-of: WordCloudMain.prototype.drawWordCloud = function (words, bounds) {
+
+    return WordCloudMain;
+
+}); // End-of: define('WordCloudMain', ['logme'], function (logme) {
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define) {

common/lib/xmodule/xmodule/poll_module.py

@@ -4,8 +4,6 @@ to do set of polls.
 On the client side we show:
 If student does not yet anwered - Question with set of choices.
 If student have answered - Question with statistics for each answers.
-
-Student can't change his answer.
 """
 
 import cgi

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

+---
+metadata:
+    display_name: Word cloud
+    version: 1
+    num_inputs: 5
+    num_top_words: 250
+    display_student_percents: True
+data: {}
+children: []

common/lib/xmodule/xmodule/tests/test_export.py

 import unittest
 
 from fs.osfs import OSFS
-from nose.tools import assert_equals, assert_true
 from path import path
 from tempfile import mkdtemp
 import shutil
@@ -22,7 +21,7 @@ def strip_filenames(descriptor):
     """
     Recursively strips 'filename' from all children's definitions.
     """
-    print "strip filename from {desc}".format(desc=descriptor.location.url())
+    print("strip filename from {desc}".format(desc=descriptor.location.url()))
     descriptor._model_data.pop('filename', None)
 
     if hasattr(descriptor, 'xml_attributes'):
@@ -41,12 +40,12 @@ class RoundTripTestCase(unittest.TestCase):
     '''
     def check_export_roundtrip(self, data_dir, course_dir):
         root_dir = path(self.temp_dir)
-        print "Copying test course to temp dir {0}".format(root_dir)
+        print("Copying test course to temp dir {0}".format(root_dir))
 
         data_dir = path(data_dir)
         shutil.copytree(data_dir / course_dir, root_dir / course_dir)
 
-        print "Starting import"
+        print("Starting import")
         initial_import = XMLModuleStore(root_dir, course_dirs=[course_dir])
 
         courses = initial_import.get_courses()
@@ -55,7 +54,7 @@ class RoundTripTestCase(unittest.TestCase):
 
         # export to the same directory--that way things like the custom_tags/ folder
         # will still be there.
-        print "Starting export"
+        print("Starting export")
         fs = OSFS(root_dir)
         export_fs = fs.makeopendir(course_dir)
 
@@ -63,14 +62,14 @@ class RoundTripTestCase(unittest.TestCase):
         with export_fs.open('course.xml', 'w') as course_xml:
             course_xml.write(xml)
 
-        print "Starting second import"
+        print("Starting second import")
         second_import = XMLModuleStore(root_dir, course_dirs=[course_dir])
 
         courses2 = second_import.get_courses()
         self.assertEquals(len(courses2), 1)
         exported_course = courses2[0]
 
-        print "Checking course equality"
+        print("Checking course equality")
 
         # HACK: filenames change when changing file formats
         # during imports from old-style courses.  Ignore them.
@@ -81,16 +80,18 @@ class RoundTripTestCase(unittest.TestCase):
         self.assertEquals(initial_course.id, exported_course.id)
         course_id = initial_course.id
 
-        print "Checking key equality"
+        print("Checking key equality")
         self.assertEquals(sorted(initial_import.modules[course_id].keys()),
                           sorted(second_import.modules[course_id].keys()))
 
-        print "Checking module equality"
+        print("Checking module equality")
         for location in initial_import.modules[course_id].keys():
-            print "Checking", location
+            print("Checking", location)
             if location.category == 'html':
-                print ("Skipping html modules--they can't import in"
-                       " final form without writing files...")
+                print(
+                    "Skipping html modules--they can't import in"
+                    " final form without writing files..."
+                )
                 continue
             self.assertEquals(initial_import.modules[course_id][location],
                               second_import.modules[course_id][location])
@@ -123,3 +124,6 @@ class RoundTripTestCase(unittest.TestCase):
     def test_exam_registration_roundtrip(self):
         # Test exam_registration xmodule to see if it exports correctly
         self.check_export_roundtrip(DATA_DIR, "test_exam_registration")
+
+    def test_word_cloud_roundtrip(self):
+        self.check_export_roundtrip(DATA_DIR, "word_cloud")

common/lib/xmodule/xmodule/tests/test_import.py

@@ -53,7 +53,7 @@ class BaseCourseTestCase(unittest.TestCase):
 
     def get_course(self, name):
         """Get a test course by directory name.  If there's more than one, error."""
-        print "Importing {0}".format(name)
+        print("Importing {0}".format(name))
 
         modulestore = XMLModuleStore(DATA_DIR, course_dirs=[name])
         courses = modulestore.get_courses()
@@ -145,7 +145,7 @@ class ImportTestCase(BaseCourseTestCase):
         descriptor = system.process_xml(start_xml)
         compute_inherited_metadata(descriptor)
 
-        print descriptor, descriptor._model_data
+        print(descriptor, descriptor._model_data)
         self.assertEqual(descriptor.lms.due, Date().from_json(v))
 
         # Check that the child inherits due correctly
@@ -161,7 +161,7 @@ class ImportTestCase(BaseCourseTestCase):
         exported_xml = descriptor.export_to_xml(resource_fs)
 
         # Check that the exported xml is just a pointer
-        print "Exported xml:", exported_xml
+        print("Exported xml:", exported_xml)
         pointer = etree.fromstring(exported_xml)
         self.assertTrue(is_pointer_tag(pointer))
         # but it's a special case course pointer
@@ -262,22 +262,22 @@ class ImportTestCase(BaseCourseTestCase):
               """]
 
         for xml_str in yes:
-            print "should be True for {0}".format(xml_str)
+            print("should be True for {0}".format(xml_str))
             self.assertTrue(is_pointer_tag(etree.fromstring(xml_str)))
 
         for xml_str in no:
-            print "should be False for {0}".format(xml_str)
+            print("should be False for {0}".format(xml_str))
             self.assertFalse(is_pointer_tag(etree.fromstring(xml_str)))
 
     def test_metadata_inherit(self):
         """Make sure that metadata is inherited properly"""
 
-        print "Starting import"
+        print("Starting import")
         course = self.get_course('toy')
 
         def check_for_key(key, node):
             "recursive check for presence of key"
-            print "Checking {0}".format(node.location.url())
+            print("Checking {0}".format(node.location.url()))
             self.assertTrue(key in node._model_data)
             for c in node.get_children():
                 check_for_key(key, c)
@@ -329,7 +329,7 @@ class ImportTestCase(BaseCourseTestCase):
     def test_colon_in_url_name(self):
         """Ensure that colons in url_names convert to file paths properly"""
 
-        print "Starting import"
+        print("Starting import")
         # Not using get_courses because we need the modulestore object too afterward
         modulestore = XMLModuleStore(DATA_DIR, course_dirs=['toy'])
         courses = modulestore.get_courses()
@@ -337,10 +337,10 @@ class ImportTestCase(BaseCourseTestCase):
         course = courses[0]
         course_id = course.id
 
-        print "course errors:"
+        print("course errors:")
         for (msg, err) in modulestore.get_item_errors(course.location):
-            print msg
-            print err
+            print(msg)
+            print(err)
 
         chapters = course.get_children()
         self.assertEquals(len(chapters), 2)
@@ -348,12 +348,12 @@ class ImportTestCase(BaseCourseTestCase):
         ch2 = chapters[1]
         self.assertEquals(ch2.url_name, "secret:magic")
 
-        print "Ch2 location: ", ch2.location
+        print("Ch2 location: ", ch2.location)
 
         also_ch2 = modulestore.get_instance(course_id, ch2.location)
         self.assertEquals(ch2, also_ch2)
 
-        print "making sure html loaded"
+        print("making sure html loaded")
         cloc = course.location
         loc = Location(cloc.tag, cloc.org, cloc.course, 'html', 'secret:toylab')
         html = modulestore.get_instance(course_id, loc)
@@ -378,11 +378,11 @@ class ImportTestCase(BaseCourseTestCase):
         for i in (2, 3):
             video = sections[i]
             # Name should be 'video_{hash}'
-            print "video {0} url_name: {1}".format(i, video.url_name)
+            print("video {0} url_name: {1}".format(i, video.url_name))
 
             self.assertEqual(len(video.url_name), len('video_') + 12)
 
-    def test_poll_and_conditional_xmodule(self):
+    def test_poll_and_conditional_import(self):
         modulestore = XMLModuleStore(DATA_DIR, course_dirs=['conditional_and_poll'])
 
         course = modulestore.get_courses()[0]
@@ -393,10 +393,31 @@ class ImportTestCase(BaseCourseTestCase):
         self.assertEqual(len(sections), 1)
 
         location = course.location
-        location = Location(location.tag, location.org, location.course,
-            'sequential', 'Problem_Demos')
-        module = modulestore.get_instance(course.id, location)
-        self.assertEqual(len(module.children), 2)
+
+        conditional_location = Location(
+            location.tag, location.org, location.course,
+            'conditional', 'condone'
+        )
+        module = modulestore.get_instance(course.id, conditional_location)
+        self.assertEqual(len(module.children), 1)
+
+        poll_location = Location(
+            location.tag, location.org, location.course,
+            'poll_question', 'first_poll'
+        )
+        module = modulestore.get_instance(course.id, poll_location)
+        self.assertEqual(len(module.get_children()), 0)
+        self.assertEqual(module.voted, False)
+        self.assertEqual(module.poll_answer, '')
+        self.assertEqual(module.poll_answers, {})
+        self.assertEqual(
+            module.answers,
+            [
+                {'text': u'Yes', 'id': 'Yes'},
+                {'text': u'No', 'id': 'No'},
+                {'text': u"Don't know", 'id': 'Dont_know'}
+            ]
+        )
 
     def test_error_on_import(self):
         '''Check that when load_error_module is false, an exception is raised, rather than returning an ErrorModule'''
@@ -406,7 +427,6 @@ class ImportTestCase(BaseCourseTestCase):
 
         self.assertRaises(etree.XMLSyntaxError, system.process_xml, bad_xml)
 
-
     def test_graphicslidertool_import(self):
         '''
         Check to see if definition_from_xml in gst_module.py
@@ -423,6 +443,26 @@ class ImportTestCase(BaseCourseTestCase):
 <plot style="margin-top:15px;margin-bottom:15px;"/>""".strip()
         self.assertEqual(gst_sample.render, render_string_from_sample_gst_xml)
 
+    def test_word_cloud_import(self):
+        modulestore = XMLModuleStore(DATA_DIR, course_dirs=['word_cloud'])
+
+        course = modulestore.get_courses()[0]
+        chapters = course.get_children()
+        ch1 = chapters[0]
+        sections = ch1.get_children()
+
+        self.assertEqual(len(sections), 1)
+
+        location = course.location
+        location = Location(
+            location.tag, location.org, location.course,
+            'word_cloud', 'cloud1'
+        )
+        module = modulestore.get_instance(course.id, location)
+        self.assertEqual(len(module.get_children()), 0)
+        self.assertEqual(module.num_inputs, '5')
+        self.assertEqual(module.num_top_words, '250')
+
     def test_cohort_config(self):
         """
         Check that cohort config parsing works right.

common/lib/xmodule/xmodule/tests/test_logic.py

 # -*- coding: utf-8 -*-
+"""Test for Xmodule functional logic."""
 
 import json
 import unittest
 
 from xmodule.poll_module import PollDescriptor
 from xmodule.conditional_module import ConditionalDescriptor
+from xmodule.word_cloud_module import WordCloudDescriptor
+
+
+class PostData:
+    """Class which emulate postdata."""
+    def __init__(self, dict_data):
+        self.dict_data = dict_data
+
+    def getlist(self, key):
+        return self.dict_data.get(key)
 
 
 class LogicTest(unittest.TestCase):
@@ -13,15 +24,18 @@ class LogicTest(unittest.TestCase):
     raw_model_data = {}
 
     def setUp(self):
-        class EmptyClass: pass
+        class EmptyClass:
+            pass
 
         self.system = None
         self.location = None
         self.descriptor = EmptyClass()
 
         self.xmodule_class = self.descriptor_class.module_class
-        self.xmodule = self.xmodule_class(self.system, self.location,
-            self.descriptor, self.raw_model_data)
+        self.xmodule = self.xmodule_class(
+            self.system, self.location,
+            self.descriptor, self.raw_model_data
+        )
 
     def ajax_request(self, dispatch, get):
         return json.loads(self.xmodule.handle_ajax(dispatch, get))
@@ -64,3 +78,42 @@ class ConditionalModuleTest(LogicTest):
         html = response['html']
 
         self.assertEqual(html, [])
+
+
+class WordCloudModuleTest(LogicTest):
+    descriptor_class = WordCloudDescriptor
+    raw_model_data = {
+        'all_words': {'cat': 10, 'dog': 5, 'mom': 1, 'dad': 2},
+        'top_words': {'cat': 10, 'dog': 5, 'dad': 2},
+        'submitted': False
+    }
+
+    def test_bad_ajax_request(self):
+
+        # TODO: move top global test. Formalize all our Xmodule errors.
+        response = self.ajax_request('bad_dispatch', {})
+        self.assertDictEqual(response, {
+            'status': 'fail',
+            'error': 'Unknown Command!'
+        })
+
+    def test_good_ajax_request(self):
+        post_data = PostData({'student_words[]': ['cat', 'cat', 'dog', 'sun']})
+        response = self.ajax_request('submit', post_data)
+        self.assertEqual(response['status'], 'success')
+        self.assertEqual(response['submitted'], True)
+        self.assertEqual(response['total_count'], 22)
+        self.assertDictEqual(
+            response['student_words'],
+            {'sun': 1, 'dog': 6, 'cat': 12}
+        )
+        self.assertListEqual(
+            response['top_words'],
+            [{'text': 'dad', 'size': 2, 'percent': 9.0},
+             {'text': 'sun', 'size': 1, 'percent': 5.0},
+             {'text': 'dog', 'size': 6, 'percent': 27.0},
+             {'text': 'mom', 'size': 1, 'percent': 5.0},
+             {'text': 'cat', 'size': 12, 'percent': 54.0}]
+        )
+
+        self.assertEqual(100.0, sum(i['percent'] for i in response['top_words']) )

common/lib/xmodule/xmodule/word_cloud_module.py

+"""Word cloud is ungraded xblock used by students to
+generate and view word cloud.
+
+On the client side we show:
+If student does not yet anwered - `num_inputs` numbers of text inputs.
+If student have answered - words he entered and cloud.
+"""
+
+import json
+import logging
+
+from pkg_resources import resource_string
+from xmodule.raw_module import RawDescriptor
+from xmodule.x_module import XModule
+
+from xblock.core import Scope, String, Object, Boolean, List, Integer
+
+log = logging.getLogger(__name__)
+
+
+def pretty_bool(value):
+    BOOL_DICT = [True, "True", "true", "T", "t", "1"]
+    return value in BOOL_DICT
+
+
+class WordCloudFields(object):
+    """XFields for word cloud."""
+    display_name = String(
+        help="Display name for this module",
+        scope=Scope.settings
+    )
+    num_inputs = Integer(
+        help="Number of inputs.",
+        scope=Scope.settings,
+        default=5
+    )
+    num_top_words = Integer(
+        help="Number of max words, which will be displayed.",
+        scope=Scope.settings,
+        default=250
+    )
+    display_student_percents = Boolean(
+        help="Display usage percents for each word?",
+        scope=Scope.settings,
+        default=True
+    )
+
+    # Fields for descriptor.
+    submitted = Boolean(
+        help="Whether this student has posted words to the cloud.",
+        scope=Scope.user_state,
+        default=False
+    )
+    student_words = List(
+        help="Student answer.",
+        scope=Scope.user_state,
+        default=[]
+    )
+    all_words = Object(
+        help="All possible words from all students.",
+        scope=Scope.content
+    )
+    top_words = Object(
+        help="Top num_top_words words for word cloud.",
+        scope=Scope.content
+    )
+
+
+class WordCloudModule(WordCloudFields, XModule):
+    """WordCloud Xmodule"""
+    js = {
+        'coffee': [resource_string(__name__, 'js/src/javascript_loader.coffee')],
+        'js': [resource_string(__name__, 'js/src/word_cloud/logme.js'),
+        resource_string(__name__, 'js/src/word_cloud/d3.min.js'),
+        resource_string(__name__, 'js/src/word_cloud/d3.layout.cloud.js'),
+        resource_string(__name__, 'js/src/word_cloud/word_cloud.js'),
+        resource_string(__name__, 'js/src/word_cloud/word_cloud_main.js')]
+    }
+    css = {'scss': [resource_string(__name__, 'css/word_cloud/display.scss')]}
+    js_module_name = "WordCloud"
+
+    def get_state(self):
+        """Return success json answer for client."""
+        if self.submitted:
+            total_count = sum(self.all_words.itervalues())
+            return json.dumps({
+                'status': 'success',
+                'submitted': True,
+                'display_student_percents': pretty_bool(
+                    self.display_student_percents
+                ),
+                'student_words': {
+                    word: self.all_words[word] for word in self.student_words
+                },
+                'total_count': total_count,
+                'top_words': self.prepare_words(self.top_words, total_count)
+            })
+        else:
+            return json.dumps({
+                'status': 'success',
+                'submitted': False,
+                'display_student_percents': False,
+                'student_words': {},
+                'total_count': 0,
+                'top_words': {}
+            })
+
+    def good_word(self, word):
+        """Convert raw word to suitable word."""
+        return word.strip().lower()
+
+    def prepare_words(self, top_words, total_count):
+        """Convert words dictionary for client API.
+
+        :param top_words: Top words dictionary
+        :type top_words: dict
+        :param total_count: Total number of words
+        :type total_count: int
+
+        :rtype: list of dicts. Every dict is 3 keys: text - actual word,
+        size - counter of word, percent - percent in top_words dataset.
+
+        Calculates corrected percents for every top word:
+
+        For every word except last, it calculates rounded percent.
+        For the last is 100 - sum of all other percents.
+
+        """
+        list_to_return = []
+        percents = 0
+        for num, word_tuple in enumerate(top_words.iteritems()):
+            if num == len(top_words) - 1:
+                percent = 100 - percents
+            else:
+                percent = round(100.0 * word_tuple[1] / total_count)
+                percents += percent
+            list_to_return.append(
+                {
+                    'text': word_tuple[0],
+                    'size': word_tuple[1],
+                    'percent': percent
+                }
+            )
+        return list_to_return
+
+    def top_dict(self, dict_obj, amount):
+        """Return top words from all words, filtered by number of
+        occurences
+
+        :param dict_obj: all words
+        :type dict_obj: dict
+        :param amount: number of words to be in top dict
+        :type amount: int
+        :rtype: dict
+        """
+        return dict(
+            sorted(
+                dict_obj.items(),
+                key=lambda x: x[1],
+                reverse=True
+            )[:amount]
+        )
+
+    def handle_ajax(self, dispatch, post):
+        """Ajax handler.
+
+        Args:
+            dispatch: string request slug
+            post: dict request get parameters
+
+        Returns:
+            json string
+        """
+        if dispatch == 'submit':
+            if self.submitted:
+                return json.dumps({
+                    'status': 'fail',
+                    'error': 'You have already posted your data.'
+                })
+
+            # Student words from client.
+            # FIXME: we must use raw JSON, not a post data (multipart/form-data)
+            raw_student_words = post.getlist('student_words[]')
+            student_words = filter(None, map(self.good_word, raw_student_words))
+
+            self.student_words = student_words
+
+            # FIXME: fix this, when xblock will support mutable types.
+            # Now we use this hack.
+            # speed issues
+            temp_all_words = self.all_words
+
+            self.submitted = True
+
+            # Save in all_words.
+            for word in self.student_words:
+                temp_all_words[word] = temp_all_words.get(word, 0) + 1
+
+            # Update top_words.
+            self.top_words = self.top_dict(
+                temp_all_words,
+                int(self.num_top_words)
+            )
+
+            # Save all_words in database.
+            self.all_words = temp_all_words
+
+            return self.get_state()
+        elif dispatch == 'get_state':
+            return self.get_state()
+        else:
+            return json.dumps({
+                'status': 'fail',
+                'error': 'Unknown Command!'
+            })
+
+    def get_html(self):
+        """Template rendering."""
+        context = {
+            'element_id': self.location.html_id(),
+            'element_class': self.location.category,
+            'ajax_url': self.system.ajax_url,
+            'num_inputs': int(self.num_inputs),
+            'submitted': self.submitted
+        }
+        self.content = self.system.render_template('word_cloud.html', context)
+        return self.content
+
+
+class WordCloudDescriptor(WordCloudFields, RawDescriptor):
+    """Descriptor for WordCloud Xmodule."""
+    module_class = WordCloudModule
+    template_dir_name = 'word_cloud'
+    stores_state = True
+    mako_template = "widgets/raw-edit.html"

common/test/data/word_cloud/README

+Any place that says "YEAR_SEMESTER" needs to be replaced with something 
+in the form "2013_Spring". Take note of this name exactly, you'll need to 
+use it everywhere, precisely - capitalization is very important.
+
+See https://github.com/MITx/mitx/blob/master/doc/xml-format.md for more on all this.
+-----------------------
+
+about/: Files that live here will be visible OUTSIDE OF COURSEWARE.
+   YEAR_SEMESTER/
+        end_date.html: Specifies in plain-text the end date of the course
+	overview.html: Text of the overview of the course
+	short_description.html: 10-15 words about the course
+	prerequisites.html: Any prerequisites for the course, or None if there are none.
+
+course/
+    YEAR_SEMESTER.xml: This is your top-level xml page that points at chapters. 
+    		       Can just be <course/> for now.
+
+course.xml: This top level file points at a file in roots/. See creating_course.xml.
+
+creating_course.xml: Explains how to create course.xml
+
+info/: Files that live here will be visible on the COURSE LANDING PAGE 
+       (Course Info) WITHIN THE COURSEWARE.
+    YEAR_SEMESTER/
+        handouts.html: A list of handouts, or an empty file if there are none 
+		       (if this file doesn't exist, it displays an error)
+	updates.html: Course updates.
+
+policies/ 
+    YEAR_SEMESTER/
+        policy.json: See https://github.com/MITx/mitx/blob/master/doc/xml-format.md 
+		     for more on the fields specified by this file.
+	grading_policy.json: Optional -- you don't need it to get a course off the 
+			     ground but will eventually. For more info see 
+			     https://github.com/MITx/mitx/blob/master/doc/course_grading.md
+
+roots/
+    YEAR_SEMESTER.xml: Looks something like 
+    		       <course url_name="YEAR_SEMESTER" org="ORG"  course="COURSENUM"/> 
+		       where ORG in {"MITx", "HarvardX", "BerkeleyX"}
+
+static/
+	See README.
+
+	images/
+		course_image.jpg: You MUST have an image named this to be the background
+				  banner image on edx.org
+
+-----------------------
\ No newline at end of file

common/test/data/word_cloud/README.md

+content-harvard-justicex
+========================
\ No newline at end of file

common/test/data/word_cloud/about/2013_Spring/overview.html

+
+
+<section class="about">
+    <h2>About ER22x</h2>
+    
+    <p>Justice is a critical analysis of classical and contemporary theories of justice, including discussion of present-day applications. Topics include affirmative action, income distribution, same-sex marriage, the role of markets, debates about rights (human rights and property rights), arguments for and against equality, dilemmas of loyalty in public and private life. The course invites students to subject their own views on these controversies to critical examination.</p>
+
+<p>The principle readings for the course are texts by Aristotle, John Locke, Immanuel Kant, John Stuart Mill, and John Rawls. Other assigned readings include writings by contemporary philosophers, court cases, and articles about political controversies that raise philosophical questions.</p>
+
+<!-- 
+<p>The assigned readings will be freely available online. They are also collected in an edited volume, <emph>Justice: A Reader</emph> (ed. Michael Sandel, Oxford University Press). Students who would like further guidance on the themes of the lectures can read Michael Sandel, <emph>Justice: What’s the Right Thing to Do?</emph>  (Recommended but not required.)
+</p>
+ -->
+
+</section>
+
+
+<section class="course-staff">
+    <h2>Course instructor</h3>
+    <article class="teacher">
+        <!-- TODO: Need to change image location -->
+        <!-- First Professor -->
+        <div class="teacher-image"><img src="/static/images/professor-sandel.jpg"/></div>
+        <h3>Michael J. Sandel</h3> 
+        <p>Michael J. Sandel is the Anne T. and Robert M. Bass Professor of Government at Harvard University, where he teaches political philosophy.  His course "Justice" has enrolled more than 15,000 Harvard students.  Sandel's writings have been published in 21 languages.  His books include <i>What Money Can't Buy: The Moral Limits of Markets</i> (2012); <i>Justice: What's the Right Thing to Do?</i> (2009); <i>The Case against Perfection: Ethics in the Age of Genetic Engineering</i> (2007); <i>Public Philosophy: Essays on Morality in Politics</i> (2005); <i>Democracy's Discontent</i> (1996); and <i>Liberalism and the Limits of Justice</i>(1982; 2nd ed., 1998). </p>
+<p><br></p>
+</section>
+        
+        
+<section class="faq">
+  <section class="responses">
+    <h2>Frequently Asked Questions</h2>
+    <article class="response">
+      <h3>How much does it cost to take the course?</h3>
+<p>Nothing! The course is free.</p>
+    </article>
+
+    <article class="response">
+      <h3>Does the course have any prerequisites?</h3>
+<p>No.  Only an interest in thinking through some of the big ethical and civic questions we face in our everyday lives.</p>
+    </article>
+    
+    <article class="response">
+    <h3>Do I need any other materials to take the course?</h3>
+    <p>No. As long as you’ve got a computer to access the website, you are ready to take the course.</p>
+    </article>
+
+    <article class="response">
+    <h3>Is there a textbook for the course?</h3>
+    <p>All of the course readings that are in the public domain are freely available online, at links provided on the course website. The course can be taken using these free resources alone.  For those who wish to purchase a printed version of the assigned readings, an edited volume entitled, Justice: A Reader (ed., Michael Sandel) is available in paperback from Oxford University Press (in bookstores and from online booksellers).  Those who would like supplementary readings on the themes of the lectures can find them in Michael Sandel's book Justice: What's the Right Thing to Do?, which is available in various languages throughout the world. This book is not required, and the course can be taken using the free online resources alone.</p>
+    </article>
+  
+    <article class="response">
+    <h3>Do I need to watch the lectures at a specific time?</h3>
+    <p>No. You can watch the lectures at your leisure.</p>
+    </article>
+
+    <article class="response">
+    <h3>Will I be able to participate in class discussions?</h3>
+    <p>Yes, in several ways: </p>
+    
+    <ol>
+<li><p> Each lecture invites you to respond to a poll question related to the themes of the lecture.  If you respond to the question, you will be presented with a challenge to the opinion you have expressed, and invited to reply to the challenge.  You can also, if you wish, comment on the opinions and responses posted by other students in the course, continuing the discussion.</p></li>
+
+<li><p> In addition to the poll question, each class contains a discussion prompt that invites you to offer your view on a controversial question related to the lecture.  If you wish, you can respond to this question, and then see what other students have to say about the argument you present.  You can also comment on the opinions posted by other students.  One aim of the course is to promote reasoned public dialogue about hard moral and political questions.  </p></li>
+
+<li><p> Each week, there will be an optional live dialogue enabling students to interact with instructors and participants from around the world.</p></li>
+</ol>
+    </article>
+    
+    <article class="response">
+    <h3>Will certificates be awarded?</h3>
+    <p>Yes. Online learners who achieve a passing grade in a course can earn a certificate of mastery. These certificates will indicate you have successfully completed the course, but will not include a specific grade. Certificates will be issued by edX under the name of HarvardX, designating the institution from which the course originated. </p>
+    </article>    
+
+  </section>
+</section>
+        
+   
\ No newline at end of file

common/test/data/word_cloud/about/2013_Spring/prerequisites.html

+None

common/test/data/word_cloud/about/2013_Spring/short_description.html

+JusticeX is an introduction to moral and political philosophy, including discussion of contemporary dilemmas and controversies.
\ No newline at end of file

common/test/data/word_cloud/about/2013_Spring/video.html

+<iframe width="560" height="315" src="http://www.youtube.com/embed/fajlZMdPkKE#!" frameborder="0" allowfullscreen></iframe>
\ No newline at end of file

common/test/data/word_cloud/chapter/Staff.xml

+<chapter>
+    <sequential url_name="Problem_Demos"/>
+</chapter>

common/test/data/word_cloud/course.xml

+<course url_name="2013_Spring" org="HarvardX" course="ER22x"/>
+

common/test/data/word_cloud/course/2013_Spring.xml

+<!-- Name this file eg "2012_Fall.xml" or "2013_Spring.xml" 
+     Take note of this name exactly, you'll need to use it everywhere. -->
+<course>
+  <chapter url_name="Staff"/>
+</course>
+

common/test/data/word_cloud/creating_course.xml

+<!-- A file named "course.xml" in your top-level should point 
+at the appropriate roots file. You can do so like this:
+
+$ rm course.xml
+$ ln -s roots/YEAR_SEMESTER.xml course.xml
+
+
+Ask Sarina for help with this. -->

common/test/data/word_cloud/info/2013_Spring/handouts.html

+<ol>
+  <li>A list of course handouts, or an empty file if there are none.</li>
+</ol>

common/test/data/word_cloud/info/2013_Spring/updates.html

+<!-- If you wish to make a welcome announcement -->
+<ol>
+
+  <li><h2>December 9</h2>
+    <section class="update-description">
+      <p>Announcement text</p>
+    </section>
+  </li>
+
+</ol>

common/test/data/word_cloud/policies/2013_Spring/policy.json

+{
+    "course/2013_Spring": {
+        "start": "2099-01-01T00:00",
+	    "advertised_start" : "Spring 2013", 
+        "display_name": "Justice"
+    }
+
+}

common/test/data/word_cloud/roots/2013_Spring.xml

+<course url_name="2013_Spring" org="HarvardX" course="ER22x"/>
+

common/test/data/word_cloud/sequential/Problem_Demos.xml

+<sequential>
+    <vertical name="test_vertical">
+        <word_cloud name="cloud1" display_name="cloud" num_inputs="5" num_top_words="250" />
+    </vertical>
+</sequential>

common/test/data/word_cloud/static/README

+Images, handouts, and other statically-served content should go ONLY
+in this directory.
+
+Images for the front page should go in static/images. The frontpage
+banner MUST be named course_image.jpg
\ No newline at end of file

doc/public/course_data_formats/word_cloud/word_cloud.rst

+**********************************************
+Xml format of "Word Cloud" module [xmodule]
+**********************************************
+
+.. module:: word_cloud
+
+Format description
+==================
+
+The main tag of Word Cloud module input is:
+
+.. code-block:: xml
+
+    <word_cloud />
+
+The following attributes can be specified for this tag::
+
+    [display_name| AUTOGENERATE] – Display name of xmodule. When this attribute is not defined - display name autogenerate with some hash.
+    [num_inputs| 5] – Number of inputs.
+    [num_top_words| 250] – Number of max words, which will be displayed.
+    [display_student_percents| True] – Display usage percents for each word.
+
+.. note::
+
+   If you want to use the same word cloud (the same storage of words), you must use the same display_name value.
+
+Code Example
+============
+
+Examples of word_cloud without all attributes (all attributes get by default)
+-----------------------------------------------------------------------------
+
+.. code-block:: xml
+
+    <word_cloud />
+
+Examples of poll with all attributes
+------------------------------------
+
+.. code-block:: xml
+
+    <word_cloud display_name="cloud" num_inputs="10" num_top_words="100" />
+
+Screenshots
+===========
+
+.. image:: word_cloud.png
+    :width: 50%

doc/public/index.rst

@@ -26,6 +26,7 @@ Specific Problem Types
    course_data_formats/graphical_slider_tool/graphical_slider_tool.rst
    course_data_formats/poll_module/poll_module.rst
    course_data_formats/conditional_module/conditional_module.rst
+   course_data_formats/word_cloud/word_cloud.rst
    course_data_formats/custom_response.rst
 
 

docs/source/xmodule.rst

@@ -165,6 +165,13 @@ Video
     :members:
     :show-inheritance:
 
+Word Cloud
+==========
+
+.. automodule:: xmodule.word_cloud_module
+    :members:
+    :show-inheritance:
+
 X
 =
 

lms/templates/word_cloud.html

+<section
+    id="word_cloud_${element_id}"
+    class="${element_class}"
+    data-ajax-url="${ajax_url}"
+>
+
+    <section class="input_cloud_section">
+        % for row in range(num_inputs):
+            <input
+                class="input-cloud"
+                ${'style="display: none;"' if submitted else ''}
+                type="text"
+                size="40"
+            />
+        % endfor
+
+        <section class="action">
+            <input class="save" type="button" value="Save" />
+        </section>
+    </section>
+
+    <section id="result_cloud_section_${element_id}" class="result_cloud_section">
+        <h3>Your words: <span class="your_words"></span></h3>
+        <h3>Total number of words: <span class="total_num_words"></span></h3>
+        <div class="word_cloud"></div>
+    </section>
+
+</section>