cjohansen-juicer 0.2.0 → 0.2.4

data/lib/juicer/cache_buster.rb

@@ -0,0 +1,45 @@
+module Juicer
+  #
+  # Tool that assists in creating filenames that update everytime the file
+  # contents change. There's two ways of generating filenames, soft and hard.
+  # The point of all this is to facilitate configuring web servers to send
+  # static assets with a far future expires header - improving end user
+  # performance through caching.
+  #
+  # Soft cache busters require no web server configuration, but will not work
+  # as intended with older default configurations for popular proxy server
+  # Squid. The soft busters use query parameters to create unique file names,
+  # and these may not force an update in some cases. The soft cache busters
+  # transforms /images/logo.png to /images/logo.png?cb=1232923789
+  #
+  # Hard cache busters change the file name itself, and thus requires either
+  # the web server to (internally) rewrite requests for these files to the
+  # original ones, or the file names to actually change. Hard cache busters
+  # transforms /images/logo.png to /images/logo-1232923789.png
+  #
+  module CacheBuster
+    #
+    # Creates a unique file name for every revision to the files contents.
+    # Default parameter name for soft cache busters is cb (ie ?cb=<timestamp>)
+    # while default parameter names for hard cache busters is none (ie
+    # file-<timestamp>.png).
+    #
+    def self.path(file, type = :soft, param = :undef)
+      param = (type == :soft ? "jcb" : nil) if param == :undef
+      f = File.new(file.split("?").first)
+      mtime = f.mtime.to_i
+      f.close
+
+      if type == :soft
+        param = "#{param}".length == 0 ? "" : "#{param}="
+        file = file.sub(/#{param}\d+/, "").sub(/(\?|\&)$/, "")
+        "#{file}#{file.index('?') ? '&' : '?'}#{param}#{mtime}"
+      else
+        parts = file.split(".")
+        suffix = parts.pop
+        file = parts.join.sub(/-#{param}\d+/, "")
+        "#{parts.join('.')}-#{param}#{mtime}.#{suffix}"
+      end
+    end
+  end
+end

data/lib/juicer/chainable.rb

@@ -63,6 +63,7 @@ module Juicer
     #
     def next_in_chain=(next_obj)
       @_next_in_chain = next_obj
+      next_obj || self
     end
 
     alias_method :set_next, :next_in_chain=

data/lib/juicer/cli.rb

@@ -1,12 +1,13 @@
-require 'rubygems'
-require 'cmdparse'
+require "cmdparse"
 
 # Command line interpreter for Juicer
 #
 module Juicer
   class Cli
+
     def initialize
-      $verbose = false
+      @log = Juicer::LOGGER
+      @log.level = Logger::INFO
     end
 
     # Set up command parser and parse arguments
@@ -16,13 +17,17 @@ module Juicer
       @cmd.program_name = "juicer"
       @cmd.program_version = Juicer.version.split(".")
 
-      # @cmd.options = CmdParse::OptionParserWrapper.new do |opt|
-      #  opt.separator "Global options:"
-      #  opt.on("--verbose", "Be verbose when outputting info") {|t| $verbose = true }
-      # end
+      @cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+        opt.separator "Global options:"
+        opt.on("-v", "--verbose", "Be verbose when outputting info") { |t| @log.level = Logger::DEBUG }
+        opt.on("-q", "--quiet", "Only log warnings and errors") { |t| @log.level = Logger::WARN }
+      end
 
       add_commands
       @cmd.parse(arguments)
+      @log.close
+    rescue SystemExit
+      exit
     end
 
     # Run CLI
@@ -43,7 +48,7 @@ module Juicer
       if Juicer.const_defined?("Command")
         Juicer::Command.constants.each do |const|
           const = Juicer::Command.const_get(const)
-          @cmd.add_command(const.new) if const.kind_of?(Class)
+          @cmd.add_command(const.new(@log)) if const.kind_of?(Class)
         end
       end
     end

data/lib/juicer/command/install.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "util")
+require "cmdparse"
+require "pathname"
+
+module Juicer
+  module Command
+    # Installs a third party library so Juicer can use it.
+    #
+    class Install < CmdParse::Command
+      include Juicer::Command::Util
+
+      # Initializes command
+      #
+      def initialize(io = nil)
+        super('install', false, true)
+        @io = io || Logger.new(STDOUT)
+        @version = nil
+        @path = Juicer.home
+        self.short_desc = "Install a third party library"
+        self.description = <<-EOF
+Installs a third party used by Juicer. Downloads necessary binaries and licenses
+into Juicer installation directory, usually ~/.juicer
+        EOF
+
+        self.options = CmdParse::OptionParserWrapper.new do |opt|
+          opt.on('-v', '--version [VERSION]', 'Specify version of library to install') { |version| @version = version }
+        end
+      end
+
+      # Execute command
+      #
+      def execute(args)
+        if args.length == 0
+          raise ArgumentError.new('Please provide a library to install')
+        end
+
+        args.each do |lib|
+          installer = Juicer::Install.get(lib).new(@path)
+          path = File.join(installer.install_dir, installer.path)
+          version = version(installer)
+
+          if installer.installed?(version)
+            @io.info "#{installer.name} #{version} is already installed in #{path}"
+            break
+          end
+
+          installer.install(version)
+          @io.info "Successfully installed #{lib.camel_case} #{version} in #{path}" if installer.installed?(version)
+        end
+      end
+
+      # Returns which version to install
+      #
+      def version(installer)
+        @version ||= installer.latest
+      end
+    end
+  end
+end

data/lib/juicer/command/list.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), "util")
+require "cmdparse"
+require "pathname"
+
+module Juicer
+  module Command
+    # Displays a list of files that make up the dependency chain for the input
+    # files/patterns.
+    #
+    class List < CmdParse::Command
+      include Juicer::Command::Util
+
+      # Initializes command
+      #
+      def initialize(io = STDOUT)
+        super('list', false, true)
+        @io = io
+        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
+will be joined by juicer merge.
+
+Input parameters may be:
+  * Single file, ie $ juicer list myfile.css
+  * Single glob pattern, ie $ juicer list **/*.css
+  * Multiple mixed arguments, ie $ juicer list **/*.js **/*.css
+        EOF
+      end
+
+      # Execute command
+      #
+      def execute(args)
+        if args.length == 0
+          raise ArgumentError.new('Please provide atleast one input file/pattern')
+        end
+
+        types = { :js => Juicer::Merger::JavaScriptDependencyResolver.new,
+                  :css => Juicer::Merger::CssDependencyResolver.new }
+
+        files(args).each do |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
+      end
+    end
+  end
+end

data/lib/juicer/command/merge.rb

@@ -1,22 +1,38 @@
-require 'rubygems'
-require 'cmdparse'
-require 'tempfile'
+require File.join(File.dirname(__FILE__), "util")
+require File.join(File.dirname(__FILE__), "verify")
+require "cmdparse"
+require "pathname"
 
 module Juicer
   module Command
     # The compress command combines and minifies CSS and JavaScript files
     #
     class Merge < CmdParse::Command
+      include Juicer::Command::Util
+
       # Initializes compress command
       #
-      def initialize
+      def initialize(log = nil)
         super('merge', false, true)
         @types = { :js => Juicer::Merger::JavaScriptMerger,
                    :css => Juicer::Merger::StylesheetMerger }
-        @output = nil
-        @force = false
-        @minifyer = "yui_compressor"
-        @opts = {}
+        @output = nil                   # File to write to
+        @force = false                  # Overwrite existing file if true
+        @type = nil                     # "css" or "js" - for minifyer
+        @minifyer = "yui_compressor"    # Which minifyer to use
+        @opts = {}                      # Path to minifyer binary
+        @arguments = nil                # Minifyer arguments
+        @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
+        @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
+        @verify = true                  # Verify js files with JsLint
+
+        @log = log || Logger.new(STDOUT)
+
         self.short_desc = "Combines and minifies CSS and JavaScript files"
         self.description = <<-EOF
 Each file provided as input will be checked for dependencies to other files,
@@ -36,35 +52,75 @@ the YUI 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 [OUTPUT]', 'Output filename' ) { |filename| @output = filename }
-          opt.on( '-p', '--path [PATH]', 'Path to compressor binary' ) { |path| @opts[:bin_path] = path }
-          opt.on( '-m', '--minifyer [MINIFYER]', 'Which minifer to use. Currently only supports YUI Compressor' ) { |name| @minifyer = name }
-          opt.on( '-f', '--force', 'Force overwrite of target file' ) { @force = true }
+          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("-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("-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" +
+                           (" " * 37) + "css with this option in cases where files have other extensions.") { |type| @type = type.to_sym }
+          opt.on("-h", "--hosts hosts", "Cycle asset hosts for referenced urls. Comma separated") { |hosts| @hosts = hosts.split(",") }
+          opt.on("-l", "--local-hosts hosts", "Host names that are served from --document-root (can be given cache busters). Comma separated") do |hosts|
+            @local_hosts = hosts.split(",")
+          end
+          opt.on("", "--all-hosts-local", "Treat all hosts as local (ie served from --document-root") { |t| @local_hosts = @hosts }
+          opt.on("-r", "--relative-urls", "Convert all referenced URLs to relative URLs. Requires --document-root if\n" +
+                           (" " * 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("-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
         end
       end
 
       # Execute command
       #
       def execute(args)
-        if args.length == 0
-          raise OptionParser::ParseError.new('Please provide atleast one input file')
+        if (files = files(args)).length == 0
+          @log.fatal "Please provide atleast one input file"
+          raise SystemExit.new("Please provide atleast one input file")
+        end
+
+        # Figure out which file to output to
+        output = output(files.first)
+
+        # Warn if file already exists
+        if File.exists?(output) && !@force
+          msg = "Unable to continue, #{output} exists. Run again with --force to overwrite"
+          @log.fatal msg
+          raise SystemExit.new(msg)
         end
 
-        # If no file name is provided, use name of first input with .min
-        # prepended to suffix
-        @output = @output || args[0].sub(/\.([^\.]+)$/, '.min.\1')
+        # Set up merger to resolve imports and so on. Do not touch URLs now, if
+        # asset host cycling is added at this point, the cache buster WILL be
+        # confused
+        merger = merger(output).new(files, :relative_urls => @relative_urls,
+                                           :absolute_urls => @absolute_urls,
+                                           :web_root => @web_root,
+                                           :hosts => @hosts)
 
-        if File.exists?(@output) && !@force
-          puts "Unable to continue, #{@output} exists. Run again with --force to overwrite"
-          exit
+        # Fail if syntax trouble (js only)
+        if @verify && !Juicer::Command::Verify.check_all(merger.files.reject { |f| f =~ /\.css$/ }, @log)
+          @log.error "Problems were detected during verification"
+          raise SystemExit.new("Input files contain problems") unless @ignore
+          @log.warn "Ignoring detected problems"
         end
 
-        merger = @types[@output.split(/\.([^\.]*)$/)[1].to_sym].new(args)
-        merger.set_next(minifyer)
-        merger.save(@output)
+        # Set command chain and execute
+        merger.set_next(cache_buster(output)).set_next(minifyer)
+        merger.save(output)
 
         # Print report
-        puts "Produced #{@output}"
+        @log.info "Produced #{relative output} from"
+        merger.files.each { |file| @log.info "  #{relative file}" }
+      rescue FileNotFoundError => err
+        # Handle missing document-root option
+        puts err.message.sub(/:web_root/, "--document-root")
       end
 
      private
@@ -72,18 +128,61 @@ the YUI Compressor the path should be the path to where the jar file is found.
       # Resolve and load minifyer
       #
       def minifyer
+        return nil if @minifyer.nil? || @minifyer == "" || @minifyer.downcase == "none"
+
         begin
-          minifyer = @minifyer.split("_").collect { |p| p.capitalize! }.join
-          compressor = Juicer::Minifyer.const_get(minifyer).new(@opts)
+          @opts[:bin_path] = File.join(Juicer.home, "lib", @minifyer, "bin") unless @opts[:bin_path]
+          compressor = @minifyer.classify(Juicer::Minifyer).new(@opts)
+          compressor.set_opts(@arguments) if @arguments
+          @log.debug "Using #{@minifyer.camel_case} for minification"
+
+          return compressor
         rescue NameError
-          puts "No such minifyer '#{minifyer}', aborting"
-          exit
+          @log.fatal "No such minifyer '#{@minifyer}', aborting"
+          raise SystemExit.new("No such minifyer '#{@minifyer}', aborting")
+        rescue FileNotFoundError => e
+          @log.fatal e.message
+          @log.fatal "Try installing with; juicer install #{@minifyer.underscore}"
+          raise SystemExit.new(e.message)
         rescue Exception => e
-          puts e.message
-          exit
+          @log.fatal e.message
+          raise SystemExit.new(e.message)
         end
 
-        compressor
+        nil
+      end
+
+      #
+      # Resolve and load merger
+      #
+      def merger(output = "")
+        @type ||= output.split(/\.([^\.]*)$/)[1]
+        type = @type.to_sym if @type
+
+        if !@types.include?(type)
+          @log.warn "Unknown type '#{type}', defaulting to 'js'"
+          type = :js
+        end
+
+        @types[type]
+      end
+
+      #
+      # Load cache buster, only available for CSS files
+      #
+      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)
+      end
+
+      #
+      # Generate output file name. Optional argument is a filename to base the new
+      # name on. It will prepend the original suffix with ".min"
+      #
+      def output(file = "#{Time.now.to_i}.tmp")
+        @output = File.dirname(file) if @output.nil?
+        @output = File.join(@output, File.basename(file).sub(/\.([^\.]+)$/, '.min.\1')) if File.directory?(@output)
+        @output = File.expand_path(@output)
       end
     end
   end

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
+