uglifier 2.7.2 → 3.0.0

data/spec/source_map_spec.rb

@@ -2,6 +2,12 @@
 require 'stringio'
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
+def expect_to_have_inline_source_map(minified, original)
+  options = { :source_map => { :sources_content => true } }
+  _, map = Uglifier.compile_with_map(minified, options)
+  expect(JSON.load(map).fetch("sourcesContent", [])).to include(original)
+end
+
 describe "Uglifier" do
   let(:source) do
     <<-JS
@@ -24,20 +30,24 @@ describe "Uglifier" do
   end
 
   it "generates source maps with the correct meta-data" do
-    _, map = Uglifier.compile_with_map(source,
-                                       :source_filename => "ahoy.js",
-                                       :output_filename => "ahoy.min.js",
-                                       :source_root => "http://localhost/")
+    _, json = Uglifier.compile_with_map(
+      source,
+      :source_map => {
+        :filename => "ahoy.js",
+        :output_filename => "ahoy.min.js",
+        :root => "http://localhost/"
+      }
+    )
 
-    map = SourceMap.from_s(map)
-    expect(map.file).to eq("ahoy.min.js")
+    map = SourceMap::Map.from_json(json)
+    expect(map.filename).to eq("ahoy.min.js")
     expect(map.sources).to eq(["ahoy.js"])
     expect(map.names).to eq(%w(hello world))
-    expect(map.source_root).to eq("http://localhost/")
-    expect(map.mappings.first[:generated_line]).to eq(1)
+    expect(JSON.load(json)["sourceRoot"]).to eq("http://localhost/")
+    expect(map[0].generated.line).to eq(1)
   end
 
-  it "should skip copyright lines in source maps" do
+  it "skips copyright lines in source maps" do
     source = <<-JS
       /* @copyright Conrad Irwin */
       function hello () {
@@ -49,14 +59,19 @@ describe "Uglifier" do
       };
     JS
 
-    _, map = Uglifier.compile_with_map(source,
-                                       :source_filename => "ahoy.js",
-                                       :source_root => "http://localhost/")
-    map = SourceMap.from_s(map)
-    expect(map.mappings.first[:generated_line]).to eq(2)
+    _, json = Uglifier.compile_with_map(
+      source,
+      :source_map => {
+        :filename => "ahoy.js",
+        :root => "http://localhost/"
+      }
+    )
+
+    map = SourceMap::Map.from_json(json)
+    expect(map[0].generated.line).to eq(2)
   end
 
-  it "should be able to handle an input source map" do
+  it "proceses an input source map" do
     source = <<-JS
       function hello () {
         function world () {
@@ -69,42 +84,143 @@ describe "Uglifier" do
 
     minified1, map1 = Uglifier.compile_with_map(
       source,
-      :source_filename => "ahoy.js",
-      :source_root => "http://localhost/",
+      :source_map => {
+        :filename => "ahoy.js",
+        :root => "http://localhost/"
+      },
       :mangle => false
     )
 
-    _, map2 = Uglifier.compile_with_map(source,
-                                        :input_source_map => map1,
-                                        :mangle => true)
+    _, map2 = Uglifier.compile_with_map(
+      source,
+      :source_map => {
+        :input_source_map => map1
+      },
+      :mangle => true
+    )
 
     expect(minified1.lines.to_a.length).to eq(1)
 
-    map = SourceMap.from_s(map2)
-    expect(map.sources).to eq(["ahoy.js", "http://localhost/ahoy.js"])
-    expect(map.mappings.first[:source_line]).to eq(1)
-    expect(map.mappings.last[:source_line]).to eq(6)
+    map = SourceMap::Map.from_json(map2)
+    expect(map.sources).to eq(["http://localhost/ahoy.js"])
+    expect(map[0].generated.line).to eq(1)
+    expect(map[-1].original.line).to eq(1)
+  end
+
+  it "handles empty string as input map sourceRoot" do
+    _, map1 = Uglifier.compile_with_map(
+      source,
+      :source_map => {
+        :filename => "ahoy.js",
+        :root => ""
+      },
+      :mangle => false
+    )
+
+    _, map = Uglifier.compile_with_map(
+      source,
+      :source_map => {
+        :input_source_map => map1
+      },
+      :mangle => true
+    )
+
+    expect(SourceMap::Map.from_json(map).sources).to eq(["ahoy.js"])
   end
 
-  it "appens source map url" do
-    minified, _ = Uglifier.compile_with_map(
+  it "appends source map url to minified JS" do
+    minified, = Uglifier.compile_with_map(
       source,
-      :source_filename => "ahoy.js",
-      :output_filename => "ahoy.min.js",
-      :source_root => "http://localhost/",
-      :source_map_url => "http://example.com/map"
+      :source_map => {
+        :filename => "ahoy.js",
+        :output_filename => "ahoy.min.js",
+        :root => "http://localhost/",
+        :map_url => "http://example.com/map"
+      }
     )
     expect(minified).to include("\n//# sourceMappingURL=http://example.com/map")
   end
 
-  it "appens source url" do
-    minified, _ = Uglifier.compile_with_map(
+  it "appends source url to minified JS" do
+    minified, = Uglifier.compile_with_map(
       source,
-      :source_filename => "ahoy.js",
-      :output_filename => "ahoy.min.js",
-      :source_root => "http://localhost/",
-      :source_url => "http://example.com/source"
+      :source_map => {
+        :filename => "ahoy.js",
+        :output_filename => "ahoy.min.js",
+        :root => "http://localhost/",
+        :url => "http://example.com/source"
+      }
     )
     expect(minified).to include("\n//# sourceURL=http://example.com/source")
   end
+
+  it "inlines source map" do
+    minified = Uglifier.compile(
+      source,
+      :source_map => {
+        :filename => "ahoy.js",
+        :output_filename => "ahoy.min.js",
+        :root => "http://localhost/",
+        :url => "http://example.com/source"
+      }
+    )
+    source_map_mime = "application/json;charset=utf-8;base64,"
+    expect(minified).to include("\n//# sourceMappingURL=data:#{source_map_mime}")
+  end
+
+  describe "inline source map parsing" do
+    let(:minified) do
+      Uglifier.compile(
+        source,
+        :source_map => {
+          :filename => "ahoy.js",
+          :sources_content => true
+        }
+      )
+    end
+
+    let(:code) { minified.split("\n")[0] }
+    let(:source_mapping_url) { minified.split("\n")[1][2..-1] }
+
+    it "parses inline source maps from line comments" do
+      minified = "#{code}\n//#{source_mapping_url}"
+      expect_to_have_inline_source_map(minified, source)
+    end
+
+    it "parses inline source maps with block comments" do
+      minified = "#{code}\n/*#{source_mapping_url}*/"
+      expect_to_have_inline_source_map(minified, source)
+    end
+
+    it "parses inline source maps with multi-line block comments" do
+      minified = "#{code}\n/*\n#{source_mapping_url}\n*/"
+      expect_to_have_inline_source_map(minified, source)
+    end
+
+    it "parses inline source maps from mixed comments" do
+      minified = "#{code}\n/*\n//#{source_mapping_url}\n*/"
+      expect_to_have_inline_source_map(minified, source)
+    end
+
+    it "only parses source maps at end of file" do
+      minified = "#{code}\n//#{source_mapping_url}\nhello();"
+      _, map = Uglifier.compile_with_map(minified)
+      expect(JSON.load(map)["sourcesContent"]).to be_nil
+    end
+
+    it "handles other source map declarations at end of file" do
+      minified = "#{code}\n
+        //#{source_mapping_url}\n
+        //# sourceURL=http://example.com/source.js
+        //# sourceURL=http://example.com/source.js
+      "
+      expect_to_have_inline_source_map(minified, source)
+    end
+
+    it "does not explode when data URI is invalid" do
+      minified = "#{code}\n//# sourceMappingURL=data:application/javascript,foobar"
+      _, map = Uglifier.compile_with_map(minified)
+      expect(JSON.load(map)["sourcesContent"]).to be_nil
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,14 +1,14 @@
 # encoding: UTF-8
 require 'uglifier'
 require 'rspec'
-require 'source_map'
+require 'sourcemap'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 if ENV["ALASKA"]
-  require 'alaska'
+  require 'alaska/runtime'
   require 'tempfile'
   ExecJS.runtime = Alaska::Runtime.new
 end
@@ -20,4 +20,13 @@ RSpec.configure do |config|
   config.expect_with :rspec do |expect|
     expect.syntax = :expect
   end
+
+  if ENV['CI']
+    config.before(:example, :focus) { raise "Do not commit focused specs" }
+  else
+    config.filter_run_including :focus => true
+    config.run_all_when_everything_filtered = true
+  end
+
+  config.warnings = true
 end

data/spec/uglifier_spec.rb

@@ -27,6 +27,33 @@ describe "Uglifier" do
     expect(Uglifier.new.compile(source)[-1]).to eql(";"[0])
   end
 
+  describe "property name mangling" do
+    let(:source) do
+      <<-JS
+        var obj = {
+          _hidden: false,
+          name: 'value'
+        };
+
+        alert(object.name);
+      JS
+    end
+
+    it "does not mangle property names by default" do
+      expect(Uglifier.compile(source)).to include("object.name")
+    end
+
+    it "can be configured to mangle properties" do
+      expect(Uglifier.compile(source, :mangle_properties => true))
+        .not_to include("object.name")
+    end
+
+    it "can configure a regex for mangling" do
+      expect(Uglifier.compile(source, :mangle_properties => { :regex => /^_/ }))
+        .to include("object.name")
+    end
+  end
+
   describe "argument name mangling" do
     it "doesn't try to mangle $super by default to avoid breaking PrototypeJS" do
       expect(Uglifier.compile('function foo($super) {return $super}')).to include("$super")
@@ -34,7 +61,8 @@ describe "Uglifier" do
 
     it "allows variables to be excluded from mangling" do
       code = "function bar(foo) {return foo + 'bar'};"
-      expect(Uglifier.compile(code, :mangle => { :except => ["foo"] })).to include("(foo)")
+      expect(Uglifier.compile(code, :mangle => { :except => ["foo"] }))
+        .to include("(foo)")
     end
 
     it "skips mangling when set to false" do
@@ -42,21 +70,28 @@ describe "Uglifier" do
       expect(Uglifier.compile(code, :mangle => false)).to include("(foo)")
     end
 
-    it "mangles argumen names by default" do
+    it "mangles argument names by default" do
       code = "function bar(foo) {return foo + 'bar'};"
-      expect(Uglifier.compile(code, :mangle => true)).not_to include("(foo)")
+      expect(Uglifier.compile(code)).not_to include("(foo)")
     end
 
     it "mangles top-level names when explicitly instructed" do
       code = "function bar(foo) {return foo + 'bar'};"
-      expect(Uglifier.compile(code, :mangle => { :toplevel => false })).to include("bar(")
-      expect(Uglifier.compile(code, :mangle => { :toplevel => true })).not_to include("bar(")
+      expect(Uglifier.compile(code, :mangle => { :toplevel => false }))
+        .to include("bar(")
+      expect(Uglifier.compile(code, :mangle => { :toplevel => true }))
+        .not_to include("bar(")
+    end
+
+    it "can be controlled with mangle option" do
+      code = "function bar(foo) {return foo + 'bar'};"
+      expect(Uglifier.compile(code, :mangle => false)).to include("(foo)")
     end
   end
 
   describe "comment preservation" do
     let(:source) do
-      <<-EOS
+      <<-JS
         /* @preserve Copyright Notice */
         /* (c) 2011 */
         // INCLUDED
@@ -65,8 +100,8 @@ describe "Uglifier" do
         /* Another Copyright */
         /*! Another Bang */
         // A comment!
-        function add(a, b) { return a + b; }
-      EOS
+        function add(a, b) { return a + b; }
+      JS
     end
 
     it "handles copyright option" do
@@ -118,8 +153,8 @@ describe "Uglifier" do
       subject { Uglifier.compile(source, :comments => :none) }
 
       it "omits all comments" do
-        expect(subject).not_to match %r{//}
-        expect(subject).not_to match(/\/\*/)
+        expect(subject).not_to match(%r{//})
+        expect(subject).not_to match(%r{/\*})
       end
     end
 
@@ -155,10 +190,22 @@ describe "Uglifier" do
     expect(minified).to match(/var \w,\w/)
   end
 
-  it "forwards screw_ie8 option to UglifyJS" do
-    code = "function something() { return g['switch']; }"
-    expect(Uglifier.compile(code, :mangle => false, :screw_ie8 => true)).to match(/g\.switch/)
-    expect(Uglifier.compile(code, :compress => false, :screw_ie8 => true)).to match(/g\.switch/)
+  describe "screw_ie8 option" do
+    let(:code) { "function something() { return g['switch']; }" }
+
+    it "defaults to not screw IE8" do
+      expect(Uglifier.compile(code)).to match(".switch")
+    end
+
+    it "forwards screw_ie8 option to UglifyJS" do
+      expect(Uglifier.compile(code, :mangle => false, :screw_ie8 => true)).to match(/g\.switch/)
+      expect(Uglifier.compile(code, :compress => false, :screw_ie8 => true)).to match(/g\.switch/)
+    end
+
+    it "supports legacy ie_proof output option as opposite for screw_ie8" do
+      minified = Uglifier.compile(code, :output => { :ie_proof => true })
+      expect(minified).to include('["switch"]')
+    end
   end
 
   it "can be configured to output only ASCII" do
@@ -212,13 +259,33 @@ describe "Uglifier" do
     expect(compiled).not_to include("console")
   end
 
+  describe "collapse_vars option" do
+    let(:code) do
+      <<-JS
+        function a() {
+          var win = window;
+          return win.Handlebars;
+        }
+      JS
+    end
+
+    it "collapses vars when collapse_vars is enabled" do
+      compiled = Uglifier.compile(code, :compress => { :collapse_vars => true })
+      expect(compiled).to include("return window.Handlebars")
+    end
+
+    it "defaults to not collapsing variables" do
+      expect(Uglifier.compile(code)).not_to include("return window.Handlebars")
+    end
+  end
+
   it "processes @ngInject annotations" do
-    code = <<-EOF
+    code = <<-JS
     /**
      * @ngInject
      */
     var f = function(foo, bar) { return foo + bar};
-    EOF
+    JS
     with_angular = Uglifier.compile(code, :compress => { :angular => true })
     without_angular = Uglifier.compile(code, :compress => { :angular => false })
     expect(with_angular).to include("f.$inject")
@@ -226,10 +293,10 @@ describe "Uglifier" do
   end
 
   it "keeps unused function arguments when keep_fargs option is set" do
-    code = <<-EOF
+    code = <<-JS
     function plus(a, b, c) { return a + b};
     plus(1, 2);
-    EOF
+    JS
 
     options = lambda do |keep_fargs|
       {
@@ -245,6 +312,16 @@ describe "Uglifier" do
     expect(Uglifier.compile(code, options.call(true))).to include("c)")
   end
 
+  it "keeps function names in output when keep_fnames is set" do
+    code = <<-JS
+    (function plus(a, b) { return a + b})(1, 2);
+    JS
+    expect(Uglifier.compile(code, :compress => true)).not_to include("plus")
+
+    keep_fargs = Uglifier.compile(code, :mangle => false, :compress => { :keep_fnames => true })
+    expect(keep_fargs).to include("plus")
+  end
+
   describe "Input Formats" do
     let(:code) { "function hello() { return 'hello world'; }" }