blazer 1.7.7 → 2.6.4

data/app/assets/javascripts/blazer/stupidtable-custom-settings.js

@@ -0,0 +1,13 @@
+function removeCommas(string) {
+  return string.replace(/,/g, "")
+}
+
+// Remove commas for integers and floats to fix issues with sorting in the stupidtable plugin
+var stupidtableCustomSettings = {
+  "int": function(a, b) {
+    return parseInt(removeCommas(a), 10) - parseInt(removeCommas(b), 10);
+  },
+  "float": function(a, b) {
+    return parseFloat(removeCommas(a)) - parseFloat(removeCommas(b));
+  }
+}

data/app/assets/javascripts/blazer/stupidtable.js

@@ -1,114 +1,281 @@
 // Stupid jQuery table plugin.
 
-// Call on a table
-// sortFns: Sort functions for your datatypes.
 (function($) {
-
   $.fn.stupidtable = function(sortFns) {
     return this.each(function() {
       var $table = $(this);
       sortFns = sortFns || {};
-
-      // Merge sort functions with some default sort functions.
       sortFns = $.extend({}, $.fn.stupidtable.default_sort_fns, sortFns);
+      $table.data('sortFns', sortFns);
+      $table.stupidtable_build();
 
-
-      // ==================================================== //
-      //                  Begin execution!                    //
-      // ==================================================== //
-
-      // Do sorting when THs are clicked
-      $table.on("click.stupidtable", "th", function() {
-        var $this = $(this);
-        var th_index = 0;
-        var dir = $.fn.stupidtable.dir;
-
-        $table.find("th").slice(0, $this.index()).each(function() {
-          var cols = $(this).attr("colspan") || 1;
-          th_index += parseInt(cols,10);
-        });
-
-        // Determine (and/or reverse) sorting direction, default `asc`
-        var sort_dir = $this.data("sort-default") || dir.ASC;
-        if ($this.data("sort-dir"))
-           sort_dir = $this.data("sort-dir") === dir.ASC ? dir.DESC : dir.ASC;
-
-        // Choose appropriate sorting function.
-        var type = $this.data("sort") || null;
-
-        // Prevent sorting if no type defined
-        if (type === null) {
-          return;
-        }
-
-        // Trigger `beforetablesort` event that calling scripts can hook into;
-        // pass parameters for sorted column index and sorting direction
-        $table.trigger("beforetablesort", {column: th_index, direction: sort_dir});
-        // More reliable method of forcing a redraw
-        $table.css("display");
-
-        // Run sorting asynchronously on a timout to force browser redraw after
-        // `beforetablesort` callback. Also avoids locking up the browser too much.
-        setTimeout(function() {
-          // Gather the elements for this column
-          var column = [];
-          var sortMethod = sortFns[type];
-          var trs = $table.children("tbody").children("tr");
-
-          // Extract the data for the column that needs to be sorted and pair it up
-          // with the TR itself into a tuple
-          trs.each(function(index,tr) {
-            var $e = $(tr).children().eq(th_index);
-            var sort_val = $e.data("sort-value");
-            var order_by = typeof(sort_val) !== "undefined" ? sort_val : $e.text();
-            column.push([order_by, tr]);
-          });
-
-          // Sort by the data-order-by value
-          column.sort(function(a, b) { return sortMethod(a[0], b[0]); });
-          if (sort_dir != dir.ASC)
-            column.reverse();
-
-          // Replace the content of tbody with the sorted rows. Strangely (and
-          // conveniently!) enough, .append accomplishes this for us.
-          trs = $.map(column, function(kv) { return kv[1]; });
-          $table.children("tbody").append(trs);
-
-          // Reset siblings
-          $table.find("th").data("sort-dir", null).removeClass("sorting-desc sorting-asc");
-          $this.data("sort-dir", sort_dir).addClass("sorting-"+sort_dir);
-
-          // Trigger `aftertablesort` event. Similar to `beforetablesort`
-          $table.trigger("aftertablesort", {column: th_index, direction: sort_dir});
-          // More reliable method of forcing a redraw
-          $table.css("display");
-        }, 10);
+      $table.on("click.stupidtable", "thead th", function() {
+          $(this).stupidsort();
       });
+
+      // Sort th immediately if data-sort-onload="yes" is specified. Limit to
+      // the first one found - only one default sort column makes sense anyway.
+      var $th_onload_sort = $table.find("th[data-sort-onload=yes]").eq(0);
+      $th_onload_sort.stupidsort();
     });
   };
 
-  // Enum containing sorting directions
+  // ------------------------------------------------------------------
+  // Default settings
+  // ------------------------------------------------------------------
+  $.fn.stupidtable.default_settings = {
+    should_redraw: function(sort_info){
+      return true;
+    },
+    will_manually_build_table: false
+  };
   $.fn.stupidtable.dir = {ASC: "asc", DESC: "desc"};
-
   $.fn.stupidtable.default_sort_fns = {
     "int": function(a, b) {
-      return parseInt(a.replace(/,/g, ''), 10) - parseInt(b.replace(/,/g, ''), 10);
+      return parseInt(a, 10) - parseInt(b, 10);
     },
     "float": function(a, b) {
       return parseFloat(a) - parseFloat(b);
     },
     "string": function(a, b) {
-      if (a < b) return -1;
-      if (a > b) return +1;
-      return 0;
+      return a.toString().localeCompare(b.toString());
     },
     "string-ins": function(a, b) {
-      a = a.toLowerCase();
-      b = b.toLowerCase();
-      if (a < b) return -1;
-      if (a > b) return +1;
-      return 0;
+      a = a.toString().toLocaleLowerCase();
+      b = b.toString().toLocaleLowerCase();
+      return a.localeCompare(b);
+    }
+  };
+
+  // Allow specification of settings on a per-table basis. Call on a table
+  // jquery object. Call *before* calling .stuidtable();
+  $.fn.stupidtable_settings = function(settings) {
+    return this.each(function() {
+      var $table = $(this);
+      var final_settings = $.extend({}, $.fn.stupidtable.default_settings, settings);
+      $table.stupidtable.settings = final_settings;
+    });
+  };
+
+
+  // Expects $("#mytable").stupidtable() to have already been called.
+  // Call on a table header.
+  $.fn.stupidsort = function(force_direction){
+    var $this_th = $(this);
+    var datatype = $this_th.data("sort") || null;
+
+    // No datatype? Nothing to do.
+    if (datatype === null) {
+      return;
+    }
+
+    var dir = $.fn.stupidtable.dir;
+    var $table = $this_th.closest("table");
+
+    var sort_info = {
+        $th: $this_th,
+        $table: $table,
+        datatype: datatype
+    };
+
+
+    // Bring in default settings if none provided
+    if(!$table.stupidtable.settings){
+        $table.stupidtable.settings = $.extend({}, $.fn.stupidtable.default_settings);
+    }
+
+    sort_info.compare_fn = $table.data('sortFns')[datatype];
+    sort_info.th_index = calculateTHIndex(sort_info);
+    sort_info.sort_dir = calculateSortDir(force_direction, sort_info);
+
+    $this_th.data("sort-dir", sort_info.sort_dir);
+    $table.trigger("beforetablesort", {column: sort_info.th_index, direction: sort_info.sort_dir, $th: $this_th});
+
+    // More reliable method of forcing a redraw
+    $table.css("display");
+
+    // Run sorting asynchronously on a timout to force browser redraw after
+    // `beforetablesort` callback. Also avoids locking up the browser too much.
+    setTimeout(function() {
+      if(!$table.stupidtable.settings.will_manually_build_table){
+        $table.stupidtable_build();
+      }
+      var table_structure = sortTable(sort_info);
+      var trs = getTableRowsFromTableStructure(table_structure, sort_info);
+
+      if(!$table.stupidtable.settings.should_redraw(sort_info)){
+        return;
+      }
+      $table.children("tbody").append(trs);
+
+      updateElementData(sort_info);
+      $table.trigger("aftertablesort", {column: sort_info.th_index, direction: sort_info.sort_dir, $th: $this_th});
+      $table.css("display");
+
+    }, 10);
+    return $this_th;
+  };
+
+  // Call on a sortable td to update its value in the sort. This should be the
+  // only mechanism used to update a cell's sort value. If your display value is
+  // different from your sort value, use jQuery's .text() or .html() to update
+  // the td contents, Assumes stupidtable has already been called for the table.
+  $.fn.updateSortVal = function(new_sort_val){
+  var $this_td = $(this);
+    if($this_td.is('[data-sort-value]')){
+      // For visual consistency with the .data cache
+      $this_td.attr('data-sort-value', new_sort_val);
+    }
+    $this_td.data("sort-value", new_sort_val);
+    return $this_td;
+  };
+
+
+  $.fn.stupidtable_build = function(){
+    return this.each(function() {
+      var $table = $(this);
+      var table_structure = [];
+      var trs = $table.children("tbody").children("tr");
+      trs.each(function(index,tr) {
+
+        // ====================================================================
+        // Transfer to using internal table structure
+        // ====================================================================
+        var ele = {
+            $tr: $(tr),
+            columns: [],
+            index: index
+        };
+
+        $(tr).children('td').each(function(idx, td){
+            var sort_val = $(td).data("sort-value");
+
+            // Store and read from the .data cache for display text only sorts
+            // instead of looking through the DOM every time
+            if(typeof(sort_val) === "undefined"){
+              var txt = $(td).text();
+              $(td).data('sort-value', txt);
+              sort_val = txt;
+            }
+            ele.columns.push(sort_val);
+        });
+        table_structure.push(ele);
+      });
+      $table.data('stupidsort_internaltable', table_structure);
+    });
+  };
+
+  // ====================================================================
+  // Private functions
+  // ====================================================================
+  var sortTable = function(sort_info){
+    var table_structure = sort_info.$table.data('stupidsort_internaltable');
+    var th_index = sort_info.th_index;
+    var $th = sort_info.$th;
+
+    var multicolumn_target_str = $th.data('sort-multicolumn');
+    var multicolumn_targets;
+    if(multicolumn_target_str){
+        multicolumn_targets = multicolumn_target_str.split(',');
+    }
+    else{
+        multicolumn_targets = [];
+    }
+    var multicolumn_th_targets = $.map(multicolumn_targets, function(identifier, i){
+        return get_th(sort_info.$table, identifier);
+    });
+
+    table_structure.sort(function(e1, e2){
+      var multicolumns = multicolumn_th_targets.slice(0); // shallow copy
+      var diff = sort_info.compare_fn(e1.columns[th_index], e2.columns[th_index]);
+      while(diff === 0 && multicolumns.length){
+          var multicolumn = multicolumns[0];
+          var datatype = multicolumn.$e.data("sort");
+          var multiCloumnSortMethod = sort_info.$table.data('sortFns')[datatype];
+          diff = multiCloumnSortMethod(e1.columns[multicolumn.index], e2.columns[multicolumn.index]);
+          multicolumns.shift();
+      }
+      // Sort by position in the table if values are the same. This enforces a
+      // stable sort across all browsers. See https://bugs.chromium.org/p/v8/issues/detail?id=90
+      if (diff === 0)
+        return e1.index - e2.index;
+      else
+        return diff;
+
+    });
+
+    if (sort_info.sort_dir != $.fn.stupidtable.dir.ASC){
+      table_structure.reverse();
     }
+      return table_structure;
+  };
+
+  var get_th = function($table, identifier){
+      // identifier can be a th id or a th index number;
+      var $table_ths = $table.find('th');
+      var index = parseInt(identifier, 10);
+      var $th;
+      if(!index && index !== 0){
+          $th = $table_ths.siblings('#' + identifier);
+          index = $table_ths.index($th);
+      }
+      else{
+          $th = $table_ths.eq(index);
+      }
+      return {index: index, $e: $th};
+  };
+
+  var getTableRowsFromTableStructure = function(table_structure, sort_info){
+    // Gather individual column for callbacks
+    var column = $.map(table_structure, function(ele, i){
+        return [[ele.columns[sort_info.th_index], ele.$tr, i]];
+    });
+
+    /* Side effect */
+    sort_info.column = column;
+
+    // Replace the content of tbody with the sorted rows. Strangely
+    // enough, .append accomplishes this for us.
+    return $.map(table_structure, function(ele) { return ele.$tr; });
+
+  };
+
+  var updateElementData = function(sort_info){
+    var $table = sort_info.$table;
+    var $this_th = sort_info.$th;
+    var sort_dir = $this_th.data('sort-dir');
+    var th_index = sort_info.th_index;
+
+
+    // Reset siblings
+    $table.find("th").data("sort-dir", null).removeClass("sorting-desc sorting-asc");
+    $this_th.data("sort-dir", sort_dir).addClass("sorting-"+sort_dir);
+  };
+
+  var calculateSortDir = function(force_direction, sort_info){
+    var sort_dir;
+    var $this_th = sort_info.$th;
+    var dir = $.fn.stupidtable.dir;
+
+    if(!!force_direction){
+        sort_dir = force_direction;
+    }
+    else{
+        sort_dir = force_direction || $this_th.data("sort-default") || dir.ASC;
+        if ($this_th.data("sort-dir"))
+           sort_dir = $this_th.data("sort-dir") === dir.ASC ? dir.DESC : dir.ASC;
+    }
+    return sort_dir;
+  };
+
+  var calculateTHIndex = function(sort_info){
+    var th_index = 0;
+    var base_index = sort_info.$th.index();
+    sort_info.$th.parents("tr").find("th").slice(0, base_index).each(function() {
+      var cols = $(this).attr("colspan") || 1;
+      th_index += parseInt(cols,10);
+    });
+    return th_index;
   };
 
 })(jQuery);