ktheory-juicer 1.0.0.ktheory1

data/lib/juicer/cache_buster.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+module Juicer
+  #
+  # Assists in creating filenames that reflect the last change to the file. These
+  # kinds of filenames are useful when serving static content through a web server.
+  # If the filename changes everytime the file is modified, you can safely configure
+  # the web server to cache files indefinately, and know that the updated filename
+  # will cause the file to be downloaded again - only once - when it has changed.
+  #
+  # = Types of cache busters
+  #
+  # == Query string / "soft" cache busters
+  # Soft cache busters require no web server configuration. However, it is not
+  # guaranteed to work in all settings. For example, older default
+  # configurations for popular proxy server Squid does not consider a known URL
+  # with a new query string a new URL, and thus will not download the file over.
+  #
+  # The soft cache busters transforms
+  # <tt>/images/logo.png</tt> to <tt>/images/logo.png?cb=1232923789</tt>
+  #
+  # == Filename change / "hard" cache busters
+  # 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 <tt>/images/logo.png</tt> to <tt>/images/logo-1232923789.png</tt>
+  #
+  # Hard cache busters are guaranteed to work, and is the recommended variant.
+  # An example configuration for the Apache web server that does not require
+  # you to actually change the filenames can be seen below.
+  #
+  #   <VirtualHost *>
+  #       # Application/website configuration
+  #
+  #       # Cache static resources for a year
+  #       <FilesMatch "\.(ico|pdf|flv|jpg|jpeg|png|gif|js|css|swf)$">
+  #           ExpiresActive On
+  #           ExpiresDefault "access plus 1 year"
+  #       </FilesMatch>
+  #
+  #       # Rewrite URLs like /images/logo-cb1234567890.png to /images/logo.png
+  #       RewriteEngine On
+  #       RewriteRule (.*)-cb\d+\.(.*)$ $1.$2 [L]
+  #   </VirtualHost>])
+  #
+  # = Consecutive calls
+  #
+  # Consecutive calls to add a cache buster to a path will replace the existing
+  # cache buster *as long as the parameter name is the same*. Consider this:
+  #
+  #   file = Juicer::CacheBuster.hard("/home/file.png") #=> "/home/file-cb1234567890.png"
+  #   Juicer::CacheBuster.hard(file)                    #=> "/home/file-cb1234567891.png"
+  #
+  #   # Changing the parameter name breaks this
+  #   Juicer::CacheBuster.hard(file, :juicer)           #=> "/home/file-cb1234567891-juicer1234567892.png"
+  #
+  # Avoid this type of trouble simply be cleaning the URL with the old name first:
+  #
+  #   Juicer::CacheBuster.clean(file)                   #=> "/home/file.png"
+  #   file = Juicer::CacheBuster.hard(file, :juicer)    #=> "/home/file-juicer1234567892.png"
+  #   Juicer::CacheBuster.clean(file, :juicer)          #=> "/home/file.png"
+  #
+  # Author::    Christian Johansen (christian@cjohansen.no)
+  # Copyright:: Copyright (c) 2009 Christian Johansen
+  # License::   BSD
+  #
+  module CacheBuster
+    DEFAULT_PARAMETER = "jcb"
+
+    #
+    # Creates a unique file name for every revision to the files contents.
+    # Raises an <tt>ArgumentError</tt> if the file can not be found.
+    #
+    # The type indicates which type of cache buster you want, <tt>:soft</tt>
+    # or <tt>:hard</tt>. Default is <tt>:soft</tt>. If an unsupported value
+    # is specified, <tt>:soft</tt> will be used.
+    #
+    # See <tt>#hard</tt> and <tt>#soft</tt> for explanation of the parameter
+    # argument.
+    #
+    def self.path(file, type = :soft, parameter = DEFAULT_PARAMETER)
+      file = self.clean(file, parameter)
+      filename = file.split("?").first
+      raise ArgumentError.new("#{file} could not be found") unless File.exists?(filename)
+      mtime = File.mtime(filename).to_i
+      type = [:soft, :hard].include?(type) ? type : :soft
+
+      if type == :soft
+        parameter = "#{parameter}=".sub(/^=$/, '')
+        return "#{file}#{file.index('?') ? '&' : '?'}#{parameter}#{mtime}"
+      end
+
+      file.sub(/(\.[^\.]+$)/, "-#{parameter}#{mtime}" + '\1')
+    end
+
+    #
+    # Add a hard cache buster to a filename. The parameter is an optional prefix
+    # that is added before the mtime timestamp. It results in filenames of the form:
+    # <tt>file-[parameter name][timestamp].suffix</tt>, ie
+    # <tt>images/logo-cb1234567890.png</tt> which is the case for the default
+    # parameter name "cb" (as in *c*ache *b*uster).
+    #
+    def self.hard(file, parameter = DEFAULT_PARAMETER)
+      self.path(file, :hard, parameter)
+    end
+
+    #
+    # Add a soft cache buster to a filename. The parameter is an optional name
+    # for the mtime timestamp value. It results in filenames of the form:
+    # <tt>file.suffix?[parameter name]=[timestamp]</tt>, ie
+    # <tt>images/logo.png?cb=1234567890</tt> which is the case for the default
+    # parameter name "cb" (as in *c*ache *b*uster).
+    #
+    def self.soft(file, parameter = DEFAULT_PARAMETER)
+      self.path(file, :soft, parameter)
+    end
+
+    #
+    # Remove cache buster from a URL for a given parameter name. Parameter name is
+    # "cb" by default.
+    #
+    def self.clean(file, parameter = DEFAULT_PARAMETER)
+      query_param = "#{parameter}".length == 0 ? "" : "#{parameter}="
+      new_file = file.sub(/#{query_param}\d+&?/, "").sub(/(\?|&)$/, "")
+      return new_file unless new_file == file
+
+      file.sub(/-#{parameter}\d+(\.\w+)($|\?)/, '\1\2')
+    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,61 @@
+require "juicer/command/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)
+        args.flatten!
+
+        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,57 @@
+require "juicer/command/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(log = nil)
+        super('list', false, true)
+        @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
+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::JavaScriptDependencyResolver.new,
+                  :css => Juicer::CssDependencyResolver.new }
+
+        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]
+
+          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
+end

data/lib/juicer/command/merge.rb

@@ -0,0 +1,205 @@
+require "juicer/command/util"
+require "juicer/command/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
+        @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)
+
+        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 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 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.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" +
+                           (" " * 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
+          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
+
+      # 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 @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
+
+        # Set command chain and execute
+        merger.set_next(image_embed(output)).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 => e
+          @log.fatal e.message
+          @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$/ || @cache_buster.nil?
+        Juicer::CssCacheBuster.new(:web_root => @web_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"
+      #
+      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
+end