juicer 0.2.0

data/History.txt

@@ -0,0 +1,10 @@
+== 0.2.0 / 2009-xx-xx
+
+* Refactored the minifyers execute method from compress to save
+* Refactored Juicer::Merger::FileMerger -> Juicer::Merger::Base
+* Refactored the mergers and minifyers to be chainable commands.
+* Added Chainable module
+
+== 0.1.0 / 2008-12-17
+
+* Dug up old project and set it up with Mr Bones

data/Manifest.txt

@@ -0,0 +1,58 @@
+History.txt
+Manifest.txt
+Rakefile
+Readme.rdoc
+bin/juicer
+lib/juicer.rb
+lib/juicer/binary.rb
+lib/juicer/cache_buster.rb
+lib/juicer/chainable.rb
+lib/juicer/cli.rb
+lib/juicer/command/install.rb
+lib/juicer/command/list.rb
+lib/juicer/command/merge.rb
+lib/juicer/command/util.rb
+lib/juicer/command/verify.rb
+lib/juicer/core.rb
+lib/juicer/css_cache_buster.rb
+lib/juicer/install/base.rb
+lib/juicer/install/jslint_installer.rb
+lib/juicer/install/rhino_installer.rb
+lib/juicer/install/yui_compressor_installer.rb
+lib/juicer/jslint.rb
+lib/juicer/merger/base.rb
+lib/juicer/merger/css_dependency_resolver.rb
+lib/juicer/merger/dependency_resolver.rb
+lib/juicer/merger/javascript_dependency_resolver.rb
+lib/juicer/merger/javascript_merger.rb
+lib/juicer/merger/stylesheet_merger.rb
+lib/juicer/minifyer/yui_compressor.rb
+tasks/test/setup.rake
+test/bin/jslint.js
+test/bin/rhino1_7R1.zip
+test/bin/rhino1_7R2-RC1.zip
+test/bin/yuicompressor
+test/bin/yuicompressor-2.3.5.zip
+test/bin/yuicompressor-2.4.2.zip
+test/juicer/command/test_install.rb
+test/juicer/command/test_list.rb
+test/juicer/command/test_merge.rb
+test/juicer/command/test_util.rb
+test/juicer/command/test_verify.rb
+test/juicer/install/test_installer_base.rb
+test/juicer/install/test_jslint_installer.rb
+test/juicer/install/test_rhino_installer.rb
+test/juicer/install/test_yui_compressor_installer.rb
+test/juicer/merger/test_base.rb
+test/juicer/merger/test_css_dependency_resolver.rb
+test/juicer/merger/test_javascript_dependency_resolver.rb
+test/juicer/merger/test_javascript_merger.rb
+test/juicer/merger/test_stylesheet_merger.rb
+test/juicer/minifyer/test_yui_compressor.rb
+test/juicer/test_cache_buster.rb
+test/juicer/test_chainable.rb
+test/juicer/test_core.rb
+test/juicer/test_css_cache_buster.rb
+test/juicer/test_jslint.rb
+test/test_helper.rb
+test/test_juicer.rb

data/Rakefile

@@ -0,0 +1,44 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  load 'tasks/test/setup.rake'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'juicer'
+
+task :default => 'test:run'
+
+PROJ.name = 'juicer'
+PROJ.authors = 'Christian Johansen'
+PROJ.email = 'christian@cjohansen.no'
+PROJ.url = 'http://www.cjohansen.no/en/projects/juicer'
+PROJ.version = Juicer::VERSION
+PROJ.rubyforge.name = 'juicer'
+PROJ.readme_file = 'Readme.rdoc'
+PROJ.exclude = %w(tmp$ bak$ ~$ CVS \.svn ^pkg ^doc \.git ^rcov ^test\/data gemspec ^test\/bin$)
+PROJ.rdoc.remote_dir = 'juicer'
+
+PROJ.spec.opts << '--color'
+
+PROJ.gem.extras[:post_install_message] = <<-MSG
+Juicer does not ship with third party libraries. You probably want to install
+Yui Compressor and JsLint now:
+
+juicer install yui_compressor
+juicer install jslint
+
+Happy juicing!
+MSG
+
+CLOBBER.include "test/data"
+
+depend_on 'cmdparse'
+depend_on 'hpricot'
+depend_on 'rubyzip'

data/Readme.rdoc

@@ -0,0 +1,143 @@
+= Juicer
+Official URL: http://github.com/cjohansen/juicer/tree/master
+Christian Johansen (http://www.cjohansen.no)
+
+== DESCRIPTION:
+
+Juicer is a command line tool that helps you ship frontend code for production.
+
+High level overview; Juicer can
+
+* figure out which files depend on each other and merge them together, reducing
+  the number of http requests per page view, thus improving performance
+* use YUI Compressor to compress code, thus improving performance
+* verify that your JavaScript is safe to minify/compress by running JsLint on it
+* cycle asset hosts in CSS files
+* add "cache busters" to URLs in CSS files
+* recalculate relative URLs in CSS files, as well as convert them to absolute
+  (or convert absolute URLs to relative URLs)
+
+== FEATURES:
+
+=== Merging and minifying
+
+Juicer can read @import statements in CSS files and use them to combine all your
+stylesheets into a single file. This file may be minified using the YUI
+Compressor. Eventually it will support other minifying tools too.
+
+Juicer can treat your JavaScript files much the same way too, parsing a comment
+switch @depend, as this example shows:
+
+  /**
+   * My script file
+   *
+   * @depend jquery-1.2.0.js
+   */
+  var myNS = {
+      myObject = {}
+  };
+
+Running <tt>juicer merge</tt> on this file will result in a minified file
+<tt>filename.min.js</tt> containing the file jquery-1.2.0.js (located in the
+same directory) and the code above.
+
+You can use @import (CSS files) and @depend (JavaScript) recursively, effectively
+creating a dependency chain for Juicer to climb and merge.
+
+=== Paths
+
+When merging CSS files, you may want to merge CSS files in different directories.
+You may also want the resulting CSS file to end up in another directory as well.
+Juicer automatically recalculates referenced URLs to reflect this change.
+
+Absolute URLs are not changed by default, but if you provide juicer merge with
+--document-root [DIR] and --relative-urls then absolute URLs are converted to
+URLs relative to output directory. You can also use --absolute-urls to convert
+all URLs to absolute ones.
+
+=== Cache busters
+
+Juicer supports so-called cache busters. A cache buster is a pattern in a path
+whose only purpose is to "trick" browsers to redownload a file when it has
+changed in cases where a far future expires header is used.
+
+There are two types of cache busters; soft ones add a parameter to the URL, like
+so: http://assets/images/1.png?cb1234567890, ie the letters "cb" (as in cache
+buster) and then the timestamp of the files mtime.
+
+Unfortunately, the popular web proxy Squid shipped for some time with a default
+configuration which would not treat a URL as a "new" URL if the only thing changed
+was the GET parameters. For this reason Juicer provides hard cache busters.
+
+Hard cache busters result in URLs such as http://assets/images/1-cb1234567890.png,
+ie URLs that require either renaming of files, or (more conveniently) a web
+server configuration that will forward URLs to the right files anyway.
+
+== PLANNED FEATURES:
+
+Juicer 0.2.0 is the first usable release. Work will continue from here. Improving
+documentation and APIs is one concern, but there are also new features planned:
+
+* Support more minifiers, JsMin (Ruby port), Packer and possibly others
+* Add support for CssTidy to compress CSS files
+* juicer build, a command that can build several files in one swoop using a
+  configuration file
+* juicer doc, a command that produces documentation using YUI Doc or JsDoc
+
+If you have any ideas, feature requests, want to contribute or whatever, fork
+the project on github, or get in touch through christian (at) cjohansen.no.
+
+== SYNOPSIS:
+
+  juicer merge myfile.css
+  -> Produces myfile.min.css which may contain several CSS files, minified
+
+  juicer merge myfile.js
+  -> Produces myfile.min.js, minified and combined
+
+  juicer help
+
+== REQUIREMENTS:
+
+In order to use YUI Compressor and JsMin (requires Rhino) you need Java
+installed and the java executable available on your path.
+
+== INSTALL:
+
+  $ gem install juicer
+  $ juicer install yui_compressor
+
+You need Java installed and available on your PATH. During gem installation,
+Juicer will download and install YUI Compressor, JsLint and Rhino for you.
+
+== For developers
+
+Before running tests you should run
+  rake test:setup
+
+which brings in third party libraries (ie, requires a working network connection)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008-2009 Christian Johansen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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 = '0.2.0'
+  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/binary.rb

@@ -0,0 +1,173 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "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?(:defualt_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)
+      #puts "#{self.command} #{params}"
+      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