juicer 0.2.6 → 1.0.0

data/lib/juicer/command/install.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "util")
+require "juicer/command/util"
 require "cmdparse"
 require "pathname"
 
@@ -29,7 +29,9 @@ into Juicer installation directory, usually ~/.juicer
 
       # Execute command
       #
-      def execute(args)
+      def execute(*args)
+        args.flatten!
+
         if args.length == 0
           raise ArgumentError.new('Please provide a library to install')
         end

data/lib/juicer/command/list.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "util")
+require "juicer/command/util"
 require "cmdparse"
 require "pathname"
 
@@ -12,9 +12,9 @@ module Juicer
 
       # Initializes command
       #
-      def initialize(io = STDOUT)
+      def initialize(log = nil)
         super('list', false, true)
-        @io = io
+        @log = log
         self.short_desc = "Lists all dependencies for all input files/patterns"
         self.description = <<-EOF
 Dependencies are looked up recursively. The dependency chain reveals which files
@@ -34,16 +34,23 @@ Input parameters may be:
           raise ArgumentError.new('Please provide atleast one input file/pattern')
         end
 
-        types = { :js => Juicer::Merger::JavaScriptDependencyResolver.new,
-                  :css => Juicer::Merger::CssDependencyResolver.new }
+        types = { :js => Juicer::JavaScriptDependencyResolver.new,
+                  :css => Juicer::CssDependencyResolver.new }
 
-        files(args).each do |file|
+        result = files(args).map { |file|
           type = file.split(".").pop.to_sym
           raise FileNotFoundError.new("Unable to guess type (CSS/JavaScript) of file #{relative(file)}") unless types[type]
 
-          @io.puts "Dependency chain for #{relative file}:"
-          @io.puts "  #{relative(types[type].resolve(file)).join("\n  ")}\n\n"
-        end
+          deps = relative types[type].resolve(file)
+          # there may only be one dependency, which resolve() returns as a string
+          deps = deps.join("\n  ") if deps.is_a? Array
+
+          "Dependency chain for #{relative file}:\n  #{deps}"
+        }.join("\n\n") + "\n"
+
+        @log.info result
+
+        result
       end
     end
   end

data/lib/juicer/command/merge.rb

@@ -1,5 +1,5 @@
-require File.join(File.dirname(__FILE__), "util")
-require File.join(File.dirname(__FILE__), "verify")
+require "juicer/command/util"
+require "juicer/command/verify"
 require "cmdparse"
 require "pathname"
 
@@ -25,11 +25,12 @@ module Juicer
         @ignore = false                 # Ignore syntax problems if true
         @cache_buster = :soft           # What kind of cache buster to use, :soft or :hard
         @hosts = nil                    # Hosts to use when replacing URLs in stylesheets
-        @web_root = nil                 # Used to understand absolute paths
+        @document_root = nil                 # Used to understand absolute paths
         @relative_urls = false          # Make the merger use relative URLs
         @absolute_urls = false          # Make the merger use absolute URLs
-        @local_hosts = []               # Host names that are served from :web_root
+        @local_hosts = []               # Host names that are served from :document_root
         @verify = true                  # Verify js files with JsLint
+				@image_embed_type = :none       # Embed images in css files, options are :none, :data_uri
 
         @log = log || Logger.new(STDOUT)
 
@@ -47,16 +48,18 @@ inside the first multi-line comment. The switch is @depend or @depends, your
 choice.
 
 The -m --minifyer switch can be used to select which minifyer to use. Currently
-only YUI Compressor is supported, ie -m yui_compressor (default). When using
-the YUI Compressor the path should be the path to where the jar file is found.
+only YUI Compressor and Google Closure Compiler is supported, ie -m yui_compressor (default) or -m closure_compiler. When using
+the compressor the path should be the path to where the jar file is found.
         EOF
 
         self.options = CmdParse::OptionParserWrapper.new do |opt|
           opt.on("-o", "--output file", "Output filename") { |filename| @output = filename }
           opt.on("-p", "--path path", "Path to compressor binary") { |path| @opts[:bin_path] = path }
-          opt.on("-m", "--minifyer name", "Which minifer to use. Currently only supports yui_compressor") { |name| @minifyer = name }
+          opt.on("-m", "--minifyer name", "Which minifer to use. Currently only supports yui_compressor and closure compiler") { |name| @minifyer = name }
           opt.on("-f", "--force", "Force overwrite of target file") { @force = true }
-          opt.on("-a", "--arguments arguments", "Arguments to minifyer, escape with quotes") { |arguments| @arguments = arguments }
+          opt.on("-a", "--arguments arguments", "Arguments to minifyer, escape with quotes") { |arguments|
+            @arguments = arguments.to_s.gsub(/(^['"]|["']$)/, "")
+          }
           opt.on("-i", "--ignore-problems", "Merge and minify even if verifyer finds problems") { @ignore = true }
           opt.on("-s", "--skip-verification", "Skip JsLint verification (js files only). Not recomended!") { @verify = false }
           opt.on("-t", "--type type", "Juicer can only guess type when files have .css or .js extensions. Specify js or\n" +
@@ -70,11 +73,15 @@ the YUI Compressor the path should be the path to where the jar file is found.
                            (" " * 37) + "absolute URLs are used. Only valid for CSS files") { |t| @relative_urls = true }
           opt.on("-b", "--absolute-urls", "Convert all referenced URLs to absolute URLs. Requires --document-root.\n" +
                            (" " * 37) + "Works with cycled asset hosts. Only valid for CSS files") { |t| @absolute_urls = true }
-          opt.on("-d", "--document-root dir", "Path to resolve absolute URLs relative to") { |path| @web_root = path }
+          opt.on("-d", "--document-root dir", "Path to resolve absolute URLs relative to") { |path| @document_root = path }
           opt.on("-c", "--cache-buster type", "none, soft or hard. Default is soft, which adds timestamps to referenced\n" +
                            (" " * 37) + "URLs as query parameters. None leaves URLs untouched and hard alters file names") do |type|
             @cache_buster = [:soft, :hard].include?(type.to_sym) ? type.to_sym : nil
           end
+          opt.on("-e", "--embed-images type", "none or data_uri. Default is none. Data_uri embeds images using Base64 encoding\n" +
+                           (" " * 37) + "None leaves URLs untouched. Candiate images must be flagged with '?embed=true to be considered") do |embed|
+            @image_embed_type = [:none, :data_uri].include?(embed.to_sym) ? embed.to_sym : nil
+          end
         end
       end
 
@@ -101,7 +108,7 @@ the YUI Compressor the path should be the path to where the jar file is found.
         # confused
         merger = merger(output).new(files, :relative_urls => @relative_urls,
                                            :absolute_urls => @absolute_urls,
-                                           :web_root => @web_root,
+                                           :document_root => @document_root,
                                            :hosts => @hosts)
 
         # Fail if syntax trouble (js only)
@@ -112,7 +119,7 @@ the YUI Compressor the path should be the path to where the jar file is found.
         end
 
         # Set command chain and execute
-        merger.set_next(cache_buster(output)).set_next(minifyer)
+        merger.set_next(image_embed(output)).set_next(cache_buster(output)).set_next(minifyer)
         merger.save(output)
 
         # Print report
@@ -120,7 +127,7 @@ the YUI Compressor the path should be the path to where the jar file is found.
         merger.files.each { |file| @log.info "  #{relative file}" }
       rescue FileNotFoundError => err
         # Handle missing document-root option
-        puts err.message.sub(/:web_root/, "--document-root")
+        puts err.message.sub(/:document_root/, "--document-root")
       end
 
      private
@@ -137,7 +144,8 @@ the YUI Compressor the path should be the path to where the jar file is found.
           @log.debug "Using #{@minifyer.camel_case} for minification"
 
           return compressor
-        rescue NameError
+        rescue NameError => e
+          @log.fatal e.message
           @log.fatal "No such minifyer '#{@minifyer}', aborting"
           raise SystemExit.new("No such minifyer '#{@minifyer}', aborting")
         rescue FileNotFoundError => e
@@ -172,9 +180,17 @@ the YUI Compressor the path should be the path to where the jar file is found.
       #
       def cache_buster(file)
         return nil if !file || file !~ /\.css$/ || @cache_buster.nil?
-        Juicer::CssCacheBuster.new(:web_root => @web_root, :type => @cache_buster, :hosts => @local_hosts)
+        Juicer::CssCacheBuster.new(:document_root => @document_root, :type => @cache_buster, :hosts => @local_hosts)
       end
 
+			#
+			# Load image embed, only available for CSS files
+			# 
+			def image_embed(file)
+        return nil if !file || file !~ /\.css$/ || @image_embed_type.nil?
+        Juicer::ImageEmbed.new( :type => @image_embed_type )
+			end
+
       #
       # Generate output file name. Optional argument is a filename to base the new
       # name on. It will prepend the original suffix with ".min"

data/lib/juicer/command/verify.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "util")
+require "juicer/command/util"
 require "rubygems"
 require "cmdparse"
 require "pathname"

data/lib/juicer/css_cache_buster.rb

@@ -1,5 +1,6 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "chainable"))
-require File.expand_path(File.join(File.dirname(__FILE__), "cache_buster"))
+require "juicer/chainable"
+require "juicer/cache_buster"
+require "juicer/asset/path_resolver"
 
 module Juicer
   #
@@ -12,23 +13,23 @@ module Juicer
   # work.
   #
   # When dealing with CSS files that reference absolute URLs like /images/1.png
-  # you must specify the :web_root option that these URLs should be resolved
+  # you must specify the :document_root option that these URLs should be resolved
   # against.
   #
   # When dealing with full URLs (ie including hosts) you can optionally specify
   # an array of hosts to recognize as "local", meaning they serve assets from
-  # the :web_root directory. This way even asset host cycling can benefit from
+  # the :document_root directory. This way even asset host cycling can benefit from
   # cache busters.
   #
   class CssCacheBuster
     include Juicer::Chainable
 
     def initialize(options = {})
-      @web_root = options[:web_root]
-      @web_root.sub!(%r{/?$}, "") if @web_root # Remove trailing slash
+      @document_root = options[:document_root]
+      @document_root.sub!(%r{/?$}, "") if @document_root
       @type = options[:type] || :soft
-      @hosts = (options[:hosts] || []).collect { |h| h.sub!(%r{/?$}, "") } # Remove trailing slashes
-      @contents = nil
+      @hosts = (options[:hosts] || []).collect { |h| h.sub!(%r{/?$}, "") }
+      @contents = @base = nil
     end
 
     #
@@ -36,20 +37,21 @@ module Juicer
     #
     def save(file, output = nil)
       @contents = File.read(file)
+      self.base = File.dirname(file)
       used = []
 
-      urls(file).each do |url|
+      urls(file).each do |asset|
         begin
-          path = resolve(url, file)
-          next if used.include?(path)
-
-          if path != url
-            used << path
-            basename = File.basename(Juicer::CacheBuster.path(path, @type))
-            @contents.gsub!(url, File.join(File.dirname(url), basename))
-          end
+          next if used.include?(asset.path)          
+          @contents.gsub!(asset.path, asset.path(:cache_buster_type => @type))
         rescue Errno::ENOENT
-          puts "Unable to locate file #{path || url}, skipping cache buster"
+          puts "Unable to locate file #{asset.path}, skipping cache buster"
+        rescue ArgumentError => e
+          if e.message =~ /No document root/
+            raise FileNotFoundError.new("Unable to resolve path #{asset.path} without :document_root option")
+          else
+            raise e
+          end
         end
       end
 
@@ -67,40 +69,22 @@ module Juicer
       @contents = File.read(file) unless @contents
 
       @contents.scan(/url\([\s"']*([^\)"'\s]*)[\s"']*\)/m).collect do |match|
-        match.first
+        path_resolver.resolve(match.first)
       end
     end
 
-    #
-    # Resolve full path from URL
-    #
-    def resolve(target, from)
-      # If URL is external, check known hosts to see if URL can be treated
-      # like a local one (ie so we can add cache buster)
-      catch(:continue) do
-        if target =~ %r{^[a-z]+\://}
-          # This could've been a one-liner, but I prefer to be
-          # able to read my own code ;)
-          @hosts.each do |host|
-            if target =~ /^#{host}/
-              target.sub!(/^#{host}/, "")
-              throw :continue
-            end
-          end
-
-          # No known hosts matched, return
-          return target
-        end
-      end
+    protected
+    def base=(base)
+      @prev_base = @base
+      @base = base
+    end
 
-      # Simply add web root to absolute URLs
-      if target =~ %r{^/}
-        raise FileNotFoundError.new("Unable to resolve absolute path #{target} without :web_root option") unless @web_root
-        return File.expand_path(File.join(@web_root, target))
-      end
+    def path_resolver
+      return @path_resolver if @path_resolver && @base == @prev_base
 
-      # Resolve relative URLs to full paths
-      File.expand_path(File.join(File.dirname(File.expand_path(from)), target))
+      @path_resolver = Juicer::Asset::PathResolver.new(:document_root => @document_root,
+                                                       :hosts => @hosts,
+                                                       :base => @base)
     end
   end
 end

data/lib/juicer/datafy/datafy.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby -w
+
+# Datafy code lifted from http://segment7.net/projects/ruby/datafy/
+
+require 'base64'
+require 'cgi'
+
+module Datafy
+  def Datafy::make_data_uri(content, content_type)
+    outuri = 'data:' + content_type
+    unless content_type =~ /^text/i # base64 encode if not text
+      outuri += ';base64'
+      content = Base64.encode64(content).gsub("\n", '')
+    else
+      content = CGI::escape(content)
+    end
+    outuri += ",#{content}"
+  end
+  
+end

data/lib/juicer/dependency_resolver/css_dependency_resolver.rb

@@ -0,0 +1,29 @@
+require "juicer/dependency_resolver/dependency_resolver"
+
+module Juicer
+
+  # 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(?:\surl\(|\s)(['"]?)([^\?'"\)\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
+
+    def extension
+      ".css"
+    end
+  end
+
+end

data/lib/juicer/dependency_resolver/dependency_resolver.rb

@@ -0,0 +1,101 @@
+module Juicer
+  class DependencyResolver
+    include Enumerable
+    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
+
+    #
+    # Yield files recursively. Resolve dependencies first, then call each, or
+    # any other enumerable methods.
+    #
+    def each(&block)
+      @files.each(&block)
+    end
+
+    #
+    # Resolves a path relative to another. If the path is absolute (ie it
+    # starts with a protocol or /) the <tt>:document_root</tt> options has to be
+    # set as well.
+    #
+    def resolve_path(path, reference)
+      # Absolute URL
+      if path =~ %r{^(/|[a-z]+:)}
+        if @options[:document_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[:document_root], path))
+      end
+
+      File.expand_path(File.join(File.dirname(reference), path))
+    end
+
+    private
+    def parse(line)
+      raise NotImplementedError.new
+    end
+
+    def extension
+      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_path = 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_path = parse(line, imported_path)
+
+          # If a dependency declaration was found
+          if imported_path
+            # Resolves a path relative to the file that imported it
+            imported_path = resolve_path(imported_path, file)
+
+            if File.directory?(imported_path)
+              imported_files = Dir.glob(File.join(imported_path, "**", "*#{extension}"))
+            else
+              imported_files = [imported_path]
+            end
+
+            imported_files.each do |imported_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
+      end
+
+      file = File.expand_path(file)
+      @files << file if !@files.include?(file) && (!block_given? || yield(file))
+    end
+  end
+end