Date: Tue, 23 Aug 2016 23:11:04 +0800
Subject: [PATCH 69/72] Support overriding, currently only Rails.href
---
src/features/method.coffee | 2 +-
src/features/remote.coffee | 2 +-
src/utils/ajax.coffee | 2 ++
test/public/test/override.js | 65 ++++++++++++++++--------------------
test/views/index.erb | 2 +-
5 files changed, 33 insertions(+), 40 deletions(-)
diff --git a/src/features/method.coffee b/src/features/method.coffee
index 100d73e9..60f777c9 100644
--- a/src/features/method.coffee
+++ b/src/features/method.coffee
@@ -9,7 +9,7 @@ Rails.handleMethod = (e) ->
method = link.getAttribute('data-method')
return unless method
- href = link.href
+ href = Rails.href(link)
csrfToken = Rails.csrfToken()
csrfParam = Rails.csrfParam()
form = document.createElement('form')
diff --git a/src/features/remote.coffee b/src/features/remote.coffee
index ba6d8184..76530f48 100644
--- a/src/features/remote.coffee
+++ b/src/features/remote.coffee
@@ -48,7 +48,7 @@ Rails.handleRemote = (e) ->
data = serializeElement(element, element.getAttribute('data-params'))
else
method = element.getAttribute('data-method')
- url = element.href
+ url = Rails.href(element)
data = element.getAttribute('data-params')
ajax(
diff --git a/src/utils/ajax.coffee b/src/utils/ajax.coffee
index 6321d459..9af515be 100644
--- a/src/utils/ajax.coffee
+++ b/src/utils/ajax.coffee
@@ -73,6 +73,8 @@ processResponse = (response, type) ->
try response = parser.parseFromString(response, type)
response
+# Default way to get an element's href. May be overridden at Rails.href.
+Rails.href = (element) -> element.href
# Determines if the request is a cross domain request.
Rails.isCrossDomain = (url) ->
diff --git a/test/public/test/override.js b/test/public/test/override.js
index 34e13f2f..afccb3d6 100644
--- a/test/public/test/override.js
+++ b/test/public/test/override.js
@@ -1,18 +1,17 @@
(function() {
+var realHref
+
module('override', {
setup: function() {
- window.realHref = $.rails.href
+ realHref = $.rails.href
$('#qunit-fixture')
.append($('', {
- href: '/real/href', 'data-method': 'delete', 'data-href': '/data/href'
- }))
- .append($('', {
- href: '/other/href', 'data-custom-remote-link': 'true'
+ href: '/real/href', 'data-remote': 'true', 'data-method': 'delete', 'data-href': '/data/href'
}))
},
teardown: function() {
- $.rails.href = window.realHref
+ $.rails.href = realHref
}
})
@@ -22,47 +21,39 @@ asyncTest('the getter for an element\'s href is publicly accessible', 1, functio
})
asyncTest('the getter for an element\'s href is overridable', 1, function() {
- $.rails.href = function(element) { return element.data('href') }
- $.rails.ajax = function(options) {
- equal('/data/href', options.url)
- }
- $.rails.handleRemote($('#qunit-fixture').find('a'))
+ $.rails.href = function(element) { return $(element).data('href') }
+ $('#qunit-fixture a')
+ .bindNative('ajax:beforeSend', function(e, xhr, options) {
+ equal('/data/href', options.url)
+ return false
+ })
+ .triggerNative('click')
start()
})
asyncTest('the getter for an element\'s href works normally if not overridden', 1, function() {
- $.rails.ajax = function(options) {
- equal(location.protocol + '//' + location.host + '/real/href', options.url)
- }
- $.rails.handleRemote($('#qunit-fixture').find('a'))
+ $('#qunit-fixture a')
+ .bindNative('ajax:beforeSend', function(e, xhr, options) {
+ equal(location.protocol + '//' + location.host + '/real/href', options.url)
+ return false
+ })
+ .triggerNative('click')
start()
})
-asyncTest('the event selector strings are overridable', 2, function() {
- var documentClickBindings = $._data(document, 'events').click,
- linkClickBinding = $.grep(documentClickBindings, function(a) {
- return a.selector && a.selector.indexOf('a[data-remote]') != -1
- })[0]
-
+asyncTest('the event selector strings are overridable', 1, function() {
ok($.rails.linkClickSelector.indexOf(', a[data-custom-remote-link]') != -1, 'linkClickSelector contains custom selector')
-
- ok(linkClickBinding.selector.indexOf(', a[data-custom-remote-link]') != -1, 'actual document binding contains custom selector')
-
start()
})
-// Not sure why this test isn't working in jquery 1.7,
-// or why the error message doesn't show in the console in 1.8
-// when the test is run.
-//
-//asyncTest("including jquery-ujs multiple times throws error", 1, function() {
-// var script = document.createElement( 'script' )
-// script.type = 'text/javascript'
-// script.src = '/src/rails.js'
-// raises(function() {
-// $("#qunit-fixture").append( script )
-// }, 'appending rails.js again throws error')
-// setTimeout(function() { start() }, 50)
-//})
+asyncTest('including jquery-ujs multiple times throws error', 1, function() {
+ var script = document.createElement('script')
+ script.type = 'text/javascript'
+ script.src = '/rails.js'
+ throws(function() {
+ $('#qunit-fixture').append(script)
+ }, 'appending rails.js again throws error')
+ setTimeout(function() { start() }, 50)
+})
})()
diff --git a/test/views/index.erb b/test/views/index.erb
index 26b6de0b..776a4bab 100644
--- a/test/views/index.erb
+++ b/test/views/index.erb
@@ -1,6 +1,6 @@
<% @title = "jquery-ujs test" %>
-<%= test 'data-confirm', 'data-remote', 'data-disable', 'data-disable-with', 'call-remote', 'call-remote-callbacks', 'data-method', 'csrf-refresh', 'csrf-token' %>
+<%= test 'data-confirm', 'data-remote', 'data-disable', 'data-disable-with', 'call-remote', 'call-remote-callbacks', 'data-method', 'override', 'csrf-refresh', 'csrf-token' %>
From fdd66077987c0c481def38fe4961d565880fb8d7 Mon Sep 17 00:00:00 2001
From: Dangyi Liu
Date: Wed, 24 Aug 2016 12:47:40 +0800
Subject: [PATCH 70/72] Fix a bug that script won't execute upon inserted in
jQuery 2.x.
---
test/public/test/override.js | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/test/public/test/override.js b/test/public/test/override.js
index afccb3d6..be6ec774 100644
--- a/test/public/test/override.js
+++ b/test/public/test/override.js
@@ -47,11 +47,8 @@ asyncTest('the event selector strings are overridable', 1, function() {
})
asyncTest('including jquery-ujs multiple times throws error', 1, function() {
- var script = document.createElement('script')
- script.type = 'text/javascript'
- script.src = '/rails.js'
throws(function() {
- $('#qunit-fixture').append(script)
+ Rails.start()
}, 'appending rails.js again throws error')
setTimeout(function() { start() }, 50)
})
From 46059912050b735c67b82dc77e1a3bb2705018fe Mon Sep 17 00:00:00 2001
From: Dangyi Liu
Date: Sun, 2 Oct 2016 13:12:41 -0700
Subject: [PATCH 71/72] Provide a pre-built version of rails.js
---
.blade.yml | 1 -
dist/.gitignore | 2 -
dist/rails.js | 700 ++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 700 insertions(+), 3 deletions(-)
delete mode 100644 dist/.gitignore
create mode 100644 dist/rails.js
diff --git a/.blade.yml b/.blade.yml
index 79fcd0a0..fe447507 100644
--- a/.blade.yml
+++ b/.blade.yml
@@ -8,4 +8,3 @@ build:
logical_paths:
- rails.js
path: dist
- js_compressor: uglifier
diff --git a/dist/.gitignore b/dist/.gitignore
deleted file mode 100644
index d6b7ef32..00000000
--- a/dist/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*
-!.gitignore
diff --git a/dist/rails.js b/dist/rails.js
new file mode 100644
index 00000000..659af3d7
--- /dev/null
+++ b/dist/rails.js
@@ -0,0 +1,700 @@
+(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) {
+ if (matches(e.target, selector)) {
+ if (handler.call(e.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(e.target)) {
+ 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 = e.target;
+ method = link.getAttribute('data-method');
+ if (!method) {
+ return;
+ }
+ href = Rails.href(link);
+ csrfToken = Rails.csrfToken();
+ csrfParam = Rails.csrfParam();
+ form = document.createElement('form');
+ formContent = "";
+ if ((csrfParam != null) && (csrfToken != null) && !Rails.isCrossDomain(href)) {
+ formContent += "";
+ }
+ formContent += '';
+ 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 = e.target;
+ 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 = e.target;
+ 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 = e.target;
+ 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 = e.target;
+ 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);
From 4214612936e9378c0ebb8e3c24ec1d8b9c99a8a4 Mon Sep 17 00:00:00 2001
From: Dangyi Liu
Date: Tue, 15 Nov 2016 01:14:12 -0800
Subject: [PATCH 72/72] Remove 'uglifier' and 'sprockets-commoner' from Gemfile
Actually we are not using them at all.
---
Gemfile | 2 --
Gemfile.lock | 10 +---------
2 files changed, 1 insertion(+), 11 deletions(-)
diff --git a/Gemfile b/Gemfile
index 3380bfdb..8aadabed 100644
--- a/Gemfile
+++ b/Gemfile
@@ -6,5 +6,3 @@ gem 'shotgun', :group => :reloadable
gem 'thin', :group => :reloadable
gem 'rake'
gem 'blade'
-gem 'uglifier'
-gem 'sprockets-commoner'
diff --git a/Gemfile.lock b/Gemfile.lock
index 6befaafb..447e45da 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -58,7 +58,6 @@ GEM
rack-protection (1.5.3)
rack
rake (11.2.2)
- schmooze (0.1.6)
shotgun (0.9.1)
rack (>= 1.0)
sinatra (1.4.7)
@@ -68,9 +67,6 @@ GEM
sprockets (3.7.0)
concurrent-ruby (~> 1.0)
rack (> 1, < 3)
- sprockets-commoner (0.6.0)
- schmooze (~> 0.1.6)
- sprockets (>= 3, < 4)
sprockets-export (0.9.1)
thin (1.7.0)
daemons (~> 1.0, >= 1.0.9)
@@ -81,8 +77,6 @@ GEM
tilt (2.0.5)
tzinfo (1.2.2)
thread_safe (~> 0.1)
- uglifier (3.0.0)
- execjs (>= 0.3.0, < 3)
useragent (0.16.7)
websocket-driver (0.6.4)
websocket-extensions (>= 0.1.0)
@@ -96,9 +90,7 @@ DEPENDENCIES
rake
shotgun
sinatra (~> 1.0)
- sprockets-commoner
thin
- uglifier
BUNDLED WITH
- 1.12.5
+ 1.13.1