tb_core 1.4.0.1 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94d2db866f51de6c90377e7b45b255deb84e1c2e
-  data.tar.gz: 281c43074a1a1de7098a84e5bbd3ba5cc71239e6
+  metadata.gz: a9b6cb6c8e20c8f5e050ff4194eecd52873a8ee8
+  data.tar.gz: 6f0923c173310c948501ab42f63fd9cdc4117577
 SHA512:
-  metadata.gz: ae37cc5ceeefdd1a0001af643b2059e56cb3b82dbd968ab5708c3990fbc57b0fbbae0a088d537fea50fd9fd413f4b0622ac8d3430023a824e5532543b40acd10
-  data.tar.gz: e863b1df22a455f397d6d586c86b7a6dddbe1149a2b1db802cc52c9849f27273373cb4ae06fc9c0b754262448d7e001bc079b7a5b2b1f45f05abfa4c2f446618
+  metadata.gz: 75f1dcb89bd05dad030e06f21955d670c3cd8cb7af2541807de9588840aa1202205699cbd53bb95ecce5d6337ae456fe53b529f01b35e57fcca6c8f83c0ffac0
+  data.tar.gz: e8fbe677701e25eafca66574b35ed73bd0689bddf9af713c896da23d21b28d013a4166f7b7645f450c7bf35917b258e9fb9da0fa149fa0b0649e64c6b0af99ab

data/app/assets/javascripts/admin/core/jquery_ui.js

@@ -15,8 +15,8 @@
 //
 //= require jquery-ui/core
 //= require jquery-ui/widget
-//= require jquery-ui/mouse
-//= require jquery-ui/draggable
-//= require jquery-ui/droppable
-//= require jquery-ui/sortable
+//= require jquery-ui/widgets/mouse
+//= require jquery-ui/widgets/draggable
+//= require jquery-ui/widgets/droppable
+//= require jquery-ui/widgets/sortable
 //

data/app/assets/javascripts/tb_core/remote.js

@@ -1,5 +1,5 @@
+//= require rails-ujs
 //= require_self
-//= require jquery_ujs
 
 (function(){
 
@@ -16,14 +16,10 @@
 */
 tb.remote = {
   init: function(){
-    var $document = $(document);
-    $document.on('ajax:before', 'form', onRemoteFormBefore);
-    $document.on('ajax:complete', 'form', onRemoteFormComplete);
-    $document.on('ajax:success', 'form[data-success]', onRemoteFormSuccess);
-    $document.on('ajax:error', 'form[data-errors]', onRemoteFormErrors);
-    $document.on('ajax:success', 'tr a[data-method=delete][data-remote=true]', onRemoteDeleteTableRow);
-    $document.on('ajax:aborted:file', 'form', onRemoteAbortedFile);
-    $document.ready(extendEnableFormElementMethod);
+    Rails.delegate(document, 'form', 'ajax:before', onRemoteFormBefore);
+    Rails.delegate(document, 'form[data-success], a[data-success]', 'ajax:success', onRemoteFormSuccess);
+    Rails.delegate(document, 'form[data-errors]', 'ajax:error', onRemoteFormErrors);
+    Rails.delegate(document, 'tr a[data-method=delete][data-remote=true]', 'ajax:success', onRemoteDeleteTableRow);
   }
 };
 
@@ -31,22 +27,11 @@ tb.remote = {
 * UJS likes to request application/javascript by default, but Twice Baked prefers JSON.
 */
 var onRemoteFormBefore = function(event){
-  var $form = $(this);
-  if($form.data('type') === undefined){
-    $form.data('type', 'json');
+  if(this.getAttribute('data-type') === null){
+    this.setAttribute('data-type', 'json');
   }
 };
 
-/*
-* Runs any time a remote form completes and assigns a true/false value
-* to lastRemoteSuccess depending on if the post was succesful. This is
-* referenced later on in enableFormElement
-*/
-var onRemoteFormComplete = function(event, jqXHR, textStatus){
-  var success = jqXHR.status >= 200 && jqXHR.status < 300;
-  $(this).data('lastRemoteSuccess', success);
-};
-
 /*
 * Called when a remote form is submitted with a data-success configured
 * Simply redirects to the configured path, or reloads the page if "reload" is passed
@@ -54,12 +39,13 @@ var onRemoteFormComplete = function(event, jqXHR, textStatus){
 * ie:
 * <form action="..." data-remote="true" data-success="/path/for/success/:id">
 */
-var onRemoteFormSuccess = function(event, json, textStatus, jqXHR){
-  var successPath = $(this).data('success');
-  if(successPath == 'reload'){
+var onRemoteFormSuccess = function(event){
+  var successPath = this.getAttribute('data-success');
+  if(successPath === 'reload'){
     window.location.reload(true);
   }
   else{
+    var json = event.detail[0];
     window.location = buildSuccessPath(successPath, json);
   }
 };
@@ -94,72 +80,120 @@ var buildSuccessPath = function(path, json){
 *   - OR -
 * <form action="..." data-remote="true" data-errors="alert">
 */
-var onRemoteFormErrors = function(event, jqXHR, textStatus, errorThrown){
-  var $form = $(this);
-  var errorType = $form.data('errors');
-  if(jqXHR.status == 422){
-    if(errorType == 'inline'){
-      tb.remote.displayErrorsInline($form, jqXHR.responseJSON);
+var onRemoteFormErrors = function(event){
+  var json = event.detail[0];
+  var xhr = event.detail[2];
+  var form = this;
+  var errorType = form.getAttribute('data-errors');
+
+  if(xhr.status === 422){
+    if(errorType === 'inline'){
+      tb.remote.displayErrorsInline(form, json);
     }
     else{
-      tb.remote.displayErrorsAlert(jqXHR.responseJSON);
+      tb.remote.displayErrorsAlert(json);
     }
   }
-  else if(jqXHR.status == 401 || jqXHR.status == 403){
+  else if(xhr.status === 401 || xhr.status === 403){
     window.alert('Error: Access denied.');
   }
+  else if(json.location) {
+    window.location = json.location;
+  }
   else{
+    var errorThrown = event.detail[1];
     window.alert('An unexpected error occurred: ' + errorThrown);
   }
 };
 
+function removeElement(element) {
+  element.parentElement.removeChild(element);
+}
+
+function createErrorParagraph(text, base) {
+  var p = document.createElement('p');
+  p.classList.add('form-error');
+  p.classList.add(base ? 'form-error-base' : 'form-error-inline');
+  p.innerText = text;
+  return p;
+}
+
+function querySelectorArray(parent, selector) {
+  var query = parent.querySelectorAll(selector);
+  var array = Array.prototype.slice.call(query);
+  return array;
+}
+
+/*
+* Take a single error message and format it as if it were
+* a json error coming from the server
+*/
+function formatStringAsErrors(errorString) {
+  return {base: {messages: [errorString] }};
+}
+
+/*
+* Remove inline error messages
+*/
+tb.remote.clearErrors = function(form) {
+  querySelectorArray(form, '.form-error-inline, .form-error-base').forEach(removeElement);
+};
+
 /*
 * Append error text to form input fields and scroll to the first error
 */
-tb.remote.displayErrorsInline = function($form, errors){
-  $form.find('.form-error-inline, .form-error-base').remove();
+tb.remote.displayErrorsInline = function(form, errors){
+  if(typeof errors === 'string') {
+    errors = formatStringAsErrors(errors);
+  }
+
+  tb.remote.clearErrors(form);
+
   for(var key in errors){
     var messages = errors[key].messages;
-    if(key == 'base'){
+    if(key === 'base'){
       for(var i=0; i<messages.length; i++){
-        $form.prepend('<p class="form-error form-error-base">'+messages[i]+'</p>');
+        var p = createErrorParagraph(messages[i], true);
+        form.insertBefore(p, form.firstChild);
       }
     }
     else{
-      var inputName, $input;
+      var inputName, input;
 
       keyArr = key.split('.');
 
       if(keyArr.length === 2){
         keyArr[0] += '_attributes';
-        $input = $form.find("[name$='[" + keyArr.join('][') + "]']");
+        input = form.querySelector("[name$='[" + keyArr.join('][') + "]']");
       }
       else{
-        $input = $form.find("[name$='[" + key + "]']").filter(function(index, input){
+        var array = querySelectorArray(form, "[name$='[" + key + "]']");
+        input = array.filter(function(input){
           return !input.name.match(/\]\[/); // Filter out nested attribute inputs ie model[a][b]
-        })
-        if($input.length === 0 && !key.match(/_id$/)){
-          $input = $form.find("[name$='[" + key + "_id]']");
+        })[0];
+        if(input === null && !key.match(/_id$/)){
+          input = form.querySelector("[name$='[" + key + "_id]']");
         }
       }
 
       var message = messages[0];
-      if($input.length > 0){
-        $input.parent().append('<p class="form-error form-error-inline">'+message+'</p>');
+      if(input){
+        input.parentNode.appendChild(createErrorParagraph(message));
       }
       else{
         console.warn('Missing input field for key:', key);
-        $form.prepend('<p class="form-error form-error-base">'+key+' '+message+'</p>');
+        form.insertBefore(
+          createErrorParagraph(key+' '+message), form.firstChild
+        );
       }
     }
   }
-  var $firstError = $form.find('.form-error-inline, .form-error-base').first().parent();
-  if($firstError.length > 0){
-    if(!tb.util.elementIsInView($firstError)){
-      $('body, html').animate({
-        scrollTop: $firstError.offset().top
-      });
-    }
+
+  var firstError = form.querySelector('.form-error-inline, .form-error-base')
+  if(firstError &&
+    !tb.util.elementIsInView(firstError) &&
+    typeof(firstError.scrollIntoView) === 'function'){
+    firstError.parentElement.scrollIntoView();
   }
 };
 
@@ -167,13 +201,16 @@ tb.remote.displayErrorsInline = function($form, errors){
 * Display errors in a standard window.alert dialog
 */
 tb.remote.displayErrorsAlert = function(errors){
+  if(typeof errors === 'string') {
+    errors = formatStringAsErrors(errors);
+  }
   var text = "Please correct the following errors:\n";
   var label, message;
   var index = 0;
   for(var key in errors){
     label = errors[key].label;
     message = errors[key].messages[0];
-    if(key == 'base'){
+    if(key === 'base'){
       text += ' - ' + message + "\n"
     }
     else{
@@ -195,55 +232,6 @@ var onRemoteDeleteTableRow = function(){
   });
 };
 
-/*
-* Attach an authenticity_token input field when a remote form aborts due to a file input field
-*
-* When a form is configured with remote:true, the authenticity_token hidden input you would normally see is not included. Then what
-* can happen is the form can fall back to a non-remote action for some reason, possibly due to the presence of a file input field. The
-* net result is that the server responds with a "Can't verify CSRF token authenticity" error because none was sent.
-*
-* This function handles that case by injecting the missing authenticity_token input just before the form is posted.
-*
-*/
-var onRemoteAbortedFile = function(event, inputs){
-  var $form = $(this);
-  var csrfParam = $.rails.csrfParam();
-  if($form.find('input[name='+csrfParam+']').length === 0){
-    var csrfToken = $.rails.csrfToken();
-    var $input = $('<input/>', {
-      type: 'hidden',
-      name: csrfParam,
-      value: csrfToken
-    });
-    $form.prepend($input);
-  }
-};
-
-/*
-* Monkeypatch the base $.rails.enableFormElement function to add a
-* delay and a success text value to the button before returning to
-* default state.
-*/
-var extendEnableFormElementMethod = function(){
-  var originalEnableFormElement = $.rails.enableFormElement;
-
-  $.rails.enableFormElement = function(element){
-    var success = $(element).parents('form').data('lastRemoteSuccess');
-    var message = element.data('enableWith');
-
-    if(success && message){
-      var method = element.is('button') ? 'html' : 'val';
-      element[method](message);
-      setTimeout(function(){
-        originalEnableFormElement(element);
-      }, 1000);
-    }
-    else{
-      originalEnableFormElement(element);
-    }
-  };
-};
-
 tb.remote.init();
 
 })();

data/app/assets/javascripts/tb_core/utility.js

@@ -29,18 +29,26 @@ tb.util = {
   },
 
   getCsrfToken: function(){
-    return $('meta[name=csrf-token]').attr('content');
+    console.warn('Call to tb.util.getCsrfToken() will be removed in the future; Use Rails.csrfToken() instead.')
+    return Rails.csrfToken();
   },
 
   /*
   * Use top/bottom offsets to determine if the given jQuery element is within the current scroll view
+  *
+  * http://stackoverflow.com/questions/123999/how-to-tell-if-a-dom-element-is-visible-in-the-current-viewport/7557433#7557433
   */
-  elementIsInView: function($element){
-    var docViewTop = document.body.scrollTop;
-    var docViewBottom = docViewTop + $(window).height();
-    var container = $('.stat-front-desk');
-    var elemTop = $element.offset().top;
-    return docViewBottom >= elemTop && docViewTop <= elemTop;
+  elementIsInView: function(el){
+     if (typeof jQuery === "function" && el instanceof jQuery) {
+       el = el[0];
+     }
+     var rect = el.getBoundingClientRect();
+     return (
+       rect.top >= 0 &&
+       rect.left >= 0 &&
+       rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && /*or $(window).height() */
+       rect.right <= (window.innerWidth || document.documentElement.clientWidth) /*or $(window).width() */
+     );
   }
 };
 

data/app/assets/libs/rails-ujs.js

@@ -0,0 +1,705 @@
+// https://github.com/rails/rails-ujs
+
+(function() {
+  (function() {
+    (function() {
+      this.Rails = {
+        linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
+        buttonClickSelector: {
+          selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',
+          exclude: 'form button'
+        },
+        inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
+        formSubmitSelector: 'form',
+        formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
+        formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
+        formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
+        requiredInputSelector: 'input[name][required]:not([disabled]), textarea[name][required]:not([disabled])',
+        fileInputSelector: 'input[name][type=file]:not([disabled])',
+        linkDisableSelector: 'a[data-disable-with], a[data-disable]',
+        buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
+      };
+
+    }).call(this);
+  }).call(this);
+
+  var Rails = this.Rails;
+
+  (function() {
+    (function() {
+      var expando, m;
+
+      m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
+
+      Rails.matches = function(element, selector) {
+        if (selector.exclude != null) {
+          return m.call(element, selector.selector) && !m.call(element, selector.exclude);
+        } else {
+          return m.call(element, selector);
+        }
+      };
+
+      expando = '_ujsData';
+
+      Rails.getData = function(element, key) {
+        var ref;
+        return (ref = element[expando]) != null ? ref[key] : void 0;
+      };
+
+      Rails.setData = function(element, key, value) {
+        if (element[expando] == null) {
+          element[expando] = {};
+        }
+        return element[expando][key] = value;
+      };
+
+      Rails.$ = function(selector) {
+        return Array.prototype.slice.call(document.querySelectorAll(selector));
+      };
+
+    }).call(this);
+    (function() {
+      var $, csrfParam, csrfToken;
+
+      $ = Rails.$;
+
+      csrfToken = Rails.csrfToken = function() {
+        var meta;
+        meta = document.querySelector('meta[name=csrf-token]');
+        return meta && meta.content;
+      };
+
+      csrfParam = Rails.csrfParam = function() {
+        var meta;
+        meta = document.querySelector('meta[name=csrf-param]');
+        return meta && meta.content;
+      };
+
+      Rails.CSRFProtection = function(xhr) {
+        var token;
+        token = csrfToken();
+        if (token != null) {
+          return xhr.setRequestHeader('X-CSRF-Token', token);
+        }
+      };
+
+      Rails.refreshCSRFTokens = function() {
+        var param, token;
+        token = csrfToken();
+        param = csrfParam();
+        if ((token != null) && (param != null)) {
+          return $('form input[name="' + param + '"]').forEach(function(input) {
+            return input.value = token;
+          });
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var CustomEvent, fire, matches;
+
+      matches = Rails.matches;
+
+      CustomEvent = window.CustomEvent;
+
+      if (typeof CustomEvent === 'function') {
+        CustomEvent = function(event, params) {
+          var evt;
+          evt = document.createEvent('CustomEvent');
+          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+          return evt;
+        };
+        CustomEvent.prototype = window.Event.prototype;
+      }
+
+      fire = Rails.fire = function(obj, name, data) {
+        var event;
+        event = new CustomEvent(name, {
+          bubbles: true,
+          cancelable: true,
+          detail: data
+        });
+        obj.dispatchEvent(event);
+        return !event.defaultPrevented;
+      };
+
+      Rails.stopEverything = function(e) {
+        fire(e.target, 'ujs:everythingStopped');
+        e.preventDefault();
+        e.stopPropagation();
+        return e.stopImmediatePropagation();
+      };
+
+      Rails.delegate = function(element, selector, eventType, handler) {
+        return element.addEventListener(eventType, function(e) {
+          var target;
+          target = e.target;
+          while (!(!(target instanceof Element) || matches(target, selector))) {
+            target = target.parentNode;
+          }
+          if (target instanceof Element && handler.call(target, e) === false) {
+            e.preventDefault();
+            return e.stopPropagation();
+          }
+        });
+      };
+
+    }).call(this);
+    (function() {
+      var AcceptHeaders, CSRFProtection, createXHR, fire, prepareOptions, processResponse;
+
+      CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;
+
+      AcceptHeaders = {
+        '*': '*/*',
+        text: 'text/plain',
+        html: 'text/html',
+        xml: 'application/xml, text/xml',
+        json: 'application/json, text/javascript',
+        script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
+      };
+
+      Rails.ajax = function(options) {
+        var xhr;
+        options = prepareOptions(options);
+        xhr = createXHR(options, function() {
+          var response;
+          response = processResponse(xhr.response, xhr.getResponseHeader('Content-Type'));
+          if (Math.floor(xhr.status / 100) === 2) {
+            if (typeof options.success === "function") {
+              options.success(response, xhr.statusText, xhr);
+            }
+          } else {
+            if (typeof options.error === "function") {
+              options.error(response, xhr.statusText, xhr);
+            }
+          }
+          return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : void 0;
+        });
+        if (typeof options.beforeSend === "function") {
+          options.beforeSend(xhr, options);
+        }
+        if (xhr.readyState === XMLHttpRequest.OPENED) {
+          return xhr.send(options.data);
+        } else {
+          return fire(document, 'ajaxStop');
+        }
+      };
+
+      prepareOptions = function(options) {
+        options.type = options.type.toUpperCase();
+        if (options.type === 'GET' && options.data) {
+          if (options.url.indexOf('?') < 0) {
+            options.url += '?' + options.data;
+          } else {
+            options.url += '&' + options.data;
+          }
+        }
+        if (AcceptHeaders[options.dataType] == null) {
+          options.dataType = '*';
+        }
+        options.accept = AcceptHeaders[options.dataType];
+        if (options.dataType !== '*') {
+          options.accept += ', */*; q=0.01';
+        }
+        return options;
+      };
+
+      createXHR = function(options, done) {
+        var xhr;
+        xhr = new XMLHttpRequest();
+        xhr.open(options.type, options.url, true);
+        xhr.setRequestHeader('Accept', options.accept);
+        if (typeof options.data === 'string') {
+          xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
+        }
+        if (!options.crossDomain) {
+          xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+        }
+        CSRFProtection(xhr);
+        xhr.withCredentials = !!options.withCredentials;
+        xhr.onreadystatechange = function() {
+          if (xhr.readyState === XMLHttpRequest.DONE) {
+            return done(xhr);
+          }
+        };
+        return xhr;
+      };
+
+      processResponse = function(response, type) {
+        var parser, script;
+        if (typeof response === 'string' && typeof type === 'string') {
+          if (type.match(/\bjson\b/)) {
+            try {
+              response = JSON.parse(response);
+            } catch (undefined) {}
+          } else if (type.match(/\bjavascript\b/)) {
+            script = document.createElement('script');
+            script.innerHTML = response;
+            document.body.appendChild(script);
+          } else if (type.match(/\b(xml|html|svg)\b/)) {
+            parser = new DOMParser();
+            type = type.replace(/;.+/, '');
+            try {
+              response = parser.parseFromString(response, type);
+            } catch (undefined) {}
+          }
+        }
+        return response;
+      };
+
+      Rails.href = function(element) {
+        return element.href;
+      };
+
+      Rails.isCrossDomain = function(url) {
+        var e, error, originAnchor, urlAnchor;
+        originAnchor = document.createElement('a');
+        originAnchor.href = location.href;
+        urlAnchor = document.createElement('a');
+        try {
+          urlAnchor.href = url;
+          return !(((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host) || (originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host));
+        } catch (error) {
+          e = error;
+          return true;
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var matches, toArray;
+
+      matches = Rails.matches;
+
+      toArray = function(e) {
+        return Array.prototype.slice.call(e);
+      };
+
+      Rails.serializeElement = function(element, additionalParam) {
+        var inputs, params;
+        inputs = [element];
+        if (matches(element, 'form')) {
+          inputs = toArray(element.elements);
+        }
+        params = [];
+        inputs.forEach(function(input) {
+          if (!input.name) {
+            return;
+          }
+          if (matches(input, 'select')) {
+            return toArray(input.options).forEach(function(option) {
+              if (option.selected) {
+                return params.push({
+                  name: input.name,
+                  value: option.value
+                });
+              }
+            });
+          } else if (input.type !== 'radio' && input.type !== 'checkbox' || input.checked) {
+            return params.push({
+              name: input.name,
+              value: input.value
+            });
+          }
+        });
+        if (additionalParam) {
+          params.push(additionalParam);
+        }
+        return params.map(function(param) {
+          if (param.name != null) {
+            return (encodeURIComponent(param.name)) + "=" + (encodeURIComponent(param.value));
+          } else {
+            return param;
+          }
+        }).join('&');
+      };
+
+      Rails.formElements = function(form, selector) {
+        if (matches(form, 'form')) {
+          return toArray(form.elements).filter(function(el) {
+            return matches(el, selector);
+          });
+        } else {
+          return toArray(form.querySelectorAll(selector));
+        }
+      };
+
+      Rails.blankInputs = function(form, selector, nonBlank) {
+        var checkedRadioButtonNames, foundInputs, requiredInputs;
+        foundInputs = [];
+        requiredInputs = toArray(form.querySelectorAll(selector || 'input, textarea'));
+        checkedRadioButtonNames = {};
+        requiredInputs.forEach(function(input) {
+          var radioName, radios, valueToCheck;
+          if (input.type === 'radio') {
+            radioName = input.name;
+            if (!checkedRadioButtonNames[radioName]) {
+              if (form.querySelectorAll("input[type=radio][name='" + radioName + "']:checked").length === 0) {
+                radios = form.querySelectorAll("input[type=radio][name='" + radioName + "']");
+                foundInputs = foundInputs.concat(toArray(radios));
+              }
+              return checkedRadioButtonNames[radioName] = radioName;
+            }
+          } else {
+            valueToCheck = input.type === 'checkbox' ? input.checked : !!input.value;
+            if (valueToCheck === nonBlank) {
+              return foundInputs.push(input);
+            }
+          }
+        });
+        return foundInputs;
+      };
+
+    }).call(this);
+    (function() {
+      var allowAction, fire, stopEverything;
+
+      fire = Rails.fire, stopEverything = Rails.stopEverything;
+
+      Rails.handleConfirm = function(e) {
+        if (!allowAction(this)) {
+          return stopEverything(e);
+        }
+      };
+
+      allowAction = function(element) {
+        var answer, callback, message;
+        message = element.getAttribute('data-confirm');
+        if (!message) {
+          return true;
+        }
+        answer = false;
+        if (fire(element, 'confirm')) {
+          try {
+            answer = confirm(message);
+          } catch (undefined) {}
+          callback = fire(element, 'confirm:complete', [answer]);
+        }
+        return answer && callback;
+      };
+
+    }).call(this);
+    (function() {
+      var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, matches, setData, stopEverything;
+
+      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;
+
+      Rails.enableElement = function(e) {
+        var element;
+        element = e instanceof Event ? e.target : e;
+        if (matches(element, Rails.linkDisableSelector)) {
+          return enableLinkElement(element);
+        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {
+          return enableFormElement(element);
+        } else if (matches(element, Rails.formSubmitSelector)) {
+          return enableFormElements(element);
+        }
+      };
+
+      Rails.disableElement = function(e) {
+        var element;
+        element = e instanceof Event ? e.target : e;
+        if (matches(element, Rails.linkDisableSelector)) {
+          return disableLinkElement(element);
+        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {
+          return disableFormElement(element);
+        } else if (matches(element, Rails.formSubmitSelector)) {
+          return disableFormElements(element);
+        }
+      };
+
+      disableLinkElement = function(element) {
+        var replacement;
+        replacement = element.getAttribute('data-disable-with');
+        if (replacement != null) {
+          setData(element, 'ujs:enable-with', element.innerHTML);
+          element.innerHTML = replacement;
+        }
+        element.addEventListener('click', stopEverything);
+        return setData(element, 'ujs:disabled', true);
+      };
+
+      enableLinkElement = function(element) {
+        var originalText;
+        originalText = getData(element, 'ujs:enable-with');
+        if (originalText != null) {
+          element.innerHTML = originalText;
+          setData(element, 'ujs:enable-with', null);
+        }
+        element.removeEventListener('click', stopEverything);
+        return setData(element, 'ujs:disabled', null);
+      };
+
+      disableFormElements = function(form) {
+        return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);
+      };
+
+      disableFormElement = function(element) {
+        var replacement;
+        replacement = element.getAttribute('data-disable-with');
+        if (replacement != null) {
+          if (matches(element, 'button')) {
+            setData(element, 'ujs:enable-with', element.innerHTML);
+            element.innerHTML = replacement;
+          } else {
+            setData(element, 'ujs:enable-with', element.value);
+            element.value = replacement;
+          }
+        }
+        element.disabled = true;
+        return setData(element, 'ujs:disabled', true);
+      };
+
+      enableFormElements = function(form) {
+        return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);
+      };
+
+      enableFormElement = function(element) {
+        var originalText;
+        originalText = getData(element, 'ujs:enable-with');
+        if (originalText != null) {
+          if (matches(element, 'button')) {
+            element.innerHTML = originalText;
+          } else {
+            element.value = originalText;
+          }
+          setData(element, 'ujs:enable-with', null);
+        }
+        element.disabled = false;
+        return setData(element, 'ujs:disabled', null);
+      };
+
+    }).call(this);
+    (function() {
+      var stopEverything;
+
+      stopEverything = Rails.stopEverything;
+
+      Rails.handleMethod = function(e) {
+        var csrfParam, csrfToken, form, formContent, href, link, method;
+        link = this;
+        method = link.getAttribute('data-method');
+        if (!method) {
+          return;
+        }
+        href = Rails.href(link);
+        csrfToken = Rails.csrfToken();
+        csrfParam = Rails.csrfParam();
+        form = document.createElement('form');
+        formContent = "<input name='_method' value='" + method + "' type='hidden' />";
+        if ((csrfParam != null) && (csrfToken != null) && !Rails.isCrossDomain(href)) {
+          formContent += "<input name='" + csrfParam + "' value='" + csrfToken + "' type='hidden' />";
+        }
+        formContent += '<input type="submit" />';
+        form.method = 'post';
+        form.action = href;
+        form.target = link.target;
+        form.innerHTML = formContent;
+        form.style.display = 'none';
+        document.body.appendChild(form);
+        form.querySelector('[type="submit"]').click();
+        return stopEverything(e);
+      };
+
+    }).call(this);
+    (function() {
+      var ajax, blankInputs, fire, getData, isCrossDomain, isRemote, matches, serializeElement, setData, stopEverything,
+        slice = [].slice;
+
+      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, blankInputs = Rails.blankInputs, serializeElement = Rails.serializeElement;
+
+      isRemote = function(element) {
+        var value;
+        value = element.getAttribute('data-remote');
+        return (value != null) && value !== 'false';
+      };
+
+      Rails.handleRemote = function(e) {
+        var button, data, dataType, element, method, url, withCredentials;
+        element = this;
+        if (!isRemote(element)) {
+          return true;
+        }
+        if (!fire(element, 'ajax:before')) {
+          fire(element, 'ajax:stopped');
+          return false;
+        }
+        withCredentials = element.getAttribute('data-with-credentials');
+        dataType = element.getAttribute('data-type') || 'script';
+        if (matches(element, Rails.formSubmitSelector)) {
+          button = getData(element, 'ujs:submit-button');
+          method = getData(element, 'ujs:submit-button-formmethod') || element.method;
+          url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;
+          if (method.toUpperCase() === 'GET') {
+            url = url.replace(/\?.*$/, '');
+          }
+          if (element.enctype === 'multipart/form-data') {
+            data = new FormData(element);
+            if (button != null) {
+              data.append(button.name, button.value);
+            }
+          } else {
+            data = serializeElement(element, button);
+          }
+          setData(element, 'ujs:submit-button', null);
+          setData(element, 'ujs:submit-button-formmethod', null);
+          setData(element, 'ujs:submit-button-formaction', null);
+        } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {
+          method = element.getAttribute('data-method');
+          url = element.getAttribute('data-url');
+          data = serializeElement(element, element.getAttribute('data-params'));
+        } else {
+          method = element.getAttribute('data-method');
+          url = Rails.href(element);
+          data = element.getAttribute('data-params');
+        }
+        ajax({
+          type: method || 'GET',
+          url: url,
+          data: data,
+          dataType: dataType,
+          beforeSend: function(xhr, options) {
+            if (fire(element, 'ajax:beforeSend', [xhr, options])) {
+              return fire(element, 'ajax:send', [xhr]);
+            } else {
+              fire(element, 'ajax:stopped');
+              return xhr.abort();
+            }
+          },
+          success: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:success', args);
+          },
+          error: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:error', args);
+          },
+          complete: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:complete', args);
+          },
+          crossDomain: isCrossDomain(url),
+          withCredentials: (withCredentials != null) && withCredentials !== 'false'
+        });
+        return stopEverything(e);
+      };
+
+      Rails.validateForm = function(e) {
+        var blankRequiredInputs, form;
+        form = this;
+        if (form.noValidate || getData(form, 'ujs:formnovalidate-button')) {
+          return;
+        }
+        blankRequiredInputs = blankInputs(form, Rails.requiredInputSelector, false);
+        if (blankRequiredInputs.length > 0 && fire(form, 'ajax:aborted:required', [blankRequiredInputs])) {
+          return stopEverything(e);
+        }
+      };
+
+      Rails.formSubmitButtonClick = function(e) {
+        var button, form;
+        button = this;
+        form = button.form;
+        if (!form) {
+          return;
+        }
+        if (button.name) {
+          setData(form, 'ujs:submit-button', {
+            name: button.name,
+            value: button.value
+          });
+        }
+        setData(form, 'ujs:formnovalidate-button', button.formNoValidate);
+        setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));
+        return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));
+      };
+
+      Rails.handleMetaClick = function(e) {
+        var data, link, metaClick, method;
+        link = this;
+        method = (link.getAttribute('data-method') || 'GET').toUpperCase();
+        data = link.getAttribute('data-params');
+        metaClick = e.metaKey || e.ctrlKey;
+        if (metaClick && method === 'GET' && !data) {
+          return e.stopImmediatePropagation();
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleMetaClick, handleMethod, handleRemote, refreshCSRFTokens, validateForm;
+
+      fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleConfirm = Rails.handleConfirm, handleRemote = Rails.handleRemote, validateForm = Rails.validateForm, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMetaClick = Rails.handleMetaClick, handleMethod = Rails.handleMethod;
+
+      if ((typeof jQuery !== "undefined" && jQuery !== null) && !jQuery.rails) {
+        jQuery.rails = Rails;
+        jQuery.ajaxPrefilter(function(options, originalOptions, xhr) {
+          if (!options.crossDomain) {
+            return CSRFProtection(xhr);
+          }
+        });
+      }
+
+      Rails.start = function() {
+        if (window._rails_loaded) {
+          throw new Error('jquery-ujs has already been loaded!');
+        }
+        window.addEventListener('pageshow', function() {
+          $(Rails.formEnableSelector).forEach(function(el) {
+            if (getData(el, 'ujs:disabled')) {
+              return enableElement(el);
+            }
+          });
+          return $(Rails.linkDisableSelector).forEach(function(el) {
+            if (getData(el, 'ujs:disabled')) {
+              return enableElement(el);
+            }
+          });
+        });
+        delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);
+        delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);
+        delegate(document, Rails.linkClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.linkClickSelector, 'click', handleMetaClick);
+        delegate(document, Rails.linkClickSelector, 'click', disableElement);
+        delegate(document, Rails.linkClickSelector, 'click', handleRemote);
+        delegate(document, Rails.linkClickSelector, 'click', handleMethod);
+        delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.buttonClickSelector, 'click', disableElement);
+        delegate(document, Rails.buttonClickSelector, 'click', handleRemote);
+        delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);
+        delegate(document, Rails.inputChangeSelector, 'change', handleRemote);
+        delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);
+        delegate(document, Rails.formSubmitSelector, 'submit', validateForm);
+        delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);
+        delegate(document, Rails.formSubmitSelector, 'submit', function(e) {
+          return setTimeout((function() {
+            return disableElement(e);
+          }), 13);
+        });
+        delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);
+        delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);
+        document.addEventListener('DOMContentLoaded', refreshCSRFTokens);
+        return window._rails_loaded = true;
+      };
+
+      if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {
+        Rails.start();
+      }
+
+    }).call(this);
+  }).call(this);
+
+  if (typeof module === "object" && module.exports) {
+    module.exports = Rails;
+  } else if (typeof define === "function" && define.amd) {
+    define(Rails);
+  }
+}).call(this);

data/app/controllers/admin/password_resets_controller.rb

@@ -9,7 +9,7 @@ class Admin::PasswordResetsController < Admin::ApplicationController
   end
 
   def create
-    @user = SpudUser.find_by_email(params[:email])
+    @user = SpudUser.find_by(email: params[:email])
     if @user
       @user.reset_perishable_token!
       TbCoreMailer.forgot_password_notification(@user, admin_password_reset_url(@user.perishable_token)).deliver_later
@@ -42,12 +42,11 @@ private
 
   def load_user_using_perishable_token
     @user = SpudUser.find_using_perishable_token(params[:id])
-    unless @user
-      flash[:notice] = "We're sorry, but we could not locate your account. " +
-      'If you are having issues try copying and pasting the URL ' +
-      'from your email into your browser or restarting the ' +
-      'reset password process.'
-      redirect_to admin_login_path
-    end
+    return if @user
+    flash[:notice] = "We're sorry, but we could not locate your account. " +
+    'If you are having issues try copying and pasting the URL ' +
+    'from your email into your browser or restarting the ' +
+    'reset password process.'
+    redirect_to admin_login_path
   end
 end

data/app/controllers/password_resets_controller.rb

@@ -10,7 +10,7 @@ class PasswordResetsController < ApplicationController
   end
 
   def create
-    @user = SpudUser.find_by_email(params[:email])
+    @user = SpudUser.find_by(email: params[:email])
     if @user
       @user.reset_perishable_token!
       TbCoreMailer.forgot_password_notification(@user, password_reset_url(@user.perishable_token)).deliver_later

data/app/controllers/spud/application_controller.rb

@@ -52,7 +52,7 @@ private
   # Override this in a controller to redifine where the login form is
   #
   def login_path_for_require_user
-    login_path(return_to: request.path)
+    login_path(return_to: request.fullpath)
   end
 
   def require_admin_user
@@ -70,6 +70,7 @@ private
   def back_or_default(default='/')
     if params[:return_to]
       uri = URI.parse(params[:return_to].to_s)
+      return "#{uri.path}?#{uri.query}" if uri.query
       return uri.path
     else
       return default

data/app/controllers/user_sessions_controller.rb

@@ -65,7 +65,7 @@ class UserSessionsController < ApplicationController
 private
 
   def user_session_params
-    params.require(:spud_user_session).permit(:login, :password)
+    params.require(:spud_user_session).permit(:login, :password, :email)
   end
 
   def change_password_params

data/app/views/admin/users/index.html.erb

@@ -15,19 +15,17 @@
         <th>&nbsp;</th>
       </thead>
       <tbody>
-        <% cache @spud_users.to_a do %>
-          <% @spud_users.each do |spud_user| %>
-            <tr>
-              <td><%= spud_user.full_name %></td>
-              <td><%= mail_to spud_user.email %></td>
-              <td><%= timestamp(spud_user.last_login_at) %></td>
-              <td class="table-actions">
-                <%= link_to 'Details', admin_user_path(spud_user), :class => 'btn btn-default btn-sm' %>
-                <%= link_to 'Edit', edit_admin_user_path(spud_user), :class => 'btn btn-default btn-sm' %>
-                <%= link_to 'Delete', admin_user_path(spud_user), :method => :delete, :data => {:confirm => 'Are you sure you want to delete this user?'}, :class => 'btn btn-danger btn-sm' %>
-              </td>
-            </tr>
-          <% end %>
+        <% @spud_users.each do |spud_user| %>
+          <tr>
+            <td><%= spud_user.full_name %></td>
+            <td><%= mail_to spud_user.email %></td>
+            <td><%= timestamp(spud_user.current_login_at) %></td>
+            <td class="table-actions">
+              <%= link_to 'Details', admin_user_path(spud_user), :class => 'btn btn-default btn-sm' %>
+              <%= link_to 'Edit', edit_admin_user_path(spud_user), :class => 'btn btn-default btn-sm' %>
+              <%= link_to 'Delete', admin_user_path(spud_user), :method => :delete, :data => {:confirm => 'Are you sure you want to delete this user?'}, :class => 'btn btn-danger btn-sm' %>
+            </td>
+          </tr>
         <% end %>
       </tbody>
     </table>

data/lib/spud_core/version.rb

@@ -1,5 +1,5 @@
 module Spud
   module Core
-    VERSION = '1.4.0.1'
+    VERSION = '1.4.1'.freeze
   end
 end

data/spec/controllers/admin/password_reset_controller_spec.rb

@@ -36,14 +36,14 @@ describe Admin::PasswordResetsController, type: :controller do
     describe 'create' do
       context 'with a valid user email address submitted' do
         it 'should trigger the password notificiation' do
-          allow(SpudUser).to receive(:find_by_email).and_return(user)
+          allow(SpudUser).to receive(:find_by).and_return(user)
           expect do
             post :create, params: { email: user.email }
           end.to have_enqueued_job.on_queue('mailers')
         end
 
         it 'should redirect to the login form' do
-          allow(SpudUser).to receive(:find_by_email).and_return(user)
+          allow(SpudUser).to receive(:find_by).and_return(user)
 
           post :create, params: { email: user.email }
           expect(response).to redirect_to(admin_login_path)
@@ -52,7 +52,7 @@ describe Admin::PasswordResetsController, type: :controller do
 
       context 'with an invalid user email address submitted' do
         before(:each) do
-          allow(SpudUser).to receive(:find_by_email).and_return(nil)
+          allow(SpudUser).to receive(:find_by).and_return(nil)
         end
         it 'should re-render the password reset form' do
           post :create, params: { email: 'invalid@email.com' }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tb_core
 version: !ruby/object:Gem::Version
-  version: 1.4.0.1
+  version: 1.4.1
 platform: ruby
 authors:
 - Greg Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-14 00:00:00.000000000 Z
+date: 2017-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,34 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: jquery-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: jquery-ui-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: breadcrumbs_on_rails
   requirement: !ruby/object:Gem::Requirement
@@ -308,6 +294,7 @@ files:
 - app/assets/libs/datepicker/css/datepicker.css
 - app/assets/libs/datepicker/js/bootstrap-datepicker.js
 - app/assets/libs/datepicker/less/datepicker.less
+- app/assets/libs/rails-ujs.js
 - app/assets/stylesheets/admin/application.css
 - app/assets/stylesheets/admin/core/application.scss
 - app/assets/stylesheets/admin/core/jquery_ui.scss