kea-rails 1.0.0

data/app/assets/javascripts/kea/extenders/min_length.js

@@ -0,0 +1,39 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.minLength = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: "",
+        length: 0,
+        allowBlank: false
+      };
+
+      options = $.extend({}, defaults, options);
+   
+      target.validate = function validate(newValue, newComparisonValue) {
+        var validatableValue  = typeof newValue === 'undefined' ? target() : newValue;
+
+        if (options.allowBlank && (!validatableValue || validatableValue === '')) {
+          target.markValid();
+          
+          return !target.hasError();
+        }
+
+        if (typeof validatableValue !== 'undefined' && validatableValue.length >= options.length) {
+          target.markValid();
+        } else {
+          target.markInvalid(options.message);
+        }
+
+        return !target.hasError();
+      };
+   
+      target.subscribe(target.validate);
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);

data/app/assets/javascripts/kea/extenders/numeric_range.js

@@ -0,0 +1,64 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.numericRange = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: "",
+        allowBlank: true,
+        requiredMessage: "",
+        if: null,
+        dependencies: []
+      };
+
+      options = $.extend({}, defaults, options);
+   
+      target.validate = function validate(newValue) {
+        var validatableValue = typeof newValue === 'undefined' ? target() : newValue;
+
+        validatableValue = parseInt(validatableValue, 10);
+
+        if (typeof options.if === 'function' && options.if() === false) {
+          target.markValid();
+          return true;
+        }
+
+        if (!validatableValue && !options.allowBlank) {
+          target.markInvalid(options.requiredMessage);
+          return false;
+        }
+
+        if (typeof options.min !== 'undefined' && validatableValue < options.min) {
+          target.markInvalid(options.message);
+          return false;
+        }
+
+        if (typeof options.max !== 'undefined' && validatableValue > options.max) {
+          target.markInvalid(options.message);
+          return false;
+        }
+
+        target.markValid();
+        return true;
+      };
+   
+      target.subscribe(target.validate);
+      
+      if (ko.isObservable(options.if)) {
+        options.dependencies.push(options.if);
+      }
+      
+      ko.utils.arrayForEach(options.dependencies, function(dependency) {
+        dependency.subscribe(function(newValue) {
+          if (!target.isUnvalidated()) {
+            target.validate();
+          }
+        });
+      });
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);

data/app/assets/javascripts/kea/extenders/required.js

@@ -0,0 +1,39 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.required = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: "",
+        validate_if: null
+      };
+
+      options = $.extend({}, defaults, options);
+      
+      target.isRequired = true;
+   
+      target.validate = function validate(newValue) {
+        if (typeof options.validate_if === 'function' && !options.validate_if()) {
+          target.markValid();
+          return true;
+        }
+        
+        var validatableValue = typeof newValue === 'undefined' ? target() : newValue;
+
+        if (validatableValue) {
+          target.markValid();
+        } else {
+          target.markInvalid(options.message);
+        }
+
+        return !target.hasError();
+      };
+   
+      target.subscribe(target.validate);
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);

data/app/assets/javascripts/kea/extenders/valid_date.js

@@ -0,0 +1,32 @@
+(function(ko, $, moment) {
+  "use strict";
+
+  ko.extenders.validDate = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: ""
+      };
+
+      options = $.extend({}, defaults, options);
+   
+      target.validate = function validate(newValue) {
+        var validatableValue  = typeof newValue === 'undefined' ? target() : newValue,
+            m                 = moment(validatableValue, ["DD MM", "DD MM YY", "DD MM YYYY"]);
+
+        if ( m === null || !m.isValid() || m.isBefore(moment().startOf('day')) ) {
+          target.markInvalid(options.message);
+          return false;
+        }
+
+        target.markValid();
+        return true;
+      };
+   
+      target.subscribe(target.validate);
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $, moment);

data/app/assets/javascripts/kea/extenders/valid_time.js

@@ -0,0 +1,41 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.validTime = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: ""
+      };
+
+      options = $.extend({}, defaults, options);
+   
+      target.validate = function validate(newValue) {
+        var validatableValue = typeof newValue === 'undefined' ? target() : newValue,
+            hour,
+            minute;
+
+        if (validatableValue.indexOf(':') === -1) {
+          target.markInvalid(options.message);
+          return false;
+        }
+
+        hour    = parseInt(validatableValue.split(':')[0], 10);
+        minute  = parseInt(validatableValue.split(':')[1], 10);
+
+        if ( (hour < 0 || hour > 23) || (minute < 0 || minute > 59) ) {
+          target.markInvalid(options.message);
+          return false;
+        }
+
+        target.markValid();
+        return true;
+      };
+   
+      target.subscribe(target.validate);
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);

data/app/assets/javascripts/kea/extenders/validator_base.js

@@ -0,0 +1,75 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.utils.validatorBase = function(target) {
+    if (typeof target.isValidatable === 'undefined') {
+      target.isValidatable = true;
+    }
+
+    if (typeof target.hasError === 'undefined') {
+      target.hasError = ko.observable();
+    }
+
+    if (typeof target.isUnvalidated === 'undefined') {
+      target.isUnvalidated = ko.observable(true);
+    }
+
+    if (typeof target.validationInProgress === 'undefined') {
+      target.validationInProgress = ko.observable(false);
+    }
+
+    if (typeof target.onNextValidationChange === 'undefined') {
+      target.onNextValidationChange = null;
+    }
+
+    if (typeof target.validationMessage === 'undefined') {
+      target.validationMessage = ko.observable();
+    }
+    
+    if (typeof target.forceValidate === 'undefined') {
+      target.forceValidate = function forceValidate() {
+        var args = Array.prototype.slice.call(arguments);
+        
+        target.validate.apply(target, args);
+      };
+    }
+
+    if (typeof target.markValid === 'undefined') {
+      target.markValid = function markValid() {
+        var hadError        = target.hasError(),
+            wasUnvalidated  = target.isUnvalidated();
+
+        target.hasError(false);
+
+        if (target.isUnvalidated()) {
+          target.isUnvalidated(false);
+        }
+
+        if ((hadError || wasUnvalidated) && target.onNextValidationChange) {
+          target.onNextValidationChange(true);
+          target.onNextValidationChange = null;
+        }
+      };
+    }
+
+    if (typeof target.markInvalid === 'undefined') {
+      target.markInvalid = function markInvalid(message) {
+        var hadError        = target.hasError(),
+            wasUnvalidated  = target.isUnvalidated();
+
+        target.hasError(true);
+        target.validationMessage(message);
+
+        if (target.isUnvalidated()) {
+          target.isUnvalidated(false);
+        }
+
+        if ((!hadError || wasUnvalidated) && target.onNextValidationChange) {
+          target.onNextValidationChange(false);
+          target.onNextValidationChange = null;
+        }
+      };
+    }
+  };
+
+})(ko, $);

data/app/assets/javascripts/kea/helpers/kea.activity_button.js

@@ -0,0 +1,97 @@
+
+// Expose plugin as an AMD module if AMD loader is present:
+(function (factory) {
+  'use strict';
+
+  if (typeof define === 'function' && define.amd) {
+    define(['jquery'], factory);
+  } else {
+    factory(jQuery);
+  }
+
+}(function ($) {
+  'use strict';
+
+  function ActivityButton(button) {
+    this.$button    = $(button);
+    this.isOn       = false;
+    this.iconCache  = null;
+  }
+
+  ActivityButton.prototype = (function() {
+
+    var on, off, active;
+
+    on = function on() {
+      if (this.isOn) {
+        return false;
+      }
+
+      var existingIcon = this.$button.find('[class^="icon-"]');
+
+      if (existingIcon.length > 0) {
+        this.iconCache = existingIcon.remove();
+      }
+
+      this.$button.prepend("<i class='icon-spin3 animate-spin'></i>");
+
+      this.isOn = true;
+    };
+
+    off = function off() {
+      if (!this.isOn) {
+        return false;
+      }
+
+      this.$button.find('.icon-spin3').remove();
+
+      if (this.iconCache) {
+        this.$button.prepend(this.iconCache);
+        this.iconCache = null;
+      }
+
+      this.isOn = false;
+    };
+    
+    active = function active() {
+      return this.isOn;
+    };
+
+    return {
+      on: on,
+      off: off,
+      active: active
+    };
+  })();
+
+  // Create chainable jQuery plugin:
+  $.fn.activityButton = function (optionsOrFnName, args) {
+    var dataKey = 'activityButton';
+
+    // If function invoked without argument return
+    // instance of the first matched element
+    if (arguments.length === 0 && this.first().data(dataKey)) {
+      return this.first().data(dataKey);
+    }
+
+    return this.each(function () {
+      var inputElement  = $(this),
+          instance      = inputElement.data(dataKey);
+
+      if (typeof optionsOrFnName === 'string') {
+        if (instance && typeof instance[optionsOrFnName] === 'function') {
+          instance[optionsOrFnName](args);
+        }
+
+      } else {
+        // If instance already exists, destroy it:
+        if (instance && instance.dispose) {
+          instance.dispose();
+        }
+
+        instance = new ActivityButton(this, optionsOrFnName);
+        inputElement.data(dataKey, instance);
+      }
+    });
+  };
+}));

data/app/assets/javascripts/kea/helpers/kea.notify.js

@@ -0,0 +1,46 @@
+window.kea.notify = (function() {
+  "use strict";
+  
+  var addNotificationToDom,
+      displayNotifications,
+      notify,
+      notifications = {};
+
+  addNotificationToDom = function addNotificationToDom(text, type) {
+    var clickToClose  = true,
+        timeout       = 4000,
+        cssClass      = 'humane-original-info';
+
+    if (type === 'alert' || type === 'error') {
+      timeout   = 0;
+      cssClass  = 'humane-original-error';
+    }
+
+    humane.log(text, { baseCls: 'humane-original', timeout: timeout, clickToClose: clickToClose, addnCls: cssClass });
+  };
+
+  displayNotifications = function displayNotifications() {
+    if (!$.isReady) {
+      return;
+    }
+
+    $.each(notifications, function(type, notificationsForType) {
+      $.each(notificationsForType, function(idx, text) {
+        addNotificationToDom(text, type);
+      });
+
+      notifications[type] = [];
+    });
+  };
+
+  notify = function notify(text, type) {
+    if (typeof notifications[type] === 'undefined') {
+      notifications[type] = [];
+    }
+
+    notifications[type].push(text);
+    displayNotifications();
+  };
+
+  return notify;
+})();

data/app/assets/javascripts/kea/initializers/base.js

@@ -0,0 +1,11 @@
+(function(app, ko, $) {
+  "use strict";
+
+  app.initialize_on = function initialize_on() {
+    var selectors = Array.prototype.slice.call(arguments),
+        callback  = selectors.pop();
+    
+    app.initializers.push({selectors: selectors, callback: callback});
+  };
+})(window.app, ko, $);
+

data/app/assets/javascripts/kea/kea.js

@@ -0,0 +1,14 @@
+//= require_directory ./bindings
+//= require_directory ./extenders
+//= require ./models/base
+//= require ./services/base
+//= require ./viewmodels/base
+
+//= require ./overlay/overlay_control
+//= require ./overlay/overlay_template
+//= require ./overlay/child_vm_overlay
+
+//= require ./viewmodels/sherlock
+//= require ./sherlock/base_provider
+
+//= require ./initializers/base

data/app/assets/javascripts/kea/kea_dependencies.js

@@ -0,0 +1,20 @@
+//= require knockout-3.2.0-debug
+
+//= require_directory ../../../../vendor/assets/javascripts/.
+
+// Bower components
+
+//= require attachejs/attache
+//= require attachejs/attache-jquery
+//= require veiljs/veil
+//= require veiljs/veil-jquery
+//= require uri.js/src/URI.js
+//= require knockout-sortable/build/knockout-sortable
+//= require humane-js/humane
+//= require Keypress/keypress.js
+
+//= require ./kea_init
+
+// Internal helpers and plugins
+
+//= require_directory ./helpers

data/app/assets/javascripts/kea/kea_init.js

@@ -0,0 +1,24 @@
+window.kea            = window.kea || {};
+window.kea.models     = window.kea.models || {};
+window.kea.services   = window.kea.services || {};
+window.kea.viewmodels = window.kea.viewmodels || {};
+
+window.kea.sherlock = {
+  providers: []
+};
+
+window.kea.u = {
+  inherit: function inherit(Child, Parent) {
+    "use strict";
+
+    Child.super_ = Parent;
+    Child.prototype = Object.create(Parent.prototype, {
+      constructor: {
+        value: Child,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  }
+};