Merge pull request #60 from Techn1x/improved-regex

Improved regex, added new flags to helper

Author: stefanpenner

README.md

@@ -11,8 +11,9 @@ This addon provides `{{app-version}}` helper that allows you to show your curren
 
 The addon has flags to display parts of the version:
 
-* `{{app-version hideSha=true}} // => 2.0.1`
-* `{{app-version hideVersion=true}} // => <git SHA>`
+* `{{app-version versionOnly=true}} // => 2.0.1`
+* `{{app-version versionOnly=true showExtended=true}} // => 2.0.1-alpha.1`
+* `{{app-version shaOnly=true}} // => <git SHA>`
 
 Flags are `false` by default.
 

addon/utils/regexp.js

@@ -1,23 +1,32 @@
 import { helper } from '@ember/component/helper';
 import config from '../config/environment';
-import { shaRegExp, versionRegExp } from 'ember-cli-app-version/utils/regexp';
-
-const {
-  APP: {
-    version
-  }
-} = config;
+import { shaRegExp, versionRegExp, versionExtendedRegExp } from 'ember-cli-app-version/utils/regexp';
 
 export function appVersion(_, hash = {}) {
-  if (hash.hideSha) {
-    return version.match(versionRegExp)[0];
+  const version = config.APP.version;
+  // e.g. 1.0.0-alpha.1+4jds75hf
+
+  // Allow use of 'hideSha' and 'hideVersion' For backwards compatibility
+  let versionOnly = hash.versionOnly || hash.hideSha;
+  let shaOnly = hash.shaOnly || hash.hideVersion;
+
+  let match = null;
+
+  if (versionOnly) {
+    if (hash.showExtended) {
+      match = version.match(versionExtendedRegExp); // 1.0.0-alpha.1
+    }
+    // Fallback to just version
+    if (!match) {
+      match = version.match(versionRegExp); // 1.0.0
+    }
   }
 
-  if (hash.hideVersion) {
-    return version.match(shaRegExp)[0];
+  if (shaOnly) {
+    match = version.match(shaRegExp); // 4jds75hf
   }
 
-  return version;
+  return match ? match[0] : version;
 }
 
 export default helper(appVersion);

app/helpers/app-version.js

@@ -1,25 +1,54 @@
 import { moduleForComponent, test } from 'ember-qunit';
 import hbs from 'htmlbars-inline-precompile';
-import { shaRegExp, versionRegExp } from 'ember-cli-app-version/utils/regexp';
 
 moduleForComponent('Integration | Helper | {{app-version}}', {
   integration: true
 });
 
-test('it displays only app version', function(assert) {
-  assert.expect(2);
+test('it displays entire version', function(assert) {
+  assert.expect(1);
+
+  this.render(hbs`{{app-version}}`);
+
+  assert.ok(this.$().text(), 'Version not empty');
+});
+
+test('it displays only app version (backwards compatible)', function(assert) {
+  assert.expect(1);
 
   this.render(hbs`{{app-version hideSha=true}}`);
 
-  assert.ok(this.$().text().match(versionRegExp), 'Displays version.');
-  assert.ok(!this.$().text().match(shaRegExp), 'Does not display git sha.');
+  assert.ok(this.$().text(), 'Version not empty');
 });
 
-test('it displays only git sha', function(assert) {
-  assert.expect(2);
+test('it displays only app version', function(assert) {
+  assert.expect(1);
+
+  this.render(hbs`{{app-version versionOnly=true}}`);
+
+  assert.ok(this.$().text(), 'Version not empty');
+});
+
+test('it displays only app version extended', function(assert) {
+  assert.expect(1);
+
+  this.render(hbs`{{app-version versionOnly=true showExtended=true}}`);
+
+  assert.ok(this.$().text(), 'Version not empty');
+});
+
+test('it displays only git sha (backwards compatible)', function(assert) {
+  assert.expect(1);
 
   this.render(hbs`{{app-version hideVersion=true}}`);
 
-  assert.ok(this.$().text().match(shaRegExp), 'Displays git sha.');
-  assert.ok(!this.$().text().match(versionRegExp), 'Does not display version.');
+  assert.ok(this.$().text(), 'Version not empty');
 });
+
+test('it displays only git sha', function(assert) {
+  assert.expect(1);
+
+  this.render(hbs`{{app-version shaOnly=true}}`);
+
+  assert.ok(this.$().text(), 'Version not empty');
+});

tests/integration/helpers/app-version-test.js

@@ -1,35 +1,78 @@
 import { appVersion } from 'dummy/helpers/app-version';
-import { module, test } from 'qunit';
 import config from 'dummy/config/environment';
+import { module, test } from 'qunit';
 
-const {
-  APP: {
-    version
-  }
-} = config;
+const versionOnlyString = '10.20.3';
+const extendedTagOnlyString = 'alpha.15';
+const shaOnlyString = 'deadb33f';
+
+const versionString = versionOnlyString+'-'+extendedTagOnlyString+'+'+shaOnlyString;
+const standardVersionString = versionOnlyString+'+'+shaOnlyString;
+const oldVersion = config.APP.version;
 
-module('Unit | Helper | app version');
+module('Unit | Helper | app version', {
+  afterEach() {
+    config.APP.version = oldVersion;
+  }
+});
 
 test('it returns app version', function(assert) {
   assert.expect(1);
+  config.APP.version = versionString;
 
-  let result = appVersion();
+  assert.equal(appVersion(), versionString, 'Returns app version.');
+});
 
-  assert.equal(result, version, 'Returns app version.');
+test('it returns only app version (backwards compatible)', function(assert) {
+  assert.expect(1);
+
+  config.APP.version = versionString;
+  let result = appVersion([], { hideSha: true });
+
+  assert.equal(result, versionOnlyString, 'Returns app version without git sha.');
 });
 
 test('it returns only app version', function(assert) {
   assert.expect(1);
 
-  let result = appVersion([], { hideSha: true });
+  config.APP.version = versionString;
+  let result = appVersion([], { versionOnly: true });
 
-  assert.equal(result, version.split('+')[0], 'Returns app version without git sha.');
+  assert.equal(result, versionOnlyString, 'Returns app version without git sha.');
 });
 
-test('it returns only git sha', function(assert) {
+test('it returns only app version extended', function(assert) {
   assert.expect(1);
 
+  config.APP.version = versionString;
+  let result = appVersion([], { versionOnly: true, showExtended: true });
+
+  assert.equal(result, versionOnlyString+'-'+extendedTagOnlyString, 'Returns app version extended without git sha.');
+});
+
+test('it returns only app version (falls back when no extended)', function(assert) {
+  assert.expect(1);
+
+  config.APP.version = standardVersionString;
+  let result = appVersion([], { versionOnly: true, showExtended: true });
+
+  assert.equal(result, versionOnlyString, 'Returns app version without git sha.');
+});
+
+test('it returns only git sha (backwards compatible)', function(assert) {
+  assert.expect(1);
+
+  config.APP.version = versionString;
   let result = appVersion([], { hideVersion: true });
 
-  assert.equal(result, version.split('+')[1], 'Returns git sha without app version.');
+  assert.equal(result, shaOnlyString, 'Returns git sha without app version.');
+});
+
+test('it returns only git sha', function(assert) {
+  assert.expect(1);
+
+  config.APP.version = versionString;
+  let result = appVersion([], { shaOnly: true });
+
+  assert.equal(result, shaOnlyString, 'Returns git sha without app version.');
 });

tests/unit/helpers/app-version-test.js

@@ -1,19 +1,31 @@
 import { module, test } from 'qunit';
-import { shaRegExp, versionRegExp } from 'ember-cli-app-version/utils/regexp';
+import { shaRegExp, versionRegExp, versionExtendedRegExp } from 'ember-cli-app-version/utils/regexp';
 
 module('Unit | Utility | regexp');
 
 test('version reg ex matches expected strings', function(assert) {
-  assert.expect(3);
+  assert.expect(4);
 
   assert.ok('2.0.1'.match(versionRegExp), 'Matches expected pattern.');
+  assert.ok('2.20.1'.match(versionRegExp), 'Matches expected pattern.');
   assert.ok(!'a.b.c'.match(versionRegExp), 'Does not match letters.');
   assert.ok(!'git12sha'.match(versionRegExp), 'Does not match sha.');
 });
 
+test('version extended reg ex matches expected strings', function(assert) {
+  assert.expect(4);
+
+  assert.ok('2.0.1-alpha'.match(versionExtendedRegExp), 'Matches expected pattern.');
+  assert.ok('2.20.1-alpha.15'.match(versionExtendedRegExp), 'Matches expected pattern.');
+  assert.ok(!'a.b.c-alpha.15'.match(versionExtendedRegExp), 'Does not match letters.');
+  assert.ok(!'git12sha'.match(versionExtendedRegExp), 'Does not match sha.');
+});
+
 test('git sha reg ex matches expected strings', function(assert) {
-  assert.expect(2);
+  assert.expect(4);
 
   assert.ok('git12sha'.match(shaRegExp), 'Matches expected pattern.');
   assert.ok(!'2.0.1'.match(shaRegExp), 'Does not match version pattern.');
+  assert.ok(!'2.0.1-alpha.15'.match(shaRegExp), 'Does not match version extended pattern.');
+  assert.ok(!'2.0.1-alphaabc.15'.match(shaRegExp), 'Does not match version extended pattern (with 8 chars in tag name).');
 });