html_minifier 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/.project

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/html-minifier"]
+	path = vendor/html-minifier
+	url = https://github.com/kangax/html-minifier.git

data/.travis.yml

@@ -0,0 +1,19 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby
+before_script: "git submodule update --init --recursive"
+env:
+  - EXECJS_RUNTIME=RubyRacer
+  - EXECJS_RUNTIME=RubyRhino
+matrix:
+  exclude:
+    - rvm: 1.8.7
+      env: EXECJS_RUNTIME=RubyRhino
+    - rvm: 1.9.2
+      env: EXECJS_RUNTIME=RubyRhino
+    - rvm: 1.9.3
+      env: EXECJS_RUNTIME=RubyRhino
+    - rvm: jruby
+      env: EXECJS_RUNTIME=RubyRacer

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gemspec
+gemspec
+
+# Depend on defined ExecJS runtime
+execjs_runtimes = {
+  "RubyRacer" => "therubyracer",
+  "RubyRhino" => "therubyrhino",
+  "Mustang" => "mustang"
+}
+
+if ENV["EXECJS_RUNTIME"] && execjs_runtimes[ENV["EXECJS_RUNTIME"]]
+  gem execjs_runtimes[ENV["EXECJS_RUNTIME"]], :group => :development
+end
+

data/README.md

@@ -0,0 +1,43 @@
+# HtmlMinifier
+[![Build Status](https://secure.travis-ci.org/stereobooster/html_minifier.png?branch=master)](http://travis-ci.org/stereobooster/html_minifier)
+
+Ruby wrapper for [html-minifier](https://github.com/kangax/html-minifier/).
+
+## Installation
+
+`html_minifier` is available as ruby gem.
+
+    $ gem install html_minifier
+
+Ensure that your environment has a JavaScript interpreter supported by [ExecJS](https://github.com/sstephenson/execjs). Usually, installing therubyracer gem is the best alternative.
+
+## Usage
+
+```ruby
+require 'html_minifier'
+
+HtmlMinifier.minify(File.read("source.html"))
+```
+
+Or you can use it with rake
+
+```ruby
+require "html_minifier/task"
+HtmlMinifier::Task.new :html do |t|
+  t.pattern = 'static/**/*.html'
+end
+```
+
+When initializing `HtmlMinifier`, you can pass options
+
+```ruby
+HtmlMinifier::minifier.new( <options> ).minify(source)
+# Or
+HtmlMinifier.minify(source, <options>)
+```
+
+## TODO
+
+ - add more tests
+ - add color reporter. Maybe [colorize](https://github.com/fazibear/colorize)
+ - add cli

data/Rakefile

@@ -0,0 +1,61 @@
+require "bundler/gem_tasks"
+
+[:build, :install, :release].each do |task_name|
+  Rake::Task[task_name].prerequisites << :spec
+end
+
+require 'submodule'
+Submodule::Task.new do |t|
+  t.branch = "gh-pages"
+
+  t.test do
+    js = []
+    js << File.open(File.expand_path("../lib/js/console.js", __FILE__), "r:UTF-8").read
+    %w{htmlparser htmllint htmlminifier}.each do |i|
+      js << File.open("src/#{i}.js", "r:UTF-8").read
+    end
+    js << File.open("tests/qunit.js", "r:UTF-8").read
+    js << File.open(File.expand_path("../spec/qunit_helper.js", __FILE__), "r:UTF-8").read
+    %w{minify_test lint_test}.each do |i|
+      js << File.open("tests/#{i}.js", "r:UTF-8").read
+    end
+
+    require "execjs"
+    context = ExecJS.compile js.join("\n")
+    result = context.exec "return QUnit.result();"
+    if result["fail"] > 0 && result["assertions"].respond_to?(:each)
+      puts "Failures:"
+      i = 1
+      result["assertions"].each do |test, details|
+        puts "  #{i}) #{test}"
+        puts "    Failure/Error: #{details[0]}"
+        puts "      expected: #{details[1].inspect}"
+        puts "           got: #{details[2].inspect}"
+        i+=1
+      end
+    end
+    #  (#{result['pass_asserions']}) (#{result['fail_asserions']})
+    puts "Pass: #{result['pass']}, Fail: #{result['fail']}"
+    if result["fail"] > 0
+      abort
+    end
+  end
+
+  t.after_pull do
+    %w{htmlparser htmllint htmlminifier}.each do |i|
+      cp "vendor/html-minifier/src/#{i}.js", "lib/js/#{i}.js"
+      sh "git add lib/js/#{i}.js"
+    end
+  end
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+task :default => [:spec, "submodule:test"]
+
+#desc "Generate code coverage"
+# RSpec::Core::RakeTask.new(:coverage) do |t|
+  # t.rcov = true
+  # t.rcov_opts = ["--exclude", "spec"]
+# end

data/html_minifier.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "html_minifier/version"
+
+Gem::Specification.new do |s|
+  s.name        = "html_minifier"
+  s.version     = HtmlMinifier::VERSION
+  s.authors     = ["slavic"]
+  s.email       = ["stereobooster@gmail.com"]
+  s.homepage    = "https://github.com/stereobooster/html_minifier"
+  s.summary     = %q{Ruby wrapper for kangax html-minifier}
+  s.description = %q{Ruby wrapper for kangax html-minifier}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "submodule", ">= 0.1.0"
+  s.add_runtime_dependency "rake"
+
+  s.add_dependency "multi_json", ">= 1.3"
+  s.add_dependency "execjs"
+end

data/lib/html_minifier/minifier.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require "execjs"
+require "multi_json"
+
+module HtmlMinifier
+
+  class Minifier
+    Error = ExecJS::Error
+
+    SourceBasePath = File.expand_path("../../js/", __FILE__)
+
+    def initialize(options = nil)
+      if options.instance_of? Hash then
+        @options = options.dup
+        @log = @options.delete :log
+      elsif options.nil?
+        @options = nil
+      else
+        raise 'Unsupported option for HtmlMinifier: ' + options.to_s
+      end
+
+      js = %w{console htmlparser htmllint htmlminifier}.map do |i|
+        File.open("#{SourceBasePath}/#{i}.js", "r:UTF-8").read
+      end.join("\n")
+      @context = ExecJS.compile(js)
+    end
+
+    def minify(source)
+      source = source.respond_to?(:read) ? source.read : source.to_s
+      js = []
+      if @options.nil? then
+        js << "var min = minify(#{MultiJson.dump(source)});"
+      else
+        js << "var min = minify(#{MultiJson.dump(source)}, #{MultiJson.dump(@options)});"
+      end
+      js << "return {min:min, logs:console.clear()};"
+      result = @context.exec js.join("\n")
+      if @log.respond_to?(:info)
+        result["logs"].each do |i|
+          @log.info i
+        end
+      end
+      result["min"]
+    end
+  end
+
+  def self.minify(source, options = nil)
+    Minifier.new(options).minify(source)
+  end
+  
+end

data/lib/html_minifier/version.rb

@@ -0,0 +1,4 @@
+module HtmlMinifier
+  VERSION = "0.0.2"
+  SUBMODULE = "7032d3d3d97aabf0a2c96c8155ed077b455aca31"
+end

data/lib/html_minifier.rb

@@ -0,0 +1,6 @@
+require "html_minifier/version"
+require "html_minifier/minifier"
+
+module HtmlMinifier
+  # Your code goes here...
+end

data/lib/js/console.js

@@ -0,0 +1,16 @@
+(function (global) {
+	var logs = [];
+	global.console =  {
+		log: function (message) {
+			logs.push(message);
+		},
+		get: function () {
+			return logs;
+		},
+		clear: function () {
+			var ret = logs;
+			logs = [];
+			return ret;
+		}
+	};
+}(this));

data/lib/js/exports.js

@@ -0,0 +1,16 @@
+var exports = (function () {
+	var logs = [];
+	return {
+		console: {
+			log: function (message) {
+				logs.push(message);
+			},
+			get: function () {
+				return logs;
+			},
+			clear: function () {
+				logs = [];
+			}
+		}
+	};
+})();

data/lib/js/htmllint.js

@@ -0,0 +1,150 @@
+/*!
+ * HTMLLint (to be used in conjunction with HTMLMinifier)
+ *
+ * Copyright (c) 2010 Juriy "kangax" Zaytsev
+ * Licensed under the MIT license.
+ *
+ */
+ 
+(function(global){
+  
+  function isPresentationalElement(tag) {
+    return (/^(?:b|i|big|small|hr|blink|marquee)$/).test(tag);
+  }  
+  function isDeprecatedElement(tag) {
+    return (/^(?:applet|basefont|center|dir|font|isindex|menu|s|strike|u)$/).test(tag);
+  }
+  function isEventAttribute(attrName) {
+    return (/^on[a-z]+/).test(attrName);
+  }
+  function isStyleAttribute(attrName) {
+    return ('style' === attrName.toLowerCase());
+  }
+  function isDeprecatedAttribute(tag, attrName) {
+    return (
+      (attrName === 'align' && 
+      (/^(?:caption|applet|iframe|img|imput|object|legend|table|hr|div|h[1-6]|p)$/).test(tag)) ||
+      (attrName === 'alink' && tag === 'body') ||
+      (attrName === 'alt' && tag === 'applet') ||
+      (attrName === 'archive' && tag === 'applet') ||
+      (attrName === 'background' && tag === 'body') ||
+      (attrName === 'bgcolor' && (/^(?:table|t[rdh]|body)$/).test(tag)) ||
+      (attrName === 'border' && (/^(?:img|object)$/).test(tag)) ||
+      (attrName === 'clear' && tag === 'br') ||
+      (attrName === 'code' && tag === 'applet') ||
+      (attrName === 'codebase' && tag === 'applet') ||
+      (attrName === 'color' && (/^(?:base(?:font)?)$/).test(tag)) ||
+      (attrName === 'compact' && (/^(?:dir|[dou]l|menu)$/).test(tag)) ||
+      (attrName === 'face' && (/^base(?:font)?$/).test(tag)) ||
+      (attrName === 'height' && (/^(?:t[dh]|applet)$/).test(tag)) ||
+      (attrName === 'hspace' && (/^(?:applet|img|object)$/).test(tag)) ||
+      (attrName === 'language' && tag === 'script') ||
+      (attrName === 'link' && tag === 'body') ||
+      (attrName === 'name' && tag === 'applet') ||
+      (attrName === 'noshade' && tag === 'hr') ||
+      (attrName === 'nowrap' && (/^t[dh]$/).test(tag)) ||
+      (attrName === 'object' && tag === 'applet') ||
+      (attrName === 'prompt' && tag === 'isindex') ||
+      (attrName === 'size' && (/^(?:hr|font|basefont)$/).test(tag)) ||
+      (attrName === 'start' && tag === 'ol') ||
+      (attrName === 'text' && tag === 'body') ||
+      (attrName === 'type' && (/^(?:li|ol|ul)$/).test(tag)) ||
+      (attrName === 'value' && tag === 'li') ||
+      (attrName === 'version' && tag === 'html') ||
+      (attrName === 'vlink' && tag === 'body') ||
+      (attrName === 'vspace' && (/^(?:applet|img|object)$/).test(tag)) ||
+      (attrName === 'width' && (/^(?:hr|td|th|applet|pre)$/).test(tag))
+    );
+  }
+  function isInaccessibleAttribute(attrName, attrValue) {
+    return (
+      attrName === 'href' && 
+      (/^\s*javascript\s*:\s*void\s*(\s+0|\(\s*0\s*\))\s*$/i).test(attrValue)
+    );
+  }
+  
+  function Lint() {
+    this.log = [ ];
+    this._lastElement = null;
+    this._isElementRepeated = false;
+  }
+  
+  Lint.prototype.testElement = function(tag) {
+    if (isDeprecatedElement(tag)) {
+      this.log.push(
+        '<li>Found <span class="deprecated-element">deprecated</span> <strong><code>&lt;' + 
+          tag + '&gt;</code></strong> element</li>');
+    }
+    else if (isPresentationalElement(tag)) {
+      this.log.push(
+        '<li>Found <span class="presentational-element">presentational</span> <strong><code>&lt;' + 
+          tag + '&gt;</code></strong> element</li>');
+    }
+    else {
+      this.checkRepeatingElement(tag);
+    }
+  };
+  
+  Lint.prototype.checkRepeatingElement = function(tag) {
+    if (tag === 'br' && this._lastElement === 'br') {
+      this._isElementRepeated = true;
+    }
+    else if (this._isElementRepeated) {
+      this._reportRepeatingElement();
+      this._isElementRepeated = false;
+    }
+    this._lastElement = tag;
+  };
+  
+  Lint.prototype._reportRepeatingElement = function() {
+    this.log.push('<li>Found <code>&lt;br></code> sequence. Try replacing it with styling.</li>');
+  };
+  
+  Lint.prototype.testAttribute = function(tag, attrName, attrValue) {
+    if (isEventAttribute(attrName)) {
+      this.log.push(
+        '<li>Found <span class="event-attribute">event attribute</span> (<strong>', 
+        attrName, '</strong>) on <strong><code>&lt;' + tag + '&gt;</code></strong> element</li>');
+    }
+    else if (isDeprecatedAttribute(tag, attrName)) {
+      this.log.push(
+        '<li>Found <span class="deprecated-attribute">deprecated</span> <strong>' + 
+          attrName + '</strong> attribute on <strong><code>&lt;', tag, '&gt;</code></strong> element</li>');
+    }
+    else if (isStyleAttribute(attrName)) {
+      this.log.push(
+        '<li>Found <span class="style-attribute">style attribute</span> on <strong><code>&lt;', tag, '&gt;</code></strong> element</li>');
+    }
+    else if (isInaccessibleAttribute(attrName, attrValue)) {
+      this.log.push(
+        '<li>Found <span class="inaccessible-attribute">inaccessible attribute</span> '+
+          '(on <strong><code>&lt;', tag, '&gt;</code></strong> element)</li>');
+    }
+  };
+  
+  Lint.prototype.testChars = function(chars) {
+    this._lastElement = '';
+    if (/(&nbsp;\s*){2,}/.test(chars)) {
+      this.log.push('<li>Found repeating <strong><code>&amp;nbsp;</code></strong> sequence. Try replacing it with styling.</li>');
+    }
+  };
+  
+  Lint.prototype.test = function(tag, attrName, attrValue) {
+    this.testElement(tag);
+    this.testAttribute(tag, attrName, attrValue);
+  };
+  
+  Lint.prototype.populate = function(writeToElement) {
+    if (this._isElementRepeated) {
+      this._reportRepeatingElement();
+    }
+    var report;
+    if (this.log.length && writeToElement) {
+      report = '<ol>' + this.log.join('') + '</ol>';
+      writeToElement.innerHTML = report;
+    }
+  };
+  
+  global.HTMLLint = Lint;
+  
+})(typeof exports === 'undefined' ? this : exports);

data/lib/js/htmlminifier.js

@@ -0,0 +1,406 @@
+/*!
+ * HTMLMinifier v0.4.4
+ * http://kangax.github.com/html-minifier/
+ *
+ * Copyright (c) 2010 Juriy "kangax" Zaytsev
+ * Licensed under the MIT license.
+ *
+ */
+ 
+(function(global){
+  
+  var log, HTMLParser;
+  if (global.console && global.console.log) {
+    log = function(message) {
+      // "preserving" `this`
+      global.console.log(message);
+    };
+  }
+  else {
+    log = function(){ };
+  }
+  
+  if (global.HTMLParser) {
+    HTMLParser = global.HTMLParser;
+  }
+  else if (typeof require === 'function') {
+    HTMLParser = require('./htmlparser').HTMLParser;
+  }
+
+  function trimWhitespace(str) {
+    return str.replace(/^\s+/, '').replace(/\s+$/, '');
+  }
+  if (String.prototype.trim) {
+    trimWhitespace = function(str) {
+      return str.trim();
+    };
+  }
+  
+  function collapseWhitespace(str) {
+    return str.replace(/\s+/g, ' ');
+  }
+  
+  function isConditionalComment(text) {
+    return (/\[if[^\]]+\]/).test(text);
+  }
+  
+  function isEventAttribute(attrName) {
+    return (/^on[a-z]+/).test(attrName);
+  }
+  
+  function canRemoveAttributeQuotes(value) {
+    // http://www.w3.org/TR/html4/intro/sgmltut.html#attributes
+    // avoid \w, which could match unicode in some implementations
+    return (/^[a-zA-Z0-9-._:]+$/).test(value);
+  }
+  
+  function attributesInclude(attributes, attribute) {
+    for (var i = attributes.length; i--; ) {
+      if (attributes[i].name.toLowerCase() === attribute) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  function isAttributeRedundant(tag, attrName, attrValue, attrs) {
+    attrValue = trimWhitespace(attrValue.toLowerCase());
+    return (
+        (tag === 'script' && 
+        attrName === 'language' && 
+        attrValue === 'javascript') ||
+        
+        (tag === 'form' && 
+        attrName === 'method' && 
+        attrValue === 'get') ||
+        
+        (tag === 'input' && 
+        attrName === 'type' &&
+        attrValue === 'text') ||
+        
+        (tag === 'script' &&
+        attrName === 'charset' &&
+        !attributesInclude(attrs, 'src')) ||
+        
+        (tag === 'a' &&
+        attrName === 'name' &&
+        attributesInclude(attrs, 'id')) ||
+        
+        (tag === 'area' &&
+        attrName === 'shape' &&
+        attrValue === 'rect')
+    );
+  }
+  
+  function isScriptTypeAttribute(tag, attrName, attrValue) {
+    return (
+      tag === 'script' && 
+      attrName === 'type' && 
+      trimWhitespace(attrValue.toLowerCase()) === 'text/javascript'
+    );
+  }
+  
+  function isStyleLinkTypeAttribute(tag, attrName, attrValue) {
+    return (
+      (tag === 'style' || tag === 'link') &&
+      attrName === 'type' &&
+      trimWhitespace(attrValue.toLowerCase()) === 'text/css'
+    );
+  }
+  
+  function isBooleanAttribute(attrName) {
+    return (/^(?:checked|disabled|selected|readonly)$/).test(attrName);
+  }
+  
+  function isUriTypeAttribute(attrName, tag) {
+    return (
+      ((/^(?:a|area|link|base)$/).test(tag) && attrName === 'href') ||
+      (tag === 'img' && (/^(?:src|longdesc|usemap)$/).test(attrName)) ||
+      (tag === 'object' && (/^(?:classid|codebase|data|usemap)$/).test(attrName)) ||
+      (tag === 'q' && attrName === 'cite') ||
+      (tag === 'blockquote' && attrName === 'cite') ||
+      ((tag === 'ins' || tag === 'del') && attrName === 'cite') ||
+      (tag === 'form' && attrName === 'action') ||
+      (tag === 'input' && (attrName === 'src' || attrName === 'usemap')) ||
+      (tag === 'head' && attrName === 'profile') ||
+      (tag === 'script' && (attrName === 'src' || attrName === 'for'))
+    );
+  }
+  
+  function isNumberTypeAttribute(attrName, tag) {
+    return (
+      ((/^(?:a|area|object|button)$/).test(tag) && attrName === 'tabindex') ||
+      (tag === 'input' && (attrName === 'maxlength' || attrName === 'tabindex')) ||
+      (tag === 'select' && (attrName === 'size' || attrName === 'tabindex')) ||
+      (tag === 'textarea' && (/^(?:rows|cols|tabindex)$/).test(attrName)) ||
+      (tag === 'colgroup' && attrName === 'span') ||
+      (tag === 'col' && attrName === 'span') ||
+      ((tag === 'th' || tag == 'td') && (attrName === 'rowspan' || attrName === 'colspan'))  
+    );
+  }
+  
+  function cleanAttributeValue(tag, attrName, attrValue) {
+    if (isEventAttribute(attrName)) {
+      return trimWhitespace(attrValue).replace(/^javascript:\s*/i, '').replace(/\s*;$/, '');
+    }
+    else if (attrName === 'class') {
+      return collapseWhitespace(trimWhitespace(attrValue));
+    }
+    else if (isUriTypeAttribute(attrName, tag) || isNumberTypeAttribute(attrName, tag)) {
+      return trimWhitespace(attrValue);
+    }
+    else if (attrName === 'style') {
+      return trimWhitespace(attrValue).replace(/\s*;\s*$/, '');
+    }
+    return attrValue;
+  }
+  
+  function cleanConditionalComment(comment) {
+    return comment
+      .replace(/^(\[[^\]]+\]>)\s*/, '$1')
+      .replace(/\s*(<!\[endif\])$/, '$1');
+  }
+  
+  function removeCDATASections(text) {
+    return text
+      // "/* <![CDATA[ */" or "// <![CDATA["
+      .replace(/^(?:\s*\/\*\s*<!\[CDATA\[\s*\*\/|\s*\/\/\s*<!\[CDATA\[.*)/, '')
+      // "/* ]]> */" or "// ]]>"
+      .replace(/(?:\/\*\s*\]\]>\s*\*\/|\/\/\s*\]\]>)\s*$/, '');
+  }
+  
+  var reStartDelimiter = {
+    // account for js + html comments (e.g.: //<!--)
+    'script': /^\s*(?:\/\/)?\s*<!--.*\n?/,
+    'style': /^\s*<!--\s*/
+  };
+  var reEndDelimiter = {
+    'script': /\s*(?:\/\/)?\s*-->\s*$/,
+    'style': /\s*-->\s*$/
+  };
+  function removeComments(text, tag) {
+    return text.replace(reStartDelimiter[tag], '').replace(reEndDelimiter[tag], '');
+  }
+  
+  function isOptionalTag(tag) {
+    return (/^(?:html|t?body|t?head|tfoot|tr|option)$/).test(tag);
+  }
+  
+  var reEmptyAttribute = new RegExp(
+    '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
+      '?:down|up|over|move|out)|key(?:press|down|up)))$');
+      
+  function canDeleteEmptyAttribute(tag, attrName, attrValue) {
+    var isValueEmpty = /^(["'])?\s*\1$/.test(attrValue);
+    if (isValueEmpty) {
+      return (
+        (tag === 'input' && attrName === 'value') ||
+        reEmptyAttribute.test(attrName));
+    }
+    return false;
+  }
+  
+  function canRemoveElement(tag) {
+    return tag !== 'textarea';
+  }
+  
+  function canCollapseWhitespace(tag) {
+    return !(/^(?:script|style|pre|textarea)$/.test(tag));
+  }
+  
+  function canTrimWhitespace(tag) {
+    return !(/^(?:pre|textarea)$/.test(tag));
+  }
+  
+  function normalizeAttribute(attr, attrs, tag, options) {
+    
+    var attrName = attr.name.toLowerCase(),
+        attrValue = attr.escaped,
+        attrFragment;
+    
+    if ((options.removeRedundantAttributes && 
+      isAttributeRedundant(tag, attrName, attrValue, attrs)) 
+      ||
+      (options.removeScriptTypeAttributes && 
+      isScriptTypeAttribute(tag, attrName, attrValue))
+      ||
+      (options.removeStyleLinkTypeAttributes &&
+      isStyleLinkTypeAttribute(tag, attrName, attrValue))) {
+      return '';
+    }
+    
+    attrValue = cleanAttributeValue(tag, attrName, attrValue);
+    
+    if (!options.removeAttributeQuotes || 
+        !canRemoveAttributeQuotes(attrValue)) {
+      attrValue = '"' + attrValue + '"';
+    }
+    
+    if (options.removeEmptyAttributes &&
+        canDeleteEmptyAttribute(tag, attrName, attrValue)) {
+      return '';
+    }
+
+    if (options.collapseBooleanAttributes && 
+        isBooleanAttribute(attrName)) {
+      attrFragment = attrName;
+    }
+    else {
+      attrFragment = attrName + '=' + attrValue;
+    }
+    
+    return (' ' + attrFragment);
+  }
+
+
+  function setDefaultTesters(options) {
+
+    var defaultTesters = ['canCollapseWhitespace','canTrimWhitespace'];
+
+    for (var i = 0, len = defaultTesters.length; i < len; i++) {
+      if (!options[defaultTesters[i]]) {
+        options[defaultTesters[i]] = function() {
+          return false;
+        }
+      }
+    }
+  }
+  
+  function minify(value, options) {
+    
+    options = options || { };
+    value = trimWhitespace(value);
+    setDefaultTesters(options);
+    
+    var results = [ ],
+        buffer = [ ],
+        currentChars = '',
+        currentTag = '',
+        currentAttrs = [],
+        stackNoTrimWhitespace = [],
+        stackNoCollapseWhitespace = [],
+        lint = options.lint,
+        t = new Date()
+
+    function _canCollapseWhitespace(tag, attrs) {
+      return canCollapseWhitespace(tag) || options.canTrimWhitespace(tag, attrs);
+    }
+
+    function _canTrimWhitespace(tag, attrs) {
+      return canTrimWhitespace(tag) || options.canTrimWhitespace(tag, attrs);
+    }
+    
+    HTMLParser(value, {
+      start: function( tag, attrs, unary ) {
+        tag = tag.toLowerCase();
+        currentTag = tag;
+        currentChars = '';
+        currentAttrs = attrs;
+        
+        // set whitespace flags for nested tags (eg. <code> within a <pre>)
+        if (options.collapseWhitespace) {
+          if (!_canTrimWhitespace(tag, attrs)) {
+            stackNoTrimWhitespace.push(tag);
+          }
+          if (!_canCollapseWhitespace(tag, attrs)) {
+            stackNoCollapseWhitespace.push(tag);
+          }
+        }
+        
+        buffer.push('<', tag);
+        
+        lint && lint.testElement(tag);
+        
+        for ( var i = 0, len = attrs.length; i < len; i++ ) {
+          lint && lint.testAttribute(tag, attrs[i].name.toLowerCase(), attrs[i].escaped);
+          buffer.push(normalizeAttribute(attrs[i], attrs, tag, options));
+        }
+        
+        buffer.push('>');
+      },
+      end: function( tag ) {
+        // check if current tag is in a whitespace stack
+        if (options.collapseWhitespace) {
+          if (stackNoTrimWhitespace.length &&
+            tag == stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+            stackNoTrimWhitespace.pop();
+          }
+          if (stackNoCollapseWhitespace.length &&
+            tag == stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+            stackNoCollapseWhitespace.pop();
+          }
+        }
+        
+        var isElementEmpty = currentChars === '' && tag === currentTag;
+        if ((options.removeEmptyElements && isElementEmpty && canRemoveElement(tag))) {
+          // remove last "element" from buffer, return
+          buffer.splice(buffer.lastIndexOf('<'));
+          return;
+        }
+        else if (options.removeOptionalTags && isOptionalTag(tag)) {
+          // noop, leave start tag in buffer
+          return;
+        }
+        else {
+          // push end tag to buffer
+          buffer.push('</', tag.toLowerCase(), '>');
+          results.push.apply(results, buffer);
+        }
+        // flush buffer
+        buffer.length = 0;
+        currentChars = '';
+      },
+      chars: function( text ) {
+        if (currentTag === 'script' || currentTag === 'style') {
+          if (options.removeCommentsFromCDATA) {
+            text = removeComments(text, currentTag);
+          }
+          if (options.removeCDATASectionsFromCDATA) {
+            text = removeCDATASections(text);
+          }
+        }
+        if (options.collapseWhitespace) {
+          if (!stackNoTrimWhitespace.length && _canTrimWhitespace(currentTag, currentAttrs)) {
+            text = trimWhitespace(text);
+          }
+          if (!stackNoCollapseWhitespace.length && _canCollapseWhitespace(currentTag, currentAttrs)) {
+            text = collapseWhitespace(text);
+          }
+        }
+        currentChars = text;
+        lint && lint.testChars(text);
+        buffer.push(text);
+      },
+      comment: function( text ) {
+        if (options.removeComments) {
+          if (isConditionalComment(text)) {
+            text = '<!--' + cleanConditionalComment(text) + '-->';
+          }
+          else {
+            text = '';
+          }
+        }
+        else {
+          text = '<!--' + text + '-->';
+        }
+        buffer.push(text);
+      },
+      doctype: function(doctype) {
+        buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespace(doctype));
+      }
+    });  
+    
+    results.push.apply(results, buffer)    
+    var str = results.join('');
+    log('minified in: ' + (new Date() - t) + 'ms');
+    return str;
+  }
+
+  // for CommonJS enviroments, export everything
+  if ( typeof exports !== "undefined" ) {
+    exports.minify = minify;
+  } else {
+    global.minify = minify;
+  }
+
+}(this));

data/lib/js/htmlparser.js

@@ -0,0 +1,327 @@
+/*
+ * HTML Parser By John Resig (ejohn.org)
+ * Modified by Juriy "kangax" Zaytsev
+ * Original code by Erik Arvidsson, Mozilla Public License
+ * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
+ *
+ * // Use like so:
+ * HTMLParser(htmlString, {
+ *     start: function(tag, attrs, unary) {},
+ *     end: function(tag) {},
+ *     chars: function(text) {},
+ *     comment: function(text) {}
+ * });
+ *
+ * // or to get an XML string:
+ * HTMLtoXML(htmlString);
+ *
+ * // or to get an XML DOM Document
+ * HTMLtoDOM(htmlString);
+ *
+ * // or to inject into an existing document/DOM node
+ * HTMLtoDOM(htmlString, document);
+ * HTMLtoDOM(htmlString, document.body);
+ *
+ */
+
+(function(global){
+
+  // Regular Expressions for parsing tags and attributes
+  var startTag = /^<(\w+)((?:\s*[\w:-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
+      endTag = /^<\/(\w+)[^>]*>/,
+      attr = /([\w:-]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g,
+      doctype = /^<!DOCTYPE [^>]+>/i;
+    
+  // Empty Elements - HTML 4.01
+  var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed");
+
+  // Block Elements - HTML 4.01
+  var block = makeMap("address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,ins,isindex,li,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
+
+  // Inline Elements - HTML 4.01
+  var inline = makeMap("a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
+
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
+
+  // Attributes that have their values filled in disabled="disabled"
+  var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
+
+  // Special Elements (can contain anything)
+  var special = makeMap("script,style");
+  
+  var reCache = { }, stackedTag, re;
+
+  var HTMLParser = global.HTMLParser = function( html, handler ) {
+    var index, chars, match, stack = [], last = html;
+    stack.last = function(){
+      return this[ this.length - 1 ];
+    };
+
+    while ( html ) {
+      chars = true;
+
+      // Make sure we're not in a script or style element
+      if ( !stack.last() || !special[ stack.last() ] ) {
+
+        // Comment
+        if ( html.indexOf("<!--") === 0 ) {
+          index = html.indexOf("-->");
+  
+          if ( index >= 0 ) {
+            if ( handler.comment )
+              handler.comment( html.substring( 4, index ) );
+            html = html.substring( index + 3 );
+            chars = false;
+          }
+        }
+        else if ( match = doctype.exec( html )) {
+          if ( handler.doctype )
+            handler.doctype( match[0] );
+          html = html.substring( match[0].length );
+          chars = false;
+        
+        // end tag
+        } else if ( html.indexOf("</") === 0 ) {
+          match = html.match( endTag );
+  
+          if ( match ) {
+            html = html.substring( match[0].length );
+            match[0].replace( endTag, parseEndTag );
+            chars = false;
+          }
+  
+        // start tag
+        } else if ( html.indexOf("<") === 0 ) {
+          match = html.match( startTag );
+  
+          if ( match ) {
+            html = html.substring( match[0].length );
+            match[0].replace( startTag, parseStartTag );
+            chars = false;
+          }
+        }
+
+        if ( chars ) {
+          index = html.indexOf("<");
+          
+          var text = index < 0 ? html : html.substring( 0, index );
+          html = index < 0 ? "" : html.substring( index );
+          
+          if ( handler.chars )
+            handler.chars( text );
+        }
+
+      } else {
+        
+        stackedTag = stack.last().toLowerCase();
+        reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp("([\\s\\S]*?)<\/" + stackedTag + "[^>]*>", "i"));
+        
+        html = html.replace(reStackedTag, function(all, text) {
+          if (stackedTag !== 'script' && stackedTag !== 'style') {
+            text = text
+              .replace(/<!--([\s\S]*?)-->/g, "$1")
+              .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1");
+          }
+
+          if ( handler.chars )
+            handler.chars( text );
+
+          return "";
+        });
+
+        parseEndTag( "", stackedTag );
+      }
+
+      if ( html == last )
+        throw "Parse Error: " + html;
+      last = html;
+    }
+    
+    // Clean up any remaining tags
+    parseEndTag();
+
+    function parseStartTag( tag, tagName, rest, unary ) {
+      if ( block[ tagName ] ) {
+        while ( stack.last() && inline[ stack.last() ] ) {
+          parseEndTag( "", stack.last() );
+        }
+      }
+
+      if ( closeSelf[ tagName ] && stack.last() == tagName ) {
+        parseEndTag( "", tagName );
+      }
+
+      unary = empty[ tagName ] || !!unary;
+
+      if ( !unary )
+        stack.push( tagName );
+      
+      if ( handler.start ) {
+        var attrs = [];
+  
+        rest.replace(attr, function(match, name) {
+          var value = arguments[2] ? arguments[2] :
+            arguments[3] ? arguments[3] :
+            arguments[4] ? arguments[4] :
+            fillAttrs[name] ? name : "";
+          attrs.push({
+            name: name,
+            value: value,
+            escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
+          });
+        });
+  
+        if ( handler.start )
+          handler.start( tagName, attrs, unary );
+      }
+    }
+
+    function parseEndTag( tag, tagName ) {
+      // If no tag name is provided, clean shop
+      if ( !tagName )
+        var pos = 0;
+        
+      // Find the closest opened tag of the same type
+      else
+        for ( var pos = stack.length - 1; pos >= 0; pos-- )
+          if ( stack[ pos ] == tagName )
+            break;
+      
+      if ( pos >= 0 ) {
+        // Close all the open elements, up the stack
+        for ( var i = stack.length - 1; i >= pos; i-- )
+          if ( handler.end )
+            handler.end( stack[ i ] );
+        
+        // Remove the open elements from the stack
+        stack.length = pos;
+      }
+    }
+  };
+  
+  global.HTMLtoXML = function( html ) {
+    var results = "";
+    
+    HTMLParser(html, {
+      start: function( tag, attrs, unary ) {
+        results += "<" + tag;
+    
+        for ( var i = 0; i < attrs.length; i++ )
+          results += " " + attrs[i].name + '="' + attrs[i].escaped + '"';
+    
+        results += (unary ? "/" : "") + ">";
+      },
+      end: function( tag ) {
+        results += "</" + tag + ">";
+      },
+      chars: function( text ) {
+        results += text;
+      },
+      comment: function( text ) {
+        results += "<!--" + text + "-->";
+      }
+    });
+    
+    return results;
+  };
+  
+  global.HTMLtoDOM = function( html, doc ) {
+    // There can be only one of these elements
+    var one = makeMap("html,head,body,title");
+    
+    // Enforce a structure for the document
+    var structure = {
+      link: "head",
+      base: "head"
+    };
+  
+    if ( !doc ) {
+      if ( typeof DOMDocument != "undefined" )
+        doc = new DOMDocument();
+      else if ( typeof document != "undefined" && document.implementation && document.implementation.createDocument )
+        doc = document.implementation.createDocument("", "", null);
+      else if ( typeof ActiveX != "undefined" )
+        doc = new ActiveXObject("Msxml.DOMDocument");
+      
+    } else
+      doc = doc.ownerDocument ||
+        doc.getOwnerDocument && doc.getOwnerDocument() ||
+        doc;
+    
+    var elems = [],
+      documentElement = doc.documentElement ||
+        doc.getDocumentElement && doc.getDocumentElement();
+        
+    // If we're dealing with an empty document then we
+    // need to pre-populate it with the HTML document structure
+    if ( !documentElement && doc.createElement ) (function(){
+      var html = doc.createElement("html");
+      var head = doc.createElement("head");
+      head.appendChild( doc.createElement("title") );
+      html.appendChild( head );
+      html.appendChild( doc.createElement("body") );
+      doc.appendChild( html );
+    })();
+    
+    // Find all the unique elements
+    if ( doc.getElementsByTagName )
+      for ( var i in one )
+        one[ i ] = doc.getElementsByTagName( i )[0];
+    
+    // If we're working with a document, inject contents into
+    // the body element
+    var curParentNode = one.body;
+    
+    HTMLParser( html, {
+      start: function( tagName, attrs, unary ) {
+        // If it's a pre-built element, then we can ignore
+        // its construction
+        if ( one[ tagName ] ) {
+          curParentNode = one[ tagName ];
+          return;
+        }
+      
+        var elem = doc.createElement( tagName );
+        
+        for ( var attr in attrs )
+          elem.setAttribute( attrs[ attr ].name, attrs[ attr ].value );
+        
+        if ( structure[ tagName ] && typeof one[ structure[ tagName ] ] != "boolean" )
+          one[ structure[ tagName ] ].appendChild( elem );
+        
+        else if ( curParentNode && curParentNode.appendChild )
+          curParentNode.appendChild( elem );
+          
+        if ( !unary ) {
+          elems.push( elem );
+          curParentNode = elem;
+        }
+      },
+      end: function( tag ) {
+        elems.length -= 1;
+        
+        // Init the new parentNode
+        curParentNode = elems[ elems.length - 1 ];
+      },
+      chars: function( text ) {
+        curParentNode.appendChild( doc.createTextNode( text ) );
+      },
+      comment: function( text ) {
+        // create comment node
+      }
+    });
+    
+    return doc;
+  };
+
+  function makeMap(str){
+    var obj = {}, items = str.split(",");
+    for ( var i = 0; i < items.length; i++ ) {
+      obj[ items[i] ] = true;
+      obj[ items[i].toUpperCase() ] = true;
+    }
+    return obj;
+  }
+})(typeof exports === 'undefined' ? this : exports);

data/spec/html_minifier_spec.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+require "html_minifier"
+
+class TestLogger
+  attr_accessor :logs
+
+  def initialize
+    @logs = []
+  end
+
+  def info message
+    @logs <<  message
+  end
+end
+
+describe "HtmlMinifier" do
+  
+  it "it works" do
+    html = '<p>foo</p>'
+    HtmlMinifier.minify(html).should eq html
+  end
+
+  it "it logs" do
+    html = '<p>foo</p>'
+    log = TestLogger.new
+    HtmlMinifier.minify(html, :log => log).should eq html
+    log.logs.length.should eq 1
+  end
+end

data/spec/qunit_helper.js

@@ -0,0 +1,44 @@
+(function(QUnit) {
+
+    QUnit.init();
+    QUnit.config.blocking = false;
+    QUnit.config.autorun = true;
+    QUnit.config.updateRate = 0;
+
+    var assertions,
+        result = { 
+            pass: 0,
+            fail: 0,
+            pass_asserions: 0,
+            fail_asserions: 0,
+            assertions: {},
+            tests: 0
+        };
+
+    QUnit.testDone(function (r) {
+        if (r.failed > 0) {
+            result.fail += 1;
+            result.assertions[(r.module ? r.module + ':' : '') + r.name] = assertions;
+            assertions = null;
+        } else {
+            result.pass += 1;
+        }
+        result.fail_asserions += r.failed;
+        result.pass_asserions += r.passed;
+        result.tests++;
+    });
+
+    QUnit.log(function (r) {
+        if (!r.result) {
+            assertions = [r.message, r.actual, r.expected];
+        }
+    });
+
+    QUnit.result = function () {
+        // run the tests
+        // QUnit.begin();
+        // QUnit.start();
+        return result;
+    };
+
+}( QUnit ));

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: html_minifier
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- slavic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &28832952 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *28832952
+- !ruby/object:Gem::Dependency
+  name: submodule
+  requirement: &28832652 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *28832652
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &28832400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *28832400
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &28832076 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *28832076
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: &28831824 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *28831824
+description: Ruby wrapper for kangax html-minifier
+email:
+- stereobooster@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- html_minifier.gemspec
+- lib/html_minifier.rb
+- lib/html_minifier/linter.rb
+- lib/html_minifier/minifier.rb
+- lib/html_minifier/task.rb
+- lib/html_minifier/version.rb
+- lib/js/console.js
+- lib/js/exports.js
+- lib/js/htmllint.js
+- lib/js/htmlminifier.js
+- lib/js/htmlparser.js
+- spec/html_minifier_spec.rb
+- spec/qunit_helper.js
+homepage: https://github.com/stereobooster/html_minifier
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -143587247
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -143587247
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for kangax html-minifier
+test_files: []