ktheory-juicer 1.0.0.ktheory1

data/lib/juicer/merger/base.rb

@@ -0,0 +1,74 @@
+require "juicer/chainable"
+
+# Merge several files into one single output file
+module Juicer
+  module Merger
+    class Base
+      include Chainable
+      attr_accessor :dependency_resolver
+      attr_reader :files
+
+      def initialize(files = [], options = {})
+        @files = []
+        @root = nil
+        @options = options
+        @dependency_resolver ||= nil
+        self.append files
+      end
+
+      #
+      # Append contents to output. Resolves dependencies and adds
+      # required files recursively
+      # file = A file to add to merged content
+      #
+      def append(file)
+        return file.each { |f| self << f } if file.class == Array
+        return if @files.include?(file)
+
+        if !@dependency_resolver.nil?
+          path = File.expand_path(file)
+          resolve_dependencies(path)
+        elsif !@files.include?(file)
+          @files << file
+        end
+      end
+
+      alias_method :<<, :append
+
+      #
+      # Save the merged contents. If a filename is given the new file is
+      # written. If a stream is provided, contents are written to it.
+      #
+      def save(file_or_stream)
+        output = file_or_stream
+
+        if output.is_a? String
+          @root = Pathname.new(File.dirname(File.expand_path(output)))
+          output = File.open(output, 'w')
+        else
+          @root = Pathname.new(File.expand_path("."))
+        end
+
+        @files.each do |f|
+          output.puts(merge(f))
+        end
+
+        output.close if file_or_stream.is_a? String
+      end
+
+      chain_method :save
+
+     private
+      def resolve_dependencies(file)
+        @files.concat @dependency_resolver.resolve(file)
+        @files.uniq!
+      end
+
+      # Fetch contents of a single file. May be overridden in subclasses to provide
+      # custom content filtering
+      def merge(file)
+        IO.read(file) + "\n"
+      end
+    end
+  end
+end

data/lib/juicer/merger/javascript_merger.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require "juicer/merger/base"
+require "juicer/dependency_resolver/javascript_dependency_resolver"
+
+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__
+  puts("Usage: javascript_merger.rb file[...] output") and exit if $*.length < 2
+
+  fm = JavaScriptMerger.new()
+  fm << $*[0..-2]
+  fm.save($*[-1])
+end

data/lib/juicer/merger/stylesheet_merger.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+require "juicer/merger/base"
+require "juicer/dependency_resolver/css_dependency_resolver"
+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)
+        @hosts = options[:hosts] || []
+        @host_num = 0
+        @use_absolute = options.key?(:absolute_urls) ? options[:absolute_urls] : false
+        @use_relative = options.key?(:relative_urls) ? options[:relative_urls] : false
+        @web_root = options[:web_root]
+        @web_root = File.expand_path(@web_root).sub(/\/?$/, "") if @web_root # Make sure path doesn't end in a /
+      end
+
+     private
+      #
+      # Takes care of removing any import statements. This avoids importing the
+      # file that was just merged into the current file.
+      #
+      # +merge+ also recalculates any referenced URLs. Relative URLs are adjusted
+      # to be relative to the resulting merged file. Absolute URLs are left alone
+      # by default. If the :hosts option is set, the absolute URLs will cycle
+      # through these. This may help in concurrent downloads.
+      #
+      # The options hash decides how Juicer recalculates referenced URLs:
+      #
+      #   options[:absolute_urls] When true, all paths are converted to absolute
+      #                           URLs. Requires options[:web_root] to define
+      #                           root directory to resolve absolute URLs from.
+      #   options[:relative_urls] When true, all paths are converted to relative
+      #                           paths. Requires options[:web_root] to define
+      #                           root directory to resolve absolute URLs from.
+      #
+      # If none if these are set then relative URLs are recalculated to match
+      # location of merged target while absolute URLs are left absolute.
+      #
+      # If options[:hosts] is set to an array of hosts, then they will be cycled
+      # for all absolute URLs regardless of absolute/relative URL strategy.
+      #
+      def merge(file)
+        content = super.gsub(/^\s*\@import\s("|')(.*)("|')\;?/, '')
+        dir = File.expand_path(File.dirname(file))
+
+        content.scan(/url\([\s"']*([^\)"'\s]*)[\s"']*\)/m).uniq.collect do |url|
+          url = url.first
+          path = resolve_path(url, dir)
+          content.gsub!(/\(#{url}\)/m, "(#{path})") unless path == url
+        end
+
+        content
+      end
+
+      #
+      # Resolves a path relative to a directory
+      #
+      def resolve_path(url, dir)
+        path = url
+
+        # Absolute URLs
+        if url =~ %r{^/} && @use_relative
+          raise ArgumentError.new("Unable to handle absolute URLs without :web_root option") if !@web_root
+          path = Pathname.new(File.join(@web_root, url)).relative_path_from(@root).to_s
+        end
+
+        # All URLs that don't start with a protocol
+        if url !~ %r{^/} && url !~ %r{^[a-z]+://}
+          if @use_absolute
+            raise ArgumentError.new("Unable to handle absolute URLs without :web_root option") if !@web_root
+            path = File.expand_path(File.join(dir, url)).sub(@web_root, "")         # Make absolute
+          else
+            path = Pathname.new(File.join(dir, url)).relative_path_from(@root).to_s # ...or redefine relative ref
+          end
+        end
+
+        # Cycle hosts, if any
+        if url =~ %r{^/} && @hosts.length > 0
+          path = File.join(@hosts[@host_num % @hosts.length], url)
+          @host_num += 1
+        end
+
+        path
+      end
+    end
+  end
+end
+
+# Run file from command line
+#
+if $0 == __FILE__
+  puts("Usage: stylesheet_merger.rb file[...] output") and exit if $*.length < 2
+
+  fm = Juicer::Merger::StylesheetMerger.new()
+  fm << $*[0..-2]
+  fm.save($*[-1])
+end

data/lib/juicer/minifyer/closure_compiler.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'juicer/minifyer/java_base'
+require 'juicer/chainable'
+
+module Juicer
+  module Minifyer
+
+    # Provides an interface to the Closure compiler library using
+    # Juicer::Shell::Binary. The Closure compiler library is implemented
+    # using Java, and as such Java is required when running this code. Also, the
+    # compiler jar file has to be provided.
+    #
+    # The Closure Compiler is invoked using the java binary and the compiler
+    # jar file.
+    #
+    # Providing the Jar file (usually compiler.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 $CLOSUREC_HOME, if set
+    #  3. Current working directory
+    #
+    # For more information on how the Jar is located, see
+    # +Juicer::Minify::ClosureCompiler.locate_jar+
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no), Pavel Valodzka (pavel@valodzka.name)
+    # Copyright:: Copyright (c) 2008-2009 Christian Johansen, (c) 2009 Pavel Valodzka
+    # License::   MIT
+    #
+    # = Usage example =
+    # closure = Juicer::Minifyer::ClosureCompiler.new
+    # closure.java = "/usr/local/bin/java" # If 'java' is not on path
+    # closure.path << "/home/user/java/yui_compressor/"
+    # closure.save("", "")
+    #
+    class ClosureCompiler
+      include Juicer::Minifyer::JavaBase
+      include Juicer::Chainable
+
+      # 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
+
+        use_tmp = unless output
+                    output = file
+                    file = File.join(Dir::tmpdir, File.basename(file) + '.min.tmp.' + type.to_s)
+                    FileUtils.mkdir_p(File.dirname(file))
+                    FileUtils.move(output, file)
+
+                    true
+                  end
+
+        out_dir = File.dirname(output)
+        FileUtils.mkdir_p(out_dir) unless File.exists?(out_dir)
+        result = execute(%Q{-jar "#{locate_jar}"#{jar_args} -js_output_file "#{output}" -js "#{file}"})
+
+        File.delete(file) if use_tmp
+      end
+
+      chain_method :save
+
+      def self.bin_base_name
+        "*compiler"
+      end
+
+      def self.env_name
+        "CLOSUREC_HOME"
+      end
+
+     private
+
+      # Some class level options may be set:
+      # :bin_path (defaults to Dir.cwd)
+      # :java     (Java command, defaults to 'java')
+      def default_options
+        { }
+      end
+    end
+  end
+end

data/lib/juicer/minifyer/java_base.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'juicer/binary'
+
+module Juicer
+  module Minifyer
+
+    # Provides an interface to Java based compressor libraries using
+    # Juicer::Shell::Binary.
+    #
+    # The compressor is invoked using the java binary and the compressor jar
+    # file.
+    #
+    # Providing the Jar file 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, if set
+    #  3. Current working directory
+    #
+    # Name of environment variable is decided by including classes self.env_name
+    # constant.
+    #
+    # For more information on how the Jar is located, see
+    # +Juicer::Minify::JavaMinifyer.locate_jar+
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no)
+    # Copyright:: Copyright (c) 2008-2009 Christian Johansen
+    # License::   MIT
+    #
+    module JavaBase
+      include Juicer::Binary
+
+      def initialize(options = {})
+        bin = options.delete(:java) || "java"
+        bin_path = options.delete(:bin_path) || nil
+        @jar = nil
+        @jar_args = nil
+
+        super(bin, options)
+        path << bin_path if bin_path
+      end
+
+      # Overrides set_opts called from binary class
+      # This avoids sending illegal options to the java binary
+      #
+      def set_opts(args)
+        @jar_args = " #{args}"
+      end
+
+      def jar_args
+        @jar_args
+      end
+
+     private
+
+      # 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, if set
+      #  3. Current working directory
+      #
+      # If any of these folders contain one or more files named like
+      # [self.class.bin_base_name].jar or [self.class.bin_base_name]-x.y.z.jar
+      # the method willpick the last file in the list returned by
+      # +Dir.glob("#{dir}/[self.class.bin_base_name]*.jar").sort. This means that
+      # higher version numbers will be preferred with the default naming for the
+      # jars
+      #
+      def locate_jar
+        files = locate("#{self.class.bin_base_name}*.jar", self.class.env_name)
+        !files || files.empty? ? nil : files.sort.last
+      end
+    end
+  end
+end

data/lib/juicer/minifyer/yui_compressor.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+require 'juicer/minifyer/java_base'
+require 'juicer/chainable'
+
+module Juicer
+  module Minifyer
+
+    # Provides an interface to the YUI compressor library using
+    # Juicer::Shell::Binary. 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
+    # yuic.java = "/usr/local/bin/java" # If 'java' is not on path
+    # yuic.path << "/home/user/java/yui_compressor/"
+    # yuic.save("", "")
+    #
+    #
+    class YuiCompressor
+      include Juicer::Minifyer::JavaBase
+      include Juicer::Chainable
+
+      # 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
+
+        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))
+
+        result = execute(%Q{-jar "#{locate_jar}"#{jar_args} -o "#{output}" "#{file}"})
+
+        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
+
+      def self.bin_base_name
+        "yuicompressor"
+      end
+
+      def self.env_name
+        "YUIC_HOME"
+      end
+
+     private
+      # Returns a map of options accepted by YUI Compressor, currently:
+      #
+      # :charset
+      # :line_break
+      # :no_munge (JavaScript only)
+      # :preserve_semi
+      # :disable_optimizations
+      #
+      # 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, :nomunge => nil,
+          :preserve_semi => nil, :disable_optimizations => nil }
+      end
+    end
+  end
+end