uglifier 2.7.1 → 3.0.1

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)
+    map = SourceMap::Map.from_json(map2)
     expect(map.sources).to eq(["http://localhost/ahoy.js"])
-    expect(map.mappings.first[:source_line]).to eq(1)
-    expect(map.mappings.last[:source_line]).to eq(6)
+    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

@@ -19,7 +19,7 @@ describe "Uglifier" do
   end
 
   it "doesn't omit null character in strings" do
-    expect(Uglifier.new.compile('var foo="\0bar"')).to include("\\x00bar")
+    expect(Uglifier.new.compile('var foo="\0bar"')).to include("\\0bar")
   end
 
   it "adds trailing semicolon to minified source" do
@@ -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
 
@@ -145,8 +180,8 @@ describe "Uglifier" do
 
   it "honors max line length" do
     code = "var foo = 123;function bar() { return foo; }"
-    uglifier = Uglifier.new(:output => { :max_line_len => 16 }, :compress => false)
-    expect(uglifier.compile(code).split("\n").length).to eq(2)
+    uglifier = Uglifier.new(:output => { :max_line_len => 20 }, :compress => false)
+    expect(uglifier.compile(code).split("\n").map(&:length)).to all(be < 28)
   end
 
   it "hoists vars to top of the scope" do
@@ -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,14 +293,33 @@ 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
-    expect(Uglifier.compile(code, :mangle => false)).not_to include("c)")
+    JS
+
+    options = lambda do |keep_fargs|
+      {
+        :mangle => false,
+        :compress => {
+          :keep_fargs => keep_fargs,
+          :unsafe => true
+        }
+      }
+    end
+
+    expect(Uglifier.compile(code, options.call(false))).not_to include("c)")
+    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_fargs => true })
-    expect(keep_fargs).to include("c)")
+    keep_fargs = Uglifier.compile(code, :mangle => false, :compress => { :keep_fnames => true })
+    expect(keep_fargs).to include("plus")
   end
 
   describe "Input Formats" do

data/uglifier.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.description = "Uglifier minifies JavaScript files by wrapping UglifyJS to be accessible in Ruby"
   spec.license = "MIT"
 
-  spec.required_ruby_version = '>= 1.8.7'
+  spec.required_ruby_version = '>= 1.9.3'
 
   spec.extra_rdoc_files = [
     "LICENSE.txt",
@@ -25,11 +25,9 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "execjs", ">= 0.3.0"
-  spec.add_runtime_dependency "json", ">= 1.8.0"
+  spec.add_runtime_dependency "execjs", [">= 0.3.0", "< 3"]
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rake", "~> 10.4"
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rdoc", ">= 3.11"
-  spec.add_development_dependency "source_map", ">= 0"
+  spec.add_development_dependency "sourcemap", "~> 0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uglifier
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 3.0.1
 platform: ruby
 authors:
 - Ville Lautanala
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-27 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: execjs
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,20 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.8.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,33 +73,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.11'
-- !ruby/object:Gem::Dependency
-  name: source_map
+  name: sourcemap
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
 description: Uglifier minifies JavaScript files by wrapping UglifyJS to be accessible
   in Ruby
 email:
@@ -126,6 +104,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -136,7 +115,9 @@ files:
 - gemfiles/rubyracer
 - gemfiles/rubyrhino
 - lib/es5.js
+- lib/source-map.js
 - lib/split.js
+- lib/uglifier.js
 - lib/uglifier.rb
 - lib/uglifier/version.rb
 - lib/uglify.js
@@ -156,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -164,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for UglifyJS JavaScript compressor