kea-rails 1.0.0

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

@@ -0,0 +1,215 @@
+(function(app, kea, ko) {
+  "use strict";
+
+  var Base,
+      Validatable;
+
+  Base = function Base() {
+
+  };
+
+  Base.prototype._modelName = function _modelName() {
+    console.error("Model does not implement _modelName");
+  };
+
+  Base.prototype.service = function service() {
+    if (DEBUG) {
+      console.assert(app.services[ this._modelName() ], this._modelName() + " service does not exist");
+    }
+
+    return app.services[ this._modelName() ];
+  };
+
+  Base.prototype.fromJSON = function fromJSON(json) {
+    console.error("object does not implement fromJSON: %O", this);
+  };
+
+  Base.prototype.serialize = function serialize() {
+    console.error("object does not implement serialize: %O", this);
+  };
+
+  Base.prototype.update = function update(params) {
+    var that = this,
+        deferred;
+
+    deferred = this.service()
+      .update(that, params)
+      .done(function(data) {
+        that.fromJSON(data);
+      });
+
+    return deferred;
+  };
+
+  Base.prototype.destroy = function destroy() {
+    return $.ajax({
+      type:     'DELETE',
+      url:      this.resource_path,
+      dataType: 'JSON'
+
+    }).fail(function(jqXHR, textStatus) {
+      window.kea.notify(textStatus, 'error');
+
+    });
+  };
+
+  kea.models.Base = Base;
+
+  Validatable = function Validatable() {
+    var that = this;
+
+    this.isValidatable = ko.observable(false);
+
+    this.makeValidatable = function makeValidatable() {
+      if (DEBUG) {
+        console.assert(this.attachValidators, "object does not implement attachValidators");
+      }
+
+      this.attachValidators();
+      this.isValidatable(true);
+    };
+
+    this.validatableFields = function validatableFields() {
+      return [];
+    };
+
+    this.validatableAssociations = function validatableAssociations() {
+      return [];
+    };
+
+    this.validatableAssociationLists = function validatableAssociationLists() {
+      return [];
+    };
+
+    this.forEachValidatableField = function forEachValidatableField(callback) {
+      ko.utils.arrayForEach(this.validatableFields(), function(field) {
+        if (that[field].isValidatable) {
+          callback.call(that, that[field]);
+        }
+      });
+    };
+
+    this.forEachValidatableAssociation = function forEachValidatableAssociation(callback) {
+      var association_list;
+
+      ko.utils.arrayForEach(this.validatableAssociations(), function(association_name) {
+        var association = that[association_name]();
+        
+        if (association.isValidatable && association.isValidatable()) {
+          callback.call(that, association);
+        }
+      });
+
+      ko.utils.arrayForEach(this.validatableAssociationLists(), function(association_list_name) {
+        association_list = that[association_list_name];
+
+        ko.utils.arrayForEach(association_list(), function(association) {
+          if (association.isValidatable && association.isValidatable()) {
+            callback.call(that, association);
+          }
+        });
+      });
+    };
+
+    this.hasErrors = ko.computed(function hasErrors() {
+      var result = false;
+
+      that.forEachValidatableField(function(observable) {
+        if (observable.hasError()) {
+          result = true;
+        }
+      }, this);
+
+      if (result) {
+        return true;
+      }
+
+      that.forEachValidatableAssociation(function(association) {
+        if (association.hasErrors()) {
+          result = true;
+        }
+      });
+
+      return result;
+    }, this, {deferEvaluation: true});
+    
+    this.validationMessages = ko.computed(function validationMessages() {
+      var messages = [];
+
+      that.forEachValidatableField(function(observable) {
+        if (observable.hasError()) {
+          messages.push(observable.validationMessage());
+        }
+      }, this);
+
+      that.forEachValidatableAssociation(function(association) {
+        if (association.hasErrors()) {
+          messages = messages.concat(association.validationMessages());
+        }
+      });
+
+      return messages;
+    }, this, {deferEvaluation: true});
+
+    this.isFullyValidated = ko.computed(function isFullyValidated() {
+      var result = true;
+
+      that.forEachValidatableField(function(observable) {
+        if (observable.isUnvalidated() || observable.validationInProgress()) {
+          result = false;
+        }
+      });
+
+      if (!result) {
+        return false;
+      }
+
+      that.forEachValidatableAssociation(function(association) {
+        if (!association.isFullyValidated() || association.hasValidationsInProgress()) {
+          result = false;
+        }
+      });
+
+      return result;
+    }, this, {deferEvaluation: true});
+
+    this.hasValidationsInProgress = ko.computed(function hasValidationsInProgress() {
+      var result = false;
+
+      that.forEachValidatableField(function(observable) {
+        if (observable.validationInProgress()) {
+          result = true;
+        }
+      });
+
+      if (result) {
+        return true;
+      }
+
+      that.forEachValidatableAssociation(function(association) {
+        if (association.hasValidationsInProgress()) {
+          result = true;
+        }
+      });
+
+      return result;
+    }, this, {deferEvaluation: true});
+
+    this.isValid = ko.computed(function isValid() {
+      return !this.hasErrors() && this.isFullyValidated();
+    }, this, {deferEvaluation: true});
+
+    this.validate = function validate() {
+      that.forEachValidatableField(function(observable) {
+        observable.validate();
+      });
+
+      that.forEachValidatableAssociation(function(association) {
+        association.validate();
+      });
+    };
+  };
+
+  kea.models.Validatable = Validatable;
+
+})(window.app, window.kea, ko);

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

@@ -0,0 +1,49 @@
+(function(ko, $, Veil, Overlay, app) {
+  "use strict";
+
+  ko.bindingHandlers.childVmOverlay = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element        = $(element),
+          options         = ko.unwrap(valueAccessor()),
+          overlayName     = ko.unwrap(options.name),
+          vmName          = ko.unwrap(options.vm),
+          parentVm        = options.parentVm || bindingContext.$parent,
+          setup           = options.setup,
+          overlayOptions  = options.overlayOptions || {},
+          css             = options.css;
+      
+      overlayOptions.overlayClass = [overlayOptions.overlayClass, overlayName, css].join(' ');
+          
+      $element.on('click', function() {
+        var childVm = parentVm.getVm(vmName),
+            overlay;
+        
+        if (childVm.setup) {
+          childVm.setup(setup);
+        }
+        
+        overlay = Overlay.control.createOverlay(overlayName, bindingContext, childVm, overlayOptions);
+        
+        if (childVm.keyboardHandlerConfigs) {
+          childVm.keyboardHandlerConfigs.forEach(function(config) {
+            childVm.keyboardHandlers.push( app.page.MainVm.listener.register_combo(config) );
+          });
+          
+          overlay.on('beforeClose', function() {
+            app.page.MainVm.listener.unregister_many(childVm.keyboardHandlers);
+            childVm.keyboardHandlers.length = 0;
+          });
+        }
+        
+        if (childVm.exit) {
+          childVm.exit.subscribe(function() {
+            overlay.hide();
+          });
+        }
+        
+        overlay.show();
+      });
+    }
+  };
+
+})(ko, $, window.Veil, window.Overlay, window.app);

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

@@ -0,0 +1,87 @@
+(function(app, ko) {
+  "use strict";
+
+  var OverlayControl,
+      Overlay;
+
+  OverlayControl = function OverlayControl() {
+    var that = this;
+    
+    this.providers = {};
+    this.existingOverlays = {};
+    
+    this.registerProvider = function registerProvider(name, createCallback) {
+      that.providers[name] = createCallback;
+    };
+    
+    this.createOverlay = function createOverlay(name, ctx, ctxExtension, overlayOptions) {
+      var overlay;
+      
+      if (DEBUG) { console.assert(that.providers[name], "%s is not an available overlay provider", name); }
+      
+      if (that.existingOverlays[name]) {
+        overlay = that.existingOverlays[name];
+        
+        overlay.update(ctx, ctxExtension);
+        
+      } else {
+        overlay = that.providers[name](ctx, ctxExtension, overlayOptions);
+        
+        that.existingOverlays[name] = overlay;
+      }
+      
+      return overlay;
+    };
+  };
+  
+  Overlay = function Overlay(name, veil) {
+    var that = this;
+    
+    this.name = name;
+    this.veil = veil;
+    
+    this.updateCallback  = function noop() {};
+    this.destroyCallback = function noop() {};
+    
+    this.callbacks = {
+      'beforeShow' : [],
+      'beforeClose': []
+    };
+    
+    this.runCallbacks = function runCallbacks(name) {
+      that.callbacks[name].forEach(function(callback) {
+        callback.apply(that);
+      });
+    };
+    
+    this.on = function on(callbackName, callback) {
+      that.callbacks[callbackName].push(callback);
+    };
+    
+    this.update = function update() {
+      that.updateCallback.apply(that, arguments);
+    };
+    
+    this.destroy = function destroy() {
+      that.runCallbacks('beforeClose');
+      that.destroyCallback.apply(that, arguments);
+    };
+    
+    this.show = function show() {
+      that.runCallbacks('beforeShow');
+      that.veil.show();
+    };
+    
+    this.hide = function hide() {
+      that.runCallbacks('beforeClose');
+      that.veil.hide();
+    };
+    
+  };
+  
+  window.Overlay = {
+    control: new OverlayControl(),
+    Overlay: Overlay
+  };
+
+})(window.app, ko);

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

@@ -0,0 +1,58 @@
+(function(ko, $, Veil, Overlay) {
+  "use strict";
+
+  ko.bindingHandlers.overlayTemplate = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $container  = $(element),
+          name        = ko.unwrap(valueAccessor()),
+          newCtx,
+          createCallback;
+      
+      // returns either current context extended, or an
+      // extended child context
+      newCtx = function newCtx(overlay, ctx, ctxExtension) {
+        if (ctxExtension) {
+          return ctx.createChildContext(
+            ctxExtension,
+            null, // optional alias for $data
+            function(context) {
+                ko.utils.extend(context, { overlay: overlay} );
+            });
+        } else {
+          return ctx.extend({ overlay: overlay});
+        }
+      };
+      
+      createCallback = function createCallback(ctx, ctxExtension, veilOptions) {
+        var veil      = new Veil(veilOptions),
+            overlay   = new Overlay.Overlay(name, veil),
+            childCtx  = newCtx(overlay, ctx, ctxExtension);
+        
+        ko.bindingHandlers.template.init(veil.overlay().get(0), function() { return name; }, allBindingsAccessor, childCtx.$data, childCtx);
+        ko.bindingHandlers.template.update(veil.overlay().get(0), function() { return name; }, allBindingsAccessor, childCtx.$data, childCtx);
+        
+        overlay.updateCallback = function updateCallback(ctx, ctxExtension) {
+          var updatedCtx = newCtx(this, ctx, ctxExtension);
+          
+          ko.bindingHandlers.template.update(veil.overlay().get(0), function() { return name; }, allBindingsAccessor, updatedCtx.$data, updatedCtx);
+        };
+        
+        overlay.destroyCallback = function destroyCallback() {
+          ko.virtualElements.emptyNode( veil.overlay().get(0) );
+          veil.destroy();
+        };
+        
+        return overlay;
+      };
+      
+      Overlay.control.registerProvider(name, createCallback);
+      
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+        // listener.destroy();
+      });
+      
+      return {controlsDescendantBindings: true};
+    }
+  };
+
+})(ko, $, window.Veil, window.Overlay);

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

@@ -0,0 +1,227 @@
+(function(app, kea, ko, URI) {
+  "use strict";
+
+  var _regex_uppercase        = new RegExp('([A-Z])', 'g'),
+      _regex_underbar_prefix  = new RegExp('^_'),
+      _lookupCache,
+      _request,
+      _defaultFailureHandler,
+      _modelnameToParameter,
+      _resourcePathForAction,
+      failure422Handler,
+      failure423Handler,
+      getCollection,
+      get,
+      refresh,
+      create,
+      update,
+      destroy;
+
+  _lookupCache = function _lookupCache(path) {
+    var cachedResult = app.cache[path];
+
+    if (DEBUG) { console.debug("looking up cache for %s: %o", path, cachedResult); }
+
+    return typeof cachedResult !== 'undefined' ? $.when(cachedResult) : undefined;
+  };
+
+  _request = function _request(type, path, params) {
+    return $.ajax({
+      type:     type,
+      url:      path,
+      data:     params,
+      dataType: 'JSON'
+    });
+  };
+
+  _defaultFailureHandler = function _defaultFailureHandler(jqXHR, textStatus) {
+    if (DEBUG) {
+      console.error("%s %s failed: %s", this.type, this.url, textStatus, jqXHR);
+    }
+
+    if (jqXHR.status === 0 && jqXHR.statusText === 'timeout') {
+      kea.notify("Server antwortet nicht <p><small>Der Server hat nicht rechtzeitig geantwortet. Bitte versuchen Sie es erneut!</small></p>", 'error');
+
+    } else if (jqXHR.status === 500 || jqXHR.status === 400 || jqXHR.status === 404) {
+      kea.notify("Entschuldigung! Der Server hat Schluckauf. <p><small><pre>" + jqXHR.responseText + "</pre></small></p>", 'error');
+
+    } else if (jqXHR.status === 403) {
+      kea.notify("Das geht nun wirklich nicht! <p><small>Diese Aktion ist nicht erlaubt</small></p>", 'error');
+      
+    }
+
+  };
+
+  failure422Handler = function failure422Handler(jqXHR, textStatus) {
+    if (jqXHR.status === 422) {
+      kea.notify(jqXHR.responseText, 'error');
+    }
+  };
+  
+  failure423Handler = function failure423Handler(jqXHR, textStatus) {
+    if (jqXHR.status === 423) {
+      kea.notify(jqXHR.responseText, 'error');
+    }
+  };
+
+  // taken from https://code.google.com/p/inflection-js/source/browse/trunk/inflection.js
+  _modelnameToParameter = function _modelnameToParameter(name) {
+    name = name.replace(_regex_uppercase, '_$1');
+    name = name.replace(_regex_underbar_prefix, '');
+
+    return name.toLowerCase();
+  };
+  
+  _resourcePathForAction = function _resourcePathForAction(action, modelObject) {
+    var pathMethod = action + 'Path';
+    
+    if (typeof modelObject[pathMethod] === 'function') {
+      return modelObject[action + 'Path']();
+      
+    } else if (modelObject.service() && typeof modelObject.service()[pathMethod] === 'function') {
+      return modelObject.service()[pathMethod]();
+      
+    } else {
+      return modelObject.resource_path;
+    }
+  };
+
+  get = function get(modelName, path, params, cache_key) {
+    var responseProcessor,
+        deferred,
+        cachedResult;
+
+    params = params || {};
+
+    if (cache_key === true) {
+      cache_key = new URI(path).query(params).toString();
+    }
+
+    responseProcessor = function responseProcessor(data) {
+      if (DEBUG) { console.debug("received resource %s: %o", modelName, data); }
+
+      if ( $.isArray(data) ) {
+        return ko.utils.arrayMap(data, function(json) {
+          return new app.models[modelName](json);
+        });
+
+      } else {
+        return new app.models[modelName](data);
+      }
+    };
+
+    if (cache_key) {
+      cachedResult = _lookupCache(cache_key);
+    }
+
+    return (cachedResult || _request('GET', path, params))
+      .then(responseProcessor)
+      .fail(_defaultFailureHandler);
+  };
+  
+  refresh = function refresh(modelName, modelObject, params, path) {
+    var responseProcessor,
+        deferred;
+
+    params = params || {};
+
+    responseProcessor = function responseProcessor(data) {
+      if (DEBUG) { console.debug("received resource %s for refresh: %o", modelName, data); }
+
+      if ( $.isArray(data) ) {
+        if (DEBUG) { console.error("received multiple resources when trying to refresh %s : %o", modelName, data); }
+
+      } else {
+        
+        if (typeof modelObject.refreshFromJSON === 'function') {
+          modelObject.refresh(data);
+          
+        } else {
+          modelObject.fromJSON(data);
+        }
+        
+        return modelObject;
+      }
+    };
+
+    return _request('GET', path, params)
+      .then(responseProcessor)
+      .fail(_defaultFailureHandler);
+  };
+
+  create = function create(modelName, modelObject, path) {
+    var params = {};
+
+    if (!path) {
+      path = _resourcePathForAction('create', modelObject);
+    }
+
+    params[ _modelnameToParameter(modelName) ] = modelObject.serialize();
+
+    return $.ajax({
+      type:     'POST',
+      url:      path,
+      data:     params,
+      dataType: 'JSON'
+
+    }).then(function(data) {
+      if (DEBUG) { console.debug("POST %s: %o", path, data); }
+      return new app.models[modelName](data);
+
+    }).fail(_defaultFailureHandler);
+  };
+
+  update = function update(modelName, modelObject, attributeHash, path) {
+    var params  = {};
+
+    if (!path) {
+      path = _resourcePathForAction('update', modelObject);
+    }
+
+    if (attributeHash) {
+      params[ _modelnameToParameter(modelName) ] = attributeHash;
+    } else {
+      params[ _modelnameToParameter(modelName) ] = modelObject.serialize();
+    }
+
+    return $.ajax({
+      type:     'PUT',
+      url:      path,
+      data:     params,
+      dataType: 'JSON'
+
+    }).then(function(data) {
+      if (DEBUG) { console.debug("PUT %s: %o", path, data); }
+      return data;
+
+    }).fail(_defaultFailureHandler);
+  };
+
+  destroy = function destroy(modelName, modelObject, path) {
+    
+    if (!path) {
+      path = _resourcePathForAction('destroy', modelObject);
+    }
+
+    return $.ajax({
+      type:     'DELETE',
+      url:      path,
+      dataType: 'JSON'
+
+    }).fail(_defaultFailureHandler);
+  };
+
+  kea.services.Base = {
+    getCollection: getCollection,
+    get: get,
+    refresh: refresh,
+    create: create,
+    update: update,
+    destroy: destroy,
+    failure422Handler: failure422Handler,
+    failure423Handler: failure423Handler,
+    _request: _request,
+    _defaultFailureHandler: _defaultFailureHandler
+  };
+
+})(window.app, window.kea, ko, URI);