stapler 0.1.0 → 0.4.1

data/README.md

@@ -1,31 +1,54 @@
-= stapler 
-
-== DESCRIPTION:
+Stapler
+=======
 
 Stapler uses YUI Compressor to automatically compress cached assets in Rails
 
-== FEATURES/PROBLEMS:
 
-* Support both CSS and Javascript 
+Features/Problems
+-----------------
+
+* Support both CSS and Javascript
+
 
-== REQUIREMENTS:
+Requirements
+------------
 
 * yuicompressor gem
 
-== INSTALL:
+TODO
+------------
+
+* warnings if the bundle URL is longer than 2048 chars (for IE)
+* make sure that Config.secret is not a class variable
+* logging
+* specs
+* pass 404 errors to the underlying app
+
+Install
+-------
 
 * gem install stapler
 
-== REFERENCES:
 
-  * YUI Compressor
-    http://developer.yahoo.com/yui/compressor/ 
+References
+----------
+
+  * YUI Compressor - <http://developer.yahoo.com/yui/compressor/>
+  * yuicompressor gem - <http://github.com/mjijackson/yuicompressor>
+
+
+Author
+------
+
+Michael Rykov :: missingfeature.com :: @michaelrykov
+
 
-== LICENSE:
+License
+-------
 
 (The MIT License)
 
-Copyright (c) 2009  Michael Rykov 
+Copyright (c) 2009  Michael Rykov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/stapler.rb

@@ -5,12 +5,13 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'yuicompressor'
+require 'stapler/utils'
+require 'stapler/asset'
+require 'stapler/bundle/key'
+require 'stapler/bundle'
 require 'stapler/config'
-require 'stapler/compressor'
-require 'stapler/stapler'
-require 'stapler/helper'
 require 'stapler/middleware'
 
-if defined?(::ActionView::Helpers)
-  ::ActionView::Helpers.send(:include, Stapler::Helper)
-end
+if defined?(Rails)
+  require 'stapler/rails'
+end

data/lib/stapler/asset.rb

@@ -0,0 +1,37 @@
+#--
+# Copyright (c) Michael Rykov
+#++
+
+module Stapler
+  class Asset
+    FORBIDDEN_PATHS = %w(.. WEB-INF META-INF)
+    REWRITE_KEYS = %w(PATH_INFO REQUEST_PATH REQUEST_URI)
+
+    def initialize(config, path)
+      @config = config
+      @path = Utils.groom_path(path)
+    end
+
+    def response(env)
+      if forbidden?
+        @config.rack_file.not_found
+      else
+        @config.rack_file.call(rewrite_env(env))
+      end
+    end
+
+  private
+    def forbidden?
+      FORBIDDEN_PATHS.any? { |fp| @path.include?(fp) }
+    end
+
+    def rewrite_env(env)
+      out = env.dup
+      REWRITE_KEYS.each do |key|
+        next unless out[key].is_a?(String)
+        out[key] = out[key].gsub(@config.path_regex, @path)
+      end
+      out
+    end
+  end
+end

data/lib/stapler/bundle.rb

@@ -0,0 +1,41 @@
+#--
+# Copyright (c) Michael Rykov
+#++
+require 'rack/utils'
+require 'rack/file'
+
+module Stapler
+  class Bundle
+    def initialize(config, bundle)
+      @config = config
+      @paths = Key.to_paths(bundle.to_s)
+    end
+
+    # Collect asset responses and build the collective response
+    def response(env)
+      if not @paths.is_a?(Array)
+        @config.rack_file.not_found
+      else
+        @paths.inject([200, {}, '']) do |sum, path|
+          # Fetch the response
+          item = Stapler::Asset.new(@config, path).response(env)
+
+          # Add the file title
+          sum[2] << "\n\n\n/***** #{path} *****/\n\n\n"
+
+          if item[0] != 200
+            sum[2] << "/* [#{item[0]}] Asset problem */\n\n\n"
+          else
+            # Headers are merged
+            sum[1].merge!(item[1])
+            # Body is concatenated
+            sum[2] << Stapler::Utils.response_body(item)
+          end
+
+          # Return the response
+          sum
+        end
+      end
+    end
+  end
+end

data/lib/stapler/bundle/key.rb

@@ -0,0 +1,12 @@
+#--
+# Copyright (c) Michael Rykov
+#++
+
+require 'stapler/bundle/serialized_key'
+
+# Placeholder that will be configurable in the future
+module Stapler
+  class Bundle
+    Key = SerializedKey
+  end
+end

data/lib/stapler/bundle/serialized_key.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) Michael Rykov
+#++
+
+module Stapler
+  class Bundle
+    class SerializedKey; end
+    @@asset_id = Time.now.to_i.to_s
+
+    class << SerializedKey
+      def to_key(paths)
+        key = Utils.url_encode(paths.map { |a| Utils.groom_path(a) })
+        File.join(key, signature(key), @@asset_id)
+      end
+
+      def to_paths(bundle)
+        key, signature = bundle.split(/[\.\/]/, 3)
+        url_decode_with_signature(key, signature)
+      rescue Utils::BadString
+        nil
+      end
+
+    private
+      # Security signature for URLs #
+      def signature(key)
+        Digest::SHA1.hexdigest("#{key}#{Config.secret}")[0...8]
+      end
+
+      def url_decode_with_signature(key, key_signature)
+        if signature(key.to_s) == key_signature.to_s
+          Utils.url_decode(key)
+        else
+          raise BadString, "Invalid signature"
+        end
+      end
+    end
+  end
+end

data/lib/stapler/config.rb

@@ -5,11 +5,64 @@
 #++
 
 module Stapler
-  module Config
-    WHITELIST = [%r{^/javascripts/.*\.js$}, %r{^/stylesheets/.*\.css$}]
+  class Config
+    PREFIX = 'stapler'
+    WHITELIST_DIR = %w(javascripts stylesheets)
+    WHITELIST_RE = Regexp.union(
+      %r{^/javascripts/.*\.js($|\?)},
+      %r{^/stylesheets/.*\.css($|\?)}
+    )
 
-    def self.stapleable?(source)
-      ActionController::Base.perform_caching && WHITELIST.any? { |re| source =~ re }
+    STAPLIZE_RE = Regexp.union(
+      %r{/javascripts/.*\.js($|\?)},
+      %r{/stylesheets/.*\.css($|\?)}
+    )
+
+    class << self
+      def stapleable_path?(source)
+        source =~ WHITELIST_RE
+      end
+
+      def stapleable_dir?(dir)
+        WHITELIST_DIR.include?(dir)
+      end
+
+      def staplize_url(url)
+        url.gsub(STAPLIZE_RE, "/#{PREFIX}\\0")
+      end
+    end
+
+    DEFAULT_ROOT = defined?(Rails) ? Rails.public_path : 'public'
+    DEFAULT_PREFIX = 'stapler'
+
+    attr_accessor :path_regex, :bundle_regex, :rack_file,
+                  :perform_caching, :perform_compress
+
+    def initialize(opts = {})
+      # The root directory of where all the public files are stored
+      asset_dir    = opts[:public_path] || DEFAULT_ROOT
+
+      # The path prefix and correcsponding RegEx for stapled assets
+      path_prefix   = opts[:path_prefix] || DEFAULT_PREFIX
+      @path_regex   = %r(^/#{path_prefix}/(.+)$)
+      @bundle_regex = %r(^/#{path_prefix}/bundle/(.+)$)
+
+      # Rack::File will pull all the source files
+      @rack_file = Rack::File.new(asset_dir)
+
+      # Should we write stapled results and where?
+      @perform_caching = opts[:cache_assets] || false
+
+      # Should we compress stapled results
+      @perform_compress = opts[:compress_assets] || false
+
+      # Bundle URL signature secret
+      @@secret = opts[:secret] || 'nakedemperor'
+    end
+
+    # FIXME: This should not be class variable
+    def self.secret
+      @@secret
     end
   end
 end

data/lib/stapler/middleware.rb

@@ -1,35 +1,70 @@
+require 'rack/utils'
+require 'rack/file'
+
 module Stapler
   class Middleware
-    ASSETS_DIR = defined?(Rails.public_path) ? Rails.public_path : "public"
-
-    def initialize(app)
+    def initialize(app, opts = {})
       @app = app
+      @config = Stapler::Config.new(opts)
     end
 
     def call(env)
-      path = env['PATH_INFO']
-      puts "LOOKING AT PATH #{path}"
+      path_info = env["PATH_INFO"]
 
-      if path =~ %r(^/stapler/(.*)$)
-        stapler_call(env, $1)
+      if path_info =~ @config.bundle_regex
+        _call_bundle(env, Rack::Utils.unescape($1))
+      elsif path_info =~ @config.path_regex
+        _call_asset(env, Rack::Utils.unescape($1))
       else
         @app.call(env)
       end
     end
 
   private
-    def stapler_call(env, path)
-      file_path = asset_file_path(path)
+    def _call_bundle(env, path)
+      bundle = Stapler::Bundle.new(@config, path)
+      staple_response(bundle.response(env), "bundle/#{path}")
+    end
+
+    def _call_asset(env, path)
+      assets = Stapler::Asset.new(@config, path)
+      staple_response(assets.response(env), path)
+    end
+
+    def staple_response(response, asset_path)
+      if response[0] == 200
+        # Pull out the body
+        body = Stapler::Utils.response_body(response)
+
+        # Compress the body and update response
+        body = compress(body, asset_path) if @config.perform_compress
+
+        # Prepare the response and headers
+        response[1]['Content-Length'] = Rack::Utils.bytesize(body).to_s
+        response[2] = body
+
+        # Add cache headers for Rack::Cache, etc
+        response[1].merge!(cache_headers(asset_path))
+      end
+
+      response
+    end
 
-      if File.file?(file_path)
-        [200, {"Content-Type" => "text/plain"}, ['NOT DONE!']]
+    def compress(content, path)
+      # Compress using the path as an indicator for format
+      if path =~ /\.css$/
+        YUICompressor.compress_css(content)
+      elsif path =~ /\.js$/
+        YUICompressor.compress_js(content, :munge => true)
       else
-        [404, {"Content-Type" => "text/html"}, ["Not Found!"]]
+        content
       end
     end
 
-    def asset_file_path(path)
-      File.join(ASSETS_DIR, path.split('?').first)
+    def cache_headers(path)
+      duration = @config.perform_caching ? 31536000 : 0
+      { "Cache-Control" => "public, max-age=#{duration.to_s}",
+        "ETag" => %("#{Digest::SHA1.hexdigest(path)}") }
     end
   end
 end

data/lib/stapler/rails.rb

@@ -0,0 +1,65 @@
+#--
+# Copyright (c) 2010 Michael Rykov
+#++
+
+module Stapler
+  module Rails
+    class << self
+      def activate!
+        ::ActionView::Base.send(:include, RailsHelper)
+      end
+
+      def asset_host_proc(image_host = nil)
+        prefix = File.join('/', Config::PREFIX)
+        if image_host
+          Proc.new { |source|
+            host = image_host
+            host << prefix if Config.stapleable_path?(source)
+            host
+          }
+        else
+          Proc.new { |source, request|
+            host = request.host_with_port
+            host << prefix if Config.stapleable_path?(source)
+            host
+          }
+        end
+      end
+    end
+
+    module RailsHelper
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+
+        if options.delete('cache') || options.delete('concat')
+          recursive = options.delete('recursive')
+          paths = compute_javascript_paths(sources, recursive)
+          javascript_src_tag(Utils.bundle_path(paths), options)
+        else
+          sources << options
+          super(*sources)
+        end
+      end
+
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+
+        if options.delete('cache') || options.delete('concat')
+          recursive = options.delete('recursive')
+          paths = compute_stylesheet_paths(sources, recursive)
+          stylesheet_tag(Utils.bundle_path(paths), options)
+        else
+          sources << options
+          super(*sources)
+        end
+      end
+
+    private
+      def compute_public_path(src, dir, ext = nil, include_host = true)
+        staple = include_host && src !~ %r{^[-a-z]+://} && Config.stapleable_dir?(dir)
+        path = super(src, dir, ext, include_host)
+        staple ? Config.staplize_url(path) : path
+      end
+    end
+  end
+end

data/lib/stapler/utils.rb

@@ -0,0 +1,54 @@
+#--
+# Copyright (c) Michael Rykov
+#
+# Some methods copied from Dragonfly gem Serializer
+#++
+
+require 'base64'
+require 'cgi'
+require 'digest/sha1'
+
+module Stapler
+  module Utils
+    # Exceptions
+    class BadString < RuntimeError; end
+
+    class << self
+      def response_body(response)
+        body = response[2]
+        body.is_a?(Rack::File) ? File.read(body.path) : body
+      end
+
+      #### Base64 encoding for URLS ####
+      def b64_encode(string)
+        Base64.encode64(string).tr("\n=",'')
+      end
+
+      def b64_decode(string)
+        padding_length = string.length % 4
+        Base64.decode64(string + '=' * padding_length)
+      end
+
+      def url_encode(object)
+        CGI.escape(b64_encode(Marshal.dump(object)))
+      end
+
+      def url_decode(string)
+        Marshal.load(b64_decode(CGI.unescape(string)))
+      rescue TypeError, ArgumentError => e
+        raise BadString, "couldn't decode #{string} - got #{e}"
+      end
+
+      def groom_path(path)
+        # Remove leading slashes and query params
+        path.gsub(/^\//, '').gsub(/\?.*$/, '')
+      end
+
+      # Convert a list of assets into an URL
+      # Note: Rails helpers adds the appropriate extension
+      def bundle_path(assets)
+        File.join('/stapler/bundle/', Bundle::Key.to_key(assets))
+      end
+    end
+  end
+end

metadata

@@ -1,94 +1,71 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: stapler
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Michael Rykov
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-08-27 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: yuicompressor
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70096179375860 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 1
-        - 2
-        - 0
+      - !ruby/object:Gem::Version
         version: 1.2.0
   type: :runtime
-  version_requirements: *id001
-description: |
-  Dynamic asset compression for Rails using YUI Compressor
+  prerelease: false
+  version_requirements: *70096179375860
+description: ! 'Dynamic asset compression for Rails using YUI Compressor
 
+'
 email: mrykov@gmail
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README.md
 - Rakefile
 - LICENSE
-- lib/stapler/compressor.rb
+- lib/stapler/asset.rb
+- lib/stapler/bundle/key.rb
+- lib/stapler/bundle/serialized_key.rb
+- lib/stapler/bundle.rb
 - lib/stapler/config.rb
-- lib/stapler/helper.rb
 - lib/stapler/middleware.rb
-- lib/stapler/stapler.rb
+- lib/stapler/rails.rb
+- lib/stapler/utils.rb
 - lib/stapler.rb
 - lib/tasks/stapler.rake
 - lib/tasks/tasks.rb
-has_rdoc: false
 homepage: http://github.com/rykov/stapler
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Dynamic asset compression for Rails
 test_files: []
-

data/lib/stapler/compressor.rb

@@ -1,40 +0,0 @@
-#--
-# Copyright (c) 2009 Michael Rykov
-#++
-
-module Stapler
-  class Compressor
-    def initialize(from, to)
-      @from_path = from
-      @to_path = to
-    end
-
-    def compress!
-      compress(@from_path, @to_path)
-      logger.info("[Stapler] Compressed #{@from_path}")
-    rescue => e
-      logger.warn("[Stapler] Compression failure for #{@from_path}: #{e}")
-      FileUtil.cp(@from_path, @to_path)
-    end
-
-  protected
-    def compress(from, to)
-      out = File.open(from) do |from_file|
-        if from =~ /\.css$/
-          YUICompressor.compress_css(from_file)
-        elsif from =~ /\.js$/
-          YUICompressor.compress_js(from_file, :munge => true)
-        else
-          raise StandardError.new("Unrecognized file type")
-        end
-      end
-
-      File.open(to, 'w') { |f| f.write(out) }
-    end
-
-    def logger
-      Rails.logger
-    end
-  end
-end
-

data/lib/stapler/helper.rb

@@ -1,35 +0,0 @@
-#--
-# Copyright (c) 2009 Michael Rykov
-#++
-
-module Stapler
-  module Helper
-    StaplerRoot = "/stapler"
-
-    def self.included(base)
-      base.send :alias_method_chain, :rewrite_asset_path, :stapler
-      #base.send :alias_method_chain, :compute_asset_host, :stapler
-    end
-
-  private
-    def rewrite_asset_path_with_stapler(source)
-      if Config.stapleable?(source)
-        @@stapler ||= Stapler.new
-        stapled_source = "#{StaplerRoot}#{source}"
-        stapled_path = asset_file_path(stapled_source)
-
-        if @@stapler.ready?(stapled_path)
-          source = stapled_source
-        else
-          @@stapler.process(asset_file_path(source), stapled_path)
-        end
-      end
-
-      rewrite_asset_path_without_stapler(source)
-    end
-
-    #def compute_asset_host_with_stapler(source)
-    #  compute_asset_host_without_stapler(source)
-    #end
-  end
-end

data/lib/stapler/stapler.rb

@@ -1,33 +0,0 @@
-#--
-# Copyright (c) 2009 Michael Rykov
-#++
-
-module Stapler
-  class Stapler
-
-    def initialize
-      @in_progress = {}
-      @in_progress_guard = Mutex.new
-    end
-
-    def ready?(path)
-      !@in_progress[path] && File.exists?(path)
-    end
-
-    def process(from, to)
-      @in_progress_guard.synchronize do
-        return if @in_progress[to]
-        @in_progress[to] = true
-      end
-
-      Thread.new { self.compress(from, to) }
-    end
-
-  protected
-    def compress(from, to)
-      FileUtils.mkdir_p(File.dirname(to))
-      Compressor.new(from, to).compress!
-      @in_progress.delete(to)
-    end
-  end
-end