# HG changeset patch
# User Andrew Azores <aazores@redhat.com>
# Date 1508874649 14400
# Node ID 9f3ee8157ac691a795d91698b3b84b7857dbe0ff
# Parent  c1dc3d7d0552bedc20f49b031927cf7f670175c3
Rename jvm-gc controller properties

Use underscore naming convention for "private" properties

Reviewed-by: jkang
Review-thread: http://icedtea.classpath.org/pipermail/thermostat/2017-October/025439.html

diff -r c1dc3d7d0552 -r 9f3ee8157ac6 src/app/components/jvm-info/jvm-gc/jvm-gc.controller.js
--- a/src/app/components/jvm-info/jvm-gc/jvm-gc.controller.js	Mon Oct 23 10:45:02 2017 -0400
+++ b/src/app/components/jvm-info/jvm-gc/jvm-gc.controller.js	Tue Oct 24 15:50:49 2017 -0400
@@ -34,50 +34,50 @@
     metricToNumberFilter, jvmGcService, sanitizeService, $translate) {
     'ngInject';
     this.jvmId = $stateParams.jvmId;
-    this.interval = $interval;
-    this.dateFilter = dateFilter;
-    this.dateFormat = DATE_FORMAT;
-    this.metricToNumberFilter = metricToNumberFilter;
-    this.jvmGcService = jvmGcService;
-    this.sanitizeService = sanitizeService;
-    this.translate = $translate;
+    this._interval = $interval;
+    this._dateFilter = dateFilter;
+    this._dateFormat = DATE_FORMAT;
+    this._metricToNumber = metricToNumberFilter;
+    this._svc = jvmGcService;
+    this._sanitize = sanitizeService;
+    this._translate = $translate;
   }
 
   $onInit () {
     this.collectors = [];
     this.chartConfigs = {};
     this.chartData = {};
-    this.collectorData = new Map();
-    this.constructChartData();
+    this._collectorData = new Map();
+    this._constructChartData();
 
     this._refreshRate = 1000;
     this._dataAgeLimit = 30000;
 
-    this.start();
+    this._start();
   }
 
   $onDestroy () {
-    this.stop();
+    this._stop();
   }
 
-  start () {
-    this.stop();
-    this.update();
-    this._refresh = this.interval(() => this.update(), this.refreshRate);
+  _start () {
+    this._stop();
+    this._update();
+    this._refresh = this._interval(() => this._update(), this.refreshRate);
   }
 
-  stop () {
+  _stop () {
     if (angular.isDefined(this._refresh)) {
-      this.interval.cancel(this._refresh);
+      this._interval.cancel(this._refresh);
       delete this._refresh;
     }
   }
 
   set refreshRate (val) {
-    this.stop();
+    this._stop();
     this._refreshRate = parseInt(val);
     if (this._refreshRate > 0) {
-      this.start();
+      this._start();
     }
   }
 
@@ -87,20 +87,20 @@
 
   set dataAgeLimit (val) {
     this._dataAgeLimit = val;
-    this.trimData();
+    this._trimData();
   }
 
   get dataAgeLimit () {
     return this._dataAgeLimit.toString();
   }
 
-  makeConfig (collector) {
+  _makeConfig (collector) {
     if (_.includes(this.collectors, collector)) {
       return;
     }
     this.collectors.push(collector);
     this.collectors.sort();
-    this.translate([
+    this._translate([
       'jvmGc.chart.UNITS',
       'jvmGc.chart.X_AXIS_LABEL',
       'jvmGc.chart.Y_AXIS_LABEL'
@@ -114,7 +114,7 @@
             type: 'timeseries',
             localtime: false,
             tick: {
-              format: timestamp => this.dateFilter(timestamp, this.dateFormat.time.medium),
+              format: timestamp => this._dateFilter(timestamp, this._dateFormat.time.medium),
               count: 5
             }
           },
@@ -137,15 +137,15 @@
         point: {
           r: 0
         },
-        onmouseover: () => this.stop(),
-        onmouseout: () => this.start()
+        onmouseover: () => this._stop(),
+        onmouseout: () => this._start()
       };
       this.chartConfigs[collector] = config;
     });
   }
 
-  trimData() {
-    for (let entry of this.collectorData) {
+  _trimData () {
+    for (let entry of this._collectorData) {
       let collector = entry[0];
       let samples = entry[1];
 
@@ -163,8 +163,8 @@
     }
   }
 
-  constructChartData () {
-    for (let entry of this.collectorData) {
+  _constructChartData () {
+    for (let entry of this._collectorData) {
       let collector = entry[0];
       let samples = entry[1];
 
@@ -184,32 +184,32 @@
     }
   }
 
-  update () {
-    this.jvmGcService.getJvmGcData(this.jvmId)
-      .then(resp => this.processData(resp), angular.noop);
+  _update () {
+    this._svc.getJvmGcData(this.jvmId)
+      .then(resp => this._processData(resp), angular.noop);
   }
 
-  processData (resp) {
+  _processData (resp) {
     let seenCollectors = new Set();
     let latestStamp = 0;
     for (let i = resp.data.response.length - 1; i >= 0; i--) {
       let data = resp.data.response[i];
       let collectorName = data.collectorName;
-      let timestamp = this.metricToNumberFilter(data.timeStamp);
-      let micros = this.metricToNumberFilter(data.wallTimeInMicros);
+      let timestamp = this._metricToNumber(data.timeStamp);
+      let micros = this._metricToNumber(data.wallTimeInMicros);
 
       seenCollectors.add(collectorName);
-      this.makeConfig(collectorName, micros);
+      this._makeConfig(collectorName, micros);
 
-      if (!this.collectorData.has(collectorName)) {
-        this.collectorData.set(collectorName, []);
+      if (!this._collectorData.has(collectorName)) {
+        this._collectorData.set(collectorName, []);
       }
 
       if (timestamp > latestStamp) {
         latestStamp = timestamp;
       }
 
-      let collectorData = this.collectorData.get(collectorName);
+      let collectorData = this._collectorData.get(collectorName);
       if (collectorData.length === 0) {
         collectorData.push({
           timestamp: timestamp,
@@ -225,7 +225,7 @@
       }
     }
 
-    for (let entry of this.collectorData) {
+    for (let entry of this._collectorData) {
       let collectorName = entry[0];
       let collectorData = entry[1];
       if (!seenCollectors.has(collectorName)) {
@@ -236,19 +236,19 @@
       }
     }
 
-    this.trimData();
+    this._trimData();
 
-    this.constructChartData();
+    this._constructChartData();
   }
 
   sanitize (input) {
-    return this.sanitizeService.sanitize(input);
+    return this._sanitize.sanitize(input);
   }
 
   multichartFn (collector) {
     return new Promise(resolve => {
-      this.jvmGcService.getJvmGcData(this.jvmId, 1, collector).then(resp => {
-        resolve(this.metricToNumberFilter(resp.data.response[0].wallTimeInMicros));
+      this._svc.getJvmGcData(this.jvmId, 1, collector).then(resp => {
+        resolve(this._metricToNumber(resp.data.response[0].wallTimeInMicros));
       });
     });
   }
diff -r c1dc3d7d0552 -r 9f3ee8157ac6 src/app/components/jvm-info/jvm-gc/jvm-gc.controller.spec.js
--- a/src/app/components/jvm-info/jvm-gc/jvm-gc.controller.spec.js	Mon Oct 23 10:45:02 2017 -0400
+++ b/src/app/components/jvm-info/jvm-gc/jvm-gc.controller.spec.js	Tue Oct 24 15:50:49 2017 -0400
@@ -87,7 +87,7 @@
   it('should call to service on update', () => {
     svc.getJvmGcData.should.be.calledOnce();
     promise.then.should.be.calledOnce();
-    ctrl.update();
+    ctrl._update();
     svc.getJvmGcData.should.be.calledTwice();
     promise.then.should.be.calledTwice();
 
@@ -122,15 +122,14 @@
   });
 
   it('should trim data on dataAgeLimit change', () => {
-    sinon.spy(ctrl, 'trimData');
-    ctrl.trimData.should.not.be.called();
+    sinon.spy(ctrl, '_trimData');
+    ctrl._trimData.should.not.be.called();
     ctrl.dataAgeLimit = 10000;
-    ctrl.trimData.should.be.calledOnce();
-    ctrl.trimData.restore();
+    ctrl._trimData.should.be.calledOnce();
+    ctrl._trimData.restore();
     ctrl.dataAgeLimit.should.equal('10000');
   });
 
-
   it('should trim old data', () => {
     let oldSample = {
       micros: 100,
@@ -142,13 +141,13 @@
       timestamp: Date.now() + 600000
     };
 
-    ctrl.collectorData.set('fooCollector', [oldSample, futureSample]);
+    ctrl._collectorData.set('fooCollector', [oldSample, futureSample]);
     ctrl.dataAgeLimit = '30000';
 
     let expected = new Map();
     expected.set('fooCollector', [futureSample]);
 
-    ctrl.collectorData.should.deepEqual(expected);
+    ctrl._collectorData.should.deepEqual(expected);
   });
 
   it('should set interval on start', () => {
@@ -159,7 +158,7 @@
 
   it('should disable when set refreshRate is called with a non-positive value', () => {
     interval.cancel.should.not.be.called();
-    ctrl.update.should.not.be.called();
+    ctrl._update.should.not.be.called();
 
     ctrl.refreshRate = '1';
 
@@ -172,7 +171,7 @@
     ctrl.should.not.have.ownProperty('_refresh');
   });
 
-  it('should call controller#update() on refresh', () => {
+  it('should call controller#_update() on refresh', () => {
     ctrl.refreshRate = 1;
     let func = interval.args[0][0];
     let callCount = svc.getJvmGcData.callCount;
@@ -180,22 +179,22 @@
     svc.getJvmGcData.callCount.should.equal(callCount + 1);
   });
 
-  describe('makeConfig', () => {
+  describe('_makeConfig', () => {
     let cfg;
     beforeEach(() => {
-      ctrl.makeConfig('fooCollector');
+      ctrl._makeConfig('fooCollector');
       cfg = ctrl.chartConfigs.fooCollector;
     });
 
     it('should cache', () => {
       ctrl.collectors.should.deepEqual(['fooCollector']);
-      ctrl.makeConfig('fooCollector');
+      ctrl._makeConfig('fooCollector');
       ctrl.collectors.should.deepEqual(['fooCollector']);
     });
 
     it('should sort', () => {
-      ctrl.makeConfig('gooCollector');
-      ctrl.makeConfig('booCollector');
+      ctrl._makeConfig('gooCollector');
+      ctrl._makeConfig('booCollector');
       ctrl.collectors.should.deepEqual(['booCollector', 'fooCollector', 'gooCollector']);
     });
 
@@ -228,7 +227,7 @@
     });
 
     it('should stop on mouseover', () => {
-      ctrl.start();
+      ctrl._start();
       let fn = cfg.onmouseover;
       fn.should.be.a.Function();
       interval.cancel.should.be.calledOnce();
@@ -237,7 +236,7 @@
     });
 
     it('should start on mouseout', () => {
-      ctrl.stop();
+      ctrl._stop();
       let fn = cfg.onmouseout;
       fn.should.be.a.Function();
       interval.should.be.calledOnce();
@@ -246,18 +245,18 @@
     });
   });
 
-  describe('constructChartData', () => {
+  describe('_constructChartData', () => {
     it('should leave chartData empty if no collectorData present', () => {
-      ctrl.collectorData = new Map();
-      ctrl.constructChartData;
+      ctrl._collectorData = new Map();
+      ctrl._constructChartData;
       ctrl.chartData.should.deepEqual({});
     });
 
     it('should construct chartData according to collectorData', () => {
       let map = new Map();
       map.set('fooCollector', [{ timestamp: 100, micros: 50 }, { timestamp: 101, micros: 60 }]);
-      ctrl.collectorData = map;
-      ctrl.constructChartData();
+      ctrl._collectorData = map;
+      ctrl._constructChartData();
 
       ctrl.chartData.should.deepEqual({
         fooCollector: {
@@ -268,13 +267,13 @@
     });
   });
 
-  describe('processData', () => {
+  describe('_processData', () => {
     it('should process singleton service results', () => {
       ctrl.collectors.should.deepEqual([]);
       ctrl.chartConfigs.should.deepEqual({});
-      ctrl.collectorData.has('fooCollector').should.be.false();
+      ctrl._collectorData.has('fooCollector').should.be.false();
       let timestamp = Date.now().toString();
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -285,19 +284,19 @@
           ]
         }
       });
-      ctrl.collectorData.has('fooCollector').should.be.true();
-      ctrl.collectorData.get('fooCollector').should.be.an.Array();
-      ctrl.collectorData.get('fooCollector').length.should.equal(1);
-      ctrl.collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestamp), micros: 50 });
+      ctrl._collectorData.has('fooCollector').should.be.true();
+      ctrl._collectorData.get('fooCollector').should.be.an.Array();
+      ctrl._collectorData.get('fooCollector').length.should.equal(1);
+      ctrl._collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestamp), micros: 50 });
     });
 
     it('should process multiple service results', () => {
       ctrl.collectors.should.deepEqual([]);
       ctrl.chartConfigs.should.deepEqual({});
-      ctrl.collectorData.has('fooCollector').should.be.false();
+      ctrl._collectorData.has('fooCollector').should.be.false();
       let timestampA = Date.now().toString();
       let timestampB = (Date.now() - 10).toString();
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -313,17 +312,17 @@
           ]
         }
       });
-      ctrl.collectorData.has('fooCollector').should.be.true();
-      ctrl.collectorData.get('fooCollector').should.be.an.Array();
-      ctrl.collectorData.get('fooCollector').length.should.equal(2);
-      ctrl.collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampB), micros: 25 });
-      ctrl.collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampA), micros: 50 });
+      ctrl._collectorData.has('fooCollector').should.be.true();
+      ctrl._collectorData.get('fooCollector').should.be.an.Array();
+      ctrl._collectorData.get('fooCollector').length.should.equal(2);
+      ctrl._collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampB), micros: 25 });
+      ctrl._collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampA), micros: 50 });
     });
 
     it('should append new data', () => {
       let timestampA = Date.now().toString();
       let timestampB = (Date.now() + 5000).toString();
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -334,7 +333,7 @@
           ]
         }
       });
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -345,17 +344,17 @@
           ]
         }
       });
-      ctrl.collectorData.has('fooCollector').should.be.true();
-      ctrl.collectorData.get('fooCollector').should.be.an.Array();
-      ctrl.collectorData.get('fooCollector').length.should.equal(2);
-      ctrl.collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampA), micros: 50 });
-      ctrl.collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampB), micros: 100 });
+      ctrl._collectorData.has('fooCollector').should.be.true();
+      ctrl._collectorData.get('fooCollector').should.be.an.Array();
+      ctrl._collectorData.get('fooCollector').length.should.equal(2);
+      ctrl._collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampA), micros: 50 });
+      ctrl._collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampB), micros: 100 });
     });
 
     it('should append a sample with duplicate elapsed time if no sample received for a collector', () => {
       let timestampA = Date.now().toString();
       let timestampB = (Date.now() + 10).toString();
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -366,7 +365,7 @@
           ]
         }
       });
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -377,17 +376,17 @@
           ]
         }
       });
-      ctrl.collectorData.get('fooCollector').length.should.equal(2);
-      ctrl.collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampA), micros: 100 });
-      ctrl.collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampB), micros: 100 });
+      ctrl._collectorData.get('fooCollector').length.should.equal(2);
+      ctrl._collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestampA), micros: 100 });
+      ctrl._collectorData.get('fooCollector')[1].should.deepEqual({ timestamp: parseInt(timestampB), micros: 100 });
 
-      ctrl.collectorData.get('barCollector').length.should.equal(1);
-      ctrl.collectorData.get('barCollector')[0].should.deepEqual({ timestamp: parseInt(timestampB), micros: 200 });
+      ctrl._collectorData.get('barCollector').length.should.equal(1);
+      ctrl._collectorData.get('barCollector')[0].should.deepEqual({ timestamp: parseInt(timestampB), micros: 200 });
     });
 
     it('should ignore duplicate timestamps', () => {
       let timestamp = Date.now().toString();
-      ctrl.processData({
+      ctrl._processData({
         data: {
           response: [
             {
@@ -408,9 +407,9 @@
           ]
         }
       });
-      ctrl.collectorData.get('fooCollector').length.should.equal(1);
+      ctrl._collectorData.get('fooCollector').length.should.equal(1);
       // note: response is processed in reverse order, so 100 is seen first
-      ctrl.collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestamp), micros: 100 });
+      ctrl._collectorData.get('fooCollector')[0].should.deepEqual({ timestamp: parseInt(timestamp), micros: 100 });
     });
   });