yuicompressor 1.0

data/README

@@ -0,0 +1,155 @@
+YUICompressor
+=============
+
+YUICompressor is a Ruby module that may be used to create compressed versions
+of JavaScript and CSS code quickly and easily using the Yahoo User Interface
+(YUI) library compressor. The module is essentially a wrapper around the YUI
+Compressor (a Java library) that supports two different modes of operation:
+shell and native.
+
+In shell mode the YUI Compressor library executes in a separate process. Code
+is piped into and out of this process using the system shell. This approach
+yields good performance and is the default for MRI and other Ruby versions that
+are not able to execute Java code.
+
+In native mode the compressor is invoked in the same process as Ruby. This is
+only possible when using YUICompressor on JRuby. With this approach, compression
+speeds dramatically improve because the system does not incur the overhead of
+invoking a separate Java process for each compression.
+
+In any case YUICompressor will automatically detect the Ruby platform it is
+running on and choose the mode that will offer the best performance.
+
+The inspiration for this project is Sam Stephenson's yui-compressor gem. The
+goal of YUICompressor is to provide a more fluent interface, greater
+flexibility, and better performance than its predecessor.
+
+
+Installation
+------------
+
+Via RubyGems:
+
+    $ gem install yuicompressor
+
+From a local copy:
+
+    $ git clone git://github.com/mjijackson/yuicompressor.git
+    $ cd yuicompressor
+    $ rake package && rake install
+
+Usage
+-----
+
+The easiest way to compress JavaScript code using YUICompressor is to pass an IO
+or a string containing your code to YUICompressor.compress_js. Similarly, CSS
+code may similarly be compressed using YUICompressor.compress_css. Both methods
+may take a second parameter that is a Hash of options to use during compression.
+When compressing CSS, the following option is available:
+
+    :line_break     The maximum number of characters that may appear in a
+                    single line of compressed code. Defaults to no maximum
+                    length. If set to 0 each line will be the minimum length
+                    possible.
+
+When compressing JavaScript, these additional options are available:
+
+    :munge                  Should be +true+ if the compressor should shorten
+                            local variable names when possible. Defaults to
+                            +false+.
+    :preserve_semicolons    Should be +true+ if the compressor should preserve
+                            all semicolons in the code. Defaults to +false+.
+    :optimize               Should be +true+ if the compressor should enable all
+                            micro optimizations. Defaults to +true+.
+
+When running in shell mode (i.e. not on JRuby) a :java option may be used to
+specify the path to the Java binary. The default value is "java".
+
+Examples
+--------
+
+JavaScript compression:
+
+    require 'yuicompressor'
+    js = '(function () { var abc = {}; abc["key"] = "value"; })()'
+    YUICompressor.compress_js(js)
+     => "(function(){var abc={};abc.key=\"value\"})();"
+
+JavaScript compression with shortened local variable names (i.e. munging):
+
+    require 'yuicompressor'
+    js = '(function () { var abc = {}; abc["key"] = "value"; })()'
+    YUICompressor.compress_js(js, :munge => true)
+     => "(function(){var a={};a.key=\"value\"})();"
+
+CSS compression:
+
+    require 'yuicompressor'
+    css = <<'CODE'
+    div.main {
+      background-position: 0;
+    }
+    h1#title {
+      color: #FFFFFF;
+    }
+    CODE
+    YUICompressor.compress_css(css)
+     => "div.main{background-position:0 0;}h1#title{color:#FFF;}"
+
+CSS compression with every statement on a separate line:
+
+    require 'yuicompressor'
+    css = <<'CODE'
+    div.main {
+      background-position: 0;
+    }
+    h1#title {
+      color: #FFFFFF;
+    }
+    CODE
+    YUICompressor.compress_css(css, :line_break => 0)
+     => "div.main{background-position:0 0;}\nh1#title{color:#FFF;}"
+
+Including in another module:
+
+    require 'yuicompressor'
+
+    module MyJavaScriptCompressor
+      include YUICompressor
+
+      def compress(code)
+        compress_js(code)
+      end
+    end
+
+License
+-------
+
+Copyright 2010 Michael Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Credits
+-------
+
+The YUI Compressor library is copyright Yahoo! Inc. The jar file is included in
+the source distribution under the terms of the BSD license.
+
+Also, thanks to Charles Nutter (@headius) for helping me understand how to
+convert Ruby streams to Java and back when doing the JRuby module.

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rake/clean'
+require 'rake/testtask'
+
+task :default => :test
+
+# TESTS #######################################################################
+
+Rake::TestTask.new do |t|
+  t.libs += ['lib', 'test']
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+# DOCS ########################################################################
+
+desc "Generate API documentation"
+task :api => FileList['lib/**/*.rb'] do |t|
+  output_dir = ENV['OUTPUT_DIR'] || 'api'
+  rm_rf output_dir
+  sh((<<-SH).gsub(/[\s\n]+/, ' ').strip)
+  hanna
+    --op #{output_dir}
+    --promiscuous
+    --charset utf8
+    --fmt html
+    --inline-source
+    --line-numbers
+    --accessor option_accessor=RW
+    --main YUICompressor
+    --title 'YUICompressor API Documentation'
+    #{t.prerequisites.join(' ')}
+  SH
+end
+
+CLEAN.include 'api'
+
+# PACKAGING & INSTALLATION ####################################################
+
+if defined?(Gem)
+  $spec = eval("#{File.read('yuicompressor.gemspec')}")
+
+  directory 'dist'
+
+  def package(ext='')
+    "dist/#{$spec.name}-#{$spec.version}" + ext
+  end
+
+  file package('.gem') => %w< dist > + $spec.files do |f|
+    sh "gem build yuicompressor.gemspec"
+    mv File.basename(f.name), f.name
+  end
+
+  file package('.tar.gz') => %w< dist > + $spec.files do |f|
+    sh "git archive --format=tar HEAD | gzip > #{f.name}"
+  end
+
+  desc "Build packages"
+  task :package => %w< .gem .tar.gz >.map {|e| package(e) }
+
+  desc "Build and install as local gem"
+  task :install => package('.gem') do |t|
+    sh "gem install #{package('.gem')}"
+  end
+
+  desc "Upload gem to rubygems.org"
+  task :release => package('.gem') do |t|
+    sh "gem push #{package('.gem')}"
+  end
+end
+
+CLOBBER.include 'dist'

data/lib/yuicompressor/jruby.rb

@@ -0,0 +1,85 @@
+require 'java'
+
+module YUICompressor
+  # This module contains methods specific to the JRuby platform and is
+  # automatically used when JRuby is detected. It provides a significant
+  # increase in performance over the Shell module.
+  module JRuby
+
+    require JAR_FILE
+
+    import java.io.InputStreamReader
+    import java.io.OutputStreamWriter
+    import com.yahoo.platform.yui.compressor.JavaScriptCompressor
+    import com.yahoo.platform.yui.compressor.CssCompressor
+
+    class ErrorReporter #:nodoc:
+      def error(message, source_name, line, line_source, line_offset)
+        if line < 0
+          "\n[ERROR] %s" % message
+        else
+          "\n[ERROR] %s:%s:%s" % [line, line_offset, message]
+        end
+      end
+
+      def runtimeError(*args)
+        raise RuntimeError, 'Compression failed. %s' % error(*args)
+      end
+    end
+
+    # Returns the set of arguments that are needed to instantiate a compressor
+    # using the given +options+.
+    def command_arguments(options={})
+      args = [ options[:line_break] ? options[:line_break].to_i : -1 ]
+
+      if options[:type].to_s == 'js'
+        args << !! options[:munge]
+        args << false # verbose?
+        args << !! options[:preserve_semicolons]
+        args << ! options[:optimize] # disable optimizations?
+      end
+
+      args
+    end
+
+    # Compresses the given +stream_or_string+ of code using the given +options+.
+    # When using this method directly, at least the +:type+ option must be
+    # specified, and should be one of <tt>"css"</tt> or <tt>"js"</tt>. See
+    # YUICompressor#compress_css and YUICompressor#compress_js for details about
+    # which options are acceptable for each type of compressor.
+    #
+    # If a block is given, it will receive the IO output object. Otherwise the
+    # output will be returned as a string.
+    def compress(stream_or_string, options={})
+      raise ArgumentError, 'Option :type required' unless options.key?(:type)
+
+      stream = streamify(stream_or_string)
+      output = StringIO.new
+
+      reader = InputStreamReader.new(stream.to_inputstream)
+      writer = OutputStreamWriter.new(output.to_outputstream)
+
+      compressor = case options[:type].to_s
+      when 'js'
+        options = default_js_options.merge(options)
+        JavaScriptCompressor.new(reader, ErrorReporter.new)
+      when 'css'
+        options = default_css_options.merge(options)
+        CssCompressor.new(reader)
+      else
+        raise ArgumentError, 'Unknown resource type: %s' % options[:type]
+      end
+
+      compressor.compress(writer, *command_arguments(options))
+      writer.flush
+      output.rewind
+
+      if block_given?
+        yield output
+      else
+        output.read
+      end
+    end
+
+  end
+end

data/lib/yuicompressor/shell.rb

@@ -0,0 +1,82 @@
+begin
+  require 'open3'
+rescue LoadError
+  require 'win32/open3'
+end
+
+module YUICompressor
+  # This module contains methods that allow the YUI Compressor to be used by
+  # piping IO to a separate Java process via the system shell. It is used on all
+  # Ruby platforms except for JRuby.
+  module Shell
+
+    # Returns an array of flags that should be passed to the jar file on the
+    # command line for the given set of +options+.
+    def command_arguments(options={})
+      args = []
+      args.concat(['--type', options[:type].to_s]) if options[:type]
+      args.concat(['--line-break', options[:line_break].to_s]) if options[:line_break]
+
+      if options[:type].to_s == 'js'
+        args << '--nomunge' unless options[:munge]
+        args << '--preserve-semi' if options[:preserve_semicolons]
+        args << '--disable-optimizations' unless options[:optimize]
+      end
+
+      args
+    end
+
+    # Compresses the given +stream_or_string+ of code using the given +options+.
+    # When using this method directly, at least the +:type+ option must be
+    # specified, and should be one of <tt>"css"</tt> or <tt>"js"</tt>. See
+    # YUICompressor#compress_css and YUICompressor#compress_js for details about
+    # which options are acceptable for each type of compressor.
+    #
+    # In addition to the standard options, this method also accepts a
+    # <tt>:java</tt> option that can be used to specify the location of the Java
+    # binary. This option will default to using <tt>"java"</tt> unless otherwise
+    # specified.
+    #
+    # If a block is given, it will receive the IO output object. Otherwise the
+    # output will be returned as a string.
+    def compress(stream_or_string, options={})
+      raise ArgumentError, 'Option :type required' unless options.key?(:type)
+
+      stream = streamify(stream_or_string)
+
+      case options[:type].to_s
+      when 'js'
+        options = default_js_options.merge(options)
+      when 'css'
+        options = default_css_options.merge(options)
+      else
+        raise ArgumentError, 'Unknown resource type: %s' % options[:type]
+      end
+
+      command = [ options.delete(:java) || 'java', '-jar', JAR_FILE ]
+      command.concat(command_arguments(options))
+
+      Open3.popen3(command.join(' ')) do |input, output, stderr|
+        begin
+          while buffer = stream.read(4096)
+            input.write(buffer)
+          end
+
+          input.close
+
+          err = stderr.read
+          raise err unless err.empty?
+
+          if block_given?
+            yield output
+          else
+            output.read
+          end
+        rescue Exception => e
+          raise RuntimeError, 'Compression failed. %s' % e
+        end
+      end
+    end
+
+  end
+end

data/lib/yuicompressor.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+module YUICompressor
+
+  # The path to the YUI Compressor jar file.
+  JAR_FILE = File.expand_path('../yuicompressor-2.4.2.jar', __FILE__)
+
+  autoload :JRuby, 'yuicompressor/jruby'
+  autoload :Shell, 'yuicompressor/shell'
+
+  module_function
+
+  # Returns +true+ if the Ruby platform is JRuby.
+  def jruby?
+    !! (RUBY_PLATFORM =~ /java/)
+  end
+
+  # Compress the given CSS +stream_or_string+ using the given +options+.
+  # Options should be a Hash with any of the following keys:
+  #
+  # +:line_break+::   The maximum number of characters that may appear in a
+  #                   single line of compressed code. Defaults to no maximum
+  #                   length. If set to 0 each line will be the minimum length
+  #                   possible.
+  def compress_css(stream_or_string, options={}, &block)
+    compress(stream_or_string, options.merge(:type => 'css'), &block)
+  end
+
+  # Compress the given JavaScript +stream_or_string+ using the given +options+.
+  # Options should be a Hash with any of the following keys:
+  #
+  # +:line_break+::   The maximum number of characters that may appear in a
+  #                   single line of compressed code. Defaults to no maximum
+  #                   length. If set to 0 each line will be the minimum length
+  #                   possible.
+  # +:munge+::        Should be +true+ if the compressor should shorten local
+  #                   variable names when possible. Defaults to +false+.
+  # +:preserve_semicolons+::  Should be +true+ if the compressor should preserve
+  #                           all semicolons in the code. Defaults to +false+.
+  # +:optimize+::     Should be +true+ if the compressor should enable all
+  #                   micro optimizations. Defaults to +true+.
+  def compress_js(stream_or_string, options={}, &block)
+    compress(stream_or_string, options.merge(:type => 'js'), &block)
+  end
+
+  def default_css_options #:nodoc:
+    { :line_break => nil }
+  end
+
+  def default_js_options #:nodoc:
+    default_css_options.merge(
+      :munge => false,
+      :preserve_semicolons => false,
+      :optimize => true
+    )
+  end
+
+  def streamify(stream_or_string) #:nodoc:
+    if IO === stream_or_string || StringIO === stream_or_string
+      stream_or_string
+    elsif String === stream_or_string
+      StringIO.new(stream_or_string.to_s)
+    else
+      raise ArgumentError, 'Stream or string required'
+    end
+  end
+
+  # If we're on JRuby we can use the YUI Compressor Java classes directly. This
+  # gives a huge speed boost. Otherwise we need to make a system call to the
+  # Java interpreter and stream IO to/from the shell.
+  mod = jruby? ? JRuby : Shell
+
+  include mod
+
+  mod.instance_methods.each do |name|
+    module_function name
+  end
+
+end

data/test/css_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../helper', __FILE__)
+
+class CSSTest < Test::Unit::TestCase
+  FIXTURE = <<'CODE'
+.a-class {
+  background-color: red;
+  background-position: 0;
+}
+
+div#an-id { color: #FFFFFF; }
+CODE
+
+  def test_default_command_arguments
+    args = command_arguments(default_css_options)
+
+    if jruby?
+      assert_equal([-1], args)
+    else
+      assert_equal(%w< --charset utf-8 >, args)
+    end
+  end
+
+  def test_command_arguments
+    if jruby?
+      args = command_arguments(:type => 'css')
+      assert_equal([-1], args)
+
+      args = command_arguments(:type => 'css', :line_break => 80)
+      assert_equal([80], args)
+
+      args = command_arguments(:type => 'css', :non_existent => true)
+      assert_equal([-1], args)
+    else
+      args = command_arguments(:type => 'css')
+      assert_equal(%w< --type css >, args)
+
+      args = command_arguments(:type => 'css', :line_break => 80)
+      assert_equal(%w< --type css --line-break 80 >, args)
+
+      args = command_arguments(:type => 'css', :non_existent => true)
+      assert_equal(%w< --type css >, args)
+    end
+  end
+
+  def test_default_options
+    assert_equal (<<'CODE').chomp, compress_css(FIXTURE)
+.a-class{background-color:red;background-position:0 0;}div#an-id{color:#FFF;}
+CODE
+  end
+
+  def test_line_break_option
+    assert_equal (<<'CODE').chomp, compress_css(FIXTURE, :line_break => 0)
+.a-class{background-color:red;background-position:0 0;}
+div#an-id{color:#FFF;}
+CODE
+  end
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'test/unit'
+require 'yuicompressor'
+
+class Test::Unit::TestCase
+  include YUICompressor
+end

data/test/js_test.rb

@@ -0,0 +1,99 @@
+require File.expand_path('../helper', __FILE__)
+
+class JSTest < Test::Unit::TestCase
+  FIXTURE = <<'CODE'
+// here's a comment
+var Foo = { "a": 1 };
+Foo["bar"] = (function(baz) {
+  /* here's a
+     multiline comment */
+  if (false) {
+    doSomething();
+  } else {
+    for (var index = 0; index < baz.length; index++) {
+      doSomething(baz[index]);
+    }
+  }
+})("hello");
+CODE
+
+  def test_default_command_arguments
+    if jruby?
+      args = command_arguments(default_js_options)
+      assert_equal([-1], args)
+    else
+      args = command_arguments(default_js_options)
+      assert_equal(%w< --charset utf-8 >, args)
+    end
+  end
+
+  def test_command_arguments
+    if jruby?
+      args = command_arguments(:type => 'js')
+      assert_equal([-1, false, false, false, true], args)
+
+      args = command_arguments(:type => 'js', :optimize => true)
+      assert_equal([-1, false, false, false, false], args)
+
+      args = command_arguments(:type => 'js', :munge => true)
+      assert_equal([-1, true, false, false, true], args)
+
+      args = command_arguments(:type => 'js', :non_existent => true)
+      assert_equal([-1, false, false, false, true], args)
+    else
+      args = command_arguments(:type => 'js')
+      assert_equal(%w< --type js --nomunge --disable-optimizations >, args)
+
+      args = command_arguments(:type => 'js', :optimize => true)
+      assert_equal(%w< --type js --nomunge >, args)
+
+      args = command_arguments(:type => 'js', :munge => true)
+      assert_equal(%w< --type js --disable-optimizations >, args)
+
+      args = command_arguments(:type => 'js', :non_existent => true)
+      assert_equal(%w< --type js --nomunge --disable-optimizations >, args)
+    end
+  end
+
+  def test_default_options
+    assert_equal (<<'CODE').chomp, compress_js(FIXTURE)
+var Foo={a:1};Foo.bar=(function(baz){if(false){doSomething()}else{for(var index=0;index<baz.length;index++){doSomething(baz[index])}}})("hello");
+CODE
+  end
+
+  def test_line_break_option
+    assert_equal (<<'CODE').chomp, compress_js(FIXTURE, :line_break => 0)
+var Foo={a:1};
+Foo.bar=(function(baz){if(false){doSomething()
+}else{for(var index=0;
+index<baz.length;
+index++){doSomething(baz[index])
+}}})("hello");
+CODE
+  end
+
+  def test_munge_option
+    assert_equal (<<'CODE').chomp, compress_js(FIXTURE, :munge => true)
+var Foo={a:1};Foo.bar=(function(b){if(false){doSomething()}else{for(var a=0;a<b.length;a++){doSomething(b[a])}}})("hello");
+CODE
+  end
+
+  def test_optimize_option
+    assert_equal (<<'CODE').chomp, compress_js(FIXTURE, :optimize => false)
+var Foo={"a":1};Foo["bar"]=(function(baz){if(false){doSomething()}else{for(var index=0;index<baz.length;index++){doSomething(baz[index])}}})("hello");
+CODE
+  end
+
+  def test_preserve_semicolons_option
+    assert_equal (<<'CODE').chomp, compress_js(FIXTURE, :preserve_semicolons => true)
+var Foo={a:1};Foo.bar=(function(baz){if(false){doSomething();}else{for(var index=0;index<baz.length;index++){doSomething(baz[index]);}}})("hello");
+CODE
+  end
+
+  def test_errors
+    assert_raise RuntimeError do
+      # Should trigger a compilation error.
+      compress_js('var a = function(){;')
+    end
+  end
+end

data/yuicompressor.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name = 'yuicompressor'
+  s.version = '1.0'
+  s.date = '2010-08-02'
+
+  s.summary = 'A YUI JavaScript and CSS compressor for Ruby and JRuby'
+  s.description = 'A YUI JavaScript and CSS compressor for Ruby and JRuby'
+
+  s.author = 'Michael Jackson'
+  s.email = 'mjijackson@gmail.com'
+
+  s.require_paths = %w< lib >
+
+  s.files = Dir['lib/**/*.rb'] +
+    Dir['test/*.rb'] +
+    %w< yuicompressor.gemspec Rakefile README >
+
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/ }
+
+  s.add_development_dependency('rake')
+
+  s.has_rdoc = true
+  s.rdoc_options = %w< --line-numbers --inline-source --title YUICompressor --main YUICompressor >
+  s.extra_rdoc_files = %w< README >
+
+  s.homepage = 'http://github.com/mjijackson/yuicompressor'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: yuicompressor
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Michael Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-02 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: A YUI JavaScript and CSS compressor for Ruby and JRuby
+email: mjijackson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/yuicompressor/jruby.rb
+- lib/yuicompressor/shell.rb
+- lib/yuicompressor.rb
+- test/css_test.rb
+- test/helper.rb
+- test/js_test.rb
+- yuicompressor.gemspec
+- Rakefile
+- README
+has_rdoc: true
+homepage: http://github.com/mjijackson/yuicompressor
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- YUICompressor
+- --main
+- YUICompressor
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A YUI JavaScript and CSS compressor for Ruby and JRuby
+test_files: 
+- test/css_test.rb
+- test/js_test.rb