sinatra-assetpack-flexible-compression 0.0.1

data/lib/sinatra/assetpack/class_methods.rb

@@ -0,0 +1,82 @@
+module Sinatra
+  module AssetPack
+    # Class methods that will be given to the Sinatra application.
+    module ClassMethods
+      # Sets asset options, or gets them
+      def assets(&blk)
+        @options ||= Options.new(self, &blk)
+        self.assets_initialize!  if block_given?
+
+        @options
+      end
+
+      def assets_initialize!
+        add_compressed_routes!
+        add_individual_routes!
+
+        # Cache the built files.
+        if assets.prebuild && !reload_templates
+          assets.cache! { |file| $stderr.write "** Building #{file}...\n" }
+        end
+      end
+
+      # Add routes for the compressed versions
+      def add_compressed_routes!
+        assets.packages.each do |name, package|
+          get package.route_regex do
+            mtime, contents = @template_cache.fetch(package.path) {
+              [ package.mtime, package.minify ]
+            }
+
+            content_type package.type
+            last_modified mtime
+            contents
+          end
+        end
+      end
+
+      # Add the routes for the individual files.
+      def add_individual_routes!
+        assets.served.each do |path, from|
+          get %r{#{"^/#{path}/".squeeze('/')}(.*)$} do |file|
+            fmt = File.extname(file)[1..-1]
+
+            # Sanity checks
+            pass unless AssetPack.supported_formats.include?(fmt)
+            fn = asset_path_for(file, from)  or pass
+
+            pass  if settings.assets.ignored?("#{path}/#{file}")
+
+            # Send headers
+            content_type fmt.to_sym
+            last_modified File.mtime(fn).to_i
+            expires 86400*30, :public
+
+            format = File.extname(fn)[1..-1]
+
+            if AssetPack.supported_formats.include?(format)
+              # It's a raw file, just send it
+              not_found  unless format == fmt
+
+              if fmt == 'css'
+                @template_cache.fetch(fn) { asset_filter_css File.read(fn) }
+              else
+                send_file fn
+              end
+            else
+              # Dynamic file
+              not_found unless AssetPack.tilt_formats[format] == fmt
+
+              @template_cache.fetch(fn) {
+                out = render format.to_sym, File.read(fn)
+                out = asset_filter_css(out)  if fmt == 'css'
+                out
+              }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/compressor.rb

@@ -0,0 +1,54 @@
+module Sinatra
+  module AssetPack
+    module Compressor
+      extend self
+
+      # Compresses a given string.
+      #
+      #     compress File.read('x.js'), :js, :jsmin
+      #
+      def compress(str, type, engine=nil, options={})
+        # Use defaults if no engine is given.
+        return fallback(str, type, options)  if engine.nil?
+
+        # Ensure that the engine exists.
+        klass = compressors[[type, engine]]
+        raise Error, "Engine #{engine} (#{type}) doesn't exist."  unless klass
+
+        # Ensure that the engine can support that type.
+        engine = klass.new
+        raise Error, "#{klass} does not support #{type.upcase} compression."  unless engine.respond_to?(type)
+
+        # Build it using the engine, and fallback to defaults if it fails.
+        output   = engine.send type, str, options
+        output ||= fallback(str, type, options)  unless options[:no_fallback]
+        output
+      end
+
+      # Compresses a given string using the default engines.
+      def fallback(str, type, options)
+        if type == :js
+          compress str, :js, :jsmin, :no_fallback => true
+        elsif type == :css
+          compress str, :css, :simple, :no_fallback => true
+        end
+      end
+
+      def compressors
+        @compressors ||= Hash.new
+      end
+
+      def register(type, engine, meth)
+        compressors[[type, engine]] = meth
+      end
+    end
+
+    require "#{AssetPack::PREFIX}/assetpack/engines/simple"
+    require "#{AssetPack::PREFIX}/assetpack/engines/jsmin"
+    require "#{AssetPack::PREFIX}/assetpack/engines/yui"
+    require "#{AssetPack::PREFIX}/assetpack/engines/sass"
+    require "#{AssetPack::PREFIX}/assetpack/engines/sqwish"
+    require "#{AssetPack::PREFIX}/assetpack/engines/closure"
+    require "#{AssetPack::PREFIX}/assetpack/engines/uglify"
+  end
+end

data/lib/sinatra/assetpack/configurator.rb

@@ -0,0 +1,21 @@
+module Sinatra
+  module AssetPack
+    module Configurator
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def attrib(name)
+          define_method(:"#{name}") { |*a|
+            value = a.first
+            self.instance_variable_set :"@#{name}", value  unless value.nil?
+            self.instance_variable_get :"@#{name}"
+          }
+
+          alias_method(:"#{name}=", :"#{name}")
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/css.rb

@@ -0,0 +1,36 @@
+module Sinatra
+  module AssetPack
+    module Css
+      def self.preproc(str, assets)
+        str.gsub(/url\(["']?(.*?)["']?\)/) { |url|
+          path = $1
+          file, options = path.split('?')
+          local = assets.local_file_for file
+
+          url = if local
+            if options.to_s.include?('embed')
+              to_data_uri(local)
+            else
+              BusterHelpers.add_cache_buster(file, local)
+            end
+          else
+            path
+          end
+
+          "url(#{url})"
+        }
+      end
+
+      def self.to_data_uri(file)
+        require 'base64'
+
+        data = File.read(file)
+        ext  = File.extname(file)
+        mime = Sinatra::Base.mime_type(ext)
+        b64  = Base64.encode64(data).gsub("\n", '')
+
+        "data:#{mime};base64,#{b64}"
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/engine.rb

@@ -0,0 +1,20 @@
+module Sinatra
+  module AssetPack
+    # The base class for all CSS/JS compression engines.
+    class Engine
+      # Helper for system files.
+      # Usage: sys('css', string, "sqwish %f")
+      # Returns stdout.
+      def sys(type, str, cmd)
+        t = Tempfile.new ['', ".#{type}"]
+        t.write(str)
+        t.close
+
+        output = `#{cmd.gsub('%f', t.path)}`
+        FileUtils.rm t
+
+        [output, t.path]
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/engines/closure.rb

@@ -0,0 +1,19 @@
+module Sinatra::AssetPack
+  class ClosureEngine < Engine
+    def js(str, options={})
+      require 'net/http'
+      require 'uri'
+
+      response = Net::HTTP.post_form(URI.parse('http://closure-compiler.appspot.com/compile'), {
+        'js_code' => str,
+        'compilation_level' => options[:level] || "ADVANCED_OPTIMIZATIONS",
+        'output_format' => 'text',
+        'output_info' => 'compiled_code'
+      })
+
+      response.body
+    end
+  end
+
+  Compressor.register :js, :closure, ClosureEngine
+end

data/lib/sinatra/assetpack/engines/jsmin.rb

@@ -0,0 +1,10 @@
+module Sinatra::AssetPack
+  class JsminEngine < Engine
+    def js(str, options={})
+      require 'jsmin'
+      JSMin.minify str
+    end
+  end
+
+  Compressor.register :js, :jsmin, JsminEngine
+end

data/lib/sinatra/assetpack/engines/sass.rb

@@ -0,0 +1,11 @@
+module Sinatra::AssetPack
+  class SassEngine < Engine
+    def css(str, options={})
+      Tilt.new("scss", {:style => :compressed}) { str }.render
+    rescue LoadError
+      nil
+    end
+  end
+
+  Compressor.register :css, :sass, SassEngine
+end

data/lib/sinatra/assetpack/engines/simple.rb

@@ -0,0 +1,11 @@
+module Sinatra::AssetPack
+  class SimpleEngine < Engine
+    def css(str, options={})
+      str.gsub! /[ \r\n\t]+/m, ' '
+      str.gsub! %r{ *([;\{\},:]) *}, '\1'
+      str
+    end
+  end
+
+  Compressor.register :css, :simple, SimpleEngine
+end

data/lib/sinatra/assetpack/engines/sqwish.rb

@@ -0,0 +1,21 @@
+module Sinatra::AssetPack
+  class SqwishEngine < Engine
+    def css(str, options={})
+      cmd = "#{sqwish_bin} %f "
+      cmd += "--strict"  if options[:strict]
+
+      _, input = sys :css, str, cmd
+      output   = input.gsub(/\.css/, '.min.css')
+
+      File.read(output)
+    rescue => e
+      nil
+    end
+
+    def sqwish_bin
+      ENV['SQWISH_PATH'] || "sqwish"
+    end
+  end
+
+  Compressor.register :css, :sqwish, SqwishEngine
+end

data/lib/sinatra/assetpack/engines/uglify.rb

@@ -0,0 +1,12 @@
+module Sinatra::AssetPack
+  class UglifyEngine < Engine
+    def js(str, options={})
+      require 'uglifier'
+      Uglifier.compile str, options
+    rescue => e
+      nil
+    end
+  end
+
+  Compressor.register :js, :uglify, UglifyEngine
+end

data/lib/sinatra/assetpack/engines/yui.rb

@@ -0,0 +1,22 @@
+module Sinatra::AssetPack
+  class YuiEngine < Engine
+    def initialize
+      require 'yui/compressor'
+    end
+
+    def js(str, options={})
+      YUI::JavaScriptCompressor.new(options).compress(str)
+    rescue LoadError
+      nil
+    end
+
+    def css(str, options={})
+      YUI::CssCompressor.new.compress(str)
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+
+  Compressor.register :js,  :yui, YuiEngine
+  Compressor.register :css, :yui, YuiEngine
+end

data/lib/sinatra/assetpack/hasharray.rb

@@ -0,0 +1,66 @@
+module Sinatra
+  module AssetPack
+    # Class: HashArray
+    # A stopgap solution to Ruby 1.8's lack of ordered hashes.
+    #
+    # A HashArray, for all intents and purposes, acts like an array. However, the
+    # common stuff are overloaded to work with hashes.
+    #
+    # ## Basic usage
+    #
+    # #### Creating
+    # You can create a HashArray by passing it an array.
+    #
+    #     dict = HashArray.new([
+    #       { :good_morning => "Bonjour" },
+    #       { :goodbye      => "Au revoir" },
+    #       { :good_evening => "Bon nuit" }
+    #     ])
+    #
+    # #### Converting
+    # You may also use it like so:
+    #
+    #     letters = [ { :a => "Aye"}, { :b => "Bee" } ].to_hash_array
+    #
+    # #### Iterating
+    # Now you can use the typical enumerator functions:
+    #
+    #     dict.each do |(key, value)|
+    #       puts "#{key} is #{value}"
+    #     end
+    #
+    #     #=> :good_morning is "Bonjour"
+    #     #   :goodbye is "Au revoir"
+    #     #   :good_evening is "Bon nuit"
+    #
+    class HashArray < Array
+      def self.[](*arr)
+        new arr.each_slice(2).map { |(k, v)| Hash[k, v] }
+      end
+
+      # Works like Hash#values.
+      def values
+        inject([]) { |a, (k, v)| a << v; a }
+      end
+
+      # Returns everything as a hash.
+      def to_hash
+        inject({}) { |hash, (k, v)| hash[k] = v; hash }
+      end
+
+      def keys
+        inject([]) { |a, (k, v)| a << k; a }
+      end
+
+      [:each, :map, :map!, :reject, :reject!, :select, :select!].each do |meth|
+        send(:define_method, meth) { |*a, &block|
+          if block.respond_to?(:call)
+            super(*a) { |hash| block.call *hash.to_a }
+          else
+            super(*a)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/helpers.rb

@@ -0,0 +1,61 @@
+module Sinatra
+  module AssetPack
+    module Helpers
+      def css(*args)
+        show_asset_pack :css, *args
+      end
+
+      def js(*args)
+        show_asset_pack :js, *args
+      end
+
+      def img(src, options={})
+        attrs = { :src => src }.merge(options)
+
+        local = settings.assets.local_file_for src
+        if local
+          i = Image[local]
+          attrs[:src] = BusterHelpers.add_cache_buster(src, local)
+          if i.dimensions?
+            attrs[:width]  ||= i.width
+            attrs[:height] ||= i.height
+          end
+        end
+
+        "<img#{HtmlHelpers.kv attrs} />"
+      end
+
+      def show_asset_pack(type, *args)
+        names = Array.new
+        while args.first.is_a?(Symbol)
+          names << args.shift
+        end
+
+        options = args.shift  if args.first.is_a?(Hash)
+
+        names.map { |name|
+          show_one_asset_pack type, name, (options || Hash.new)
+        }.join "\n"
+      end
+
+      def show_one_asset_pack(type, name, options={})
+        pack = settings.assets.packages["#{name}.#{type}"]
+        return ""  unless pack
+
+        if (settings.respond_to? 'compressed_env') ? settings.compressed_env : settings.production?
+          pack.to_production_html options
+        else
+          pack.to_development_html options
+        end
+      end
+
+      def asset_filter_css(str)
+        Css.preproc str, settings.assets
+      end
+
+      def asset_path_for(file, from)
+        settings.assets.dyn_local_file_for file, from
+      end
+    end
+  end
+end