publish_my_data 0.0.32 → 1.0.0

data/app/assets/javascripts/bootstrap/transition.js

@@ -0,0 +1,56 @@
+/* ========================================================================
+ * Bootstrap: transition.js v3.0.0
+ * http://twbs.github.com/bootstrap/javascript.html#transitions
+ * ========================================================================
+ * Copyright 2013 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================================== */
+
+
++function ($) { "use strict";
+
+  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
+  // ============================================================
+
+  function transitionEnd() {
+    var el = document.createElement('bootstrap')
+
+    var transEndEventNames = {
+      'WebkitTransition' : 'webkitTransitionEnd'
+    , 'MozTransition'    : 'transitionend'
+    , 'OTransition'      : 'oTransitionEnd otransitionend'
+    , 'transition'       : 'transitionend'
+    }
+
+    for (var name in transEndEventNames) {
+      if (el.style[name] !== undefined) {
+        return { end: transEndEventNames[name] }
+      }
+    }
+  }
+
+  // http://blog.alexmaccaw.com/css-transitions
+  $.fn.emulateTransitionEnd = function (duration) {
+    var called = false, $el = this
+    $(this).one($.support.transition.end, function () { called = true })
+    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
+    setTimeout(callback, duration)
+    return this
+  }
+
+  $(function () {
+    $.support.transition = transitionEnd()
+  })
+
+}(window.jQuery);

data/app/assets/javascripts/publish_my_data/grid/10_data-loader.js

@@ -0,0 +1,142 @@
+(function ($) {
+
+  function DataLoader(totalCount, pageSize) {
+
+    var self = this;
+    var pageSize = pageSize;
+    var data = {length: 0}; // the data rows, which we'll fill in, plus an extra property for total length
+    var pagesToLoad = {};
+    var loadingPages = 0; // number of pages currently being loaded by loader.
+
+    // events
+    //////////////////
+
+    var onDataLoading = new Slick.Event();
+    var onDataLoaded = new Slick.Event();
+    var onPageLoading = new Slick.Event();
+    var onPageLoaded = new Slick.Event();
+    var onReady = new Slick.Event();
+    var onBusy = new Slick.Event();
+
+    // some setup
+
+    // subscribe to some grid and loader events.
+    onPageLoading.subscribe(function (e, args) {
+      if (loadingPages == 0) {
+        onBusy.notify();
+      }
+      loadingPages ++;
+    });
+
+    onPageLoaded.subscribe(function (e, args) {
+      loadingPages --;
+      if(loadingPages == 0) {
+        onReady.notify();
+      }
+    });
+
+
+    // private funcs
+    //////////////////
+    function updateTotalCount(newTotalCount) {
+      totalCount = newTotalCount;
+    }
+
+    function getData() {
+      return data;
+    }
+
+    function clear() {
+      for (var key in data) {
+        delete data[key];
+      }
+      data.length = totalCount;
+      pagesToLoad = {};
+    }
+
+    // From and to are 0-based row indices.
+    // LoaderFunction should be a function that takes a zero-based page index, and call setPageOfData with the data.
+    // Raises onDataLoading event, and onPageLoading events.
+    // Works out what pages it needs to load, then calls the loaderFunction provided for each one.
+    function ensureData(from, to, loaderFunction){
+
+      data.length = totalCount;
+
+      if (from < 0) {
+        from = 0;
+      }
+      if (to > data.length-1) {
+        to = data.length -1;
+      }
+
+      // tell the world we're trying to load.
+      onDataLoading.notify({from: from, to: to});
+
+      var fromPage = Math.floor(from / pageSize);
+      var toPage = Math.floor(to / pageSize);
+
+      for (var page = fromPage; page <= toPage; page++ ){
+        if (pagesToLoad[page] == undefined) {
+          pagesToLoad[page] = null;
+        }
+      }
+
+      // do a bunch of queries to get the data for the range.
+      for (var page = fromPage; page <= toPage; page++ ){
+        if (pagesToLoad[page] == null) {
+          onPageLoading.notify({page: page});
+          loaderFunction.call(self, page);
+        }
+      }
+    }
+
+    // given a page index, and an array of row data, set the data for the page.
+    // Raises onPageLoaded and onDataLoaded events.
+    function setPageOfData(page, rows) {
+
+      pagesToLoad[page] = true; // set the page as loaded.
+      var noOfRows = rows.length;
+      var thisPageFrom = page * pageSize;
+      var thisPageTo = thisPageFrom + noOfRows -1;
+
+      // fill the results in in data.
+      for (var i = 0; i < noOfRows; i++) {
+
+        // assign the row of results;
+        data[thisPageFrom + i] = rows[i];
+
+        // set row num (1-based)
+        var rowNum = thisPageFrom + i + 1;
+        data[thisPageFrom + i]["__row_num"] = rowNum;
+      }
+
+      onPageLoaded.notify({page: page});
+      onDataLoaded.notify({from: thisPageFrom, to: thisPageTo});
+    }
+
+    // public api.
+    //////////////////
+
+    return {
+
+      "data": data
+
+      // methods
+    , "updateTotalCount": updateTotalCount
+    , "clear": clear
+    , "ensureData": ensureData
+    , "setPageOfData": setPageOfData
+
+      // events
+    , "onDataLoading": onDataLoading
+    , "onDataLoaded": onDataLoaded
+    , "onPageLoading": onPageLoading
+    , "onPageLoaded": onPageLoaded
+    , "onReady": onReady
+    , "onBusy": onBusy
+    };
+  }
+
+  // Swirrl.DataLoader
+  $.extend(true, window, { Swirrl: { DataLoader: DataLoader }});
+})(jQuery);

data/app/assets/javascripts/publish_my_data/grid/20_cube-grid.js

@@ -0,0 +1,512 @@
+(function ($) {
+
+  // add key counting to old browsers.
+  // https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys
+  if (!Object.keys) {
+    Object.keys = (function () {
+      var hasOwnProperty = Object.prototype.hasOwnProperty,
+          hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
+          dontEnums = [
+            'toString',
+            'toLocaleString',
+            'valueOf',
+            'hasOwnProperty',
+            'isPrototypeOf',
+            'propertyIsEnumerable',
+            'constructor'
+          ],
+          dontEnumsLength = dontEnums.length;
+
+      return function (obj) {
+        if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');
+
+        var result = [];
+
+        for (var prop in obj) {
+          if (hasOwnProperty.call(obj, prop)) result.push(prop);
+        }
+
+        if (hasDontEnumBug) {
+          for (var i=0; i < dontEnumsLength; i++) {
+            if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
+          }
+        }
+        return result;
+      }
+    })()
+  };
+
+  // constructor
+  function CubeGrid(elementSelector, siteDomain, datasetSlug, pageSize) {
+
+    // some constants.
+    //////////////////
+
+    var SLICKGRIDOPTIONS = {
+          enableCellNavigation: false
+        , enableColumnReorder: false
+        , syncColumnCellResize: true
+        , rowHeight: 24
+        }
+
+      , ROWNUMBERSCOLUMNWIDTH = 60
+      , FIRSTCOLUMNWIDTH = 280
+      , COLUMNWIDTH = 200
+      ;
+
+    // object-level vars.
+    //////////////////
+
+    var loader = null
+      , slickGrid = null
+      , urlBase = "http://" +  siteDomain + "/data/" + datasetSlug + "/cube"
+      , cubeDimensions = null // an array of cubeDimension objects.
+      , rowsDimension = null
+      , lockedDimensions = {}
+      , columnsDimension = null
+      , gridSize = null
+      , gridColumns = null
+      , orderByColumn = null // order by rows by default
+      , orderDesc = false // order asc by default
+      ;
+
+    // events
+    //////////////////
+
+    var onCubeDimensionsReady = new Slick.Event()
+      , onGridSizeReady = new Slick.Event()
+      , onGridColumnsReady = new Slick.Event()
+      , onGridGettingData = new Slick.Event()
+      , onGridReady = new Slick.Event()
+      , onGridInitialized = new Slick.Event()
+      , onAjaxError = new Slick.Event()
+      ;
+
+    // some setup.
+    ///////////////
+
+    // we will construct the slick grid once we have enough information.
+
+    function initGridWhenReady() {
+
+      function readyHandler(e, args) {
+        if (gridPrerequisitesReady()) {
+          initGrid();
+
+          // only do this once.
+          onGridSizeReady.unsubscribe(readyHandler);
+          onGridColumnsReady.unsubscribe(readyHandler);
+        }
+      }
+
+      onGridSizeReady.subscribe(readyHandler);
+      onGridColumnsReady.subscribe(readyHandler);
+    }
+
+    initGridWhenReady();
+
+    // private funcs
+    //////////////////
+
+    function checkLockedDimensions() {
+
+      if(cubeDimensions) {
+        // there should be exactly 2 less locked dimensions than dimensions
+        return !!((cubeDimensions.length -2) == Object.keys(lockedDimensions).length);
+      } else {
+        alert('no dimensions exist');
+        return false;
+      }
+    }
+
+    function gridPrerequisitesReady(){
+      var ready = !!(gridSize && gridColumns && checkLockedDimensions());
+      return ready;
+    }
+
+    function clear() {
+      // clear out the display
+      $(elementSelector).empty();
+
+      // reset some stuff dimensions.
+      rowsDimension = null
+      lockedDimensions = {}
+      columnsDimension = null
+      gridSize = null
+      gridColumns = null
+      orderByColumn = null // order by rows by default
+      orderDesc = false // order asc by default
+    }
+
+    function initGrid() {
+      // when we've got grid size, columns, and the lockedDimensions we can construct the grid
+      if(!checkLockedDimensions()) {
+        alert('missing locked dimensions');
+        return;
+      }
+
+      // construct the grid with a loader.
+      loader = new Swirrl.DataLoader(gridSize, pageSize);
+      slickGrid = new Slick.Grid(elementSelector, loader.data, gridColumns, SLICKGRIDOPTIONS);
+      slickGrid.setSortColumn(rowsDimension.uri, true); // start it off being sorted by row dimension, asc
+
+      // now subscribe to some events:
+      ////////////////////////////////
+
+      // high level busy and ready events:
+      loader.onReady.subscribe(function() {
+        onGridReady.notify();
+      });
+
+      loader.onBusy.subscribe(function() {
+        onGridGettingData.notify();
+      });
+
+      // when a bunch of rows are loaded,
+      // re-render them.
+      loader.onDataLoaded.subscribe(function (e, args) {
+        for (var i = args.from; i <= args.to; i++) {
+          slickGrid.invalidateRow(i); // causes the appropriate rows to redraw.
+        }
+        slickGrid.updateRowCount(); // uses data.length
+        slickGrid.render();
+      });
+
+      // When the viewport changes, ensure the loader has the relevent data.
+      // (when scrolling stops for 200ms)
+      var viewportChangedTimer;
+      slickGrid.onViewportChanged.subscribe(function (e, args) {
+        clearTimeout(viewportChangedTimer);
+
+        viewportChangedTimer = setTimeout( function() {
+          loader.ensureData(slickGrid.getViewport().top, slickGrid.getViewport().bottom, dataLoaderFunction);
+         }, 200); // 200ms delay.
+      });
+
+      // Sorting behaviour:
+      slickGrid.onSort.subscribe(function (e, args) {
+
+        // hack to avoid sorting when clicking on links in col headers
+        // (by setting sort back to what it was before click).
+        if ($(e.target).hasClass('cell-link')) {
+          if(orderByColumn == null) {
+            slickGrid.setSortColumn(rowsDimension.uri, (!orderDesc));
+          } else {
+            slickGrid.setSortColumn(orderByColumn, (!orderDesc));
+          }
+          return false;  // and do nothing else
+        }
+
+        // work out the column and order to sort by
+        if (args.sortCol.field == rowsDimension.uri) {
+          orderByColumn = null;
+        } else {
+          orderByColumn = args.sortCol.field;
+        }
+        orderDesc = args.sortAsc ? false : true;
+
+        // tell the loader to re-get the data.
+        loader.clear();
+        slickGrid.setData(loader.data, true);
+        loader.ensureData(slickGrid.getViewport().top, slickGrid.getViewport().bottom, dataLoaderFunction);
+        showCSVDownloadLink();
+      });
+
+      // finally, ensure the loader has the right data,
+      // to initialise the first 'page' of results
+      //////////////////
+      loader.ensureData(slickGrid.getViewport().top, slickGrid.getViewport().bottom, dataLoaderFunction);
+
+      // and set that we're initialized
+      onGridInitialized.notify();
+    }
+
+    // the function that the loader uses to get the data
+    function dataLoaderFunction(page) {
+
+      function processResponseData(responseData) {
+        var start = new Date();
+
+        var processedData = [];
+
+        for( var i=0; i < responseData.length; i++ ) {
+          var row = responseData[i];
+
+          var processedRow = {};
+
+          for (var key in row) {
+            // for all keys except the row values or row labels...
+            if (!(key == rowsDimension.uri || key == "rowlabel" ) ){
+              var obsUri = row[key]["obs"];
+              var obsVal = row[key]["val"];
+              processedRow[key] = buildUriLink(obsUri, (obsVal || "").toString());
+            }
+          }
+
+          // set the value of the row-dimension column
+          var rowUri = row[rowsDimension.uri];
+          var rowLabel = row["rowlabel"];
+          processedRow[rowsDimension.uri] = buildUriLink(rowUri, (rowLabel || rowUri));
+
+          processedData.push(processedRow);
+        }
+        return processedData;
+      }
+
+      var url = buildObservationsUrl('json', page);
+
+      var req = $.ajax({
+        dataType: 'json',
+        url: url,
+        success: function(responseData, _, jqXHR) {
+          loader.setPageOfData(jqXHR.page, processResponseData(responseData));
+        },
+        error: function( jqXHR, _, _ ) {
+          onAjaxError.notify({status: jqXHR.status});
+        }
+      });
+
+      req.page = page; // add a page property onto the jqXHR obj
+
+    }
+
+
+    function buildUriLink(uri, text) {
+      var url = uri;
+
+      // if string doesn't start with this domain, use the resource= style
+      if(url.indexOf('http://' + siteDomain) != 0) {
+        url = 'http://' + siteDomain + '/resource?uri=' + encodeURIComponent(uri);
+      }
+      return "<a class='cell-link' target='_blank' href='" + url + "'>" + text + "</a>";
+    }
+
+    function getCubeDimensions() {
+      return cubeDimensions;
+    }
+
+    function getDimensionWithUri(uri) {
+      var dim = null;
+      $.each(cubeDimensions, function(i, d) {
+        if (d.uri == uri) {
+          dim = d;
+          return false;
+        }
+      });
+      return dim;
+    }
+
+    // memoized lookup of all cube dimensions.
+    function getAllDimensionsAsync(){
+
+      if (!cubeDimensions) {
+        cubeDimensions = []; //this is the object-level var.
+        $.ajax({
+          dataType: 'json',
+          url: urlBase + "/dimensions.json",
+          success: function(responseData, textStatus, jqXHR) {
+            $.each(responseData, function(i, dimension) {
+              cubeDimension = new Swirrl.CubeDimension(dimension.uri, dimension.label, urlBase);
+              cubeDimension.onAjaxError.subscribe(function (e, args) {
+                // bubble up ajax errors to the grid.
+                onAjaxError.notify({status: jqXHR.status});
+              });
+              cubeDimensions.push(cubeDimension);
+            });
+            onCubeDimensionsReady.notify({cubeDimensions: cubeDimensions});
+          },
+          error: function( jqXHR, _, _ ) {
+            onAjaxError.notify({status: jqXHR.status});
+          }
+        });
+      } else {
+        onCubeDimensionsReady.notify({cubeDimensions: cubeDimensions});
+      }
+    }
+
+
+    function getSlickGrid() {
+      return slickGrid;
+    }
+
+    // set the rows dimension to the cubeDimension object passed in.
+    function setRowsDimension(cubeDimension) {
+      rowsDimension = cubeDimension;
+
+      var sizeReadyHandler = function(e, args) {
+        // this is the Size of this dimension
+        gridSize = args.size;
+        onGridSizeReady.notify({gridSize: gridSize});
+        rowsDimension.onSizeReady.unsubscribe(sizeReadyHandler); // only do it once.
+      }
+
+      rowsDimension.onSizeReady.subscribe(sizeReadyHandler);
+      rowsDimension.getSizeAsync();
+    }
+
+    function getRowsDimension() {
+      return rowsDimension;
+    }
+
+    function setGridColumns(cols) {
+
+      function rawFormatter(row, cell, value, columnDef, dataContext) {
+        return value;
+      }
+
+      // start with ids...
+      gridColumns = [{id: '__row_num', field: '__row_num', name: '#', width: ROWNUMBERSCOLUMNWIDTH, cssClass: 'row-num' }];
+
+      // and rows...
+      gridColumns.push({id: rowsDimension.uri, name: buildUriLink(rowsDimension.uri, rowsDimension.label || rowsDimension.uri), field: rowsDimension.uri, width: FIRSTCOLUMNWIDTH, sortable:true, formatter: rawFormatter });
+
+      // finally, all the columns.
+      $.each(cols, function(i, col) {
+        gridColumns.push({id: col.uri, name: buildUriLink(col.uri, col.label || col.uri), field: col.uri, width: COLUMNWIDTH, sortable:true, formatter: rawFormatter });
+      });
+
+      return gridColumns;
+    }
+
+    // set the columns dimension to the cubeDimension object passed in.
+    function setColumnsDimension(cubeDimension) {
+      columnsDimension = cubeDimension;
+
+      var onValuesReadyHandler = function(e, args) {
+        // this is the list of columns.
+        var cols = args.values;
+        setGridColumns(cols);
+        onGridColumnsReady.notify({gridColumns: gridColumns});
+
+        // unsubscribe: we only want to do this once.
+        columnsDimension.onValuesReady.unsubscribe(onValuesReadyHandler);
+      }
+
+      columnsDimension.onValuesReady.subscribe(onValuesReadyHandler);
+      columnsDimension.getValuesAsync();
+    }
+
+    function getColumnsDimension() {
+      return columnsDimension;
+    }
+
+    function setLockedDimensionValue(dimensionUri, value) {
+      lockedDimensions[dimensionUri] = value;
+    }
+
+    function getLockedDimensionValue(dimensionUri) {
+      return lockedDimensions[dimensionUri];
+    }
+
+    // retuns an array of cubeDimension objects.
+    function getLockedDimensionObjects() {
+      var retVal = [];
+
+      if (checkLockedDimensions()) {
+
+        var retVal;
+        for (var lockedDimensionUri in lockedDimensions) {
+          // find the right cube Dimension
+          $.each(cubeDimensions, function(i, cubeDim) {
+            if(cubeDim.uri == lockedDimensionUri) {
+              retVal.push(cubeDim);
+            }
+          });
+        }
+      }
+
+      return retVal;
+    }
+
+    // if page passed as null, get whole result set.
+    function buildObservationsUrl(format, page) {
+      var url = urlBase + "/observations." + format;
+
+      url += "?rows_dimension=" + encodeURIComponent(rowsDimension.uri);
+      url += "&columns_dimension=" + encodeURIComponent(columnsDimension.uri);
+
+      if (page!=null) { url += "&per_page=" + pageSize.toString(); }
+      if (page!=null) { url += "&page=" + (page+1).toString(); } // we use 1-based pages on server
+      if (orderDesc) { url += "&order_desc=true"; }
+      if (orderByColumn) { url += "&order_by_column=" + encodeURIComponent(orderByColumn); }
+
+      for (var lockedDimension in lockedDimensions) {
+        var dimensionVal = lockedDimensions[lockedDimension];
+        url += "&" + encodeURIComponent(lockedDimension) + "=" + encodeURIComponent(dimensionVal);
+      }
+
+      return url;
+    }
+
+    function showCSVDownloadLink() {
+      // call hide first, so can call it repeatedly.
+      hideCSVDownloadLink();
+
+      var url = buildObservationsUrl('csv', null);
+
+      $(".grid-footer i.icon-download").show();
+
+      var theIcon = $("<i></i>");
+      theIcon.addClass("icon-download");
+
+      var theLink = $("<a></a>");
+      theLink.addClass("download-csv");
+      theLink.attr("href", url);
+
+      theLink.append(theIcon);
+      theLink.append(" Download results as CSV");
+
+      $(".grid-footer .footer-content").append(theLink);
+    }
+
+    function hideCSVDownloadLink() {
+      $(".grid-footer .footer-content a.download-csv").remove();
+    }
+
+    // public api.
+    //////////////////
+    return {
+
+      // methods
+      //////////////////
+      "getSlickGrid": getSlickGrid
+    , "clear": clear
+
+    , "getAllDimensionsAsync": getAllDimensionsAsync // raises cubeDimensionsReady when cubeDimensions ready
+
+    , "setRowsDimension": setRowsDimension
+    , "getRowsDimension": getRowsDimension
+
+    , "setColumnsDimension": setColumnsDimension
+    , "getColumnsDimension": getColumnsDimension
+
+    , "setLockedDimensionValue": setLockedDimensionValue
+    , "getLockedDimensionValue": getLockedDimensionValue
+    , "getLockedDimensionObjects": getLockedDimensionObjects
+
+    , "checkLockedDimensions": checkLockedDimensions
+    , "getCubeDimensions": getCubeDimensions
+    , "getDimensionWithUri": getDimensionWithUri
+
+    , "showCSVDownloadLink": showCSVDownloadLink
+    , "hideCSVDownloadLink": hideCSVDownloadLink
+
+
+    , "initGridWhenReady": initGridWhenReady // re-initialises grid from currently set dims when all the pre-reqs have arrived.
+
+      // events
+      //////////////////
+    , "onCubeDimensionsReady": onCubeDimensionsReady
+    , "onGridSizeReady": onGridSizeReady
+    , "onGridColumnsReady": onGridColumnsReady
+
+    , "onGridGettingData": onGridGettingData
+    , "onGridReady": onGridReady
+    , "onGridInitialized": onGridInitialized
+    , "onAjaxError": onAjaxError
+    }
+  }
+
+  // Swirrl.CubeGrid
+  $.extend(true, window, { Swirrl: { CubeGrid: CubeGrid }});
+})(jQuery)