actionview 5.0.7.2 → 5.1.0.beta1

data/lib/action_view/template/text.rb

@@ -4,19 +4,16 @@ module ActionView #:nodoc:
     class Text #:nodoc:
       attr_accessor :type
 
-      def initialize(string, type = nil)
+      def initialize(string)
         @string = string.to_s
-        @type   = Types[type] || type if type
-        @type ||= Types[:text]
+        @type = Types[:text]
       end
 
       def identifier
-        'text template'
+        "text template"
       end
 
-      def inspect
-        'text template'
-      end
+      alias_method :inspect, :identifier
 
       def to_str
         @string
@@ -27,7 +24,7 @@ module ActionView #:nodoc:
       end
 
       def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
+        [@type.ref]
       end
     end
   end

data/lib/action_view/template/types.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/module/attribute_accessors'
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
   class Template

data/lib/action_view/test_case.rb

@@ -1,9 +1,9 @@
-require 'active_support/core_ext/module/remove_method'
-require 'action_controller'
-require 'action_controller/test_case'
-require 'action_view'
+require "active_support/core_ext/module/remove_method"
+require "action_controller"
+require "action_controller/test_case"
+require "action_view"
 
-require 'rails-dom-testing'
+require "rails-dom-testing"
 
 module ActionView
   # = Action View Test Case
@@ -18,16 +18,16 @@ module ActionView
       end
 
       def controller_path=(path)
-        self.class.controller_path=(path)
+        self.class.controller_path = (path)
       end
 
       def initialize
         super
         self.class.controller_path = ""
-        @request = ActionController::TestRequest.create
+        @request = ActionController::TestRequest.create(self.class)
         @response = ActionDispatch::TestResponse.new
 
-        @request.env.delete('PATH_INFO')
+        @request.env.delete("PATH_INFO")
         @params = ActionController::Parameters.new
       end
     end
@@ -49,7 +49,7 @@ module ActionView
 
       include ActiveSupport::Testing::ConstantLookup
 
-      delegate :lookup_context, :to => :controller
+      delegate :lookup_context, to: :controller
       attr_accessor :controller, :output_buffer, :rendered
 
       module ClassMethods
@@ -96,7 +96,6 @@ module ActionView
           helper(helper_class) if helper_class
           include _helpers
         end
-
       end
 
       def setup_with_controller
@@ -104,8 +103,8 @@ module ActionView
         @request = @controller.request
         # empty string ensures buffer has UTF-8 encoding as
         # new without arguments returns ASCII-8BIT encoded buffer like String#new
-        @output_buffer = ActiveSupport::SafeBuffer.new ''
-        @rendered = ''
+        @output_buffer = ActiveSupport::SafeBuffer.new ""
+        @rendered = ""
 
         make_test_case_available_to_view!
         say_no_to_protect_against_forgery!
@@ -125,6 +124,10 @@ module ActionView
         @_rendered_views ||= RenderedViewsCollection.new
       end
 
+      def _routes
+        @controller._routes if @controller.respond_to?(:_routes)
+      end
+
       # Need to experiment if this priority is the best one: rendered => output_buffer
       class RenderedViewsCollection
         def initialize
@@ -146,7 +149,7 @@ module ActionView
 
         def view_rendered?(view, expected_locals)
           locals_for(view).any? do |actual_locals|
-            expected_locals.all? {|key, value| value == actual_locals[key] }
+            expected_locals.all? { |key, value| value == actual_locals[key] }
           end
         end
       end
@@ -207,8 +210,8 @@ module ActionView
           view = @controller.view_context
           view.singleton_class.include(_helpers)
           view.extend(Locals)
-          view.rendered_views = self.rendered_views
-          view.output_buffer = self.output_buffer
+          view.rendered_views = rendered_views
+          view.output_buffer = output_buffer
           view
         end
       end
@@ -259,10 +262,6 @@ module ActionView
         end]
       end
 
-      def _routes
-        @controller._routes if @controller.respond_to?(:_routes)
-      end
-
       def method_missing(selector, *args)
         begin
           routes = @controller.respond_to?(:_routes) && @controller._routes
@@ -271,8 +270,8 @@ module ActionView
         end
 
         if routes &&
-           ( routes.named_routes.route_defined?(selector) ||
-             routes.mounted_helpers.method_defined?(selector) )
+           (routes.named_routes.route_defined?(selector) ||
+             routes.mounted_helpers.method_defined?(selector))
           @controller.__send__(selector, *args)
         else
           super

data/lib/action_view/testing/resolvers.rb

@@ -1,4 +1,4 @@
-require 'action_view/template/resolver'
+require "action_view/template/resolver"
 
 module ActionView #:nodoc:
   # Use FixtureResolver in your tests to simulate the presence of files on the
@@ -8,46 +8,45 @@ module ActionView #:nodoc:
   class FixtureResolver < PathResolver
     attr_reader :hash
 
-    def initialize(hash = {}, pattern=nil)
+    def initialize(hash = {}, pattern = nil)
       super(pattern)
       @hash = hash
     end
 
     def to_s
-      @hash.keys.join(', ')
+      @hash.keys.join(", ")
     end
 
-  private
-
-    def query(path, exts, formats, _)
-      query = ""
-      EXTENSIONS.each_key do |ext|
-        query << '(' << exts[ext].map {|e| e && Regexp.escape(".#{e}") }.join('|') << '|)'
-      end
-      query = /^(#{Regexp.escape(path)})#{query}$/
-
-      templates = []
-      @hash.each do |_path, array|
-        source, updated_at = array
-        next unless _path =~ query
-        handler, format, variant = extract_handler_and_format_and_variant(_path, formats)
-        templates << Template.new(source, _path, handler,
-          :virtual_path => path.virtual,
-          :format => format,
-          :variant => variant,
-          :updated_at => updated_at
-        )
+    private
+
+      def query(path, exts, _, _)
+        query = ""
+        EXTENSIONS.each_key do |ext|
+          query << "(" << exts[ext].map { |e| e && Regexp.escape(".#{e}") }.join("|") << "|)"
+        end
+        query = /^(#{Regexp.escape(path)})#{query}$/
+
+        templates = []
+        @hash.each do |_path, array|
+          source, updated_at = array
+          next unless query.match?(_path)
+          handler, format, variant = extract_handler_and_format_and_variant(_path)
+          templates << Template.new(source, _path, handler,
+            virtual_path: path.virtual,
+            format: format,
+            variant: variant,
+            updated_at: updated_at
+          )
+        end
+
+        templates.sort_by { |t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
       end
-
-      templates.sort_by {|t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
-    end
   end
 
   class NullResolver < PathResolver
-    def query(path, exts, formats, _)
-      handler, format, variant = extract_handler_and_format_and_variant(path, formats)
-      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, :virtual_path => path.virtual, :format => format, :variant => variant)]
+    def query(path, exts, _, _)
+      handler, format, variant = extract_handler_and_format_and_variant(path)
+      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: format, variant: variant)]
     end
   end
 end
-

data/lib/action_view/version.rb

@@ -1,4 +1,4 @@
-require_relative 'gem_version'
+require_relative "gem_version"
 
 module ActionView
   # Returns the version of the currently loaded ActionView as a <tt>Gem::Version</tt>

data/lib/action_view/view_paths.rb

@@ -5,11 +5,11 @@ module ActionView
     included do
       class_attribute :_view_paths
       self._view_paths = ActionView::PathSet.new
-      self._view_paths.freeze
+      _view_paths.freeze
     end
 
     delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
-             :locale, :locale=, :to => :lookup_context
+             :locale, :locale=, to: :lookup_context
 
     module ClassMethods
       def _prefixes # :nodoc:
@@ -22,11 +22,11 @@ module ActionView
 
       private
 
-      # Override this method in your controller if you want to change paths prefixes for finding views.
-      # Prefixes defined here will still be added to parents' <tt>._prefixes</tt>.
-      def local_prefixes
-        [controller_path]
-      end
+        # Override this method in your controller if you want to change paths prefixes for finding views.
+        # Prefixes defined here will still be added to parents' <tt>._prefixes</tt>.
+        def local_prefixes
+          [controller_path]
+        end
     end
 
     # The prefixes used in render "foo" shortcuts.
@@ -43,13 +43,25 @@ module ActionView
     end
 
     def details_for_lookup
-      { }
+      {}
     end
 
+    # Append a path to the list of view paths for the current <tt>LookupContext</tt>.
+    #
+    # ==== Parameters
+    # * <tt>path</tt> - If a String is provided, it gets converted into
+    #   the default view path. You may also provide a custom view path
+    #   (see ActionView::PathSet for more information)
     def append_view_path(path)
       lookup_context.view_paths.push(*path)
     end
 
+    # Prepend a path to the list of view paths for the current <tt>LookupContext</tt>.
+    #
+    # ==== Parameters
+    # * <tt>path</tt> - If a String is provided, it gets converted into
+    #   the default view path. You may also provide a custom view path
+    #   (see ActionView::PathSet for more information)
     def prepend_view_path(path)
       lookup_context.view_paths.unshift(*path)
     end

data/lib/assets/compiled/rails-ujs.js

@@ -0,0 +1,648 @@
+(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',
+    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);
+(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 (error) {}
+      } 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 (error) {}
+      }
+    }
+    return response;
+  };
+
+  Rails.href = function(element) {
+    return element.href;
+  };
+
+  Rails.isCrossDomain = function(url) {
+    var e, 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.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {
+        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));
+    }
+  };
+
+}).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 (error) {}
+      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, 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, 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.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;
+
+  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, 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('rails-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', 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);