juicer 0.2.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 File.join(File.dirname(__FILE__), "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/core.rb

@@ -0,0 +1,59 @@
+#
+# Additions to core Ruby objects
+#
+
+class String
+  #
+  # Turn an underscored string into camel case, ie this_becomes -> ThisBecomes
+  #
+  def camel_case
+    self.split("_").inject("") { |str, piece| str + piece.capitalize }
+  end
+
+  #
+  # 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
+
+  #
+  # 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
+
+  #
+  # Turn a camelcase string into underscore string
+  #
+  def underscore
+    self.split(/([A-Z][^A-Z]*)/).find_all { |str| str != "" }.join("_").downcase
+  end
+end
+
+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
+
+class Logger
+  def format_message(severity, datetime, progname, msg)
+    "#{msg}\n"
+  end
+end

data/lib/juicer/css_cache_buster.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "chainable"))
+require File.expand_path(File.join(File.dirname(__FILE__), "cache_buster"))
+
+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 :web_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
+  # 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
+      @type = options[:type] || :soft
+      @hosts = (options[:hosts] || []).collect { |h| h.sub!(%r{/?$}, "") } # Remove trailing slashes
+      @contents = nil
+    end
+
+    #
+    # Update file. If no +output+ is provided, the input file is overwritten
+    #
+    def save(file, output = nil)
+      @contents = File.read(file)
+
+      urls(file).each do |url|
+        path = resolve(url, file)
+
+        if path != url
+          basename = File.basename(Juicer::CacheBuster.path(path))
+          @contents.sub!(url, File.join(File.dirname(url), basename))
+        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\(([^\)]*)\)/m).collect do |match|
+        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
+
+      # 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
+
+      # Resolve relative URLs to full paths
+      File.expand_path(File.join(File.dirname(File.expand_path(from)), target))
+    end
+  end
+end

data/lib/juicer/install/base.rb

@@ -0,0 +1,186 @@
+require 'hpricot'
+require 'open-uri'
+require 'fileutils'
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. juicer])) unless defined?(Juicer)
+
+module Juicer
+  module Install
+    #
+    # Installer skeleton. Provides basic functionality like figuring out where
+    # to install, create base directories, remove unneeded directories and more
+    # housekeeping.
+    #
+    class Base
+      attr_reader :install_dir
+
+      #
+      # Create new installer
+      #
+      def initialize(install_dir = Juicer.home)
+        @install_dir = install_dir
+        @path = nil
+        @bin_path = nil
+        @name = nil
+        @dependencies = {}
+      end
+
+      #
+      # Returns the latest available version number. Must be implemented in
+      # subclasses. Raises an exception when called directly.
+      #
+      def latest
+        raise NotImplementedError.new("Implement in subclasses")
+      end
+
+      # Returns the path relative to installation path this installer will
+      # install to
+      def path
+        return @path if @path
+        @path = "lib/" + self.class.to_s.split("::").pop.sub(/Installer$/, "").underscore
+      end
+
+      # Returns the path to search for binaries from
+      #
+      def bin_path
+        return @bin_path if @bin_path
+        @bin_path = File.join(path, "bin")
+      end
+
+      #
+      # Returns name of component. Default implementation returns class name
+      # with "Installer" removed
+      #
+      def name
+        return @name if @name
+        @name = File.basename(path).split("_").inject("") { |str, word| (str + " #{word.capitalize}").strip }
+      end
+
+      #
+      # Checks if the component is currently installed.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      def installed?(version = nil)
+        installed = File.exists?(File.join(@install_dir, path, "#{version || latest}"))
+        deps = @dependencies.length == 0 || dependencies.all? { |d, v| d.installed?(v) }
+        installed && deps
+      end
+
+      #
+      # Install the component. Creates basic directory structure.
+      #
+      def install(version = nil)
+        raise "#{name} #{version} is already installed in #{File.join(@install_dir, path)}" if installed?(version)
+        version ||= latest
+        log "Installing #{name} #{version} in #{File.join(@install_dir, path)}"
+
+        if @dependencies.length > 0
+          log "Installing dependencies"
+          dependencies { |dependency, ver| dependency.install(ver) unless dependency.installed?(ver) }
+        end
+
+        # Create directories
+        FileUtils.mkdir_p(File.join(@install_dir, path, "bin"))
+        FileUtils.mkdir_p(File.join(@install_dir, path, version))
+
+        # Return resolved version for subclass to use
+        version
+      end
+
+      #
+      # Uninstalls the given version of the component.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      # If there are no more files left in INSTALLATION_PATH/<path>, the
+      # whole directory is removed.
+      #
+      # This method takes a block and can be used from subclasses like so:
+      #
+      #   def self.uninstall(install_dir = nil, version = nil)
+      #     super do |home_dir, version|
+      #       # Custom uninstall logic
+      #     end
+      #   end
+      #
+      #
+      def uninstall(version = nil)
+        version ||= self.latest
+        install_dir = File.join(@install_dir, path, version)
+        raise "#{name} #{version} is not installed" if !File.exists?(install_dir)
+
+        FileUtils.rm_rf(install_dir)
+
+        yield(File.join(@install_dir, path), version) if block_given?
+
+        files = Dir.glob(File.join(@install_dir, path, "**", "*")).find_all { |f| File.file?(f) }
+        FileUtils.rm_rf(File.join(@install_dir, path)) if files.length == 0
+      end
+
+      #
+      # Download a file to Juicer temporary directory. The file will be kept
+      # until #purge is called to wipe it. If the installer receives a request
+      # to download the same file again, the disk cache will be used unless the
+      # force argument is true (default false)
+      #
+      def download(url, force = false)
+        filename = File.join(@install_dir, "download", path.sub("lib/", ""), File.basename(url))
+        return filename if File.exists?(filename) && !force
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.delete(filename) if File.exists?(filename) && force
+
+        log "Downloading #{url}"
+        File.open(filename, "wb") do |file|
+          webpage = open(url)
+          file.write(webpage.read)
+          webpage.close
+        end
+
+        filename
+      end
+
+      #
+      # Display a message to the user through Juicer::LOGGER
+      #
+      def log(str)
+        Juicer::LOGGER.info str
+      end
+
+      #
+      # Add a dependency. Dependency should be a Juicer::Install::Base installer
+      # class (not instance) OR a symbol/string like :rhino/"rhino" (which will
+      # be expanded unto Juicer::Install::RhinoInstaller). Version is optional
+      # and defaults to latest and greatest.
+      #
+      def dependency(dependency, version = nil)
+        dependency = Juicer::Install.get(dependency) if [String, Symbol].include?(dependency.class)
+
+        @dependencies[dependency.to_s + (version || "")] = [dependency, version]
+      end
+
+      #
+      # Yields depencies one at a time: class and version and returns an array
+      # of arrays: [dependency, version] where dependency is an instance and
+      # version a string.
+      #
+      def dependencies(&block)
+        @dependencies.collect do |name, dependency|
+          version = dependency[1]
+          dependency = dependency[0].new(@install_dir)
+          block.call(dependency, version) if block
+          [dependency, version]
+        end
+      end
+    end
+
+    #
+    # Returns the installer. Accepts installer classes (which are returned
+    # directly), strings or symbols. Strings and symbols may be on the form
+    # :my_module which is expanded to Juicer::Install::MyModuleInstaller
+    #
+    def self.get(nameOrClass)
+      return nameOrClass if nameOrClass.is_a? Class
+      (nameOrClass.to_s + "_installer").classify(Juicer::Install)
+    end
+  end
+end

data/lib/juicer/install/jslint_installer.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. juicer])) unless defined?(Juicer)
+require File.expand_path(File.join(File.dirname(__FILE__), "base"))
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the JSLint library by Douglas Crockford.
+    # Installation downloads the jslintfull.js and rhino.js files and stores
+    # them in the Juicer installation directory.
+    #
+    class JSLintInstaller < Base
+      attr_reader :latest
+
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = "1.0"
+        @website = "http://www.jslint.com/"
+        @path = "lib/jslint"
+        @name = "JsLint"
+        dependency :rhino
+      end
+
+      #
+      # Install JSLint. Downloads the two js files and stores them in the
+      # installation directory.
+      #
+      def install(version = nil)
+        version = super(version)
+        filename = download(File.join(@website, "rhino/jslint.js"))
+        File.copy(filename, File.join(@install_dir, path, "bin", "jslint-#{version}.js"))
+      end
+
+      #
+      # Uninstalls JSLint
+      #
+      def uninstall(version = nil)
+        super(version) do |dir, version|
+          File.delete(File.join(dir, "bin", "jslint-#{version}.js"))
+        end
+      end
+    end
+
+    #
+    # This class makes it possible to do Juicer.install("jslint") instead of
+    # Juicer.install("j_s_lint"). Sugar, sugar...
+    #
+    class JslintInstaller < JSLintInstaller
+    end
+  end
+end