foresth-cloudfront_asset_host 1.0.3

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Menno van der Sman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,88 @@
+# CloudFront AssetHost
+
+Easy deployment of your assets on CloudFront or S3. When enabled in production, your assets will be served from CloudFront/S3 which will result in a speedier front-end.
+
+## Why?
+
+Hosting your assets on CloudFront ensures minimum latency for all your visitors. But deploying your assets requires some additional management that this gem provides.
+
+### Expiration
+
+The best way to expire your assets on CloudFront is to upload the asset to a new unique url. The gem will calculate the MD5-hash of the asset and incorporate that into the URL.
+
+### Efficient uploading
+
+By using the MD5-hash we can easily determined which assets aren't uploaded yet. This speeds up the deployment considerably.
+
+### Compressed assets
+
+CloudFront will not serve compressed assets automatically. To counter this, the gem will upload gzipped javascripts and stylesheets and serve them when the user-agent supports it.
+
+## Installing
+
+    gem install cloudfront_asset_host
+
+Include the gem in your app's `environment.rb` or `Gemfile`.
+
+### Dependencies
+
+The gem relies on `openssl md5` and `gzip` utilities. Make sure they are available locally and on your servers.
+
+### Configuration
+
+Make sure your s3-credentials are stored in _config/s3.yml_ like this:
+
+    access_key_id: 'access_key'
+    secret_access_key: 'secret'
+
+Create an initializer to configure the plugin _config/initializers/cloudfront_asset_host.rb_
+
+    # Simple configuration
+    CloudfrontAssetHost.configure do |config|
+      config.bucket = "bucketname" # required
+      config.enabled = true if Rails.env.production? # only enable in production
+    end
+
+    # Extended configuration
+    CloudfrontAssetHost.configure do |config|
+      config.bucket     = "bucketname"        # required
+      config.cname      = "assets.domain.com" # if you have a cname configured for your distribution or bucket
+      config.key_prefix = "app/"              # if you share the bucket and want to keep things separated
+      config.s3_config  = "#{RAILS_ROOT}/config/s3.yml" # Alternative location of your s3-config file
+
+      # gzip related configuration
+      config.gzip = true                      # enable gzipped assets (defaults to true)
+      config.gzip_extensions = ['js', 'css']  # only gzip javascript or css (defaults to %w(js css))
+      config.gzip_prefix = "gz"               # prefix for gzipped bucket (defaults to "gz")
+
+      config.enabled = true if Rails.env.production? # only enable in production
+    end
+
+## Usage
+
+### Uploading your assets
+Run `CloudfrontAssetHost::Uploader.upload!(:verbose => true, :dryrun => false)` before your deployment. Put it for example in your Rakefile or capistrano-recipe. Verbose output will include information about which keys are being uploaded. Enabling _dryrun_ will skip the actual upload if you're just interested to see what will be uploaded.
+
+### Hooks
+If the plugin is enabled. Rails' internal `asset_host` and `asset_id` functionality will be overridden to point to the location of the assets on Cloudfront.
+
+### Other plugins
+When using in combination with SASS and/or asset_packager it is recommended to generate the css-files and package your assets before uploading them to Cloudfront. For example, call     `Sass::Plugin.update_stylesheets` and `Synthesis::AssetPackage.build_all` first.
+
+## Contributing
+
+Feel free to fork the project and send pull-requests.
+
+## Known Limitations
+
+ - Does not delete old assets
+
+## Compatibility
+
+Tested on Rails 2.3.5 with SASS and AssetPackager plugins
+
+## Copyright
+
+Created at Wakoopa
+
+Copyright (c) 2010 Menno van der Sman, released under the MIT license

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the cloudfront_asset_host plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the cloudfront_asset_host plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CloudfrontAssetHost'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "cloudfront_asset_host"
+    gemspec.summary = "Rails plugin to easily and efficiently deploy your assets on Amazon's S3 or CloudFront"
+    gemspec.description = "Easy deployment of your assets on CloudFront or S3 using a simple rake-task. When enabled in production, the application's asset_host and public_paths will point to the correct location."
+    gemspec.email = "menno@wakoopa.com"
+    gemspec.homepage = "http://github.com/menno/cloudfront_asset_host"
+    gemspec.authors = ["Menno van der Sman"]
+    gemspec.add_dependency 'right_aws'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.2

data/cloudfront_asset_host.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{foresth-cloudfront_asset_host}
+  s.version = "1.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Menno van der Sman"]
+  s.date = %q{2010-07-27}
+  s.description = %q{Easy deployment of your assets on CloudFront or S3 using a simple rake-task. When enabled in production, the application's asset_host and public_paths will point to the correct location.}
+  s.email = %q{menno@wakoopa.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "cloudfront_asset_host.gemspec",
+     "lib/cloudfront_asset_host.rb",
+     "lib/cloudfront_asset_host/asset_tag_helper_ext.rb",
+     "lib/cloudfront_asset_host/css_rewriter.rb",
+     "lib/cloudfront_asset_host/mime_types.yml",
+     "lib/cloudfront_asset_host/uploader.rb",
+     "test/app/config/s3.yml",
+     "test/app/public/images/image.png",
+     "test/app/public/javascripts/application.js",
+     "test/app/public/stylesheets/style.css",
+     "test/cloudfront_asset_host_test.rb",
+     "test/css_rewriter_test.rb",
+     "test/test_helper.rb",
+     "test/uploader_test.rb"
+  ]
+  s.homepage = %q{http://github.com/foresth/cloudfront_asset_host}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Rails plugin to easily and efficiently deploy your assets on Amazon's S3 or CloudFront}
+  s.test_files = [
+    "test/cloudfront_asset_host_test.rb",
+     "test/css_rewriter_test.rb",
+     "test/test_helper.rb",
+     "test/uploader_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<right_aws>, [">= 0"])
+    else
+      s.add_dependency(%q<right_aws>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<right_aws>, [">= 0"])
+  end
+end
+

data/lib/cloudfront_asset_host.rb

@@ -0,0 +1,136 @@
+require 'cloudfront_asset_host/asset_tag_helper_ext'
+require 'digest/md5'
+
+module CloudfrontAssetHost
+
+  autoload :Uploader,    'cloudfront_asset_host/uploader'
+  autoload :CssRewriter, 'cloudfront_asset_host/css_rewriter'
+
+  # Bucket that will be used to store all the assets (required)
+  mattr_accessor :bucket
+
+  # CNAME that is configured for the bucket or CloudFront distribution
+  mattr_accessor :cname
+
+  # Prefix keys
+  mattr_accessor :key_prefix
+
+  # Path to S3 config. Expects an +access_key_id+ and +secret_access_key+
+  mattr_accessor :s3_config
+  
+  # Log S3 server access on a bucket
+  mattr_accessor :s3_logging
+
+  # Indicates whether the plugin should be enabled
+  mattr_accessor :enabled
+
+  # Upload gzipped assets and serve those assets when applicable
+  mattr_accessor :gzip
+
+  # Which extensions to serve as gzip
+  mattr_accessor :gzip_extensions
+
+  # Key-prefix under which to store gzipped assets
+  mattr_accessor :gzip_prefix
+  
+  # Which extensions are likely to occur in css files
+  mattr_accessor :image_extensions
+
+  class << self
+
+    def configure
+      # default configuration
+      self.bucket     = nil
+      self.cname      = nil
+      self.key_prefix = ""
+      self.s3_config  = "#{RAILS_ROOT}/config/s3.yml"
+      self.s3_logging = false
+      self.enabled    = false
+
+      self.gzip            = true
+      self.gzip_extensions = %w(js css)
+      self.gzip_prefix     = "gz"
+      
+      self.image_extensions = %w(jpg jpeg gif png)
+
+      yield(self)
+
+      if properly_configured?
+        enable!
+      end
+    end
+
+    def asset_host(source = nil, request = nil)
+      if cname.present?
+        if cname.is_a?(Proc) 
+          host = cname.call(source, request)
+        else
+          host = (cname =~ /%d/) ? cname % (source.hash % 4) : cname
+        end
+      else
+        host = "http://#{self.bucket_host}"
+      end
+
+      if source && request && CloudfrontAssetHost.gzip
+        gzip_allowed  = CloudfrontAssetHost.gzip_allowed_for_source?(source)
+
+        # Only Netscape 4 does not support gzip
+        # IE masquerades as Netscape 4, so we check that as well
+        user_agent = request.headers['User-Agent'].to_s
+        gzip_accepted = !(user_agent =~ /^Mozilla\/4/) || user_agent =~ /\bMSIE/
+        gzip_accepted &&= request.headers['Accept-Encoding'].to_s.include?('gzip')
+
+        if gzip_accepted && gzip_allowed
+          host << "/#{CloudfrontAssetHost.gzip_prefix}"
+        end
+      end
+
+      host
+    end
+
+    def bucket_host
+      "#{self.bucket}.s3.amazonaws.com"
+    end
+
+    def enable!
+      if enabled
+        ActionController::Base.asset_host = Proc.new { |source, request| CloudfrontAssetHost.asset_host(source, request) }
+        ActionView::Helpers::AssetTagHelper.send(:alias_method_chain, :rewrite_asset_path, :cloudfront)
+        ActionView::Helpers::AssetTagHelper.send(:alias_method_chain, :rails_asset_id, :cloudfront)
+      end
+    end
+
+    def key_for_path(path)
+      key_prefix + md5sum(path)[0..8]
+    end
+
+    def gzip_allowed_for_source?(source)
+      extension = source.split('.').last
+      CloudfrontAssetHost.gzip_extensions.include?(extension)
+    end
+    
+    def image?(path)
+      extension = path.split('.').last
+      CloudfrontAssetHost.image_extensions.include?(extension)
+    end
+    
+    def css?(path)
+      File.extname(path) == '.css'
+    end
+
+  private
+
+    def properly_configured?
+      raise "You'll need to specify a bucket" if bucket.blank?
+      raise "Could not find S3-configuration" unless File.exists?(s3_config)
+      true
+    end
+
+    def md5sum(path)
+      #`openssl md5 #{path}`.split(/\s/)[1].to_s
+      Digest::MD5.hexdigest(File.read(path))
+    end
+
+  end
+
+end

data/lib/cloudfront_asset_host/asset_tag_helper_ext.rb

@@ -0,0 +1,37 @@
+module ActionView
+  module Helpers
+    module AssetTagHelper
+
+    private
+
+      # Override asset_id so it calculates the key by md5 instead of modified-time
+      def rails_asset_id_with_cloudfront(source)
+        if @@cache_asset_timestamps && (asset_id = @@asset_timestamps_cache[source])
+          asset_id
+        else
+          path = File.join(ASSETS_DIR, source)
+          asset_id = File.exist?(path) ? CloudfrontAssetHost.key_for_path(path) : ''
+
+          if @@cache_asset_timestamps
+            @@asset_timestamps_cache_guard.synchronize do
+              @@asset_timestamps_cache[source] = asset_id
+            end
+          end
+
+          asset_id
+        end
+      end
+
+      # Override asset_path so it prepends the asset_id
+      def rewrite_asset_path_with_cloudfront(source)
+        asset_id = rails_asset_id(source)
+        if asset_id.blank?
+          source
+        else
+          "/#{asset_id}#{source}"
+        end
+      end
+
+    end
+  end
+end

data/lib/cloudfront_asset_host/css_rewriter.rb

@@ -0,0 +1,65 @@
+require 'tempfile'
+
+module CloudfrontAssetHost
+  module CssRewriter
+
+    # Location of the stylesheets directory
+    mattr_accessor :stylesheets_dir
+    self.stylesheets_dir = File.join(Rails.public_path, 'stylesheets')
+
+    class << self
+      # matches optional quoted url(<path>)
+      ReplaceRexeg = /url\(["']?([^\)"']+)["']?\)/i
+
+      # Returns the path to the temporary file that contains the
+      # rewritten stylesheet
+      def rewrite_stylesheet(path)
+        contents = File.read(path)
+        contents.gsub!(ReplaceRexeg) do |match|
+          rewrite_asset_link(match, path)
+        end
+
+        tmp = Tempfile.new("cfah-css")
+        tmp.write(contents)
+        tmp.flush
+        tmp
+      end
+
+    private
+
+      def rewrite_asset_link(asset_link, stylesheet_path)
+        url = asset_link.match(ReplaceRexeg)[1]
+        if url
+          path = path_for_url(url, stylesheet_path)
+
+          if path.present? && File.exists?(path)
+            key = CloudfrontAssetHost.key_for_path(path) + path.gsub(Rails.public_path, '')
+            "url(#{CloudfrontAssetHost.asset_host}/#{key})"
+          else
+            puts "Could not extract path: #{path}"
+            asset_link
+          end
+        else
+          puts "Could not find url in #{asset_link}"
+          asset_link
+        end
+      end
+
+      def path_for_url(url, stylesheet_path)
+        if url.starts_with?('/')
+          # absolute to public path
+          File.expand_path(File.join(Rails.public_path, url))
+        else
+          # relative to stylesheet_path
+          File.expand_path(File.join(File.dirname(stylesheet_path), url))
+        end
+      end
+
+      def stylesheets_to_rewrite
+        Dir.glob("#{stylesheets_dir}/**/*.css")
+      end
+
+    end
+
+  end
+end

data/lib/cloudfront_asset_host/mime_types.yml

@@ -0,0 +1,151 @@
+"text/html":
+ - html
+ - htm
+ - shtml
+"text/css":
+ - css
+"text/xml":
+ - xml
+ - rss
+"image/gif":
+ - gif
+"image/jpeg":
+ - jpeg
+ - jpg
+"application/x-javascript":
+ - js
+"application/atom+xml":
+ - atom
+"text/mathml":
+ - mml
+"text/plain":
+ - txt
+"text/vnd.sun.j2me.app-descriptor":
+ - jad
+"text/vnd.wap.wml":
+ - wml
+"text/x-component":
+ - htc
+"image/png":
+ - png
+"image/tiff":
+ - tif
+ - tiff
+"image/vnd.wap.wbmp":
+ - wbmp
+"image/x-icon":
+ - ico
+"image/x-jng":
+ - jng
+"image/x-ms-bmp":
+ - bmp
+"image/svg+xml":
+ - svg
+"application/java-archive":
+ - jar
+ - war
+ - ear
+"application/mac-binhex40":
+ - hqx
+"application/msword":
+ - doc
+"application/pdf":
+ - pdf
+"application/postscript":
+ - ps
+ - eps
+ - ai
+"application/rtf":
+ - rtf
+"application/vnd.ms-excel":
+ - xls
+"application/vnd.ms-powerpoint":
+ - ppt
+"application/vnd.wap.wmlc":
+ - wmlc
+"application/vnd.wap.xhtml+xml":
+ - xhtml
+"application/x-cocoa":
+ - cco
+"application/x-java-archive-diff":
+ - jardiff
+"application/x-java-jnlp-file":
+ - jnlp
+"application/x-makeself":
+ - run
+"application/x-perl":
+ - pl
+ - pm
+"application/x-pilot":
+ - prc
+ - pdb
+"application/x-rar-compressed":
+ - rar
+"application/x-redhat-package-manager":
+ - rpm
+"application/x-sea":
+ - sea
+"application/x-shockwave-flash":
+ - swf
+"application/x-stuffit":
+ - sit
+"application/x-tcl":
+ - tcl
+ - tk
+"application/x-x509-ca-cert":
+ - der
+ - pem
+ - crt
+"application/x-xpinstall":
+ - xpi
+"application/zip":
+ - zip
+"application/octet-stream":
+ - bin
+ - exe
+ - dll
+"application/octet-stream":
+ - deb
+"application/octet-stream":
+ - dmg
+"application/octet-stream":
+ - eot
+"application/octet-stream":
+ - iso
+ - img
+"application/octet-stream":
+ - msi
+ - msp
+ - msm
+"audio/midi":
+ - mid
+ - midi
+ - kar
+"audio/mpeg":
+ - mp3
+"audio/x-realaudio":
+ - ra
+"video/3gpp":
+ - 3gpp
+ - 3gp
+"video/mpeg":
+ - mpeg
+ - mpg
+"video/quicktime":
+ - mov
+"video/x-flv":
+ - flv
+"video/x-mng":
+ - mng
+"video/x-ms-asf":
+ - asx
+ - asf
+"video/x-ms-wmv":
+ - wmv
+"video/x-msvideo":
+ - avi
+"text/plain":
+ - py
+ - php
+ - config
+ - txt

data/lib/cloudfront_asset_host/uploader.rb

@@ -0,0 +1,149 @@
+require 'right_aws'
+require 'tempfile'
+
+module CloudfrontAssetHost
+  module Uploader
+    
+    mattr_accessor :new_keys
+
+    class << self
+
+      def upload!(options = {})
+        dryrun = options.delete(:dryrun) || false
+        verbose = options.delete(:verbose) || false
+
+        self.new_keys = []
+
+        puts "-- Updating uncompressed files" if verbose
+        upload_keys_with_paths(keys_with_paths, dryrun, verbose, false)
+
+        if CloudfrontAssetHost.gzip
+          puts "-- Updating compressed files" if verbose
+          upload_keys_with_paths(gzip_keys_with_paths, dryrun, verbose, true)
+        end
+        
+        delete_old_keys
+
+        @existing_keys = nil
+      end
+
+      def upload_keys_with_paths(keys_paths, dryrun, verbose, gzip)
+        keys_paths.each do |key, path|
+          new_keys << key
+          if !existing_keys.include?(key) || CloudfrontAssetHost.css?(path) && rewrite_all_css?
+            puts "+ #{key}" if verbose
+
+            extension = File.extname(path)[1..-1]
+
+            path = rewritten_css_path(path)
+
+            data_path = gzip ? gzipped_path(path) : path
+            bucket.put(key, File.read(data_path), {}, 'public-read', headers_for_path(extension, gzip)) unless dryrun
+
+            File.unlink(data_path) if gzip && File.exists?(data_path)
+          else
+            puts "= #{key}" if verbose
+          end
+        end
+      end
+
+      def gzipped_path(path)
+        tmp = Tempfile.new("cfah-gz")
+        `gzip #{path} -q -c > #{tmp.path}`
+        tmp.path
+      end
+
+      def rewritten_css_path(path)
+        if CloudfrontAssetHost.css?(path)
+          tmp = CloudfrontAssetHost::CssRewriter.rewrite_stylesheet(path)
+          tmp.path
+        else
+          path
+        end
+      end
+
+      def keys_with_paths
+        current_paths.inject({}) do |result, path|
+          key = CloudfrontAssetHost.key_for_path(path) + path.gsub(Rails.public_path, '')
+
+          result[key] = path
+          result
+        end
+      end
+
+      def gzip_keys_with_paths
+        current_paths.inject({}) do |result, path|
+          source = path.gsub(Rails.public_path, '')
+
+          if CloudfrontAssetHost.gzip_allowed_for_source?(source)
+            key = "#{CloudfrontAssetHost.gzip_prefix}/" << CloudfrontAssetHost.key_for_path(path) << source
+            result[key] = path
+          end
+
+          result
+        end
+      end
+      
+      def delete_old_keys
+        puts "-- Removing expired files" if verbose
+        (existing_keys - new_keys).uniq.each do |key|
+          unless new_keys.include?(key)
+            puts "- #{key}" if verbose
+            bucket.delete_folder(key)
+          end
+        end
+      end
+      
+      def rewrite_all_css?
+        @rewrite_all_css ||= !keys_with_paths.delete_if { |key, path| existing_keys.include?(key) || !CloudfrontAssetHost.image?(path) }.empty?
+      end
+
+      def existing_keys
+        @existing_keys ||= begin
+          keys = []
+          keys.concat bucket.keys('prefix' => CloudfrontAssetHost.key_prefix).map  { |key| key.name }
+          keys.concat bucket.keys('prefix' => CloudfrontAssetHost.gzip_prefix).map { |key| key.name }
+          keys
+        end
+      end
+
+      def current_paths
+        @current_paths ||= Dir.glob("#{Rails.public_path}/{images,javascripts,stylesheets}/**/*").reject { |path| File.directory?(path) }
+      end
+
+      def headers_for_path(extension, gzip = false)
+        mime = ext_to_mime[extension] || 'application/octet-stream'
+        headers = {
+          'Content-Type' => mime,
+          'Cache-Control' => "max-age=#{10.years.to_i}",
+          'Expires' => 1.year.from_now.utc.to_s
+        }
+        headers['Content-Encoding'] = 'gzip' if gzip
+
+        headers
+      end
+
+      def ext_to_mime
+        @ext_to_mime ||= Hash[ *( YAML::load_file(File.join(File.dirname(__FILE__), "mime_types.yml")).collect { |k,vv| vv.collect{ |v| [v,k] } }.flatten ) ]
+      end
+
+      def bucket
+        @bucket ||= begin 
+          bucket = s3.bucket(CloudfrontAssetHost.bucket)
+          bucket.disable_logging unless CloudfrontAssetHost.s3_logging
+          bucket
+        end
+      end
+
+      def s3
+        @s3 ||= RightAws::S3.new(config['access_key_id'], config['secret_access_key'])
+      end
+
+      def config
+        @config ||= YAML::load_file(CloudfrontAssetHost.s3_config)
+      end
+
+    end
+
+  end
+end

data/test/app/config/s3.yml

@@ -0,0 +1,5 @@
+#!/bin/bash
+access_key_id: 'access_key'
+secret_access_key: 'secret'
+options:
+  use_ssl: true

data/test/app/public/javascripts/application.js

@@ -0,0 +1 @@
+// Javascripts here

data/test/app/public/stylesheets/style.css

@@ -0,0 +1,4 @@
+body { background-image: url(../images/image.png); }
+body { background-image: url(/images/image.png); }
+body { background-image: url('/images/image.png'); }
+body { background-image: url("/images/image.png"); }

data/test/cloudfront_asset_host_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class CloudfrontAssetHostTest < Test::Unit::TestCase
+
+  context "A configured plugin" do
+    setup do
+      CloudfrontAssetHost.configure do |config|
+        config.cname  = "assethost.com"
+        config.bucket = "bucketname"
+        config.key_prefix = ""
+        config.enabled = false
+      end
+    end
+
+    should "add methods to asset-tag-helper" do
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rails_asset_id_with_cloudfront')
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rewrite_asset_path_with_cloudfront')
+    end
+
+    should "not enable itself by default" do
+      assert_equal false, CloudfrontAssetHost.enabled
+      assert_equal "", ActionController::Base.asset_host
+    end
+
+    should "return key for path" do
+      assert_equal "8ed41cb87", CloudfrontAssetHost.key_for_path(File.join(RAILS_ROOT, 'public', 'javascripts', 'application.js'))
+    end
+
+    should "prepend prefix to key" do
+      CloudfrontAssetHost.key_prefix = "prefix/"
+      assert_equal "prefix/8ed41cb87", CloudfrontAssetHost.key_for_path(File.join(RAILS_ROOT, 'public', 'javascripts', 'application.js'))
+    end
+
+    context "asset-host" do
+
+      setup do
+        @source  = "/javascripts/application.js"
+      end
+
+      should "use cname for asset_host" do
+        assert_equal "http://assethost.com", CloudfrontAssetHost.asset_host(@source)
+      end
+
+      should "use bucket_host when cname is not present" do
+        CloudfrontAssetHost.cname = nil
+        assert_equal "http://bucketname.s3.amazonaws.com", CloudfrontAssetHost.asset_host(@source)
+      end
+
+      should "not support gzip for images" do
+        request = stub(:headers => {'User-Agent' => 'Mozilla/5.0', 'Accept-Encoding' => 'gzip, compress'})
+        source  = "/images/logo.png"
+        assert_equal "http://assethost.com", CloudfrontAssetHost.asset_host(source, request)
+      end
+
+      context "when taking the headers into account" do
+
+        should "support gzip for IE" do
+          request = stub(:headers => {'User-Agent' => 'Mozilla/4.0 (compatible; MSIE 8.0)', 'Accept-Encoding' => 'gzip, compress'})
+          assert_equal "http://assethost.com/gz", CloudfrontAssetHost.asset_host(@source, request)
+        end
+
+        should "support gzip for modern browsers" do
+          request = stub(:headers => {'User-Agent' => 'Mozilla/5.0', 'Accept-Encoding' => 'gzip, compress'})
+          assert_equal "http://assethost.com/gz", CloudfrontAssetHost.asset_host(@source, request)
+        end
+
+        should "support not support gzip for Netscape 4" do
+          request = stub(:headers => {'User-Agent' => 'Mozilla/4.0', 'Accept-Encoding' => 'gzip, compress'})
+          assert_equal "http://assethost.com", CloudfrontAssetHost.asset_host(@source, request)
+        end
+
+        should "require gzip in accept-encoding" do
+          request = stub(:headers => {'User-Agent' => 'Mozilla/5.0'})
+          assert_equal "http://assethost.com", CloudfrontAssetHost.asset_host(@source, request)
+        end
+
+      end
+
+    end
+  end
+
+  context "An enabled and configured plugin" do
+    setup do
+      CloudfrontAssetHost.configure do |config|
+        config.enabled = true
+        config.cname  = "assethost.com"
+        config.bucket = "bucketname"
+        config.key_prefix = ""
+      end
+    end
+
+    should "set the asset_host" do
+      assert ActionController::Base.asset_host.is_a?(Proc)
+    end
+
+    should "alias methods in asset-tag-helper" do
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rails_asset_id_without_cloudfront')
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rewrite_asset_path_without_cloudfront')
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rails_asset_id')
+      assert ActionView::Helpers::AssetTagHelper.private_method_defined?('rewrite_asset_path')
+    end
+  end
+
+  context "An improperly configured plugin" do
+    should "complain about bucket not being set" do
+      assert_raise(RuntimeError) {
+        CloudfrontAssetHost.configure do |config|
+          config.enabled = false
+          config.cname = "assethost.com"
+          config.bucket = nil
+        end
+      }
+    end
+
+    should "complain about missing s3-config" do
+      assert_raise(RuntimeError) {
+        CloudfrontAssetHost.configure do |config|
+          config.enabled = false
+          config.cname = "assethost.com"
+          config.bucket = "bucketname"
+          config.s3_config = "bogus"
+        end
+      }
+    end
+  end
+
+end

data/test/css_rewriter_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class CssRewriterTest < Test::Unit::TestCase
+
+  context "The CssRewriter" do
+
+    setup do
+      CloudfrontAssetHost.configure do |config|
+        config.cname  = "assethost.com"
+        config.bucket = "bucketname"
+        config.key_prefix = ""
+        config.enabled = false
+      end
+
+      @stylesheet_path = File.join(Rails.public_path, 'stylesheets', 'style.css')
+    end
+
+    should "rewrite a single css file" do
+      tmp = CloudfrontAssetHost::CssRewriter.rewrite_stylesheet(@stylesheet_path)
+      contents = File.read(tmp.path)
+      contents.split("\n").each do |line|
+        assert_equal "body { background-image: url(http://assethost.com/d41d8cd98/images/image.png); }", line
+      end
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'rubygems'
+
+require 'action_controller'
+require 'right_aws'
+
+require 'shoulda'
+require 'mocha'
+begin require 'redgreen'; rescue LoadError; end
+begin require 'turn'; rescue LoadError; end
+
+RAILS_ROOT = File.expand_path(File.join(File.dirname(__FILE__), 'app'))
+
+module Rails
+  class << self
+    def root
+      RAILS_ROOT
+    end
+
+    def public_path
+      File.join(RAILS_ROOT, 'public')
+    end
+  end
+end
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'cloudfront_asset_host')

data/test/uploader_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class UploaderTest < Test::Unit::TestCase
+
+  context "A configured uploader" do
+    setup do
+      CloudfrontAssetHost.configure do |config|
+        config.cname  = "assethost.com"
+        config.bucket = "bucketname"
+        config.key_prefix = ""
+        config.s3_config = "#{RAILS_ROOT}/config/s3.yml"
+        config.enabled = false
+      end
+    end
+
+    should "be able to retrieve s3-config" do
+      config = CloudfrontAssetHost::Uploader.config
+      assert_equal 'access_key', config['access_key_id']
+      assert_equal 'secret', config['secret_access_key']
+    end
+
+    should "be able to instantiate s3-interface" do
+      RightAws::S3.expects(:new).with('access_key', 'secret').returns(mock)
+      assert_not_nil CloudfrontAssetHost::Uploader.s3
+    end
+
+    should "glob current files" do
+      assert_equal 3, CloudfrontAssetHost::Uploader.current_paths.length
+    end
+
+    should "calculate keys for paths" do
+      keys_with_paths = CloudfrontAssetHost::Uploader.keys_with_paths
+      assert_equal 3, keys_with_paths.length
+      assert_match %r{/test/app/public/javascripts/application\.js$}, keys_with_paths["8ed41cb87/javascripts/application.js"]
+    end
+
+    should "calculate gzip keys for paths" do
+      gz_keys_with_paths = CloudfrontAssetHost::Uploader.gzip_keys_with_paths
+      assert_equal 2, gz_keys_with_paths.length
+      assert_match %r{/test/app/public/javascripts/application\.js$}, gz_keys_with_paths["gz/8ed41cb87/javascripts/application.js"]
+      assert_match %r{/test/app/public/stylesheets/style\.css$},      gz_keys_with_paths["gz/bd258f13d/stylesheets/style.css"]
+    end
+
+    should "return a mimetype for an extension" do
+      assert_equal 'application/x-javascript', CloudfrontAssetHost::Uploader.ext_to_mime['js']
+    end
+
+    should "construct the headers for a path" do
+      headers = CloudfrontAssetHost::Uploader.headers_for_path('js')
+      assert_equal 'application/x-javascript', headers['Content-Type']
+      assert_match /max-age=\d+/, headers['Cache-Control']
+      assert DateTime.parse(headers['Expires'])
+    end
+
+    should "add gzip-header" do
+      headers = CloudfrontAssetHost::Uploader.headers_for_path('js', true)
+      assert_equal 'application/x-javascript', headers['Content-Type']
+      assert_equal 'gzip', headers['Content-Encoding']
+      assert_match /max-age=\d+/, headers['Cache-Control']
+      assert DateTime.parse(headers['Expires'])
+    end
+
+    should "retrieve existing keys" do
+      bucket_mock = mock
+      bucket_mock.expects(:keys).with({'prefix' => ''}).returns([stub(:name => "keyname")])
+      bucket_mock.expects(:keys).with({'prefix' => 'gz'}).returns([stub(:name => "gz/keyname")])
+
+      CloudfrontAssetHost::Uploader.expects(:bucket).times(2).returns(bucket_mock)
+      assert_equal ["keyname", "gz/keyname"], CloudfrontAssetHost::Uploader.existing_keys
+    end
+
+    should "upload files when there are no existing keys" do
+      bucket_mock = mock
+      bucket_mock.expects(:put).times(5)
+      CloudfrontAssetHost::Uploader.stubs(:bucket).returns(bucket_mock)
+      CloudfrontAssetHost::Uploader.stubs(:existing_keys).returns([])
+
+      CloudfrontAssetHost::Uploader.upload!
+    end
+
+    should "not re-upload existing keys" do
+      CloudfrontAssetHost::Uploader.expects(:bucket).never
+      CloudfrontAssetHost::Uploader.stubs(:existing_keys).returns(
+        ["gz/8ed41cb87/javascripts/application.js", "8ed41cb87/javascripts/application.js",
+         "d41d8cd98/images/image.png",
+         "bd258f13d/stylesheets/style.css", "gz/bd258f13d/stylesheets/style.css"]
+      )
+
+      CloudfrontAssetHost::Uploader.upload!
+    end
+
+    should "correctly gzip files" do
+      path = File.join(RAILS_ROOT, 'public', 'javascripts', 'application.js')
+      contents = File.read(path)
+
+      gz_path = CloudfrontAssetHost::Uploader.gzipped_path(path)
+      gunzip_contents = `gunzip #{gz_path} -q -c`
+
+      assert_equal contents, gunzip_contents
+    end
+
+    should "correctly rewrite css files" do
+      path = File.join(RAILS_ROOT, 'public', 'stylesheets', 'style.css')
+      css_path = CloudfrontAssetHost::Uploader.rewritten_css_path(path)
+
+      File.read(css_path).split("\n").each do |line|
+        assert_equal "body { background-image: url(http://assethost.com/d41d8cd98/images/image.png); }", line
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: foresth-cloudfront_asset_host
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
+platform: ruby
+authors: 
+- Menno van der Sman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-27 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Easy deployment of your assets on CloudFront or S3 using a simple rake-task. When enabled in production, the application's asset_host and public_paths will point to the correct location.
+email: menno@wakoopa.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- cloudfront_asset_host.gemspec
+- lib/cloudfront_asset_host.rb
+- lib/cloudfront_asset_host/asset_tag_helper_ext.rb
+- lib/cloudfront_asset_host/css_rewriter.rb
+- lib/cloudfront_asset_host/mime_types.yml
+- lib/cloudfront_asset_host/uploader.rb
+- test/app/config/s3.yml
+- test/app/public/images/image.png
+- test/app/public/javascripts/application.js
+- test/app/public/stylesheets/style.css
+- test/cloudfront_asset_host_test.rb
+- test/css_rewriter_test.rb
+- test/test_helper.rb
+- test/uploader_test.rb
+has_rdoc: true
+homepage: http://github.com/foresth/cloudfront_asset_host
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rails plugin to easily and efficiently deploy your assets on Amazon's S3 or CloudFront
+test_files: 
+- test/cloudfront_asset_host_test.rb
+- test/css_rewriter_test.rb
+- test/test_helper.rb
+- test/uploader_test.rb