juicer 0.2.0

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

@@ -0,0 +1,106 @@
+module Juicer
+  #
+  # Facilitates the chain of responsibility pattern. Wraps given methods and
+  # calls them in a chain.
+  #
+  # To make an object chainable, simply include the module and call the class
+  # method chain_method for each method that should be chained.
+  #
+  # Example is a simplified version of the Wikipedia one
+  # (http://en.wikipedia.org/wiki/Chain-of-responsibility_pattern)
+  #
+  #  class Logger
+  #    include Juicer::Chainable
+  #
+  #    ERR = 3
+  #    NOTICE = 5
+  #    DEBUG = 7
+  #
+  #    def initialize(level)
+  #      @level = level
+  #    end
+  #
+  #    def log(str, level)
+  #      if level <= @level
+  #        write str
+  #      else
+  #        abort_chain
+  #      end
+  #    end
+  #
+  #    def write(str)
+  #      puts str
+  #    end
+  #
+  #    chain_method :message
+  #  end
+  #
+  #  class EmailLogger < Logger
+  #    def write(str)
+  #      p "Logging by email"
+  #      # ...
+  #    end
+  #  end
+  #
+  #  logger = Logger.new(Logger::NOTICE)
+  #  logger.next_in_chain = EmailLogger.new(Logger::ERR)
+  #
+  #  logger.log("Some message", Logger::DEBUG) # Ignored
+  #  logger.log("A warning", Logger::NOTICE)   # Logged to console
+  #  logger.log("An error", Logger::ERR)       # Logged to console and email
+  #
+  module Chainable
+
+    #
+    # Add the chain_method to classes that includes the module
+    #
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #
+    # Sets the next command in the chain
+    #
+    def next_in_chain=(next_obj)
+      @_next_in_chain = next_obj
+      next_obj || self
+    end
+
+    alias_method :set_next, :next_in_chain=
+
+    #
+    # Get next command in chain
+    #
+    def next_in_chain
+      @_next_in_chain ||= nil
+      @_next_in_chain
+    end
+
+   private
+    #
+    # Abort the chain for the current message
+    #
+    def abort_chain
+      @_abort_chain = true
+    end
+
+    module ClassMethods
+      #
+      # Sets up a method for chaining
+      #
+      def chain_method(method)
+        original_method = "execute_#{method}".to_sym
+        alias_method original_method, method
+
+        self.class_eval <<-RUBY
+          def #{method}(*args, &block)
+            @_abort_chain = false
+            #{original_method}(*args, &block)
+            next_in_chain.#{method}(*args, &block) if !@_abort_chain && next_in_chain
+            @_abort_chain = false
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/juicer/cli.rb

@@ -0,0 +1,56 @@
+require "cmdparse"
+
+# Command line interpreter for Juicer
+#
+module Juicer
+  class Cli
+
+    def initialize
+      @log = Juicer::LOGGER
+      @log.level = Logger::INFO
+    end
+
+    # Set up command parser and parse arguments
+    #
+    def parse(arguments = ARGV)
+      @cmd = CmdParse::CommandParser.new(true, true)
+      @cmd.program_name = "juicer"
+      @cmd.program_version = Juicer.version.split(".")
+
+      @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
+    #
+    def self.run(arguments = ARGV)
+      juicer = self.new
+      juicer.parse(arguments)
+    end
+
+   private
+    # Adds commands supported by juicer. Instantiates all classes in the
+    # Juicer::Command namespace.
+    #
+    def add_commands
+      @cmd.add_command(CmdParse::HelpCommand.new)
+      @cmd.add_command(CmdParse::VersionCommand.new)
+
+      if Juicer.const_defined?("Command")
+        Juicer::Command.constants.each do |const|
+          const = Juicer::Command.const_get(const)
+          @cmd.add_command(const.new(@log)) if const.kind_of?(Class)
+        end
+      end
+    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

@@ -0,0 +1,185 @@
+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(log = nil)
+        super('merge', false, true)
+        @types = { :js => Juicer::Merger::JavaScriptMerger,
+                   :css => Juicer::Merger::StylesheetMerger }
+        @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
+
+        @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,
+and those files will be added to the final output
+
+For CSS files the dependency checking is done through regular @import
+statements.
+
+For JavaScript files you can tell Juicer about dependencies through special
+comment switches. These should appear inside a multi-line comment, specifically
+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.
+        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("-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("-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 (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
+
+        # 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)
+
+        # Fail if syntax trouble (js only)
+        if !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
+
+        # Set command chain and execute
+        merger.set_next(cache_buster(output)).set_next(minifyer)
+        merger.save(output)
+
+        # Print report
+        @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
+      #
+      # Resolve and load minifyer
+      #
+      def minifyer
+        return nil if @minifyer.nil? || @minifyer == "" || @minifyer.downcase == "none"
+
+        begin
+          @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
+          @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
+          @log.fatal e.message
+          raise SystemExit.new(e.message)
+        end
+
+        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$/
+        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.sub(/\.([^\.]+)$/, '.min.\1')
+      end
+    end
+  end
+end