Merge pull request #6 from vitaly-t/to-string

adding host conversion

README.md

@@ -117,7 +117,7 @@ Both the root function and class `ConnectionString` take a second optional param
 If it is specified, the parser will call method `setDefaults` automatically (see below). 
 
 The object returned by the parser contains all the properties as specified in the connection string,
-plus two methods: `setDefaults` and `build` (see below).
+plus two methods: `setDefaults` and `toString` (see below).
 
 #### Method `setDefaults(defaults) => ConnectionString`
 
@@ -127,7 +127,7 @@ specified within the connection string, and returns the same object (itself).
 You can make use of this method either explicitly, after constructing the class, or implicitly, by 
 passing the `defaults` object into the parser/constructor.
 
-#### Method `build() => string`
+#### Method `toString() => string`
 
 Constructs and returns a connection string from all the current properties.
 
@@ -136,7 +136,7 @@ Example:
 ```js
 const a = new ConnectionString('abc://localhost');
 a.setDefaults({user: 'guest'});
-a.build(); //=> 'abc://guest@localhost'
+a.toString(); //=> 'abc://guest@localhost'
 ```
 
 For any parameter within `params`, if the value is not a string, it will be converted into a JSON

package.json

@@ -1,6 +1,6 @@
 {
   "name": "connection-string",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Advanced URL Connection String Parser.",
   "main": "src/index.js",
   "typings": "src/index.d.ts",

src/index.d.ts

@@ -2,6 +2,7 @@ interface IHost {
     name?: string
     port?: number
     isIPv6?: boolean
+    toString?: () => string
 }
 
 interface IConnectionDefaults {
@@ -23,7 +24,7 @@ export class ConnectionString {
     segments?: string[];
     params?: { [name: string]: string };
 
-    build(): string;
+    toString(): string;
 
     setDefaults(defaults: IConnectionDefaults): ConnectionString;
 }

src/index.js

@@ -87,6 +87,9 @@
                         if (!this.hosts) {
                             this.hosts = [];
                         }
+                        Object.defineProperty(h, 'toString', {
+                            value: fullHostName.bind(null, h)
+                        });
                         this.hosts.push(h);
                     }
                 }
@@ -124,7 +127,7 @@
         }
     }
 
-    function build() {
+    function toString() {
         var s = '';
         if (this.protocol) {
             s += encode(this.protocol) + '://';
@@ -193,6 +196,9 @@
                     if (port > 0 && port < 65536) {
                         obj.port = port;
                     }
+                    Object.defineProperty(obj, 'toString', {
+                        value: fullHostName.bind(null, obj)
+                    });
                     hosts.push(obj);
                 }
             });
@@ -259,7 +265,7 @@
         return (typeof str1 === 'string' && typeof str2 === 'string') && str1.toUpperCase() === str2.toUpperCase();
     }
 
-    Object.defineProperty(ConnectionString.prototype, 'build', {value: build});
+    Object.defineProperty(ConnectionString.prototype, 'toString', {value: toString});
     Object.defineProperty(ConnectionString.prototype, 'setDefaults', {value: setDefaults});
 
     ConnectionString.ConnectionString = ConnectionString; // to make it more TypeScript-friendly

test/main.js

@@ -16,7 +16,7 @@ a.params = {
     first: '123',
     second: 'hello!'
 };
-var cs = a.build();
+var cs = a.toString();
 a.setDefaults({
     hosts: [
         { name: '[::]', port: 123, isIPv6: true }
@@ -26,5 +26,5 @@ a.setDefaults({
     user: '',
     password: ''
 });
-cs = a.build();
+cs = a.toString();
 var qq = a.setDefaults(new src_1.ConnectionString(''));

test/main.ts

@@ -20,7 +20,7 @@ a.params = {
     second: 'hello!'
 };
 
-let cs = a.build();
+let cs = a.toString();
 a.setDefaults({
     hosts: [
         {name: '[::]', port: 123, isIPv6: true}
@@ -32,6 +32,6 @@ a.setDefaults({
     password: ''
 });
 
-cs = a.build();
+cs = a.toString();
 
 const qq: ConnectionString = a.setDefaults(new ConnectionString(''));

test/mainSpec.js

@@ -7,7 +7,7 @@ function parse(cs, defaults) {
 }
 
 function create(obj) {
-    return (new ConnectionString('', obj)).build();
+    return (new ConnectionString('', obj)).toString();
 }
 
 describe('init', () => {
@@ -299,7 +299,7 @@ describe('complex', () => {
     });
 });
 
-describe('build', () => {
+describe('toString', () => {
     it('must encode protocol', () => {
         expect(create({protocol: 'abc 123?456'})).toBe('abc%20123%3F456://');
     });
@@ -310,47 +310,47 @@ describe('build', () => {
         expect(create({password: 'pass 1?2'})).toBe(':pass%201%3F2@');
     });
     it('must support user + password', () => {
-        expect(parse('user:pass@').build()).toBe('user:pass@');
+        expect(parse('user:pass@').toString()).toBe('user:pass@');
     });
     it('must encode non-IPv6 host name', () => {
-        expect(parse('one%20two%20three!').build()).toBe('one%20two%20three');
+        expect(parse('one%20two%20three!').toString()).toBe('one%20two%20three');
     });
     it('must not encode IPv6 host name', () => {
-        expect(parse('[123::%20:%20:456]').build()).toBe('[123::%20:%20:456]');
+        expect(parse('[123::%20:%20:456]').toString()).toBe('[123::%20:%20:456]');
     });
     it('must support solo hostname', () => {
-        expect(parse('server').build()).toBe('server');
-        expect(parse('[123::]').build()).toBe('[123::]');
+        expect(parse('server').toString()).toBe('server');
+        expect(parse('[123::]').toString()).toBe('[123::]');
     });
     it('must support solo port', () => {
-        expect(parse(':123').build()).toBe(':123');
+        expect(parse(':123').toString()).toBe(':123');
     });
     it('must support hostname + port', () => {
-        expect(parse('server:123').build()).toBe('server:123');
-        expect(parse('[::]:123').build()).toBe('[::]:123');
+        expect(parse('server:123').toString()).toBe('server:123');
+        expect(parse('[::]:123').toString()).toBe('[::]:123');
     });
     it('must encode segments', () => {
-        expect(parse('/a%20b').build()).toBe('/a%20b');
-        expect(parse('/a/b%20/c').build()).toBe('/a/b%20/c');
+        expect(parse('/a%20b').toString()).toBe('/a%20b');
+        expect(parse('/a/b%20/c').toString()).toBe('/a/b%20/c');
     });
     it('must ignore empty segment list', () => {
         const a = parse('');
         a.segments = [];
-        expect(a.build()).toBe('');
+        expect(a.toString()).toBe('');
     });
     it('must encode params', () => {
         const obj = {
             text: 1,
             values: ['one', true]
         };
         const a = parse('', {params: {value1: obj, value2: 'text'}});
-        const b = parse(a.build());
+        const b = parse(a.toString());
         expect(JSON.parse(b.params.value1)).toEqual(obj);
     });
     it('must ignore empty parameter list', () => {
         const a = parse('');
         a.params = {};
-        expect(a.build()).toBe('');
+        expect(a.toString()).toBe('');
     });
 });