From 32b02f044d35f89be9b6ac407c95705502e3b54e Mon Sep 17 00:00:00 2001
From: Juriy Zaytsev <kangax@gmail.com>
Date: Tue, 9 Feb 2010 13:17:18 -0500
Subject: [PATCH] =?utf8?q?Refactor=20`minify`=20function=20slightly.=20Mor?=
 =?utf8?q?e=20tests=20=E2=80=94=20case=20normalization,=20space=20normaliz?=
 =?utf8?q?ation=20and=20options.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 src/htmlminifier.js | 98 ++++++++++++++++++++++-----------------------
 tests/index.html    | 51 +++++++++++++++++++----
 2 files changed, 91 insertions(+), 58 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 6a4bda9..788c6c3 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -31,8 +31,6 @@
   }
   
   function isAttributeRedundant(tag, attrName, attrValue, attrs) {
-    tag = tag.toLowerCase();
-    attrName = attrName.toLowerCase();
     attrValue = attrValue.toLowerCase();
     return (
         (tag === 'script' && 
@@ -78,14 +76,8 @@
       
   function canDeleteEmptyAttribute(tag, attrName, attrValue) {
     var isValueEmpty = /^(["'])?\s*\1$/.test(attrValue);
-    
     if (isValueEmpty) {
-      
       log('empty attribute: ' + tag + ' :: ' + attrName);
-      
-      tag = tag.toLowerCase();
-      attrName = attrName.toLowerCase();
-
       return (
         (tag === 'input' && attrName === 'value') ||
         reEmptyAttribute.test(attrName));
@@ -93,63 +85,66 @@
     return false;
   }
   
+  function normalizeAttribute(attr, attrs, tag, options) {
+    
+    var attrName = attr.name.toLowerCase();
+    var attrValue = attr.escaped;
+    var attrFragment;
+    
+    if (options.shouldRemoveRedundantAttributes && 
+        isAttributeRedundant(tag, attrName, attrValue, attrs)) {
+      return '';
+    }
+    
+    attrValue = cleanAttributeValue(tag, attrName, attrValue);
+    
+    if (!options.shouldRemoveAttributeQuotes || 
+        !canRemoveAttributeQuotes(attrValue)) {
+      attrValue = '"' + attrValue + '"';
+    }
+    
+    if (options.shouldRemoveEmptyAttributes &&
+        canDeleteEmptyAttribute(tag, attrName, attrValue)) {
+      return '';
+    }
+
+    if (options.shouldCollapseBooleanAttributes && 
+        isBooleanAttribute(attrName)) {
+      attrFragment = attrName;
+    }
+    else {
+      attrFragment = attrName + '=' + attrValue;
+    }
+    
+    return (' ' + attrFragment);
+  }
+  
   function minify(value, options) {
     
+    options = options || { };
+    value = trimWhitespace(value);
+    
     var results = [];
     var t = new Date();
     
     HTMLParser(value, {
       start: function( tag, attrs, unary ) {
+        
+        tag = tag.toLowerCase();
+        
         results.push('<', tag);
+        
         for ( var i = 0, len = attrs.length; i < len; i++ ) {
-
-          if (options.shouldRemoveRedundantAttributes &&
-              isAttributeRedundant(tag, attrs[i].name, attrs[i].value, attrs)) {
-            continue;
-          }
-
-          var escaped = attrs[i].escaped, 
-              attrName = attrs[i].name,
-              attrValue = escaped;
-          
-          attrValue = cleanAttributeValue(tag, attrName, attrValue);
-          
-          if (options.shouldRemoveAttributeQuotes && 
-              canRemoveAttributeQuotes(attrValue)) {
-            // noop
-          }
-          else {
-            attrValue = '"' + attrValue + '"';
-          }
-          
-          if (options.shouldRemoveEmptyAttributes &&
-              canDeleteEmptyAttribute(tag, attrName, attrValue)) {
-            continue;
-          }
-
-          var attributeFragment;
-          if (options.shouldCollapseBooleanAttributes && 
-              isBooleanAttribute(attrName)) {
-            attributeFragment = attrName;
-          }
-          else {
-            attributeFragment = attrName + '=' + attrValue;
-          }
-          
-          results.push(' ', attributeFragment);
+          results.push(normalizeAttribute(attrs[i], attrs, tag, options));
         }
+        
         results.push('>');
       },
       end: function( tag ) {
-        results.push('</', tag, '>');
+        results.push('</', tag.toLowerCase(), '>');
       },
       chars: function( text ) {
-        if (options.shouldCollapseWhitespace) {
-          results.push(trimWhitespace(text));
-        }
-        else {
-          results.push(text);
-        }
+        results.push(options.shouldCollapseWhitespace ? trimWhitespace(text) : text);
       },
       comment: function( text ) {
         results.push(options.shouldRemoveComments ? '' : ('<!--' + text + '-->'));
@@ -166,6 +161,7 @@
     return str;
   }
   
-  this.minify = minify;
+  // export
+  global.minify = minify;
   
 })(this);
\ No newline at end of file
diff --git a/tests/index.html b/tests/index.html
index 0c1480e..92b5e3a 100644
--- a/tests/index.html
+++ b/tests/index.html
@@ -12,7 +12,7 @@
   <body>
     
     <h1 id="qunit-header">HTML Minifier</h1>
-    <!-- <h2 id="qunit-banner"></h2> -->
+    <h2 id="qunit-banner"></h2>
     <h2 id="qunit-userAgent"></h2>
     <ol id="qunit-tests"></ol>
     
@@ -26,7 +26,33 @@
           ok(minify);
         });
         
-        test('Short doctype with html 4.01 doctype', function() {
+        test('options', function() {
+          var input = '<p>blah<span>blah 2<span>blah 3</span></span></p>';
+          equals(minify(input), input);
+          equals(minify(input, {}), input);
+        });
+        
+        test('case normalization', function() {
+          equals(minify('<P>foo</p>'), '<p>foo</p>');
+          equals(minify('<DIV>boo</DIV>'), '<div>boo</div>');
+          equals(minify('<DIV title="moo">boo</DiV>'), '<div title="moo">boo</div>');
+          equals(minify('<DIV TITLE="blah">boo</DIV>'), '<div title="blah">boo</div>');
+          equals(minify('<DIV tItLe="blah">boo</DIV>'), '<div title="blah">boo</div>');
+          equals(minify('<DiV tItLe="blah">boo</DIV>'), '<div title="blah">boo</div>');
+        });
+        
+        test('space normalization between attributes', function() {
+          equals(minify('<p title="bar">foo</p>'), '<p title="bar">foo</p>');
+          equals(minify('<p title = "bar">foo</p>'), '<p title="bar">foo</p>');
+          equals(minify('<p title\n\n\t  =\n     "bar">foo</p>'), '<p title="bar">foo</p>');
+          equals(minify('<input title="bar"       id="boo"    value="hello world">'), '<input title="bar" id="boo" value="hello world">');
+        });
+        
+        test('space normalization around text', function(){
+          equals(minify('   <p>blah</p>\n\n\n   '), '<p>blah</p>');
+        });
+        
+        test('doctype normalization', function() {
           var html401doctype = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"\n    "http://www.w3.org/TR/html4/strict.dtd">';
           var actual = minify(html401doctype, { shouldUseShortDoctype: true });
           var expected = '<!DOCTYPE html>';
@@ -41,7 +67,7 @@
           equals(actual, expected);
         });
         
-        test('Remove comments', function(){
+        test('removing comments', function(){
           var input = '<!-- test -->';
           equals(minify(input, { shouldRemoveComments: true }), '');
           
@@ -56,7 +82,7 @@
           equals(minify(input, { shouldRemoveComments: true }), input);
           
           var input = '<STYLE><!-- alert(1) --><\/STYLE>';
-          equals(minify(input, { shouldRemoveComments: true }), input);
+          equals(minify(input, { shouldRemoveComments: true }), '<style><!-- alert(1) --><\/style>');
         });
         
         test('empty attributes', function(){
@@ -74,7 +100,7 @@
           equals(minify(input, { shouldRemoveEmptyAttributes: true }), '<input name="foo">');
         });
         
-        test('Clean attributes', function(){
+        test('cleaning attributes', function(){
           var input = '<p onclick="javascript:alert(1)">x</p>';
           equals(minify(input, { shouldCleanAttributes: true }), '<p onclick="alert(1)">x</p>');
           
@@ -95,7 +121,7 @@
           equals(minify(input, { shouldCleanAttributes: true }), '<p class="foo class1 class-23">foo bar baz</p>');
         });
         
-        test('remove attribute quotes', function(){
+        test('removing attribute quotes', function(){
           var input = '<p title="blah" class="a23B-foo.bar_baz:qux" id="moo">foo</p>';
           equals(minify(input, { shouldRemoveAttributeQuotes: true }), '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
           
@@ -109,8 +135,19 @@
           equals(minify(input, { shouldRemoveAttributeQuotes: true }), '<a href="http://example.com" title=blah>\nfoo\n\n</a>');
         });
         
+        test('collapsing whitespace', function() {
+          var input = '<script type="text/javascript">  \n\t   alert(1) \n\n\n  \t <\/script>', 
+              output = '<script type="text/javascript">alert(1)<\/script>';
+              
+          equals(minify(input, { shouldCollapseWhitespace: true }), output);
+          
+          input = '<p>foo</p>    <p> bar</p>\n\n   \n\t\t  <div title="quz">baz  </div>';
+          output = '<p>foo</p><p>bar</p><div title="quz">baz</div>';
+          
+          equals(minify(input, { shouldCollapseWhitespace: true }), output);
+        });
+        
       })(this);
     </script>
-    <input type="input" title=" ">
   </body>
 </html>
\ No newline at end of file
-- 
2.34.1