aleph_analytics 0.0.0.alpha

data/app/assets/javascripts/angular/services/lib/schema_completer.js.es6

@@ -0,0 +1,56 @@
+!(angular => {
+  'use strict';
+
+  function SchemaCompleterImports(aceSqlParse, SchemaColumns, MatcherRunner, SCHEMA_MATCHERS) {
+
+    return class SchemaCompleter {
+
+      constructor() {
+        this._columns = new SchemaColumns();
+        this.loadColumnData();
+      }
+
+      loadColumnData() {
+        this._columns.initCollection().then(columns => {
+          this._rawColumnsData = columns;
+          this._matcherRunner = new MatcherRunner(SCHEMA_MATCHERS, _.map(columns, o => o.item));
+        });
+      }
+
+      isLoaded() {
+        return _.exists(this._rawColumnsData) && this._rawColumnsData.length > 0;
+      }
+
+      getCompletions(editor, session, pos, prefix, callback) {
+        if (prefix.length === 0) { callback(null, []); return; }
+
+        let parsedSql = aceSqlParse(session, pos);
+        let currentClause = parsedSql.currentClause;
+        let isSubstring = this._makeIsSubstringFn(parsedSql.fromClause);
+        let matchingTables = _(this._columns.uniqueTables).filter(isSubstring);
+        let matchingSchemas = _(this._columns.uniqueSchemas).filter(isSubstring);
+
+        if (_.exists(this._matcherRunner)) {
+          let matches = this._matcherRunner.execute(currentClause, {
+            tableRestrict: matchingTables,
+            schemaRestrict: matchingSchemas
+          }, prefix);
+
+          callback(null, matches);
+        }
+      }
+
+      // private methods
+
+      _makeIsSubstringFn(check) {
+        return string => _.exists(check) ? check.indexOf(string) > -1 : false;
+      }
+    };
+  }
+
+
+  SchemaCompleterImports.$inject = ['aceSqlParse', 'SchemaColumns', 'MatcherRunner', 'SCHEMA_MATCHERS'];
+  angular.module('alephServices.schemaCompleter', ['aleph.schemaCompleterConfig'])
+    .service('SchemaCompleter', SchemaCompleterImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/lib/selection_tag_input.js.es6

@@ -0,0 +1,42 @@
+!(angular => {
+  'use strict';
+
+  class SelectionTagInput {
+    constructor(options) {
+      this._items = this._makeItemsFn(options.items, options.iteratee);
+      this._itemField = options.itemField;
+      this.selectedTags = [];
+    }
+
+    add(tag) {
+      _.each(this._items(), item => {
+        item[this._itemField].unshift(tag.text);
+      });
+    }
+
+    remove(tag) {
+      _.each(this._items(), item => {
+        item[this._itemField] = _.reject(item[this._itemField], itemTag => {
+          return tag.text === itemTag;
+        });
+      });
+    }
+
+    onSelection() {
+      this.selectedTags = _.reduce(this._items(), (acc, item) => {
+        return _.uniq(acc.concat(item[this._itemField]));
+      }, []);
+    }
+
+    // private methods
+
+    _makeItemsFn(items, _iteratee) {
+      let rawItems = _.isFunction(items) ? items : () => items;
+      let iteratee = _iteratee;
+      return _.isFunction(iteratee) ? () => _.map(rawItems(), iteratee) : rawItems;
+    }
+  }
+
+  angular.module('alephServices.selectionTagInput', []).service('SelectionTagInput', () => SelectionTagInput);
+
+}(angular));

data/app/assets/javascripts/angular/services/lib/server_configurations.js.es6

@@ -0,0 +1,15 @@
+!(angular => {
+  'use strict';
+
+  class ServerConfigurations {
+    constructor() {
+      this.configurations = {};
+    }
+
+    setConfigs(c) {
+      this.configurations = JSON.parse(c);
+    }
+  }
+
+  angular.module('alephServices.serverConfigurations', []).service('ServerConfigurations', ServerConfigurations);
+}(angular));

data/app/assets/javascripts/angular/services/lib/spinner_state.js.es6

@@ -0,0 +1,45 @@
+!(angular => {
+  'use strict';
+
+  class Spinner {
+
+    constructor(context) {
+      this.context = context;
+      this.active = false;
+    }
+
+    on() {
+      this.active = true;
+    }
+
+    off() {
+      this.active = false;
+    }
+  }
+
+  class SpinnerState {
+    constructor() {
+      this._spinnersMap = {};
+    }
+
+    withContext(context) {
+      if (!_.has(this._spinnersMap, context))  {
+        this._spinnersMap[context] = new Spinner(context);
+      }
+
+      return this._spinnersMap[context];
+    }
+
+    isActive() {
+      return _.some(this._spinners(), spinner => spinner.active );
+    }
+
+    _spinners() {
+      return _.values(this._spinnersMap);
+    }
+
+  }
+
+  angular.module('alephServices.spinnerState', []).service('SpinnerState', SpinnerState);
+
+}(angular));

data/app/assets/javascripts/angular/services/lib/tag_resource.js.es6

@@ -0,0 +1,14 @@
+(angular => {
+  'use strict';
+
+  angular.module('alephServices.tagResource', [])
+
+  .factory('TagResource', ['$resource',
+    function ($resource) {
+      return $resource('/tags/:id.json', {id: '@id'}, {
+        index:   { method: 'GET', isArray: true, responseType: 'json'},
+      });
+    }
+  ]);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/collection_dirty_awareness.js.es6

@@ -0,0 +1,33 @@
+!(angular => {
+  'use strict';
+
+  /* Dirty Aware methods for a collection of DirtyAwareModel's */
+
+  class CollectionDirtyAwareness {
+
+    constructor(models) {
+      this._models = models;
+    }
+
+    dirtyItems() {
+      return _.filter(this._models(), model => model.isDirty());
+    }
+
+    isDirty() {
+      return this.dirtyItems().length > 0;
+    }
+
+    isPristine() {
+      return !this.isDirty();
+    }
+
+    revert() {
+      _.each(this._models(), model => {
+        model.revert();
+      });
+    }
+  }
+
+  angular.module('models.collectionDirtyAwareness', [])
+    .service('CollectionDirtyAwareness', () => CollectionDirtyAwareness);
+}(angular));

data/app/assets/javascripts/angular/services/model/collection_model_base.js.es6

@@ -0,0 +1,75 @@
+!(angular => {
+  'use strict';
+
+  function CollectionModelBaseImports($q) {
+
+    return class CollectionModelBase {
+
+      constructor(resource, Model) {
+        this.collection = [];
+        this._resource = resource;
+        this._Model = Model;
+      }
+
+      get Model() {
+        return this._Model;
+      }
+
+      internalize(items) {
+        if(_.exists(items) && _.isArray(items) && items.length > 0) {
+          this.collection = _.map(items, this._toModel.bind(this));
+        } else {
+          this.collection = [];
+        }
+      }
+
+      initCollection(params) {
+        return this._resource.index(params).$promise.then(items => {
+          this.internalize(items);
+          return this.collection;
+        });
+      }
+
+      save(saveParams, initParams) {
+        return this._saveCollection(saveParams, initParams, this.collection);
+      }
+
+      add(item) {
+        let model = this._toModel(item);
+        this.collection.unshift(model);
+        return model;
+      }
+
+      remove(item) {
+        let index = _.map(this.collection, m => m.item.id).indexOf(item.id);
+        return this.collection.splice(index, 1)[0];
+      }
+
+      items() {
+        return _.map(this.collection, o => o.item);
+      }
+
+      // protected methods
+
+      _saveCollection(saveParams, initParams, collection) {
+        return $q.all(
+            _.map(collection, m => m.save(saveParams))
+          ).then(this.initCollection.bind(this, initParams));
+      }
+
+      // private methods
+
+      _toModel(item) {
+        let m = new this._Model();
+        m.internalize(item);
+        return m;
+      }
+    };
+  }
+
+  CollectionModelBaseImports.$inject = ['$q'];
+
+  angular.module('models.collectionModelBase', [])
+    .service('CollectionModelBase', CollectionModelBaseImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/dirty_aware_collection_model.js.es6

@@ -0,0 +1,31 @@
+!(angular => {
+  'use strict';
+
+  function DirtyAwareCollectionModelImports(CollectionDirtyAwareness, CollectionModelBase) {
+
+    return class DirtyAwareCollectionModel extends CollectionModelBase {
+
+      constructor(resource, Model) {
+        super(resource, Model);
+        this._collectionDirtyAwareness = new CollectionDirtyAwareness(() => this.collection);
+
+        // delegated methods
+
+        this.dirtyItems     = this._collectionDirtyAwareness.dirtyItems.bind(this._collectionDirtyAwareness);
+        this.isDirty        = this._collectionDirtyAwareness.isDirty.bind(this._collectionDirtyAwareness);
+        this.isPristine     = this._collectionDirtyAwareness.isPristine.bind(this._collectionDirtyAwareness);
+        this.revert         = this._collectionDirtyAwareness.revert.bind(this._collectionDirtyAwareness);
+      }
+
+      save(saveParams, initParams) {
+        return this._saveCollection(saveParams, initParams, this.dirtyItems());
+      }
+    };
+  }
+
+  DirtyAwareCollectionModelImports.$inject = ['CollectionDirtyAwareness', 'CollectionModelBase'];
+
+  angular.module('models.dirtyAwareCollectionModel', [])
+    .service('DirtyAwareCollectionModel', DirtyAwareCollectionModelImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/dirty_aware_model.js.es6

@@ -0,0 +1,50 @@
+!(angular => {
+  'use strict';
+
+  function DirtyAwareModelImports(ModelBase, ModelState) {
+
+    return class DirtyAwareModel extends ModelBase {
+
+      constructor(resource, fields, comparators) {
+        super(resource);
+        this.modelState = new ModelState(fields, comparators);
+      }
+
+      set item(item) {
+        this._item = item;
+
+        if(this.modelState) {
+          this.modelState.snapshotItem(this._item);
+        }
+      }
+
+      get item() {
+        return this._item;
+      }
+
+      isPristine() {
+        if(this.isNew()) return true;
+        if(!this.isPersisted()) return false;
+
+        return this.modelState.isPristine(this.item);
+      }
+
+      isDirty() {
+        return !this.isPristine();
+      }
+
+      revert() {
+        this._item = this.modelState.snapshot;
+      }
+
+      isValidForSave() {
+        return this.isNew() || !this.isPersisted() || this.modelState.isDirty(this.item);
+      }
+
+    };
+  }
+
+  DirtyAwareModelImports.$inject = ['ModelBase', 'ModelState'];
+  angular.module('models.dirtyAwareModel', []).service('DirtyAwareModel', DirtyAwareModelImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/model_base.js.es6

@@ -0,0 +1,80 @@
+!(angular => {
+  'use strict';
+
+  function ModelBaseImports($q) {
+
+    return class ModelBase {
+
+      constructor(resource) {
+        this._resource = resource;
+        this.item = {};
+      }
+
+      internalize(item) {
+        if (item) {
+          this.item = item;
+        } else {
+          this.item = {};
+        }
+      }
+
+      // higher order CRUD functions
+      initItem(itemId) {
+        if(itemId) {
+          return this.fetch({ id: itemId });
+        } else {
+          this.item = this._newItem();
+          return $q.when(this.item);
+        }
+      }
+
+      save(params) {
+        return this.isPersisted() ? this.update(_.merge(this.item, params)) : this.create(_.merge(this.item, params));
+      }
+
+      // fundemental CRUD functions
+      destroy() {
+        return this._resource.destroy({ id: this.item.id }).$promise.then(item => item);
+      }
+
+      fetch(params) {
+        return this._resource.show(params).$promise.then(i => {
+          this.item = i;
+          return this.item;
+        });
+      }
+
+      update(params) {
+        return this._resource.update(params).$promise.then(i => {
+          this.item = i;
+          return this.item;
+        });
+      }
+
+      create(params) {
+        return this._resource.create(params).$promise.then(i => {
+          this.item = i;
+          return this.item;
+        });
+      }
+
+      isPersisted() {
+        return _.exists(this.item.id);
+      }
+
+      isNew() {
+        return JSON.stringify(this.item) === JSON.stringify(this._newItem());
+      }
+
+      // protected methods
+
+      _newItem() {
+        throw '#_newItem must be implemented in subclasses!';
+      }
+    };
+  }
+
+  ModelBaseImports.$inject = ['$q'];
+  angular.module('models.modelBase', []).service('ModelBase', ModelBaseImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/model_state.js.es6

@@ -0,0 +1,51 @@
+!(angular => {
+  'use strict';
+
+  class ModelState {
+
+    constructor(fields, comparators = {}) {
+      this._fields = fields;
+      this._comparators = this._defaultComparators(fields, comparators);
+    }
+
+    snapshotItem(item) {
+      this._snapshot = angular.copy(item);
+    }
+
+    get snapshot() {
+      return angular.copy(this._snapshot);
+    }
+
+    isPristine(item) {
+      return _.every(this._fields, field => {
+        return this._comparators[field] (
+          this._resolve(field, item),
+          this._resolve(field, this._snapshot)
+        );
+      });
+    }
+
+    isDirty(item) {
+      return !this.isPristine(item);
+    }
+
+    // private methods
+
+    _resolve(path, obj, safe = true) {
+      return path.split('.').reduce((prev, curr) => {
+        return !safe ? prev[curr] : (prev ? prev[curr] : undefined);
+      }, obj || this);
+    }
+
+    _defaultComparators(fields, comparators) {
+      let defaulted = {};
+      _.each(fields, f => {
+        defaulted[f] = comparators[f] || ((l, r) => JSON.stringify(l) === JSON.stringify(r));
+      });
+      return defaulted;
+    }
+  }
+
+  angular.module('models.modelState', []).service('ModelState', () => ModelState);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/models.js.es6

@@ -0,0 +1,15 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('models', [
+      'models.collectionDirtyAwareness',
+      'models.dirtyAwareCollectionModel',
+      'models.dirtyAwareModel',
+      'models.modelState',
+      'models.collectionModelBase',
+      'models.modelBase',
+      'models.unpersistedModel'
+    ]);
+
+}(angular));

data/app/assets/javascripts/angular/services/model/unpersisted_model.js.es6

@@ -0,0 +1,20 @@
+!(angular => {
+  'use strict';
+
+  class UnpersistedModel {
+    constructor() {
+      this.item = {};
+    }
+
+    internalize(item) {
+      this.item = item;
+    }
+
+    save() {
+      throw 'Cannot save an unpersisted model';
+    }
+  }
+
+  angular.module('models.unpersistedModel', []).service('UnpersistedModel', () => UnpersistedModel);
+
+}(angular));

data/app/assets/javascripts/angular/services/model_generation/model_factory.js.es6

@@ -0,0 +1,28 @@
+!(angular => {
+  'use strict';
+
+  function ModelFactory(StandardModel, StandardCollectionModel) {
+
+    this.makeCollectionModel = function makeCollectionModel(name, Model, resource) {
+      return class FactoryCollectionModel extends StandardCollectionModel {
+        constructor() {
+          super(name, resource, Model);
+        }
+      };
+    };
+
+    this.makeModel = function makeModel(name, newItem, resource, options = {}) {
+      let dirtyAwareFields = options.dirtyAwareFields || _.keys(newItem);
+      let dirtyAwareComparators = options.dirtyAwareComparators;
+
+      return class FactoryModel extends StandardModel {
+        constructor() {
+          super(name, resource, newItem, dirtyAwareFields, dirtyAwareComparators);
+        }
+      };
+    };
+  }
+
+  ModelFactory.$inject = ['StandardModel', 'StandardCollectionModel'];
+  angular.module('modelGeneration.modelFactory', []).service('ModelFactory', ModelFactory);
+}(angular));

data/app/assets/javascripts/angular/services/model_generation/model_generation.js.es6

@@ -0,0 +1,13 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('modelGeneration', [
+      'modelGeneration.modelFactory',
+      'modelGeneration.modelManager',
+      'modelGeneration.resourceFactory',
+      'modelGeneration.standardModel',
+      'modelGeneration.standardCollectionModel'
+    ]);
+
+}(angular));

data/app/assets/javascripts/angular/services/model_generation/model_manager.js.es6

@@ -0,0 +1,86 @@
+!(angular => {
+  'use strict';
+
+  class ModelManager {
+
+    constructor(ModelFactory, ResourceFactory, ModelDefinitions) {
+      this._ModelFactory = ModelFactory;
+      this._ResourceFactory = ResourceFactory;
+      this._definitions = ModelDefinitions;
+      this._resources = {};
+      this._modelClasses = {};
+      this._collectionModelClasses = {};
+    }
+
+    forModelName(name) {
+      let definition = this._definitions[name];
+      let resource = this._loadResource(name, definition.resource);
+
+      return {
+        resource: () => resource,
+        modelClass: () => {
+          return this._loadModelClass(name, definition.newItem, resource, definition.options);
+        },
+        collectionClass: Model => {
+          return this._loadCollectionModelClass(pluralize.plural(name), Model, resource);
+        }
+      };
+    }
+
+    // private methods
+
+    _loadCollectionModelClass(name, Model, resource) {
+      return this._load(
+        this._collectionModelClasses,
+        name,
+        this._ModelFactory.makeCollectionModel,
+        this._ModelFactory,
+        name,
+        Model,
+        resource
+      );
+    }
+
+    _loadModelClass(name, newItem, resource, options) {
+      return this._load(
+        this._modelClasses,
+        name,
+        this._ModelFactory.makeModel,
+        this._ModelFactory,
+        name,
+        newItem,
+        resource,
+        options
+      );
+    }
+
+    _loadResource(name, resourceArgs) {
+      let resourceName = this._capitalize(name) + 'Resource';
+      return this._load(
+        this._resources,
+        resourceName,
+        this._ResourceFactory.make,
+        this._ResourceFactory,
+        resourceArgs.path,
+        resourceArgs.parameters,
+        resourceArgs.actions
+      );
+    }
+
+    _load(cache, key, f, context, ...args) {
+      let o = cache[key];
+      if (!_.exists(o)) {
+        o = f.apply(context, args);
+        cache[key] = o;
+      }
+      return o;
+    }
+
+    _capitalize(s) {
+      return s.charAt(0).toUpperCase() + s.slice(1);
+    }
+  }
+
+  ModelManager.$inject = ['ModelFactory', 'ResourceFactory', 'ModelDefinitions'];
+  angular.module('modelGeneration.modelManager', []).service('ModelManager', ModelManager);
+}(angular));