sinatra-assetpack 0.0.5

data/lib/sinatra/assetpack/buster_helpers.rb

@@ -0,0 +1,21 @@
+module Sinatra
+  module AssetPack
+    module BusterHelpers
+      extend self
+      # Returns the cache buster suffix for given file(s).
+      # This implementation somewhat obfuscates the mtime to not reveal deployment dates.
+      def cache_buster_hash(*files)
+        i = files.map { |f| File.mtime(f).to_i }.max
+        (i * 4567).to_s.reverse[0...6]
+      end
+
+      # Adds a cache buster for the given path.
+      #
+      #   add_cache_buster('/images/email.png', '/var/www/x/public/images/email.png')
+      #
+      def add_cache_buster(path, *files)
+        path.gsub(/(\.[^.]+)$/) { |ext| ".#{cache_buster_hash *files}#{ext}" }
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/class_methods.rb

@@ -0,0 +1,68 @@
+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!
+      end
+
+      # Add routes for the compressed versions
+      def add_compressed_routes!
+        assets.packages.each do |name, package|
+          get package.route_regex do
+            content_type package.type
+            last_modified package.mtime
+
+            settings.assets.cache[package.hash] ||= package.minify
+          end
+        end
+      end
+
+      # Add the routes for the individual files.
+      def add_individual_routes!
+        assets.served.each do |path, from|
+          get "/#{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
+
+            # Send headers
+            content_type fmt.to_sym
+            last_modified File.mtime(fn).to_i
+
+            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'
+                asset_filter_css File.read(fn)
+              else
+                send_file fn
+              end
+            else
+              # Dynamic file
+              not_found unless AssetPack.tilt_formats[format] == fmt
+              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,109 @@
+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={})
+        engine ||= 'jsmin'   if type == :js
+        engine ||= 'simple'  if type == :css
+
+        key  = :"#{type}/#{engine}"
+        meth = compressors[key]
+        return str  unless meth
+
+        meth[str, options]
+      end
+
+      def compressors
+        @compressors ||= {
+          :'js/jsmin'    => method(:jsmin),
+          :'js/yui'      => method(:yui_js),
+          :'js/closure'  => method(:closure_js),
+          :'css/sass'    => method(:sass),
+          :'css/yui'     => method(:yui_css),
+          :'css/simple'  => method(:simple_css),
+          :'css/sqwish'  => method(:sqwish_css)
+        }
+      end
+
+      # =====================================================================
+      # Compressors
+
+      def jsmin(str, options={})
+        require 'jsmin'
+        JSMin.minify str
+      end
+
+      def sass(str, options={})
+        Tilt.new("scss", {:style => :compressed}) { str }.render
+      rescue LoadError
+        simple_css str
+      end
+
+      def yui_css(str, options={})
+        require 'yui/compressor'
+        YUI::CssCompressor.new.compress(str)
+      rescue Errno::ENOENT
+        sass str
+      end
+
+      def yui_js(str, options={})
+        require 'yui/compressor'
+        YUI::JavaScriptCompressor.new(options).compress(str)
+      rescue LoadError
+        jsmin str
+      end
+
+      def simple_css(str, options={})
+        str.gsub! /[ \r\n\t]+/m, ' '
+        str.gsub! %r{ *([;\{\},:]) *}, '\1'
+      end
+
+      def sqwish_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
+        simple_css str
+      end
+
+      def sqwish_bin
+        ENV['SQWISH_PATH'] || "sqwish"
+      end
+
+      def closure_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
+
+      # For others
+      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/configurator.rb

@@ -0,0 +1,15 @@
+module Sinatra
+  module AssetPack
+    module Configurator
+      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

data/lib/sinatra/assetpack/css.rb

@@ -0,0 +1,35 @@
+module Sinatra
+  module AssetPack
+    module Css
+      def self.preproc(str, assets)
+        str.gsub(/url\(["']?(.*?)["']?\)/) { |url|
+          file, options = $1.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
+            url
+          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/hasharray.rb

@@ -0,0 +1,70 @@
+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#each.
+      #
+      # By extension, methods that rely on #each (like #inject) will work
+      # as intended.
+      #
+      def each(&block)
+        super { |hash| yield hash.to_a.flatten }
+      end
+
+      # Works like Hash#map.
+      def map(&block)
+        super { |hash| yield hash.to_a.flatten }
+      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
+    end
+  end
+end

data/lib/sinatra/assetpack/helpers.rb

@@ -0,0 +1,48 @@
+module Sinatra
+  module AssetPack
+    module Helpers
+      def css(name, options={})
+        show_asset_pack :css, name, options
+      end
+
+      def js(name, options={})
+        show_asset_pack :js, name, options
+      end
+
+      def img(src, options={})
+        attrs = { :src => src }.merge(options)
+
+        local = settings.assets.local_file_for src
+        if local
+          i = Image.new(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, name, options={})
+        pack = settings.assets.packages["#{name}.#{type}"]
+        return ""  unless pack
+
+        if 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

data/lib/sinatra/assetpack/html_helpers.rb

@@ -0,0 +1,17 @@
+module Sinatra
+  module AssetPack
+    module HtmlHelpers
+      extend self
+
+      def e(str)
+        re = Rack::Utils.escape_html str
+        re = re.gsub("/", '/')  # Rack sometimes insists on munging slashes in Ruby 1.8.
+        re
+      end
+
+      def kv(hash)
+        hash.map { |k, v| " #{e k}='#{e v}'" }.join('')
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/image.rb

@@ -0,0 +1,37 @@
+module Sinatra
+  module AssetPack
+    class Image
+      def initialize(file)
+        @file = file
+      end
+
+      def dimensions
+        return @dimensions  unless @dimensions.nil?
+
+         _, _, dim = `identify "#{@file}"`.split(' ')
+         w, h = dim.split('x')
+
+         if w.to_i != 0 && h.to_i != 0
+           @dimensions = [w.to_i, h.to_i]
+         else
+           @dimensions = false
+         end
+
+      rescue => e
+        @dimensions = false
+      end
+
+      def dimensions?
+        !! dimensions
+      end
+
+      def width
+        dimensions? && dimensions[0]
+      end
+
+      def height
+        dimensions? && dimensions[1]
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/options.rb

@@ -0,0 +1,223 @@
+module Sinatra
+  module AssetPack
+    # Assets.
+    #
+    # == Common usage
+    #
+    #     SinatraApp.assets {
+    #       # dsl stuff here
+    #     }
+    #
+    #     a = SinatraApp.assets
+    #
+    # Getting options:
+    #
+    #     a.js_compression
+    #     a.output_path
+    #
+    # Served:
+    #
+    #     a.served         # { '/js' => '/var/www/project/app/js', ... }
+    #                      # (URL path => local path)
+    #
+    # Packages:
+    #
+    #     a.packages       # { 'app.css' => #<Package>, ... }
+    #                      # (name.type => package instance)
+    #
+    # Build:
+    #
+    #     a.build! { |path| puts "Building #{path}" }
+    #
+    # Lookup:
+    #
+    #     a.local_path_for('/images/bg.gif')
+    #     a.served?('/images/bg.gif')
+    #
+    #     a.glob('/js/*.js', '/js/vendor/**/*.js')
+    #     # Returns a HashArray of (local => remote)
+    #
+    class Options
+      extend Configurator
+
+      def initialize(app, &blk)
+        @app             = app
+        @js_compression  = :jsmin
+        @css_compression = :simple
+        @output_path     = app.public
+
+        @js_compression_options  = Hash.new
+        @css_compression_options = Hash.new
+
+        reset!
+
+        # Defaults!
+        serve '/css',    :from => 'app/css'
+        serve '/js',     :from => 'app/js'
+        serve '/images', :from => 'app/images'
+
+        instance_eval &blk  if block_given?
+      end
+
+      # =====================================================================
+      # DSL methods
+
+      def serve(path, options={})
+        raise Error  unless options[:from]
+        return  unless File.directory?(File.join(app.root, options[:from]))
+
+        @served[path] = options[:from]
+      end
+
+      # Undo defaults.
+      def reset!
+        @served   = Hash.new
+        @packages = Hash.new
+      end
+
+      # Adds some JS packages.
+      #
+      #     js :foo, '/js', [ '/js/vendor/jquery.*.js' ]
+      #
+      def js(name, path, files=[])
+        @packages["#{name}.js"] = Package.new(self, name, :js, path, files)
+      end
+
+      # Adds some CSS packages.
+      #
+      #     css :app, '/css', [ '/css/screen.css' ]
+      #
+      def css(name, path, files=[])
+        @packages["#{name}.css"] = Package.new(self, name, :css, path, files)
+      end
+
+      attr_reader   :app        # Sinatra::Base instance
+      attr_reader   :packages   # Hash, keys are "foo.js", values are Packages
+      attr_reader   :served     # Hash, paths to be served.
+                                # Key is URI path, value is local path
+
+      attrib :js_compression    # Symbol, compression method for JS
+      attrib :css_compression   # Symbol, compression method for CSS
+      attrib :output_path       # '/public'
+
+      attrib :js_compression_options   # Hash
+      attrib :css_compression_options  # Hash
+      
+      # =====================================================================
+      # Stuff
+
+      attr_reader :served
+
+      def build!(&blk)
+        session = Rack::Test::Session.new app
+
+        packages.each { |_, pack|
+          out = session.get(pack.path).body
+
+          write pack.path, out, &blk
+          write pack.production_path, out, &blk
+        }
+
+        files.each { |path, local|
+          out = session.get(path).body
+          write path, out, &blk
+          write BusterHelpers.add_cache_buster(path, local), out, &blk
+        }
+      end
+
+      def served?(path)
+        !! local_file_for(path)
+      end
+
+      # Returns the local file for a given URI path.
+      # Returns nil if a file is not found.
+      def local_file_for(path)
+        path = path.squeeze('/')
+
+        uri, local = served.detect { |uri, local| path[0...uri.size] == uri }
+
+        if local
+          path = path[uri.size..-1]
+          path = File.join app.root, local, path
+
+          path  if File.exists?(path)
+        end
+      end
+
+      # Returns the local file for a given URI path. (for dynamic files)
+      # Returns nil if a file is not found.
+      # TODO: consolidate with local_file_for
+      def dyn_local_file_for(file, from)
+        # Remove extension
+        file = $1  if file =~ /^(.*)(\.[^\.]+)$/
+
+        # Remove cache-buster (/js/app.28389.js => /js/app)
+        file = $1  if file =~ /^(.*)\.[0-9]+$/
+
+        Dir[File.join(app.root, from, "#{file}.*")].first
+      end
+
+      # Writes `public/#{path}` based on contents of `output`.
+      def write(path, output)
+        require 'fileutils'
+
+        path = File.join(@output_path, path)
+        yield path  if block_given?
+
+        FileUtils.mkdir_p File.dirname(path)
+        File.open(path, 'w') { |f| f.write output }
+      end
+
+      # Returns the files as a hash.
+      def files(match=nil)
+          # All
+          # A buncha tuples
+          tuples = @served.map { |prefix, local_path|
+            path = File.expand_path(File.join(@app.root, local_path))
+            spec = File.join(path, '**', '*')
+
+            Dir[spec].map { |f|
+              [ to_uri(f, prefix, path), f ]  unless File.directory?(f)
+            }
+          }.flatten.compact
+
+          Hash[*tuples]
+      end
+
+      # Returns an array of URI paths of those matching given globs.
+      def glob(*match)
+        tuples = match.map { |spec|
+          paths = files.keys.select { |f| File.fnmatch?(spec, f) }.sort
+          paths.map { |key| [key, files[key]] }
+        }
+
+        HashArray[*tuples.flatten]
+      end
+
+      def cache
+        @cache ||= Hash.new
+      end
+
+      def reset_cache
+        @cache = nil && cache
+      end
+
+    private
+      # Returns a URI for a given file
+      #     path = '/projects/x/app/css'
+      #     to_uri('/projects/x/app/css/file.sass', '/styles', path) => '/styles/file.css'
+      #
+      def to_uri(f, prefix, path)
+        fn = (prefix + f.gsub(path, '')).squeeze('/')
+
+        # Switch the extension ('x.sass' => 'x.css')
+        file_ext = File.extname(fn).to_s[1..-1]
+        out_ext  = AssetPack.tilt_formats[file_ext]
+
+        fn = fn.gsub(/\.#{file_ext}$/, ".#{out_ext}")  if file_ext && out_ext
+
+        fn
+      end
+    end
+  end
+end