psyho_juicer 1.0.0

data/lib/juicer/command/util.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+module Juicer
+  module Command
+    # Utilities for Juicer command objects
+    #
+    module Util
+      # Returns an array of files from a variety of input. Input may be a single
+      # file, a single glob pattern or multiple files and/or patterns. It may
+      # even be an array of mixed input.
+      #
+      def files(*args)
+        args.flatten.collect { |file| Dir.glob(file) }.flatten
+      end
+
+      #
+      # Uses Pathname to calculate the shortest relative path from +path+ to
+      # +reference_path+ (default is +Dir.cwd+)
+      #
+      def relative(paths, reference_path = Dir.pwd)
+        paths = [paths].flatten.collect do |path|
+          path = Pathname.new(File.expand_path(path))
+          reference_path = Pathname.new(File.expand_path(reference_path))
+          path.relative_path_from(reference_path).to_s
+        end
+
+        paths.length == 1 ? paths.first : paths
+      end
+    end
+  end
+end
+

data/lib/juicer/command/verify.rb

@@ -0,0 +1,60 @@
+require "juicer/command/util"
+require "rubygems"
+require "cmdparse"
+require "pathname"
+
+module Juicer
+  module Command
+    # Verifies problem-free-ness of source code (JavaScript and CSS)
+    #
+    class Verify < CmdParse::Command
+      include Juicer::Command::Util
+
+      # Initializes command
+      #
+      def initialize(log = nil)
+        super('verify', false, true)
+        @log = log || Logger.new($STDIO)
+        self.short_desc = "Verifies that the given JavaScript/CSS file is problem free"
+        self.description = <<-EOF
+Uses JsLint (http://www.jslint.com) to check that code adheres to good coding
+practices to avoid potential bugs, and protect against introducing bugs by
+minifying.
+        EOF
+      end
+
+      # Execute command
+      #
+      def execute(args)
+        # Need atleast one file
+        raise ArgumentError.new('Please provide atleast one input file/pattern') if args.length == 0
+        Juicer::Command::Verify.check_all(files(args), @log)
+      end
+
+      def self.check_all(files, log = nil)
+        log ||= Logger.new($stdio)
+        jslint = Juicer::JsLint.new(:bin_path => Juicer.home)
+        problems = false
+
+        # Check that JsLint is installed
+        raise FileNotFoundError.new("Missing 3rd party library JsLint, install with\njuicer install jslint") if jslint.locate_lib.nil?
+
+        # Verify all files
+        files.each do |file|
+          log.info "Verifying #{file} with JsLint"
+          report = jslint.check(file)
+
+          if report.ok?
+            log.info "  OK!"
+          else
+            problems = true
+            log.warn "  Problems detected"
+            log.warn "  #{report.errors.join("\n").gsub(/\n/, "\n  ")}\n"
+          end
+        end
+
+        !problems
+      end
+    end
+  end
+end

data/lib/juicer/css_cache_buster.rb

@@ -0,0 +1,90 @@
+require "juicer/chainable"
+require "juicer/cache_buster"
+require "juicer/asset/path_resolver"
+
+module Juicer
+  #
+  # The CssCacheBuster is a tool that can parse a CSS file and substitute all
+  # referenced URLs by a URL appended with a timestamp denoting it's last change.
+  # This causes the URLs to be unique every time they've been modified, thus
+  # facilitating using a far future expires header on your web server.
+  #
+  # See Juicer::CacheBuster for more information on how the cache buster URLs
+  # work.
+  #
+  # When dealing with CSS files that reference absolute URLs like /images/1.png
+  # 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 :document_root directory. This way even asset host cycling can benefit from
+  # cache busters.
+  #
+  class CssCacheBuster
+    include Juicer::Chainable
+
+    def initialize(options = {})
+      @document_root = options[:document_root]
+      @document_root.sub!(%r{/?$}, "") if @document_root
+      @type = options[:type] || :soft
+      @hosts = (options[:hosts] || []).collect { |h| h.sub!(%r{/?$}, "") }
+      @contents = @base = nil
+    end
+
+    #
+    # Update file. If no +output+ is provided, the input file is overwritten
+    #
+    def save(file, output = nil)
+      @contents = File.read(file)
+      self.base = File.dirname(file)
+      used = []
+
+      urls(file).each do |asset|
+        begin
+          next if used.include?(asset.path)          
+          @contents.gsub!(asset.path, asset.path(:cache_buster_type => @type))
+        rescue Errno::ENOENT
+          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
+
+      File.open(output || file, "w") { |f| f.puts @contents }
+      @contents = nil
+    end
+
+    chain_method :save
+
+    #
+    # Returns all referenced URLs in +file+. Returned paths are absolute (ie,
+    # they're resolved relative to the +file+ path.
+    #
+    def urls(file)
+      @contents = File.read(file) unless @contents
+
+      @contents.scan(/url\([\s"']*([^\)"'\s]*)[\s"']*\)/m).collect do |match|
+        path_resolver.resolve(match.first)
+      end
+    end
+
+    protected
+    def base=(base)
+      @prev_base = @base
+      @base = base
+    end
+
+    def path_resolver
+      return @path_resolver if @path_resolver && @base == @prev_base
+
+      @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

data/lib/juicer/dependency_resolver/javascript_dependency_resolver.rb

@@ -0,0 +1,23 @@
+require "juicer/dependency_resolver/dependency_resolver"
+
+module Juicer
+  # 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
+
+    def extension
+      ".js"
+    end
+  end
+end

data/lib/juicer/ext/logger.rb

@@ -0,0 +1,5 @@
+class Logger
+  def format_message(severity, datetime, progname, msg)
+    "#{msg}\n"
+  end
+end

data/lib/juicer/ext/string.rb

@@ -0,0 +1,47 @@
+#
+# Additions to core Ruby objects
+#
+
+class String
+
+  unless String.method_defined?(:camel_case)
+    #
+    # Turn an underscored string into camel case, ie this_becomes -> ThisBecomes
+    #
+    def camel_case
+      self.split("_").inject("") { |str, piece| str + piece.capitalize }
+    end
+  end
+
+  unless String.method_defined?(:to_class)
+    #
+    # Treat a string as a class name and return the class. Optionally provide a
+    # module to look up the class in.
+    #
+    def to_class(mod = nil)
+      res = "#{mod}::#{self}".sub(/^::/, "").split("::").inject(Object) do |mod, obj|
+        raise "No such class/module" unless mod.const_defined?(obj)
+        mod = mod.const_get(obj)
+      end
+    end
+  end
+
+  unless String.method_defined?(:classify)
+    #
+    # Turn a string in either underscore or camel case form into a class directly
+    #
+    def classify(mod = nil)
+      self.camel_case.to_class(mod)
+    end
+  end
+
+  unless String.method_defined?(:underscore)
+    #
+    # Turn a camelcase string into underscore string
+    #
+    def underscore
+      self.split(/([A-Z][^A-Z]*)/).find_all { |str| str != "" }.join("_").downcase
+    end
+  end
+end
+

data/lib/juicer/ext/symbol.rb

@@ -0,0 +1,15 @@
+class Symbol
+  #
+  # Converts symbol to string and calls String#camel_case
+  #
+  def camel_case
+    self.to_s.camel_case
+  end
+
+  #
+  # Converts symbol to string and calls String#classify
+  #
+  def classify(mod = nil)
+    self.to_s.classify(mod)
+  end
+end

data/lib/juicer/image_embed.rb

@@ -0,0 +1,129 @@
+require "juicer/chainable"
+require "juicer/cache_buster"
+require "juicer/asset/path_resolver"
+
+module Juicer
+  #
+  # The ImageEmbed is a tool that can parse a CSS file and substitute all
+  # referenced URLs by a data uri
+  # 
+  # - data uri (http://en.wikipedia.org/wiki/Data_URI_scheme)
+  # 
+  # Only local resources will be processed this way, external resources referenced
+  # by absolute urls will be left alone
+  # 
+  class ImageEmbed
+    include Juicer::Chainable
+
+    # The maximum supported limit for modern browsers, See the Readme.rdoc for details
+    SIZE_LIMIT = 32768
+    
+    #
+    # Returns the size limit
+    #
+    def size_limit
+      SIZE_LIMIT
+    end
+
+    def initialize(options = {})
+      @document_root = options[:document_root]
+      @document_root.sub!(%r{/?$}, "") if @document_root # Remove trailing slash
+      @type = options[:type] || :none
+      @contents = nil
+      @hosts = options[:hosts]
+      @path_resolver = Juicer::Asset::PathResolver.new(:document_root => options[:document_root],
+                                                       :hosts => options[:hosts])
+    end
+
+    #
+    # Update file. If no +output+ is provided, the input file is overwritten
+    #
+    def save(file, output = nil)
+      return unless @type == :data_uri
+
+      output_file = output || file
+      @contents = File.read(file)
+      used = []
+
+      @path_resolver = Juicer::Asset::PathResolver.new(:document_root => @document_root,
+                                                       :hosts => @hosts,
+                                                       :base => File.dirname(file))
+
+      assets = urls(file)
+
+      # TODO: Remove "?embed=true" from duplicate urls
+      duplicates = duplicate_urls(assets)
+
+      if duplicates.length > 0
+        Juicer::LOGGER.warn("Duplicate image urls detected, these images will not be embedded: #{duplicates.collect { |v| v.gsub('?embed=true', '') }.inspect}") 
+      end
+
+      assets.each do |asset|
+        begin
+          next if used.include?(asset) || duplicates.include?(asset.path)
+          used << asset
+
+          # make sure we do not exceed SIZE_LIMIT
+          new_path = embed_data_uri(asset.filename)
+
+          if new_path.length < SIZE_LIMIT
+            # replace the url in the css file with the data uri
+            @contents.gsub!(asset.path, embed_data_uri(asset.path))
+          else
+            Juicer::LOGGER.warn("The final data uri for the image located at #{asset.path.gsub('?embed=true', '')} exceeds #{SIZE_LIMIT} and will not be embedded to maintain compatability.") 
+          end
+        rescue Errno::ENOENT
+          puts "Unable to locate file #{asset.path}, skipping image embedding"
+        end
+      end
+
+      File.open(output || file, "w") { |f| f.puts @contents }
+      @contents = nil
+    end
+
+    chain_method :save
+            
+    def embed_data_uri( path )
+      new_path = path
+      
+      if path.match( /\?embed=true$/ )
+        supported_file_matches = path.match( /(?:\.)(png|gif|jpg|jpeg)(?:\?embed=true)$/i )
+        filetype = supported_file_matches[1] if supported_file_matches
+        
+        if ( filetype )        
+          filename = path.gsub('?embed=true','')      
+
+          # check if file exists, throw an error if it doesn't exist
+          if File.exist?( filename )
+            
+            # read contents of file into memory              
+            content = File.read( filename )
+            content_type = "image/#{filetype}"
+            
+            # encode the url
+            new_path = Datafy::make_data_uri( content, content_type )
+          else
+            puts "Unable to locate file #{filename} on local file system, skipping image embedding"
+          end
+        end
+      end
+      return new_path
+    end
+
+    #
+    # Returns all referenced URLs in +file+.
+    #
+    def urls(file)
+      @contents = File.read(file) unless @contents
+
+      @contents.scan(/url\([\s"']*([^\)"'\s]*)[\s"']*\)/m).collect do |match|
+        @path_resolver.resolve(match.first)
+      end
+    end
+
+    private
+    def duplicate_urls(urls)
+      urls.inject({}) { |h,v| h[v.path] = h[v.path].to_i+1; h }.reject{ |k,v| v == 1 }.keys
+    end
+  end
+end