kea-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 16389b697b4f38ceff8313c38e890be59cba06e1
+  data.tar.gz: 665a5552419bab02bc5cf9b8dd29351763568b14
+SHA512:
+  metadata.gz: 806a1c1dbe01578fe421662d257d91c0ee1815181b6ee8ab623eb76aaecc4042363bede478788ad57ca9bd2f40a623ed5346f8228f4fae186bc5244d55e15b2c
+  data.tar.gz: e1af766999bd513b358d445911dec1e0ab03b89b2de62dbe6dce443c7b186efafe68bb31c33e6e801e3db08d087db1def2b89107f24ad492b9075848e11d3064

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Jan-Christian Föh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Kea
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Kea'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

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

@@ -0,0 +1,24 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.activity = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element      = $(element),
+          activityState = ko.unwrap(valueAccessor());
+
+      $element.activityButton();
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element      = $(element),
+          activityState = ko.unwrap(valueAccessor());
+          
+      if (activityState && !$element.activityButton().active()) {
+        $element.activityButton().on();
+        
+      } else if (!activityState && $element.activityButton().active()) {
+        $element.activityButton().off();
+      }
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,32 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.childVm = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var vmName        = ko.unwrap(valueAccessor()),
+          parentVm      = allBindingsAccessor().parentVm ? ko.unwrap(allBindingsAccessor().parentVm) : viewModel,
+          initVm        = allBindingsAccessor().initVm ? ko.unwrap(allBindingsAccessor().initVm) : false,
+          setupContext  = allBindingsAccessor().setupContext ? ko.unwrap(allBindingsAccessor().setupContext) : null,
+          childVm;
+
+      if (initVm) {
+        childVm = parentVm.addChildVm(vmName);
+      } else {
+        childVm = ko.utils.arrayFirst(parentVm._childVms(), function(item) {
+          return item._viewmodelName() === vmName;
+        });
+      }
+
+      if (setupContext && typeof childVm.setup === 'function') {
+        childVm.setup(setupContext);
+      }
+
+      // 'with' returns {controlsDescendants: true}, so we have to pass it up - otherwise,
+      // the descendant bindings will be bound twice ("You cannot apply bindings multiple times to the same element")
+      return ko.bindingHandlers.with.init(element, function() { return childVm; }, allBindingsAccessor, viewModel, bindingContext);
+    }
+  };
+  
+  ko.virtualElements.allowedBindings.childVm = true;
+
+})(ko, $);

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

@@ -0,0 +1,172 @@
+(function(ko, $, app) {
+  "use strict";
+
+  ko.bindingHandlers.komplete = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $container    = $(element),
+          $searchInput  = $container.find('> .komplete-search-term'),
+          listener      = new window.keypress.Listener( $searchInput.get(0) ),
+          options       = ko.unwrap(valueAccessor()),
+          AutocompleteVm,
+          AutocompleteResult,
+          vm,
+          vmName;
+      
+      AutocompleteResult = function AutocompleteResult(label, value, rawResult) {
+        this.label     = label;
+        this.value     = value;
+        this.rawResult = rawResult;
+        this.hasFocus  = ko.observable(false);
+      };
+      
+      AutocompleteVm = function AutocompleteVm(url, autoSelect, selectCallback) {
+        this.url               = url;
+        this.autoSelect        = autoSelect;
+        this.selectCallback    = selectCallback;
+        this.responseMap       = {label: 'label', value: 'value'};
+        this.searchTerm        = ko.observable('').extend({ rateLimit: { timeout: 500, method: "notifyWhenChangesStop" } });
+        this.requestInProgress = ko.observable(false);
+        
+        this.showDropdown      = ko.computed(function() {
+          return this.searchResults().length > 0;
+        }, this, {deferEvaluation: true});
+        
+        this.searchTerm.subscribe(function() {
+          if (this.searchTerm().length > 0) {
+            this.fetch();
+          }
+        }, this);
+        
+        this.searchResults     = ko.observableArray([]);
+      };
+      
+      AutocompleteVm.prototype.focusedResult = function focusedResult(results) {
+        return ko.utils.arrayFirst(this.searchResults(), function(result) { return result.hasFocus(); });
+      };
+      
+      AutocompleteVm.prototype.focusOffset = function focusOffset(idxOffset) {
+        var currentFocus = this.focusedResult(),
+            focusedIdx   = currentFocus      ? this.searchResults().indexOf(currentFocus)   : -1,
+            futureFocus  = focusedIdx !== -1 ? this.searchResults()[focusedIdx + idxOffset] : null;
+            
+        if (!futureFocus) { return; }
+        
+        currentFocus.hasFocus(false);
+        futureFocus.hasFocus(true);
+      };
+      
+      AutocompleteVm.prototype.focusNext = function focusNext() {
+        this.focusOffset(1);
+      };
+      
+      AutocompleteVm.prototype.focusPrevious = function focusPrevious() {
+        this.focusOffset(-1);
+      };
+      
+      AutocompleteVm.prototype.select = function select(result) {
+        this.selectCallback.call(bindingContext.$data, result);
+        this.reset();
+      };
+      
+      AutocompleteVm.prototype.reset = function reset() {
+        this.searchTerm('');
+        this.searchResults.removeAll();
+        this.requestInProgress(false);
+      };
+      
+      AutocompleteVm.prototype.fetch = function fetch(results) {
+        var that = this;
+        
+        this.requestInProgress(true);
+        
+        app.services.Base._request('GET', this.url, { q: this.searchTerm() })
+          .done(function(response) {
+            that.searchResults( that.parseResults(response) );
+            
+            if (that.autoSelect && that.searchResults()[0]) {
+              that.searchResults()[0].hasFocus(true);
+            }
+          })
+          .always(function() {
+            that.requestInProgress(false);
+          });
+      };
+      
+      AutocompleteVm.prototype.parseResults = function parseResults(results) {
+        var labelKey = this.responseMap.label,
+            valueKey = this.responseMap.value;
+            
+        return results.map(function(result) {
+          return new AutocompleteResult(result[labelKey], result[valueKey], result);
+        });
+      };
+      
+      if (DEBUG) { console.assert(options.url || options.fetch || options.vm, "Provide either an autocomplete URL, a custom fetch method or a custom AutocompleteVM"); }
+      if (DEBUG) { console.assert(options.onSelect, "onSelect callback missing"); }
+      
+      options.autoSelect   = typeof options.autoSelect !== 'undefined' ? options.autoSelect : true;
+      options.blurOnSelect = typeof options.blurOnSelect !== 'undefined' ? options.blurOnSelect : true;
+      
+      vm = options.vm || new AutocompleteVm(options.url, options.autoSelect, options.onSelect);
+      
+      if (options.fetch) {
+        vm.fetch = options.fetch;
+      }
+      
+      if (options.responseMap) {
+        vm.responseMap = options.responseMap;
+      }
+      
+      if (options.parseResults) {
+        vm.parseResults = options.parseResults;
+      }
+      
+      listener.register_combo({
+        keys: "down",
+        on_keydown: function() { vm.focusNext(); }
+      });
+      
+      listener.register_combo({
+        keys: "up",
+        on_keydown: function() { vm.focusPrevious(); }
+      });
+      
+      listener.register_combo({
+        keys: "enter",
+        on_keydown: function() {
+          if (!options.autoSelect && !vm.focusedResult()) {
+            if (options.blurOnSelect) {
+              $searchInput.get(0).blur();
+            }
+            
+            vm.select( $searchInput.val() );
+            
+          } else if (options.autoSelect && !vm.focusedResult()) {
+            return;
+            
+          } else {
+            if (options.blurOnSelect) {
+              $searchInput.get(0).blur();
+            }
+            
+            vm.select( vm.focusedResult() );
+          }
+        }
+      });
+      
+      $container.on('click', function() {
+        $searchInput.focus();
+      });
+      
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+        listener.destroy();
+      });
+      
+      return ko.bindingHandlers.with.init(element, function() { return vm; }, allBindingsAccessor, viewModel, bindingContext);
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+
+    }
+  };
+
+})(ko, $, window.app);

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

@@ -0,0 +1,47 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.sherlock = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $container  = $(element),
+          options     = ko.unwrap(valueAccessor()),
+          $providerSearchField,
+          sherlockVm;
+      
+      sherlockVm = new app.sherlock.SherlockVm();
+      sherlockVm.setup();
+      
+      sherlockVm.params.subscribe(function(params) {
+        bindingContext.$data.sherlockParams(params);
+      });
+      
+      ko.renderTemplate('sherlock-container-template', sherlockVm, {}, element);
+      
+      $container.addClass('sherlock-search-bar');
+      
+      $providerSearchField = $container.find('.provider-search-field > input');
+      
+      $providerSearchField.on('focus', function() {
+        sherlockVm.providerSearchActive(true);
+      });
+      
+      $providerSearchField.on('blur', function() {
+        // if we do not delay this, it will fire before the 'click'
+        // event on dropdown list entries, clearing the list
+        setTimeout(function() {
+          sherlockVm.providerSearchActive(false);
+        }, 200);
+      });
+      
+      $container.on('click', function() {
+        $providerSearchField.focus();
+      });
+      
+      return { controlsDescendantBindings: true };
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,57 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.sherlockProviderSearch = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $container            = $(element).find('.provider-search-dropdown'),
+          $providerSearchField  = $(element).find('> input[type=text]'),
+          sherlockVm            = bindingContext.$data,
+          listener              = new window.keypress.Listener($providerSearchField.get(0)),
+          keyCombos;
+      
+      listener.register_combo({
+        keys: "down",
+        on_keydown: function() { sherlockVm.focusNextFragment(); }
+      });
+      
+      listener.register_combo({
+        keys: "up",
+        on_keydown: function() { sherlockVm.focusPreviousFragment(); }
+      });
+      
+      listener.register_combo({
+        keys: "enter",
+        on_keydown: function() { $providerSearchField.get(0).blur(); sherlockVm.selectFocusedFragment(); }
+      });
+      
+      listener.register_combo({
+        keys: "backspace",
+        on_keydown: function() {
+          if (sherlockVm.providerSearchTerm().length === 0) {
+            sherlockVm.removeLastActiveFragment();
+          }
+          
+          return true;
+        }
+      });
+      
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+        listener.destroy();
+      });
+      
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $container  = $(element).find('.provider-search-dropdown'),
+          sherlockVm  = bindingContext.$data,
+          providerSearchActive    = sherlockVm.providerSearchActive(),
+          fragmentsForSearchTerm = sherlockVm.fragmentsForSearchTerm();
+          
+      if (providerSearchActive && (fragmentsForSearchTerm.length > 0 || sherlockVm.liveSearchProviders().length > 0)) {
+        $container.addClass('active');
+      } else {
+        $container.removeClass('active');
+      }
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,33 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.submitButton = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element    = $(element),
+          boundModel  = ko.unwrap(valueAccessor()),
+          onSubmitSuccess = allBindingsAccessor().onSubmitSuccess || null;
+
+      $element.activityButton();
+
+      if (onSubmitSuccess) {
+        boundModel.submitComplete.subscribe(function(submitState) {
+          if (submitState) {
+            onSubmitSuccess($element, boundModel);
+          }
+        });
+      }
+
+      ko.bindingHandlers.click.init(element, function() { return boundModel.submit; }, allBindingsAccessor, viewModel, bindingContext);
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element      = $(element),
+          boundModel    = ko.unwrap(valueAccessor()),
+          isActive      = ko.unwrap(boundModel.submitInProgress),
+          isSubmittable = ko.unwrap(boundModel.isSubmittable);
+
+      isActive ? $element.activityButton().on() : $element.activityButton().off();
+      isSubmittable ? $element.removeClass('disabled') : $element.addClass('disabled');
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,38 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.validationState = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element = $(element),
+          tooltipPosition = allBindingsAccessor().tooltipPosition || 'center top';
+
+      $element.attache({popoverClass: 'formerror', position: tooltipPosition});
+
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+        $element.attache().destroy();
+      });
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var $element          = $(element),
+          $parentLabel      = $element.parent('label'),
+          hasParentLabel    = $parentLabel.length > 0,
+          $cssClassLocation = hasParentLabel ? $parentLabel.find('span.custom') : $element,
+          $errorMessage     = hasParentLabel ? $parentLabel.find('span.error.message') : $element.next('span.error.message'),
+          observable        = valueAccessor(),
+          hasError          = ko.unwrap(observable.hasError ? observable.hasError : observable.hasErrors),
+          messageText       = ko.unwrap(observable.validationMessage ? observable.validationMessage : observable.validationMessages);
+
+      if (typeof hasError === 'undefined' || !hasError) {
+        $cssClassLocation.removeClass('error');
+        $element.attache().hide();
+
+      } else {
+        $cssClassLocation.addClass('error');
+
+        $element.attache().setContent(messageText);
+        $element.attache().show();
+      }
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,44 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.bindingHandlers.waitForVm = {
+    init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+      var vmName = ko.unwrap(valueAccessor()),
+          subscription,
+          childVm;
+
+      childVm = ko.utils.arrayFirst(viewModel._childVms(), function(item) {
+        return item._viewmodelName() === vmName;
+      });
+
+      // if the child viewmodel isn't available yet...
+      if (!childVm) {
+
+        // subscribe to the list of child viewmodels
+        subscription = viewModel._childVms.subscribe(function() {
+          childVm = ko.utils.arrayFirst(viewModel._childVms(), function(item) {
+            return item._viewmodelName() === vmName;
+          });
+
+          // and if it has become available now, remove the subscription,
+          // apply the bindings to our child elements and make ourselves visible
+          if (childVm) {
+            subscription.dispose();
+            ko.applyBindingsToDescendants(bindingContext, element);
+            ko.bindingHandlers.visible.update(element, function() { return childVm; }, allBindingsAccessor, viewModel, bindingContext);
+          }
+        });
+      }
+
+      // hide ourselves and our children if the viewmodel isn't 
+      // immediately available on init().
+      ko.bindingHandlers.visible.update(element, function() { return childVm; }, allBindingsAccessor, viewModel, bindingContext);
+
+      // prevent our descendant elements from being bound if the
+      // viewmodel isn't immediately available on init(). We will
+      // take care of that later ourselves through ko.applyBindingsToDescendants
+      return {controlsDescendantBindings: !childVm};
+    }
+  };
+
+})(ko, $);

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

@@ -0,0 +1,85 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.equals = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: "",
+        to: null
+      };
+
+      options = $.extend({}, defaults, options);
+
+      if (!options.to) {
+        if (DEBUG) { console.error("equality validator is missing its comparison target"); }
+      }
+      
+      target.shouldValidate = function shouldValidate(comparisonValueHasCHanged) {
+        
+        // don't validate if the comparison value
+        // a) is invalid or unvalidated
+        // b) was changed, but this value has not been validated before
+        if (ko.isObservable(options.to)) {
+          if (  ( options.to.isUnvalidated() || options.to.hasError() ) ||
+                ( comparisonValueHasCHanged && target.isUnvalidated() ) ) {
+
+            return false;
+          }
+        }
+        
+        return true;
+      };
+      
+      target.performValidation = function performValidation(validatableValue, comparisonValue) {
+        if (options.allowBlank && (!validatableValue || validatableValue === '')) {
+          target.markValid();
+          
+          return !target.hasError();
+        }
+
+        if (validatableValue === comparisonValue) {
+          target.markValid();
+        } else {
+          target.markInvalid(options.message);
+        }
+
+        return !target.hasError();
+      };
+   
+      target.validate = function validate(newValue, newComparisonValue, comparisonValueHasCHanged) {
+        var validatableValue  = typeof newValue === 'undefined' ? target() : newValue,
+            comparisonValue   = typeof newComparisonValue === 'undefined' ? ko.unwrap(options.to) : newComparisonValue;
+
+        if (!target.shouldValidate(comparisonValueHasCHanged)) {
+          return;
+        }
+        
+        return target.performValidation(validatableValue, comparisonValue);
+      };
+      
+      target.forceValidate = function forceValidate(newValue, newComparisonValue, comparisonValueHasCHanged) {
+        var validatableValue  = typeof newValue === 'undefined' ? target() : newValue,
+            comparisonValue   = typeof newComparisonValue === 'undefined' ? ko.unwrap(options.to) : newComparisonValue;
+        
+        return target.performValidation(validatableValue, comparisonValue);
+      };
+   
+      target.subscribe(target.validate);
+
+      // trigger re-validation if the comparison value changes, too.
+      // Only do this if this value has been validated before, or we risk throwing
+      // an error before the user had time to fill out this field
+      if (ko.isObservable(options.to)) {
+        options.to.subscribe(function() {
+          if (typeof target !== 'undefined') {
+            target.validate(undefined, undefined, true);
+          }
+        });
+      }
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);

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

@@ -0,0 +1,65 @@
+(function(ko, $) {
+  "use strict";
+
+  ko.extenders.externalValidator = function(target, options) {
+      ko.utils.validatorBase(target);
+
+      var defaults = {
+        message: "",
+        validator: function(v) {},
+        dependencies: []
+      };
+
+      options = $.extend({}, defaults, options);
+   
+      target.validate = function validate(newValue) {
+        var validatableValue  = typeof newValue === 'undefined' ? target() : newValue,
+            validatorResponse = options.validator(validatableValue),
+            validatorResponseHandler;
+
+        validatorResponseHandler = function validatorResponseHandler(response) {
+          var result, message;
+
+          if (typeof response === 'boolean') {
+            result  = response;
+            message = options.message;
+
+          } else {
+            result  = response.result;
+            message = response.message;
+          }
+          
+          if (result) {
+            target.markValid();
+          } else {
+            target.markInvalid(message);
+          }
+        };
+
+        if (typeof validatorResponse === 'object' && typeof validatorResponse.done === 'function') {
+          target.validationInProgress(true);
+          validatorResponse.done(function(response) { validatorResponseHandler(response); target.validationInProgress(false); });
+          return;
+
+        } else {
+          validatorResponseHandler(validatorResponse);
+          return !target.hasError();
+        }
+      };
+   
+      //validate whenever the value changes
+      target.subscribe(target.validate);
+      
+      ko.utils.arrayForEach(options.dependencies, function(dependency) {
+        dependency.subscribe(function(newValue) {
+          if (!target.isUnvalidated()) {
+            target.validate();
+          }
+        });
+      });
+   
+      //return the original observable
+      return target;
+  };
+
+})(ko, $);