kea-rails 1.0.0

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

@@ -0,0 +1,201 @@
+(function(app, sherlock, ko, Fuse) {
+  "use strict";
+
+  var Base;
+
+  Base = function Base() {
+    var that = this;
+    
+    this.minimumConfidence = 0.8;
+    this.displayName = '';
+    this.defaultKeyword = '';
+    this.parameterName = '';
+    this.keywords = [];
+    this.activeFragments = ko.observableArray([]);
+    this.prefilledFragmentsAreChangeable = true;
+    
+    this.liveSearchFragments    = ko.observableArray([]);
+    this.liveSearchAjaxActivity = ko.observable(false);
+    this.liveSearchAlwaysVisible = ko.observable(false);
+    
+    this.liveSearchVisible = ko.computed(function() {
+      return this.liveSearchAlwaysVisible() || this.liveSearchFragments().length > 0;
+    }, this, {deferEvaluation: true});
+    
+    this.offersLiveSearch = ko.computed(function() {
+      return typeof this.liveSearch === 'function' && this.allowAnotherFragment();
+    }, this, {deferEvaluation: true});
+    
+    this.fragmentsToParam = ko.computed(function() {
+      var result                      = {},
+          values                      = [];
+          
+      this.activeFragments().forEach(function(activeFragment) {
+        var fragmentResult = activeFragment.toParam();
+        
+        if (!fragmentResult) {
+          return;
+        }
+        
+        values.push(fragmentResult);
+      });
+      
+      if (values.length === 0) {
+        return;
+        
+      } else if (values.length === 1) {
+        result[this.parameterName] = values[0];
+        
+      } else {
+        result[this.parameterName] = values;
+      }
+      
+      return result;
+          
+    }, this, {deferEvaluation: true});
+  };
+  
+  Base.prototype.allowAnotherFragment = function allowAnotherFragment() {
+    return this.activeFragments().length === 0;
+  };
+
+  Base.prototype.setStaticKeywords = function setStaticKeywords(stringOrArray) {
+    var that = this,
+        keywords,
+        defaultKeyword;
+    
+    if (typeof stringOrArray === 'string') {
+      keywords = [stringOrArray];
+    } else {
+      keywords = stringOrArray;
+    }
+    
+    this.keywords.push( {keyword: keywords.shift(), isDefaultKeyword: true} );
+    
+    keywords.forEach(function(keyword) {
+      that.keywords.push( {keyword: keyword} );
+    });
+  };
+  
+  Base.prototype.respondsTo = function respondsTo(searchTerm) {
+    if (this.offersLiveSearch()) {
+      this.liveSearch(searchTerm);
+    }
+    return this.fuzzyKeywordSearch(searchTerm);
+  };
+  
+  Base.prototype.fuzzyKeywordSearch = function fuzzyKeywordSearch(searchTerm) {
+    var that          = this,
+        fuse_results  = new Fuse(that.keywords, {
+          keys: ['keyword'],
+          includeScore: true,
+          threshold: (1 - this.minimumConfidence)
+        }).search(searchTerm),
+        matches;
+    
+    if (!fuse_results) {
+      return;
+    }
+    
+    matches = fuse_results.map(function(fuse_result) { return new that.KeywordMatch(fuse_result); });
+    
+    matches = matches.map(function(match) {
+      return that.fragmentForMatch(match);
+    });
+    
+    return matches.length > 0 ? matches : null;
+  };
+  
+  Base.prototype.fragmentForMatch = function fragmentForMatch(match) {
+    var fragment = new this.Fragment(this);
+    
+    fragment.importMatch(match);
+    
+    if (typeof this.fragmentDisplayStringForMatch === 'function') {
+      fragment.displayString = this.fragmentDisplayStringForMatch(match);
+      
+    } else {
+      if (match.isDefaultKeyword) {
+        fragment.displayString = '<span class="keyword default-keyword">' + match.keyword + '</span>';
+      } else {
+        fragment.displayString = '<span class="keyword">' + match.keyword + '</span> — <span class="keyword default-keyword">' + this.displayName + '</span>';
+      }
+    }
+    
+    return fragment;
+  };
+  
+  Base.prototype.defaultFragment = function defaultFragment() {
+    return new this.Fragment(this, this.displayName, 1);
+  };
+  
+  Base.prototype.KeywordMatch = function KeywordMatch(fuse_result) {
+    this.isDefaultKeyword = fuse_result.item.isDefaultKeyword || false;
+    this.item             = fuse_result.item;
+    this.keyword          = fuse_result.item.keyword;
+    this.searchValue      = fuse_result.item.searchValue;
+    this.predicate        = fuse_result.item.predicate;
+    this.confidence       = 1 - fuse_result.score;
+  };
+  
+  Base.prototype.Fragment = function BaseFragment(provider, displayString, confidence, searchValue, predicate) {
+    var that = this;
+    
+    this.provider      = provider;
+    
+    this.displayString = displayString;
+    this.confidence    = confidence;
+    this.searchValueDisplay = displayString;
+    this.searchValueOptions = ko.observableArray([]);
+    this.predicateOptions = ko.observableArray([]);
+    this.searchValue   = ko.observable(searchValue);
+    this.predicate     = ko.observable(predicate);
+    this.hasFocus       = ko.observable(false);
+    
+    if (typeof provider.searchValueOptions === 'function') {
+      this.searchValueOptions( provider.searchValueOptions() );
+    }
+    
+    if (typeof provider.predicateOptions === 'function') {
+      this.predicateOptions( provider.predicateOptions() );
+    }
+    
+    this.importMatch = function importMatch(match) {
+      if (match.searchValue) {
+        this.searchValue(match.searchValue);
+      }
+      
+      if (match.predicate) {
+        this.searchValue(match.predicate);
+      }
+      
+      this.confidence = match.confidence;
+    };
+    
+    this.changeable = !this.searchValue() || provider.prefilledFragmentsAreChangeable;
+    
+    this.toParam = ko.computed(function() {
+      if (!this.searchValue()) {
+        return;
+      }
+      
+      if (this.predicate()) {
+        return {
+          predicate: this.predicate(),
+          value: this.searchValue()
+        };
+        
+      } else {
+        return this.searchValue();
+      }
+      
+    }, this, {deferEvaluation: true});
+    
+  };
+  
+  Base.prototype.fragment_template_name   = 'sherlock-base-fragment-template';
+  Base.prototype.livesearch_template_name = 'sherlock-base-livesearch-template';
+
+  app.sherlock.BaseProvider = Base;
+
+})(window.app, window.app.sherlock, ko, window.Fuse);

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

@@ -0,0 +1,150 @@
+(function(app, kea, ko) {
+  "use strict";
+
+  // Sub-viewmodel handling. Use with borrowed constructor pattern
+
+  var Parent = function Parent() {
+    var that = this;
+
+    this._childVms = ko.observableArray();
+
+    this.addChildVm = function addChildVm(vm) {
+      var vmName = vm;
+
+      if (DEBUG) {
+        console.assert(app.viewmodels[vmName], vmName + " viewmodel could not be loaded into " + that._viewmodelName());
+      }
+
+      vm = new app.viewmodels[vmName]();
+
+      if (typeof vm.initChildFromParent === 'function') {
+        if (DEBUG) {
+          console.group("%s: init sub-vm %s", that._viewmodelName(), vm._viewmodelName());
+        }
+
+        vm.initChildFromParent(that);
+
+        if (DEBUG) { console.groupEnd(); }
+      }
+
+      that._childVms.push( vm );
+      
+      return vm;
+    };
+
+    this.getVm = function getVm(name) {
+      return ko.utils.arrayFirst(that._childVms(), function(item) {
+        return item._viewmodelName() === name;
+      });
+    };
+  };
+
+  kea.viewmodels.Parent = Parent;
+
+  // Parent-viewmodel handling. Use with borrowed constructor pattern
+
+  var Child = function Child() {
+    var that = this;
+
+    this._viewmodelName = function _viewmodelName() {
+      throw "Viewmodel does not implement _viewmodelName";
+    };
+
+    this.parent = null;
+
+    this.initChildFromParent = function initChildFromParent(parentVm) {
+      that.parent = parentVm;
+
+      if (typeof that.init === 'function') {
+        that.init();
+      }
+    };
+  };
+
+  kea.viewmodels.Child = Child;
+
+  // Object validation handling. Use with borrowed constructor pattern
+
+  var Validatable = function Validatable() {
+    var that = this;
+
+    this.validatableName = ko.observable();
+
+    this.validatable = ko.computed(function() {
+      if (typeof that[ that.validatableName() ] !== 'undefined') {
+        return that[ that.validatableName() ]();
+      } else {
+        return undefined;
+      }
+    });
+
+    this.validatableFields = function validatableFields() {
+      if (DEBUG) {
+        console.assert(that.validatable().validatableFields, "%o does not implement validatableFields", that.validatable());
+      }
+
+      return that.validatable().validatableFields();
+    };
+
+    this.hasFieldsWithErrors = ko.computed(function() {
+      var result = false;
+
+      if (!that.validatable()) {
+        return false;
+      }
+
+      ko.utils.arrayForEach(that.validatableFields(), function(field) {
+        if ( that.validatable()[field].hasError() ) {
+          result = true;
+        }
+      });
+
+      return result;
+    });
+
+    this.hasUnvalidatedFields = ko.computed(function() {
+      var result = false;
+
+      if (!that.validatable()) {
+        return false;
+      }
+
+      ko.utils.arrayForEach(that.validatableFields(), function(field) {
+        if ( that.validatable()[field].isUnvalidated() ) {
+          result = true;
+        }
+      });
+
+      return result;
+    });
+
+    this.allFieldsValid = ko.computed(function() {
+      return !that.hasFieldsWithErrors() && !that.hasUnvalidatedFields();
+    });
+
+    this.hasValidationsInProgress = ko.computed(function() {
+      var result = false;
+
+      if (!that.validatable()) {
+        return false;
+      }
+
+      ko.utils.arrayForEach(that.validatableFields(), function(field) {
+        if ( that.validatable()[field].validationInProgress() ) {
+          result = true;
+        }
+      });
+
+      return result;
+    });
+
+    this.validateAllFields = function validateAllFields() {
+      ko.utils.arrayForEach(that.validatableFields(), function(field) {
+        that.validatable()[field].forceValidate();
+      });
+    };
+  };
+
+  kea.viewmodels.Validatable = Validatable;
+
+})(window.app, window.kea, ko);

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

@@ -0,0 +1,230 @@
+(function(app, ko) {
+  "use strict";
+
+  var SherlockVm;
+
+  SherlockVm = function SherlockVm() {
+    app.viewmodels.Parent.apply(this);
+    app.viewmodels.Child.apply(this);
+
+    var that = this;
+
+    this.providers                        = ko.observableArray([]);
+    this.providerSearchTerm               = ko.observable('').extend({ rateLimit: { timeout: 500, method: "notifyWhenChangesStop" } });
+    this.providerSearchActive             = ko.observable(false);
+    this.showLiveSearchWidgets            = ko.observable(false);
+    this.activeFragments                  = ko.observableArray([]);
+    
+    this.params = ko.computed(function() {
+      var params = {};
+      
+      this.providers().forEach(function(provider) {
+        var param = provider.fragmentsToParam();
+        
+        if (param) {
+          params = $.extend({}, params, param);
+        }
+      });
+      
+      return params;
+      
+    }, this, {deferEvaluation: true});
+    
+    this.fragmentsForSearchTerm           = ko.observableArray([]);
+    this.orderedFragmentsForSearchTerm    = ko.computed(function() {
+      if (!this.fragmentsForSearchTerm()) {
+        return;
+      }
+      
+      return this.fragmentsForSearchTerm.sort(function(left, right) {
+        if (left.confidence === right.confidence) {
+          return 0;
+        }
+        
+        return left.confidence < right.confidence ? 1 : -1;
+      });
+      
+    }, this, {deferEvaluation: true});
+    
+    this.availableProviders = ko.computed(function() {
+      var available = [];
+      
+      this.providers().forEach(function(provider) {
+        if (provider.allowAnotherFragment()) {
+          available.push(provider);
+        }
+      });
+      
+      return available;
+      
+    }, this, {deferEvaluation: true});
+    
+    this.liveSearchProviders = ko.computed(function() {
+      var available = [];
+      
+      this.providers().forEach(function(provider) {
+        if (provider.offersLiveSearch()) {
+          available.push(provider);
+        }
+      });
+      
+      return available;
+      
+    }, this, {deferEvaluation: true});
+    
+    this.focuseableFragments = ko.computed(function() {
+      var fragments = [];
+      
+      this.orderedFragmentsForSearchTerm().forEach(function(fragment) {
+        fragments.push(fragment);
+      });
+      
+      this.liveSearchProviders().forEach(function(provider) {
+        provider.liveSearchFragments().forEach(function(fragment) {
+          fragments.push(fragment);
+        });
+      });
+      
+      return fragments;
+      
+    }, this, {deferEvaluation: true});
+    
+    this.focusNextFragment = function focusNextFragment() {
+      if (that.focuseableFragments().length === 0) {
+        return;
+      }
+      
+      var result = that.focuseableFragments().some(function(fragment, idx) {
+        var nextFragment;
+        
+        if (!fragment.hasFocus()) {
+          return false;
+        }
+        
+        nextFragment = that.focuseableFragments()[idx + 1];
+        
+        if (nextFragment) {
+          fragment.hasFocus(false);
+          nextFragment.hasFocus(true);
+        }
+        
+        return true;
+      });
+      
+      if (!result) {
+        that.focuseableFragments()[0].hasFocus(true);
+      }
+      
+    };
+    
+    this.focusPreviousFragment = function focusPreviousFragment() {
+      if (that.focuseableFragments().length === 0) {
+        return;
+      }
+      
+      var result = that.focuseableFragments().some(function(fragment, idx) {
+        var previousFragment;
+        
+        if (!fragment.hasFocus()) {
+          return false;
+        }
+        
+        previousFragment = that.focuseableFragments()[idx - 1];
+        
+        if (previousFragment) {
+          fragment.hasFocus(false);
+          previousFragment.hasFocus(true);
+        }
+        
+        return true;
+      });
+      
+      if (!result) {
+        that.focuseableFragments()[0].hasFocus(true);
+      }
+    };
+    
+    this.selectFocusedFragment = function selectFocusedFragment() {
+      var fragment = ko.utils.arrayFirst(that.focuseableFragments(), function(fragment) {
+        return fragment.hasFocus();
+      });
+      
+      if (fragment) {
+        that.selectFragment(fragment);
+      }
+    };
+    
+    this.removeLastActiveFragment = function removeLastActiveFragment() {
+      var fragment = that.activeFragments()[ that.activeFragments().length - 1 ];
+      
+      if (fragment) {
+        that.removeFragment(fragment);
+      }
+    };
+    
+    this.setDefaultFragments = function setDefaultFragments() {
+      that.availableProviders().forEach(function(provider) {
+        that.fragmentsForSearchTerm.push( provider.defaultFragment() );
+      });
+    };
+    
+    this.selectFragment = function selectFragment(fragment) {
+      that.activeFragments.push(fragment);
+      fragment.provider.activeFragments.push(fragment);
+      that.providerSearchActive(false);
+      that.fragmentsForSearchTerm([]);
+      that.providerSearchTerm('');
+    };
+    
+    this.removeFragment = function removeFragment(fragment) {
+      fragment.provider.activeFragments.remove(fragment);
+      that.activeFragments.remove(fragment);
+    };
+    
+    this.providerSearchTerm.subscribe(function(searchTerm) {
+      var fragments;
+    
+      that.fragmentsForSearchTerm([]);
+      
+      if (searchTerm.length > 0) {
+        that.showLiveSearchWidgets(true);
+        
+        that.availableProviders().forEach(function(provider) {
+          fragments = provider.respondsTo(searchTerm);
+          
+          if (fragments) {
+            fragments.forEach(function(fragment) { that.fragmentsForSearchTerm.push(fragment); });
+            fragments[0].hasFocus(true);
+          }
+        });
+        
+      } else {
+        if (that.providerSearchActive()) {
+          that.setDefaultFragments();
+          that.showLiveSearchWidgets(false);
+        }
+      }
+    });
+    
+    this.providerSearchActive.subscribe(function(isActive) {
+      if (!isActive) {
+        return;
+      }
+      
+      if (that.fragmentsForSearchTerm().length === 0) {
+        that.setDefaultFragments();
+      }
+    });
+    
+    this.setup = function setup() {
+      for (var providerName in app.sherlock.providers) {
+        if (app.sherlock.providers.hasOwnProperty(providerName)) {
+          that.providers.push( new app.sherlock.providers[providerName]() );
+        }
+      }
+    };
+  };
+
+  app.sherlock.SherlockVm = SherlockVm;
+
+})(window.app, ko);

data/app/assets/stylesheets/kea/kea.css.sass

@@ -0,0 +1,16 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require humane-js/themes/flatty
+ *= require pikaday
+ *= require_self
+ */

data/app/helpers/kea/application_helper.rb

@@ -0,0 +1,42 @@
+module Kea
+  module ApplicationHelper
+    def body_id
+      content_for?(:body_id) ? content_for(:body_id) : [body_class, params[:action]].join('-')
+    end
+    
+    def body_class
+      controller.class.to_s.gsub('Controller', '').underscore.dasherize.gsub('/', '-')
+    end
+    
+    def json_for(target, options = {})
+      options[:scope]       ||= self
+      options[:url_options] ||= url_options
+      
+      target.active_model_serializer.new(target, options).to_json
+    end
+
+    def cache_json(object, path = nil, options = {})
+      unless path
+        path = polymorphic_path(object)
+      end
+
+      content = json_for(object, options)
+
+      content_for :json_cache, "window.app.cache['#{path}'] = #{content};\n".html_safe
+    end
+    
+    def overlay_template(name, partial: nil, &block)
+      content_for :knockout_templates do
+        if partial
+          content_tag :script, type: "text/html", id: name, "data-bind" => "overlayTemplate: '#{name}'" do
+            render partial: partial
+          end
+        else
+          content_tag :script, type: "text/html", id: name, "data-bind" => "overlayTemplate: '#{name}'" do
+            capture(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/kea/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Installs Kea, optionally into a namespace such as 'backend' or 'frontend'
+
+Example:
+    rails generate kea:install
+
+      or
+      
+    rails generate kea:install backend