cjohansen-juicer 0.2.0 → 0.2.4

data/lib/juicer/install/rhino_installer.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. juicer])) unless defined?(Juicer)
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the Mozilla Rhino jar.
+    #
+    class RhinoInstaller < Base
+      attr_reader :latest
+
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = "1_7R2-RC1"
+        @website = "ftp://ftp.mozilla.org/pub/mozilla.org/js/"
+      end
+
+      #
+      # Install Rhino. Downloads the jar file and stores it in the installation
+      # directory along with the License text.
+      #
+      def install(version = nil)
+        version = super((version || latest).gsub(/\./, "_"))
+        base = "rhino#{version}"
+        filename = download(File.join(@website, "#{base}.zip"))
+        target = File.join(@install_dir, path)
+
+        Zip::ZipFile.open(filename) do |file|
+          FileUtils.mkdir_p(File.join(target, version))
+
+          begin
+            file.extract("#{base.sub(/-RC\d/, "")}/LICENSE.txt", File.join(target, version, "LICENSE.txt"))
+          rescue Exception
+            # Fail silently, some releases don't carry the license
+          end
+
+          file.extract("#{base.sub(/-RC\d/, "")}/js.jar", File.join(target, "bin", "#{base}.jar"))
+        end
+      end
+
+      #
+      # Uninstalls Rhino
+      #
+      def uninstall(version = nil)
+        super((version || latest).gsub(/\./, "_")) do |dir, version|
+          base = "rhino#{version}"
+          File.delete(File.join(dir, "bin/", "#{base}.jar"))
+        end
+      end
+    end
+  end
+end

data/lib/juicer/install/yui_compressor_installer.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. juicer])) unless defined?(Juicer)
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the YUI Compressor.
+    # Installation downloads the YUI Compressor distribution, unzips it and
+    # storesthe jar file on disk along with the license.
+    #
+    class YuiCompressorInstaller < Base
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = nil
+        @website = "http://www.julienlecomte.net/yuicompressor/"
+      end
+
+      #
+      # Install the Yui Compressor. Downloads the distribution and keeps the jar
+      # file inside PATH/yui_compressor/bin and the README and CHANGELOG in
+      # PATH/yui_compressor/x.y.z/ where x.y.z is the version, most recent if
+      # not specified otherwise.
+      #
+      # Path defaults to environment variable $JUICER_HOME or default Juicer
+      # home
+      #
+      def install(version = nil)
+        version = super(version)
+        base = "yuicompressor-#{version}"
+        filename = download(File.join(@website, "#{base}.zip"))
+        target = File.join(@install_dir, path)
+
+        Zip::ZipFile.open(filename) do |file|
+          file.extract("#{base}/doc/README", File.join(target, version, "README"))
+          file.extract("#{base}/doc/CHANGELOG", File.join(target, version, "CHANGELOG"))
+          file.extract("#{base}/build/#{base}.jar", File.join(target, "bin", "#{base}.jar"))
+        end
+      end
+
+      #
+      # Uninstalls the given version of YUI Compressor. If no location is
+      # provided the environment variable $JUICER_HOME or Juicers default home
+      # directory is used.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      # If there are no more files left in INSTALLATION_PATH/yui_compressor, the
+      # whole directory is removed.
+      #
+      def uninstall(version = nil)
+        super(version) do |dir, version|
+          File.delete(File.join(dir, "bin/yuicompressor-#{version}.jar"))
+        end
+      end
+
+      #
+      # Check which version is the most recent
+      #
+      def latest
+        return @latest if @latest
+        webpage = Hpricot(open(@website))
+        @latest = (webpage / "#downloadbutton a")[0].get_attribute("href").match(/(\d\.\d\.\d)/)[1]
+      end
+    end
+  end
+end

data/lib/juicer/jslint.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "binary"))
+
+module Juicer
+  #
+  # A Ruby API to Douglas Crockfords genious JsLint program
+  # http://www.jslint.com/
+  #
+  # JsLint parses JavaScript code and identifies (potential) problems.
+  # Effectively, JsLint defines a subset of JavaScript which is safe to use, and
+  # among other things make code minification a substantially less dangerous
+  # task.
+  #
+  class JsLint
+    include Juicer::Binary
+
+    def initialize(options = {})
+      super(options[:java] || "java")
+      path << options[:bin_path] if options[:bin_path]
+    end
+
+    #
+    # Checks if a files has problems. Also includes experimental support for CSS
+    # files. CSS files should begin with the line @charset "UTF-8";
+    #
+    # Returns a Juicer::JsLint::Report object
+    #
+    def check(file)
+      rhino_jar = rhino
+      js_file = locate_lib
+
+      raise FileNotFoundError.new("Unable to locate Rhino jar '#{rhino_jar}'") if !rhino_jar || !File.exists?(rhino_jar)
+      raise FileNotFoundError.new("Unable to locate JsLint '#{js_file}'") if !js_file || !File.exists?(js_file)
+      raise FileNotFoundError.new("Unable to locate input file '#{file}'") unless File.exists?(file)
+
+      lines = execute(%Q{-jar "#{rhino}" "#{locate_lib}" "#{file}"}).split("\n")
+      return Report.new if lines.length == 1 && lines[0] =~ /jslint: No problems/
+
+      report = Report.new
+      lines = lines.reject { |line| !line || "#{line}".strip == "" }
+      report.add_error(lines.shift, lines.shift) while lines.length > 0
+
+      return report
+    end
+
+    def rhino
+      files = locate("**/rhino*.jar", "RHINO_HOME")
+      !files || files.empty? ? nil : files.sort.last
+    end
+
+    def locate_lib
+      files = locate("**/jslint-*.js", "JSLINT_HOME")
+      !files || files.empty? ? nil : files.sort.last
+    end
+
+    #
+    # Represents the results of a JsLint run
+    #
+    class Report
+      attr_accessor :errors
+
+      def initialize(errors = [])
+        @errors = errors
+      end
+
+      def add_error(message, code)
+        @errors << JsLint::Error.new(message, code)
+      end
+
+      def ok?
+        @errors.nil? || @errors.length == 0
+      end
+    end
+
+    #
+    # A JsLint error
+    #
+    class Error
+      attr_accessor :message, :code
+
+      def initialize(message, code)
+        @message = message
+        @code = code
+      end
+
+      def to_s
+        "#@message\n#@code"
+      end
+    end
+  end
+end

data/lib/juicer/merger/base.rb

@@ -1,72 +1,74 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "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 = []
-        @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
-        output = File.open(output, 'w') if output.is_a? String
-
-        @files.each { |f| output.puts(merge(f)) }
-        output.close if file_or_stream.is_a? String
-      end
-
-      chain_method :save
-
-     private
-      def resolve_dependencies(file)
-        @dependency_resolver.resolve(file) do |f|
-          if @files.include?(f)
-            false
-          else
-            @files << f
-            resolve_dependencies(f)
-            true
-          end
-        end
-
-        @files
-      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
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "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/dependency_resolver.rb

@@ -16,23 +16,9 @@ module Juicer
       # if the block is true for the given file. Without a block every found
       # file is returned.
       #
-      def resolve(file)
-        imported_file = nil
+      def resolve(file, &block)
         @files = []
-
-        catch(:done) do
-          IO.foreach(file) do |line|
-            imported_file = parse(line, imported_file)
-
-            if imported_file
-              imported_file = resolve_path(imported_file, file)
-              @files << imported_file if !block_given? || yield(imported_file)
-            end
-          end
-        end
-
-        file = File.expand_path(file)
-        @files << file if !block_given? || yield(file)
+        _resolve(file, &block)
       end
 
       #
@@ -59,6 +45,38 @@ module Juicer
       def parse(line)
         raise NotImplementedError.new
       end
+
+      #
+      # Carries out the actual work of resolve. resolve resets the internal
+      # file list and yields control to _resolve for rebuilding the file list.
+      #
+      def _resolve(file)
+        imported_file = nil
+
+        IO.foreach(file) do |line|
+          # Implementing subclasses may throw :done from the parse method when
+          # the file is exhausted for dependency declaration possibilities.
+          catch(:done) do
+            imported_file = parse(line, imported_file)
+
+            # If a dependency declaration was found
+            if imported_file
+              # Resolves a path relative to the file that imported it
+              imported_file = resolve_path(imported_file, file)
+
+              # Only keep processing file if it's not already included.
+              # Yield to block to allow caller to ignore file
+              if !@files.include?(imported_file) && (!block_given? || yield(imported_file))
+                # Check this file for imports before adding it to get order right
+                _resolve(imported_file) { |f| f != File.expand_path(file) }
+              end
+            end
+          end
+        end
+
+        file = File.expand_path(file)
+        @files << file if !@files.include?(file) && (!block_given? || yield(file))
+      end
     end
   end
 end

data/lib/juicer/merger/stylesheet_merger.rb

@@ -20,12 +20,82 @@ module Juicer
       #
       def initialize(files = [], options = {})
         @dependency_resolver = CssDependencyResolver.new(options)
-        super(files, 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\(([^\)]*)\)/).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