lash 0.1.1 → 1.0.1

data/lib/lash/java_script_bundler.rb

@@ -0,0 +1,117 @@
+require 'fileutils'
+require 'lash/files'
+require 'lash/closure_minifier'
+
+module Lash
+  
+  # Bundles JavaScripts into single files or individually minified scripts
+  #
+  # ## Example
+  #
+  #     bundler = JavaScriptBundler.new
+  #     bundler.bundle( "application", :style => :single )      # => bundle_application.js
+  #     bundler.bundle( "demand", :style => :individual )       # => demand/form.min.js
+  #                                                             # => demand/fancybox.min.js
+  #
+  class JavaScriptBundler
+   
+    
+    def initialize( options = nil )
+      @options ||= {}
+      @minifiers = [ options[:minifiers] || ClosureMinifier.new ].flatten
+      @options[:javascripts_path] ||= File.expand_path( File.join( Rails.root, "public/javascripts" ) )
+      @demand_dirs ||= options[:demand_dirs] || ["demand"]      
+      @cdn_dirs ||= options[:cdn_dirs] || ["cdn"]      
+    end
+    
+    # Bundles all the scripts in the {directory}
+    def bundle( directory, options = nil )
+      options = resolve_options( options || {}, directory )
+      files = Lash::Files.recursive_file_list( options[:directory], '.js' )
+      
+      case options[:style]
+      when :single
+        bundle_into_single_script files, options
+      when :individual
+        files = files.reject{ |f| f.end_with? 'min.js' }
+        bundle_individual_scripts files, options
+      end
+    end
+    
+    def bundle_style( directory )
+      infer_style_from_directory directory
+    end
+    
+    private
+    
+      def resolve_directory( directory )
+        File.expand_path( directory, @options[:javascripts_path] )
+      end
+    
+      def infer_style_from_directory( directory )
+        individual = (( @cdn_dirs || [] ) + ( @demand_dirs || [] )).map{ |d| resolve_directory d }
+        individual.include?( directory ) ? :individual : :single
+      end
+    
+      def resolve_options( options, directory )
+        options[:directory] = resolve_directory( directory )
+        options[:style] ||= infer_style_from_directory( options[:directory] )
+        options[:target_dir] ||= @options[:javascripts_path]
+        options[:log] = @options[:log] unless options.has_key? :log
+        options
+      end
+      
+      def bundle_into_single_script( files, options )
+        bundle_scripts_with_best_minifier( files, options )
+      end
+      
+      def bundle_individual_scripts( files, options )
+        files.each do |f|
+          unless bundle_scripts_with_best_minifier( [f], options )
+            return false
+          end
+        end
+      end
+      
+      def bundle_scripts_with_best_minifier( files, options )
+        targets = []
+        @minifiers.each do |m|
+          target = bundle_scripts_with_minifier( files, options, m )          
+          targets << target if target
+        end
+
+        return nil unless targets.length > 0
+        
+        migrate_best_target( targets, options.merge({
+          :target_bundle => bundle_target_name( files, options )
+        }))        
+        true
+      ensure
+        targets.each { |f| FileUtils.rm_f f }
+      end
+      
+      def bundle_target_name( files, options )
+        options[:style] == :single \
+            ? File.join( options[:target_dir], "bundle_#{File.basename( options[:directory] ).parameterize}.js" )
+            : File.join( options[:directory], "#{File.basename( files.first, '.js' )}.min.js" )
+      end
+      
+      def migrate_best_target( targets, options )
+        smallest = targets.min_by { |f| File.size( f ) }
+        FileUtils.mv smallest, options[:target_bundle], :force => true
+        FileUtils.mv smallest + '.gz', options[:target_bundle] + '.gz', :force => true if File.exist? smallest + ".gz"
+        
+        puts "Bundled to #{options[:target_bundle]}" if options[:log]
+      end
+      
+      def bundle_scripts_with_minifier( files, options, minifier )
+        target = bundle_target_name( files, options ) + ".#{minifier.class.name.parameterize}"
+        if minifier.minify( files, target )
+          target
+        else
+          nil
+        end        
+      end
+    
+  end
+end

data/lib/lash/java_script_minifier.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+
+module Lash
+  # Utility class for minifying a set of javascript sources
+  class JavaScriptMinifier 
+    
+    attr_accessor :options
+    
+    def initialize
+      @options = {}
+    end
+    
+    # Compresses array of files into a single target minified script.
+    def minify( files, target )
+      target = File.expand_path( target )
+      outdir = File.dirname( target )
+      
+      FileUtils.mkdir_p outdir
+      
+      if minify_scripts( files, target )
+        gzip_bundle target
+      end
+    end
+    
+    private
+      def command_options
+        return unless @options
+        @options.inject("") do |o,p|
+          v = if p[1]
+            "#{p[0]} #{p[1]}"
+          else
+            p[0]
+          end
+          o = o + " " if o.length > 0
+          o + v
+        end
+      end
+    
+      def minify_scripts( files, target )
+        tmp = "#{target}.tmp"
+        bundle_scripts files, tmp
+        File.delete target if File.exist? target
+        File.rename tmp, target
+      end
+      
+      def bundle_scripts( files, bundle_target )
+        File.open( bundle_target, "w+" ) do |t|          
+          files.each do |file|
+            File.open( file, "rb" ) do |f|
+              t.write ";\n"
+              t.write f.read
+            end
+          end          
+        end
+      end
+      
+      def temporary_bundle_file_for_target( target )
+        
+      end
+    
+      def gzip_bundle( target )
+        %x{gzip -c -9 "#{target}" > "#{target}.gz"}
+        File.size "#{target}.gz"
+      end
+    
+  end
+end

data/lib/lash/railtie.rb

@@ -1,8 +1,9 @@
 require 'lash'
+require 'lash/assets_host'
 require 'rails'
-require 'grit'
 
 module Lash
+  # Adds Lash helper methods to your rails application. See {Lash::AssetsHost} for more details.
   class Railtie < Rails::Railtie
 
     rake_tasks do
@@ -15,38 +16,8 @@ module Lash
     end
     
     initializer "lash.setup_git_asset_id", :before => "action_controller.set_configs" do |app|
-      repo = Grit::Repo.new( Rails.root.to_s )
-
-      ENV['RAILS_ASSET_ID'] = \
-      [:javascripts, :stylesheets, :images] \
-        .map { |folder| repo.log( 'master', "public/#{folder}", :max_count => 1 ).first } \
-        .max_by { |log| log.committed_date }
-        .id
-
-      app.config.action_controller.asset_host = Proc.new do |source,request|
-        if /\/\// =~ source
-          nil
-        elsif request.ssl? and ! Lash.lash_options[:use_asset_servers_in_ssl]
-          nil
-        elsif !Lash.lash_options[:use_asset_servers]
-          nil
-        else
-
-          # Change the host name to include a randomized asset name at the same domain
-          # level. This is required so that HTTPS requests can use a wildcard domain
-          # without using subject alt name.
-
-          host = request.host_with_port
-          parts = host.split( /\./ )
-          if parts.length > 2 
-            parts[0] = "#{parts[0]}-assets#{source.hash % 4}"
-          else
-            parts.unshift "assets#{source.hash % 4}"
-          end
-
-          "http#{'s' if request.ssl?}://#{parts.join('.')}"
-        end
-      end
+      AssetsHost.use_git_asset_id      
+      app.config.action_controller.asset_host = AssetsHosts.resolve_static_asset_server_for_source
     end
     
   end

data/lib/lash/sprite_bundler.rb

@@ -0,0 +1,132 @@
+require 'lash'
+require 'lash-sprites/sprite'
+require 'lash-sprites/css'
+require 'lash/assets_host'
+require 'fileutils'
+
+module Lash
+  # Bundles a series of loose images into a single CSS sprite and generates a corresponding CSS support
+  # files
+  class SpriteBundler
+    
+    # Bundles the images in the given directory into a single large CSS sprite image
+    #
+    # @param [String] directory the directory of images to bundle into a sprite
+    #
+    # @option options [Boolean] :sass         Generate a SASS script for importing into a master.scss script
+    # @option options [Boolean] :class_name   The css class name, defaults to name of directory
+    # @option options [Boolean] :sprite_file  The name of the png sprite to generate. Defaults to `#{directory}-sprite.png`
+    # @option options [Boolean] :css_file     The name of the CSS file to generate
+    #
+    # @example
+    #
+    #     bundler.bundle "ui"         # => public/images/ui-sprite.png
+    #                                 # => public/sprites/sass/_ui-sprite.scss 
+    def bundle( directory, options = nil )
+      options = resolve_options( options || {}, directory )
+      
+      sprite = create_sprite_image( options )
+      generate_css( sprite, options )      
+
+      puts "=> bundled css at #{ Lash::Files.relative_to( options[:css_file], Rails.root )}" if options[:log]
+    end
+    
+    private
+      def resolve_options( options, directory )
+        options[:directory]     =   File.expand_path( directory, File.join( Rails.root, "public/sprites" ) )
+        options[:sass]          =   Lash.lash_options[:use_sass] unless options.has_key?(:sass) or !Gem.available?(:sass)
+        options[:class_name]    ||= ( File.basename( directory ) ).parameterize
+        options[:sprite_name]   ||= ( File.basename( directory ) + '-sprite' ).parameterize
+        options[:sprite_file]   ||= File.join( Rails.root, "public/images", "#{options[:sprite_name]}.png")
+        options[:css_file]      ||= options[:sass] \
+          ? File.join( Rails.root, 'public/stylesheets/sass/', "_#{options[:sprite_name]}.scss" )
+          : File.join( Rails.root, 'public/stylesheets/', "#{options[:sprite_name]}.css" )
+        options
+      end
+      
+      def create_sprite_image( options )
+        sprite_files  = Lash::Files.recursive_file_list( options[:directory], /\.(jpe?g|png|gif)$/ )
+        FileUtils.rm_rf( options[:sprite_file] )
+        sprite = RubySprites::Sprite.new( Lash::Files.relative_to( options[:sprite_file], Rails.root ), 
+                                          Rails.root, 
+                                          :graphics_manager => :rmagick,
+                                          :pack_type => 'both_smart' )
+
+        sprite_files.each do |f|
+          sprite.add_image( Lash::Files.relative_to( f, Rails.root ) )
+        end
+
+        sprite.update
+        `#{File.expand_path ::File.join( __FILE__, '../../../bin/optipng')} -o7 \"#{sprite.filename}\"` if File.exists? sprite.filename
+        
+        
+        sprite
+      end
+    
+      def load_css_template( sprite_dir, template_name )
+        css_template_file = File.join( sprite_dir, template_name );
+        return IO.read(css_template_file) if File.exists? css_template_file
+        nil
+      end
+
+      # Generates the acutal CSS sprite file
+      def generate_css( sprite, options )
+        width, height = best_width_and_height( sprite )
+    
+        asset_id = Lash::AssetsHost.asset_id( options[:sprite_file] )
+        png_file = sprite.filename[6,sprite.filename.size-6]
+        css = eval ( load_css_template( options[:directory], "template.css" ) ||
+        '"
+.#{options[:class_name]}-background { 
+    background-image: url(..#{png_file}?#{asset_id}); 
+    background-repeat: no-repeat;
+}
+
+.#{options[:class_name]} { 
+  background-color: transparent;
+  background-image: url(..#{png_file}?#{asset_id}); 
+  background-repeat: no-repeat;
+  overflow: hidden;
+  text-indent: 99999px;
+  *text-indent: 999px; // IE 7 fix
+  text-align: left!important;
+  width: #{width}px;
+  height: #{height}px;
+}
+
+"' )
+    
+        css_sprite_template = load_css_template( options[:directory], "sprite-template.css" ) || '
+          ".#{options[:class_name]}-#{name} { background-position: -#{image.x}px -#{image.y}px;#{ "width: #{image.width}px; " if image.width != width }#{ "height: #{image.height}px; " if image.height != height } }\n" 
+        '
+    
+        sprite.images.each do |path, image|
+          name = File.basename( path )
+          name = name[ 0, name.rindex( '.' ) ].gsub( '/', '-' )
+          css += eval css_sprite_template
+        end
+    
+        FileUtils.mkdir_p File.dirname( options[:css_file] )
+    
+        fp = File.open( options[:css_file], 'w+' )
+        fp.write( css )
+        fp.close
+      end
+      
+      # Calculate most common width and height so sprites can default to most common dimensions
+      def best_width_and_height( sprite )
+        width_freq, height_freq = {}, {}
+    
+        sprite.images.each do |path,image|
+          next unless image.width and image.height
+    
+          width_freq[image.width] = ( width_freq[image.width] || 0 ) + 1
+          height_freq[image.height] = ( height_freq[image.height] || 0 ) + 1
+        end
+    
+        [ width_freq.max_by { |e| e[1] }[0], height_freq.max_by { |e| e[1] }[0] ]
+      end
+    
+    
+  end
+end

data/lib/lash/tasks/lash.rake

@@ -1,5 +1,4 @@
-require 'lash-sprites/sprite'
-require 'lash-sprites/css'
+require 'lash'
 require 'fileutils'
 if Lash.lash_options[:use_sass]
   require 'sass'
@@ -15,128 +14,77 @@ namespace :lash do
   task :all => [:js, :css]
 
   cdn_dirs = ['cdn']
-  minify_dirs = ['demand']
+  demand_dirs = ['demand']
+  bundler = Lash::JavaScriptBundler.new :cdn_dirs => cdn_dirs, :demand_dirs => demand_dirs, :log => true
+  
   @bin_path = File.expand_path( File.join( __FILE__, '../../../../bin' ) )
   
-  exclude_dirs = cdn_dirs + minify_dirs
-
   javascripts_path = File.join( ::Rails.root, 'public', 'javascripts', '' )
+
+  CLEAN.include( "#{javascripts_path}/**/bundle_*.js")
   CLEAN.include( "#{javascripts_path}/**/*.gz")
   CLEAN.include( "#{File.join ::Rails.root, 'public/stylesheets' }/**/*.gz")
 
   desc 'Bundles and minifies javascripts'
   task :js => [:js_bundle, :js_min]
   
+  # Creates an application.bundleVersion.js file
+  task :js_bundle_version do
+    target = File.join( Rails.root, "public/javascripts/application" )
+    if File.exist? target
+      asset_id = Lash::AssetsHost.asset_id( target )
+      File.open( File.join( target, "application.bundleVersion.js" ), "w+" ) { |f| f.write "window.bundleVersion = '#{asset_id}';"}
+    end
+  end
+  
   desc 'Bundles javascripts folders into single minified files'
-  task :js_bundle do    
-    
-    paths = get_top_level_directories( javascripts_path )
-    paths.each do |bundle_directory|
-      bundle_name = bundle_directory.gsub( javascripts_path, "")
-      
-      next if exclude_dirs.include? bundle_name
-      
-      files = recursive_file_list( bundle_directory, ".js" )
-      next if files.empty?
-      
-      target = File.join( javascripts_path, "bundle_#{bundle_name}.js" )
-      
-      compile_js files, target
+  task :js_bundle => [:js_bundle_version] do    
+    Lash::Files.get_top_level_directories( javascripts_path ).each do |bundle_directory|
+      next unless bundler.bundle_style( bundle_directory ) == :single
+      bundler.bundle bundle_directory, :log => true
     end
   end 
   
-  desc 'Minifies all javascripts'
-  task :js_min do
-            
-    paths = get_top_level_directories( javascripts_path )
-    
-    paths.each do |bundle_directory|
-      bundle_name = bundle_directory.gsub( javascripts_path, "")
-      next unless minify_dirs.include? bundle_name
-      
-      recursive_file_list(bundle_directory,'.js').reject{|f| f =~ /\.min\.js$/}.each do |file|
-        compile_js( [file], 
-                    file.gsub( /.js$/, ".min.js" ) )
-      end
+  desc 'Minifies all loose javascripts'
+  task :js_min => [:js_bundle_version] do
+    Lash::Files.get_top_level_directories( javascripts_path ).each do |bundle_directory|
+      next unless bundler.bundle_style( bundle_directory ) == :individual
+      bundler.bundle bundle_directory
     end
   end
   
-  desc 'Compresses minified javascripts for nginx gzip_static support'
+  desc 'Compresses all javascripts for nginx gzip_static support'
   task :js_gzip do |t|
     Dir[ File.join Rails.root, 'public/javascripts/**/*.js' ].each do |file|
+      next unless bundler.bundle_style( File.dirname( file ) ) == :individual
       %x{gzip -c -9 "#{file}" > "#{file}.gz" }
     end
   end
   
-  def compile_js(files,target)
-    
-    tmp_file = File.join( Rails.root, 'tmp', File.basename( target, '.js' ) );
-    packs = []
-    
-    %W{ closure }.each do |packer|
-      packs << pack = { 
-        :file => "#{tmp_file}_#{packer}",
-      }
-            
-      self.send "compile_js_#{packer}", files, pack[:file]
-      %x{gzip -c -9 "#{pack[:file]}" > "#{pack[:file]}.gz" }
-      pack[:size] = File.size "#{pack[:file]}.gz"
+  desc 'Generate CSS sprites from the public/sprites folders'
+  task :sprites do |t|
+    sprites_folder = File.join( Rails.root, "public/sprites" )
+    if File.exist? sprites_folder
+      sprite_bundler = Lash::SpriteBundler.new
+      Lash::Files.get_top_level_directories( sprites_folder ).each do |bundle_directory|
+        sprite_bundler.bundle bundle_directory, :log => true
+      end
     end
-    
-    smallest = packs.min{ |a,b| a[:size] <=> b[:size] }[:file]
-    
-    FileUtils.cp smallest, target
-    FileUtils.cp "#{smallest}.gz", "#{target}.gz"
-    puts "=> bundled js at #{target}"
-
-  ensure
-    packs.each { |pack| 
-      File.delete pack[:file] if File.exist? pack[:file] 
-      File.delete "#{pack[:file]}.gz" if File.exist? "#{pack[:file]}.gz"
-      }
   end
   
-  
-  
-  def compile_js_closure(files,target)
-    closure_path = File.join( @bin_path, 'closure-compiler/compiler.jar' )
-    `java -jar \"#{closure_path}\" --warning_level QUIET --js \"#{files.join("\" --js \"")}\" --js_output_file \"#{target}\"`
-    abort "Could not minify files #{files.join(", ")}" unless $?.exitstatus
-  end
-
-  desc 'Generate CSS sprites from the public/sprites folders'
-  task :css_sprites do |t|
-    
-    Dir[  'public/sprites/*' ].select{ |d| File.directory? d }.each do |sprite_dir|
-      
-      sprite_name   = ( File.basename( sprite_dir ) + '-sprite' ).gsub(' ', '-')
-      css_file      = File.join( 'public/stylesheets/sass/', "_#{sprite_name}.scss" )
-      sprite_files  = FileList[ File.join( sprite_dir, '*.*' ) ].exclude(/.*\.css$/)
-
-      sprite_file   = "public/images/#{sprite_name}.png";
-      FileUtils.rm_rf( File.join( Rails.root, sprite_file ) )
-
-      sprite = RubySprites::Sprite.new( "public/images/#{sprite_name}.png", 
-                                        Rails.root, 
-                                        :graphics_manager => :rmagick,
-                                        :pack_type => 'both_smart' )
-      
-      sprite_files.each do |f|
-        sprite.add_image( f )
+  desc 'Pre-generate sass scripts' if Lash.lash_options[:use_sass]
+  task :sass do |t|
+    if Lash.lash_options[:use_sass]
+      sass_target = File.join( Rails.root, "public/stylesheets/sass" )
+      if File.exist? sass_target
+        asset_id = Lash::AssetsHost.asset_id( sass_target ) 
+        File.open( File.join( sass_target, "_version.scss" ), "w+" ) { |f| f.write "$bundle-version: '#{asset_id}';"}
       end
-
-      sprite.update
-      generate_css( sprite, File.basename( sprite_dir ), css_file, sprite_dir )      
       
-      puts "=> bundled css at #{css_file}"
+      Sass::Plugin.force_update_stylesheets
     end
   end
   
-  desc 'Pre-generate sass scripts'
-  task :sass do |t|
-    puts "SASS env = #{Rails.env} / #{Sass::Plugin.options[:style]}"
-    Sass::Plugin.force_update_stylesheets
-  end
   desc "Compresses stylesheets for use with nginx gzip_static"
   task :css_gzip do |t|
     Dir[ File.join Rails.root, 'public/stylesheets/*.css' ].each do |file|
@@ -145,97 +93,18 @@ namespace :lash do
   end
   
   desc 'Process CSS scripts'
-  task :css => [:css_sprites, :sass, :css_gzip] do |t|
-
+  task :css => [:sprites, :sass, :css_gzip, :png] do |t|
   end
   
-  
-  def load_css_template(sprite_dir, template_name)
-    css_template_file = File.join( sprite_dir, template_name );
-    return IO.read(css_template_file) if File.exists? css_template_file
-    nil
-  end
-
-  def generate_css(sprite,class_name,file,sprite_dir)
-
-    # Calculate most common width and height so sprites can default
-    width_freq, height_freq = {}, {}
-
-    sprite.images.each do |path,image|
-      next unless image.width and image.height
-      
-      width_freq[image.width] = ( width_freq[image.width] || 0 ) + 1
-      height_freq[image.height] = ( height_freq[image.height] || 0 ) + 1
+  desc 'Optimizes all PNG images in the public/images folder'
+  task :png do |t|
+    Lash::Files.recursive_file_list( File.join( Rails.root, "public/images" ), ".png" ).each do |p|
+      `#{File.expand_path ::File.join( __FILE__, '../../../../bin/optipng')} -o7 \"#{p}\"`
+      abort "Failed to optimize png #{p}, status = #{$?.exitstatus}" unless $?.exitstatus == 0
     end
-    
-    width = width_freq.max_by { |e| e[1] }[0]
-    height = height_freq.max_by { |e| e[1] }[0]
-    
-
-    png_file = sprite.filename[6,sprite.filename.size-6]
-    css = eval ( load_css_template( sprite_dir, "template.css" ) ||
-    '"
-.#{class_name}-background { 
-  	background-image: url(..#{png_file}?#{Date.new.to_time.to_i}); 
-  	background-repeat: no-repeat;
-}
-
-.#{class_name} { 
-	background-color: transparent;
-	background-image: url(..#{png_file}?#{Date.new.to_time.to_i}); 
-	background-repeat: no-repeat;
-	overflow: hidden;
-  text-indent: 99999px;
-  *text-indent: 999px; // IE 7 fix
-  text-align: left!important;
-  width: #{width}px;
-  height: #{height}px;
-}
-
-"' )
+  end  
 
-    css_sprite_template = load_css_template( sprite_dir, "sprite-template.css" ) || '
-      ".#{class_name}-#{name} { background-position: -#{image.x}px -#{image.y}px;#{ "width: #{image.width}px; " if image.width != width }#{ "height: #{image.height}px; " if image.height != height } }\n" 
-    '
-
-    sprite.images.each do |path, image|
-      name = File.basename(path)
-      name = name[ 0, name.rindex( '.' ) ].gsub( '/', '-' )
-      css += eval css_sprite_template
-    end
-
-    fp = File.open( sprite.file_root + file, 'w' )
-    fp.write( css )
-    fp.close
-
-    `#{File.join( @bin_path, 'optipng')} -o7 \"#{sprite.filename}\"` if File.exists? sprite.filename
-  end
-    
-  
-  require 'find'
-  def recursive_file_list(basedir, ext)
-    files = []
-    Find.find( basedir ) do |path|
-      if FileTest.directory?( path )
-        if File.basename( path )[0] == ?. # Skip dot directories
-          Find.prune
-        else
-          next
-        end
-      end
-      files << path if File.extname( path ) == ext
-    end
-    files.sort
-  end
-
-  def get_top_level_directories( base_path )
-    Dir.entries( base_path ).collect do |path|
-      path = File.join( base_path, path )
-      File.basename( path )[0] == ?. || !File.directory?( path ) ? nil : path # not dot directories or files
-    end - [nil]
-  end
-  
   desc 'Called by capistrano to generate static assets on the server'
-  task :deploy => [:sass, :gzip_css, :js_gzip] do
+  task :deploy => [:js, :css, :png] do
   end
 end