cdn_fu 0.5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Curtis W Spencer (@jubos)
+
+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.md

@@ -0,0 +1,20 @@
+## cdn fu
+cdn fu is a fun domain specific language for deployment of assets to content
+deliver network.  There are 4 pluggable steps in the chain:
+
+1. Preprocessing
+2. Listing
+3. Minification
+4. Uploading
+
+## Installation
+
+    ruby script/plugin install git://github.com/jubos/cdn_fu.git 
+
+
+## Example
+For example, you can first run a Sass/Sprockets/AssetPacker during
+preprocessing, then minify all of the resulting .js and .css assets, and
+finally upload to a third party CDN.
+
+

data/bin/cdnfu

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# The command line cdn fu executor
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'cdn_fu'
+opts = CdnFu::CommandLine.new(ARGV)
+opts.parse!

data/lib/cdn_fu/config.rb

@@ -0,0 +1,138 @@
+module CdnFu
+  # This is just a storage class for the configuration for CdnFu
+  class Config
+    def self.configure(&block)
+      @@cfg ||= Config.new
+      @@cfg.instance_eval &block if block_given?
+      @@cfg
+    end
+
+    def self.clear
+      @@cfg = nil
+    end
+
+    def self.config
+      @@cfg ||= Config.new
+      @@cfg
+    end
+
+    # Make a lister object 
+    def initialize
+      @lister = Lister.new
+    end
+
+    # Accessors
+    def asset_id(*args)
+      return @asset_id if args.size == 0
+      @asset_id = args[0]
+    end
+
+    def verbose(*args)
+      return @verbose if args.size == 0
+      @verbose = args[0]
+    end
+
+    def asset_root_dir(*args)
+      return @asset_root_dir if args.size == 0
+      asset_root = args.first
+      # TODO add default separator so it works on windows
+      if asset_root[0,1] == '/'
+        @asset_root_dir = File.expand_path(asset_root)
+      else
+        @asset_root_dir = File.expand_path(File.join(Dir.pwd,asset_root))
+      end
+    end
+
+    def tmp_dir(*args)
+      return @tmp_dir if args.size == 0
+      @tmp_dir = args[0]
+    end
+
+    def prepare_and_upload
+      @tmp_dir ||= "/tmp"
+      FileUtils.mkdir_p(@tmp_dir)
+
+      case @preprocessor
+      when Proc
+        @preprocessor.call
+      when Class
+        @preprocessor.preprocess
+      end
+
+      file_list = @lister.list
+
+      case @minifier
+      when Proc
+        @minifier.call(file_list)
+      when CdnFu::Minifier
+        @minifier.validate_and_minify(file_list)
+      end
+
+      case @uploader
+      when Proc
+        @uploader.call(file_list)
+      when CdnFu::Uploader
+        @uploader.validate_and_upload(file_list)
+      end
+    end
+
+    def preprocess
+      if block_given?
+        @preprocessor = proc
+      else 
+        raise ConfigError,"No preprocess block given"
+      end
+    end
+
+    def preprocessor(klass)
+      @preprocessor = klass
+      yield @preprocessor if block_given?
+    end
+
+    def files(&block)
+      if block_given?
+        @lister.instance_eval &block
+      else
+        @lister.list
+      end
+    end
+
+    def minify(&block)
+      if block_given?
+        @minifier = block 
+      else
+        raise ConfigError,"No minify block given"
+      end
+    end
+
+    def minifier(*args,&block)
+      return @minifier if args.size == 0
+      minifier_class = args[0]
+      @minifier = minifier_class.new
+      @minifier.instance_eval &block if block_given?
+    end
+
+    def upload(&block)
+      if block_given?
+        @uploader = block
+      else
+        raise CdnFuConfigError,"No upload block given"
+      end
+    end
+
+    def uploader(*args,&block)
+      return @uploader if args.size == 0
+      uploader_class = args[0]
+      @uploader = uploader_class.new
+      @uploader.instance_eval &block if block_given?
+    end
+  end
+end
+
+# Here we read in the config file
+#cf_config_path = File.join(RAILS_ROOT,"config/cdn_fu.rb")
+#if File.exists?(cf_config_path)
+#  require cf_config_path
+#else
+#  puts "Please make a cdn_fu.rb file in RAILS_ROOT/config/ using rake cdn:init"
+#end

data/lib/cdn_fu/config_error.rb

@@ -0,0 +1,4 @@
+module CdnFu
+  class ConfigError < StandardError
+  end
+end

data/lib/cdn_fu/executor.rb

@@ -0,0 +1,92 @@
+require 'optparse'
+require 'fileutils'
+
+module CdnFu
+  class CommandLine
+    def initialize(args)
+      @args = args
+      @options = {}
+    end
+
+    def parse!
+      begin
+        @opts = OptionParser.new do |opts|
+          opts.banner = 'Usage: cdnfu [options]'
+          opts.on('-c', '--config CONFIG' , 'a cdn fu configuration file') do |config|
+            @options[:config] = config
+          end
+
+          opts.on('--rails RAILS_DIR', "Install CDN Fu from the gem into a rails project") do |dir|
+            puts "Rails Install #{dir}"
+            @options[:rails] = dir
+          end
+
+          opts.on_tail('-?','-h','--help', 'Show this message') do
+            puts opts
+            exit
+          end
+        end
+
+        @opts.parse!(@args)
+
+        # Check for required arguments
+        if !@options[:config] && !@options[:rails]
+          puts @opts
+          exit
+        end
+
+        if config_file = @options[:config]
+          if File.exists?(config_file)
+            Dir.chdir(File.dirname(config_file))
+            eval(File.open(config_file).read)
+            Config.config.prepare_and_upload
+          else
+            puts "Cannot find config file"
+            exit
+          end
+        elsif rails_dir = @options[:rails]
+          plugins_dir = File.join(rails_dir,"vendor","plugins")
+          unless File.exists?(plugins_dir)
+            puts "#{plugins_dir} doesn't exist.  Are you sure this is a rails project?"
+            exit
+          end
+
+          cdn_fu_dir = File.join(plugins_dir,'cdn_fu')
+
+          if File.exists?(cdn_fu_dir)
+            print "Directory #{cdn_fu_dir} already exists, overwrite [y/N]?"
+            exit if gets !~ /y/i
+            FileUtils.rm_rf(cdn_fu_dir)
+          end
+
+          tasks_dir = File.join(cdn_fu_dir,'tasks')
+
+          begin 
+            Dir.mkdir(cdn_fu_dir)
+            Dir.mkdir(tasks_dir)
+          rescue SystemCallError
+            puts "Cannot create #{cdn_fu_dir}"
+            exit
+          end
+
+          File.open(File.join(cdn_fu_dir,'init.rb'), 'w') do |file|
+            file << File.read(File.dirname(__FILE__) + "/../../rails/init.rb")
+          end
+
+          File.open(File.join(tasks_dir,'cdn_fu.rake'),'w') do |file|
+            file << File.read(File.dirname(__FILE__) + "/../../tasks/cdn_fu.rake")
+          end
+
+          puts "CDN Fu plugin added to #{rails_dir}"
+          exit
+        end
+      rescue RuntimeError => e
+        puts e
+        e.backtrace.each do |line|
+          puts line
+        end
+        exit
+      end
+    end
+  end
+end

data/lib/cdn_fu/file_info.rb

@@ -0,0 +1,14 @@
+module CdnFu
+  class FileInfo
+    attr_accessor :local_path,:minified_path,:remote_path
+    attr_writer :gzip,:minify
+
+    def gzip?
+      @gzip
+    end
+
+    def minify?
+      @minify
+    end
+  end
+end

data/lib/cdn_fu/lister.rb

@@ -0,0 +1,47 @@
+module CdnFu
+  class Lister
+    def initialize
+      @globs = []
+      @files = []
+    end
+    def glob(name,options = {})
+      options[:name] = name
+      @globs << options
+    end
+
+    def file(name,options = {})
+      options[:name] = name
+      @files << options
+    end
+
+    def list
+      file_infos ||= []
+      asset_root = Config.config.asset_root_dir
+      asset_root ||= Dir.pwd
+
+      @globs.each do |glob|
+        glob_str = glob[:name]
+        Dir.glob(File.join(asset_root,glob_str)).each do |file|
+          fi = FileInfo.new
+          fi.local_path = File.expand_path(file)
+          fi.gzip = glob[:gzip]
+          fi.minify = glob[:minify]
+          root_sub_path = fi.local_path.gsub(asset_root,'')
+          glob_sub_path = root_sub_path.gsub(glob_str[0,glob_str.index('*')],'')
+          fi.remote_path = glob[:path] ? File.join(glob[:path],glob_sub_path) : root_sub_path
+          file_infos << fi
+        end
+      end
+
+      @files.each do |file|
+        fi = FileInfo.new
+        fi.local_path = File.join(asset_root,file[:name])
+        fi.gzip = file[:gzip]
+        fi.minify = file[:minify]
+        fi.remote_path = file[:path] ? file[:path] : fi.local_path.gsub(Config.config.asset_root_dir,'')
+        file_infos << fi
+      end
+      file_infos
+    end
+  end
+end

data/lib/cdn_fu/minifier.rb

@@ -0,0 +1,56 @@
+module CdnFu
+  class Minifier
+    class << self
+
+      def optional_attributes(*arr)
+        return @optional_attributes if arr.size == 0
+        @optional_attributes ||= []
+        arr.each do |a|
+          @optional_attributes << a.to_sym
+          class_eval do 
+            define_method(a.to_sym) do |*args|
+              return instance_variable_get("@#{a}") if args.size == 0
+              instance_variable_set("@#{a}",args[0])
+            end
+          end
+        end
+      end
+      alias :optional_attribute :optional_attributes
+
+      def required_attributes(*arr)
+        return @required_attributes if arr.size == 0
+        @required_attributes ||= []
+        arr.each do |a|
+          @required_attributes << a.to_sym
+          class_eval do 
+            define_method(a.to_sym) do |*args|
+              return instance_variable_get("@#{a}") if args.size == 0
+              instance_variable_set("@#{a}",args[0])
+            end
+          end
+        end
+      end
+      alias :required_attribute :required_attributes
+    end
+
+    def validate_and_minify(file_list)
+      attribute_validate
+      validate
+      minify(file_list)
+    end
+
+    def attribute_validate
+      if @required_attributes
+        @required_attributes.each do |attr|
+          res = self.send(attr)
+          if res.nil? or res == ''
+            raise CdnFuConfigError, "#{attr} must be specified in the configuration"
+          end
+        end
+      end
+    end
+
+    def validate
+    end
+  end
+end

data/lib/cdn_fu/minifiers/yui_minifier.rb

@@ -0,0 +1,35 @@
+class YuiMinifier < CdnFu::Minifier
+  required_attribute :yui_jar_path
+
+  # Essentially iterate through through the files and if minify is specified call it.
+  def minify(file_list)
+    file_list.each do |cf_file|
+      one_minification(cf_file) if cf_file.minify?
+    end
+  end
+
+  # Custom validate method ensures that the jar specified will actually work.
+  def validate
+    if @yui_jar_path
+      if File.exists?(@yui_jar_path)
+        output = `java -jar #{@yui_jar_path}`
+        if output !~ /java -jar yuicompressor-x\.y\.z\.jar/
+          raise CdnFu::ConfigError,"Invalid YUI Compressor jar specified in cdn_fu.rb"
+        end
+      else
+        raise CdnFu::ConfigError,"YUI Compressor jar specified in cdn_fu.rb does not exist"
+      end
+    else
+      raise CdnFu::ConfigError,"You must specify a yui_jar_path for YUI Compressor"
+    end
+  end
+
+  private
+
+  def one_minification(file)
+    modified_path = File.join(CdnFu::Config.config.tmp_dir,"minified_#{File.basename(file.local_path)}")
+    `java -jar #{@yui_jar_path} #{file.local_path} > #{modified_path}`
+    puts "[minify] #{file.local_path}" if CdnFu::Config.config.verbose
+    file.minified_path = modified_path
+  end
+end

data/lib/cdn_fu/uploader.rb

@@ -0,0 +1,59 @@
+module CdnFu
+  class Uploader
+    # These are class level methods, so that subclasses can do some light
+    # metaprogramming to specify optional and required attributes
+    class << self;
+      def required_attributes( *arr ) 
+        return @required_attributes if arr.size == 0
+        @required_attributes ||= []
+        arr.each do |a|
+          @required_attributes << a.to_sym
+          class_eval do 
+            define_method(a.to_sym) do |*args|
+              return instance_variable_get("@#{a}") if args.size == 0
+              instance_variable_set("@#{a}",args[0])
+            end
+          end
+        end
+      end 
+
+      def optional_attributes( *arr ) 
+        return @optional_attributes if arr.size == 0
+        @optional_attributes ||= []
+        arr.each do |a|
+          @optional_attributes << a.to_sym
+          class_eval do 
+            define_method(a.to_sym) do |*args|
+              return instance_variable_get("@#{a}") if args.size == 0
+              instance_variable_set("@#{a}",args[0])
+            end
+          end
+        end
+      end 
+
+      # aliases just for syntactic sugar
+      alias :required_attribute :required_attributes
+      alias :optional_attribute :optional_attributes
+    end
+
+    def validate_and_upload(file_list)
+      attribute_validate
+      validate
+      upload(file_list)
+    end
+
+    def attribute_validate
+      if self.class.required_attributes
+        self.class.required_attributes.each do |attr|
+          res = self.send(attr)
+          if res.nil? or res == '' 
+            raise CdnFuConfigError, "#{attr} must be specified in the uploader configuration"
+          end
+        end
+      end
+    end
+
+    def validate
+    end
+  end
+end

data/lib/cdn_fu/uploaders/cloudfront_uploader.rb

@@ -0,0 +1,94 @@
+# This uploader using aws:s3 gem to upload everything to the specified bucket
+require 'zlib'
+require 'aws/s3'
+class CloudfrontUploader < CdnFu::Uploader
+  include AWS::S3
+  required_attribute :s3_bucket
+  optional_attributes :s3_access_key, :s3_secret_key
+
+  MAX_KEYS = 1000
+
+  def upload(file_list)
+    access_key = @s3_access_key ? @s3_access_key : ENV["CDN_FU_AMAZON_ACCESS_KEY"]
+    secret_key = @s3_secret_key ? @s3_secret_key : ENV["CDN_FU_AMAZON_SECRET_KEY"]
+
+    AWS::S3::Base.establish_connection!(
+      :access_key_id => access_key,
+      :secret_access_key => secret_key
+    )
+
+    checksums = populate_existing_asset_checksums
+    file_list.each do |file|
+      upload_single_file(file)
+    end
+  end
+
+  # This uploader requires a valid asset_id at the top level configuration
+  # because cloudfront only invalidates its files every 24 hours, so you need
+  # to have an incrementing id to avoid stale assets
+  def validate
+    if !CdnFu::Config.config.asset_id 
+      raise CdnFu::ConfigError, "You must specify an asset_id at the top level"
+    end
+    access_key = @s3_access_key ? @s3_access_key : ENV["CDN_FU_AMAZON_ACCESS_KEY"]
+    secret_key = @s3_secret_key ? @s3_secret_key : ENV["CDN_FU_AMAZON_SECRET_KEY"]
+
+    if !access_key or !secret_key
+      raise CdnFu::ConfigError, "Please specify s3_access_key and s3_secret_key attributes or use the environnment variables: CDN_FU_AMAZON_ACCESS_KEY and CDN_FU_AMAZON_SECRET_KEY"
+    end
+  end
+
+  private
+  def populate_existing_asset_checksums 
+    @existing_asset_checksums = {}
+    objects = []
+    bucket = Bucket.find(@s3_bucket)
+    objects += bucket.objects(:max_keys => MAX_KEYS)
+    if objects.size == MAX_KEYS
+      loop do
+        new_objects = bucket.objects(:max_keys => MAX_KEYS,:marker => objects.last)
+        objects += new_objects
+        break if new_objects.size < MAX_KEYS
+      end
+    end
+    objects.each do |obj|
+      @existing_asset_checksums[obj.path] = obj.metadata['x-amz-meta-sha1-hash']
+    end
+    return objects
+  end
+
+  def upload_single_file(cf_file)
+    versioned_filename = CdnFu::Config.config.asset_id + cf_file.remote_path
+    options = {}
+    options[:access] = :public_read
+    path_to_upload = cf_file.minified_path
+    path_to_upload ||= cf_file.local_path
+    fstat = File.stat(path_to_upload)
+    sha1sum = Digest::SHA1.hexdigest(File.open(path_to_upload).read)
+    if remote_sha1 = @existing_asset_checksums["/" + s3_bucket + "/" + versioned_filename]
+      if remote_sha1 != sha1sum
+        puts "Your assets are different from the ones in s3 with this asset_id.  Please increment your asset_id in cdn_fu.rb"
+        exit
+      end
+    else
+      options[:access] = :public_read
+      options["x-amz-meta-sha1_hash"] = sha1sum
+      options["x-amz-meta-mtime"] = fstat.mtime.getutc.to_i 
+      options["x-amz-meta-size"] = fstat.size
+      file_content =open(path_to_upload).read 
+      if cf_file.gzip? 
+        options["Content-Encoding"] = 'gzip'
+        strio = StringIO.open('', 'w')
+        gz = Zlib::GzipWriter.new(strio)
+        gz.write(file_content)
+        gz.close
+        file_content = strio.string
+      end
+
+      options[:cache_control] = "max-age=#{8.years.to_i}"
+      options[:expires] = 8.years.from_now.httpdate
+      S3Object.store(versioned_filename,file_content,s3_bucket, options)
+      puts "[upload] #{s3_bucket} #{versioned_filename}" if CdnFu::Config.config.verbose
+    end
+  end
+end

data/lib/cdn_fu/uploaders/local_uploader.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+require 'pathname'
+class LocalUploader < CdnFu::Uploader
+  required_attribute :path
+
+  def validate
+    path = @path
+    if !@path
+      raise CdnFu::ConfigError, "Please specify a path for LocalUploader"
+    end
+
+    @path_obj = Pathname.new(@path)
+    if !@path_obj.absolute?
+      raise CdnFu::ConfigError, "Please specify an absolute path"
+    end
+
+    if File.exists?(@path) and !FileTest.directory?(@path)
+      raise CdnFu::ConfigError, "LocalUploader path must be a directory"
+    end
+
+  end
+
+  # Here we just iterate through the files
+  def upload(file_list)
+    FileUtils.mkdir_p(@path) if !File.exists?(@path)
+    file_list.each do |file|
+      path_to_copy = file.minified_path
+      path_to_copy ||= file.local_path
+      destination = File.join(@path,file.remote_path)
+      dest_dir = File.dirname(destination)
+      FileUtils.mkdir_p(dest_dir) if !File.exists?(dest_dir)
+      FileUtils.cp path_to_copy,dest_dir
+    end
+  end
+end

data/lib/cdn_fu.rb

@@ -0,0 +1,35 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+module CdnFu
+  VERSION = 0.5
+  # Do some sensible defaults for rails
+  def self.init_rails(binding)
+    cfg = CdnFu::Config.config
+    cfg.asset_root_dir(File.join(RAILS_ROOT,'public'))
+    cfg.tmp_dir(File.join(RAILS_ROOT,'tmp'))
+    # If there is a RAILS_ASSET_ID use that.
+    begin
+      cfg.asset_id(RAILS_ASSET_ID)
+    rescue NameError
+    end
+  end
+
+  def self.load_rails_config
+    cdn_fu_config_file = File.join(RAILS_ROOT,'config','cdn_fu.rb')
+    if File.exists?(cdn_fu_config_file)
+      eval(File.open(cdn_fu_config_file).read)
+    end
+  end
+end
+
+require 'cdn_fu/config_error'
+require 'cdn_fu/config'
+require 'cdn_fu/executor'
+require 'cdn_fu/file_info.rb'
+require 'cdn_fu/lister.rb'
+require 'cdn_fu/minifier.rb'
+require 'cdn_fu/uploader.rb'
+["minifiers","listers","uploaders"].each do |subdir|
+  Dir[File.join(File.dirname(__FILE__),'cdn_fu',subdir, "*")].each {|f| require f}
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+require 'cdn_fu'
+
+# Load CdnFu into the space of rails
+CdnFu.init_rails(binding)

data/tasks/cdn_fu.rake

@@ -0,0 +1,82 @@
+namespace "cdn" do
+  desc "Initialize a cdn_fu.rb"
+  task "init" => :environment do
+    cfg_path = File.join(RAILS_ROOT,'config/cdn_fu.rb')
+    if FileTest.exists?(cfg_path)
+      puts "config/cdn_fu.rb already exists." 
+      print "Do you want to overwrite? [y/n] "
+      if STDIN.gets !~ /^[yY]/
+        exit
+      end
+    end
+    File.open(cfg_path,'w') do |f|
+      f << <<-EOF
+CdnFu::Config.configure do
+  # asset_id
+  # default: RAILS_ASSET_ID
+  # The asset id that you need to increment whenever your assets change (for
+  # cloudfront) This ensures that cloudfront assets are properly invalidated,
+  # since there is no way to explicitly invalidate entries. Set it to nil if
+  # you don't care about stale assets.
+  #
+  # Examples:
+  # asset_id nil
+  # asset_id '123'
+  # asset_id File.open(File.join(RAILS_ROOT,'revision')) {|f| f.read.strip }
+  # asset_id RAILS_ASSET_ID
+
+  # asset_root_dir
+  # default: RAILS_ROOT + 'public/'
+  # This is where your files specifications will start looking for assets.
+
+  # You can specify things to do before the minification step here.  For
+  # example if you use Sass you will want to ensure you have the latest
+  # stylesheets processed
+  #
+  #preprocess do
+  #  Sass::Plugin.update_stylesheets
+  #end
+
+  files do 
+    glob "javascripts/*.js", :minify => true, :gzip => true
+    glob "stylesheets/*.css", :minify => true, :gzip => true
+    glob "images/**/*.*"
+  end
+  
+  # minifier
+  # default: nil
+  # YuiMinifier is the only included backend for now.  This will iterate over
+  # each js/css asset and do a minification.
+  # minifier YuiMinifier do 
+  # yui_jar_path "/usr/bin/yuicompressor-2.4.2.jar"
+  #end
+
+  # uploader
+  # default: nil
+  #
+  # Cloudfront is the only supported backend now. You can specify access
+  # credentials in this file or for more safety, put them in your environment
+  # variables CDN_FU_AMAZON_ACCESS_KEY and CDN_FU_AMAZON_SECRET_KEY environment
+  # variables
+  #uploader CloudfrontUploader do 
+  #  s3_bucket 'mybucket'
+  #  s3_access_key 'blah'
+  #  s3_secret_key 'blah'
+  #end
+end
+EOF
+    end
+  end
+
+  desc "Uploads all your assets to your cdn"
+  task "upload" => :environment do
+    cfg_path = File.join(RAILS_ROOT,'config/cdn_fu.rb')
+    if !FileTest.exists?(cfg_path)
+      puts "#{cfg_path} doesn't exist.  Please run rake cdn:init to create a basic configuration file"
+      exit
+    end
+    CdnFu.load_rails_config
+    CdnFu::Config.config.prepare_and_upload
+  end
+end
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: cdn_fu
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Curtis Spencer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-04 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.8"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.2
+    version: 
+description: |
+  CDN Fu is a framework for making listing, minification and deployment of static
+  assets easy.  It allows you to use it standalone on the command line for non
+  Rails project and it can be used as a Rails plugin to add useful rake tasks and
+  sensible defaults.
+
+email: curtis@sevenforge.com
+executables: 
+- cdnfu
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- MIT-LICENSE
+- bin/cdnfu
+- lib/cdn_fu/config.rb
+- lib/cdn_fu/config_error.rb
+- lib/cdn_fu/executor.rb
+- lib/cdn_fu/file_info.rb
+- lib/cdn_fu/lister.rb
+- lib/cdn_fu/minifier.rb
+- lib/cdn_fu/minifiers/yui_minifier.rb
+- lib/cdn_fu/uploader.rb
+- lib/cdn_fu/uploaders/cloudfront_uploader.rb
+- lib/cdn_fu/uploaders/local_uploader.rb
+- lib/cdn_fu.rb
+- rails/init.rb
+- tasks/cdn_fu.rake
+has_rdoc: true
+homepage: http://www.sevenforge.com/cdn_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cdn_fu
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: CDN Fu is a framework for making minification and deployment of static assets easy
+test_files: []
+