introduced formatting for objects,increased performance,specifier bugfix

sevensc · sevensc · commit a9aba128b584 · 2018-04-12T11:58:35.000+02:00
diff --git a/dist/index.js b/dist/index.js
@@ -55,24 +55,36 @@ var String = (function () {
             args[_i - 1] = arguments[_i];
         }
         try {
-            return format.replace(/{(\d+(:\w*)?)}/g, function (match, i) {
-                var s = match.split(':');
-                if (s.length > 1) {
-                    i = i[0];
-                    match = s[1].replace('}', '');
-                }
-                var arg = args[i];
-                if (arg == null || arg == undefined || match.match(/{d+}/))
-                    return arg;
-                arg = String.parsePattern(match, arg);
-                return typeof arg != 'undefined' && arg != null ? arg : String.Empty;
-            });
+            if (format.match(String.regexNumber))
+                return String.format(String.regexNumber, format, args);
+            if (format.match(String.regexObject))
+                return String.format(String.regexObject, format, args, true);
+            return String.Empty;
         }
         catch (e) {
             console.log(e);
             return String.Empty;
         }
     };
+    String.format = function (regex, format, args, parseByObject) {
+        if (parseByObject === void 0) { parseByObject = false; }
+        return format.replace(regex, function (match, x) {
+            var s = match.split(':');
+            if (s.length > 1) {
+                x = s[0].replace('{', '');
+                match = s[1].replace('}', '');
+            }
+            var arg;
+            if (parseByObject)
+                arg = args[0][x];
+            else
+                arg = args[x];
+            if (arg == null || arg == undefined || match.match(/{\d+}/))
+                return arg;
+            arg = String.parsePattern(match, arg);
+            return typeof arg != 'undefined' && arg != null ? arg : String.Empty;
+        });
+    };
     String.parsePattern = function (match, arg) {
         switch (match) {
             case 'L':
@@ -98,6 +110,8 @@ var String = (function () {
                 }
                 break;
             case 'n':
+                if (typeof (arg) !== "string")
+                    arg = arg.toString();
                 var replacedString = arg.replace(/,/g, '.');
                 if (isNaN(parseFloat(replacedString)) || replacedString.length <= 3)
                     break;
@@ -181,7 +195,9 @@ var String = (function () {
         }
         return temp;
     };
-    String.Empty = "";
+    String.regexNumber = /{(\d+(:\w*)?)}/g;
+    String.regexObject = /{(\w+(:\w*)?)}/g;
+    String.Empty = '';
     return String;
 }());
 exports.String = String;
diff --git a/dist/index.ts b/dist/index.ts
@@ -1,5 +1,8 @@
 export class String {
-    public static Empty: string = "";
+    private static readonly regexNumber = /{(\d+(:\w*)?)}/g;
+    private static readonly regexObject = /{(\w+(:\w*)?)}/g;
+
+    public static Empty: string = '';
 
     public static IsNullOrWhiteSpace(value: string): boolean {
         try {
@@ -51,27 +54,42 @@ export class String {
 
     public static Format(format: string, ...args: any[]): string {
         try {
-            return format.replace(/{(\d+(:\w*)?)}/g, function (match, i) { //0
-                let s = match.split(':');
-                if (s.length > 1) {
-                    i = i[0];
-                    match = s[1].replace('}', ''); //U
-                }
+            if (format.match(String.regexNumber))
+                return String.format(String.regexNumber, format, args);
+
+            if (format.match(String.regexObject))
+                return String.format(String.regexObject, format, args, true);
 
-                let arg = args[i];
-                if (arg == null || arg == undefined || match.match(/{d+}/))
-                    return arg;        
-                    
-                arg = String.parsePattern(match, arg);
-                return typeof arg != 'undefined' && arg != null ? arg : String.Empty;
-            });
+            return String.Empty;
         }
         catch (e) {
             console.log(e);
             return String.Empty;
         }
     }
 
+    private static format(regex: any, format: string, args: any, parseByObject: boolean = false): string {
+        return format.replace(regex, function (match, x) { //0
+            let s = match.split(':');
+            if (s.length > 1) {
+                x = s[0].replace('{', '');
+                match = s[1].replace('}', ''); //U
+            }
+
+            let arg;
+            if (parseByObject)
+                arg = args[0][x];
+            else
+                arg = args[x];
+
+            if (arg == null || arg == undefined || match.match(/{\d+}/))
+                return arg;
+
+            arg = String.parsePattern(match, arg);
+            return typeof arg != 'undefined' && arg != null ? arg : String.Empty;
+        });
+    }
+
     private static parsePattern(match: 'L' | 'U' | 'd' | 's' | 'n' | string, arg: string | Date | number | any): string {
         switch (match) {
             case 'L':
@@ -97,15 +115,17 @@ export class String {
                 }
                 break;
             case 'n': //Tausender Trennzeichen
-                let replacedString = arg.replace(/,/g,'.');
+                if (typeof (arg) !== "string")
+                    arg = arg.toString();
+                let replacedString = arg.replace(/,/g, '.');
                 if (isNaN(parseFloat(replacedString)) || replacedString.length <= 3)
                     break;
 
                 let numberparts = replacedString.split(/[^0-9]+/g);
                 let parts = numberparts;
 
-                if(numberparts.length > 1){
-                    parts = [String.join('',...(numberparts.splice(0, numberparts.length -1 ))), numberparts[numberparts.length-1]];
+                if (numberparts.length > 1) {
+                    parts = [String.join('', ...(numberparts.splice(0, numberparts.length - 1))), numberparts[numberparts.length - 1]];
                 }
 
                 let integer = parts[0];
@@ -114,8 +134,8 @@ export class String {
                 var output = (mod > 0 ? (integer.substring(0, mod)) : String.Empty);
                 var firstGroup = output;
                 var remainingGroups = integer.substring(mod).match(/.{3}/g);
-                output =  output + '.' + String.Join('.',remainingGroups);
-                arg = output + (parts.length > 1 ? ','+ parts[1] : '');
+                output = output + '.' + String.Join('.', remainingGroups);
+                arg = output + (parts.length > 1 ? ',' + parts[1] : '');
                 return arg;
             default:
                 break;
@@ -151,24 +171,24 @@ export class String {
         let times = splitted[splitted.length - 1].split(' ');
         let time = String.Empty;
         if (times.length > 1)
-            time = times[times.length - 1];        
+            time = times[times.length - 1];
 
         let year = splitted[splitted.length - 1].split(' ')[0];
         let month = splitted[splitted.length - 2];
         let day = splitted[splitted.length - 3];
         let result = `${year}-${month}-${day}`
-    
+
         if (!String.IsNullOrWhiteSpace(time) && time.length > 1)
             result += `T${time}`;
         else
-            result += "T00:00:00";        
+            result += "T00:00:00";
 
         return result;
     }
 
     private static formatNumber(input: number, formatTemplate: string): string {
         let count = formatTemplate.length;
-        let stringValue = input.toString();   
+        let stringValue = input.toString();
         if (count <= stringValue.length)
             return stringValue;
 
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "typescript-string-operations",
-  "version": "1.2.4",
+  "version": "1.3.0",
   "description": "Simple lightweight string operation library for Typescript, works with Angular",
   "main": "dist/index.min.js",
   "scripts": {
diff --git a/readme.md b/readme.md
@@ -45,6 +45,22 @@ value = String.Format("{0:00}", 1);
 //output "01"
 ```
 
+## UPDATE
+#### String Format for Objects including specifiers
+
+```typescript
+var fruit = new Fruit();
+fruit.type = "apple";
+fruit.color = "RED";
+fruit.shippingDate = "";
+fruit.amount = 10000;
+
+String.Format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amount of {amount:n}", fruit);
+// output: the APPLE is red shipped on  with an amount of 10.000
+
+```
+
+
 |	Specifier	  |	 			Result 	   	    |
 | :-------------: |:---------------------------:|
 |		`L`		  |	LowerCase					|
diff --git a/tests/fruit.ts b/tests/fruit.ts
@@ -0,0 +1,13 @@
+export class Fruit {
+    public type: string;
+    public color: string;
+    public shippingDate: string | Date;
+    public amount: number | string;
+
+    constructor(type: string, color: string, shippingDate: string | Date, amount: number | string) {
+        this.type = type;
+        this.color = color;
+        this.shippingDate = shippingDate;
+        this.amount = amount;
+    }
+}
diff --git a/tests/test.html b/tests/test.html
@@ -1,4 +1,4 @@
 <html>
     <script>var exports = {};</script>
-    <script src="../dist/index.js"></script>    
+    <script src="../dist/index.js"></script>
 </html>
diff --git a/tests/tests.ts b/tests/tests.ts
@@ -1,4 +1,5 @@
 import { String } from '../dist/index';
+import { Fruit } from './fruit';
 import { expect } from 'chai';
 import 'mocha';
 
@@ -29,7 +30,7 @@ describe('String.IsNullOrWhitespace', () => {
     });
 });
 
-describe('String.Format', () => {
+describe('String.Format Number Pattern', () => {
     describe('Placeholders', () => {
         it('should format the string correct', () => {
             let template = "{0}";
@@ -179,6 +180,32 @@ describe('String.Format', () => {
 
 });
 
+describe('String.Format Text Pattern', () => {
+    describe("formatting", () => {
+        it("Should parse out the word", () => {
+            // Arrange
+            var fruit = { type: "apple", color: "red" };
+
+            // Act
+            var formatted = String.Format("the {type} is {color}", fruit);
+
+            // Assert
+            expect(formatted).to.equal("the apple is red");
+        });
+
+        it("Should parse out the word with specifiers and TS Class", () => {
+            // Arrange
+            var fruit: Fruit = new Fruit("apple", "RED", "31.12.2018 01:02:03", "10000");
+
+            // Act
+            var formatted = String.Format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amount of {amount:n}", fruit);
+
+            // Assert
+            expect(formatted).to.equal("the APPLE is red shipped on 2018-12-31T01:02:03 with an amount of 10.000");
+        });
+    });
+});
+
 describe('String.Join', () => {
     it('should join the given strings passed as args', () => {
         let stringOne = "red", stringTwo = "yellow", stringThree = "blue";

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "typescript-string-operations",`
`3`		`- "version": "1.2.4",`
	`3`	`+ "version": "1.3.0",`
`4`	`4`	`"description": "Simple lightweight string operation library for Typescript, works with Angular",`
`5`	`5`	`"main": "dist/index.min.js",`
`6`	`6`	`"scripts": {`