uglifier 2.2.1 → 2.7.2

data/spec/source_map_spec.rb

@@ -3,18 +3,8 @@ require 'stringio'
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Uglifier" do
-  it "generates source maps" do
-    source = File.open("lib/uglify.js", "r:UTF-8").read
-    minified, map = Uglifier.new.compile_with_map(source)
-    minified.length.should < source.length
-    map.length.should > 0
-    lambda {
-      JSON.parse(map)
-    }.should_not raise_error
-  end
-
-  it "generates source maps with the correct meta-data" do
-    source = <<-JS
+  let(:source) do
+    <<-JS
       function hello () {
         function world () {
           return 2;
@@ -23,18 +13,28 @@ describe "Uglifier" do
         return world() + world();
       };
     JS
+  end
+
+  it "generates source maps" do
+    source = File.open("lib/uglify.js", "r:UTF-8").read
+    minified, map = Uglifier.new.compile_with_map(source)
+    expect(minified.length).to be < source.length
+    expect(map.length).to be > 0
+    expect { JSON.parse(map) }.not_to raise_error
+  end
 
-    minified, map = Uglifier.compile_with_map(source,
-                                              :source_filename => "ahoy.js",
-                                              :output_filename => "ahoy.min.js",
-                                              :source_root => "http://localhost/")
+  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/")
 
     map = SourceMap.from_s(map)
-    map.file.should == "ahoy.min.js"
-    map.sources.should == ["ahoy.js"]
-    map.names.should == ["hello", "world"]
-    map.source_root.should == "http://localhost/"
-    map.mappings.first[:generated_line].should == 1
+    expect(map.file).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)
   end
 
   it "should skip copyright lines in source maps" do
@@ -49,11 +49,11 @@ describe "Uglifier" do
       };
     JS
 
-    minified, map = Uglifier.compile_with_map(source,
-                                              :source_filename => "ahoy.js",
-                                              :source_root => "http://localhost/")
+    _, map = Uglifier.compile_with_map(source,
+                                       :source_filename => "ahoy.js",
+                                       :source_root => "http://localhost/")
     map = SourceMap.from_s(map)
-    map.mappings.first[:generated_line].should == 2
+    expect(map.mappings.first[:generated_line]).to eq(2)
   end
 
   it "should be able to handle an input source map" do
@@ -67,20 +67,44 @@ describe "Uglifier" do
       };
     JS
 
-    minified1, map1 = Uglifier.compile_with_map(source,
-                                               :source_filename => "ahoy.js",
-                                               :source_root => "http://localhost/",
-                                               :mangle => false)
+    minified1, map1 = Uglifier.compile_with_map(
+      source,
+      :source_filename => "ahoy.js",
+      :source_root => "http://localhost/",
+      :mangle => false
+    )
 
-    minified2, map2 = Uglifier.compile_with_map(source,
-                                               :input_source_map => map1,
-                                               :mangle => true)
+    _, map2 = Uglifier.compile_with_map(source,
+                                        :input_source_map => map1,
+                                        :mangle => true)
 
-    minified1.lines.to_a.length.should == 1
+    expect(minified1.lines.to_a.length).to eq(1)
 
     map = SourceMap.from_s(map2)
-    map.sources.should == ["http://localhost/ahoy.js"]
-    map.mappings.first[:source_line].should == 1
-    map.mappings.last[:source_line].should == 6
+    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)
+  end
+
+  it "appens source map url" 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"
+    )
+    expect(minified).to include("\n//# sourceMappingURL=http://example.com/map")
+  end
+
+  it "appens source url" 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"
+    )
+    expect(minified).to include("\n//# sourceURL=http://example.com/source")
   end
 end

data/spec/spec_helper.rb

@@ -5,8 +5,19 @@ require 'source_map'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+if ENV["ALASKA"]
+  require 'alaska'
+  require 'tempfile'
+  ExecJS.runtime = Alaska::Runtime.new
+end
 
 RSpec.configure do |config|
-  
+  config.mock_with :rspec do |mock|
+    mock.syntax = :expect
+  end
+  config.expect_with :rspec do |expect|
+    expect.syntax = :expect
+  end
 end

data/spec/uglifier_spec.rb

@@ -6,93 +6,102 @@ describe "Uglifier" do
   it "minifies JS" do
     source = File.open("lib/uglify.js", "r:UTF-8").read
     minified = Uglifier.new.compile(source)
-    minified.length.should < source.length
-    lambda {
-      Uglifier.new.compile(minified)
-    }.should_not raise_error
+    expect(minified.length).to be < source.length
+    expect { Uglifier.new.compile(minified) }.not_to raise_error
   end
 
   it "throws an exception when compilation fails" do
-    expect {
-      Uglifier.new.compile(")(")
-    }.to raise_error(Uglifier::Error)
+    expect { Uglifier.new.compile(")(") }.to raise_error(Uglifier::Error)
   end
 
   it "throws an exception on invalid option" do
-    expect {
-      Uglifier.new(:foo => true)
-    }.to raise_error(ArgumentError)
+    expect { Uglifier.new(:foo => true) }.to raise_error(ArgumentError)
   end
 
   it "doesn't omit null character in strings" do
-    Uglifier.new.compile('var foo="\0bar"').should include("\\x00bar")
+    expect(Uglifier.new.compile('var foo="\0bar"')).to include("\\x00bar")
   end
 
   it "adds trailing semicolon to minified source" do
     source = "(function id(i) {return i;}());"
-    Uglifier.new.compile(source)[-1].should eql(";"[0])
+    expect(Uglifier.new.compile(source)[-1]).to eql(";"[0])
   end
 
   describe "argument name mangling" do
     it "doesn't try to mangle $super by default to avoid breaking PrototypeJS" do
-      Uglifier.compile('function foo($super) {return $super}').should include("$super")
+      expect(Uglifier.compile('function foo($super) {return $super}')).to include("$super")
     end
 
     it "allows variables to be excluded from mangling" do
       code = "function bar(foo) {return foo + 'bar'};"
-      Uglifier.compile(code, :mangle => {:except => ["foo"]}).should include("(foo)")
+      expect(Uglifier.compile(code, :mangle => { :except => ["foo"] })).to include("(foo)")
     end
 
     it "skips mangling when set to false" do
       code = "function bar(foo) {return foo + 'bar'};"
-      Uglifier.compile(code, :mangle => false).should include("(foo)")
+      expect(Uglifier.compile(code, :mangle => false)).to include("(foo)")
     end
 
     it "mangles argumen names by default" do
       code = "function bar(foo) {return foo + 'bar'};"
-      Uglifier.compile(code, :mangle => true).should_not include("(foo)")
+      expect(Uglifier.compile(code, :mangle => true)).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(")
     end
   end
 
   describe "comment preservation" do
-    let(:source) {
+    let(:source) do
       <<-EOS
         /* @preserve Copyright Notice */
         /* (c) 2011 */
         // INCLUDED
+        //! BANG
         function identity(p) { return p; }
         /* Another Copyright */
+        /*! Another Bang */
+        // A comment!
         function add(a, b) { return a + b; }
       EOS
-    }
+    end
 
     it "handles copyright option" do
       compiled = Uglifier.compile(source, :copyright => false)
-      compiled.should_not match /Copyright/
+      expect(compiled).not_to match(/Copyright/)
     end
 
     describe ":copyright" do
       subject { Uglifier.compile(source, :comments => :copyright) }
 
       it "preserves comments with string Copyright" do
-        subject.should match /Copyright Notice/
-        subject.should match /Another Copyright/
+        expect(subject).to match(/Copyright Notice/)
+        expect(subject).to match(/Another Copyright/)
+      end
+
+      it "preserves comments that start with a bang (!)" do
+        expect(subject).to match(/! BANG/)
+        expect(subject).to match(/! Another Bang/)
       end
 
       it "ignores other comments" do
-        subject.should_not match /INCLUDED/
+        expect(subject).not_to match(/INCLUDED/)
+        expect(subject).not_to match(/A comment!/)
       end
     end
 
     describe ":jsdoc" do
-      subject { Uglifier.compile(source, :output => {:comments => :jsdoc}) }
+      subject { Uglifier.compile(source, :output => { :comments => :jsdoc }) }
 
       it "preserves jsdoc license/preserve blocks" do
-        subject.should match /Copyright Notice/
+        expect(subject).to match(/Copyright Notice/)
       end
 
       it "ignores other comments" do
-        subject.should_not match /Another Copyright/
+        expect(subject).not_to match(/Another Copyright/)
       end
     end
 
@@ -100,8 +109,8 @@ describe "Uglifier" do
       subject { Uglifier.compile(source, :comments => :all) }
 
       it "preserves all comments" do
-        subject.should match /INCLUDED/
-        subject.should match /2011/
+        expect(subject).to match(/INCLUDED/)
+        expect(subject).to match(/2011/)
       end
     end
 
@@ -109,8 +118,8 @@ describe "Uglifier" do
       subject { Uglifier.compile(source, :comments => :none) }
 
       it "omits all comments" do
-        subject.should_not match /\/\//
-        subject.should_not match /\/\*/
+        expect(subject).not_to match %r{//}
+        expect(subject).not_to match(/\/\*/)
       end
     end
 
@@ -118,87 +127,133 @@ describe "Uglifier" do
       subject { Uglifier.compile(source, :comments => /included/i) }
 
       it "matches comment blocks with regex" do
-        subject.should match /INCLUDED/
+        expect(subject).to match(/INCLUDED/)
       end
 
       it "omits other blocks" do
-        subject.should_not match /2011/
+        expect(subject).not_to match(/2011/)
       end
     end
   end
 
   it "squeezes code only if squeeze is set to true" do
     code = "function a(a){if(a) { return 0; } else { return 1; }}"
-    Uglifier.compile(code, :squeeze => false).length.should > Uglifier.compile(code, :squeeze => true).length
+    minified = Uglifier.compile(code, :squeeze => false)
+    squeezed = Uglifier.compile(code, :squeeze => true)
+    expect(minified.length).to be > squeezed.length
   end
 
   it "honors max line length" do
     code = "var foo = 123;function bar() { return foo; }"
-    Uglifier.compile(code, :output => {:max_line_len => 16}, :compress => false).split("\n").length.should == 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
-    code = "function something() { var foo = 123; foo = 1234; var bar = 123456; return foo + bar}"
-    Uglifier.compile(code, :compress => {:hoist_vars => true}).should match /var \w,\w/
+    code = "function something() { var a = 1; a = 2; var b = 3; return a + b;}"
+    minified = Uglifier.compile(code, :compress => { :hoist_vars => true })
+    expect(minified).to match(/var \w,\w/)
   end
 
   it "forwards screw_ie8 option to UglifyJS" do
     code = "function something() { return g['switch']; }"
-    Uglifier.compile(code, :mangle => false, :screw_ie8 => true).should match /g\.switch/
-    Uglifier.compile(code, :compress => false, :screw_ie8 => true).should match /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/)
   end
 
   it "can be configured to output only ASCII" do
     code = "function emoji() { return '\\ud83c\\ude01'; }"
-    Uglifier.compile(code, :output => {:ascii_only => true}).should include("\\ud83c\\ude01")
+    minified = Uglifier.compile(code, :output => { :ascii_only => true })
+    expect(minified).to include("\\ud83c\\ude01")
   end
 
   it "escapes </script when asked to" do
     code = "function test() { return '</script>';}"
-    Uglifier.compile(code, :output => {:inline_script => true}).should_not include("</script>")
+    minified = Uglifier.compile(code, :output => { :inline_script => true })
+    expect(minified).not_to include("</script>")
   end
 
   it "quotes keys" do
     code = "var a = {foo: 1}"
-    Uglifier.compile(code, :output => {:quote_keys => true}).should include('"foo"')
+    minified = Uglifier.compile(code, :output => { :quote_keys => true })
+    expect(minified).to include('"foo"')
   end
 
   it "quotes unsafe keys by default" do
-    code = 'var code = {"class": ""}'
-    Uglifier.compile(code).should include('"class"')
+    code = 'var code = {"class": "", "\u200c":"A"}'
+    expect(Uglifier.compile(code)).to include('"class"')
+    expect(Uglifier.compile(code)).to include('"\u200c"')
+
+    uglifier = Uglifier.new(:output => { :ascii_only => false, :quote_keys => false })
+    expect(uglifier.compile(code)).to include(["200c".to_i(16)].pack("U*"))
   end
 
   it "handles constant definitions" do
-    code = "if (BOOLEAN) { var a = STRING; var b = NULL; var c = NUMBER; }"
-    defines = {"NUMBER" => 1234, "BOOLEAN" => true, "NULL" => nil, "STRING" => "str"}
+    code = "if (BOOL) { var a = STR; var b = NULL; var c = NUM; }"
+    defines = { "NUM" => 1234, "BOOL" => true, "NULL" => nil, "STR" => "str" }
     processed = Uglifier.compile(code, :define => defines)
-    processed.should include("a=\"str\"")
-    processed.should_not include("if")
-    processed.should include("b=null")
-    processed.should include("c=1234")
+    expect(processed).to include("a=\"str\"")
+    expect(processed).not_to include("if")
+    expect(processed).to include("b=null")
+    expect(processed).to include("c=1234")
   end
 
   it "can disable IIFE negation" do
     code = "(function() { console.log('test')})();"
-    disabled_negation = Uglifier.compile(code, :compress => {:negate_iife => false})
-    disabled_negation.should_not include("!")
-    negation = Uglifier.compile(code, :compress => {:negate_iife => true})
-    negation.should include("!")
+    disabled_negation = Uglifier.compile(code, :compress => { :negate_iife => false })
+    expect(disabled_negation).not_to include("!")
+    negation = Uglifier.compile(code, :compress => { :negate_iife => true })
+    expect(negation).to include("!")
+  end
+
+  it "can drop console logging" do
+    code = "(function() { console.log('test')})();"
+    compiled = Uglifier.compile(code, :compress => { :drop_console => true })
+    expect(compiled).not_to include("console")
+  end
+
+  it "processes @ngInject annotations" do
+    code = <<-EOF
+    /**
+     * @ngInject
+     */
+    var f = function(foo, bar) { return foo + bar};
+    EOF
+    with_angular = Uglifier.compile(code, :compress => { :angular => true })
+    without_angular = Uglifier.compile(code, :compress => { :angular => false })
+    expect(with_angular).to include("f.$inject")
+    expect(without_angular).not_to include("f.$inject")
+  end
+
+  it "keeps unused function arguments when keep_fargs option is set" do
+    code = <<-EOF
+    function plus(a, b, c) { return a + b};
+    plus(1, 2);
+    EOF
+
+    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
 
   describe "Input Formats" do
     let(:code) { "function hello() { return 'hello world'; }" }
 
     it "handles strings" do
-      lambda {
-        Uglifier.new.compile(code).should_not be_empty
-      }.should_not raise_error
+      expect(Uglifier.new.compile(code)).not_to be_empty
     end
 
     it "handles IO objects" do
-      lambda {
-        Uglifier.new.compile(StringIO.new(code)).should_not be_empty
-      }.should_not raise_error
+      expect(Uglifier.new.compile(StringIO.new(code))).not_to be_empty
     end
   end
 
@@ -206,18 +261,20 @@ describe "Uglifier" do
     let(:code) { "$.foo()" }
 
     it "encloses code with given arguments" do
-      Uglifier.compile(code, :enclose => {'window.jQuery' => '$'}).should match /window.jQuery/
+      minified = Uglifier.compile(code, :enclose => { 'window.jQuery' => '$' })
+      expect(minified).to match(/window.jQuery/)
     end
 
     it "handles multiple definitions" do
-      minified = Uglifier.compile(code, :enclose => [['lol','lulz'],['foo','bar']])
-      minified.should match(/lol,foo/)
-      minified.should match(/lulz,bar/)
+      definitions = [%w(lol lulz), %w(foo bar)]
+      minified = Uglifier.compile(code, :enclose => definitions)
+      expect(minified).to match(/lol,foo/)
+      expect(minified).to match(/lulz,bar/)
     end
 
     it "wraps with function when given empty object" do
       minified = Uglifier.compile(code, :enclose => {})
-      minified.should match(/function\(/)
+      expect(minified).to match(/function\(/)
     end
   end
 end

data/uglifier.gemspec

@@ -1,75 +1,35 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'uglifier/version'
 
-Gem::Specification.new do |s|
-  s.name = "uglifier"
-  s.version = "2.2.1"
+Gem::Specification.new do |spec|
+  spec.name = "uglifier"
+  spec.version = Uglifier::VERSION
+  spec.authors = ["Ville Lautanala"]
+  spec.email = ["lautis@gmail.com"]
+  spec.homepage = "http://github.com/lautis/uglifier"
+  spec.summary = "Ruby wrapper for UglifyJS JavaScript compressor"
+  spec.description = "Uglifier minifies JavaScript files by wrapping UglifyJS to be accessible in Ruby"
+  spec.license = "MIT"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ville Lautanala"]
-  s.date = "2013-08-28"
-  s.email = "lautis@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".gitmodules",
-    ".rspec",
-    ".travis.yml",
-    "CHANGELOG.md",
-    "CONTRIBUTING.md",
-    "Gemfile",
+  spec.required_ruby_version = '>= 1.8.7'
+
+  spec.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/es5.js",
-    "lib/split.js",
-    "lib/uglifier.rb",
-    "lib/uglify.js",
-    "spec/source_map_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/uglifier_spec.rb",
-    "uglifier.gemspec"
+    "CHANGELOG.md",
+    "CONTRIBUTING.md"
   ]
-  s.homepage = "http://github.com/lautis/uglifier"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
-  s.summary = "Ruby wrapper for UglifyJS JavaScript compressor"
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  spec.files = `git ls-files`.split($/)
+  spec.test_files = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<execjs>, [">= 0.3.0"])
-      s.add_runtime_dependency(%q<multi_json>, [">= 1.0.2", "~> 1.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.7"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_development_dependency(%q<rdoc>, [">= 3.11"])
-      s.add_development_dependency(%q<source_map>, [">= 0"])
-    else
-      s.add_dependency(%q<execjs>, [">= 0.3.0"])
-      s.add_dependency(%q<multi_json>, [">= 1.0.2", "~> 1.0"])
-      s.add_dependency(%q<rspec>, ["~> 2.7"])
-      s.add_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_dependency(%q<rdoc>, [">= 3.11"])
-      s.add_dependency(%q<source_map>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<execjs>, [">= 0.3.0"])
-    s.add_dependency(%q<multi_json>, [">= 1.0.2", "~> 1.0"])
-    s.add_dependency(%q<rspec>, ["~> 2.7"])
-    s.add_dependency(%q<bundler>, ["~> 1.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-    s.add_dependency(%q<rdoc>, [">= 3.11"])
-    s.add_dependency(%q<source_map>, [">= 0"])
-  end
+  spec.add_runtime_dependency "execjs", ">= 0.3.0"
+  spec.add_runtime_dependency "json", ">= 1.8.0"
+  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"
 end
-