sw2at-ui 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a5404de1a4d2e5bc0345da18a15c682e7a0b95b
-  data.tar.gz: 05addc5cc180d16f16a6865612076df959e9f92d
+  metadata.gz: 7857e82e50e84a809a23b3954a5e09d0d8d2cf11
+  data.tar.gz: 01c616fd52714cf6109fe0fb072a26d57f11702d
 SHA512:
-  metadata.gz: 41174a6f3ad946fb9a140f45d699d075230c739816cf7ea553c61a70af63811b5b70a772dc8be406e3573eb0e76b5ec8f31256ae5d003ee16afb8ec439981089
-  data.tar.gz: aeafc9c19be4f8d5af4af4e9e655c5229b455309f2cc8c420a2b145e9e09d35762b3ab5f8e3e83ed18fe73638a6aea4f123f1559819492cccdbde2ab17ed36aa
+  metadata.gz: 4a34ae34569c6985f5f9736d260a2834f431381884d0b5ac088bf57f44b9c3388a29671059bec6534befa0edfa9be47a3198b72b67789b8695f9d409457e1e93
+  data.tar.gz: 40f01fde652e0c708f8f381db0ff20144da05007208fbb145553239b31cf36f52ae50fa5b5ac0a7a553a1c07c569930a129709c0209fd84b445b19b0693d576a

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 gem 'rails', '>= 3.1'
 
-gem 'fire-model', '~> 0.0.15'
+gem 'fire-model', '~> 0.0.17'
 gem 'slim-rails'
 gem 'sass-rails'
 gem 'coffee-rails'

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/app/assets/javascripts/swat/app/app.coffee

@@ -4,6 +4,11 @@
 #= require_tree ./factories
 #= require_tree ./controllers
 
+window.Swat =
+  debug: true#false
+  log: (message)->
+    return unless window.Swat.debug
+    console.log(message)
 
 App = angular.module 'SWAT', [
   'ngResource'
@@ -11,6 +16,7 @@ App = angular.module 'SWAT', [
   'ui.router'
   'ui.bootstrap'
   'ngClipboard'
+  'highcharts-ng'
 ]
 
 App.config ($urlRouterProvider, $stateProvider) ->
@@ -29,6 +35,13 @@ App.config ($urlRouterProvider, $stateProvider) ->
         templateUrl:  "/swat/pages/revisions/show.html"
         controller: 'RevisionCtrl'
   )
+  .state("summary",
+    url: "/swat/summary/revisions/:branch/:user/:time"
+    views:
+      content:
+        templateUrl:  "/swat/pages/revisions/summary.html"
+        controller: 'SummaryCtrl'
+  )
 App.config(['ngClipProvider', (ngClipProvider)->
   ngClipProvider.setPath("/assets/swat/bower_components/zeroclipboard/dist/ZeroClipboard.swf")
 ])

data/app/assets/javascripts/swat/app/controllers/revisions.coffee

@@ -1,7 +1,7 @@
 angular.module("SWAT").controller "RevisionsCtrl", ($rootScope, $scope, $state, RevisionService)->
 
   $scope.init = ->
-    console.log('Revisions Controller initalized!')
+    window.Swat.log('Revisions Controller initalized!')
     $scope.initRevisions()
 
   $scope.initRevisions = ->

data/app/assets/javascripts/swat/app/controllers/root.coffee

@@ -1,7 +1,7 @@
 angular.module("SWAT").controller "RootCtrl", ($rootScope, $scope, $state) ->
 
   $scope.init = ->
-    console.log 'Swat Root initialized.'
+    window.Swat.log 'Swat Root initialized.'
 
   $scope.init()
 

data/app/assets/javascripts/swat/app/controllers/summary.coffee

@@ -0,0 +1,72 @@
+angular.module("SWAT").controller "SummaryCtrl", ($rootScope, $scope, $state, $stateParams
+  RevisionService, FailsGraph, SwatHelpers) ->
+
+  $scope.init = ->
+    $scope.summary = {}
+    $scope.reloadData()
+
+  $scope.reloadData = ->
+    return if $scope.revisionPromise && !$scope.revisionPromise.$resolved
+    params = { branch: $stateParams.branch, user: $stateParams.user, time: $stateParams.time }
+    $scope.revisionPromise = RevisionService.get(params)
+    $scope.revisionPromise.$promise.then($scope.initInformation)
+
+  $scope.initInformation = (revision)->
+    $scope.revision = revision
+    $scope.tests = _.flatten(_.map($scope.revision.data.threads, (thread)-> thread.tests || []))
+    window.Swat.log($scope.tests)
+    $scope.initFails()
+    $scope.initExceptions()
+    $scope.initMetrics()
+    $scope.initFailsStatsGraph()
+
+  $scope.initFails = ->
+    $scope.summary.fails = _.select($scope.tests, (t)->(t.exception) )
+
+  $scope.initExceptions = ->
+    groups = _.groupBy($scope.summary.fails, (f)->(f.exception.message) )
+    window.Swat.log(groups)
+
+    result = []
+    for exMessage in _.keys(groups)
+      exception =
+        message: exMessage
+        backtrace: groups[exMessage][0].exception.backtrace
+        tests: groups[exMessage]
+      result.push(exception)
+
+    window.Swat.log(result)
+    $scope.summary.exceptions = result
+
+  $scope.initFailsStatsGraph = ->
+    $scope.failsStats = new FailsGraph($scope.tests, $scope.summary.fails)
+    return
+    $scope.failsStats =1
+
+  $scope.initMetrics = ->
+    result = []
+    totalTests = $scope.tests.length
+    totalFailedTests = $scope.summary.fails.length
+    totalDuration = _.sum($scope.tests, 'run_time')
+    totalThreadDuration = _.sum($scope.revision.data.threads, 'total_runtime')
+    successPercentage =  (($scope.tests.length - $scope.summary.fails.length) / $scope.tests.length*100)
+
+    result.push({ name: 'Revision Name', value: $scope.revision.data.name })
+    result.push({ name: 'Revision Status', value: $scope.revision.data.status.name })
+    result.push({ name: 'Revision Branch', value: $scope.revision.data.branch })
+    result.push({ name: 'Revisor', value: $scope.revision.data.user })
+    result.push({ name: 'Threads Count', value: $scope.revision.data.threads_count })
+
+    result.push({ name: 'Total Tests', value: totalTests })
+    result.push({ name: 'Total Failed Tests', value: totalFailedTests })
+
+    result.push({ name: 'Total Tests Duration', value: SwatHelpers.formatTime(totalDuration) })
+    result.push({ name: 'Total Threads Duration', value: SwatHelpers.formatTime(totalThreadDuration) })
+
+    result.push({ name: 'Success Percentage', value: (successPercentage.toFixed(2)+'%') })
+
+    $scope.summary.metrics = result
+
+  $scope.init()
+
+

data/app/assets/javascripts/swat/app/factories/fails_graph.coffee

@@ -0,0 +1,45 @@
+class FailsGraph
+  constructor: (@tests, @fails) ->
+  conf: ->
+
+    res =
+      options:
+        chart:
+          plotBackgroundColor: null
+          plotBorderWidth: null
+          plotShadow: false
+          type: 'pie'
+      title:
+        text: 'Fail Rate'
+
+      tooltip:
+        pointFormat: '{series.name}: <b>{point.percentage:.1f}%</b>'
+      plotOptions: pie:
+        allowPointSelect: true
+        cursor: 'pointer'
+        dataLabels:
+          enabled: true
+          format:
+            '<b>{point.name}</b>: {point.percentage:.1f} %'
+          style:
+            color:
+              Highcharts.theme and Highcharts.theme.contrastTextColor or 'black'
+      series: [ {
+        name: 'Results'
+        colors: [ '#1FEC33', '#EC243B', '#90ed7d', '#f7a35c', '#8085e9', '#f15c80', '#e4d354', '#2b908f', '#f45b5b', '#91e8e1']
+        colorByPoint: true
+        data: [
+          {
+            name: 'Passed Examples'
+            y: (@tests.length - @fails.length)
+          }
+          {
+            name: 'Failed Examples'
+            y: @fails.length
+          }
+        ]
+      } ]
+
+angular.module("SWAT").factory "FailsGraph", ->
+  (tests, fails)->
+    new FailsGraph(tests, fails).conf()

data/app/assets/javascripts/swat/app/factories/helpers.coffee

@@ -0,0 +1,7 @@
+angular.module("SWAT").factory "SwatHelpers", ->
+  Helpers =
+    formatTime: (seconds) ->
+      hh = Math.floor(seconds / 3600)
+      mm = Math.floor(seconds / 60) % 60
+      ss = Math.floor(seconds) % 60
+      (if hh then (if hh < 10 then '0' else '') + hh + ':' else '') + (if mm < 10 and hh then '0' else '') + mm + ':' + (if ss < 10 then '0' else '') + ss

data/app/assets/javascripts/swat/app/factories/revision_model.coffee

@@ -1,8 +1,7 @@
 angular.module("SWAT").factory "RevisionModel", ->
   class RevisionModel
     constructor: (@data) ->
-      #@prepareThreads()
-      console.log(@data)
+      window.Swat.log(@data)
 
     prepareThreads: ->
       for thread in @data.threads

data/app/assets/javascripts/swat/bower_components.coffee

@@ -12,4 +12,7 @@
 #= require swat/bower_components/angular-bootstrap/ui-bootstrap.js
 #= require swat/bower_components/angular-bootstrap/ui-bootstrap-tpls.js
 #= require swat/bower_components/ng-clip/src/ngClip
-#= require swat/bower_components/zeroclipboard/dist/ZeroClipboard.js
+#= require swat/bower_components/zeroclipboard/dist/ZeroClipboard.js
+
+#= require swat/lib/highcharts.src.js
+#= require swat/lib/highcharts-ng.js

data/app/assets/javascripts/swat/lib/highcharts-ng.js

@@ -0,0 +1,396 @@
+if (typeof module !== 'undefined' && typeof exports !== 'undefined' && module.exports === exports){
+    module.exports = 'highcharts-ng';
+}
+(function () {
+    'use strict';
+    /*global angular: false, Highcharts: false */
+
+    angular.module('highcharts-ng', [])
+        .factory('highchartsNGUtils', highchartsNGUtils)
+        .directive('highchart', ['highchartsNGUtils', '$timeout', highchart]);
+
+    function highchartsNGUtils() {
+
+        return {
+
+            //IE8 support
+            indexOf: function (arr, find, i /*opt*/) {
+                if (i === undefined) i = 0;
+                if (i < 0) i += arr.length;
+                if (i < 0) i = 0;
+                for (var n = arr.length; i < n; i++)
+                    if (i in arr && arr[i] === find)
+                        return i;
+                return -1;
+            },
+
+            prependMethod: function (obj, method, func) {
+                var original = obj[method];
+                obj[method] = function () {
+                    var args = Array.prototype.slice.call(arguments);
+                    func.apply(this, args);
+                    if (original) {
+                        return original.apply(this, args);
+                    } else {
+                        return;
+                    }
+
+                };
+            },
+
+            deepExtend: function deepExtend(destination, source) {
+                //Slightly strange behaviour in edge cases (e.g. passing in non objects)
+                //But does the job for current use cases.
+                if (angular.isArray(source)) {
+                    destination = angular.isArray(destination) ? destination : [];
+                    for (var i = 0; i < source.length; i++) {
+                        destination[i] = deepExtend(destination[i] || {}, source[i]);
+                    }
+                } else if (angular.isObject(source)) {
+                    for (var property in source) {
+                        destination[property] = deepExtend(destination[property] || {}, source[property]);
+                    }
+                } else {
+                    destination = source;
+                }
+                return destination;
+            }
+        };
+    }
+
+    function highchart(highchartsNGUtils, $timeout) {
+
+        // acceptable shared state
+        var seriesId = 0;
+        var ensureIds = function (series) {
+            var changed = false;
+            angular.forEach(series, function(s) {
+                if (!angular.isDefined(s.id)) {
+                    s.id = 'series-' + seriesId++;
+                    changed = true;
+                }
+            });
+            return changed;
+        };
+
+        // immutable
+        var axisNames = [ 'xAxis', 'yAxis' ];
+        var chartTypeMap = {
+            'stock': 'StockChart',
+            'map':   'Map',
+            'chart': 'Chart'
+        };
+
+        var getMergedOptions = function (scope, element, config) {
+            var mergedOptions = {};
+
+            var defaultOptions = {
+                chart: {
+                    events: {}
+                },
+                title: {},
+                subtitle: {},
+                series: [],
+                credits: {},
+                plotOptions: {},
+                navigator: {enabled: false}
+            };
+
+            if (config.options) {
+                mergedOptions = highchartsNGUtils.deepExtend(defaultOptions, config.options);
+            } else {
+                mergedOptions = defaultOptions;
+            }
+            mergedOptions.chart.renderTo = element[0];
+
+            angular.forEach(axisNames, function(axisName) {
+                if(angular.isDefined(config[axisName])) {
+                    mergedOptions[axisName] = angular.copy(config[axisName]);
+
+                    if(angular.isDefined(config[axisName].currentMin) ||
+                        angular.isDefined(config[axisName].currentMax)) {
+
+                        highchartsNGUtils.prependMethod(mergedOptions.chart.events, 'selection', function(e){
+                            var thisChart = this;
+                            if (e[axisName]) {
+                                scope.$apply(function () {
+                                    scope.config[axisName].currentMin = e[axisName][0].min;
+                                    scope.config[axisName].currentMax = e[axisName][0].max;
+                                });
+                            } else {
+                                //handle reset button - zoom out to all
+                                scope.$apply(function () {
+                                    scope.config[axisName].currentMin = thisChart[axisName][0].dataMin;
+                                    scope.config[axisName].currentMax = thisChart[axisName][0].dataMax;
+                                });
+                            }
+                        });
+
+                        highchartsNGUtils.prependMethod(mergedOptions.chart.events, 'addSeries', function(e){
+                            scope.config[axisName].currentMin = this[axisName][0].min || scope.config[axisName].currentMin;
+                            scope.config[axisName].currentMax = this[axisName][0].max || scope.config[axisName].currentMax;
+                        });
+                    }
+                }
+            });
+
+            if(config.title) {
+                mergedOptions.title = config.title;
+            }
+            if (config.subtitle) {
+                mergedOptions.subtitle = config.subtitle;
+            }
+            if (config.credits) {
+                mergedOptions.credits = config.credits;
+            }
+            if(config.size) {
+                if (config.size.width) {
+                    mergedOptions.chart.width = config.size.width;
+                }
+                if (config.size.height) {
+                    mergedOptions.chart.height = config.size.height;
+                }
+            }
+            return mergedOptions;
+        };
+
+        var updateZoom = function (axis, modelAxis) {
+            var extremes = axis.getExtremes();
+            if(modelAxis.currentMin !== extremes.dataMin || modelAxis.currentMax !== extremes.dataMax) {
+                axis.setExtremes(modelAxis.currentMin, modelAxis.currentMax, false);
+            }
+        };
+
+        var processExtremes = function(chart, axis, axisName) {
+            if(axis.currentMin || axis.currentMax) {
+                chart[axisName][0].setExtremes(axis.currentMin, axis.currentMax, true);
+            }
+        };
+
+        var chartOptionsWithoutEasyOptions = function (options) {
+            return highchartsNGUtils.deepExtend({}, options, {data: null, visible: null});
+        };
+
+        var getChartType = function(scope) {
+            if (scope.config === undefined) return 'Chart';
+            return chartTypeMap[('' + scope.config.chartType).toLowerCase()] ||
+                (scope.config.useHighStocks ? 'StockChart' : 'Chart');
+        };
+
+        return {
+            restrict: 'EAC',
+            replace: true,
+            template: '<div></div>',
+            scope: {
+                config: '=',
+                disableDataWatch: '='
+            },
+            link: function (scope, element, attrs) {
+                // We keep some chart-specific variables here as a closure
+                // instead of storing them on 'scope'.
+
+                // prevSeriesOptions is maintained by processSeries
+                var prevSeriesOptions = {};
+
+                var processSeries = function(series) {
+                    var i;
+                    var ids = [];
+
+                    if(series) {
+                        var setIds = ensureIds(series);
+                        if(setIds) {
+                            //If we have set some ids this will trigger another digest cycle.
+                            //In this scenario just return early and let the next cycle take care of changes
+                            return false;
+                        }
+
+                        //Find series to add or update
+                        angular.forEach(series, function(s) {
+                            ids.push(s.id);
+                            var chartSeries = chart.get(s.id);
+                            if (chartSeries) {
+                                if (!angular.equals(prevSeriesOptions[s.id], chartOptionsWithoutEasyOptions(s))) {
+                                    chartSeries.update(angular.copy(s), false);
+                                } else {
+                                    if (s.visible !== undefined && chartSeries.visible !== s.visible) {
+                                        chartSeries.setVisible(s.visible, false);
+                                    }
+                                    chartSeries.setData(angular.copy(s.data), false);
+                                }
+                            } else {
+                                chart.addSeries(angular.copy(s), false);
+                            }
+                            prevSeriesOptions[s.id] = chartOptionsWithoutEasyOptions(s);
+                        });
+
+                        //  Shows no data text if all series are empty
+                        if(scope.config.noData) {
+                            var chartContainsData = false;
+
+                            for(i = 0; i < series.length; i++) {
+                                if (series[i].data && series[i].data.length > 0) {
+                                    chartContainsData = true;
+
+                                    break;
+                                }
+                            }
+
+                            if (!chartContainsData) {
+                                chart.showLoading(scope.config.noData);
+                            } else {
+                                chart.hideLoading();
+                            }
+                        }
+                    }
+
+                    //Now remove any missing series
+                    for(i = chart.series.length - 1; i >= 0; i--) {
+                        var s = chart.series[i];
+                        if (s.options.id !== 'highcharts-navigator-series' && highchartsNGUtils.indexOf(ids, s.options.id) < 0) {
+                            s.remove(false);
+                        }
+                    }
+
+                    return true;
+                };
+
+                // chart is maintained by initChart
+                var chart = false;
+                var initChart = function() {
+                    if (chart) chart.destroy();
+                    prevSeriesOptions = {};
+                    var config = scope.config || {};
+                    var mergedOptions = getMergedOptions(scope, element, config);
+                    var func = config.func || undefined;
+                    var chartType = getChartType(scope);
+
+                    chart = new Highcharts[chartType](mergedOptions, func);
+
+                    for (var i = 0; i < axisNames.length; i++) {
+                        if (config[axisNames[i]]) {
+                            processExtremes(chart, config[axisNames[i]], axisNames[i]);
+                        }
+                    }
+                    if(config.loading) {
+                        chart.showLoading();
+                    }
+                    config.getHighcharts = function() {
+                        return chart;
+                    };
+
+                };
+                initChart();
+
+
+                if(scope.disableDataWatch){
+                    scope.$watchCollection('config.series', function (newSeries, oldSeries) {
+                        processSeries(newSeries);
+                        chart.redraw();
+                    });
+                } else {
+                    scope.$watch('config.series', function (newSeries, oldSeries) {
+                        var needsRedraw = processSeries(newSeries);
+                        if(needsRedraw) {
+                            chart.redraw();
+                        }
+                    }, true);
+                }
+
+                scope.$watch('config.title', function (newTitle) {
+                    chart.setTitle(newTitle, true);
+                }, true);
+
+                scope.$watch('config.subtitle', function (newSubtitle) {
+                    chart.setTitle(true, newSubtitle);
+                }, true);
+
+                scope.$watch('config.loading', function (loading) {
+                    if(loading) {
+                        chart.showLoading(loading === true ? null : loading);
+                    } else {
+                        chart.hideLoading();
+                    }
+                });
+                scope.$watch('config.noData', function (noData) {
+                    if(scope.config && scope.config.loading) {
+                        chart.showLoading(noData);
+                    }
+                }, true);
+
+                scope.$watch('config.credits.enabled', function (enabled) {
+                    if (enabled) {
+                        chart.credits.show();
+                    } else if (chart.credits) {
+                        chart.credits.hide();
+                    }
+                });
+
+                scope.$watch(getChartType, function (chartType, oldChartType) {
+                    if (chartType === oldChartType) return;
+                    initChart();
+                });
+
+                angular.forEach(axisNames, function(axisName) {
+                    scope.$watch('config.' + axisName, function(newAxes, oldAxes) {
+                        if (newAxes === oldAxes || !newAxes) {
+                            return;
+                        }
+
+                        if (angular.isArray(newAxes)) {
+
+                            for (var axisIndex = 0; axisIndex < newAxes.length; axisIndex++) {
+                                var axis = newAxes[axisIndex];
+
+                                if (axisIndex < chart[axisName].length) {
+                                    chart[axisName][axisIndex].update(axis, false);
+                                    updateZoom(chart[axisName][axisIndex], angular.copy(axis));
+                                }
+
+                            }
+
+                        } else {
+                            // update single axis
+                            chart[axisName][0].update(newAxes, false);
+                            updateZoom(chart[axisName][0], angular.copy(newAxes));
+                        }
+
+                        chart.redraw();
+                    }, true);
+                });
+                scope.$watch('config.options', function (newOptions, oldOptions, scope) {
+                    //do nothing when called on registration
+                    if (newOptions === oldOptions) return;
+                    initChart();
+                    processSeries(scope.config.series);
+                    chart.redraw();
+                }, true);
+
+                scope.$watch('config.size', function (newSize, oldSize) {
+                    if(newSize === oldSize) return;
+                    if(newSize) {
+                        chart.setSize(newSize.width || chart.chartWidth, newSize.height || chart.chartHeight);
+                    }
+                }, true);
+
+                scope.$on('highchartsng.reflow', function () {
+                    chart.reflow();
+                });
+
+                scope.$on('$destroy', function() {
+                    if (chart) {
+                        try{
+                            chart.destroy();
+                        }catch(ex){
+                            // fail silently as highcharts will throw exception if element doesn't exist
+                        }
+
+                        $timeout(function(){
+                            element.remove();
+                        }, 0);
+                    }
+                });
+
+            }
+        };
+    }
+}());