slight_assets 0.1.0

data/generators/slight_assets/slight_assets_generator.rb

@@ -0,0 +1,28 @@
+require 'rbconfig'
+
+class SlightAssetsGenerator < ::Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.file "config/assets.yml", "config/assets.yml"
+      m.file "config/initializers/assets.rb", "config/initializers/assets.rb"
+    end
+  end
+
+  def self.gem_root
+    File.expand_path('../../../', __FILE__)
+  end
+
+  def self.source_root
+    File.join(gem_root, 'templates', 'install')
+  end
+
+  def source_root
+    self.class.source_root
+  end
+
+  private
+
+  def banner
+    "Usage: #{$0} slight_assets"
+  end
+end

data/lib/slight_assets/base.rb

@@ -0,0 +1,7 @@
+module SlightAssets
+  autoload :Util, "slight_assets/util"
+  autoload :Rails, "slight_assets/rails"
+  autoload :Cfg, "slight_assets/settings"
+  autoload :JsReducer, "slight_assets/js_reducer"
+  autoload :VERSION, "slight_assets/version"
+end

data/lib/slight_assets/js_reducer.rb

@@ -0,0 +1,85 @@
+module SlightAssets
+  class JsReducer
+    BYTE_RANGE = 32..127
+    BASE_NUMBER = BYTE_RANGE.count
+    FETCH_RANGE = BASE_NUMBER ** 2
+    LOOKUP_CHAR = "`"
+    ESCAPABLE_CHARS = ["\\", "\"", "\r", "\n"].freeze
+
+    def compress(js_content)
+      content = reduce(js_content)
+      return js_content if content == js_content
+      func = 'function(x){var b="",p=0,c,l,L=x.length,m="`";while(p<L)b+=(c=x[p++])!=m?c:(l=x.charCodeAt(p++)-31)>1?b.substr(b.length-x.charCodeAt(p++)*96-x.charCodeAt(p++)+3104-l,l):m;return b}'
+      content = content.gsub(/([\\"])/, '\\\\\\1').gsub(/\r/, "\\r").gsub(/\n/, "\\n")
+      "eval((#{func})(\"#{content}\"))"
+    end
+
+    def reduce(js_content)
+      max_cropsize = BASE_NUMBER
+      content = str_as_utf8(js_content)
+      return js_content if content.nil?
+      output, index, limit = "", -1, content.size
+      while (index+=1) < limit
+        i, chars = -1, str_as_utf8("")
+        cropindex, cropsize, s = nil, 0, 0
+        while (i+=1) < max_cropsize && index + i < limit
+          chars << (c = content[index+i])
+          next if s < 5 && (s += (ESCAPABLE_CHARS.include?(c) ? 2 : c.bytesize) ) < 5
+          max_start = index - chars.size
+          start = [0, max_start - FETCH_RANGE].max
+          if (pos = content.index(chars, start)) && pos <= max_start
+            cropindex, cropsize = pos, chars.size
+          end
+        end
+        if cropindex.nil?
+          output << content[index]
+          output << " " if content[index] == LOOKUP_CHAR
+        else
+          max_start = [0, index - cropsize].max
+          chars = str_as_utf8(content[cropindex, cropsize])
+          cropindex = pos while (pos = content.index(chars, cropindex + 1)) && pos <= max_start
+          output << LOOKUP_CHAR
+          output << BYTE_RANGE.last - max_cropsize + cropsize
+          offset = (index - cropindex) - cropsize
+          output << BYTE_RANGE.first + (offset / BASE_NUMBER)
+          output << BYTE_RANGE.first + (offset % BASE_NUMBER)
+          index += cropsize - 1
+        end
+      end
+      output
+    end
+
+    if RUBY_VERSION =~ /\A1\.[0-8]/
+      begin
+        require "utf8"
+        def str_as_utf8(str)
+          str.as_utf8
+        end
+      rescue LoadError
+        def str_as_utf8(str)
+          a = str.is_a?(Array) ? str : str.scan(/./mu)
+          class << a
+            def index(chars, start)
+              return nil if start >= size
+              i, s, cs = start - 1, size, chars.size
+              while (i+=1) < s
+                next if self[i] != chars[0]
+                return i if cs == 1
+                j = 0
+                while (j+=1) < cs && i + j < s
+                  break if self[i+j] != chars[j]
+                  return i if j + 1 == cs
+                end
+              end
+            end
+          end
+          a
+        end
+      end
+    else
+      def str_as_utf8(str)
+        str
+      end  
+    end
+  end
+end

data/lib/slight_assets/rails.rb

@@ -0,0 +1,79 @@
+module SlightAssets
+  module Rails
+    def init!
+      ActionView::Helpers::AssetTagHelper.send :include, HelperMethods
+    end
+    module_function :init!
+
+    module HelperMethods
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :write_asset_file_contents, :static_compressed_file
+          alias_method_chain :javascript_src_tag, :static_compressed_file
+          alias_method_chain :stylesheet_tag, :static_compressed_file
+        end
+      end
+
+      private
+
+      def write_asset_file_contents_with_static_compressed_file(joined_asset_path, asset_paths)
+        minify = false
+        asset_paths = asset_paths.map do |asset_path|
+          p = asset_path.to_s
+          if p =~ /\.min\./
+            asset_path
+          else
+            p = p.gsub(/\.(js|css)(\?\w+)?\z/, '.min.\1\2')
+            if ::File.exists?(asset_file_path(p))
+              p
+            else
+              minify = true
+              asset_path
+            end
+          end
+        end
+        minified_joined_asset_path = joined_asset_path.gsub(/(?:\.min)?\.(js|css)\z/, '.min.\1')
+        already_existed = File.exists?(minified_joined_asset_path)
+        r = write_asset_file_contents_without_static_compressed_file(minify ? joined_asset_path : minified_joined_asset_path, asset_paths)
+        if minify && ! already_existed
+          SlightAssets::Util.async_write_static_compressed_file(joined_asset_path)
+        else
+          SlightAssets::Util.write_static_gzipped_file(minified_joined_asset_path)
+        end
+        r
+      end
+
+      def javascript_src_tag_with_static_compressed_file(source, options)
+        unless source =~ /\A(?:\w+:)?\/\//
+          asset_path = path_to_javascript(source).split('?').first
+          file_path = asset_file_path(asset_path)
+          if asset_path.end_with?(".js") && asset_path !~ /\.min\./
+            compressed_path = asset_path.gsub(/\.js\z/, '.min.js')
+            if ::File.exists?(asset_file_path(compressed_path))
+              source = compressed_path unless ::File.exists?("#{file_path}.locked")
+            elsif ::File.exists?(file_path)
+              SlightAssets::Util.async_write_static_compressed_file(file_path)
+            end
+          end
+        end
+        javascript_src_tag_without_static_compressed_file(source, options)
+      end
+
+      def stylesheet_tag_with_static_compressed_file(source, options)
+        unless source =~ /\A(?:\w+:)?\/\//
+          asset_path = path_to_stylesheet(source).split('?').first
+          file_path = asset_file_path(asset_path)
+          if asset_path.end_with?(".css") && asset_path !~ /\.min\./
+            compressed_path = asset_path.gsub(/\.css\z/, '.min.css')
+            if ::File.exists?(asset_file_path(compressed_path))
+              source = compressed_path unless ::File.exists?("#{file_path}.locked")
+            elsif ::File.exists?(file_path)
+              SlightAssets::Util.async_write_static_compressed_file(file_path)
+            end
+          end
+        end
+        stylesheet_tag_without_static_compressed_file(source, options)
+      end
+    end
+  end
+end

data/lib/slight_assets/rake_tasks.rb

@@ -0,0 +1,112 @@
+namespace :asset do
+  namespace :compress do
+    task :pre => :environment do
+      require "slight_assets"
+      class AssetWriter
+        include ::SlightAssets::Util
+        attr_reader :image_report
+        def initialize
+          @image_report = {}
+        end
+        def write_compressed_file(file)
+          write_static_compressed_file(file)
+        end
+        def js_list
+          unless defined?(@js_list)
+            @js_list = []
+            (SlightAssets::Cfg.minify_assets? || []).each do |mask|
+              if mask =~ /\A([+-])?\s*(.*\.js)\z/
+                oper = $1 || "+"
+                files_mask = [::Rails.root, "public", "javascripts", $2]
+                @js_list = @js_list.send(oper, FileList[File.join(*files_mask)])
+              end
+            end
+            files_mask = [::Rails.root, "public", "javascripts", "**", "*.min.js"]
+            @js_list = (@js_list - FileList[File.join(*files_mask)]).uniq.sort
+          end
+          @js_list
+        end
+        def css_list
+          unless defined?(@css_list)
+            @css_list = []
+            (SlightAssets::Cfg.minify_assets? || []).each do |mask|
+              if mask =~ /\A([+-])?\s*(.*\.css)\z/
+                oper = $1 || "+"
+                files_mask = [::Rails.root, "public", "stylesheets", $2]
+                @css_list = @css_list.send(oper, FileList[File.join(*files_mask)])
+              end
+            end
+            files_mask = [::Rails.root, "public", "stylesheets", "**", "*.min.css"]
+            @css_list = (@css_list - FileList[File.join(*files_mask)]).uniq.sort
+          end
+          @css_list
+        end
+      end
+    end
+
+    desc "Compress all JS files from your Rails application"
+    task :js => :pre do
+      puts "=" * 80
+      if SlightAssets::Util.js_compressor.nil?
+        puts "WARN: No JS compressor was found"
+        exit 1
+      end
+      writer = AssetWriter.new
+      jslist = writer.js_list
+      originalsize, compressedsize = 0, 0
+      start_time = Time.now
+      jslist.each do |jsfile|
+        print "Compressing #{jsfile[(Rails.root.to_s.size+1)..-1]}"
+        time = Time.now
+        minfile = writer.write_compressed_file(jsfile).chomp(".gz")
+        originalsize += jssize = File.size(jsfile)
+        compressedsize += minsize = File.size(minfile)
+        percent = jssize.zero? ? 100 : (100.0 * minsize / jssize).round
+        puts " (#{Time.now - time}s)\n  -> #{jssize} bytes to #{minsize} bytes (#{percent}% size)"
+      end
+      if jslist.any?
+        puts "Total #{jslist.size} JS files were compressed"
+        percent = originalsize.zero? ? 100 : (100.0 * compressedsize / originalsize).round
+        puts "  -> reduced from #{originalsize} bytes to #{compressedsize} bytes (#{percent}% size total, #{originalsize - compressedsize} bytes saved)"
+      end
+      puts "Elapsed time: #{Time.now - start_time}s"
+    end
+
+    desc "Compress all CSS files from your Rails application"
+    task :css => :pre do
+      puts "=" * 80
+      if SlightAssets::Util.css_compressor.nil?
+        puts "WARN: No CSS compressor was found"
+        exit 1
+      end
+      writer = AssetWriter.new
+      csslist = writer.css_list
+      start_time = Time.now
+      csslist.each do |cssfile|
+        print "Compressing #{cssfile[(Rails.root.to_s.size+1)..-1]}"
+        time = Time.now
+        minfile = writer.write_compressed_file(cssfile).chomp(".gz")
+        csssize = File.size(cssfile)
+        minsize = File.size(minfile)
+        percent = csssize.zero? ? 100 : (100.0 * minsize / csssize).round
+        puts " (#{Time.now - time}s)\n  -> #{csssize} bytes to #{minsize} bytes (#{percent}% size)"
+      end
+      puts "Total: #{csslist.size} CSS files were compressed" if csslist.any?
+      puts "Elapsed time: #{Time.now - start_time}s"
+      if writer.image_report.any?
+        puts "=" * 80
+        writer.image_report.each_pair do |image_file, report|
+          refs = report[:found_in].size
+          puts "Image: #{image_file[(Rails.public_path.size)..-1]} (#{"\033[1;31m" unless refs == 1}#{refs} occurrence#{"s" unless refs == 1}\033[0m)"
+          report[:found_in].each_pair do |css_file, count|
+            mode = report[:exists] ? (report[:embeddable] && count == 1 ? "embedded" : "\033[0;33mnot embedded\033[0m") : "\033[0;31mnot found\033[0m"
+            puts "  found in #{css_file[(Rails.public_path.size)..-1]} (#{count} ref#{"s" unless count == 1}, #{mode})"
+          end
+        end
+      end
+    end
+  end
+
+  desc "Compress all JS and CSS files from your Rails application"
+  task :compress => ["compress:js", "compress:css"]
+end

data/lib/slight_assets/settings/default_config.yml

@@ -0,0 +1,43 @@
+slight_asset: &slight_asset
+
+  # Maximum embedded file size
+  # The limit file size to decide whether or not to embed
+  # Must be less than or equal to "32kB"
+  maximum_embedded_file_size: "32kB"
+
+  # Scope of assets to minify in batch process (rake).
+  # The prefix "-" indicates the files to exclude from minifying.
+  # Keep in mind that the sequence matters.
+  minify_assets:
+    - **/*.js
+    - -**/ckeditor/**/*.js
+    - **/*.css
+    # in the end, the masks below will be used for cleaning (even if omitted).
+    - -**/*.min.js
+    - -**/*.min.css
+
+  # Absolute MHTML base href (Optional)
+  # If present, the CSS images that was referenced twice or more
+  # will be embedded inside a MHTML block
+  #mhtml_base_href: "http://localhost:3000"
+
+  # JavaScript Reducer (Optional)
+  # This mode enables obfuscation for JavaScript compression, reducing
+  # even more the file size.
+  # Sets the JavaScript reduce mode:
+  #   "rake" - Reduce only when executing rake task (asset:compress:js)
+  #   true   - Reduce at runtime or when executing rake
+  #   false  - Don't reduce JavaScript's
+  js_reducer: false
+
+development:
+  slight_asset:
+    <<: *slight_asset
+
+test:
+  slight_asset:
+    <<: *slight_asset
+
+production:
+  slight_asset:
+    <<: *slight_asset

data/lib/slight_assets/settings.rb

@@ -0,0 +1,57 @@
+require "yaml"
+
+module SlightAssets
+  class Config
+    attr_reader :config
+    def initialize
+      @config = {}
+    end
+
+    def method_missing(name, *args)
+      sname = name.to_s
+      case sname
+      when /\?$/
+        @config[$`]
+      when /\=$/
+        @config[$`] = args.first
+      else
+        return @config[sname] if @config.has_key?(sname)
+        super
+      end
+    end
+
+    def load_config(path)
+      return @config unless File.exists? path
+      hash = YAML.load_file(path)
+      hash = hash[::Rails.env] || hash if defined?(::Rails)
+      @config.merge! hash["slight_asset"] if hash.has_key?("slight_asset")
+    rescue TypeError => e
+      puts "could not load #{path}: #{e.inspect}"
+    end
+
+    def maximum_embedded_file_size
+      unless defined?(@maximum_embedded_file_size)
+        c = @config["maximum_embedded_file_size"]
+        if c.is_a?(Fixnum)
+          @maximum_embedded_file_size = c
+        elsif c =~ /\A(\d+)\s*(\w+)\z/
+          c = $1.to_i
+          case $2
+          when "kB", "kb"
+            c = c * 1_024
+          end
+          @maximum_embedded_file_size = [c, 32 * 1_024].min
+        end
+      end
+      @maximum_embedded_file_size
+    end
+
+    def url_matcher
+      /url\(['"]?(.*?)(?:\?\d+)?['"]?\)/
+    end
+  end
+
+  Cfg = Config.new
+  Cfg.load_config File.expand_path(File.join(*%w[.. settings default_config.yml]), __FILE__)
+  Cfg.load_config ::Rails.root.join(*%w[config assets.yml]) if defined?(::Rails)
+end

data/lib/slight_assets/util.rb

@@ -0,0 +1,243 @@
+require "base64"
+require "zlib"
+
+module SlightAssets
+  module Util
+    def write_static_gzipped_file(file_path, content = nil)
+      return file_path if file_path.nil? || file_path.end_with?(".gz") || ! File.exists?(file_path)
+      zip_path = "#{file_path}.gz"
+      return zip_path if File.exists?(zip_path)
+      content = File.read(file_path) if content.nil?
+      Zlib::GzipWriter.open(zip_path, Zlib::BEST_COMPRESSION) {|f| f.write(content) }
+      # Set mtime to the latest of the file to allow for
+      # consistent ETag without a shared filesystem.
+      mt = File.mtime(file_path)
+      File.utime(mt, mt, zip_path)
+      zip_path
+    end
+    module_function :write_static_gzipped_file
+
+    def write_static_minified_asset(file_path)
+      return file_path if file_path.nil? || file_path =~ /\.min\./ || file_path !~ /\.(?:js|css)\z/ || ! File.exists?(file_path)
+      min_path = file_path.gsub(/\.(js|css)\z/, '.min.\1')
+      compressor = nil
+      case extension = $1
+      when "css"
+        compressor = css_compressor
+      when "js"
+        compressor = js_compressor
+      end
+      return file_path if compressor.nil?
+      content = File.read(file_path)
+      c = compressor.compress(content)
+      content = c if c.bytesize < content.bytesize
+      content = embed_images(content, min_path) if extension == "css"
+      reduced_content = content
+      if extension == "js"
+        reduced_content = js_reduce(content)
+        reduced_content = content if reduced_content.bytesize > content.bytesize
+      end
+      File.open(min_path, "w") { |f| f.write(reduced_content) }
+      mt = File.mtime(file_path)
+      File.utime(mt, mt, min_path)
+      [min_path, content]
+    end
+    module_function :write_static_minified_asset
+
+    def js_reduce(content)
+      unless (Cfg.js_reducer? == "rake" && is_rake?) || Cfg.js_reducer? == true
+        content
+      else
+        JsReducer.new.compress(content)
+      end
+    end
+    module_function :js_reduce
+
+    def embed_images(content, file_path)
+      return content if file_path =~ /\A(?:\w+:)?\/\//
+      images = extract_images(content, file_path)
+      file_url = asset_url(file_path)
+      image_contents = {}
+      multipart = ["/*\r\nContent-Type: multipart/related; boundary=\"MHTML_IMAGES\"\r\n"]
+      replace_imports = Cfg.replace_css_imports?
+      content = content.gsub(Cfg.url_matcher) do |url_match|
+        image_path = $1
+        quot = (url_match =~ /"/ ? "\"" : "")
+        if image_path =~ /\A(?:[\\\/]|\w+:)/
+          url_match
+        elsif image_path =~ /(\.min)?\.css\z/ && replace_imports
+          if $1
+            url_match
+          elsif File.exists?(asset_expand_path(image_path, file_path))
+            "url(#{quot}#{image_path.gsub(/\.css\z/, ".min.css")}#{quot})"
+          else
+            url_match
+          end
+        else
+          image_file_path = asset_expand_path(image_path, file_path)
+          if (mt = image_mime_type(image_path)) &&
+             (encode64 = encoded_file_contents(image_file_path, file_path))
+            if image_contents[image_file_path].nil?
+              part_name = "img#{multipart.size}_#{File.basename(image_file_path)}"
+              image_contents[image_file_path] = [part_name, encode64]
+            else
+              part_name = image_contents[image_file_path].first
+            end
+            if images[image_file_path] > 1
+              if file_url
+                multipart << [
+                  "\r\n--MHTML_IMAGES",
+                  "\r\nContent-Location: ",
+                  part_name,
+                  "\r\nContent-Type: ",
+                  mt,
+                  "\r\nContent-Transfer-Encoding: base64\r\n\r\n",
+                  encode64
+                ]
+                "url(#{quot}mhtml:#{file_url}!#{part_name}#{quot})"
+              else
+                url_match
+              end
+            else
+              "url(#{quot}data:#{mt};base64,#{encode64}#{quot})"
+            end
+          else
+            url_match
+          end
+        end
+      end
+      if multipart.size > 1
+        content = content.gsub(/(\*?)(background-image:[^;\}]*?url\("?mhtml)/, '*\2')
+        (multipart + ["\r\n--MHTML_IMAGES--\r\n*/\r\n", content]).flatten.join("")
+      else
+        content
+      end
+    end
+    module_function :embed_images
+
+    def asset_url(file_path)
+      if defined?(::Rails) && file_path.start_with?(::Rails.public_path) && Cfg.mhtml_base_href?
+        URI.join(Cfg.mhtml_base_href, file_path[(::Rails.public_path.size)..-1])
+      end
+    end
+    module_function :asset_url
+
+    def extract_images(content, file_path)
+      images = {}
+      content.scan(Cfg.url_matcher).flatten.each do |image_path|
+        image_file_path = asset_expand_path(image_path, file_path)
+        images[image_file_path] = (images[image_file_path] || 0) + 1
+      end
+      images
+    end
+    module_function :extract_images
+
+    def asset_expand_path(relative_asset_path, absolute_source_file_path)
+      File.expand_path(File.join("..", relative_asset_path), absolute_source_file_path)
+    end
+    module_function :asset_expand_path
+
+    def image_mime_type(path)
+      return if path !~ /\.([^\.]+)$/
+      case $1.downcase.to_sym
+      when :jpg, :jpeg
+        "image/jpeg"
+      when :png
+        "image/png"
+      when :gif
+        "image/gif"
+      when :tif, :tiff
+        "image/tiff"
+      end
+    end
+    module_function :image_mime_type
+
+    def encoded_file_contents(file_path, css_file_path = nil)
+      if css_file_path && is_rake?
+        @image_report[file_path] ||= {:found_in => {}}
+        @image_report[file_path][:found_in][css_file_path] =
+          (@image_report[file_path][:found_in][css_file_path] || 0) + 1
+        if @image_report[file_path][:exists] = File.exists?(file_path)
+          @image_report[file_path][:embeddable] =
+            File.size(file_path) <= Cfg.maximum_embedded_file_size
+        end
+      end
+      if File.exists?(file_path) && File.size(file_path) <= Cfg.maximum_embedded_file_size
+        Base64.encode64(File.read(file_path)).gsub(/\n/, "")
+      end
+    end
+    module_function :encoded_file_contents
+
+    def is_runtime?
+      ! is_rake?
+    end
+    module_function :is_runtime?
+
+    def is_rake?
+      defined?(@image_report) && @image_report.is_a?(Hash)
+    end
+    module_function :is_rake?
+
+    def async_write_static_compressed_file(file_path, &block)
+      lock_file_path = "#{file_path}.locked"
+      return if File.exists?(lock_file_path) && File.mtime(lock_file_path) > (Time.now - 120)
+      File.open(lock_file_path, "w"){}  # touch
+      Thread.new do
+        begin
+          file_path = write_static_compressed_file(file_path)
+        ensure
+          File.delete(lock_file_path)
+        end
+      end
+    end
+    module_function :async_write_static_compressed_file
+
+    def write_static_compressed_file(file_path)
+      file_path, content = write_static_minified_asset(file_path)
+      file_path = write_static_gzipped_file(file_path, content)
+    end
+    module_function :write_static_compressed_file
+
+    def js_compressor
+      closure_compiler_js_compressor || yui_js_compressor
+    end
+    module_function :js_compressor
+
+    def css_compressor
+      yui_css_compressor
+    end
+    module_function :css_compressor
+
+    protected
+
+    begin
+      require "closure-compiler"
+      def closure_compiler_js_compressor
+        Closure::Compiler.new
+      end
+    rescue LoadError => e
+      STDERR.puts "WARN: #{e.message}"
+      def closure_compiler_js_compressor
+      end
+    end
+    module_function :closure_compiler_js_compressor
+
+    begin
+      require "yui/compressor"
+      def yui_js_compressor
+        YUI::JavaScriptCompressor.new
+      end
+      def yui_css_compressor
+        YUI::CssCompressor.new
+      end
+    rescue LoadError => e
+      STDERR.puts "WARN: #{e.message}"
+      def yui_js_compressor
+      end
+      def yui_css_compressor
+      end
+    end
+    module_function :yui_js_compressor
+    module_function :yui_css_compressor
+  end
+end

data/lib/slight_assets/version.rb

@@ -0,0 +1,6 @@
+module SlightAssets
+  version = nil
+  version = $1 if ::File.expand_path('../..', __FILE__) =~ /\/slight_assets-(\d[\w\.]+)/
+  version = ::StepUp::Driver::Git.new.last_version_tag if version.nil? && ::File.exists?(::File.expand_path('../../../.git', __FILE__))
+  VERSION = version.gsub(/^v?([^\+]+)\+?\d*$/, '\1')
+end

data/lib/slight_assets.rb

@@ -0,0 +1 @@
+require "slight_assets/base"

data/templates/install/config/assets.yml

@@ -0,0 +1,42 @@
+slight_asset: &slight_asset
+
+  # Maximum embedded file size
+  # The limit file size to decide whether or not to embed
+  # Must be less than or equal to "32kB"
+  maximum_embedded_file_size: "32kB"
+
+  # Scope of assets to minify in batch process (rake).
+  # The prefix "-" indicates the files to exclude from minifying.
+  # Keep in mind that the sequence matters.
+  minify_assets:
+    - **/*.js
+    - **/*.css
+    # in the end, the masks below will be used for cleaning (even if omitted).
+    - -**/*.min.js
+    - -**/*.min.css
+
+  # Absolute MHTML base href (Optional)
+  # If present, the CSS images that was referenced twice or more
+  # will be embedded inside a MHTML block
+  #mhtml_base_href: "http://localhost:3000"
+
+  # JavaScript Reducer (Optional)
+  # This mode enables obfuscation for JavaScript compression, reducing
+  # even more the file size.
+  # Sets the JavaScript reduce mode:
+  #   "rake" - Reduce only when executing rake task (asset:compress:js)
+  #   true   - Reduce at runtime or when executing rake
+  #   false  - Don't reduce JavaScript's
+  js_reducer: false
+
+development:
+  slight_asset:
+    <<: *slight_asset
+
+test:
+  slight_asset:
+    <<: *slight_asset
+
+production:
+  slight_asset:
+    <<: *slight_asset

data/templates/install/config/initializers/assets.rb

@@ -0,0 +1,2 @@
+require "slight_assets"
+SlightAssets::Rails.init!

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: slight_assets
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Marcelo Manzan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-20 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yui-compressor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 9
+        - 6
+        version: 0.9.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: step-up
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: closure-compiler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Optimize the assets of your Rails application without change any line of code.
+email: 
+- manzan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- generators/slight_assets/slight_assets_generator.rb
+- lib/slight_assets.rb
+- lib/slight_assets/base.rb
+- lib/slight_assets/js_reducer.rb
+- lib/slight_assets/rails.rb
+- lib/slight_assets/rake_tasks.rb
+- lib/slight_assets/settings.rb
+- lib/slight_assets/settings/default_config.yml
+- lib/slight_assets/util.rb
+- lib/slight_assets/version.rb
+- templates/install/config/assets.yml
+- templates/install/config/initializers/assets.rb
+has_rdoc: true
+homepage: https://github.com/kawamanza/slight_assets
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: slight_assets
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: All you need to make your rails application more fast.
+test_files: []
+