ktheory-juicer 1.0.0.ktheory1

data/VERSION

@@ -0,0 +1 @@
+1.0.0.ktheory1

data/bin/juicer

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require "rubygems"
+dir = File.dirname(File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__)
+base = File.expand_path(File.join(dir, %w[.. lib juicer]))
+require base
+require File.join(base, "cli")
+
+Juicer::Cli.run(ARGV)

data/lib/juicer.rb

@@ -0,0 +1,70 @@
+require "logger"
+
+module Juicer
+
+  # :stopdoc:
+  VERSION = '1.0.0-a1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  LOGGER = Logger.new(STDOUT)
+  @@home = nil
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the installation directory for Juicer
+  #
+  def self.home
+    return @@home if @@home
+    return ENV['JUICER_HOME'] if ENV['JUICER_HOME']
+    return File.join(ENV['HOME'], ".juicer") if ENV['HOME']
+    return File.join(ENV['APPDATA'], "juicer") if ENV['APPDATA']
+    return File.join(ENV['HOMEDRIVE'], ENV['HOMEPATH'], "juicer") if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+    return File.join(ENV['USERPROFILE'], "juicer") if ENV['USERPROFILE']
+    return File.join(ENV['Personal'], "juicer") if ENV['Personal']
+  end
+
+  # Set home directory
+  #
+  def self.home=(home)
+    @@home = home
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each { |rb| require rb }
+  end
+
+end
+
+Juicer.require_all_libs_relative_to(__FILE__)
+
+class FileNotFoundError < Exception
+end

data/lib/juicer/asset/path.rb

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+
+require "pathname"
+require "juicer/cache_buster"
+
+module Juicer
+  module Asset
+    #
+    # Assets are files used by CSS and JavaScript files. The Asset class provides
+    # tools for manipulating asset paths, such as rebasing, adding cache busters,
+    # and cycling asset hosts.
+    #
+    # Asset::Path objects are most commonly created by <tt>Juicer::Asset::PathResolver#resolve</tt>
+    # which resolves include paths to file names. It is possible, however, to use
+    # the asset class directly:
+    #
+    #   Dir.pwd
+    #   #=> "/home/christian/projects/mysite/design/css"
+    #   
+    #   asset = Juicer::Asset::Path.new "../images/logo.png"
+    #   asset.path
+    #   #=> "../images/logo.png"
+    #   
+    #   asset.rebase("~/projects/mysite/design").path
+    #   #=> "images/logo.png"
+    #   
+    #   asset.filename
+    #   #=> "/home/christian/projects/mysite/design/images/logo.png"
+    #   
+    #   asset.path(:cache_buster_type => :soft)
+    #   #=> "../images/logo.png?jcb=1234567890"
+    #   
+    #   asset.path(:cache_buster_type => :soft, :cache_buster => nil)
+    #   #=> "../images/logo.png?1234567890"
+    #   
+    #   asset.path(:cache_buster => "bustIT")
+    #   #=> "../images/logo.png?bustIT=1234567890"
+    #   
+    #   asset = Juicer::Asset::Path.new "../images/logo.png", :document_root
+    #   #=> "/home/christian/projects/mysite"
+    #   
+    #   asset.absolute_path(:cache_buster_type => :hard)
+    #   #=> "/images/logo-jcb1234567890.png"
+    #   
+    #   asset.absolute_path(:host => "http://localhost")
+    #   #=> "http://localhost/images/logo.png"
+    #   
+    #   asset.absolute_path(:host => "http://localhost", :cache_buster_type => :hard)
+    #   #=> "http://localhost/images/logo-jcb1234567890.png"
+    #
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no)
+    # Copyright:: Copyright (c) 2009 Christian Johansen
+    # License::   BSD
+    #
+    class Path
+      # Base directory to resolve relative path from, see Juicer::Asset::Path#initialize
+      attr_reader :base
+
+      # Hosts served from <tt>:document_root</tt>, see Juicer::Asset::Path#initialize
+      attr_reader :hosts
+
+      # Directory served as root through a web server, see Juicer::Asset::Path#initialize
+      attr_reader :document_root
+
+      @@scheme_pattern = %r{^[a-zA-Z]{3,5}://}
+
+      #
+      # Initialize asset at <tt>path</tt>. Accepts an optional hash of options:
+      #
+      # [<tt>:base</tt>]
+      #     Base context from which asset is required. Given a <tt>path</tt> of
+      #     <tt>../images/logo.png</tt> and a <tt>:base</tt> of <tt>/project/design/css</tt>,
+      #     the asset file will be assumed to live in <tt>/project/design/images/logo.png</tt>
+      #     Defaults to the current directory.
+      # [<tt>:hosts</tt>]
+      #     Array of host names that are served from <tt>:document_root</tt>. May also
+      #     include scheme/protocol. If not, http is assumed.
+      # [<tt>:document_root</tt>]
+      #     The root directory for absolute URLs (ie, the server's document root). This
+      #     option is needed when resolving absolute URLs that include a hostname as well
+      #     as when generating absolute paths.
+      #
+      def initialize(path, options = {})
+        @path = path
+        @filename = nil
+        @absolute_path = nil
+        @relative_path = nil
+        @path_has_host = @path =~ @@scheme_pattern
+        @path_is_absolute = @path_has_host || @path =~ /^\//
+
+        # Options
+        @base = options[:base] || Dir.pwd
+        @document_root = options[:document_root]
+        @hosts = Juicer::Asset::Path.hosts_with_scheme(options[:hosts])
+      end
+
+      #
+      # Returns absolute path calculated using the <tt>#document_root</tt>.
+      # Optionally accepts a hash of options:
+      #
+      # [<tt>:host</tt>] Return fully qualified URL with this host name. May include
+      #                  scheme/protocol. Default scheme is http.
+      # [<tt>:cache_buster</tt>] The parameter name for the cache buster.
+      # [<tt>:cache_buster_type</tt>] The kind of cache buster to add, <tt>:soft</tt>
+      #                               or <tt>:hard</tt>.
+      #
+      # A cache buster will be added if either (or both) of the <tt>:cache_buster</tt>
+      # or <tt>:cache_buster_type</tt> options are provided. The default cache buster
+      # type is <tt>:soft</tt>.
+      #
+      # Raises an ArgumentException if no <tt>document_root</tt> has been set.
+      #
+      def absolute_path(options = {})
+        if !@absolute_path
+          # Pre-conditions
+          raise ArgumentError.new("No document root set") if @document_root.nil?
+
+          @absolute_path = filename.sub(%r{^#@document_root}, '').sub(/^\/?/, '/')
+          @absolute_path = "#{Juicer::Asset::Path.host_with_scheme(options[:host])}#@absolute_path"
+        end
+
+        path_with_cache_buster(@absolute_path, options)
+      end
+
+      #
+      # Return path relative to <tt>#base</tt>
+      #
+      # Accepts an optional hash of options for cache busters:
+      #
+      # [<tt>:cache_buster</tt>] The parameter name for the cache buster.
+      # [<tt>:cache_buster_type</tt>] The kind of cache buster to add, <tt>:soft</tt>
+      #                               or <tt>:hard</tt>.
+      #
+      # A cache buster will be added if either (or both) of the <tt>:cache_buster</tt>
+      # or <tt>:cache_buster_type</tt> options are provided. The default cache buster
+      # type is <tt>:soft</tt>.
+      #
+      def relative_path(options = {})
+        @relative_path ||= Pathname.new(filename).relative_path_from(Pathname.new(base)).to_s
+        path_with_cache_buster(@relative_path, options)
+      end
+
+      #
+      # Returns the original path.
+      #
+      # Accepts an optional hash of options for cache busters:
+      #
+      # [<tt>:cache_buster</tt>] The parameter name for the cache buster.
+      # [<tt>:cache_buster_type</tt>] The kind of cache buster to add, <tt>:soft</tt>
+      #                               or <tt>:hard</tt>.
+      #
+      # A cache buster will be added if either (or both) of the <tt>:cache_buster</tt>
+      # or <tt>:cache_buster_type</tt> options are provided. The default cache buster
+      # type is <tt>:soft</tt>.
+      #
+      def path(options = {})
+        path_with_cache_buster(@path, options)
+      end
+
+      #
+      # Return filename on disk. Requires the <tt>#document_root</tt> to be set if
+      # original path was an absolute one.
+      #
+      # If asset path includes scheme/protocol and host, it can only be resolved if
+      # a match is found in <tt>#hosts</tt>. Otherwise, an exeception is raised.
+      #
+      def filename
+        return @filename if @filename
+
+        # Pre-conditions
+        raise ArgumentError.new("No document root set") if @path_is_absolute && @document_root.nil?
+        raise ArgumentError.new("No hosts served from document root") if @path_has_host && @hosts.empty?
+
+        path = strip_host(@path)
+        raise ArgumentError.new("No matching host found for #{@path}") if path =~ @@scheme_pattern
+
+        dir = @path_is_absolute ? document_root : base
+        @filename = File.expand_path(File.join(dir, path))
+      end
+
+      #
+      # Rebase path and return a new Asset::Path object.
+      #
+      #   asset = Juicer::Asset::Path.new "../images/logo.png", :base => "/var/www/public/stylesheets"
+      #   asset2 = asset.rebase("/var/www/public")
+      #   asset2.relative_path #=> "images/logo.png"
+      #
+      def rebase(base_path)
+        path = Pathname.new(filename).relative_path_from(Pathname.new(base_path)).to_s
+
+        Juicer::Asset::Path.new(path,
+                                :base => base_path,
+                                :hosts => hosts,
+                                :document_root => document_root)
+      end
+
+      #
+      # Returns basename of filename on disk
+      #
+      def basename
+        File.basename(filename)
+      end
+
+      #
+      # Returns basename of filename on disk
+      #
+      def dirname
+        File.dirname(filename)
+      end
+
+      #
+      # Returns <tt>true</tt> if file exists on disk
+      #
+      def exists?
+        File.exists?(filename)
+      end
+
+      #
+      # Accepts a single host, or an array of hosts and returns an array of hosts
+      # that include scheme/protocol, and don't have trailing slash.
+      #
+      def self.hosts_with_scheme(hosts)
+        hosts.nil? ? [] : [hosts].flatten.collect { |host| self.host_with_scheme(host) }
+      end
+
+      #
+      # Assures that a host has scheme/protocol and no trailing slash
+      #
+      def self.host_with_scheme(host)
+        return host if host.nil?
+        (host !~ @@scheme_pattern ? "http://#{host}" : host).sub(/\/$/, '')
+      end
+
+      def <=>(other)
+        filename <=> other.filename
+      end
+
+      private
+      #
+      # Adds cache buster to paths if :cache_buster_type and :cache_buster indicates
+      # they should be added.
+      #
+      def path_with_cache_buster(path, options = {})
+        return path if !options.key?(:cache_buster) && options[:cache_buster_type].nil?
+
+        buster_path = nil
+        type = options[:cache_buster_type] || :soft
+
+        if options.key?(:cache_buster)
+          # Pass :cache_buster even if it's nil
+          buster_path = Juicer::CacheBuster.send(type, filename, options[:cache_buster])
+        else
+          # If :cache_buster wasn't specified, rely on default value
+          buster_path = Juicer::CacheBuster.send(type, filename)
+        end
+
+        path.sub(File.basename(path), File.basename(buster_path))
+      end
+
+      #
+      # Strip known hosts from path
+      #
+      def strip_host(path)
+        hosts.each do |host|
+          return path if path !~ @@scheme_pattern
+
+          path.sub!(%r{^#{host}}, '')
+        end
+
+        return path
+      end
+    end
+  end
+end

data/lib/juicer/asset/path_resolver.rb

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+
+require "juicer/asset/path"
+
+module Juicer
+  module Asset
+    #
+    # Factory class that creates <tt>Juicer::Asset::Path</tt> objects from a common set of
+    # options. Also facilitates asset host cycling on a set of asset paths.
+    #
+    #   path_resolver = Juicer::Asset::PathResolver.new(
+    #                     :document_root => "/var/www",
+    #                     :hosts => ["assets1.mysite.com", "assets2.mysite.com"]
+    #                   )
+    #
+    #   asset = path_resolver.resolve("../images/logo.png")
+    #   asset.document_root
+    #   #=> "/var/www"
+    #   
+    #   asset.absolute_path(path_resolver.cycle_hosts)
+    #   #=> "http://assets1.mysite.com/images/logo.png"
+    #   
+    #   asset = path_resolver.resolve("/favicon.ico")
+    #   asset.absolute_path(path_resolver.cycle_hosts)
+    #   #=> "http://assets2.mysite.com/favicon.ico"
+    #
+    # Author::    Christian Johansen (christian@cjohansen.no)
+    # Copyright:: Copyright (c) 2009 Christian Johansen
+    # License::   BSD
+    #
+    class PathResolver
+      attr_reader :hosts, :document_root, :base
+
+      #
+      # Initialize resolver. All options set on the resolver will be carried on to the
+      # resolved assets.
+      #
+      def initialize(options = {})
+        options[:base] ||= Dir.pwd
+        @options = options
+        @base = options[:base]
+        @hosts = Juicer::Asset::Path.hosts_with_scheme(options[:hosts]) || []
+        @current_host = 0
+        @document_root = @options[:document_root]
+      end
+
+      #
+      # Returns a <tt>Juicer::Asset::Path</tt> object for the given path, and the options
+      # set on the resolver.
+      #
+      def resolve(path)
+        Juicer::Asset::Path.new(path, @options)
+      end
+
+      #
+      # Set new base directory. Will affect any assets resolved from here, but any
+      # assets previously resolved will not be changed
+      #
+      def base=(base)
+        @base = base
+        @options[:base] = base
+      end
+
+      #
+      # Cycle asset hosts. Returns an asset host
+      #
+      def cycle_hosts
+        return nil if @hosts.length == 0
+
+        host = @hosts[@current_host % @hosts.length]
+        @current_host += 1
+
+        host
+      end
+
+      alias host cycle_hosts
+    end
+  end
+end

data/lib/juicer/binary.rb

@@ -0,0 +1,171 @@
+require "juicer/chainable"
+
+module Juicer
+
+  # Defines an abstract implementation of a binary that needs to be "shelled
+  # out" to be run. Provides a starting point when wrapping and API around a
+  # shell binary.
+  #
+  # The module requires the including class to define the default_options
+  # method. It should return a hash of options where options are keys and
+  # default values are the values. Only options defined in this hash will be
+  # allowed to set on the binary.
+  #
+  module Binary
+    # Initialize binary with options
+    # options = Hash of options, optional
+    #
+    def initialize(binary, options = {})
+      @options = self.respond_to?(:default_options) ? default_options.merge(options) : options
+      @opt_set = false
+      @command = nil
+      @binary = binary
+      @path = []
+    end
+
+    def path
+      @path
+    end
+
+    # Run command
+    #
+    def execute(params = nil)
+      cmd = IO.popen("#{self.command} #{params}", "r")
+      results = cmd.gets(nil)
+      cmd.close
+      results
+    end
+
+    # Return the value of a given option
+    # opt = The option to return value for
+    #
+    def get_opt(opt)
+      @options[opt] || nil
+    end
+
+    # Return options as a cli arguments string. Optionally accepts a list of
+    # options to exclude from the generated string
+    #
+    def options(*excludes)
+      excludes = excludes.flatten.collect { |exc| exc.to_sym }
+      @options.inject("") do |str, opt|
+        if opt[1].nil? || excludes.include?(opt[0].to_sym)
+          str
+        else
+          val = opt[1] == true ? '' : opt[1]
+          option = opt[0].to_s
+          option = (option.length == 1 ? "-" : "--") + option.gsub('_', '-')
+          "#{str} #{option} #{val}".strip
+        end
+      end
+    end
+
+    # Set an option. Important: you can only set options that are predefined by the
+    # implementing class
+    # opt = The option to set
+    # value = The value of the option
+    #
+    def set_opt(opt, value)
+      opt = opt.to_sym
+      if @options.key?(opt)
+        @options[opt] = value
+        @opt_set = true
+      else
+        msg = "Illegal option '#{opt}', specify one of: #{@options.keys.join(', ')}"
+        raise ArgumentError.new(msg)
+      end
+    end
+
+    # Performs simple parsing of a string of parameters. All recognized
+    # parameters are set, non-existent arguments raise an ArgumentError
+    #
+    def set_opts(options)
+      options = options.split " "
+      option = nil
+      regex = /^--?([^=]*)(=(.*))?/
+
+      while word = options.shift
+        if word =~ regex
+          if option
+            set_opt option, true
+          end
+
+          if $3
+            set_opt $1, $3
+          else
+            option = $1
+          end
+        else
+          set_opt option, word
+          option = nil
+        end
+      end
+    end
+
+    # Constructs the command to use
+    #
+    def command
+      return @command if !@opt_set && @command
+      @opt_set = false
+      @command = "#{@binary} #{options}"
+    end
+
+    # Locate the binary to execute. The binary is searched for in the
+    # following places:
+    #
+    # 1) The paths specified through my_binary.path << "/usr/bin"
+    # 2) The path specified by the given environment variable
+    # 3) Current working directory
+    #
+    # The name of the binary may be a glob pattern, resulting in +locate+
+    # returning an array of matches. This is useful in cases where the path
+    # is expected to store several versions oof a binary in the same directory,
+    # like /usr/bin/ruby /usr/bin/ruby1.8 /usr/bin/ruby1.9
+    #
+    # +locate+ always returns an array, or nil if no binaries where found.
+    # The result is always all files matching the given pattern in *one* of
+    # the specified paths - ie the first path where the pattern matches
+    # something.
+    #
+    def locate(bin_glob, env = nil)
+      path << ENV[env] if env && ENV.key?(env) && File.exist?(ENV[env])
+      
+      (path << Dir.pwd).each do |path|
+        files = Dir.glob(File.expand_path(File.join(path, bin_glob)))
+        return files unless files.empty?
+      end
+
+      nil
+    end
+
+    # Allows for options to be set and read directly on the object as though they were
+    # standard attributes. compressor.verbose translates to
+    # compressor.get_opt('verbose') and compressor.verbose = true to
+    # compressor.set_opt('verbose', true)
+    def method_missing(m, *args)
+      if @options.key?(m)
+        # Only hit method_missing once per option
+        self.class.send(:define_method, m) do       # def verbose
+          get_opt(m)                                #   get_opt(:verbose)
+        end                                         # end
+
+        return get_opt(m)
+      end
+
+      return super unless m.to_s =~ /=$/
+
+      opt = m.to_s.sub(/=$/, "").to_sym
+
+      if @options.key?(opt)
+        # Only hit method_missing once per option
+        self.class.send(:define_method, m) do      # def verbose=(val)
+          set_opt(opt, args[0])                    #   set_opt(:verbose, val)
+        end                                        # end
+
+        return set_opt(opt, args[0])
+      end
+
+      super
+    end
+  end
+end