assets_booster 0.0.1

data/lib/assets_booster/compiler/node-js/squeeze-more.js

@@ -0,0 +1,22 @@
+var jsp = require("./parse-js"),
+    pro = require("./process"),
+    slice = jsp.slice,
+    member = jsp.member,
+    PRECEDENCE = jsp.PRECEDENCE,
+    OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+        var w = pro.ast_walker(), walk = w.walk;
+        return w.with_walkers({
+                "call": function(expr, args) {
+                        if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+                                // foo.toString()  ==>  foo+""
+                                return [ "binary", "+", expr[1], [ "string", "" ]];
+                        }
+                }
+        }, function() {
+                return walk(ast);
+        });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;

data/lib/assets_booster/compiler/node-js/uglify.js

@@ -0,0 +1,203 @@
+#! /usr/bin/env node
+// -*- js2 -*-
+
+global.sys = require(/^v0\.[012]/.test(process.version) ? "sys" : "util");
+var fs = require("fs"),
+	jsp = require("./parse-js"),
+	pro = require("./process");
+
+var options = {
+        ast: false,
+        mangle: true,
+        mangle_toplevel: false,
+        squeeze: true,
+        make_seqs: true,
+        dead_code: true,
+        beautify: false,
+        verbose: false,
+        show_copyright: true,
+        out_same_file: false,
+        max_line_length: 32 * 1024,
+        unsafe: false,
+        reserved_names: null,
+        beautify_options: {
+                indent_level: 4,
+                indent_start: 0,
+                quote_keys: false,
+                space_colon: false
+        },
+        output: true            // stdout
+};
+
+var args = jsp.slice(process.argv, 2);
+var filename;
+
+out: while (args.length > 0) {
+        var v = args.shift();
+        switch (v) {
+            case "-b":
+            case "--beautify":
+                options.beautify = true;
+                break;
+            case "-i":
+            case "--indent":
+                options.beautify_options.indent_level = args.shift();
+                break;
+            case "-q":
+            case "--quote-keys":
+                options.beautify_options.quote_keys = true;
+                break;
+            case "-mt":
+            case "--mangle-toplevel":
+                options.mangle_toplevel = true;
+                break;
+            case "--no-mangle":
+            case "-nm":
+                options.mangle = false;
+                break;
+            case "--no-squeeze":
+            case "-ns":
+                options.squeeze = false;
+                break;
+            case "--no-seqs":
+                options.make_seqs = false;
+                break;
+            case "--no-dead-code":
+                options.dead_code = false;
+                break;
+            case "--no-copyright":
+            case "-nc":
+                options.show_copyright = false;
+                break;
+            case "-o":
+            case "--output":
+                options.output = args.shift();
+                break;
+            case "--overwrite":
+                options.out_same_file = true;
+                break;
+            case "-v":
+            case "--verbose":
+                options.verbose = true;
+                break;
+            case "--ast":
+                options.ast = true;
+                break;
+            case "--unsafe":
+                options.unsafe = true;
+                break;
+            case "--max-line-len":
+                options.max_line_length = parseInt(args.shift(), 10);
+                break;
+            case "--reserved-names":
+                options.reserved_names = args.shift().split(",");
+                break;
+            default:
+                filename = v;
+                break out;
+        }
+}
+
+if (options.verbose) {
+        pro.set_logger(function(msg){
+                sys.debug(msg);
+        });
+}
+
+if (filename) {
+        fs.readFile(filename, "utf8", function(err, text){
+                if (err) throw err;
+                output(squeeze_it(text));
+        });
+} else {
+        var stdin = process.openStdin();
+        stdin.setEncoding("utf8");
+        var text = "";
+        stdin.on("data", function(chunk){
+                text += chunk;
+        });
+        stdin.on("end", function() {
+                output(squeeze_it(text));
+        });
+}
+
+function output(text) {
+        var out;
+        if (options.out_same_file && filename)
+                options.output = filename;
+        if (options.output === true) {
+                out = process.stdout;
+        } else {
+                out = fs.createWriteStream(options.output, {
+                        flags: "w",
+                        encoding: "utf8",
+                        mode: 0644
+                });
+        }
+        out.write(text);
+        if (options.output !== true) {
+                out.end();
+        }
+};
+
+// --------- main ends here.
+
+function show_copyright(comments) {
+        var ret = "";
+        for (var i = 0; i < comments.length; ++i) {
+                var c = comments[i];
+                if (c.type == "comment1") {
+                        ret += "//" + c.value + "\n";
+                } else {
+                        ret += "/*" + c.value + "*/";
+                }
+        }
+        return ret;
+};
+
+function squeeze_it(code) {
+        var result = "";
+        if (options.show_copyright) {
+                var tok = jsp.tokenizer(code), c;
+                c = tok();
+                result += show_copyright(c.comments_before);
+        }
+        try {
+                var ast = time_it("parse", function(){ return jsp.parse(code); });
+                if (options.mangle) ast = time_it("mangle", function(){
+                        return pro.ast_mangle(ast, {
+                                toplevel: options.mangle_toplevel,
+                                except: options.reserved_names
+                        });
+                });
+                if (options.squeeze) ast = time_it("squeeze", function(){
+                        ast = pro.ast_squeeze(ast, {
+                                make_seqs  : options.make_seqs,
+                                dead_code  : options.dead_code,
+                                keep_comps : !options.unsafe
+                        });
+                        if (options.unsafe)
+                                ast = pro.ast_squeeze_more(ast);
+                        return ast;
+                });
+                if (options.ast)
+                        return sys.inspect(ast, null, null);
+                result += time_it("generate", function(){ return pro.gen_code(ast, options.beautify && options.beautify_options) });
+                if (!options.beautify && options.max_line_length) {
+                        result = time_it("split", function(){ return pro.split_lines(result, options.max_line_length) });
+                }
+                return result;
+        } catch(ex) {
+                sys.debug(ex.stack);
+                sys.debug(sys.inspect(ex));
+                sys.debug(JSON.stringify(ex));
+        }
+};
+
+function time_it(name, cont) {
+        if (!options.verbose)
+                return cont();
+        var t1 = new Date().getTime();
+        try { return cont(); }
+        finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
+};

data/lib/assets_booster/compiler/rainpress.rb

@@ -0,0 +1,17 @@
+module AssetsBooster
+  module Compiler
+    class Rainpress  
+      def self.name
+        'Rainpress'
+      end
+
+      def self.compile(css)
+        require 'rainpress'
+        ::Rainpress.compress(css)
+      rescue LoadError => e
+        raise "To use the Rainpress CSS Compressor, please install the rainpress gem first"
+      end
+    end
+  end
+end
+

data/lib/assets_booster/compiler/uglify.rb

@@ -0,0 +1,19 @@
+module AssetsBooster
+  module Compiler
+    class Uglify  
+      def self.name
+        'UglifyJS running on Node.js'
+      end
+          
+      def self.compile(code)
+        raise CompileError.new("You need to install node.js in order to compile using UglifyJS.") unless %x[which node].length > 1
+        IO.popen("cd #{Pathname.new(File.join(File.dirname(__FILE__),'node-js')).realpath} && node uglify.js", "r+") do |io|
+          io.write(code)
+          io.close_write
+          io.read
+        end
+      end
+    end
+  end
+end
+

data/lib/assets_booster/configuration.rb

@@ -0,0 +1,104 @@
+require 'yaml'
+module AssetsBooster
+  class Configuration
+    cattr_accessor :filename
+    cattr_accessor :config
+    
+    self.filename = File.join(Rails.root, "config", "assets_booster.yml")
+    
+    def self.load
+      self.config = YAML.load_file(filename)
+      AssetsBooster::Packager.packages = {}
+      config['packages'].each_pair do |type, packages|
+        type = type.to_sym
+        AssetsBooster::Packager.packages[type] = {}
+        packages.each_pair do |name, assets|
+          AssetsBooster::Packager.packages[type][name] = get_package(type).new(name, assets)
+        end
+      end
+    end
+
+    def self.asset_path(file)
+      File.join(Rails.root, "public", file)    
+    end
+
+    def self.compiler_for_type(type)
+      get_compiler(config['options'][type.to_s]['compiler'])
+    end
+    
+    def self.defaults
+      {
+        'packages' => {
+          'javascript' => {},
+          'stylesheet' => {},
+        },
+        'options' => {
+          'compiler' => {
+            'javascript' => {
+              'name' => "closure",
+              'options' => "",
+            },
+            'stylesheet' => {
+              'name' => "rainpress",
+              'options' => "",
+            }
+          },
+          'environments' => %w(staging production),
+        }
+      }
+    end
+
+    def self.create
+      if File.exists?(filename)
+        AssetsBooster.log "#{filename} already exists. Aborting task..."
+        return
+      end
+    
+      config = defaults
+      config['packages']['javascript'] = {
+        "base" => file_list("#{Rails.root}/public/javascripts", "js"),
+      }
+      config['packages']['stylesheet'] = {
+        "base" => file_list("#{Rails.root}/public/stylesheets", "css"),
+      }
+
+      File.open(filename, "w") do |out|
+        YAML.dump(config, out)
+      end
+      self.config = config
+
+      AssetsBooster.log("#{filename} example file created!")
+      AssetsBooster.log("Please reorder files under 'base' so dependencies are loaded in correct order.")
+    end
+    
+    def self.boosted_environment?
+      @boosted_environment ||= config['options']['environments'].include?(Rails.env)
+    end
+
+    private
+
+    def self.file_list(path, extension)
+      Dir[File.join(path, "*.#{extesnsion}")].map do |file| 
+        file.chomp(".#{extension}")
+      end
+    end    
+
+    def self.get_package(type)
+      require "assets_booster/package/base"
+      require "assets_booster/package/#{type}"
+      klass = "AssetsBooster::Package::#{type.to_s.camelize}"
+      klass.constantize
+    rescue LoadError => e
+      raise "You've specified an invalid package type '#{type}'"
+    end
+
+    def self.get_compiler(name)
+      require "assets_booster/compiler/#{name}"
+      klass = "AssetsBooster::Compiler::#{name.to_s.camelize}"
+      klass.constantize
+    rescue LoadError => e
+      raise "You've specified an invalid compiler '#{name}'"
+    end
+  end
+end
+

data/lib/assets_booster/merger/css.rb

@@ -0,0 +1,79 @@
+module AssetsBooster
+  module Merger
+    class CSS
+      cattr_accessor :assets
+
+      def self.name
+        "CSS Merger"
+      end
+                  
+      def self.merge(sources, target)
+        self.assets = []
+        sources.each do |source|
+          load_source(source)
+        end
+
+        target_folder = File.dirname(target)
+        assets.inject("") do |code, asset|
+          source_folder = File.dirname(asset[:source])
+          rewrite_urls!(asset[:css], source_folder, target_folder)
+          code << asset[:css]+"\n"
+        end.strip
+      end
+
+      def self.mtime(sources)
+        self.assets = []
+        sources.each do |source|
+          load_source(source)
+        end
+        assets.map{ |asset| File.mtime(asset[:source]) }.max
+      end        
+      
+      private
+      
+      def self.load_source(source)
+        css = File.read(source)
+        source_folder = File.dirname(source)
+        css.gsub!(/@import\s+([^;\n\s]+)/).each do |import|
+          url = $1.gsub(/^url\((.+)\)/i, '\1')
+          url, quotes = extract_url(url.strip)
+
+          # we don't want to statically import external stylesheets
+          next import if absolute_url?(url)
+
+          # recursively process the imported css
+          load_source(source_folder+"/"+url)
+          ""
+        end
+        self.assets << {
+          :source => source, 
+          :css => css
+        }
+      end
+      
+      def self.rewrite_urls!(css, source_folder, target_folder)
+        # difference between the source and target location
+        url_prepend = source_folder[target_folder.length+1..-1]
+        return unless url_prepend 
+  
+        css.gsub!(/url\(([^)]+)\)/i) do |match|
+          url, quotes = extract_url($1.strip)
+
+          # we don't want to change references to external assets
+          next match if absolute_url?(url) 
+
+          "url(#{quotes}#{url_prepend}/#{url}#{quotes})"
+        end
+      end
+      
+      def self.extract_url(quoted_url)
+        (quoted_url[0].chr =~ /["']/) ? [quoted_url.slice(1, quoted_url.length-2), quoted_url[0].chr] : [quoted_url, ""]
+      end
+      
+      def self.absolute_url?(url)
+        url[0].chr =~ /^(\/|https?:\/\/)/i
+      end
+    end
+  end
+end
+