juicer 0.2.0

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

@@ -0,0 +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 = []
+        @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/css_dependency_resolver.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "dependency_resolver"))
+
+module Juicer
+  module Merger
+    # Resolves @import statements in CSS files and builds a list of all
+    # files, in order.
+    #
+    class CssDependencyResolver < DependencyResolver
+      # Regexp borrowed from similar project:
+      # http://github.com/cgriego/front-end-blender/tree/master/lib/front_end_architect/blender.rb
+      @@import_pattern = /^\s*@import(?: url\(| )(['"]?)([^\?'"\)\s]+)(\?(?:[^'"\)]+)?)?\1\)?(?:[^?;]+)?;?/im
+
+     private
+      def parse(line, imported_file = nil)
+        return $2 if line =~ @@import_pattern
+
+        # At first sight of actual CSS rules we abort (TODO: This does not take
+        # into account the fact that rules may be commented out and that more
+        # imports may follow)
+        throw :done if imported_file && line =~ %r{/*}
+        throw :done if line =~ /^[\.\#a-zA-Z\:]/
+      end
+    end
+  end
+end

data/lib/juicer/merger/dependency_resolver.rb

@@ -0,0 +1,82 @@
+module Juicer
+  module Merger
+    class DependencyResolver
+      attr_reader :files
+
+      # Constructor
+      def initialize(options = {})
+        @files = []
+        @options = options
+      end
+
+      #
+      # Resolve dependencies.
+      # This method accepts an optional block. The block will receive each
+      # file in succession. The file is included in the returned collection
+      # if the block is true for the given file. Without a block every found
+      # file is returned.
+      #
+      def resolve(file, &block)
+        @files = []
+        _resolve(file, &block)
+      end
+
+      #
+      # Resolves a path relative to another. If the path is absolute (ie it
+      # starts with a protocol or /) the <tt>:web_root</tt> options has to be
+      # set as well.
+      #
+      def resolve_path(path, reference)
+        # Absolute URL
+        if path =~ %r{^(/|[a-z]+:)}
+          if @options[:web_root].nil?
+            msg = "Cannot resolve absolute path '#{path}' without web root option"
+            raise ArgumentError.new(msg)
+          end
+
+          path.sub!(%r{^[a-z]+://[^/]+/}, '')
+          return File.expand_path(File.join(@options[:web_root], path))
+        end
+
+        File.expand_path(File.join(File.dirname(reference), path))
+      end
+
+     private
+      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/javascript_dependency_resolver.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "dependency_resolver"))
+
+module Juicer
+  module Merger
+    # Resolves @depends and @depend statements in comments in JavaScript files.
+    # Only the first comment in a JavaScript file is parsed
+    #
+    class JavaScriptDependencyResolver < DependencyResolver
+      @@depends_pattern = /\@depends?\s+([^\s\'\"\;]+)/
+
+     private
+      def parse(line, imported_file = nil)
+        return $1 if line =~ @@depends_pattern
+
+        # If we have already skimmed through some @depend/@depends or a
+        # closing comment we're done.
+        throw :done unless imported_file.nil? || !(line =~ /\*\//)
+      end
+    end
+  end
+end

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