aleph_analytics 0.0.0.alpha

data/public/assets/angular/directives/visualization_directive.js-82cb45a52eba62deb283a3699add1b33.es6

@@ -0,0 +1,101 @@
+!(angular => {
+  'use strict';
+
+  class VisualizationController {
+
+    constructor($sce, VisualizationService, DefaultAceConfigurator) {
+      /* initialize visualization components and expose in controller */
+      VisualizationService.initService();
+      this.visualization = VisualizationService.visualization;
+      this.visualizations = VisualizationService.visualizations;
+      this.sourceRenderer = VisualizationService.sourceRenderer;
+      VisualizationService.sourceRenderer.setResults(this.results);
+      this.presetDisplayList = () => VisualizationService.presetDisplayList;
+      this._service = VisualizationService;
+
+      /* aceLoaded is bound to ui-ace config object */
+      let _this = this;
+      this.aceLoaded = function aceLoaded(editor) {
+        new DefaultAceConfigurator(editor);
+        editor.setOptions({
+          maxLines: 40,
+          minLines: 2
+        });
+        _this.aceEditor = editor;
+      };
+
+      this._$sce = $sce;
+    }
+
+    toggleEditor() {
+      this.editorSelected = !this.editorSelected;
+
+      // FIXME: we have to do this because ng-model on ace does not work while hidden
+      if (this.editorSelected) {
+        this.aceEditor.setValue(this.visualization.item.html_source, -1);
+      }
+    }
+
+    renderedSource() {
+      return this.sourceRenderer.isValid() ? this._$sce.trustAsHtml(this.sourceRenderer.rendered()) : '';
+    }
+
+    save() {
+      // TODO: use bootbox.js to dress this up
+      if(!this.visualization.hasTitle()) {
+        let answer = prompt("Please enter a title for this visualization:");
+        if (answer === null || answer === '') {
+          return;
+        }
+        this.visualization.item.title = answer;
+      }
+
+      this.visualization.save(this.queryId, this.queryVersionId).then(() => {
+        this.visualizations.initCollection({ query_id: this.queryId, query_version_id: this.queryVersionId });
+      });
+    }
+
+    destroy() {
+      this.visualization.destroy().then(() => {
+        this._service.load(this.queryId, this.queryVersionId);
+      });
+    }
+
+    selectVisualization(visualization) {
+      this.visualization.internalize(visualization);
+    }
+
+    selectPreset(presetName) {
+      if(this.visualization.isDirty()) {
+        let answer = confirm('You are about to overwrite some unsaved changes, proceed?');
+        if (!answer) return;
+      }
+      this.visualization.initItem().then(() => {
+        this.visualization.item.html_source = this._service.presets[presetName];
+      });
+    }
+  }
+
+  VisualizationController.$inject = ['$sce', 'VisualizationService', 'DefaultAceConfigurator'];
+
+  function visualizationComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'queryId': '=',
+        'queryVersionId': '=',
+        'results': '='
+      },
+      templateUrl: 'visualization',
+      controller: 'VisualizationController',
+      controllerAs: 'vizShowCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.visualization', ['alephServices'])
+    .controller('VisualizationController', VisualizationController)
+    .directive('visualization', visualizationComponent);
+
+}(angular));

data/public/assets/angular/filters/filters.js-48cdb16fc89337e861c9f18ad57fd9bf.es6

@@ -0,0 +1,27 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('alephFilters', [])
+    .filter('objectDotKeys', () => {
+      // this is literally only needed because of https://github.com/angular/angular.js/issues/6210
+      return input => {
+        return Object.keys(input);
+      };
+    })
+
+    .filter('humanReadableDuration', () => {
+      return (original_seconds) => {
+        let SECONDS_IN_HOUR = 3600;
+        let SECONDS_IN_MINUTE = 60;
+
+        let hours = Math.floor(original_seconds / SECONDS_IN_HOUR);
+        let minutes = Math.floor((original_seconds % SECONDS_IN_HOUR) / SECONDS_IN_MINUTE);
+        let seconds = Math.round(original_seconds % SECONDS_IN_MINUTE);
+
+        return ((original_seconds > SECONDS_IN_HOUR) ? hours + ' hours ' : '') +
+               ((original_seconds > SECONDS_IN_MINUTE) ? minutes + ' minutes ' : '') +
+               seconds + ' seconds';
+      };
+    });
+}(angular));

data/public/assets/angular/services/alert/alert.js-a76ea96e948de324fcc00f3ef3ecae4e.es6

@@ -0,0 +1,51 @@
+!(angular => {
+  'use strict';
+
+  function AlertModelImports(AlertResource, StandardModel, PollService) {
+
+    return class Alert extends StandardModel {
+
+      constructor() {
+        super(
+          'alert',
+          AlertResource,
+          {
+            email: '',
+            query_title: '',
+            target: NaN,
+            comparator: '',
+            status: '',
+            description: ''
+          },
+          [
+            'email',
+            'comparator',
+            'target',
+            'description',
+            'query_title'
+          ]
+         );
+        this._pollItemKey = 'alertItem_' + new Date().getTime();
+      }
+
+      save() {
+        if (this.item.status !== 'Paused') {
+          this.item.status = 'Pending';
+        }
+
+        return super.save().then(this._pollItem.bind(this));
+      }
+
+      //private methods
+
+      _pollItem(item) {
+        PollService.unPoll(this._pollItemKey);
+        PollService.poll(item, this._pollItemKey, () => item.status !== 'Pending');
+        return item;
+      }
+    };
+  }
+
+  AlertModelImports.$inject = ['AlertResource', 'StandardModel', 'PollService'];
+  angular.module('alephServices.alert', []).service('Alert', AlertModelImports);
+}(angular));

data/public/assets/angular/services/alert/alert_resource.js-ac68ea99936eb213c0fb37d4fbb1511a.es6

@@ -0,0 +1,10 @@
+!(angular => {
+  'use strict';
+
+  function AlertResource(ResourceFactory) {
+    return ResourceFactory.make('/alerts/:id.json', {id: '@id'});
+  }
+
+  AlertResource.$inject = ['ResourceFactory'];
+  angular.module('alephServices.alertResource', []).service('AlertResource', AlertResource);
+}(angular));

data/public/assets/angular/services/lib/ace_completers.js-5353182bc538210dad12865ad6a060fd.es6

@@ -0,0 +1,29 @@
+!(angular => {
+  'use strict';
+
+  class AceCompleters {
+    constructor(SchemaCompleter, KeywordCompleter) {
+      this.langTools = ace.require('ace/ext/language_tools');
+      this.schemaCompleter = new SchemaCompleter();
+      this.keywordCompleter = new KeywordCompleter();
+    }
+
+    ensureSchemasData() {
+      if (!this.schemaCompleter.isLoaded()) {
+        return this.schemaCompleter.loadColumnData();
+      }
+    }
+
+    setCompleters() {
+      this.langTools.setCompleters([
+        this.schemaCompleter,
+        this.keywordCompleter,
+        this.langTools.textCompleter,
+        this.langTools.snippetCompleter
+      ]);
+    }
+  }
+
+  AceCompleters.$inject = ['SchemaCompleter', 'KeywordCompleter'];
+  angular.module('alephServices.aceCompleters', []).service('AceCompleters', AceCompleters);
+}(angular));

data/public/assets/angular/services/lib/ace_sql_parse.js-4114a8ad4fe4dbf4f72c0ab7fca22e83.es6

@@ -0,0 +1,156 @@
+!(angular => {
+  'use strict';
+
+  function AceSqlParse(session, cursorPos) {
+    let Search = ace.require('ace/search').Search;
+    let search = new Search();
+    let Range = ace.require('ace/range').Range;
+    let previousOccurances = [];
+    let nextOccurances = [];
+    let locationsInitialized = false;
+    let relevantFromBoundariesForClause = {
+      select: {
+        start: {
+          location: nextOccurances,
+          type: 'from'
+        },
+        end: {
+          location: nextOccurances,
+          type: 'where'
+        }
+      },
+      from: {
+        start: {
+          location: previousOccurances,
+          type: 'from'
+        },
+        end: {
+          location: nextOccurances,
+          type: 'where'
+        }
+      },
+      where: {
+        start: {
+          location: previousOccurances,
+          type: 'from'
+        },
+        end: {
+          location: previousOccurances,
+          type: 'where'
+        }
+      }
+    };
+    let currentClause;
+
+    function previousOccurance(word) {
+      search.set({needle: word, start: cursorPos, wholeWord: true, backwards: true,  wrap: false});
+      return findResult(word);
+    }
+
+    function nextOccurance(word) {
+      search.set({needle: word, start: cursorPos, wholeWord: true, backwards: false, wrap: false});
+      return findResult(word);
+    }
+
+    function findResult(word) {
+      let result = search.find(session);
+      if (_.exists(result)) {
+        return _.merge(result, {type: word});
+      }
+    }
+
+    function sortPositions(positionObjects) {
+      return positionObjects.sort(function (a, b) {
+        let aRow = a.start.row;
+        let bRow = b.start.row;
+        let aColumn = a.start.column;
+        let bColumn = b.start.column;
+
+        if (aRow === bRow) {
+          return (aColumn < bColumn) ? -1 : (aColumn > bColumn) ? 1 : 0;
+        } else {
+          return (aRow < bRow) ? -1 : 1;
+        }
+      });
+    }
+
+    function initLocations() {
+      _.each(['select', 'from', 'where'], function(clause) {
+        previousOccurances.push(previousOccurance(clause));
+        nextOccurances.push(nextOccurance(clause));
+      });
+
+      previousOccurances = _.compact(previousOccurances);
+      nextOccurances = _.compact(nextOccurances);
+      locationsInitialized = true;
+    }
+
+    function parseCurrentClause() {
+      if (locationsInitialized === false) { initLocations(); }
+      if (previousOccurances.length === 0) { return false; }
+
+      let locationsWithCursor = _.union(previousOccurances, [{start: cursorPos, type: 'cursor'}]);
+
+      let sorted = sortPositions(locationsWithCursor);
+      let cursorIndex = _.findIndex(sorted, {type: 'cursor'});
+      let recentObject = sorted[cursorIndex - 1];
+
+      currentClause = recentObject.type;
+      return currentClause;
+    }
+
+    function parseFromClause() {
+      if (locationsInitialized === false) { initLocations(); }
+      if (!_.exists(currentClause)) { parseCurrentClause(); }
+
+      let rangeStartWord,
+        rangeEndWord,
+        fromLocation = relevantFromBoundariesForClause[currentClause];
+
+      if (_.exists(fromLocation)) {
+        rangeStartWord = _.findWhere(fromLocation.start.location, {type: fromLocation.start.type});
+        rangeEndWord = _.findWhere(fromLocation.end.location, {type: fromLocation.end.type}) ||
+          _.findWhere(nextOccurances, {type: 'select'});
+      }
+
+      if (!_.exists(rangeStartWord)) {
+        rangeStartWord = defaultFromRangeStart();
+      }
+
+      if (!_.exists(rangeEndWord)) {
+        rangeEndWord = defaultFromRangeEnd();
+      }
+
+      let range = new Range(rangeStartWord.end.row, rangeStartWord.end.column,
+        rangeEndWord.start.row, rangeEndWord.start.column);
+      return session.getTextRange(range);
+    }
+
+    function defaultFromRangeStart() {
+      return {
+        end: {
+          row: 0,
+          column: 0
+        }
+      };
+    }
+
+    function defaultFromRangeEnd() {
+      let aceDocument = session.getDocument();
+      let rows = aceDocument.getLength();
+      let lastLine = aceDocument.getLine(rows - 1);
+      let width = lastLine.length;
+
+      return {
+        start: {
+          row: rows,
+          column: width
+        }
+      };
+    }
+
+    return {currentClause: parseCurrentClause(), fromClause: parseFromClause()};
+  }
+
+  angular.module('alephServices.aceSqlParse', []).service('aceSqlParse', () => AceSqlParse);
+}(angular));

data/public/assets/angular/services/lib/action_handler.js-85a8f75f507efcf2fe950fa7717b6976.es6

@@ -0,0 +1,73 @@
+!(angular => {
+  'use strict';
+
+  function ActionHandlerImports(AlertFlash, SpinnerState, $q) {
+
+    return class ActionHandler {
+
+      constructor(modelName, options = {}) {
+        let noop = () => undefined;
+        this._modelName = modelName;
+        this._modelItem = options.modelItem || noop;
+        this._modelCollection = options.modelCollection || noop;
+
+        this.wrapFetch = _.partial(this.wrapAction, 'fetching');
+        this.wrapUpdate = _.partial(this.wrapAction, 'updating');
+        this.wrapCreate = _.partial(this.wrapAction, 'creating');
+        this.wrapDestroy = _.partial(this.wrapAction, 'deleting');
+
+        // handlers for collection models
+        this.wrapInitCollection = _.partial(this.wrapAction, 'loading');
+        this.wrapCollectionSave = _.partial(this.wrapAction, 'saving');
+      }
+
+      wrapAction(actionName, f) {
+        let spinner = SpinnerState.withContext(this._modelName + '.' + actionName);
+        spinner.on();
+        return f()
+          .then(this.onSuccess.bind(this, actionName))
+          .catch(this.onError.bind(this, actionName))
+          .finally(spinner.off.bind(spinner));
+      }
+
+      // protected methods
+
+      onError(action, e) {
+        AlertFlash.emitDanger(this._msg('Failed', action));
+        return $q.reject(e);
+      }
+
+      onSuccess(action, o) {
+        // TODO: implement something sweet if we only had like a status bar or something
+        return o;
+      }
+
+      // private
+
+      _msg(status, action) {
+        return status + ' ' + action + ' ' + this._modelName + this._itemSuffix();
+      }
+
+      _itemSuffix() {
+        let item = this._modelItem();
+        let collection = this._modelCollection();
+
+        let suffix = '';
+        if(_.exists(item)) {
+          if(_.exists(item.title) && item.title.length !== 0) {
+            suffix = ', title = ' + item.title;
+          } else if (_.exists(item.id) && item.id > 0) {
+            suffix = ', id = ' + item.id;
+          }
+        } else if(_.exists(collection)) {
+          suffix = ', count = ' + collection.length;
+        }
+        return suffix;
+      }
+    };
+  }
+
+  ActionHandlerImports.$inject = ['AlertFlash', 'SpinnerState', '$q'];
+  angular.module('alephServices.actionHandler', []).service('ActionHandler', ActionHandlerImports);
+
+}(angular));

data/public/assets/angular/services/lib/alert_flash.js-7a4fe7ef5510a224677a12ecf2fe973b.es6

@@ -0,0 +1,30 @@
+!(angular => {
+  'use strict';
+
+  class AlertFlash {
+    constructor($rootScope) {
+      this._$rootScope = $rootScope;
+      this.emitSuccess = _.partial(this.emit, 'success');
+      this.emitInfo = _.partial(this.emit, 'info');
+      this.emitWarning = _.partial(this.emit, 'warning');
+      this.emitDanger = _.partial(this.emit, 'danger');
+    }
+
+    emit(type, message, schedule) {
+      this._$rootScope.$broadcast(schedule ? 'scheduleAlert' : 'setAlert', {
+        type: type,
+        message: message
+      });
+    }
+
+    // use this if you need to surface raw error to user
+    emitError(message, error) {
+      let e =  ' => ' + (_.exists(error) ? error : '');
+      this.emitDanger(message + e);
+    }
+  }
+
+  AlertFlash.$inject = ['$rootScope'];
+  angular.module('alephServices.alertFlash', []).service('AlertFlash', AlertFlash);
+
+}(angular));

data/public/assets/angular/services/lib/default_ace_configurator_service.js-9b83d6b53495dafe10bfed5074c3ec01.es6

@@ -0,0 +1,74 @@
+!(angular => {
+  'use strict';
+
+  function DefaultAceConfiguratorImports(ModelManager, AceSnippetManager) {
+
+    return class DefaultAceConfigurator {
+
+      constructor(editor) {
+        this._editor = editor;
+        this._defaultConfig();
+
+        this._Snippet = ModelManager.forModelName('snippet').modelClass();
+        this._Snippets = ModelManager.forModelName('snippet').collectionClass(this._Snippet);
+        this._snippets = new this._Snippets();
+      }
+
+      readOnlyConfig() {
+        this._editor.setReadOnly(true);
+        this._editor.renderer.$cursorLayer.element.style.opacity=0;
+        this._editor.setOptions({
+          highlightActiveLine: false,
+          highlightGutterLine: false,
+          maxLines: 25,
+          minLines: 2
+        });
+        return this;
+      }
+
+      autoCompleteConfig() {
+        this._editor.setOptions({
+          enableSnippets: true,
+          enableBasicAutocompletion: true,
+          enableLiveAutocompletion: true
+        });
+        return this;
+      }
+
+      snippetsConfig() {
+        AceSnippetManager.reset();
+        this._snippets.initCollection().then(snippets => {
+          _.each(snippets, snippet => {
+            AceSnippetManager.add(snippet.item.name, snippet.item.content);
+          });
+        });
+
+        this.autoCompleteConfig();
+
+        return this;
+      }
+
+      // private method
+
+      _defaultConfig() {
+        let session = this._editor.getSession();
+        session.setTabSize(2);
+        session.setUseSoftTabs(true);
+        this._editor.setPrintMarginColumn(100);
+        this._editor.setShowPrintMargin(true);
+        this._editor.setBehavioursEnabled(true);
+        this._editor.$blockScrolling = Infinity;
+        this._editor.setOptions({
+          maxLines: 25,
+          minLines: 2
+        });
+      }
+    };
+  }
+
+  DefaultAceConfiguratorImports.$inject = ['ModelManager', 'AceSnippetManager'];
+  angular
+    .module('alephServices.defaultAceConfigurator', [])
+    .service('DefaultAceConfigurator', DefaultAceConfiguratorImports);
+
+}(angular));

data/public/assets/angular/services/lib/github_url_service.js-719084a625f60d20c24097f00813b481.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/public/assets/angular/services/lib/keyword_completer.js-560b51694457619401c72431dd7b647e.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/public/assets/angular/services/lib/local_resource.js-9b57357ed203c783708e48154721242a.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));