sw2at-ui 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cffde9d161f0600912286898a90e66714af2b7c
-  data.tar.gz: 3949594b3e4c1ca123f016d2592009fd1f5aae18
+  metadata.gz: 655fd2fafeee27655f4b5b13af4683bd405ebfce
+  data.tar.gz: 15deb9efdec3e938c4cd6ffb58b0da29783b1150
 SHA512:
-  metadata.gz: 300ea82224d56e73969ab919a5f1434fe7c5fc19eb5225c752465cad44cffc74afe0a52c15fe1af6568d079afce3c015cc41b1f9f5266e292f87a9fd7286b6c0
-  data.tar.gz: 80d5b68a71caacf1b5b9cd8f83bdda7ab9ba330dc28aec54481506f8da3978bdff9ef78228930c4edf8573478575d88c9cf717e23ce852519f8dbe5f895254e1
+  metadata.gz: 2784cbbeb343c6dd4c048ba9d639672ab99ccffc8d98615506960801d4b6ceff41e42ccc551bc0f6c07919e1701ac854dc45ad2ed7140d068ab7739edd50791a
+  data.tar.gz: b58bc99d1850bd960d8c9798e02607b2609ad9cb72940018a83dc5cd30ab763f2b2bf0e8a37bd7ad2f7f4f02cf02f4ad43a35cc457302f2b2a374fb0e82d4fce

data/VERSION

@@ -1 +1 @@
-0.0.12
+0.0.13

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

@@ -19,6 +19,7 @@ App = angular.module 'SWAT', [
   'ngClipboard'
   'highcharts-ng'
   'ngtimeago'
+  'ngCookies'
 ]
 
 App.config ($urlRouterProvider, $stateProvider) ->
@@ -44,6 +45,14 @@ App.config ($urlRouterProvider, $stateProvider) ->
         templateUrl:  "/swat/pages/revisions/summary.html"
         controller: 'SummaryCtrl'
   )
+  .state("configuration",
+    url: "/swat/configuration"
+    views:
+      content:
+        templateUrl:  "/swat/pages/management/configuration.html"
+        controller: 'ConfigurationCtrl'
+
+  )
 App.config(['ngClipProvider', (ngClipProvider)->
   ngClipProvider.setPath("/assets/swat/bower_components/zeroclipboard/dist/ZeroClipboard.swf")
 ])

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

@@ -0,0 +1,2 @@
+angular.module("SWAT").controller "GlobalNavController", ($rootScope, $scope, $state, $stateParams) ->
+  $scope.init = ->

data/app/assets/javascripts/swat/app/controllers/management/configuration.coffee

@@ -0,0 +1,13 @@
+angular.module("SWAT").controller "ConfigurationCtrl", ($rootScope, $scope, $state, $stateParams
+                                                        ConfigurationService) ->
+  $scope.init = ->
+    setTimeout($scope.reloadConfig, 1000);
+    $rootScope.globalControl.setReloader($scope.reloadConfig)
+
+  $scope.reloadConfig = ->
+    $scope.configPromise = ConfigurationService.get()
+    $scope.configPromise.$promise.then((resp)->
+      $scope.config = resp
+    )
+
+  $scope.init()

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

@@ -2,12 +2,13 @@ angular.module("SWAT").controller "RevisionCtrl", ($rootScope, $scope, $state, $
   RevisionService) ->
 
   $scope.init = ->
+    $scope.currentState = $state.current.name
     $scope.reloadData()
-
+    $rootScope.globalControl.setReloader($scope.reloadData)
 
   $scope.reloadData = ->
     return if $scope.revisionPromise && !$scope.revisionPromise.$resolved
-    params = { branch: $stateParams.branch, user: $stateParams.user, time: $stateParams.time }
+    params = { branch: decodeURI($stateParams.branch), user: $stateParams.user, time: $stateParams.time }
     $scope.revisionPromise = RevisionService.get(params)
     $scope.revisionPromise.$promise.then($scope.initTabs)
 

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

@@ -3,9 +3,13 @@ angular.module("SWAT").controller "RevisionsCtrl", ($rootScope, $scope, $state,
   $scope.init = ->
     window.Swat.log('Revisions Controller initalized!')
     $scope.initRevisions()
+    $rootScope.globalControl.setReloader($scope.initRevisions)
 
   $scope.initRevisions = ->
-    $scope.revisions = RevisionService.query()
+    $scope.revisionsPromise = RevisionService.query()
+    $scope.revisionsPromise.$promise.then((resp)->
+      $scope.revisions = resp
+    )
 
   $scope.testsProgress = (revision)->
 

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

@@ -1,9 +1,11 @@
-angular.module("SWAT").controller "RootCtrl", ($rootScope, $scope, $state, SwatHelpers) ->
+angular.module("SWAT").controller "RootCtrl", ($rootScope, $scope, $state, SwatHelpers, GlobalControl) ->
 
   $scope.init = ->
     $scope.helpers = SwatHelpers
     window.Swat.log 'Swat Root initialized.'
 
+    $rootScope.globalControl  = new GlobalControl()
+
   $scope.init()
 
 

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

@@ -1,9 +1,11 @@
 angular.module("SWAT").controller "SummaryCtrl", ($rootScope, $scope, $state, $stateParams
-  RevisionService, FailsGraph, SwatHelpers) ->
+  RevisionService, FailsGraph, RevisionMetrics, ExceptionGroups) ->
 
   $scope.init = ->
+    $scope.currentState = $state.current.name
     $scope.summary = {}
     $scope.reloadData()
+    $rootScope.globalControl.setReloader($scope.reloadData)
 
   $scope.reloadData = ->
     return if $scope.revisionPromise && !$scope.revisionPromise.$resolved
@@ -24,46 +26,13 @@ angular.module("SWAT").controller "SummaryCtrl", ($rootScope, $scope, $state, $s
     $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.summary.exceptions = new ExceptionGroups($scope.summary.fails).data()
 
   $scope.initFailsStatsGraph = ->
     $scope.failsStats = new FailsGraph($scope.tests, $scope.summary.fails)
 
   $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.summary.metrics  = new RevisionMetrics($scope.revision, $scope.tests, $scope.summary.fails).data()
 
   $scope.init()
 

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

@@ -0,0 +1,23 @@
+angular.module("SWAT").factory "GlobalControl", ($cookies)->
+  class GlobalControl
+    constructor: ->
+      @initStatus()
+      @setReloader(->{})
+
+    initStatus: ->
+      status = $cookies.get('MainMenuStatus') || 'closed';
+      @setStatus(status)
+
+    toggle: ->
+      @setStatus(if @status == 'closed' then 'opened' else 'closed')
+
+    setStatus: (value)->
+      $cookies.put('MainMenuStatus', value);
+      @status = value
+
+    setReloader: (func)->
+      @reloader = func
+
+    reload: ->
+      @reloader()
+

data/app/assets/javascripts/swat/app/factories/summary/exception_groups.coffee

@@ -0,0 +1,17 @@
+angular.module("SWAT").factory "ExceptionGroups", ->
+  class ExceptionGroups
+    constructor: (@fails)->
+
+    data: ->
+      groups = _.groupBy(@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)
+      result

data/app/assets/javascripts/swat/app/factories/summary/revision_metrics.coffee

@@ -0,0 +1,26 @@
+angular.module("SWAT").factory "RevisionMetrics", (SwatHelpers)->
+  class RevisionMetrics
+    constructor: (@revision, @tests, @fails)->
+
+    data: ->
+      result = []
+      totalTests = @tests.length
+      totalFailedTests = @fails.length
+      totalDuration = _.sum(@tests, 'run_time')
+      totalThreadDuration = _.sum(@revision.data.threads, 'total_runtime')
+      successPercentage =  ((@tests.length - @fails.length) / @tests.length*100)
+
+      result.push({ name: 'Revision Name', value: @revision.data.name })
+      result.push({ name: 'Revision Status', value: @revision.data.status.name })
+      result.push({ name: 'Revision Branch', value: @revision.data.branch })
+      result.push({ name: 'Revisor', value: @revision.data.user })
+      result.push({ name: 'Threads Count', value: @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)+'%') })
+      result

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

@@ -0,0 +1,4 @@
+angular.module("SWAT").factory "ConfigurationService", ($resource, GlResponse) ->
+  $resource "/swat/api/configuration", {},
+    get:
+      method: 'GET'

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

@@ -17,3 +17,4 @@
 #= require swat/lib/highcharts.src.js
 #= require swat/lib/highcharts-ng.js
 #= require swat/lib/ngtimeago.js
+#= require swat/lib/angular-cookies.js

data/app/assets/javascripts/swat/lib/angular-cookies.js

@@ -0,0 +1,321 @@
+/**
+ * @license AngularJS v1.4.2-build.4091+sha.fe0af2c
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular, undefined) {'use strict';
+
+    /**
+     * @ngdoc module
+     * @name ngCookies
+     * @description
+     *
+     * # ngCookies
+     *
+     * The `ngCookies` module provides a convenient wrapper for reading and writing browser cookies.
+     *
+     *
+     * <div doc-module-components="ngCookies"></div>
+     *
+     * See {@link ngCookies.$cookies `$cookies`} for usage.
+     */
+
+
+    angular.module('ngCookies', ['ng']).
+    /**
+     * @ngdoc provider
+     * @name $cookiesProvider
+     * @description
+     * Use `$cookiesProvider` to change the default behavior of the {@link ngCookies.$cookies $cookies} service.
+     * */
+        provider('$cookies', [function $CookiesProvider() {
+            /**
+             * @ngdoc property
+             * @name $cookiesProvider#defaults
+             * @description
+             *
+             * Object containing default options to pass when setting cookies.
+             *
+             * The object may have following properties:
+             *
+             * - **path** - `{string}` - The cookie will be available only for this path and its
+             *   sub-paths. By default, this would be the URL that appears in your base tag.
+             * - **domain** - `{string}` - The cookie will be available only for this domain and
+             *   its sub-domains. For obvious security reasons the user agent will not accept the
+             *   cookie if the current domain is not a sub domain or equals to the requested domain.
+             * - **expires** - `{string|Date}` - String of the form "Wdy, DD Mon YYYY HH:MM:SS GMT"
+             *   or a Date object indicating the exact date/time this cookie will expire.
+             * - **secure** - `{boolean}` - The cookie will be available only in secured connection.
+             *
+             * Note: by default the address that appears in your `<base>` tag will be used as path.
+             * This is import so that cookies will be visible for all routes in case html5mode is enabled
+             *
+             **/
+            var defaults = this.defaults = {};
+
+            function calcOptions(options) {
+                return options ? angular.extend({}, defaults, options) : defaults;
+            }
+
+            /**
+             * @ngdoc service
+             * @name $cookies
+             *
+             * @description
+             * Provides read/write access to browser's cookies.
+             *
+             * <div class="alert alert-info">
+             * Up until Angular 1.3, `$cookies` exposed properties that represented the
+             * current browser cookie values. In version 1.4, this behavior has changed, and
+             * `$cookies` now provides a standard api of getters, setters etc.
+             * </div>
+             *
+             * Requires the {@link ngCookies `ngCookies`} module to be installed.
+             *
+             * @example
+             *
+             * ```js
+             * angular.module('cookiesExample', ['ngCookies'])
+             *   .controller('ExampleController', ['$cookies', function($cookies) {
+     *     // Retrieving a cookie
+     *     var favoriteCookie = $cookies.get('myFavorite');
+     *     // Setting a cookie
+     *     $cookies.put('myFavorite', 'oatmeal');
+     *   }]);
+             * ```
+             */
+            this.$get = ['$$cookieReader', '$$cookieWriter', function($$cookieReader, $$cookieWriter) {
+                return {
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#get
+                     *
+                     * @description
+                     * Returns the value of given cookie key
+                     *
+                     * @param {string} key Id to use for lookup.
+                     * @returns {string} Raw cookie value.
+                     */
+                    get: function(key) {
+                        return $$cookieReader()[key];
+                    },
+
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#getObject
+                     *
+                     * @description
+                     * Returns the deserialized value of given cookie key
+                     *
+                     * @param {string} key Id to use for lookup.
+                     * @returns {Object} Deserialized cookie value.
+                     */
+                    getObject: function(key) {
+                        var value = this.get(key);
+                        return value ? angular.fromJson(value) : value;
+                    },
+
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#getAll
+                     *
+                     * @description
+                     * Returns a key value object with all the cookies
+                     *
+                     * @returns {Object} All cookies
+                     */
+                    getAll: function() {
+                        return $$cookieReader();
+                    },
+
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#put
+                     *
+                     * @description
+                     * Sets a value for given cookie key
+                     *
+                     * @param {string} key Id for the `value`.
+                     * @param {string} value Raw value to be stored.
+                     * @param {Object=} options Options object.
+                     *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
+                     */
+                    put: function(key, value, options) {
+                        $$cookieWriter(key, value, calcOptions(options));
+                    },
+
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#putObject
+                     *
+                     * @description
+                     * Serializes and sets a value for given cookie key
+                     *
+                     * @param {string} key Id for the `value`.
+                     * @param {Object} value Value to be stored.
+                     * @param {Object=} options Options object.
+                     *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
+                     */
+                    putObject: function(key, value, options) {
+                        this.put(key, angular.toJson(value), options);
+                    },
+
+                    /**
+                     * @ngdoc method
+                     * @name $cookies#remove
+                     *
+                     * @description
+                     * Remove given cookie
+                     *
+                     * @param {string} key Id of the key-value pair to delete.
+                     * @param {Object=} options Options object.
+                     *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
+                     */
+                    remove: function(key, options) {
+                        $$cookieWriter(key, undefined, calcOptions(options));
+                    }
+                };
+            }];
+        }]);
+
+    angular.module('ngCookies').
+    /**
+     * @ngdoc service
+     * @name $cookieStore
+     * @deprecated
+     * @requires $cookies
+     *
+     * @description
+     * Provides a key-value (string-object) storage, that is backed by session cookies.
+     * Objects put or retrieved from this storage are automatically serialized or
+     * deserialized by angular's toJson/fromJson.
+     *
+     * Requires the {@link ngCookies `ngCookies`} module to be installed.
+     *
+     * <div class="alert alert-danger">
+     * **Note:** The $cookieStore service is **deprecated**.
+     * Please use the {@link ngCookies.$cookies `$cookies`} service instead.
+     * </div>
+     *
+     * @example
+     *
+     * ```js
+     * angular.module('cookieStoreExample', ['ngCookies'])
+     *   .controller('ExampleController', ['$cookieStore', function($cookieStore) {
+ *     // Put cookie
+ *     $cookieStore.put('myFavorite','oatmeal');
+ *     // Get cookie
+ *     var favoriteCookie = $cookieStore.get('myFavorite');
+ *     // Removing a cookie
+ *     $cookieStore.remove('myFavorite');
+ *   }]);
+     * ```
+     */
+        factory('$cookieStore', ['$cookies', function($cookies) {
+
+            return {
+                /**
+                 * @ngdoc method
+                 * @name $cookieStore#get
+                 *
+                 * @description
+                 * Returns the value of given cookie key
+                 *
+                 * @param {string} key Id to use for lookup.
+                 * @returns {Object} Deserialized cookie value, undefined if the cookie does not exist.
+                 */
+                get: function(key) {
+                    return $cookies.getObject(key);
+                },
+
+                /**
+                 * @ngdoc method
+                 * @name $cookieStore#put
+                 *
+                 * @description
+                 * Sets a value for given cookie key
+                 *
+                 * @param {string} key Id for the `value`.
+                 * @param {Object} value Value to be stored.
+                 */
+                put: function(key, value) {
+                    $cookies.putObject(key, value);
+                },
+
+                /**
+                 * @ngdoc method
+                 * @name $cookieStore#remove
+                 *
+                 * @description
+                 * Remove given cookie
+                 *
+                 * @param {string} key Id of the key-value pair to delete.
+                 */
+                remove: function(key) {
+                    $cookies.remove(key);
+                }
+            };
+
+        }]);
+
+    /**
+     * @name $$cookieWriter
+     * @requires $document
+     *
+     * @description
+     * This is a private service for writing cookies
+     *
+     * @param {string} name Cookie name
+     * @param {string=} value Cookie value (if undefined, cookie will be deleted)
+     * @param {Object=} options Object with options that need to be stored for the cookie.
+     */
+    function $$CookieWriter($document, $log, $browser) {
+        var cookiePath = $browser.baseHref();
+        var rawDocument = $document[0];
+
+        function buildCookieString(name, value, options) {
+            var path, expires;
+            options = options || {};
+            expires = options.expires;
+            path = angular.isDefined(options.path) ? options.path : cookiePath;
+            if (value === undefined) {
+                expires = 'Thu, 01 Jan 1970 00:00:00 GMT';
+                value = '';
+            }
+            if (angular.isString(expires)) {
+                expires = new Date(expires);
+            }
+
+            var str = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+            str += path ? ';path=' + path : '';
+            str += options.domain ? ';domain=' + options.domain : '';
+            str += expires ? ';expires=' + expires.toUTCString() : '';
+            str += options.secure ? ';secure' : '';
+
+            // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
+            // - 300 cookies
+            // - 20 cookies per unique domain
+            // - 4096 bytes per cookie
+            var cookieLength = str.length + 1;
+            if (cookieLength > 4096) {
+                $log.warn("Cookie '" + name +
+                "' possibly not set or overflowed because it was too large (" +
+                cookieLength + " > 4096 bytes)!");
+            }
+
+            return str;
+        }
+
+        return function(name, value, options) {
+            rawDocument.cookie = buildCookieString(name, value, options);
+        };
+    }
+
+    $$CookieWriter.$inject = ['$document', '$log', '$browser'];
+
+    angular.module('ngCookies').provider('$$cookieWriter', function $$CookieWriterProvider() {
+        this.$get = $$CookieWriter;
+    });
+
+
+})(window, window.angular);

data/app/assets/stylesheets/swat/application.scss

@@ -2,9 +2,7 @@
 //= require_self
 
 @import "bootstrap";
-
-$greyBg: #9f9f9f;
-$greenMain: greenyellow;
+@import "vars";
 
 #swat {
   font-size: 13px;
@@ -20,9 +18,27 @@ $greenMain: greenyellow;
     }
   }
   #content {
-    background: rgb(240, 240, 240);
+
   }
-  #container {
-    padding: 0px 15px 15px 15px;
+
+
+  table.info {
+    font-size: 14px;
+    background: $greyBg;
+    width: 100%;
+    tr {
+      border-bottom: 1px solid $whiteColor;
+      td {
+        padding: 12px;
+        &.name {
+          width: 200px;
+          padding-left: 21px;
+          color: $lightBlueColor;
+        }
+      }
+    }
   }
+
 }
+
+

data/app/assets/stylesheets/swat/configuration.scss

@@ -0,0 +1,35 @@
+@import "vars";
+
+#swat {
+
+  #configuration {
+
+    .title {
+
+    }
+    .configuration-info-container {
+      display: block;
+      width: 100%;
+    }
+    #configuration-info {
+      background: $whiteColor;
+      border: 1px solid $containerBorder;
+      margin: 20px;
+      padding: 28px 38px;
+      width: 800px;
+      margin: auto;
+
+      .heading {
+        text-align: left;
+        margin: 0;
+        color: rgba(60, 56, 55, 0.68);
+      }
+
+      table {
+        margin-bottom: 18px;
+      }
+
+    }
+  }
+
+}