uglifier 0.1.0 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/uglifier.rb

@@ -10,6 +10,7 @@ class Uglifier
     :squeeze => true, # Squeeze code resulting in smaller, but less-readable code
     :seqs => true, # Reduce consecutive statements in blocks into single statement
     :dead_code => true, # Remove dead code (e.g. after return)
+    :extra => false, # Additional and potentially unsafe optimizations
     :beautify => false, # Ouput indented code
     :beautify_options => {
       :indent_level => 4,
@@ -51,12 +52,13 @@ class Uglifier
   def squeeze(cxt, ast)
     cxt["ast_squeeze"].call(ast, {
       "make_seqs" => @options[:seqs],
-      "dead_code" => @options[:dead_code]
+      "dead_code" => @options[:dead_code],
+      "extra" => @options[:extra]
     })
   end
 
   def initialize_v8(cxt)
-    cxt["process"] = { :version => "v1" }
+    cxt["process"] = { :version => "v0.2.0" }
     exports = {
       "sys" => {
         :debug => lambda { |m| puts m }

data/spec/uglifier_spec.rb

@@ -15,4 +15,14 @@ describe "Uglifier" do
       Uglifier.new.compile(")(")
     }.should raise_error(Uglifier::Error)
   end
+
+  it "logs to output" do
+    $stdout.should_receive(:write).at_least(:once)
+    lambda {
+      Uglifier.new.compile("function uglifyThis() {
+        return;
+        return 1; // This is an error
+      }")
+    }.should_not raise_error(Uglifier::Error)
+  end
 end

data/uglifier.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{uglifier}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ville Lautanala"]
+  s.date = %q{2010-11-18}
+  s.email = %q{lautis@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".gitmodules",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/uglifier.rb",
+    "spec/spec_helper.rb",
+    "spec/uglifier_spec.rb",
+    "uglifier.gemspec",
+    "vendor/uglifyjs/lib/parse-js.js",
+    "vendor/uglifyjs/lib/process.js"
+  ]
+  s.homepage = %q{http://github.com/lautis/uglifier}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby wrapper for UglifyJS JavaScript compressor}
+  s.test_files = [
+    "spec/spec_helper.rb",
+    "spec/uglifier_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<therubyracer>, [">= 0.7.5"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.0.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<therubyracer>, [">= 0.7.5"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.0.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<therubyracer>, [">= 0.7.5"])
+      s.add_dependency(%q<rspec>, ["~> 2.0.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<therubyracer>, [">= 0.7.5"])
+      s.add_dependency(%q<rspec>, ["~> 2.0.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<therubyracer>, [">= 0.7.5"])
+    s.add_dependency(%q<rspec>, ["~> 2.0.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<therubyracer>, [">= 0.7.5"])
+    s.add_dependency(%q<rspec>, ["~> 2.0.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.0.pre5"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/vendor/uglifyjs/lib/parse-js.js

@@ -460,9 +460,10 @@ function tokenizer($TEXT, skip_comments) {
 
         var handle_slash = skip_comments ? function() {
                 next();
+                var regex_allowed = S.regex_allowed;
                 switch (peek()) {
-                    case "/": read_line_comment(); return next_token();
-                    case "*": read_multiline_comment(); return next_token();
+                    case "/": read_line_comment(); S.regex_allowed = regex_allowed; return next_token();
+                    case "*": read_multiline_comment(); S.regex_allowed = regex_allowed; return next_token();
                 }
                 return S.regex_allowed ? read_regexp() : read_operator("/");
         } : function() {

data/vendor/uglifyjs/lib/process.js

@@ -405,9 +405,7 @@ function ast_add_scope(ast) {
                                 if (c != null) return [
                                         "try",
                                         t.map(walk),
-                                        with_new_scope(function(){
-                                                return [ define(c[0]), c[1].map(walk) ];
-                                        }),
+                                        [ define(c[0]), c[1].map(walk) ],
                                         f != null ? f.map(walk) : null
                                 ];
                         },
@@ -509,9 +507,7 @@ function ast_mangle(ast, do_toplevel) {
                 "try": function(t, c, f) {
                         return [ "try",
                                  t.map(walk),
-                                 c ? with_scope(c.scope, function(){
-                                         return [ get_mangled(c[0]), c[1].map(walk) ];
-                                 }) : null,
+                                 c != null ? [ get_mangled(c[0]), c[1].map(walk) ] : null,
                                  f != null ? f.map(walk) : null ];
                 },
                 "toplevel": function(body) {
@@ -527,36 +523,6 @@ function ast_mangle(ast, do_toplevel) {
         });
 };
 
-// function ast_has_side_effects(ast) {
-//         var w = ast_walker();
-//         var FOUND_SIDE_EFFECTS = {};
-//         function _found() { throw FOUND_SIDE_EFFECTS };
-//         try {
-//                 w.with_walkers({
-//                         "new": _found,
-//                         "call": _found,
-//                         "assign": _found,
-//                         "defun": _found,
-//                         "var": _found,
-//                         "const": _found,
-//                         "throw": _found,
-//                         "return": _found,
-//                         "break": _found,
-//                         "continue": _found,
-//                         "label": _found,
-//                         "function": function(name) {
-//                                 if (name) _found();
-//                         }
-//                 }, function(){
-//                         w.walk(ast);
-//                 });
-//         } catch(ex) {
-//                 if (ex === FOUND_SIDE_EFFECTS)
-//                         return true;
-//                 throw ex;
-//         }
-// };
-
 /* -----[
    - compress foo["bar"] into foo.bar,
    - remove block brackets {} where possible
@@ -572,11 +538,72 @@ function warn(msg) {
         sys.debug(msg);
 };
 
+function best_of(ast1, ast2) {
+        return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
+};
+
+function last_stat(b) {
+        if (b[0] == "block" && b[1] && b[1].length > 0)
+                return b[1][b[1].length - 1];
+        return b;
+}
+
+function aborts(t) {
+        if (t) {
+                t = last_stat(t);
+                if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
+                        return true;
+        }
+};
+
+function negate(c) {
+        var not_c = [ "unary-prefix", "!", c ];
+        switch (c[0]) {
+            case "unary-prefix":
+                return c[1] == "!" ? c[2] : c;
+            case "atom":
+                switch (c[1]) {
+                    case "false": return [ "num", 0 ];
+                    case "true": return [ "num", 1 ];
+                }
+                break;
+            case "binary":
+                var op = c[1], left = c[2], right = c[3];
+                switch (op) {
+                    case "<=": return [ "binary", ">", left, right ];
+                    case "<": return [ "binary", ">=", left, right ];
+                    case ">=": return [ "binary", "<", left, right ];
+                    case ">": return [ "binary", "<=", left, right ];
+                    case "==": return [ "binary", "!=", left, right ];
+                    case "!=": return [ "binary", "==", left, right ];
+                    case "===": return [ "binary", "!==", left, right ];
+                    case "!==": return [ "binary", "===", left, right ];
+                    case "&&": return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]);
+                    case "||": return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]);
+                }
+                break;
+        }
+        return not_c;
+};
+
+function make_conditional(c, t, e) {
+        if (c[0] == "unary-prefix" && c[1] == "!") {
+                return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
+        } else {
+                return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ];
+        }
+};
+
+function empty(b) {
+        return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
+};
+
 function ast_squeeze(ast, options) {
         options = defaults(options, {
-                make_seqs: true,
-                dead_code: true,
-                no_warnings: false
+                make_seqs   : true,
+                dead_code   : true,
+                no_warnings : false,
+                extra       : false
         });
 
         var w = ast_walker(), walk = w.walk;
@@ -585,22 +612,98 @@ function ast_squeeze(ast, options) {
                 return node[0] == "string" || node[0] == "num";
         };
 
+        function find_first_execute(node) {
+                if (!node)
+                        return false;
+
+                switch (node[0]) {
+                        case "num":
+                        case "string":
+                        case "name":
+                                return node;
+                        case "call":
+                        case "conditional":
+                        case "for":
+                        case "if":
+                        case "new":
+                        case "return":
+                        case "stat":
+                        case "switch":
+                        case "throw":
+                                return find_first_execute(node[1]);
+                        case "binary":
+                                return find_first_execute(node[2]);
+                        case "assign":
+                                if (node[1] === true)
+                                        return find_first_execute(node[3]);
+                                break;
+                        case "var":
+                                if (node[1][0].length > 1)
+                                        return find_first_execute(node[1][0][1]);
+                                break;
+                }
+                return null;
+        }
+
+        function find_assign_recursive(p, v) {
+                if (p[0] == "assign" && p[1] != true || p[0] == "unary-prefix") {
+                        if (p[2][0] == "name" && v[0] == "name" && p[2][1] == v[1])
+                                return true;
+                        return false;
+                }
+
+                if (p[0] != "assign" || p[1] !== true)
+                        return false;
+
+                if ((is_constant(p[3]) && p[3][0] == v[0] && p[3][1] == v[1]) ||
+                    (p[3][0] == "name" && v[0] == "name" && p[3][1] == v[1]) ||
+                    (p[2][0] == "name" && v[0] == "name" && p[2][1] == v[1]))
+                        return true;
+
+                return find_assign_recursive(p[3], v);
+        };
+
         function rmblock(block) {
                 if (block != null && block[0] == "block" && block[1] && block[1].length == 1)
                         block = block[1][0];
                 return block;
         };
 
+        function clone(obj) {
+                if (obj && obj.constructor == Array)
+                        return obj.map(clone);
+                return obj;
+        };
+
+        function make_seq_to_statements(node) {
+                if (node[0] != "seq") {
+                        switch (node[0]) {
+                                case "var":
+                                case "const":
+                                        return [ node ];
+                                default:
+                                        return [ [ "stat", node ] ];
+                        }
+                }
+
+                var ret = [];
+                for (var i = 1; i < node.length; i++)
+                        ret.push.apply(ret, make_seq_to_statements(node[i]));
+
+                return ret;
+        };
+
         function _lambda(name, args, body) {
                 return [ this[0], name, args, tighten(body.map(walk), "lambda") ];
         };
 
         // we get here for blocks that have been already transformed.
-        // this function does two things:
+        // this function does a few things:
         // 1. discard useless blocks
         // 2. join consecutive var declarations
         // 3. remove obviously dead code
         // 4. transform consecutive statements using the comma operator
+        // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
         function tighten(statements, block_type) {
                 statements = statements.reduce(function(a, stat){
                         if (stat[0] == "block") {
@@ -613,6 +716,64 @@ function ast_squeeze(ast, options) {
                         return a;
                 }, []);
 
+                if (options.extra) {
+                        // Detightening things. We do this because then we can assume that the
+                        // statements are structured in a specific way.
+                        statements = (function(a, prev) {
+                                statements.forEach(function(cur) {
+                                        switch (cur[0]) {
+                                            case "for":
+                                                if (cur[1] != null) {
+                                                        a.push.apply(a, make_seq_to_statements(cur[1]));
+                                                        cur[1] = null;
+                                                }
+                                                a.push(cur);
+                                                break;
+                                            case "stat":
+                                                var stats = make_seq_to_statements(cur[1]);
+                                                stats.forEach(function(s) {
+                                                        if (s[1][0] == "unary-postfix")
+                                                                s[1][0] = "unary-prefix";
+                                                });
+                                                a.push.apply(a, stats);
+                                                break;
+                                            default:
+                                                a.push(cur);
+                                        }
+                                });
+                                return a;
+                        })([]);
+
+                        statements = (function(a, prev) {
+                                statements.forEach(function(cur) {
+                                        if (!(prev && prev[0] == "stat")) {
+                                                a.push(cur);
+                                                prev = cur;
+                                                return;
+                                        }
+
+                                        var p = prev[1];
+                                        var c = find_first_execute(cur);
+                                        if (c && find_assign_recursive(p, c)) {
+                                                var old_cur = clone(cur);
+                                                c.splice(0, c.length);
+                                                c.push.apply(c, p);
+                                                var tmp_cur = best_of(cur, [ "toplevel", [ prev, old_cur ] ]);
+                                                if (tmp_cur == cur) {
+                                                        a[a.length -1] = cur;
+                                                } else {
+                                                        cur = old_cur;
+                                                        a.push(cur);
+                                                }
+                                        } else {
+                                                a.push(cur);
+                                        }
+                                        prev = cur;
+                                });
+                                return a;
+                        })([]);
+                }
+
                 statements = (function(a, prev){
                         statements.forEach(function(cur){
                                 if (prev && ((cur[0] == "var" && prev[0] == "var") ||
@@ -646,28 +807,47 @@ function ast_squeeze(ast, options) {
 
                 if (options.make_seqs) statements = (function(a, prev) {
                         statements.forEach(function(cur){
-                                if (!prev) {
-                                        a.push(cur);
-                                        if (cur[0] == "stat") prev = cur;
-                                } else if (cur[0] == "stat" && prev[0] == "stat") {
+                                if (prev && prev[0] == "stat" && cur[0] == "stat") {
                                         prev[1] = [ "seq", prev[1], cur[1] ];
                                 } else {
                                         a.push(cur);
-                                        prev = null;
+                                        prev = cur;
                                 }
                         });
                         return a;
                 })([]);
 
+                if (options.extra) {
+                        statements = (function(a, prev){
+                                statements.forEach(function(cur){
+                                        var replaced = false;
+                                        if (prev && cur[0] == "for" && cur[1] == null && (prev[0] == "var" || prev[0] == "const" || prev[0] == "stat")) {
+                                                cur[1] = prev;
+                                                a[a.length - 1] = cur;
+                                        } else {
+                                                a.push(cur);
+                                        }
+                                        prev = cur;
+                                });
+                                return a;
+                        })([]);
+                }
+
                 if (block_type == "lambda") statements = (function(i, a, stat){
                         while (i < statements.length) {
                                 stat = statements[i++];
-                                if (stat[0] == "if" && stat[2][0] == "return" && stat[2][1] == null && !stat[3]) {
-                                        a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
-                                        break;
-                                } else {
-                                        a.push(stat);
+                                if (stat[0] == "if" && !stat[3]) {
+                                        if (stat[2][0] == "return" && stat[2][1] == null) {
+                                                a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
+                                                break;
+                                        }
+                                        var last = last_stat(stat[2]);
+                                        if (last[0] == "return" && last[1] == null) {
+                                                a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
+                                                break;
+                                        }
                                 }
+                                a.push(stat);
                         }
                         return a;
                 })(0, []);
@@ -675,52 +855,30 @@ function ast_squeeze(ast, options) {
                 return statements;
         };
 
-        function best_of(ast1, ast2) {
-                return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
-        };
-
-        function aborts(t) {
-                if (t[0] == "block" && t[1] && t[1].length > 0)
-                        t = t[1][t[1].length - 1]; // interested in last statement
-                if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
-                        return true;
-        };
-
-        function negate(c) {
-                if (c[0] == "unary-prefix" && c[1] == "!") return c[2];
-                else return [ "unary-prefix", "!", c ];
-        };
-
-        function make_conditional(c, t, e) {
-                if (c[0] == "unary-prefix" && c[1] == "!") {
-                        return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
-                } else {
-                        return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ];
-                }
-        };
-
-        function empty(b) {
-                return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
-        };
-
         function make_if(c, t, e) {
                 c = walk(c);
                 t = walk(t);
                 e = walk(e);
-                var negated = c[0] == "unary-prefix" && c[1] == "!";
+
                 if (empty(t)) {
-                        if (negated) c = c[2];
-                        else c = [ "unary-prefix", "!", c ];
+                        c = negate(c);
                         t = e;
                         e = null;
-                }
-                if (empty(e)) {
+                } else if (empty(e)) {
                         e = null;
                 } else {
-                        if (negated) {
-                                c = c[2];
-                                var tmp = t; t = e; e = tmp;
-                        }
+                        // if we have both else and then, maybe it makes sense to switch them?
+                        (function(){
+                                var a = gen_code(c);
+                                var n = negate(c);
+                                var b = gen_code(n);
+                                if (b.length < a.length) {
+                                        var tmp = t;
+                                        t = e;
+                                        e = tmp;
+                                        c = n;
+                                }
+                        })();
                 }
                 if (empty(e) && empty(t))
                         return [ "stat", c ];
@@ -748,6 +906,15 @@ function ast_squeeze(ast, options) {
                         }
                         ret = walk([ "block", ret ]);
                 }
+                else if (t && aborts(e)) {
+                        ret = [ [ "if", negate(c), e ] ];
+                        if (t[0] == "block") {
+                                if (t[1]) ret = ret.concat(t[1]);
+                        } else {
+                                ret.push(t);
+                        }
+                        ret = walk([ "block", ret ]);
+                }
                 return ret;
         };
 
@@ -785,19 +952,23 @@ function ast_squeeze(ast, options) {
                         left = walk(left);
                         right = walk(right);
                         var best = [ "binary", op, left, right ];
-                        if (is_constant(left) && is_constant(right)) {
-                                var val = null;
-                                switch (op) {
-                                    case "+": val = left[1] + right[1]; break;
-                                    case "*": val = left[1] * right[1]; break;
-                                    case "/": val = left[1] / right[1]; break;
-                                    case "-": val = left[1] - right[1]; break;
-                                    case "<<": val = left[1] << right[1]; break;
-                                    case ">>": val = left[1] >> right[1]; break;
-                                    case ">>>": val = left[1] >>> right[1]; break;
-                                }
-                                if (val != null) {
-                                        best = best_of(best, [ typeof val == "string" ? "string" : "num", val ]);
+                        if (is_constant(right)) {
+                                if (is_constant(left)) {
+                                        var val = null;
+                                        switch (op) {
+                                            case "+": val = left[1] + right[1]; break;
+                                            case "*": val = left[1] * right[1]; break;
+                                            case "/": val = left[1] / right[1]; break;
+                                            case "-": val = left[1] - right[1]; break;
+                                            case "<<": val = left[1] << right[1]; break;
+                                            case ">>": val = left[1] >> right[1]; break;
+                                            case ">>>": val = left[1] >>> right[1]; break;
+                                        }
+                                        if (val != null) {
+                                                best = best_of(best, [ typeof val == "string" ? "string" : "num", val ]);
+                                        }
+                                } else if (left[0] == "binary" && left[1] == "+" && left[3][0] == "string") {
+                                        best = best_of(best, [ "binary", "+", left[2], [ "string", left[3][1] + right[1] ] ]);
                                 }
                         }
                         return best;
@@ -812,6 +983,16 @@ function ast_squeeze(ast, options) {
                                 c != null ? [ c[0], tighten(c[1].map(walk)) ] : null,
                                 f != null ? tighten(f.map(walk)) : null
                         ];
+                },
+                "unary-prefix": function(op, cond) {
+                        if (op == "!")
+                                return best_of(this, negate(cond));
+                },
+                "call": function(expr, args) {
+                        if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+                                // foo.toString()  ==>  foo+""
+                                return [ "binary", "+", expr[1], [ "string", "" ]];
+                        }
                 }
         }, function() {
                 return walk(ast);
@@ -1005,7 +1186,7 @@ function gen_code(ast, beautify) {
                 "assign": function(op, lvalue, rvalue) {
                         if (op && op !== true) op += "=";
                         else op = "=";
-                        return add_spaces([ make(lvalue), op, make(rvalue) ]);
+                        return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]);
                 },
                 "dot": function(expr) {
                         var out = make(expr), i = 1;
@@ -1193,6 +1374,10 @@ function gen_code(ast, beautify) {
         };
 
         function make_name(name) {
+                switch (name) {
+                    case "true": return beautify ? "true" : "!0";
+                    case "false": return beautify ? "false" : "!1";
+                }
                 return name.toString();
         };
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: uglifier
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Ville Lautanala
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-03 00:00:00 +02:00
+date: 2010-11-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -197,6 +197,7 @@ files:
 - lib/uglifier.rb
 - spec/spec_helper.rb
 - spec/uglifier_spec.rb
+- uglifier.gemspec
 - vendor/uglifyjs/lib/parse-js.js
 - vendor/uglifyjs/lib/process.js
 has_rdoc: true