para 0.11.4 → 0.12.0

data/app/javascripts/para/vendor/jquery.js

@@ -0,0 +1,3 @@
+import jQuery from "jquery";
+
+window.$ = window.jQuery = jQuery;

data/app/javascripts/para/vendor/spinbox.js

@@ -0,0 +1,438 @@
+( function( $ ) {
+  /*
+   * Fuel UX Spinbox
+   * https://github.com/ExactTarget/fuelux
+   *
+   * Copyright (c) 2014 ExactTarget
+   * Licensed under the BSD New license.
+   */
+
+
+
+  // -- BEGIN MODULE CODE HERE --
+
+  var old = $.fn.spinbox;
+
+  // SPINBOX CONSTRUCTOR AND PROTOTYPE
+
+  var Spinbox = function( element, options ) {
+    this.$element = $( element );
+    this.$element.find( '.btn' ).on( 'click', function( e ) {
+      //keep spinbox from submitting if they forgot to say type="button" on their spinner buttons
+      e.preventDefault();
+    } );
+    this.options = $.extend( {}, $.fn.spinbox.defaults, options );
+    this.$input = this.$element.find( '.spinbox-input' );
+    this.$element.on( 'focusin.fu.spinbox', this.$input, $.proxy( this.changeFlag, this ) );
+    this.$element.on( 'focusout.fu.spinbox', this.$input, $.proxy( this.change, this ) );
+    this.$element.on( 'keydown.fu.spinbox', this.$input, $.proxy( this.keydown, this ) );
+    this.$element.on( 'keyup.fu.spinbox', this.$input, $.proxy( this.keyup, this ) );
+
+    // this.bindMousewheelListeners();
+    this.mousewheelTimeout = {};
+
+    if ( this.options.hold ) {
+      this.$element.on( 'mousedown.fu.spinbox', '.spinbox-up', $.proxy( function() {
+        this.startSpin( true );
+      }, this ) );
+      this.$element.on( 'mouseup.fu.spinbox', '.spinbox-up, .spinbox-down', $.proxy( this.stopSpin, this ) );
+      this.$element.on( 'mouseout.fu.spinbox', '.spinbox-up, .spinbox-down', $.proxy( this.stopSpin, this ) );
+      this.$element.on( 'mousedown.fu.spinbox', '.spinbox-down', $.proxy( function() {
+        this.startSpin( false );
+      }, this ) );
+    } else {
+      this.$element.on( 'click.fu.spinbox', '.spinbox-up', $.proxy( function() {
+        this.step( true );
+      }, this ) );
+      this.$element.on( 'click.fu.spinbox', '.spinbox-down', $.proxy( function() {
+        this.step( false );
+      }, this ) );
+    }
+
+    this.switches = {
+      count: 1,
+      enabled: true
+    };
+
+    if ( this.options.speed === 'medium' ) {
+      this.switches.speed = 300;
+    } else if ( this.options.speed === 'fast' ) {
+      this.switches.speed = 100;
+    } else {
+      this.switches.speed = 500;
+    }
+
+    this.lastValue = this.options.value;
+
+    this.render();
+
+    if ( this.options.disabled ) {
+      this.disable();
+    }
+  };
+
+  Spinbox.prototype = {
+    constructor: Spinbox,
+
+    destroy: function() {
+      this.$element.remove();
+      // any external bindings
+      // [none]
+      // set input value attrbute
+      this.$element.find( 'input' ).each( function() {
+        $( this ).attr( 'value', $( this ).val() );
+      } );
+      // empty elements to return to original markup
+      // [none]
+      // returns string of markup
+      return this.$element[ 0 ].outerHTML;
+    },
+
+    render: function() {
+      var inputValue = this.parseInput( this.$input.val() );
+      var maxUnitLength = '';
+
+      // if input is empty and option value is default, 0
+      if ( inputValue !== '' && this.options.value === 0 ) {
+        this.value( inputValue );
+      } else {
+        this.output( this.options.value );
+      }
+
+      if ( this.options.units.length ) {
+        $.each( this.options.units, function( index, value ) {
+          if ( value.length > maxUnitLength.length ) {
+            maxUnitLength = value;
+          }
+        } );
+      }
+    },
+
+    output: function( value, updateField ) {
+      value = ( value + '' ).split( '.' ).join( this.options.decimalMark );
+      updateField = ( updateField || true );
+      if ( updateField ) {
+        this.$input.val( value );
+      }
+
+      return value;
+    },
+
+    parseInput: function( value ) {
+      value = ( value + '' ).split( this.options.decimalMark ).join( '.' );
+
+      return value;
+    },
+
+    change: function() {
+      var newVal = this.parseInput( this.$input.val() ) || '';
+
+      if ( this.options.units.length || this.options.decimalMark !== '.' ) {
+        newVal = this.parseValueWithUnit( newVal );
+      } else if ( newVal / 1 ) {
+        newVal = this.options.value = this.checkMaxMin( newVal / 1 );
+      } else {
+        newVal = this.checkMaxMin( newVal.replace( /[^0-9.-]/g, '' ) || '' );
+        this.options.value = newVal / 1;
+      }
+
+      this.output( newVal );
+
+      this.changeFlag = false;
+      this.triggerChangedEvent();
+    },
+
+    changeFlag: function() {
+      this.changeFlag = true;
+    },
+
+    stopSpin: function() {
+      if ( this.switches.timeout !== undefined ) {
+        clearTimeout( this.switches.timeout );
+        this.switches.count = 1;
+        this.triggerChangedEvent();
+      }
+    },
+
+    triggerChangedEvent: function() {
+      var currentValue = this.value();
+      if ( currentValue === this.lastValue ) return;
+      this.lastValue = currentValue;
+
+      // Primary changed event
+      this.$element.trigger( 'changed.fu.spinbox', this.output( currentValue, false ) ); // no DOM update
+    },
+
+    startSpin: function( type ) {
+      if ( !this.options.disabled ) {
+        var divisor = this.switches.count;
+
+        if ( divisor === 1 ) {
+          this.step( type );
+          divisor = 1;
+        } else if ( divisor < 3 ) {
+          divisor = 1.5;
+        } else if ( divisor < 8 ) {
+          divisor = 2.5;
+        } else {
+          divisor = 4;
+        }
+
+        this.switches.timeout = setTimeout( $.proxy( function() {
+          this.iterate( type );
+        }, this ), this.switches.speed / divisor );
+        this.switches.count++;
+      }
+    },
+
+    iterate: function( type ) {
+      this.step( type );
+      this.startSpin( type );
+    },
+
+    step: function( isIncrease ) {
+      // isIncrease: true is up, false is down
+
+      var digits, multiple, currentValue, limitValue;
+
+      // trigger change event
+      if ( this.changeFlag ) {
+        this.change();
+      }
+
+      // get current value and min/max options
+      currentValue = this.options.value;
+      limitValue = isIncrease ? this.options.max : this.options.min;
+
+      if ( ( isIncrease ? currentValue < limitValue : currentValue > limitValue ) ) {
+        var newVal = currentValue + ( isIncrease ? 1 : -1 ) * this.options.step;
+
+        // raise to power of 10 x number of decimal places, then round
+        if ( this.options.step % 1 !== 0 ) {
+          digits = ( this.options.step + '' ).split( '.' )[ 1 ].length;
+          multiple = Math.pow( 10, digits );
+          newVal = Math.round( newVal * multiple ) / multiple;
+        }
+
+        // if outside limits, set to limit value
+        if ( isIncrease ? newVal > limitValue : newVal < limitValue ) {
+          this.value( limitValue );
+        } else {
+          this.value( newVal );
+        }
+
+      } else if ( this.options.cycle ) {
+        var cycleVal = isIncrease ? this.options.min : this.options.max;
+        this.value( cycleVal );
+      }
+    },
+
+    value: function( value ) {
+      if ( value || value === 0 ) {
+        if ( this.options.units.length || this.options.decimalMark !== '.' ) {
+          this.output( this.parseValueWithUnit( value + ( this.unit || '' ) ) );
+          return this;
+
+        } else if ( !isNaN( parseFloat( value ) ) && isFinite( value ) ) {
+          this.options.value = value / 1;
+          this.output( value + ( this.unit ? this.unit : '' ) );
+          return this;
+
+        }
+
+      } else {
+        if ( this.changeFlag ) {
+          this.change();
+        }
+
+        if ( this.unit ) {
+          return this.options.value + this.unit;
+        } else {
+          return this.output( this.options.value, false ); // no DOM update
+        }
+
+      }
+    },
+
+    isUnitLegal: function( unit ) {
+      var legalUnit;
+
+      $.each( this.options.units, function( index, value ) {
+        if ( value.toLowerCase() === unit.toLowerCase() ) {
+          legalUnit = unit.toLowerCase();
+          return false;
+        }
+      } );
+
+      return legalUnit;
+    },
+
+    // strips units and add them back
+    parseValueWithUnit: function( value ) {
+      var unit = value.replace( /[^a-zA-Z]/g, '' );
+      var number = value.replace( /[^0-9.-]/g, '' );
+
+      if ( unit ) {
+        unit = this.isUnitLegal( unit );
+      }
+
+      this.options.value = this.checkMaxMin( number / 1 );
+      this.unit = unit || undefined;
+      return this.options.value + ( unit || '' );
+    },
+
+    checkMaxMin: function( value ) {
+      // if unreadable
+      if ( isNaN( parseFloat( value ) ) ) {
+        return value;
+      }
+
+      // if not within range return the limit
+      if ( !( value <= this.options.max && value >= this.options.min ) ) {
+        value = value >= this.options.max ? this.options.max : this.options.min;
+      }
+
+      return value;
+    },
+
+    disable: function() {
+      this.options.disabled = true;
+      this.$element.addClass( 'disabled' );
+      this.$input.attr( 'disabled', '' );
+      this.$element.find( 'button' ).addClass( 'disabled' );
+    },
+
+    enable: function() {
+      this.options.disabled = false;
+      this.$element.removeClass( 'disabled' );
+      this.$input.removeAttr( 'disabled' );
+      this.$element.find( 'button' ).removeClass( 'disabled' );
+    },
+
+    keydown: function( event ) {
+      var keyCode = event.keyCode;
+      if ( keyCode === 38 ) {
+        this.step( true );
+      } else if ( keyCode === 40 ) {
+        this.step( false );
+      }
+    },
+
+    keyup: function( event ) {
+      var keyCode = event.keyCode;
+
+      if ( keyCode === 38 || keyCode === 40 ) {
+        this.triggerChangedEvent();
+      }
+    },
+
+    bindMousewheelListeners: function() {
+      var inputEl = this.$input.get( 0 );
+      if ( inputEl.addEventListener ) {
+        //IE 9, Chrome, Safari, Opera
+        inputEl.addEventListener( 'mousewheel', $.proxy( this.mousewheelHandler, this ), false );
+        // Firefox
+        inputEl.addEventListener( 'DOMMouseScroll', $.proxy( this.mousewheelHandler, this ), false );
+      } else {
+        // IE <9
+        inputEl.attachEvent( 'onmousewheel', $.proxy( this.mousewheelHandler, this ) );
+      }
+    },
+
+    mousewheelHandler: function( event ) {
+      if ( !this.options.disabled ) {
+        var e = window.event || event; // old IE support
+        var delta = Math.max( -1, Math.min( 1, ( e.wheelDelta || -e.detail ) ) );
+        var self = this;
+
+        clearTimeout( this.mousewheelTimeout );
+        this.mousewheelTimeout = setTimeout( function() {
+          self.triggerChangedEvent();
+        }, 300 );
+
+        if ( delta < 0 ) {
+          this.step( true );
+        } else {
+          this.step( false );
+        }
+
+        if ( e.preventDefault ) {
+          e.preventDefault();
+        } else {
+          e.returnValue = false;
+        }
+
+        return false;
+      }
+    }
+  };
+
+
+  // SPINBOX PLUGIN DEFINITION
+
+  $.fn.spinbox = function( option ) {
+    var args = Array.prototype.slice.call( arguments, 1 );
+    var methodReturn;
+
+    var $set = this.each( function() {
+      var $this = $( this );
+      var data = $this.data( 'fu.spinbox' );
+      var options = typeof option === 'object' && option;
+
+      if ( !data ) {
+        $this.data( 'fu.spinbox', ( data = new Spinbox( this, options ) ) );
+      }
+
+      if ( typeof option === 'string' ) {
+        methodReturn = data[ option ].apply( data, args );
+      }
+    } );
+
+    return ( methodReturn === undefined ) ? $set : methodReturn;
+  };
+
+  // value needs to be 0 for this.render();
+  $.fn.spinbox.defaults = {
+    value: 0,
+    min: 0,
+    max: 999,
+    step: 1,
+    hold: true,
+    speed: 'medium',
+    disabled: false,
+    cycle: false,
+    units: [],
+    decimalMark: '.'
+  };
+
+  $.fn.spinbox.Constructor = Spinbox;
+
+  $.fn.spinbox.noConflict = function() {
+    $.fn.spinbox = old;
+    return this;
+  };
+
+
+  // DATA-API
+
+  $( document ).on( 'mousedown.fu.spinbox.data-api', '[data-initialize=spinbox]', function( e ) {
+    var $control = $( e.target ).closest( '.spinbox' );
+    if ( !$control.data( 'fu.spinbox' ) ) {
+      $control.spinbox( $control.data() );
+    }
+  } );
+
+  // Must be domReady for AMD compatibility
+  $( function() {
+    $( '[data-initialize=spinbox]' ).each( function() {
+      var $this = $( this );
+      if ( !$this.data( 'fu.spinbox' ) ) {
+        $this.spinbox( $this.data() );
+      }
+    } );
+  } );
+
+
+
+} )( jQuery );
+

data/app/javascripts/para/vendor/vertebra.js

@@ -0,0 +1,224 @@
+var _now, delegateEventSplitter, lastUniqueId, uniqueId;
+
+// Global Vertebra namespace
+window.Vertebra = {};
+
+// Allows assigning unique ids to views
+lastUniqueId = 0;
+
+uniqueId = function(prefix) {
+  return [prefix, ++lastUniqueId].join('-');
+};
+
+// Regex to split delegated events string
+delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+window.camelize = function(str) {
+  return str.replace(/(^|[-_])(.)/g, function(match) {
+    return match.toUpperCase();
+  }).replace(/[-_]/g, '');
+};
+
+window.trim = function(str) {
+  return str.replace(/^\s+|\s+$/g, '');
+};
+
+window.isFunction = function(obj) {
+  return !!(obj && obj.constructor && obj.call && obj.apply);
+};
+
+_now = Date.now || function() {
+  return new Date().getTime();
+};
+
+// Throttle function borrowed from underscore.js
+window.throttle = function(func, wait, options) {
+  var later, previous;
+  previous = 0;
+  if (options == null) {
+    options = {};
+  }
+  later = function() {
+    var args, context, result, timeout;
+    previous = options.leading === false ? 0 : _now();
+    timeout = null;
+    result = func.apply(context, args);
+    if (!timeout) {
+      context = args = null;
+    }
+  };
+  return function() {
+    var args, context, now, remaining, result, timeout;
+    now = _now();
+    if (!previous && options.leading === false) {
+      previous = now;
+    }
+    remaining = wait - (now - previous);
+    context = this;
+    args = arguments;
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      previous = now;
+      result = func.apply(context, args);
+      if (!timeout) {
+        context = args = null;
+      }
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(later, remaining);
+    }
+    return result;
+  };
+};
+
+// Minimalist Backbon.View with support for view element, this.$ and delegated
+// events on initialization.
+
+// Only depends on jQuery, and not underscore.js
+window.Vertebra.View = class View {
+  $(selector) {
+    return this.$el.find(selector);
+  }
+
+  constructor(options) {
+    var ref;
+    if (options.el) {
+      this.setElement(options.el);
+    }
+    this._eventListeners = {};
+    this._listeningTo = {};
+    this.cid = uniqueId('view');
+    if ((ref = this.initialize) != null) {
+      ref.apply(this, arguments);
+    }
+  }
+
+  setElement(el) {
+    this.$el = el instanceof $ ? el : $(el);
+    this.el = this.$el[0];
+    return this.delegateEvents();
+  }
+
+  delegateEvents() {
+    var events, key, match, method, results;
+    this._undelegateEvents();
+    if (!this.events) {
+      return;
+    }
+    events = isFunction(this.events) ? this.events() : this.events;
+    results = [];
+    for (key in events) {
+      method = events[key];
+      method = this[method];
+      if (!method) {
+        continue;
+      }
+      match = key.match(delegateEventSplitter);
+      results.push(this.delegate(match[1], match[2], $.proxy(method, this)));
+    }
+    return results;
+  }
+
+  delegate(eventName, selector, listener) {
+    var ref;
+    return (ref = this.$el) != null ? ref.on(eventName + '.delegateEvents' + this.cid, selector, listener) : void 0;
+  }
+
+  _undelegateEvents() {
+    var ref;
+    return (ref = this.$el) != null ? ref.off('.delegateEvents' + this.cid) : void 0;
+  }
+
+  listenTo(object, eventName, listener) {
+    var base, base1, name;
+    if ((base = this._listeningTo)[name = object.cid] == null) {
+      base[name] = {};
+    }
+    if ((base1 = this._listeningTo[object.cid])[eventName] == null) {
+      base1[eventName] = [];
+    }
+    this._listeningTo[object.cid][eventName].push(listener);
+    return object.on(eventName, (() => {
+      return listener.apply(this, arguments);
+    }));
+  }
+
+  on(eventName, listener) {
+    var base;
+    if ((base = this._eventListeners)[eventName] == null) {
+      base[eventName] = [];
+    }
+    return this._eventListeners[eventName].push(listener);
+  }
+
+  off(eventName, listener) {
+    var index, listeners, results;
+    if (!(listeners = this._eventListeners[eventName])) {
+      return;
+    }
+    if (listener) {
+      results = [];
+      for (index in listeners) {
+        if (listeners[index] === listener) {
+          results.push(listeners.splice(index, 1));
+        }
+      }
+      return results;
+    } else {
+      return this._eventListeners[eventName] = [];
+    }
+  }
+
+  trigger(eventName, ...args) {
+    var i, len, listener, listeners, results;
+    if ((listeners = this._eventListeners[eventName])) {
+      results = [];
+      for (i = 0, len = listeners.length; i < len; i++) {
+        listener = listeners[i];
+        results.push(listener.apply(this, args));
+      }
+      return results;
+    }
+  }
+
+  stopListeningTo(object, eventName, listener) {
+    var i, len, listeners, listenersHash, results;
+    if ((listenersHash = this._listeningTo[object.cid]) && (listeners = listenersHash[eventName])) {
+      results = [];
+      for (i = 0, len = listeners.length; i < len; i++) {
+        listener = listeners[i];
+        results.push(object.off(eventName, listener));
+      }
+      return results;
+    }
+  }
+
+  stopListening() {
+    var eventName, events, listeners, object, ref, results;
+    if (!this._listeningTo) {
+      return;
+    }
+    ref = this._listeningTo;
+    results = [];
+    for (object in ref) {
+      events = ref[object];
+      results.push((function() {
+        var results1;
+        results1 = [];
+        for (eventName in events) {
+          listeners = events[eventName];
+          results1.push(this.stopListeningTo(object, eventName, listener));
+        }
+        return results1;
+      }).call(this));
+    }
+    return results;
+  }
+
+  destroy() {
+    return this.stopListening();
+  }
+
+};

data/app/views/admin/para/exporter/bases/_completed.html.haml

@@ -7,5 +7,5 @@
       window.location.href = '#{ job.file.attachment_url }';
 
 = modal.footer do
-  %button.btn.btn-default{ data: { dismiss: 'modal' } }
+  %button.btn.btn-default{ data: { action: 'click->para-admin-modal#closeModal' } }
     = t('para.shared.close')

data/app/views/layouts/para/admin.html.haml

@@ -22,8 +22,10 @@
     = render partial: template_path_lookup('admin/shared/_header', 'para/admin/shared/_header')
 
     .container-fluid.page-content.admin-main-page-content
-      = display_admin_flash
+      = render partial: template_path_lookup('admin/shared/_flash', 'para/admin/shared/_flash')
 
       = yield
 
-    = javascript_include_tag 'para/admin', :'data-turbolinks-eval' => false, :'data-turbolinks-suppress-warning' => true
+    = turbo_frame_tag "para_admin_modal", data: { controller: "para-admin-modal" }
+    
+    = javascript_include_tag 'para/admin', :'data-turbo-eval' => false, :'data-turbo-suppress-warning' => true

data/app/views/para/admin/imports/new.html.haml

@@ -1,14 +1,15 @@
-= modal id: "component-import-#{ @importer.model_name.route_key }" do |modal|
-  = modal.header do
-    = @importer.model_name.human
+= turbo_frame_tag "para_admin_modal" do
+  = modal id: "component-import-#{ @importer.model_name.route_key }" do |modal|
+    = modal.header do
+      = @importer.model_name.human
 
-  = simple_form_for @file, as: :file, url: @component.path(namespace: :imports, importer: @importer.name), remote: true do |form|
-    = modal.body do
-      %p= t('para.import.help_text')
+    = simple_form_for @file, as: :file, url: @component.path(namespace: :imports, importer: @importer.name), remote: true do |form|
+      = modal.body do
+        %p= t('para.import.help_text')
 
-      = form.input :attachment, label: false, placeholder: t('para.import.placeholder')
+        = form.input :attachment, label: false, placeholder: t('para.import.placeholder')
 
-      = modal.footer do
-        %button.btn.btn-primary.btn-shadow{ type: 'submit' }
-          %i.fa.fa-upload.fa-fw
-          = t('para.import.name')
+        = modal.footer do
+          %button.btn.btn-primary.btn-shadow{ type: 'submit' }
+            %i.fa.fa-upload.fa-fw
+            = t('para.import.name')