Small changes to increase coverage and lint errors (#1)

* -fixing lint errors
-adding tests

* fixing test

* removing unncessary attribute checks

Author: jxm262

lib/htmlparser-to-vdom.js

@@ -4,6 +4,28 @@ var svg = require('./get-property-info/svg');
 var SVGAttributeHook = require('./get-property-info/svg/svg-attribute-hook');
 
 module.exports = function createConverter (VNode, VText) {
+    function convertSvg(tag, attributes, children, key) {
+        var _attributes = attributes.attributes;
+
+        for(var _key in _attributes) {
+            var namespace = svg.SVGAttributeNamespace(_key);
+
+            if (namespace === void 0) { // not a svg attribute
+                continue;
+            }
+
+            var value = _attributes[_key];
+
+            if (namespace !== null) { // namespaced attribute
+                attributes[_key] = new SVGAttributeHook(namespace, value);
+                _attributes[_key] = void 0;
+                continue;
+            }
+        }
+
+        return new VNode(tag.name, attributes, children, key, svg.getSVGNamespace());
+    }
+
     var converter = {
         convert: function (node, getVNodeKey) {
             if (node.type === 'tag' || node.type === 'script' || node.type === 'style') {
@@ -35,39 +57,5 @@ module.exports = function createConverter (VNode, VText) {
         }
     };
 
-    function convertSvg(tag, attributes, children, key) {
-        var _attributes = attributes.attributes;
-
-        for(var _key in _attributes) {
-            if (!_attributes.hasOwnProperty(_key)) {
-                continue;
-            }
-
-            var namespace = svg.SVGAttributeNamespace(_key);
-
-            if (namespace === void 0) { // not a svg attribute
-                continue;
-            }
-
-            var value = _attributes[_key];
-
-            if (typeof value !== 'string' &&
-                typeof value !== 'number' &&
-                typeof value !== 'boolean'
-            ) {
-                continue;
-            }
-
-            if (namespace !== null) { // namespaced attribute
-                attributes[_key] = SVGAttributeHook(namespace, value);
-                _attributes[_key] = void 0;
-                continue;
-            }
-        }
-
-        return new VNode(tag.name, attributes, children, key, svg.getSVGNamespace());
-    }
-    
-    
     return converter;
 };

test/get-property-info/svg/svg-attribute-hook.js

@@ -0,0 +1,102 @@
+var SVGAttributeHook = require('../../../lib/get-property-info/svg/svg-attribute-hook');
+
+
+describe('SVGAttributeHook', function () {
+    var testNamespace = "http://www.testnamespace.com";
+    var testValue = "test-value";
+    var attributeHook = SVGAttributeHook(testNamespace, testValue);
+
+    it('creates new AttributeBook with namespace and value', function () {
+        attributeHook.namespace.should.equal(testNamespace)
+        attributeHook.value.should.equal(testValue)
+    });
+
+    describe('hook', function() {
+        context('prev is the same AttributeHook', function() {
+            it('does nothing', function() {
+                var prev = attributeHook;
+                var node = {};
+                var prop = {};
+
+                var hooked = attributeHook.hook(node, prop, prev)
+
+                should.equal(hooked, undefined)
+            });
+        });
+
+        context('prev is different AttributeHook', function() {
+            it('sets the attribute to the input node', function() {
+                var otherNamespace = "othernamespace";
+                var otherValue = "otherValue";
+                var testProp = "testProp";
+                var prev = SVGAttributeHook(otherNamespace, otherValue);
+                var node = {
+                    setAttributeNS: function(namespace, prop, value) {
+                        this.namespace = namespace;
+                        this.value = value;
+                        this.prop = prop;
+                    },
+                    namespace: null,
+                    value: null,
+                    prop: null,
+                };
+
+                attributeHook.hook(node, testProp, prev)
+
+                node.namespace.should.equal(testNamespace)
+                node.value.should.equal(testValue)
+                node.prop.should.equal(testProp)
+            });
+        });
+    });
+
+    describe('unhook', function() {
+        context('node is has same namespace as next', function() {
+            it('does nothing', function() {
+                var next = attributeHook;
+                var node = {};
+                var prop = {};
+
+                var hooked = attributeHook.unhook(node, prop, next)
+
+                should.equal(hooked, undefined)
+            });
+        });
+
+        context('node has different namespace as next', function() {
+            it('removes attribute namespace from the node', function() {
+                var otherNamespace = "othernamespace";
+                var otherValue = "otherValue";
+                var testProp = "color:red";
+                var next = SVGAttributeHook(otherNamespace, otherValue);
+                var node = {
+                    removeAttributeNS: function(namespace, name) {
+                        this.namespace = name;
+                    },
+                    namespace: testNamespace
+                };
+
+                attributeHook.unhook(node, testProp, next)
+
+                node.namespace.should.equal('red')
+            });
+
+            it('removes attribute namespace without colon in prop from the node', function() {
+                var otherNamespace = "othernamespace";
+                var otherValue = "otherValue";
+                var testProp = "color";
+                var next = SVGAttributeHook(otherNamespace, otherValue);
+                var node = {
+                    removeAttributeNS: function(namespace, name) {
+                        this.namespace = name;
+                    },
+                    namespace: testNamespace
+                };
+
+                attributeHook.unhook(node, testProp, next)
+
+                node.namespace.should.equal('color')
+            });
+        });
+    });
+});