aleph_analytics 0.0.0.alpha

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

@@ -0,0 +1,53 @@
+!(angular => {
+  'use strict';
+
+  class GithubUrlService {
+    constructor(ServerConfigurations) {
+      this._isValid = _.exists(ServerConfigurations.configurations.github_owner)
+        && _.exists(ServerConfigurations.configurations.github_repo)
+        && _.exists(ServerConfigurations.configurations.github_ref);
+
+      if (this._isValid) {
+        this._branch = ServerConfigurations.configurations.github_ref.split('/')[1];
+        this._githubRoot = [
+          'https://github.com',
+          ServerConfigurations.configurations.github_owner,
+          ServerConfigurations.configurations.github_repo
+        ].join('/');
+      }
+    }
+
+    commits(queryId) {
+      return [
+        this._githubRoot,
+        'commits',
+        this._branch,
+        'query_' + queryId
+      ].join('/');
+    }
+
+    commit(version) {
+      return [
+        this._githubRoot,
+        'commit',
+        version.commit_sha
+      ].join('/');
+    }
+
+    compare(base, compare) {
+      return [
+        this._githubRoot,
+        'compare',
+        base.commit_sha + '...' + compare.commit_sha
+      ].join('/');
+    }
+
+    isValid() {
+      return this._isValid;
+    }
+
+  }
+
+  GithubUrlService.$inject = ['ServerConfigurations'];
+  angular.module('alephServices.githubUrlService', []).service('GithubUrlService', GithubUrlService);
+}(angular));

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

@@ -0,0 +1,36 @@
+!(angular => {
+  'use strict';
+
+  function KeywordCompleterImports(MatcherRunner, LocalResource) {
+
+    return class KeywordCompleter {
+      constructor() {
+        const matchers = [
+          {
+            meta: 'keyword',
+            contextRelevance: {
+              all: 1000
+            }
+          }
+        ];
+
+        let _this = this;
+        new LocalResource().get('keyword_config.json').then(keyword => {
+          _this._matcherRunner = new MatcherRunner(matchers, keyword.data);
+        });
+      }
+
+      getCompletions(editor, session, pos, prefix, callback) {
+        if (prefix.length === 0) { callback(null, []); return; }
+
+        if (_.exists(this._matcherRunner)) {
+          let matches = this._matcherRunner.execute('all', {}, prefix.toUpperCase());
+          callback(null, matches);
+        }
+      }
+    };
+  }
+
+  KeywordCompleterImports.$inject = ['MatcherRunner', 'LocalResource'];
+  angular.module('alephServices.keywordCompleter', []).service('KeywordCompleter', KeywordCompleterImports);
+}(angular));

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

@@ -0,0 +1,20 @@
+!(angular => {
+  'use strict';
+
+  function LocalResourceImports($http) {
+
+    return class LocalResource {
+
+      constructor(...paths) {
+        this.path = ['resources'].concat(paths);
+      }
+
+      get(resource) {
+        return $http.get(this.path.concat([resource]).join('/'));
+      }
+    };
+  }
+
+  LocalResourceImports.$inject = ['$http'];
+  angular.module('alephServices.localResource', []).service('LocalResource', LocalResourceImports);
+}(angular));

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

@@ -0,0 +1,48 @@
+(angular => {
+  'use strict';
+
+  class LockService {
+
+    constructor() {
+      this._locks = {};
+    }
+
+    attemptAcquire(lock) {
+      if(this._locks[lock]) {
+        return false;
+      } else {
+        this._locks[lock] = true;
+        return true;
+      }
+    }
+
+    release(lock) {
+      delete this._locks[lock];
+    }
+
+    tryWithLockAsync(lock, criticalSection) {
+      if(this.attemptAcquire(lock)) {
+        try {
+          this._locks[lock] = true;
+          return criticalSection(this.release.bind(this, lock));
+        } catch (e) {
+          this.release(lock);
+          throw e;
+        }
+      }
+    }
+
+    tryWithLock(lock, criticalSection) {
+      if(this.attemptAcquire(lock)) {
+        try {
+          this._locks[lock] = true;
+          return criticalSection();
+        } finally {
+          this.release(lock);
+        }
+      }
+    }
+  }
+
+  angular.module('alephServices.lockService', []).service('$lock', LockService);
+}(angular));

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

@@ -0,0 +1,42 @@
+(angular => {
+  'use strict';
+
+  /* utilize lock service to ensure we don't make http request unless
+     previous one has returned */
+
+  class LockingPollService {
+
+    constructor($lock, $interval) {
+      this._intervalPromises = {};
+      this._$lock = $lock;
+      this._$interval = $interval;
+      this.poll = _.wrap(this.pollWithFunction.bind(this), (func, resource, key, stopPolling) => {
+        return func(() => resource.$get(), key, stopPolling);
+      });
+    }
+
+    unPoll(key) {
+      this._$interval.cancel(this._intervalPromises[key]);
+      delete this._intervalPromises[key];
+    }
+
+    pollWithFunction(pollFunction, key, stopPolling) {
+      this._intervalPromises[key] = this._$interval(() => {
+        if (stopPolling()) {
+          this.unPoll(key);
+        } else {
+          /* request http get for a resource inside a lock
+              1) lock on key
+              2) $get makes an http request for the resource
+              3) (async) 'unlock' = callback function which releases the lock when the http request finishes */
+          this._$lock.tryWithLockAsync(key, unlock => {
+            pollFunction().then(unlock);
+          });
+        }
+      }, 5000);
+    }
+  }
+
+  LockingPollService.$inject = ['$lock', '$interval'];
+  angular.module('alephServices.pollService', []).service('PollService', LockingPollService);
+}(angular));

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

@@ -0,0 +1,65 @@
+!(angular => {
+  'use strict';
+
+  class MatcherRunner {
+
+    constructor(matchers, items) {
+      this._matchers = matchers;
+      this._items = items;
+    }
+
+    execute(currentContext, filterArgs, prefix) {
+      let allMatches = [];
+
+      _.each(this._matchers, matcher => {
+        if (this._isMatcherRelevant(matcher, currentContext)) {
+          let matches = this._uniqueFilteredMatches(matcher, currentContext, filterArgs, prefix);
+
+          _.each(matches, ea => {
+            allMatches.push({
+              name: ea,
+              value: ea,
+              score: matcher.contextRelevance[currentContext],
+              meta: matcher.meta
+            });
+          });
+        }
+      });
+
+      return allMatches;
+    }
+
+    // private methods
+
+    _uniqueFilteredMatches(matcher, currentContext, filterArgs, prefix) {
+      let filteredItems = _.map(this._items, item => {
+        if (!this._matcherFiltersForContext(matcher, currentContext) ||
+          this._itemSatisfiesFilters(matcher.contextItemFilters[currentContext], item, filterArgs)) {
+          let itemName = _.exists(matcher.nameProperty) ? item[matcher.nameProperty] : item;
+          if (itemName.indexOf(prefix) === 0) {
+            return itemName;
+          }
+        }
+      });
+
+      return _.compact(_.uniq(filteredItems));
+    }
+
+    _itemSatisfiesFilters(filters, item, filterArgs) {
+      return _.all(filters, filterFunc => filterFunc(item, filterArgs));
+    }
+
+    _matcherFiltersForContext(matcher, currentContext) {
+      return _.getPath(matcher, ('contextItemFilters.' + currentContext));
+    }
+
+    _isMatcherRelevant(matcher, currentContext) {
+      return _.any(_.keys(matcher.contextRelevance), contextKey => {
+        return (contextKey === currentContext);
+      });
+    }
+  }
+
+  angular.module('alephServices.matcherRunner', []).service('MatcherRunner', () => MatcherRunner);
+
+}(angular));

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

@@ -0,0 +1,45 @@
+!(angular => {
+  'use strict';
+
+  function NavigationGuardImports($window) {
+    return class NavigationGuard {
+      constructor($scope) {
+        this._$scope = $scope;
+        this._disabled = false;
+        this._previousOnBeforeUnload = $window.onbeforeunload;
+        $scope.$on('$destroy', () => {
+          $window.onbeforeunload = this._previousOnBeforeUnload;
+        });
+      }
+
+      registerOnBeforeUnload(fn) {
+        $window.onbeforeunload = () => {
+          if(this._disabled) {
+            return this._previousOnBeforeUnload();
+          } else {
+            return fn();
+          }
+        };
+        return this;
+      }
+
+      registerLocationChangeStart(fn) {
+        this._$scope.$on('$locationChangeStart', (e) => {
+          if (!this._disabled) { return fn(e); }
+        });
+        return this;
+      }
+
+      disable() {
+        this._disabled = true;
+      }
+
+      static defaultPreventer() {
+        return e => { e.preventDefault(); };
+      }
+    };
+  }
+
+  NavigationGuardImports.$inject = ['$window'];
+  angular.module('alephServices.navigationGuard', []).service('NavigationGuard', NavigationGuardImports);
+}(angular));

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

@@ -0,0 +1,56 @@
+!(angular => {
+  'use strict';
+
+  class OpenReplService {
+
+    constructor($uibModal, Query, AceCompleters) {
+      this._$modal = $uibModal;
+      this._Query = Query;
+      this._AceCompleters = AceCompleters;
+    }
+
+    open(options = {}) {
+      this._AceCompleters.ensureSchemasData();
+
+      let modalInstance = this._$modal.open({
+        animation: true,
+        templateUrl: 'queryRepl',
+        controller: 'QueryReplController',
+        controllerAs: 'queryRepl',
+        bindToController: true,
+        windowClass: 'query-repl-dialog',
+        backdrop: 'static',
+        keyboard: false,
+        resolve: {
+          query: () =>  _.exists(options.query) ? this._clone(options.query) : this._newQuery()
+        }
+      });
+
+      return modalInstance.result.then(({query, result}) => {
+        return {
+          query: this._clone(query),
+          result: result
+        };
+      });
+    }
+
+    // private methods
+
+    _clone(q) {
+      let copiedItem = angular.copy(q.item);
+      let m = new this._Query();
+      m.internalize(copiedItem);
+      return m;
+    }
+
+    _newQuery() {
+      let m = new this._Query();
+      m.initItem();
+      return m;
+    }
+  }
+
+  OpenReplService.$inject = ['$uibModal', 'Query', 'AceCompleters'];
+  angular.module('alephServices.openReplService', []).service('OpenReplService', OpenReplService);
+
+}(angular));

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

@@ -0,0 +1,38 @@
+!(angular => {
+  'use strict';
+
+  class PageTitleManager {
+
+    constructor(ApplicationTitle, $route) {
+      this._defaultTitle = ApplicationTitle;
+      this._$route = $route;
+    }
+
+    set title(t) {
+      this._title = t;
+    }
+
+    get title() {
+      if (Utils.stringHelpers.isPresent(this._title)) {
+        return this._title;
+      } else if(this._$route.current && Utils.stringHelpers.isPresent(this._$route.current.title)) {
+        return this._$route.current.title;
+      } else {
+        return this._defaultTitle;
+      }
+    }
+
+    onDestroy(scope) {
+      let _this = this;
+      scope.$on('$destroy', this.unset.bind(_this));
+    }
+
+    unset() {
+      this.title = undefined;
+    }
+  }
+
+  PageTitleManager.$inject = ['ApplicationTitle', '$route'];
+  angular.module('alephServices.pageTitleManager', []).service('PageTitleManager', PageTitleManager);
+
+}(angular));

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

@@ -0,0 +1,114 @@
+!(angular => {
+  'use strict';
+
+  function PaginationImports($lock, CollectionDirtyAwareness, $q) {
+
+    return class Pagination {
+
+      constructor(lockKey, resourceAction, Model, options = {}) {
+        this.search = options.initialSearch;
+        this.sortBy = options.initialSort;
+        this._Model = Model;
+        this._resourceAction = resourceAction;
+        this._lockKey = lockKey;
+        this._limit = options.limit || 30;
+        this._sortDescending = options.sortDescending === false ? false : true;
+        this._spinnerOn = _.partial(this._optionalCall, options.spinnerOn);
+        this._spinnerOff = _.partial(this._optionalCall, options.spinnerOff);
+        this._additionalParams = options.additionalParams || {};
+        this._$q = $q;
+        this._init();
+      }
+
+      reload() {
+        this._init();
+        this._fetch();
+      }
+
+      toggleSortOrder() {
+        this._sortDescending = !this._sortDescending;
+      }
+
+      fetch() {
+        if (!this._done) {
+          this._fetch();
+        }
+      }
+
+      save(params) {
+        return this._$q.all(_.map(this.dirtyItems(), m => m.save(params)));
+      }
+
+      // expose collection dirty awareness functionality
+
+      dirtyItems() {
+        return this._collectionDirtyAwareness.dirtyItems();
+      }
+
+      isDirty() {
+        return this._collectionDirtyAwareness.isDirty();
+      }
+
+      isPristine() {
+        return this._collectionDirtyAwareness.isPristine();
+      }
+
+      revert() {
+        return this._collectionDirtyAwareness.revert();
+      }
+
+      // private methods
+
+      _init() {
+        this.collection = [];
+        this._collectionDirtyAwareness = new CollectionDirtyAwareness(() => this.collection);
+        this._offset = 0;
+        this._done = false;
+        this._spinnerOn();
+      }
+
+      _optionalCall(f, ...args) {
+        if(_.exists(f) && _.isFunction(f)) {
+          f.apply(args);
+        }
+      }
+
+      _fetch() {
+        $lock.tryWithLockAsync(this._lockKey, unlock => {
+          let params = _.merge({
+            offset: this._offset,
+            limit: this._limit,
+            search: this.search,
+            sort_by: this.sortBy,
+            sort_descending: this._sortDescending
+          }, this._additionalParams);
+
+          this._resourceAction(params, items => {
+            if (items.length === 0) {
+              this._done = true;
+            } else {
+              _.each(items, item => {
+                let m = new this._Model();
+                m.internalize(item);
+                this.collection.push(m);
+              });
+            }
+            this._offset++;
+            this._spinnerOff();
+            unlock();
+            return items;
+          },
+          err => {
+            this._spinnerOff();
+            unlock();
+            return err;
+          });
+        });
+      }
+    };
+  }
+
+  PaginationImports.$inject = ['$lock', 'CollectionDirtyAwareness', '$q'];
+  angular.module('alephServices.pagination', ['models']).service('Pagination', PaginationImports);
+
+}(angular));

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

@@ -0,0 +1,91 @@
+!(angular => {
+  'use strict';
+
+  function PaginationComponentsImports($location, Pagination, SpinnerState) {
+
+    return class PaginationComponents {
+
+      constructor(key, resourceAction, Model, options = {}) {
+        this._spinner = SpinnerState.withContext(key);
+        this.searchText = this._intialSearch();
+
+        //default options
+        let additionalParams = options.additionalParams || {};
+        let sortBy = options.sortBy || 'updated_at';
+        let limit = options.limit;
+
+        this._pagination = new Pagination(key, resourceAction, Model, {
+          initialSearch: this.searchText,
+          initialSort: sortBy,
+          limit: limit,
+          spinnerOn: this._spinner.on.bind(this._spinner),
+          spinnerOff: this._spinner.off.bind(this._spinner),
+          additionalParams: additionalParams
+        });
+
+        // delegated methods
+        this.reload             = this._pagination.reload.bind(this._pagination);
+        this.toggleSortOrder    = this._pagination.toggleSortOrder.bind(this._pagination);
+        this.loadMore           = this._pagination.fetch.bind(this._pagination);
+        this.dirtyItems         = this._pagination.dirtyItems.bind(this._pagination);
+        this.isDirty            = this._pagination.isDirty.bind(this._pagination);
+        this.isPristine         = this._pagination.isPristine.bind(this._pagination);
+        this.revert             = this._pagination.revert.bind(this._pagination);
+        this.save               = this._pagination.save.bind(this._pagination);
+      }
+
+      items() {
+        return _.map(this.collection(), o => o.item);
+      }
+
+      collection() {
+        return this._pagination.collection;
+      }
+
+      clearSearch() {
+        if (this.searchText && this.searchText !== '') {
+          this.searchText = null;
+        }
+        this.triggerSearch();
+      }
+
+      setSearch(text, quote) {
+        if (quote) {
+          this.searchText = '\"' + text + '\"';
+        } else {
+          this.searchText = text;
+        }
+        this.triggerSearch();
+      }
+
+      setSort(sortBy) {
+        if (sortBy === this._pagination.sortBy) {
+          this._pagination.toggleSortOrder();
+        } else {
+          this._pagination.sortBy = sortBy;
+        }
+        this._pagination.reload();
+      }
+
+      triggerSearch() {
+        $location.search('search', this.searchText);
+        this._pagination.search = this.searchText;
+        this._pagination.reload();
+      }
+
+      // private methods
+
+      _intialSearch() {
+        let searchObject = $location.search();
+        if (!_.isEmpty(searchObject)) {
+          return searchObject.search;
+        }
+      }
+    };
+  }
+
+  PaginationComponentsImports.$inject = ['$location', 'Pagination', 'SpinnerState'];
+  angular.module('alephServices.paginationComponents', [])
+    .service('PaginationComponents', PaginationComponentsImports);
+
+}(angular));

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

@@ -0,0 +1,35 @@
+!(angular => {
+  'use strict';
+
+  class ParameterMethods {
+
+    constructor() {
+      this._parameterRegex = () => /\{\s*([^{}]+?)\s*}/g;
+    }
+
+    constructParameter(parameterName) {
+      return { name: parameterName, type: 'raw' };
+    }
+
+    detectParameters(body, parameters) {
+      let _this = this;
+      let matches = body.match(this._parameterRegex());
+      if (_.exists(matches)) {
+        matches.forEach(match => {
+          let parameterName = _this._parameterRegex().exec(match)[1];
+          if(_this._parameterExists(parameters, parameterName)) {
+            parameters.push(_this.constructParameter(parameterName));
+          }
+        });
+      }
+    }
+
+    // private methods
+
+    _parameterExists(parameters, parameterName) {
+      return _.findIndex(parameters, p => p.name === parameterName) === -1;
+    }
+  }
+
+  angular.module('alephServices.parameterMethods', []).service('ParameterMethods', ParameterMethods);
+}(angular));

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

@@ -0,0 +1,21 @@
+!(angular => {
+  'use strict';
+
+  class RoleModel {
+    constructor($resource) {
+      this.collection = [];
+      this._resource = $resource('/roles.json');
+    }
+
+    initCollection() {
+      return this._resource.query().$promise.then((roles) => {
+        this.collection = roles;
+        return roles;
+      });
+    }
+  }
+
+  RoleModel.$inject = ['$resource'];
+  angular.module('alephServices.roleModel', []).service('RoleModel', RoleModel);
+
+}(angular));