Huge refactor.

Author: niemyjski

.gitignore

@@ -1,14 +1,5 @@
+.DS_Store
+.idea
 node_modules
-bower_components
 public
-.DS_Store
-/.idea
-/src/.idea
-
-src/exceptionless.js.map
-src/exceptionless.js
-src/exceptionless-spec.js
-src/exceptionless-spec.js.map
-/src/dist
-/src/typings
-/typings
+typings

gulpfile.js

@@ -6,22 +6,22 @@ var rename = require('gulp-rename');
 var rimraf = require('rimraf');
 var sourcemaps = require('gulp-sourcemaps');
 var ts = require('gulp-typescript');
+var tsProject = require('tsproject');
 var uglify = require('gulp-uglify');
 
-var tsProject = ts.createProject({
-  declarationFiles: true,
-  module: 'AMD',
-  removeComments: true,
-  sortOutput: true,
-  sourceMap: true,
-  target: 'ES5'
-});
-
 gulp.task('clean', function (cb) {
   rimraf('./dist', cb);
 });
 
 gulp.task('scripts', function() {
+  function fixFilePath(files){
+    for (var index = 0; index < files.length; index++) {
+      files[index] = 'src/' + files[index];
+    }
+
+    return files;
+  }
+
   var files = [
     'node_modules/es6-promise/dist/es6-promise.js',
     'node_modules/stackframe/dist/stackframe.js',
@@ -31,7 +31,13 @@ gulp.task('scripts', function() {
     'node_modules/stacktrace-js/dist/stacktrace.js'
   ];
 
-  var tsResult = gulp.src(['src/exceptionless.ts']).pipe(ts(tsProject));
+  var tsconfig = require('./src/tsconfig.json');
+  var tsResult = gulp.src(fixFilePath(tsconfig.files))
+    .pipe(ts(tsconfig.compilerOptions));
+
+  //var tsResult = tsProject.src('./src');
+
+  // TODO: Look into using https://www.npmjs.com/package/gulp-wrap-umd
   return merge2(
     tsResult.dts.pipe(gulp.dest('dist')),
     merge2(gulp.src(files), tsResult.js)
@@ -52,7 +58,7 @@ gulp.task('watch', ['scripts'], function() {
 gulp.task('build', ['clean', 'scripts']);
 
 gulp.task('test', [], function() {
-  return gulp.src(['src/*-spec.ts'])
+  return gulp.src(['src/**/*-spec.ts'])
     .pipe(karma({
       configFile: 'karma.conf.js',
       action: 'run'

karma.conf.js

@@ -16,7 +16,7 @@ module.exports = function (config) {
       'node_modules/stacktrace-gps/dist/stacktrace-gps.js',
       'node_modules/stacktrace-js/dist/stacktrace.js',
 
-      'src/*.ts'
+      'src/**/*.ts'
     ],
     exclude: [],
     preprocessors: {

package.json

@@ -43,6 +43,7 @@
     "stackframe": "^0.2.2",
     "stacktrace-gps": "^2.1.2",
     "stacktrace-js": "git://github.com/stacktracejs/stacktrace.js.git",
+    "tsproject": "^0.5.7",
     "typescript": "1.5.0-alpha"
   },
   "dependencies": {}

src/EventBuilder.ts

@@ -0,0 +1,141 @@
+/// <reference path="references.ts" />
+
+module Exceptionless {
+  export class EventBuilder {
+    public target:IEvent;
+    public client:ExceptionlessClient;
+    public pluginContextData:ContextData;
+
+    constructor(event:IEvent, client:ExceptionlessClient, pluginContextData?:ContextData) {
+      this.target = event;
+      this.client = client;
+      this.pluginContextData = pluginContextData;
+    }
+
+    public setType(type:string): EventBuilder {
+      if (!!type && type.length > 0) {
+        this.target.type = type;
+      }
+
+      return this;
+    }
+
+    public setSource(source:string): EventBuilder {
+      if (!!source && source.length > 0) {
+        this.target.source = source;
+      }
+
+      return this;
+    }
+
+    public setSessionId(sessionId:string): EventBuilder {
+      if (!this.isValidIdentifier(sessionId)) {
+        throw new Error("SessionId must contain between 8 and 100 alphanumeric or '-' characters.");
+      }
+
+      this.target.session_id = sessionId;
+      return this;
+    }
+
+    public setReferenceId(referenceId:string): EventBuilder {
+      if (!this.isValidIdentifier(referenceId)) {
+        throw new Error("SessionId must contain between 8 and 100 alphanumeric or '-' characters.");
+      }
+
+      this.target.reference_id = referenceId;
+      return this;
+    }
+
+    public setMessage(message:string): EventBuilder {
+      if (!!message && message.length > 0) {
+        this.target.message = message;
+      }
+
+      return this;
+    }
+
+    public setGeo(latitude: number, longitude: number): EventBuilder {
+      if (latitude < -90.0 || latitude > 90.0)
+        throw new Error('Must be a valid latitude value between -90.0 and 90.0.');
+      if (longitude < -180.0 || longitude > 180.0)
+        throw new Error('Must be a valid longitude value between -180.0 and 180.0.');
+
+      this.target.geo = latitude + ',' + longitude;
+      return this;
+    }
+
+    public setValue(value:number): EventBuilder {
+      if (!!value) {
+        this.target.value = value;
+      }
+
+      return this;
+    }
+
+    public addTags(...tags:string[]): EventBuilder {
+      if (!tags || tags.length === 0) {
+        return this;
+      }
+
+      if (!this.target.tags) {
+        this.target.tags = [];
+      }
+
+      for (var index = 0; index < tags.length; index++) {
+        if (tags[index] && this.target.tags.indexOf(tags[index]) < 0) {
+          this.target.tags.push(tags[index]);
+        }
+      }
+
+      return this;
+    }
+
+    public setProperty(name:string, value:any): EventBuilder {
+      if (!name || (value === undefined || value == null)) {
+        return this;
+      }
+
+      if (!this.target.data) {
+        this.target.data = {};
+      }
+
+      this.target.data[name] = value;
+      return this;
+    }
+
+    public markAsCritical(critical:boolean): EventBuilder {
+      if (critical) {
+        this.addTags('Critical');
+      }
+
+      return this;
+    }
+
+    public submit(): Promise<any> {
+      return this.client.submitEvent(this.target, this.pluginContextData);
+    }
+
+    private isValidIdentifier(value:string): boolean {
+      if (!value || !value.length) {
+        return true;
+      }
+
+      if (value.length < 8 || value.length > 100) {
+        return false;
+      }
+
+      for (var index = 0; index < value.length; index++) {
+        var code = value.charCodeAt(index);
+        var isDigit = (code >= 48) && (code <= 57);
+        var isLetter = ((code >= 65) && (code <= 90)) || ((code >= 97) && (code <= 122));
+        var isMinus = code === 45;
+
+        if (!(isDigit || isLetter) && !isMinus) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+}

src/ExceptionlessClient-spec.ts

@@ -0,0 +1,26 @@
+/// <reference path="references.ts" />
+
+module Exceptionless {
+  describe('ExceptionlessClient', () => {
+    it('should use event reference ids', (done) => {
+      var error = new Error('From Unit Test');
+
+      var client = new ExceptionlessClient('LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw', 'http://localhost:50000');
+      expect(client.config.lastReferenceIdManager.getLast()).toBe(null);
+      client.submitException(error).then(
+        () => expect(client.config.lastReferenceIdManager.getLast()).toBe(null),
+        () => expect(client.config.lastReferenceIdManager.getLast()).toBe(null)
+      );
+
+      var numberOfPlugins = client.config.plugins.length;
+      client.config.useReferenceIds();
+      expect(client.config.plugins.length).toBe(numberOfPlugins + 1);
+
+      client.submitException(error)
+        .then(
+          () => expect(client.config.lastReferenceIdManager.getLast()).not.toBe(null),
+          () => expect(client.config.lastReferenceIdManager.getLast()).toBe(null))
+        .then(done);
+    }, 5000);
+  });
+}