sqweeze 0.0.2

data/Manifest

@@ -0,0 +1,20 @@
+Manifest
+README.rdoc
+Rakefile
+bin/sqweeze
+lib/compilers/assetLinker.rb
+lib/compilers/cssDomCompiler.rb
+lib/compilers/jsDomCompiler.rb
+lib/compressor.rb
+lib/compressors/cssCompressor.rb
+lib/compressors/gifCompressor.rb
+lib/compressors/jpegCompressor.rb
+lib/compressors/jsCompressor.rb
+lib/compressors/pngCompressor.rb
+lib/confManager.rb
+lib/domCompiler.rb
+lib/sqweezeUtils.rb
+spec/confManager_spec.rb
+spec/domCompiler_spec.rb
+spec/sqw_spec_helper.rb
+sqweeze.gemspec

data/README.rdoc

@@ -0,0 +1,28 @@
+== Sqweeze 
+A command line web asset optimisation tool. 
+
+=== Features
+
+_Sqweeze_ cuts the unnecessary bytes out of your web assets, helping you delivering your web project more fast and efficiently. 
+With a little help from a number of well known open source third party tools, _Sqweeze_ does the following:
+
+* Lossless compresses .PNG, .JPEG and .GIF image assets. 
+* Compresses and concatenates into single files multiple Stylesheets and Javascript files.
+* Embeds the compressed assets referenced into the stylesheet, using using {Data-uris}[https://developer.mozilla.org/En/The_data_URL_scheme] (for proper browsers and IE8) and {MHTML}[http://en.wikipedia.org/wiki/MHTML] (for IE6-7). 
+* Finally, it provides some basic functionality to linking the compressed Javascript and CSS files back to the document. 
+
+=== Installing it
+
+Sqweeze relies on a few command-line image compression tools, namely Pngcrush, Jpegtrain, and Gifsicle, which have to be installed first. 
+On an Ubuntu box, you can install these by running a single command line
+ 
+  sudo apt-get install pngcrush gifsicle libjpeg-progs  
+
+(Mac OSX users can install the first two as Macports packages. The third (part of libjpeg) instead, has to be 
+{compiled manually}[http://www.phpied.com/installing-jpegtran-mac-unix-linux]. However, Jpegtrain will not be needed as long as you do not have Jpeg files into your project.)
+
+Once installed the requirements above, you can install sqweeze, and its ruby dependencies, through ruby gems
+
+ gem install sqweeze
+
+   

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('sqweeze', '0.0.1') do |p|
+  p.description    = "A command line web-asset optimisation tool"
+  p.url            = "http://github.com/premasagar/sqwidget-builder"
+  p.author         = "Andrea Fiore"
+  p.email          = "and@inventati.org" 
+  p.spec_pattern=['spec']
+  p.ignore_pattern = ["doc/", 'spec/test_dir_sqweezed',"webapp"]
+  p.runtime_dependencies = ['hpricot >= 0.8.2','closure-compiler >=0.2.2','yui-compressor >= 0.9.1']
+
+end
+

data/bin/sqweeze

@@ -0,0 +1,116 @@
+#! /usr/bin/env ruby
+# rubygems
+%w[rubygems yui/compressor closure-compiler hpricot].each{|lib| require lib}
+# ruby standard library
+%w[logger singleton yaml base64 open-uri pathname optparse].each{|lib| require lib}
+
+# add lib sub-directories to load path
+SQWEEZE_DIR=File.expand_path( File.dirname(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(SQWEEZE_DIR) unless $LOAD_PATH.include?(SQWEEZE_DIR)
+['lib','lib/compressor', 'lib/compilers'].each do |sub_dir|
+  $LOAD_PATH.unshift("#{SQWEEZE_DIR}/#{sub_dir}")
+end
+
+%w[sqweezeUtils confManager compressor domCompiler
+   compressors/cssCompressor compressors/jsCompressor compressors/gifCompressor compressors/pngCompressor compressors/jpegCompressor 
+   compilers/cssDomCompiler compilers/jsDomCompiler compilers/assetLinker
+].each{|lib| require lib}
+
+
+
+
+options = {}
+op=OptionParser.new do |opts|
+
+  opts.banner = "Usage: sqweeze [options] SOURCE_DIR [TARGET_DIR]"
+  opts.program_name= 'sqweeze'
+  opts.on("-s", "--optimisation-strategy=ALL_IN_ONE",
+          "JavaScript/CSS optimisation strategy to be adopted ") do |s|
+    raise OptionParser::InvalidArgument unless ['all_inline','all_in_one'].include?(s)
+    options[:optimisation_strategy] = s.downcase.to_sym
+  end
+
+  opts.separator ""
+  opts.separator "File Selection:"  
+  opts.on('-i','--include-files=PATTERN', "Include a file/directory pattern (e.g. images/**/*.png  ) ") do |inc|
+    options[:include_files] = inc
+  end
+  opts.on('-e','--exclude-files=PATTERN', "Exclude a file/directory pattern (e.g. doc/**/*.* )") do |exc|
+    options[:exclude_files] = exc
+  end
+  opts.on('-d','--dom-documents=PATTERN', "Dom document/s to which CSS/JS  should be linked (e.g. **/index.html )") do |dom|
+    options[:dom_documents] = dom
+  end  
+
+  opts.separator ""
+  opts.separator "Image Compression:"
+  opts.on("--[no-]png", "do/do-not use the PNG Compressor ") do |png|  
+    options[:compress_png] = png
+  end
+  opts.on("--[no-]jpeg", "do/do-not use the Jpeg Compressor ") do |jpeg|  
+    options[:compress_jpeg] = jpeg
+  end
+  opts.on("--[no-]gif", "do/do-not use the GIF Compressor ") do |gif|  
+    options[:compress_gif] = gif
+  end
+  opts.separator ""
+  opts.separator "Stylesheets:"
+  
+  opts.on("--[no-]css", "do/do-not use the CSS Compressor ") do |css|  
+    options[:compress_css] = css
+  end
+  opts.on("-m","--mhtml-root=[ABSOLUTE_URL]", 'An absolute url pointing at the project stylesheets directory on the web') do |mr|
+    # raise OptionParser::InvalidArgument unless URI(mr).absolute?
+    options[:mhtml_root] = mr
+  end
+  opts.separator ""
+  opts.separator "JavaScript:"
+  
+  opts.on("--[no-]js", "do/do-not use the JS Compressor ") do |js|  
+    options[:compress_js] = js
+  end
+  opts.on('-a','--append_scripts_to=HEAD', "Append script elements to the HEAD or the BODY of the document") do |elm|
+    options[:append_scripts_to] = elm
+  end  
+  opts.on("-j","--default-js-compressor=YUI", "Sets the default JavaScript compressor (can be either YUI or Closure) ") do |j|
+    raise OptionParser::InvalidArgument unless ['yui','closure'].include?(j.downcase)
+    options[:default_js_compressor] = j.downcase.to_sym
+  end
+
+end
+
+begin 
+  op.parse!
+  Proc.new { puts "Missing SOURCE_DIR argument"; exit(1) }.call unless ARGV[0]
+  Proc.new { puts "source directory #{ARGV[0]} does not exist, please provide a valid path"
+             exit(1) }.call unless File.exists?(ARGV[0])
+  
+
+  $log=Logger.new( STDERR )
+  cm=ConfManager.instance
+  cm.prepare(ARGV[0], ARGV[1], options)
+   
+  # Compress images  
+  { :compress_png => PngCompressor.new, 
+    :compress_gif => GifCompressor.new,
+    :compress_jpeg => JpegCompressor.new   
+  }.each do |opt, cmp|
+       cmp.compress unless cm.get_conf(opt) == false
+  end
+  
+  case cm.get_conf(:optimisation_strategy)
+    when :all_inline
+     puts "not implemented yet.."
+     exit
+
+
+    when :all_in_one 
+      { :compress_js => JsCompressor.new, 
+        :compress_css => CssCompressor.new
+      }.each do |opt, cmp|
+         cmp.compress unless cm.get_conf(opt) == false
+      end
+      # link assets to main HTML file
+      AssetLinker.new.compile unless cm.get_conf(:dom_documents).empty?
+  end
+end

data/lib/compilers/assetLinker.rb

@@ -0,0 +1,33 @@
+class AssetLinker < DOMCompiler
+  
+  def compile
+    iterate_over("link[@rel='stylesheet'], script[@src]") do |elm,doc|
+      # Skip if the script has an absolute link
+      next if elm.get_attribute('src') =~ /^http:\/\// 
+      # Otherwise delete. 
+      elm.parent.children.delete(elm)
+    end    
+    dom_documents.each do |path|
+      # Append concatenated JavaScript file.
+      doc = Hpricot(open(path))
+      doc.search(@cm.get_conf(:append_scripts_to).to_s.downcase).append( "<script type='text/javascript' src='javascripts.min.js'></script>") 
+      
+stylesheets_html=<<EOF     
+      <!--[if lte IE 8]>
+          <link href="stylesheets.min.mhtml.css" rel="stylesheet" />
+      <![endif]-->
+      <!--[if IE 8]>
+          <link href="stylesheets.min.datauri.css" rel="stylesheet" />
+      <![endif]-->
+      <!--[if !IE]>
+         <link href="stylesheets.min.datauri.css" rel="stylesheet" />
+      <![endif]-->
+EOF
+  
+      # Append ie conditional tags
+      doc.search('head').append(stylesheets_html)      
+      write_file(doc.innerHTML,path)
+    end
+  end
+  
+end

data/lib/compilers/cssDomCompiler.rb

@@ -0,0 +1,23 @@
+class CssDomCompiler < DOMCompiler
+  
+  def compile
+    iterate_over('link[@rel="stylesheet"]') do |elm, doc|
+      next unless elm.has_attribute?('href') and not elm.get_attribute('href').nil?
+      
+      fbody=get_resource(elm.get_attribute('href'))
+      
+      # this is a bit convoluted, but it seems to be the right way of doing it
+      elm.parent.children.delete(elm)
+      
+      style_html = "<style type=\"text/css\">\n" + css_cdata(fbody,:compress) + '</style>'
+      doc.search('head').append(style_html)
+ 
+    end
+  end
+
+  
+  def compress(fbody)
+    YUI::CssCompressor.new.compress(fbody)
+  end
+  
+end

data/lib/compilers/jsDomCompiler.rb

@@ -0,0 +1,24 @@
+class JsDomCompiler < DOMCompiler
+  
+  def compile
+    iterate_over('script[@src]') do |element, doc | 
+      
+      res_body=get_resource(element.get_attribute('src'))
+      element.remove_attribute('src')
+      # do the YUI/CLOSURE thing here
+      element.innerHTML=js_cdata(res_body,:compress)
+    end
+  end
+  
+  
+  def compress(fbody)
+   unless @cm.default_js_compressor == :closure
+       compressor, method = YUI::JavaScriptCompressor.new( :munge => true), :compress
+     else
+       compressor, method = Closure::Compiler.new, :compiler
+   end
+     compressor.send(method,fbody)
+  end
+  
+ 
+end

data/lib/compressor.rb

@@ -0,0 +1,128 @@
+# Pseudo-abstract class inherited by all the other classes performing asset-compression operations
+
+class Compressor
+  include SqweezeUtils  
+
+  #  Sets the file extensions that a compressor accepts 
+  # 
+  #  *Note*: As this class cannot be instanciated directly, this method is only used by subclasses. 
+  def initialize(input_file_extensions)
+
+     # Behave as a pseudo abstract class
+     raise "Cannot instantiate #{self.class} directly" if self.class == Compressor
+     
+     @cm=ConfManager.instance
+     @input_file_extensions=input_file_extensions
+    
+
+     # Get the project file list from the configuration manager
+     @input_files=@cm.files
+
+     # The commands used by this compressor,
+     # listed in order of priority  
+     
+     @commands={}
+
+     # Set the default shell command to use for this compressor.
+     # issue: what's the point of calling this default command and not just default..
+     @default_command=nil
+     
+     # whether or not concatenating the input files (it is the case of css and javascripts)      
+     @concatenate_input=false
+     
+     # Store the overall byte weight of the assets, before compressions
+     @byteweight_before = collect_filepaths.inject(0){|sum,f| sum+File.size(f)}
+     
+     #set later, after compression
+     @byteweight_after = 0
+  end
+
+
+  attr_reader :input_file_extensions, #something here 
+              :byteweight_before, 
+              :byteweight_after
+              
+  
+  # Sets the system command to be invoked by the compressor.
+  # 
+  # This raises a runtime error if the third party command cannot be found in the file system.  
+  def set_command(libname,command)
+    
+    raise "missing library #{libname}" unless  @cm.get_conf(:bin_paths).keys.include?(libname)
+    @default_command=libname if @commands.empty?
+    @commands[libname]=command
+  end
+
+  # Turns a string or an array of strings containing several file extension names into regular expressions.
+
+  def filextension2regexpstr(ext=@input_file_extensions)
+     if @input_file_extensions.is_a?(Array) and @input_file_extensions.size > 1
+        "(#{@input_file_extensions.collect{|ext|"\.#{ext}"}.join('|')})$"
+       else
+        "\.#{@input_file_extensions}$"      
+    end
+  end
+
+
+  #  Collects the paths of files having the compressor extension name.
+  def collect_filepaths
+    exp_str = filextension2regexpstr  
+    @cm.files.select{|path| path =~ Regexp.new(exp_str,true)  }
+  end
+
+  # Applies a system command to a list of file paths.
+  #
+  # This method is overridden by both CssCompressor and JsCompressor, as these two classes do not rely on 
+  # command line executable but use ruby bindings to YUI and Google Closure.  
+
+  def process(inputpath,cmd=nil)      
+     output_path =@cm.get_target_path(inputpath)    
+     
+     cl= cmd.gsub('%executable%', @cm.get_conf(:bin_paths)[@default_command]).
+                 gsub('%input%',inputpath).
+                 gsub('%output%', output_path)
+     system(cl)
+     $log.debug("run command #{cl}, pid=#{$?.pid} exitstatus=#{$?.exitstatus}")  
+     output_path
+  end
+
+
+  # Iterates over the list of file paths matching the compressor extension/s and applies the process method to each of them. 
+ 
+  def compress
+    files=@input_files=collect_filepaths
+    
+    # This will consist of only an entry (the concatenated file body)
+    # when compressing javascript or css files 
+
+    files=[concatenate_files] if @concatenate_input
+    cmd= (@commands.empty?)? nil : @commands[ @default_command ]
+
+    files.each do |path|
+      output_path=process(path,cmd)
+      size_check(path,output_path) unless %w(.css .js).include?( File.extname(output_path))   
+    end  
+  end
+  
+  # Makes sure that the byteweight of a compressed file is not larger that the original one.  
+
+  def size_check(input_path,output_path)
+    before_size, after_size = byteweight(input_path), byteweight(output_path)
+      # if the compressed file is bigger than the original one, copy the original in the target dir
+    if after_size < before_size 
+          $log.info("compressed #{input_path} to the #{ compression_percentage(before_size,after_size)}% of its original size  (from: #{before_size} to #{after_size} bytes ) ")
+          @byteweight_after+=after_size
+      else
+          $log.debug("Oppss!!! output(#{after_size}) >= input(#{before_size}), using the original file #{input_path} ")  
+          FileUtils.cp(input_path,output_path)
+          @byteweight_after+=before_size
+      end
+  end
+
+  # Concatenates several files into a single string (used in both CSS and JS compression).
+  
+  def concatenate_files
+    @input_files.collect{|f|File.open(f,'r').read}.join("\n")
+  end
+
+end

data/lib/compressors/cssCompressor.rb

@@ -0,0 +1,103 @@
+# Compresses stylesheets using the YUI compressor, creating three new files in the target directory:
+# [<code>stylesheets.min.css</code>]
+#                  compressed and concatenated stylesheets without embedded assets (suitable for all browsers).
+#
+# [<code>stylesheets.datauir.css</code>]
+#                  compressed and concatenated stylesheets with assets embedded as data-uris (suitable for both Webkit and Geko based browser, and ie8). 
+#
+# [<code>stylesheets.mhtml.css</code>]
+#                  compressed and concatenated stylesheets with assets embedded as data-uris (suitable for IE6 and IE7).
+#
+# *Note*: some of the methods used by this class are copied from Jash kenas's excellent {Jammit}[http://github.com/documentcloud/jammit/], an asset optimisation tool for Rails. 
+
+class CssCompressor < Compressor
+  
+    # 32k maximum size for embeddable images (an IE8 limitation).
+    MAX_IMAGE_SIZE = 32768
+
+    # CSS asset-embedding regexes for URL rewriting.    
+    EMBED_DETECTOR = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
+
+    # MHTML file constants.
+    MHTML_START = "/*\nContent-Type: multipart/related; boundary=\"SQWEEZED_ASSET\"\n"
+    MHTML_SEPARATOR= "--SQWEEZED_ASSET"
+    MHTML_END = "*/\n"
+
+  def initialize
+    super('css')  
+    
+    @concatenate_input=true    
+    @concatenated_file=nil   
+    # This hash is populated while generating the data uris
+    # in order to be reused later in the MHTML file 
+    @assets={}
+    # TODO fonts..
+  end
+
+  def process(input_str,cmd=nil)
+    fout= (@concatenate_input)? "#{@cm.target_dir}/all.min.css" : @cm.get_target_path(inputpath)
+    compressed_output=YUI::CssCompressor.new.compress(input_str)
+    
+    unless compressed_output.chomp.empty?
+     write_file(compressed_output,"#{@cm.target_dir}/stylesheets.min.css") 
+     embed_datauris( compressed_output )     
+     embed_mhtml( compressed_output ) if @cm.get_conf(:mhtml_root) 
+    end
+    # this return is pointless
+    fout
+  end
+
+  
+  
+  private 
+  def mhtml_location(path)
+    p=Pathname.new(path) 
+    p.relative_path_from( Pathname.new(@cm.target_dir)) 
+  end
+
+  def embed_datauris(compressed_css)
+    out=compressed_css.gsub(EMBED_DETECTOR) do |url|
+    compressed_asset_path=remap_filepath($1)
+      mime_t=mime_type(compressed_asset_path)
+      if compressed_asset_path and File.exists?(compressed_asset_path) and File.size(compressed_asset_path) < MAX_IMAGE_SIZE and mime_t
+         base64_asset=encoded_contents( compressed_asset_path ) 
+         $log.debug("file:#{compressed_asset_path}; mime-type: #{mime_type($1)}#")
+         # label the image
+         @assets[ compressed_asset_path ] = base64_asset 
+         "url(\"data:#{mime_t};charset=utf-8;base64,#{base64_asset}\")"
+       else
+         "url(#{$1})"
+      end
+    end
+
+    
+    write_file(out,"#{@cm.target_dir}/stylesheets.min.datauri.css")
+  end
+
+
+  def embed_mhtml(compressed_css)
+    mhtml= MHTML_START
+   
+    @assets.each do |mhtml_loc,base64|
+    mhtml <<"
+#{MHTML_SEPARATOR}  
+Content-location: #{ mhtml_loc  }
+Content-Transfer-Encoding:base64
+
+#{base64}\n"
+    end
+    mhtml << "*/\n"
+    mhtml << compressed_css.gsub(EMBED_DETECTOR) do |css|
+      compressed_asset_path=remap_filepath($1)
+      if compressed_asset_path
+       "url(mhtml:#{@cm.get_conf(:mhtml_root).gsub(/\/$/,'')}/stylesheets.min.mhtml.css!#{mhtml_location( compressed_asset_path)})"
+        else
+        "url(#{$1})"
+      end
+    end
+    
+    write_file(mhtml,"#{@cm.target_dir}/stylesheets.min.mhtml.css")
+  end
+
+end
+

data/lib/compressors/gifCompressor.rb

@@ -0,0 +1,13 @@
+class GifCompressor < Compressor
+   
+  def initialize
+    super('gif')
+
+    set_command(        
+         :gifsicle, '%executable% --optimize < %input% > %output%'
+    )
+  end
+ 
+end
+
+

data/lib/compressors/jpegCompressor.rb

@@ -0,0 +1,6 @@
+class JpegCompressor < Compressor
+  def initialize
+    super(['jpeg','jpg'])
+    set_command(:jpegtran,'%executable% -copy none -optimize -outfile %output% %input%')
+  end
+end

data/lib/compressors/jsCompressor.rb

@@ -0,0 +1,27 @@
+class JsCompressor < Compressor  
+
+  def initialize
+    super('js')
+    @concatenate_input=true
+  end
+
+
+  def process(input_str,cmd=nil)
+   unless @cm.get_conf(:default_js_compressor) == :closure
+        compressor, method = YUI::JavaScriptCompressor.new( :munge => true), :compress
+   else
+        compressor, method = Closure::Compiler.new, :compiler
+   end
+
+   fout= (@concatenate_input)? "#{@cm.target_dir}/javascripts.min.js" : @cm.get_target_path(inputpath)
+
+   File.open(fout,'w') do |f|
+      f.write(compressor.send( method, input_str))
+   end
+    
+   fout
+  end
+ 
+end
+
+

data/lib/compressors/pngCompressor.rb

@@ -0,0 +1,11 @@
+class PngCompressor < Compressor
+   
+  def initialize
+    super('png')
+    set_command(:pngcrush,'%executable% -q -rem text %input% %output%')
+
+  end
+ 
+end
+
+

data/lib/confManager.rb

@@ -0,0 +1,191 @@
+# Main component for handling Sqweeze's file and command-line configuration parameters
+
+
+class ConfManager  
+  include Singleton
+  # Class constructor.  
+  # 
+  # As ConfManager implements the singleton pattern, it is actually instanciated only once. 
+  # The same instance might be retrieved from different places by calling the method: 
+  #
+  # <code>ConfManager.instance()</code>
+ 
+  def initialize  
+    @conf_filename='.sqweeze.yml'
+    @source_dir=nil
+    @target_dir=nil
+    @files=[]
+    
+    @conf={
+      :bin_paths => {},
+      :dom_documents => [],
+      :include_files => [],
+      :exclude_files => [],
+      :compress_png  => true,
+      :compress_jpeg => true,
+      :compress_gif  => true,
+      :compress_js  => true,
+      :compress_css  => true,
+      :append_scripts_to => :head,
+      :default_js_compressor => :yui,
+      :optimisation_strategy => :all_in_one
+    }
+  end   
+  attr_reader :target_dir,:source_dir,
+                :files,:conf_filename,:conf              
+  
+  
+  # Setter method used to populate the <code>@conf</code> attribute with key value pairs.
+  # 
+  # *Note*: string keys are automatically converted to symbols.
+  
+  
+  def set_conf(key,value);@conf[key.to_sym]=value;end
+  
+  # Getter method for retrieving configuration values. 
+  
+  def get_conf(key);@conf[key.to_sym];end
+
+  # Sets the source directory, the target directory, and parse configuration files.
+  #
+  # [source]  the source directory
+  #
+  # [target] the target directory
+  #
+  # [override_conf] a Hash which may be used to override file-based configuration.
+
+  def prepare(source,target=nil,override_conf={})
+    
+    @source_dir=source
+    @target_dir=unless target
+      "#{File.basename(source)}_sqweezed"            
+    else 
+      target 
+    end
+        
+    write_globalconf
+    # Parses the global configuration file in $HOME.
+    parse_conf
+    # Parses the local configuration file in source directory.
+    local_conf=mkpath(@conf_filename)
+    parse_conf(local_conf) if File.exists?(local_conf)
+   
+    # CLI/Overrides of the values already set in config files. 
+    override_conf.each{|k,v| set_conf(k, v)} unless override_conf.empty?
+
+    # Creates the list of the files in the project directory.
+    
+    list_files
+    copy_source
+  end
+ 
+  # Copies the source into the target directory.
+  def copy_source
+    FileUtils.cp_r(@source_dir,@target_dir)
+    # avoid nesting into each other multiple copies of the same directory
+    nested_dir=[@target_dir,File.basename(@source_dir)].join('/')
+    FileUtils.rm_r(nested_dir) if File.directory?(nested_dir)
+  end
+
+  # Remaps a filepath from the source to the target directory.
+  #
+  #  TODO:check if this works with relative paths (i.e. <code>../imgs/bar.png</code>)
+  
+  def get_target_path(infile_path)
+   infile_path.gsub( Regexp.new("^#{@source_dir}"), @target_dir)
+  end
+
+ 
+  # Generates a file pattern suitable to be expanded by ruby's {Dir[]}[http://ruby-doc.org/core/classes/Dir.html] method.
+
+  def mkpath(pattern,dir=@source_dir) 
+    dir.to_a.push(pattern).join('/')
+  end
+  
+  # Defines a global <code>.sqweeze.yml</code> file  and places it in the user's home directory.
+  #
+  # The golobal config files sets the default path of the image compression binaries 
+  # (see @conf[:bin_paths]).
+
+  def write_globalconf
+    unless File.exists?("#{ENV['HOME']}/#{@conf_filename}") 
+         File.open("#{ENV['HOME']}/#{@conf_filename}",'w') do |f|
+           f.write("bin_paths:
+   - pngcrush: /usr/bin/pngcrush
+   - jpegtran: /usr/bin/jpegtran
+   - gifsicle: /usr/bin/gifsicle
+           ")
+           f.close
+         end
+    end
+  end
+    
+  # Parses configuration files and sets user-defined file inclusion/exlusion patterns.
+  
+  def parse_conf(configfile="#{ENV['HOME']}/#{@conf_filename}")
+    $log.debug("Parsing configuration file: #{configfile}") 
+    conf=YAML::load_file( configfile ) 
+     
+    bin_paths={}
+    # do not select commands if their path cannot be found on disk      
+    conf['bin_paths'].each do |h| 
+        if File.exists?(h.values.first)
+          bin_paths[h.keys.first.to_sym] = h.values.first 
+        else
+          $log.warn("Command #{h.keys.first} not found in #{h.values.first}")
+        end
+    end
+    set_conf(:bin_paths,bin_paths) unless bin_paths.empty?
+    
+    # Expand the dom document pattern excluding the files located in the source directory.     
+    if conf['dom_documents']
+      
+      domdoc_file_patterns = Dir[conf['dom_documents']].collect{|f| f.gsub(Regexp.new("^#{@source_dir}"),@target_dir)}
+      set_conf(:dom_documents, domdoc_file_patterns)
+    end
+    
+    # Sets the favourite js compressor ( can either be :yui or :closure, defaults on YUI)
+    compressor = ( conf['default_js_compressor'] == :closure) ?  :closure : :yui
+    set_conf(:default_js_compressor, compressor)
+    
+    # others..
+    %w(include exclude).each {|k| set_conf(k, conf[k].to_a)}
+    %w(optimisation_strategy append_scripts_to).each{|k| set_conf(k,conf[k]) if conf[k]}
+  end
+ 
+  # Explodes the inclusion/exclusion patterns provided by the user into a list, and populates the @files attribute.   
+ 
+  def list_files
+    # unless the user defined file inclusion list is empty, select only the files specified by the user.
+    # Otherwise consider all the files in the project directory as potentially compressible.
+
+    @files = unless get_conf(:include).empty?
+               files=get_files( get_conf(:include));$log.debug("Including #{files.size} file/s from user list")
+               files
+             else 
+               get_files
+    end
+ 
+    # always exclude files explicitly blacklisted by the use 
+    exclude_files=get_files(get_conf(:exclude))
+    
+    
+    $log.debug("Excluding #{exclude_files.size} file/s from user list")
+    @files -= exclude_files
+    $log.info("#{@files.size} file/s found")
+  end
+
+
+  # Get all the files matching an array of patterns 
+  #
+  # (Any file expansion patterns accepted ruby's Dir[] method can be used).
+
+  def get_files(pathlist=['**/*'])
+    pathlist.collect{|pattern|
+ 
+      Dir[ mkpath(pattern)  ].
+           reject{|f|File.directory?(f) or not File.exists?(f)}
+    }.flatten
+  end
+
+ end

data/lib/domCompiler.rb

@@ -0,0 +1,51 @@
+# Pseudo-abstract inherited by all classes doing  dom manipulations
+class DOMCompiler
+  include SqweezeUtils
+  attr_reader :dom_documents
+  
+  def initialize
+     #   @dom_extnames=['.html','.svg']
+     @cm=ConfManager.instance
+     #if @cm.link_assets_to and not @cm.link_assets_to.empty? 
+     @dom_documents=@cm.get_conf(:dom_documents).to_a
+  end
+  # Retrieves a resource, being this either a URL or a file.
+  def get_resource(path_or_url)
+    f=open(remap_filepath(path_or_url))
+    (f.is_a? File)? f.read : f 
+  end
+  # Iterates over a DOM element and allows to apply a custom block over it. 
+  
+  def iterate_over(selector)  
+   @dom_documents.each do |path|
+    doc=Hpricot(open(path))
+    if doc
+      doc.search(selector).each do |element|
+        
+      #$log.debug..
+      yield(element, doc)
+      # save document 
+      #write_file(doc.innerHTML, [@cm.target_dir, File.basename(path) ].join('/') )
+      write_file(doc.innerHTML, path )
+    end
+      else
+      $log.error("DOMCompiler cannot parse #{path}")  
+    end
+   end
+  end
+ 
+  # Wraps a string into CDATA escaped in order to be embedded into a <code><script></code> element.
+  # [text] a text string
+  # [callback] an instance method used to process the string (normally compile).
+  def js_cdata(text,callback)
+     ["\n<!--//--><![CDATA[//><!--", self.send(callback,text), "//--><!]]>\n"].join("\n")
+  end
+   
+  # Wraps a string into CDATA escaped in order to be embedded into a <code><style></code> element.
+  # [text] a text string
+  # [callback] an instance method used to process the string (normally compile).  
+  def css_cdata(text,callback)
+     ["/* <![CDATA[ */", self.send(callback,text), "/* ]]> */\n"].join("\n")
+  end
+ 
+end

data/lib/sqweezeUtils.rb

@@ -0,0 +1,86 @@
+module SqweezeUtils
+  
+  # Mapping from extension to mime-type of all embeddable assets.
+  EMBED_MIME_TYPES = {
+      '.png' => 'image/png',
+      '.jpg' => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif' => 'image/gif',
+      '.tif' => 'image/tiff',
+      '.tiff' => 'image/tiff',
+      '.ttf' => 'font/truetype',
+      '.otf' => 'font/opentype'
+  } 
+  
+  def write_file(fbody,fpath)
+    File.open(fpath,'w') do |f|
+      f.write(fbody)
+      f.close
+    end
+  end
+  
+  # Grab the mime-type of an asset, by filename.
+  def mime_type(asset_path)
+      EMBED_MIME_TYPES[File.extname(asset_path)] if asset_path
+  end
+  
+  # Remaps a file in the source directory to its compressed 
+  # version in the target directory
+  #
+  # if the resource is an absolute URL fine, 
+  # Otherwise, if the resource is a relative url in the source dir, try 
+  # to map it to its compressed version in the target directory
+  
+  def remap_filepath(path)
+    path=Pathname.new(path)
+    parent_dir, path_basename = path.parent, path.basename
+    is_absolute = URI.parse(path).absolute? 
+    unless is_absolute
+       find_file_in_targetdir( [parent_dir, path_basename].join('/'))
+      else 
+       path.to_s
+    end
+  end
+  
+  # Return the Base64-encoded contents of an asset on a single line.
+  def encoded_contents(asset_path)
+      data = open(asset_path, 'rb'){|f| f.read }
+      Base64.encode64(data).gsub(/\n/, '')
+  end  
+  
+  
+   # Gets the byte weight of input strames, wether these are file paths or just strings
+
+  def byteweight(path_or_string)
+      path_or_string="" if path_or_string.nil?
+  
+      if File.exists?(path_or_string)
+         File.size(path_or_string)
+       else
+         bweight=0
+         path_or_string.each_byte{|b|bweight+=1}
+         bweight
+      end
+  end
+  
+  def compression_percentage(before_bweight,after_bweight)
+    sprintf('%.2f',after_bweight/before_bweight.to_f * 100)
+  end
+  
+
+  # Find a file in the target directory
+  # endpath is a string containing parent directory and file name 
+  # (e.g imgs/separator.png)
+  
+  # TODO: rewrite this! (it sucks..)
+
+  def find_file_in_targetdir(endpath)
+    pattern=  [@cm.target_dir,"**/*#{File.extname(endpath)}"].join('/')
+    #puts "searcing for files in #{pattern} ending with #{endpath}"
+    Dir[pattern].find{|path| path =~ Regexp.new("#{endpath}$")}
+  end
+  
+  
+  
+  
+end

data/spec/confManager_spec.rb

@@ -0,0 +1,61 @@
+require 'sqw_spec_helper'
+
+
+describe ConfManager do 
+  context "Starting up" do
+  
+  before(:each) do
+    @cm = ConfManager.instance
+  end
+
+  after(:each) do
+    @cm=nil
+    # clean up config files
+    %w( ENV['home'] test_dir ).each do |f|  
+        f << "/.sqweeze.yml"
+        FileUtils.rm(f) if File.exists?(f) 
+    end
+  end
+  
+  it "Should create a .sqweeze.yml file in the home directory" do  
+      @cm.prepare('test_dir')
+      File.exists?("#{ENV['HOME']}/.sqweeze.yml").should be_true
+  end
+ 
+  it "Should select the list of files provided by the user if the *include:* section of the .sqweeze.yml is not empty" do
+   extra_lines= ["include:","- js/**/*.js",'- color/**/*.png']
+   write_configfile(extra_lines[0..1].join("\n"))
+   @cm.prepare('test_dir')
+   @cm.should have(3).files
+  
+   write_configfile(extra_lines.join("\n"))
+   @cm.prepare('test_dir')
+   @cm.should have(5).files
+  end
+
+  it "Should select all files in the project if the include: section of .sqweeze.yml is left empty" do 
+    project_file_count= Dir['test_dir/**/*'].reject{|f| File.directory?(f)}.size
+    @cm.prepare('test_dir')
+    @cm.should have(project_file_count).files 
+  end
+
+  it "Should always exclude the files specified by the user in the .sqweeze.yml exclude section " do
+    write_configfile(["exclude:","- js/**/*.js"].join("\n"))
+    project_file_count= Dir['test_dir/**/*'].reject{|f| File.directory?(f)}.size
+    @cm.prepare('test_dir')
+    @cm.should have(46).files
+  end
+  
+  it "Should search *dom_documents* in the the target directory " do
+    write_configfile("dom_documents: test_dir/*/page.tpl.php")
+    @cm.prepare('test_dir')
+    @cm.get_conf(:dom_documents).should include('test_dir_sqweezed/tpl/page.tpl.php')
+  end
+  
+ 
+   
+ 
+ 
+ 
+ end 
+end

data/spec/domCompiler_spec.rb

@@ -0,0 +1,41 @@
+require '../lib/confManager'
+require '../lib/DomCompiler'
+require '../lib/jsDomCompiler'
+require '../lib/cssDomCompiler'
+require 'sqw_spec_helper'
+
+describe DOMCompiler do 
+   before(:each) do 
+      wget_webpage('http://www.dreamhost.com/domains.html','dom-testdir') 
+      cm = ConfManager.instance
+      cm.prepare('dom-testdir','dom-testdir-build')
+      @js_c=JSDOMCompiler.new
+    end
+  
+    after(:each) do
+      FileUtils.rm_r('dom-testdir')
+      FileUtils.rm_r('dom-testdir-build')
+    end
+    
+    it "(all subclasses) should look for *dom_documents* in target directory" do     
+      @js_c.should have(1).dom_documents
+      @js_c.dom_documents.should include('dom-testdir-build/index.html')
+    end
+  
+    it "Should fill each script element having a src attribute with the compressed content of the javascript file therin referenciated" do 
+      @js_c.compile
+    
+      Hpricot( open('dom-testdir-build/index.html')).search('script').each do |element|
+        element.innerHTML.should_not be_empty
+        element.get_attribute('src').should be_nil
+      end
+    end
+ 
+    it "Should fill each link tag having a href attribute with the compressed content of the  css file therein referenced" do
+      @css_c=CSSDOMCompiler.new
+      @css_c.compile()
+    end
+    
+end
+
+#

data/spec/sqw_spec_helper.rb

@@ -0,0 +1,24 @@
+     SQW_CONF_FILE='test_dir/.sqweeze.yml'
+     SQW_FBODY=<<EOF
+bin_paths:
+   - pngcrush: /usr/bin/pngcrush
+   - jpegtran: /usr/bin/jpegtran
+   - gifsicle: /usr/bin/gifsicle
+  #- cssembed: /home/and/installed/cssembed.jar
+EOF
+
+  def write_configfile(extra_lines='')
+      fbody = SQW_FBODY + extra_lines
+      f=File.open(SQW_CONF_FILE,'w')
+      f.write( fbody)
+      f.close
+  end
+  
+  def delete_configfile
+    FileUtils.rm_r(SQW_CONF_FILE) if File.exists?(SQW_CONF_FILE)
+  end
+
+  def wget_webpage(url,dir_prefix)
+    domain=URI.parse(url).host
+    system("wget --no-parent --timestamping --convert-links --page-requisites --no-directories --no-host-directories -erobots=off --quiet --directory-prefix=#{dir_prefix} #{url}")           
+  end

data/sqweeze.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sqweeze}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrea Fiore"]
+  s.date = %q{2010-05-01}
+  s.default_executable = %q{sqweeze}
+  s.description = %q{A command line web-asset optimisation tool}
+  s.email = %q{and@inventati.org}
+  s.executables = ["sqweeze"]
+  s.extra_rdoc_files = ["README.rdoc", "bin/sqweeze", "lib/compilers/assetLinker.rb", "lib/compilers/cssDomCompiler.rb", "lib/compilers/jsDomCompiler.rb", "lib/compressor.rb", "lib/compressors/cssCompressor.rb", "lib/compressors/gifCompressor.rb", "lib/compressors/jpegCompressor.rb", "lib/compressors/jsCompressor.rb", "lib/compressors/pngCompressor.rb", "lib/confManager.rb", "lib/domCompiler.rb", "lib/sqweezeUtils.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "bin/sqweeze", "lib/compilers/assetLinker.rb", "lib/compilers/cssDomCompiler.rb", "lib/compilers/jsDomCompiler.rb", "lib/compressor.rb", "lib/compressors/cssCompressor.rb", "lib/compressors/gifCompressor.rb", "lib/compressors/jpegCompressor.rb", "lib/compressors/jsCompressor.rb", "lib/compressors/pngCompressor.rb", "lib/confManager.rb", "lib/domCompiler.rb", "lib/sqweezeUtils.rb", "spec/confManager_spec.rb", "spec/domCompiler_spec.rb", "spec/sqw_spec_helper.rb", "sqweeze.gemspec"]
+  s.homepage = %q{http://github.com/premasagar/sqwidget-builder}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sqweeze", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sqweeze}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A command line web-asset optimisation tool}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<hpricot>, [">= 0", "= 0.8.2"])
+      s.add_runtime_dependency(%q<closure-compiler>, [">= 0.2.2"])
+      s.add_runtime_dependency(%q<yui-compressor>, [">= 0", "= 0.9.1"])
+    else
+      s.add_dependency(%q<hpricot>, [">= 0", "= 0.8.2"])
+      s.add_dependency(%q<closure-compiler>, [">= 0.2.2"])
+      s.add_dependency(%q<yui-compressor>, [">= 0", "= 0.9.1"])
+    end
+  else
+    s.add_dependency(%q<hpricot>, [">= 0", "= 0.8.2"])
+    s.add_dependency(%q<closure-compiler>, [">= 0.2.2"])
+    s.add_dependency(%q<yui-compressor>, [">= 0", "= 0.9.1"])
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: sqweeze
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Andrea Fiore
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-01 00:00:00 +01:00
+default_executable: sqweeze
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: closure-compiler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 2
+        version: 0.2.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yui-compressor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 1
+        version: 0.9.1
+  type: :runtime
+  version_requirements: *id003
+description: A command line web-asset optimisation tool
+email: and@inventati.org
+executables: 
+- sqweeze
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- bin/sqweeze
+- lib/compilers/assetLinker.rb
+- lib/compilers/cssDomCompiler.rb
+- lib/compilers/jsDomCompiler.rb
+- lib/compressor.rb
+- lib/compressors/cssCompressor.rb
+- lib/compressors/gifCompressor.rb
+- lib/compressors/jpegCompressor.rb
+- lib/compressors/jsCompressor.rb
+- lib/compressors/pngCompressor.rb
+- lib/confManager.rb
+- lib/domCompiler.rb
+- lib/sqweezeUtils.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- bin/sqweeze
+- lib/compilers/assetLinker.rb
+- lib/compilers/cssDomCompiler.rb
+- lib/compilers/jsDomCompiler.rb
+- lib/compressor.rb
+- lib/compressors/cssCompressor.rb
+- lib/compressors/gifCompressor.rb
+- lib/compressors/jpegCompressor.rb
+- lib/compressors/jsCompressor.rb
+- lib/compressors/pngCompressor.rb
+- lib/confManager.rb
+- lib/domCompiler.rb
+- lib/sqweezeUtils.rb
+- spec/confManager_spec.rb
+- spec/domCompiler_spec.rb
+- spec/sqw_spec_helper.rb
+- sqweeze.gemspec
+has_rdoc: true
+homepage: http://github.com/premasagar/sqwidget-builder
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sqweeze
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: sqweeze
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A command line web-asset optimisation tool
+test_files: []
+