cjohansen-juicer 0.2.0

data/lib/juicer/merger/javascript_merger.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+['base', 'javascript_dependency_resolver'].each do |lib|
+  require File.expand_path(File.join(File.dirname(__FILE__), lib))
+end
+
+module Juicer
+  module Merger
+    # Merge several files into one single output file. Resolves and adds in files from @depend comments
+    class JavaScriptMerger < Base
+
+      # Constructor
+      def initialize(files = [], options = {})
+        @dependency_resolver = JavaScriptDependencyResolver.new
+        super(files, options)
+      end
+    end
+  end
+end
+
+# Run file from command line
+# TODO: Refactor to testable Juicer::Merger::JavaScript::FileMerger.cli method
+# or similar.
+#
+if $0 == __FILE__
+  return puts("Usage: javascript_merger.rb file[...] output") if $*.length < 2
+
+  fm = JavaScriptMerger.new()
+  fm << $*[0..-2]
+  fm.save($*[-1])
+end

data/lib/juicer/merger/stylesheet_merger.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+['base', 'css_dependency_resolver'].each do |lib|
+  require File.expand_path(File.join(File.dirname(__FILE__), lib))
+end
+
+require 'pathname'
+
+module Juicer
+  module Merger
+    # Merge several files into one single output file. Resolves and adds in files
+    # from @import statements
+    #
+    class StylesheetMerger < Base
+
+      # Constructor
+      #
+      # Options:
+      # * <tt>:web_root</tt> - Path to web root if there is any @import statements
+      #   using absolute URLs
+      #
+      def initialize(files = [], options = {})
+        @dependency_resolver = CssDependencyResolver.new(options)
+        super(files, options)
+      end
+
+     private
+      def merge(file)
+        content = super.gsub(/^\s*\@import\s("|')(.*)("|')\;?/, '')
+      end
+    end
+  end
+end
+
+# Run file from command line
+#
+if $0 == __FILE__
+  return puts("Usage: stylesheet_merger.rb file[...] output") if $*.length < 2
+
+  fm = Juicer::Merger::StylesheetMerger.new()
+  fm << $*[0..-2]
+  fm.save($*[-1])
+end

data/lib/juicer/minifyer/compressor.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "chainable"))
+
+module Juicer
+  module Minifyer
+
+    # Juicer::Minifyer::Compressor defines an API for compressing CSS,
+    # JavaScript and others using either a third party compressor library, or by
+    # implementing compression routines in Ruby.
+    #
+    # The Compressor class itself is not able to do anything useful other than
+    # serving as a framework for concrete compressors to implement.
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no)
+    # Copyright:: Copyright (c) 2008-2009 Christian Johansen
+    # License::   MIT
+    #
+    class Compressor
+      include Chainable
+
+      # Initialize compressor with options
+      # options = Hash of options, optional
+      #
+      def initialize(options = {})
+        @options = default_options.merge(options)
+        @opt_set = false
+      end
+
+      # Perform compression, should be implemented in subclasses
+      # file = The file to compress
+      # output = Output file or open output stream. If nil the original file is
+      #          overwritten
+      # type = The type of file, js or css. If not provided this is guessed from
+      #        the input filename
+      #
+      def save(file, output = nil, type = nil)
+        msg = "Unable to call compress on abstract class Compressor"
+        raise NotImplementedError.new(msg)
+      end
+
+      # Return the value of a given option
+      # opt = The option to return value for
+      #
+      def get_opt(opt)
+        @options[opt] || nil
+      end
+
+      # Set an option. Important: you can only set options that are predefined by the
+      # implementing class
+      # opt = The option to set
+      # value = The value of the option
+      #
+      def set_opt(opt, value)
+        if @options.key?(opt)
+          @options[opt] = value
+          @opt_set = true
+        else
+          msg = 'Illegal option, specify one of: ' + @options.keys.join(', ')
+          raise ArgumentError.new(msg)
+        end
+      end
+
+      # Performs simple parsing of a string of parameters. All recognized
+      # parameters are set, non-existent arguments raise an ArgumentErrror
+      #
+      def set_opts(options)
+        options = options.split " "
+        option = nil
+        regex = /^--([^=]*)(=(.*))?/
+
+        while word = options.shift
+          if word =~ regex
+            if option
+              set_opt option, true
+            end
+
+            if $3
+              set_opt $1, $3
+            else
+              option = $1
+            end
+          else
+            set_opt option, word
+            option = nil
+          end
+        end
+      end
+
+      # Allows for options to be set and read directly on the object as though they were
+      # standard attributes. compressor.verbose translates to
+      # compressor.get_opt('verbose') and compressor.verbose = true to
+      # compressor.set_opt('verbose', true)
+      def method_missing(m, *args)
+        if @options.key?(m)
+          # Only hit method_missing once per option
+          self.class.send(:define_method, m) do
+            return get_opt(m)
+          end
+
+          return get_opt(m)
+        end
+
+        return super unless m.to_s =~ /=$/
+
+        opt = m.to_s.sub(/=$/, "").to_sym
+
+        if @options.key?(opt)
+          # Only hit method_missing once per option
+          self.class.send(:define_method, m) do
+            return set_opt(opt, args[0])
+          end
+
+          return set_opt(opt, args[0])
+        end
+
+        super
+      end
+
+     private
+      # May be overridden in subclasses. Provides default options
+      def default_options
+        {}
+      end
+    end
+  end
+end

data/lib/juicer/minifyer/yui_compressor.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require File.expand_path(File.join(File.dirname(__FILE__), 'compressor')) unless defined?(Juicer::Minifyer::Compressor)
+
+module Juicer
+  module Minifyer
+
+    # Provides an interface to the YUI compressor library using
+    # Juicer::Minify::Compressor. The YUI compressor library is implemented
+    # using Java, and as such Java is required when running this code. Also, the
+    # YUI jar file has to be provided.
+    #
+    # The YUI Compressor is invoked using the java binary and the YUI Compressor
+    # jar file.
+    #
+    # Providing the Jar file (usually yuicompressor-x.y.z.jar) can be done in
+    # several ways. The following directories are searched (in preferred order)
+    #
+    #  1. The directory specified by the option :bin_path
+    #  2. The directory specified by the environment variable $YUIC_HOME, if set
+    #  3. Current working directory
+    #
+    # For more information on how the Jar is located, see
+    # +Juicer::Minify::YuiCompressor.locate_jar+
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no)
+    # Copyright:: Copyright (c) 2008-2009 Christian Johansen
+    # License::   MIT
+    #
+    # = Usage example =
+    # yuic = Juicer::Minifyer::YuiCompressor.new({ :bin_path => '/home/user/java/yui/' })
+    # yuic.compress('lib.js', 'lib.compressed.js')
+    #
+    class YuiCompressor < Compressor
+      def initialize(options = {})
+        super
+        @jar = nil
+        @command = nil
+      end
+
+      # Compresses a file using the YUI Compressor. Note that the :bin_path
+      # option needs to be set in order for YuiCompressor to find and use the
+      # YUI jar file. Please refer to the class documentation for how to set
+      # this.
+      #
+      # file = The file to compress
+      # output = A file or stream to save the results to. If not provided the
+      #          original file will be overwritten
+      # type = Either :js or :css. If this parameter is not provided, the type
+      #        is guessed from the suffix on the input file name
+      def save(file, output = nil, type = nil)
+        type = type.nil? ? file.split('.')[-1].to_sym : type
+        cmd = @command = @command.nil? || @opt_set || type != @type ? command(type) : @command
+
+        output ||= file
+        use_tmp = !output.is_a?(String)
+        output = File.join(Dir::tmpdir, File.basename(file) + '.min.tmp.' + type.to_s) if use_tmp
+        FileUtils.mkdir_p(File.dirname(output))
+
+        cmd += ' -o "' + output + '" "' + file + '"'
+        compressor = IO.popen(cmd, 'r')
+        result = compressor.gets
+
+        if use_tmp                            # If no output file is provided, YUI compressor will
+          output.puts IO.read(output)         # compress to a temp file. This file should be cleared
+          File.delete(output)                 # out after we fetch its contents.
+        end
+      end
+
+      chain_method :save
+
+     private
+      # Constructs the command to use
+      def command(type)
+        @opt_set = false
+        @type = type
+        @jar = locate_jar unless @jar
+        raise 'Unable to locate YUI Compressor Jar' if @jar.nil?
+        cmd = "#{@options[:java]} -jar #{@jar} --type #{@type}"
+
+        @options.each do |k, v|
+          v = '' if v == true
+          v = " #{v}" unless v == '' || v.nil?
+          cmd += " --#{k.to_s.gsub('_', '-')}#{v}" unless v.nil? || [:bin_path, :java].include?(k)
+        end
+
+        return cmd
+      end
+
+      # Returns a map of options accepted by YUI Compressor, currently:
+      #
+      # :charset
+      # :line_break
+      # :no_munge (JavaScript only)
+      # :preserve_semi
+      # :preserve_strings
+      #
+      # In addition, some class level options may be set:
+      # :bin_path (defaults to Dir.cwd)
+      # :java     (Java command, defaults to 'java')
+      def default_options
+        { :charset => nil, :line_break => nil, :no_munge => nil,
+          :preserve_semi => nil, :preserve_strings => nil,
+          :bin_path => nil, :java => 'java' }
+      end
+
+      # Locates the Jar file by searching directories.
+      # The following directories are searched (in preferred order)
+      #
+      #  1. The directory specified by the option :bin_path
+      #  2. The directory specified by the environment variable $YUIC_HOME, if set
+      #  3. Current working directory
+      #
+      # If any of these folders contain one or more files named like
+      # yuicompressor.jar or yuicompressor-x.y.z.jar the method will pick the
+      # last file in the list returned by +Dir.glob("#{dir}/yuicompressor*.jar").sort+
+      # This means that higher version numbers will be preferred with the default
+      # naming for the YUI Compressor Jars
+      def locate_jar
+        paths = @options[:bin_path].nil? ? [] : [@options[:bin_path]]
+        jar = nil
+
+        if ENV.key?('YUIC_HOME') && File.exist?(ENV['YUIC_HOME'])
+          paths << ENV['YUIC_HOME']
+        end
+
+        (paths << Dir.pwd).each do |path|
+          files = Dir.glob(File.join(path, 'yuicompressor*.jar'))
+          jar = files.sort.last unless files.empty?
+          break unless jar.nil?
+        end
+
+        jar.nil? ? nil : File.expand_path(jar)
+      end
+    end
+
+    # Run YUI Compressor with command line interface semantics
+    #
+    class Cli
+      def self.run(args)
+        if args.length != 2
+          puts 'Usage: yui_compressor.rb input ouput'
+        else
+          yc = Juicer::Minify::YuiCompressor.new
+          yc.compress(args.shift, args.shift)
+        end
+      end
+    end
+  end
+end
+
+Juicer::Minifyer::Compressor::Cli.run($*) if $0 == __FILE__

data/lib/juicer.rb

@@ -0,0 +1,45 @@
+module Juicer
+
+  # :stopdoc:
+  VERSION = '0.2.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each { |rb| require rb }
+  end
+
+end
+
+Juicer.require_all_libs_relative_to(__FILE__)

data/test/juicer/merger/test_base.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+
+class TestMergerBase < Test::Unit::TestCase
+
+  def setup
+    @file_merger = Juicer::Merger::Base.new
+    @file_setup = Juicer::Test::FileSetup.new($DATA_DIR)
+    @file_setup.create!
+  end
+
+  def teardown
+    file = path('test_out.css')
+    File.delete(file) if File.exists?(file)
+  end
+
+  def test_constructor
+    files = ['a.css', 'b.css'].collect { |file| path(file) }
+    file_merger = Juicer::Merger::Base.new files
+    assert_equal 2, file_merger.files.length
+  end
+
+  def test_append_duplicate_files
+    @file_merger.append ['a.css', 'b.css'].collect { |file| path(file) }
+    assert_equal 2, @file_merger.files.length,
+           "b.css should not be included twice even when a.css imports it and it is manually added"
+  end
+
+  def test_append_duplicate
+    @file_merger.append ['a.css', 'b.css'].collect { |file| path(file) }
+    assert_equal 2, @file_merger.files.length
+
+    @file_merger.append path('a.css')
+    assert_equal 2, @file_merger.files.length
+
+    @file_merger.append path('version.txt')
+    assert_equal 3, @file_merger.files.length
+  end
+
+  def test_append_alias
+    @file_merger << ['a.css', 'b.css'].collect { |file| path(file) }
+    assert_equal 2, @file_merger.files.length
+  end
+
+  def test_save_to_stream
+    a_css = path('a.css')
+    a_css_contents = IO.read(a_css) + "\n"
+    ios = StringIO.new
+    @file_merger << a_css
+    @file_merger.save ios
+    assert_equal a_css_contents, ios.string
+  end
+
+  def test_save_to_file
+    a_css = path('a.css')
+    output_file = path('test_out.css')
+    @file_merger << a_css
+    @file_merger.save(output_file)
+
+    assert_equal IO.read(a_css) + "\n", IO.read(output_file)
+  end
+
+  def test_save_merged_to_stream
+    a_css = path('a.css')
+    b_css = path('b.css')
+    ios = StringIO.new
+
+    @file_merger << a_css
+    @file_merger << b_css
+    @file_merger.save(ios)
+
+    assert_equal "#{IO.read(a_css)}\n#{IO.read(b_css)}\n", ios.string
+  end
+
+  def test_save_merged_to_file
+    a_css = path('a.css')
+    b_css = path('b.css')
+    a_contents = IO.read(a_css) + "\n"
+    b_contents = IO.read(b_css) + "\n"
+    output_file = path('test_out.css')
+
+    @file_merger << a_css
+    @file_merger << b_css
+    @file_merger.save(output_file)
+
+    assert_equal "#{IO.read(a_css)}\n#{IO.read(b_css)}\n", IO.read(output_file)
+  end
+
+  def test_resolve_dependencies
+    Juicer::Merger::Base.publicize_methods do
+      @file_merger.dependency_resolver = MockImportResolver.new
+
+      @file_merger.resolve_dependencies('a.css')
+      assert_equal 1, @file_merger.files.length
+
+      @file_merger.resolve_dependencies('a.css')
+      assert_equal 1, @file_merger.files.length
+    end
+  end
+
+  def test_merge
+    Juicer::Merger::Base.publicize_methods do
+      a_content = <<EOF
+@import 'b.css';
+
+/* Dette er a.css */
+
+EOF
+
+      content = @file_merger.merge(path('a.css'))
+      assert_equal a_content, content
+    end
+  end
+
+  def test_attributes
+    assert_not_nil @file_merger.files
+  end
+end
+
+class MockImportResolver
+  def resolve(file)
+    yield file
+  end
+end

data/test/juicer/merger/test_css_dependency_resolver.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+
+class TestCssDependencyResolver < Test::Unit::TestCase
+  def setup
+    @resolver = Juicer::Merger::CssDependencyResolver.new
+    @file_setup = Juicer::Test::FileSetup.new($DATA_DIR)
+    @file_setup.create!
+  end
+
+  def test_init
+    assert_equal [], @resolver.files
+  end
+
+  def test_resolve
+    b_file = File.expand_path(path('b.css'))
+    a_file = File.expand_path(path('a.css'))
+
+    files = @resolver.resolve(path('a.css')) do |file|
+      assert b_file == file || a_file == file
+      b_file != file
+    end
+
+    assert_equal [a_file], files
+
+    files = @resolver.resolve(path('a.css')) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    assert_equal [a_file, b_file], files.sort
+  end
+end

data/test/juicer/merger/test_javascript_dependency_resolver.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+
+class TestJavaScriptDependencyResolver < Test::Unit::TestCase
+
+  def setup
+    @resolver = Juicer::Merger::JavaScriptDependencyResolver.new
+    @file_setup = Juicer::Test::FileSetup.new($DATA_DIR)
+    @file_setup.create!
+  end
+
+  def test_init
+    assert_equal [], @resolver.files
+  end
+
+  def test_resolve
+    b_file = File.expand_path(path('b.js'))
+    a_file = File.expand_path(path('a.js'))
+
+    files = @resolver.resolve(path('a.js')) do |file|
+      assert b_file == file || a_file == file, file
+      b_file != file
+    end
+
+    assert_equal [a_file], files
+
+    files = @resolver.resolve(path('a.js')) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    assert_equal [a_file, b_file], files.sort
+
+    files = @resolver.resolve(path('b.js')) do |file|
+      assert b_file == file || a_file == file
+      true
+    end
+
+    assert_equal [a_file, b_file], files.sort
+  end
+end

data/test/juicer/merger/test_javascript_merger.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. test_helper])) unless defined?(Juicer)
+
+class TestJavaScriptMerger < Test::Unit::TestCase
+
+  def setup
+    @file_merger = Juicer::Merger::JavaScriptMerger.new
+    @file_setup = Juicer::Test::FileSetup.new($DATA_DIR)
+    @file_setup.create!
+  end
+
+  def teardown
+    file = path('test_out.js')
+    File.delete(file) if File.exists?(file)
+  end
+
+  def test_init
+    Juicer::Merger::JavaScriptMerger.publicize_methods do
+      assert_equal Juicer::Merger::JavaScriptDependencyResolver, @file_merger.dependency_resolver.class
+    end
+  end
+
+  def test_merge
+    Juicer::Merger::JavaScriptMerger.publicize_methods do
+      a_content = <<EOF
+/**
+ * @depend b.js
+ */
+
+/* Dette er a.js */
+
+EOF
+      content = @file_merger.merge(path('a.js'))
+      assert_equal a_content, content
+    end
+  end
+
+  def test_constructor
+    file_merger = Juicer::Merger::JavaScriptMerger.new(path('a.js'))
+    assert_equal 2, file_merger.files.length
+  end
+
+  def test_append
+    @file_merger << path('a.js')
+    assert_equal 2, @file_merger.files.length
+  end
+
+  def test_save
+    a_js = path('a.js')
+    b_js = path('b.js')
+    merged = <<EOF
+/**
+ * @depends a.js
+ */
+
+/* Dette er b.css */
+
+/**
+ * @depend b.js
+ */
+
+/* Dette er a.js */
+
+EOF
+
+    @file_merger << a_js
+    ios = StringIO.new
+    @file_merger.save(ios)
+    assert_equal merged, ios.string
+
+    output_file = path('test_out.js')
+    @file_merger.save(output_file)
+
+    assert_equal merged, IO.read(output_file)
+  end
+end