uglifier 1.3.0 → 4.2.0

data/README.md

@@ -1,6 +1,45 @@
-# Uglifier  [![Build Status](https://secure.travis-ci.org/lautis/uglifier.png?branch=master)](http://travis-ci.org/lautis/uglifier) [![Dependency Status](https://gemnasium.com/lautis/uglifier.png?travis)](https://gemnasium.com/lautis/uglifier)
+# Uglifier
 
-Ruby wrapper for [UglifyJS](https://github.com/mishoo/UglifyJS) JavaScript compressor.
+Ruby wrapper for [UglifyJS](https://github.com/mishoo/UglifyJS2) JavaScript
+compressor.
+
+UglifyJS currently is extensively tested with ES5, but also includes experimental ES6/ES2015+/Harmony support.
+
+More stable alternatives for working with ES6 code is to first transpile to ES5 with e.g. [babel-transpiler](https://github.com/babel/ruby-babel-transpiler) or using [Closure Compiler](https://github.com/documentcloud/closure-compiler) to directly minify ES6 code.
+
+[![Build Status](https://travis-ci.org/lautis/uglifier.svg?branch=master)](https://travis-ci.org/lautis/uglifier)
+
+## ES6 / ES2015+ / Harmony mode
+
+When using Uglifier with ES6 syntax without any options, an error will be
+thrown.
+
+```
+Uglifier::Error: Unexpected token: punc ((). To use ES6 syntax, harmony mode must be enabled with Uglifier.new(:harmony => true).
+```
+
+The experimental ES6 syntax support can be enabled by passing `:harmony => true`
+option to Uglifier.
+
+```ruby
+Uglifier.compile(js, harmony: true)
+```
+
+### Rails
+
+When used in Rails, replace
+
+```ruby
+config.assets.js_compressor = :uglifier
+```
+
+with
+
+```ruby
+config.assets.js_compressor = Uglifier.new(harmony: true)
+```
+
+in `config/environments/production.rb`.
 
 ## Installation
 
@@ -8,71 +47,152 @@ Uglifier is available as a ruby gem.
 
     $ gem install uglifier
 
-Ensure that your environment has a JavaScript interpreter supported by [ExecJS](https://github.com/sstephenson/execjs). Installing `therubyracer` gem is a safe choice  and having `node` in `PATH` works too.
+Ensure that your environment has a JavaScript interpreter supported by
+[ExecJS](https://github.com/sstephenson/execjs). Using `therubyracer` gem
+is a safe choice if a runtime isn't already present. Note that while JScript built-in Windows 7 and older works, it is extremely slow.
 
 ## Usage
 
-    require 'uglifier'
-
-    Uglifier.new.compile(File.read("source.js"))
-    # => js file minified
+```ruby
+require 'uglifier'
 
-    # Or alternatively
-    Uglifier.compile(File.read("source.js"))
+Uglifier.new.compile(File.read("source.js"))
+# => js file minified
 
-When initializing UglifyJS, you can tune the behavior of UglifyJS by passing options. For example, if you want top-level variable names to be mangled:
+# Or alternatively
+Uglifier.compile(File.read("source.js"))
+```
 
-    Uglifier.new(:toplevel => true).compile(source)
+Uglifier also supports generating source maps:
 
-    # Or
-    Uglifier.compile(source, :toplevel => true)
+```ruby
+uglified, source_map = Uglifier.new.compile_with_map(source)
+```
 
-Available options and their defaults are
-
-    {
-      :mangle => true, # Mangle variable and function names, use :variables to skip function mangling
-      :toplevel => false, # Mangle top-level variable names
-      :except => [], # Variable names to be excluded from mangling
-      :max_line_length => 32 * 1024, # Maximum line length
-      :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)
-      :lift_vars => false, # Lift all var declarations at the start of the scope
-      :unsafe => false, # Optimizations known to be unsafe in some situations
-      :copyright => true, # Show copyright message
-      :ascii_only => false, # Encode non-ASCII characters as Unicode code points
-      :inline_script => false, # Escape </script
-      :quote_keys => false, # Quote keys in object literals
-      :define => {}, # Define values for symbol replacement
-      :beautify => false, # Ouput indented code
-      :beautify_options => {
-        :indent_level => 4,
-        :indent_start => 0,
-        :space_colon => false
-      }
-    }
+When initializing UglifyJS, you can tune the behavior of UglifyJS by passing options. For example, if you want disable variable name mangling:
 
-## Development
+```ruby
+Uglifier.new(:mangle => false).compile(source)
 
-Uglifier uses [stitch](https://github.com/sstephenson/stitch) to compile UglifyJs for non-node JS runtimes. If you need to update or patch UglifyJS, you can stitch UglifyJS using
+# Or
+Uglifier.compile(source, :mangle => false)
+```
 
-    node build.js
+Available options and their defaults are
 
-## Submitting an issue
+```ruby
+{
+  :output => {
+    :ascii_only => true,        # Escape non-ASCII characters
+    :comments => :copyright,    # Preserve comments (:all, :jsdoc, :copyright, :none, Regexp (see below))
+    :inline_script => false,    # Escape occurrences of </script in strings
+    :quote_keys => false,       # Quote keys in object literals
+    :max_line_len => 32 * 1024, # Maximum line length in minified code
+    :bracketize => false,       # Bracketize if, for, do, while or with statements, even if their body is a single statement
+    :semicolons => true,        # Separate statements with semicolons
+    :preserve_line => false,    # Preserve line numbers in outputs
+    :beautify => false,         # Beautify output
+    :indent_level => 4,         # Indent level in spaces
+    :indent_start => 0,         # Starting indent level
+    :width => 80,               # Specify line width when beautifier is used (only with beautifier)
+    :preamble => nil,           # Preamble for the generated JS file. Can be used to insert any code or comment.
+    :wrap_iife => false         # Wrap IIFEs in parenthesis. Note: this disables the negate_iife compression option.
+    :shebang => true            # Preserve shebang (#!) in preamble (shell scripts)
+    :quote_style => 0,          # Quote style, possible values :auto (default), :single, :double, :original
+    :keep_quoted_props => false # Keep quotes property names
+  },
+  :mangle => {
+    :eval => false,             # Mangle names when eval of when is used in scope
+    :reserved => ["$super"],    # Argument names to be excluded from mangling
+    :sort => false,             # Assign shorter names to most frequently used variables. Often results in bigger output after gzip.
+    :toplevel => false,         # Mangle names declared in the toplevel scope
+    :properties => false,       # Mangle property names
+    :keep_fnames => false       # Do not modify function names
+  },                            # Mangle variable and function names, set to false to skip mangling
+  :mangle_properties => {
+    :regex => nil,              # A regular expression to filter property names to be mangled
+    :ignore_quoted => false,    # Only mangle unquoted property names
+    :debug => false,            # Mangle names with the original name still present
+  }                             # Mangle property names, disabled by default
+  :compress => {
+    :sequences => true,         # Allow statements to be joined by commas
+    :properties => true,        # Rewrite property access using the dot notation
+    :dead_code => true,         # Remove unreachable code
+    :drop_debugger => true,     # Remove debugger; statements
+    :unsafe => false,           # Apply "unsafe" transformations
+    :unsafe_comps => false,     # Reverse < and <= to > and >= to allow improved compression. This might be unsafe when an at least one of two operands is an object with computed values due the use of methods like get, or valueOf. This could cause change in execution order after operands in the comparison are switching. Compression only works if both comparisons and unsafe_comps are both set to true.
+    :unsafe_math => false,      # Optimize numerical expressions like 2 * x * 3 into 6 * x, which may give imprecise floating point results.
+    :unsafe_proto => false,     # Optimize expressions like Array.prototype.slice.call(a) into [].slice.call(a)
+    :conditionals => true,      # Optimize for if-s and conditional expressions
+    :comparisons => true,       # Apply binary node optimizations for comparisons
+    :evaluate => true,          # Attempt to evaluate constant expressions
+    :booleans => true,          # Various optimizations to boolean contexts
+    :loops => true,             # Optimize loops when condition can be statically determined
+    :unused => true,            # Drop unreferenced functions and variables
+    :toplevel => false,         # Drop unreferenced top-level functions and variables
+    :top_retain => [],          # prevent specific toplevel functions and variables from `unused` removal
+    :hoist_funs => true,        # Hoist function declarations
+    :hoist_vars => false,       # Hoist var declarations
+    :if_return => true,         # Optimizations for if/return and if/continue
+    :join_vars => true,         # Join consecutive var statements
+    :collapse_vars => false,    # Collapse single-use var and const definitions when possible.
+    :reduce_funcs => false,     # Inline single-use functions as function expressions. Depends on reduce_vars.
+    :reduce_vars => false,      # Collapse variables assigned with and used as constant values.
+    :negate_iife => true,       # Negate immediately invoked function expressions to avoid extra parens
+    :pure_getters => false,     # Assume that object property access does not have any side-effects
+    :pure_funcs => nil,         # List of functions without side-effects. Can safely discard function calls when the result value is not used
+    :drop_console => false,     # Drop calls to console.* functions
+    :keep_fargs => false,       # Preserve unused function arguments
+    :keep_fnames => false,      # Do not drop names in function definitions
+    :passes => 1,               # Number of times to run compress. Raising the number of passes will increase compress time, but can produce slightly smaller code.
+    :keep_infinity => false,    # Prevent compression of Infinity to 1/0
+    :side_effects => true,      # Pass false to disable potentially dropping functions marked as "pure" using pure comment annotation. See UglifyJS documentation for details.
+    :switches => true,          # de-duplicate and remove unreachable switch branches
+  },                            # Apply transformations to code, set to false to skip
+  :parse => {
+    :bare_returns => false,     # Allow top-level return statements.
+    :expression => false,       # Parse a single expression, rather than a program (for parsing JSON).
+    :html5_comments => true,    # Ignore HTML5 comments in input
+    :shebang => true,           # support #!command as the first line
+    :strict => false
+  },
+  :define => {},                # Define values for symbol replacement
+  :enclose => false,            # Enclose in output function wrapper, define replacements as key-value pairs
+  :keep_fnames => false,        # Generate code safe for the poor souls relying on Function.prototype.name at run-time. Sets both compress and mangle keep_fanems to true.
+  :source_map => {
+    :map_url => false,          # Url for source mapping to be appended in minified source
+    :url => false,              # Url for original source to be appended in minified source
+    :sources_content => false,  # Include original source content in map
+    :filename => nil,           # The filename of the input file
+    :root => nil,               # The URL of the directory which contains :filename
+    :output_filename => nil,    # The filename or URL where the minified output can be found
+    :input_source_map => nil    # The contents of the source map describing the input
+  },
+  :error_context_lines => 8,    # How many context lines surrounding the error line. Env var ERROR_CONTEXT_LINES overrides this option
+  :harmony => false             # Enable ES6/Harmony mode (experimental). Disabling mangling and compressing is recommended with Harmony mode.
+}
+```
+
+When passing a regular expression to the output => comments option, be sure to pass a valid Ruby Regexp.
+The beginning and ending of comments are removed and cannot be matched (/*, */, //). For example:
+When matching
+
+```
+/*!
+ * comment
+ */
+```
+
+use `Uglifier.new(output: {comments: /^!/})`.
 
-Uglifier uses the [GitHub issue tracker](https://github.com/lautis/uglifier/issues) to track bugs and features. Before submitting a bug report or feature request, check to make sure it hasn't already been submitted. You can indicate support for an existing issuse by voting it up. When submitting a bug report, please include a Gist that includes a stack trace and any details that may be necessary to reproduce the bug, including your gem version, Ruby version, **MultiJSON engine** and **ExecJS runtime**. Ideally, a bug report should include a pull request with failing specs.
+## Development
 
-## Contributing to uglifier
+Tests are run using
 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+    bundle exec rake
 
+See [CONTRIBUTING](https://github.com/lautis/uglifier/blob/master/CONTRIBUTING.md) for details about working on and contributing to Uglifier.
 
 ## Copyright
 
-© Ville Lautanala, [Flowdock](https://flowdock.com/). Released under MIT license, see [LICENSE.txt](https://github.com/lautis/uglifier/blob/master/LICENSE.txt) for more details.
+© Ville Lautanala. Released under MIT license, see [LICENSE](https://github.com/lautis/uglifier/blob/master/LICENSE.txt) for details.

data/Rakefile

@@ -1,39 +1,137 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "uglifier"
-  gem.summary = %Q{Ruby wrapper for UglifyJS JavaScript compressor}
-  gem.email = "lautis@gmail.com"
-  gem.homepage = "http://github.com/lautis/uglifier"
-  gem.authors = ["Ville Lautanala"]
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rspec/core'
+# encoding: utf-8
+
+require 'fileutils'
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-task :default => :spec
+def version
+  ENV.fetch('VERSION')
+end
+
+HEADER = "## next"
+
+def changelog_tail
+  changelog = File.read("CHANGELOG.md")
+  if changelog.start_with?(HEADER)
+    changelog[HEADER.length + 2..-1]
+  else
+    "\n" + changelog
+  end
+end
+
+def compare_url(from, to)
+  "https://github.com/mishoo/UglifyJS2/compare/#{from}...#{to}"
+end
+
+def previous_version
+  match = File.read("CHANGELOG.md").scan(/- update UglifyJS to \[(.*)\]\(/)
+  match ? match[0][0].chomp : nil
+end
+
+def git_commit(files, message)
+  `git add #{files.join(' ')}`
+  `git commit -S -m "#{message.gsub('"', "\\\"")}"`
+end
+
+# rubocop:disable Metrics/BlockLength
+namespace :uglifyjs do
+  desc "Update UglifyJS source to version specified in VERSION environment variable"
+  task :update do
+    cd 'vendor/uglifyjs' do
+      `git fetch && git checkout v#{version}`
+    end
+  end
+
+  desc "Rebuild lib/uglify*.js"
+  task :build do
+    cd 'vendor/source-map/' do
+      `npm install --no-package-lock --no-save`
+    end
+
+    cd 'vendor/uglifyjs/' do
+      # required to run ./uglifyjs2 --self; not bundled.
+      `npm install --no-package-lock --no-save`
+    end
+
+    cd 'vendor/uglifyjs-harmony' do
+      # required to run ./uglifyjs2 --self; not bundled.
+      `npm install --no-package-lock --no-save`
+    end
+
+    FileUtils.cp("vendor/source-map/dist/source-map.js", "lib/source-map.js")
+
+    source = `./vendor/uglifyjs/bin/uglifyjs --self --comments /Copyright/`
+    File.write("lib/uglify.js", source)
+
+    harmony_source = `./vendor/uglifyjs-harmony/bin/uglifyjs --self --comments /Copyright/`
+    File.write("lib/uglify-harmony.js", harmony_source)
+
+    FileUtils.cp("vendor/split/split.js", "lib/split.js")
+    `patch -p1 -i patches/es5-string-split.patch`
+  end
+
+  desc "Add UglifyJS version bump to changelog"
+  task :changelog do
+    url = compare_url("v#{previous_version}", "v#{version}")
+    item = "- update UglifyJS to [#{version}](#{url})"
+    changelog = "#{HEADER}\n\n#{item}\n#{changelog_tail}"
+    File.write("CHANGELOG.md", changelog)
+  end
+
+  desc "Commit changes from UglifyJS version bump"
+  task :commit do
+    files = [
+      'CHANGELOG.md',
+      'lib/uglify.js',
+      'lib/uglify-harmony.js',
+      'vendor/uglifyjs',
+      'vendor/uglifyjs-harmony'
+    ]
+    git_commit(files, "Update UglifyJS to #{version}")
+  end
+end
+# rubocop:enable Metrics/BlockLength
+
+desc "Update UglifyJS to version specified in VERSION environment variable"
+task :uglifyjs => ['uglifyjs:update', 'uglifyjs:build', 'uglifyjs:changelog', 'uglifyjs:commit']
+
+namespace :version do
+  desc "Write version to CHANGELOG.md"
+  task :changelog do
+    content = File.read("CHANGELOG.md")
+    date = Time.now.strftime("%d %B %Y")
+    File.write("CHANGELOG.md", content.gsub("## next", "## #{version} (#{date})"))
+  end
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  desc "Write version to uglifier.rb"
+  task :ruby do
+    file = "lib/uglifier/version.rb"
+    content = File.read("lib/uglifier/version.rb")
+    File.write(file, content.gsub(/VERSION = "(.*)"/, "VERSION = \"#{version}\""))
+  end
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "uglifier #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  desc "Commit changes from Uglifier version bump"
+  task :commit do
+    files = ["CHANGELOG.md", "lib/uglifier/version.rb"]
+    git_commit(files, "Bump version to #{version}")
+  end
+
+  desc "Create git tag for version"
+  task :tag do
+    `git tag -s -m "Version #{version}" v#{version}`
+  end
+end
+
+desc "Update Uglifier to version specified in VERSION environment variable"
+task :version => ['version:changelog', 'version:ruby', 'version:commit', 'version:tag']
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new(:rubocop)
+  task :default => [:rubocop, :spec]
+rescue LoadError
+  task :default => [:spec]
 end

data/lib/es5.js

@@ -185,3 +185,137 @@ if (!Array.prototype.indexOf) {
         return -1;
     }
 }
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) {
+  Object.keys = (function () {
+    var hasOwnProperty = Object.prototype.hasOwnProperty,
+        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
+        dontEnums = [
+          'toString',
+          'toLocaleString',
+          'valueOf',
+          'hasOwnProperty',
+          'isPrototypeOf',
+          'propertyIsEnumerable',
+          'constructor'
+        ],
+        dontEnumsLength = dontEnums.length;
+
+    return function (obj) {
+      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');
+
+      var result = [];
+
+      for (var prop in obj) {
+        if (hasOwnProperty.call(obj, prop)) result.push(prop);
+      }
+
+      if (hasDontEnumBug) {
+        for (var i=0; i < dontEnumsLength; i++) {
+          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
+        }
+      }
+      return result;
+    }
+  })()
+};
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Object/create
+if (!Object.create) {
+    Object.create = function (o) {
+        if (arguments.length > 1) {
+            throw new Error('Object.create implementation only accepts the first parameter.');
+        }
+        function F() {}
+        F.prototype = o;
+        return new F();
+    };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Array/filter
+if (!Array.prototype.filter)
+{
+  Array.prototype.filter = function(fun /*, thisp*/)
+  {
+    "use strict";
+
+    if (this == null)
+      throw new TypeError();
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var res = [];
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++)
+    {
+      if (i in t)
+      {
+        var val = t[i]; // in case fun mutates this
+        if (fun.call(thisp, val, i, t))
+          res.push(val);
+      }
+    }
+
+    return res;
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Function/bind
+if (!Function.prototype.bind) {
+  Function.prototype.bind = function (oThis) {
+    if (typeof this !== "function") {
+      // closest thing possible to the ECMAScript 5 internal IsCallable function
+      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
+    }
+
+    var aArgs = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP = function () {},
+        fBound = function () {
+          return fToBind.apply(this instanceof fNOP && oThis
+                                 ? this
+                                 : oThis,
+                               aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Array/isArray
+if(!Array.isArray) {
+  Array.isArray = function (vArg) {
+    return Object.prototype.toString.call(vArg) === "[object Array]";
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/String/trim
+if(!String.prototype.trim) {
+  String.prototype.trim = function () {
+    return this.replace(/^\s+|\s+$/g,'');
+  };
+}
+
+
+function definePropertyWorks() {
+  try {
+    Object.defineProperty({}, "property", {});
+    return true;
+  } catch (exception) {
+    return false;
+  }
+}
+
+if (!definePropertyWorks()) {
+  Object.defineProperty = function defineProperty(object) {
+    // fail silently
+    return object;
+  }
+}