5 files changed, 249 insertions, 0 deletions
diff --git a/actionview/app/assets/javascripts/utils/ajax.coffee b/actionview/app/assets/javascripts/utils/ajax.coffee
new file mode 100644
index 0000000000..9af515beda
--- /dev/null
+++ b/actionview/app/assets/javascripts/utils/ajax.coffee
@@ -0,0 +1,95 @@
+#= require ./csrf
+#= require ./event
+
+{ CSRFProtection, fire } = Rails
+
+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 = (options) ->
+  options = prepareOptions(options)
+  xhr = createXHR options, ->
+    response = processResponse(xhr.response, xhr.getResponseHeader('Content-Type'))
+    if xhr.status // 100 == 2
+      options.success?(response, xhr.statusText, xhr)
+    else
+      options.error?(response, xhr.statusText, xhr)
+    options.complete?(xhr, xhr.statusText)
+  # Call beforeSend hook
+  options.beforeSend?(xhr, options)
+  # Send the request
+  if xhr.readyState is XMLHttpRequest.OPENED
+    xhr.send(options.data)
+  else
+    fire(document, 'ajaxStop') # to be compatible with jQuery.ajax
+
+prepareOptions = (options) ->
+  options.type = options.type.toUpperCase()
+  # append data to url if it's a GET request
+  if options.type is 'GET' and options.data
+    if options.url.indexOf('?') < 0
+      options.url += '?' + options.data
+    else
+      options.url += '&' + options.data
+  # Use "*" as default dataType
+  options.dataType = '*' unless AcceptHeaders[options.dataType]?
+  options.accept = AcceptHeaders[options.dataType]
+  options.accept += ', */*; q=0.01' if options.dataType isnt '*'
+  options
+
+createXHR = (options, done) ->
+  xhr = new XMLHttpRequest()
+  # Open and setup xhr
+  xhr.open(options.type, options.url, true)
+  xhr.setRequestHeader('Accept', options.accept)
+  # Set Content-Type only when sending a string
+  # Sending FormData will automatically set Content-Type to multipart/form-data
+  if typeof options.data is 'string'
+    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8')
+  xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest') unless options.crossDomain
+  # Add X-CSRF-Token
+  CSRFProtection(xhr)
+  xhr.withCredentials = !!options.withCredentials
+  xhr.onreadystatechange = ->
+    done(xhr) if xhr.readyState is XMLHttpRequest.DONE
+  xhr
+
+processResponse = (response, type) ->
+  if typeof response is 'string' and typeof type is 'string'
+    if type.match(/\bjson\b/)
+      try response = JSON.parse(response)
+    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(/;.+/, '') # remove something like ';charset=utf-8'
+      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) ->
+  originAnchor = document.createElement('a')
+  originAnchor.href = location.href
+  urlAnchor = document.createElement('a')
+  try
+    urlAnchor.href = url
+    # If URL protocol is false or is a string containing a single colon
+    # *and* host are false, assume it is not a cross-domain request
+    # (should only be the case for IE7 and IE compatibility mode).
+    # Otherwise, evaluate protocol and host of the URL against the origin
+    # protocol and host.
+    !(((!urlAnchor.protocol || urlAnchor.protocol == ':') && !urlAnchor.host) ||
+      (originAnchor.protocol + '//' + originAnchor.host == urlAnchor.protocol + '//' + urlAnchor.host))
+  catch e
+    # If there is an error parsing the URL, assume it is crossDomain.
+    true
diff --git a/actionview/app/assets/javascripts/utils/csrf.coffee b/actionview/app/assets/javascripts/utils/csrf.coffee
new file mode 100644
index 0000000000..4eb5ebb414
--- /dev/null
+++ b/actionview/app/assets/javascripts/utils/csrf.coffee
@@ -0,0 +1,25 @@
+#= require ./dom
+
+{ $ } = Rails
+
+# Up-to-date Cross-Site Request Forgery token
+csrfToken = Rails.csrfToken = ->
+  meta = document.querySelector('meta[name=csrf-token]')
+  meta and meta.content
+
+# URL param that must contain the CSRF token
+csrfParam = Rails.csrfParam = ->
+  meta = document.querySelector('meta[name=csrf-param]')
+  meta and meta.content
+
+# Make sure that every Ajax request sends the CSRF token
+Rails.CSRFProtection = (xhr) ->
+  token = csrfToken()
+  xhr.setRequestHeader('X-CSRF-Token', token) if token?
+
+# Make sure that all forms have actual up-to-date tokens (cached forms contain old ones)
+Rails.refreshCSRFTokens = ->
+  token = csrfToken()
+  param = csrfParam()
+  if token? and param?
+    $('form input[name="' + param + '"]').forEach (input) -> input.value = token
diff --git a/actionview/app/assets/javascripts/utils/dom.coffee b/actionview/app/assets/javascripts/utils/dom.coffee
new file mode 100644
index 0000000000..6bef618147
--- /dev/null
+++ b/actionview/app/assets/javascripts/utils/dom.coffee
@@ -0,0 +1,28 @@
+m = Element.prototype.matches or
+    Element.prototype.matchesSelector or
+    Element.prototype.mozMatchesSelector or
+    Element.prototype.msMatchesSelector or
+    Element.prototype.oMatchesSelector or
+    Element.prototype.webkitMatchesSelector
+
+Rails.matches = (element, selector) ->
+  if selector.exclude?
+    m.call(element, selector.selector) and not m.call(element, selector.exclude)
+  else
+    m.call(element, selector)
+
+# get and set data on a given element using "expando properties"
+# See: https://developer.mozilla.org/en-US/docs/Glossary/Expando
+expando = '_ujsData'
+
+Rails.getData = (element, key) ->
+  element[expando]?[key]
+
+Rails.setData = (element, key, value) ->
+  element[expando] ?= {}
+  element[expando][key] = value
+
+# a wrapper for document.querySelectorAll
+# returns an Array
+Rails.$ = (selector) ->
+  Array.prototype.slice.call(document.querySelectorAll(selector))
diff --git a/actionview/app/assets/javascripts/utils/event.coffee b/actionview/app/assets/javascripts/utils/event.coffee
new file mode 100644
index 0000000000..049b2a3ecd
--- /dev/null
+++ b/actionview/app/assets/javascripts/utils/event.coffee
@@ -0,0 +1,40 @@
+#= require ./dom
+
+{ matches } = Rails
+
+# Polyfill for CustomEvent in IE9+
+# https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent#Polyfill
+CustomEvent = window.CustomEvent
+
+if typeof CustomEvent is 'function'
+  CustomEvent = (event, params) ->
+    evt = document.createEvent('CustomEvent')
+    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail)
+    evt
+  CustomEvent.prototype = window.Event.prototype
+
+# Triggers an custom event on an element and returns false if the event result is false
+fire = Rails.fire = (obj, name, data) ->
+  event = new CustomEvent(
+    name,
+    bubbles: true,
+    cancelable: true,
+    detail: data,
+  )
+  obj.dispatchEvent(event)
+  !event.defaultPrevented
+
+# Helper function, needed to provide consistent behavior in IE
+Rails.stopEverything = (e) ->
+  fire(e.target, 'ujs:everythingStopped')
+  e.preventDefault()
+  e.stopPropagation()
+  e.stopImmediatePropagation()
+
+Rails.delegate = (element, selector, eventType, handler) ->
+  element.addEventListener eventType, (e) ->
+    target = e.target
+    target = target.parentNode until not (target instanceof Element) or matches(target, selector)
+    if target instanceof Element and handler.call(target, e) == false
+      e.preventDefault()
+      e.stopPropagation()
diff --git a/actionview/app/assets/javascripts/utils/form.coffee b/actionview/app/assets/javascripts/utils/form.coffee
new file mode 100644
index 0000000000..251113deda
--- /dev/null
+++ b/actionview/app/assets/javascripts/utils/form.coffee
@@ -0,0 +1,61 @@
+#= require ./dom
+
+{ matches } = Rails
+
+toArray = (e) -> Array.prototype.slice.call(e)
+
+Rails.serializeElement = (element, additionalParam) ->
+  inputs = [element]
+  inputs = toArray(element.elements) if matches(element, 'form')
+  params = []
+
+  inputs.forEach (input) ->
+    return unless input.name
+    if matches(input, 'select')
+      toArray(input.options).forEach (option) ->
+        params.push(name: input.name, value: option.value) if option.selected
+    else if input.type isnt 'radio' and input.type isnt 'checkbox' or input.checked
+      params.push(name: input.name, value: input.value)
+
+  params.push(additionalParam) if additionalParam
+
+  params.map (param) ->
+    if param.name?
+      "#{encodeURIComponent(param.name)}=#{encodeURIComponent(param.value)}"
+    else
+      param
+  .join('&')
+
+# Helper function that returns form elements that match the specified CSS selector
+# If form is actually a "form" element this will return associated elements outside the from that have
+# the html form attribute set
+Rails.formElements = (form, selector) ->
+  if matches(form, 'form')
+    toArray(form.elements).filter (el) -> matches(el, selector)
+  else
+    toArray(form.querySelectorAll(selector))
+
+# Helper function which checks for blank inputs in a form that match the specified CSS selector
+Rails.blankInputs = (form, selector, nonBlank) ->
+  foundInputs = []
+  requiredInputs = toArray(form.querySelectorAll(selector or 'input, textarea'))
+  checkedRadioButtonNames = {}
+
+  requiredInputs.forEach (input) ->
+    if input.type is 'radio'
+      # Don't count unchecked required radio as blank if other radio with same name is checked,
+      # regardless of whether same-name radio input has required attribute or not. The spec
+      # states https://www.w3.org/TR/html5/forms.html#the-required-attribute
+      radioName = input.name
+      # Skip if we've already seen the radio with this name.
+      unless checkedRadioButtonNames[radioName]
+        # If none checked
+        if form.querySelectorAll("input[type=radio][name='#{radioName}']:checked").length == 0
+          radios = form.querySelectorAll("input[type=radio][name='#{radioName}']")
+          foundInputs = foundInputs.concat(toArray(radios))
+        # We only need to check each name once.
+        checkedRadioButtonNames[radioName] = radioName
+    else
+      valueToCheck = if input.type is 'checkbox' then input.checked else !!input.value
+      foundInputs.push(input) if valueToCheck is nonBlank
+  foundInputs