weld 0.0.1.dev.20100402 → 0.0.1.dev.20100404

data/bin/weld

@@ -1,63 +1,40 @@
 #!/usr/bin/env ruby
 
 require 'rubygems'
-require 'trollop'
 require 'weld'
 
-options = Trollop.options do
-  version "#{Weld::APP_NAME} #{Weld::APP_VERSION}\n" << Weld::APP_COPYRIGHT
-  banner <<-EOS
-Weld combines and minifies CSS and JavaScript files at runtime and build time.
+cli = Weld::CLI.new
 
-Usage:
-  weld [options] <component> [<component> ...]
+begin
+  cli.components.each do |name|
+    cli.info "Welding #{name}"
 
-Options:
-EOS
+    component = cli.weld.component(name)
+    suffix    = Time.now.strftime('-%Y%m%d%H%M')
 
-  opt :config,     "Use the specified config file.", :short => '-c', :default => './weld.yaml'
-  opt :no_minify,  "Don't perform any minification.", :short => :none
-  opt :output_dir, "Write welded files to the specified directory.", :short => '-o', :default => './'
-  opt :type,       "Only weld components of the specified type ('css' or 'js').", :short => '-t', :type => :string
-end
-
-if options[:type_given] && !['css', 'js'].include?(options[:type])
-  abort "Error: Unsupported component type: #{options[:type]}\n" <<
-      "Try --help for help."
-end
-
-weld = Weld.new(options[:config])
-
-components = ARGV.length > 0 ? ARGV : @weld.config['components'] || []
-type       = options[:type].to_sym if options[:type_given]
-
-components.each do |name|
-  puts "Welding #{name}"
-
-  component = weld.component(name)
-  suffix    = Time.now.strftime('-%Y%m%d%H%M')
-
-  if type
-    next if component.method(type).call.empty?
-
-    filename = "#{File.join(options[:output_dir], name)}#{suffix}.#{type}"
-
-    File.open(filename, 'w') do |file|
-      puts "--> #{filename}"
-      file.write(options[:no_minify] ? component.merge(type) : component.compress(type))
-    end
-  else
-    [:css, :js].each do |type|
+    cli.types.each do |type|
       next if component.method(type).call.empty?
 
-      filename = "#{File.join(options[:output_dir], name)}#{suffix}.#{type}"
+      filename  = "#{name}#{suffix}.#{type}"
+      content   = cli.options[:no_minify] ? component.merge(type) : component.compress(type)
+
+      if cli.options[:push]
+        cdn_url = cli.cdn_push(filename, type, content)
+        cli.info "--> #{cdn_url}"
+      else
+        full_path = File.join(cli.options[:output_dir], filename)
 
-      File.open(filename, 'w') do |file|
-        puts "--> #{filename}"
-        file.write(options[:no_minify] ? component.merge(type) : component.compress(type))
+        File.open(full_path, 'w') do |file|
+          cli.info "--> #{full_path}"
+          file.write(content)
+        end
       end
     end
   end
 
-  puts
+# rescue => ex
+#   cli.error ex.message
+#   exit(1)
 end
+
+puts

data/lib/weld.rb

@@ -1,21 +1,36 @@
-require 'open-uri'
-require 'pathname'
+require 'fileutils'
 
-require 'weld/compressor'
+class Weld
+  HOME_DIR = ENV['WELD_HOME'] || File.join(File.expand_path('~/'), '.weld')
+end
+
+require 'weld/cache'
+require 'weld/component'
 require 'weld/version'
 
 class Weld
-  autoload :Server, 'weld/server'
+  autoload :CDN,        'weld/cdn'
+  autoload :CLI,        'weld/cli'
+  autoload :Compressor, 'weld/compressor'
+  autoload :Server,     'weld/server'
 
-  attr_reader :config, :config_file
+  attr_reader :cache, :config, :config_file
 
   def initialize(config_file)
     # TODO: handle exceptions
     @config      = YAML::load_file(config_file)
     @config_file = config_file
+
+    # Create home dir if it doesn't exist.
+    FileUtils.mkdir_p(HOME_DIR)
+
+    @cache           = Cache.new
+    @component_cache = {}
   end
 
   def component(name)
+    return @component_cache[name.to_sym] if @component_cache.has_key?(name.to_sym)
+
     unless definition = @config['components'][name]
       raise ComponentNotFoundError, "Component not found: #{name}"
     end
@@ -36,83 +51,17 @@ class Weld
     css += definition['css'] || []
     js  += definition['js'] || []
 
-    Component.new(self, name, :css => css, :js => js, :requires => requires)
-  end
-
-  class Component
-    attr_reader :name, :requires
-    attr_accessor :css, :js
-
-    def initialize(weld, name, config = {})
-      raise ArgumentError, "weld must be a Weld instance" unless weld.is_a?(Weld)
-
-      @weld     = weld
-      @name     = name
-      @css      = config[:css] || []
-      @js       = config[:js] || []
-      @requires = config[:requires] || []
-
-      @file_cache = {}
-    end
-
-    def compress(type)
-      compressors = @weld.config['compressors']
-
-      unless compressors && compressors[type.to_s] &&
-          compressor_name = compressors[type.to_s]['name'].capitalize.to_sym
-        raise CompressorError, "No compressor configured"
-      end
-
-      options    = compressors[type.to_s]['options'] || {}
-      compressor = Compressor.const_get(compressor_name).new(type, options)
-
-      compressor.compress(merge(type))
-    end
-
-    def merge(type)
-      raise UnsupportedFileTypeError, "Unsupported file type: #{type}" unless [:css, :js].include?(type.to_sym)
-
-      content = ''
-      method(type.to_sym).call.each {|f| content << read_file(f) + "\n" }
-      content
-    end
-
-    private
-
-    def read_file(filename)
-      filename = resolve_file(filename)
-
-      if filename.is_a?(URI)
-        open(filename, 'User-Agent' => "#{APP_NAME}/#{APP_VERSION}").read
-      else
-        File.read(filename)
-      end
-    end
-
-    def resolve_file(filename)
-      return @file_cache[filename] if @file_cache.has_key?(filename)
-
-      if filename =~ /^(?:https?|ftp):\/\//
-        @file_cache[filename] = URI.parse(filename)
-      else
-        (@weld.config['sourcePaths'] || []).each do |source_path|
-          full_path = if Pathname.new(source_path).relative?
-            File.join(File.dirname(@weld.config_file), source_path, filename)
-          else
-            File.join(source_path, filename)
-          end
-
-          return @file_cache[filename] = File.expand_path(full_path) if File.exist?(full_path)
-        end
-
-        raise FileNotFoundError, "File not found: #{filename}"
-      end
-    end
+    @component_cache[name.to_sym] = Component.new(self, name,
+        :css      => css,
+        :js       => js,
+        :requires => requires
+    )
   end
 
   class Error < StandardError; end
   class ComponentNotFoundError < Error; end
   class CompressorError < Error; end
+  class ConfigError < Error; end
   class FileNotFoundError < Error; end
   class UnsupportedFileTypeError < Error; end
 end

data/lib/weld/cache.rb

@@ -0,0 +1,65 @@
+require 'digest/sha1'
+require 'time'
+
+class Weld::Cache
+  CACHE_DIR = File.join(Weld::HOME_DIR, 'cache')
+
+  def initialize
+    # Create the cache directory if it doesn't exist.
+    FileUtils.mkdir_p(CACHE_DIR)
+
+    purge_expired
+  end
+
+  def fetch(key)
+    now = Time.now
+
+    Dir["#{CACHE_DIR}/weld.*.#{key_hash(key)}"].each do |filename|
+      next unless meta = parse_filename(filename)
+
+      if meta[:expires] <= now
+        File.delete(filename)
+      else
+        return File.read(filename)
+      end
+    end
+
+    nil
+  end
+
+  alias [] fetch
+
+  def store(key, value, expires = Time.now + 1800)
+    File.open(File.join(CACHE_DIR, "weld.#{expires.to_i}.#{key_hash(key)}"), 'w') do |f|
+      f.write(value)
+    end
+
+    value
+  end
+
+  alias []= store
+
+  private
+
+  def key_hash(key)
+    Digest::SHA1.hexdigest(key.to_s)
+  end
+
+  def parse_filename(filename)
+    if File.basename(filename) =~ /^weld\.([0-9]+)\.([0-9a-f]{40})$/
+      {:expires => Time.at($1.to_i), :hash => $2}
+    else
+      nil
+    end
+  end
+
+  # Deletes expired files from the cache.
+  def purge_expired
+    now = Time.now
+
+    Dir["#{CACHE_DIR}/weld.*"].each do |filename|
+      next unless meta = parse_filename(filename)
+      File.delete(filename) if meta[:expires] <= now
+    end
+  end
+end

data/lib/weld/cdn.rb

@@ -0,0 +1,12 @@
+class Weld::CDN
+  autoload :S3, 'weld/cdn/s3'
+
+  attr_reader :options
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def push(filename, type, content)
+  end
+end

data/lib/weld/cdn/s3.rb

@@ -0,0 +1,57 @@
+require 'aws/s3'
+require 'stringio'
+require 'zlib'
+
+class Weld::CDN::S3 < Weld::CDN
+  def initialize(options = {})
+    super(options)
+
+    raise Weld::ConfigError, "S3 bucket not specified" unless @options['bucket']
+
+    @options['access_key_id']     ||= ENV['AMAZON_ACCESS_KEY_ID']
+    @options['secret_access_key'] ||= ENV['AMAZON_SECRET_ACCESS_KEY']
+
+    AWS::S3::Base.establish_connection!(
+      :access_key_id     => @options['access_key_id'],
+      :secret_access_key => @options['secret_access_key']
+    )
+
+    @bucket = if AWS::S3::Bucket.list.include?(@options['bucket'])
+      AWS::S3::Bucket.find(@options['bucket'])
+    else
+      AWS::S3::Bucket.create(@options['bucket'], :access => :public_read)
+      AWS::S3::Bucket.find(@options['bucket'])
+    end
+  end
+
+  def push(filename, type, content)
+    content_type = type == :css ? 'text/css' : 'application/javascript'
+    prefix       = (@options['prefix'] || {})[type.to_s] || ''
+    url_base     = @options['url_base'] || "http://#{@options['bucket']}.s3.amazonaws.com/"
+
+    object_options = {
+      :access            => :public_read,
+      'Cache-Control'    => 'public,max-age=315360000',
+      'Content-Type'     => "#{content_type};charset=utf-8",
+      'Expires'          => (Time.now + 315360000).httpdate # 10 years from now
+    }
+
+    if @options['gzip']
+      content_gzip = StringIO.new
+
+      gzip = Zlib::GzipWriter.new(content_gzip, 9)
+      gzip.write(content)
+      gzip.close
+
+      object_options['Content-Encoding'] = 'gzip'
+    end
+
+    object       = @bucket.new_object
+    object.key   = "#{prefix}#{filename}"
+    object.value = @options['gzip'] ? content_gzip.string : content
+
+    object.store(object_options)
+
+    File.join(url_base, object.key)
+  end
+end

data/lib/weld/cli.rb

@@ -0,0 +1,73 @@
+require 'trollop'
+
+class Weld::CLI
+  attr_reader :components, :options, :types, :weld
+
+  def initialize
+    parse_args
+
+    @weld         = Weld.new(@options[:config])
+    @components ||= @weld.config['components']
+  end
+
+  def cdn_push(filename, type, content)
+    init_cdn
+    @cdn.push(filename, type, content)
+  end
+
+  def error(message)
+    STDERR.puts "Error: #{message}"
+  end
+
+  def info(message)
+    puts message
+  end
+
+  def warn(message)
+    STDERR.puts "Warning: #{message}"
+  end
+
+  private
+
+  def init_cdn
+    return if @cdn
+
+    cdn_config = @weld.config['cdn']
+
+    unless cdn_config && cdn_type = cdn_config['type']
+      raise Weld::ConfigError, "No CDN configured"
+    end
+
+    @cdn = Weld::CDN.const_get(cdn_type.capitalize.to_sym).new(cdn_config['options'] || {})
+  end
+
+  def parse_args
+    @options = Trollop.options do
+      version "#{Weld::APP_NAME} #{Weld::APP_VERSION}\n" << Weld::APP_COPYRIGHT
+      banner <<-EOS
+#{Weld::APP_NAME} combines and minifies CSS and JavaScript files at runtime and build time.
+
+Usage:
+  weld [options] <component> [<component> ...]
+
+Options:
+EOS
+
+      opt :config,     "Use the specified config file.", :short => '-c', :default => './weld.yaml'
+      opt :no_minify,  "Don't perform any minification.", :short => :none
+      opt :output_dir, "Write welded files to the specified directory.", :short => '-o', :default => './'
+      opt :push,       "Push welded files to the configured CDN instead of saving them locally.", :short => '-p'
+      opt :type,       "Only weld components of the specified type ('css' or 'js').", :short => '-t', :type => :string
+    end
+
+    if @options[:type_given] && !['css', 'js'].include?(@options[:type])
+      abort "Error: Unsupported component type: #{@options[:type]}\n" <<
+          "Try --help for help."
+    end
+
+    @components = ARGV.length > 0 ? ARGV.dup : nil
+    @types      = @options[:type_given] ? [@options[:type].to_sym] : [:css, :js]
+
+    @options
+  end
+end

data/lib/weld/component.rb

@@ -0,0 +1,89 @@
+require 'open-uri'
+require 'pathname'
+
+class Weld::Component
+  attr_reader :name, :requires
+  attr_accessor :css, :js
+
+  def initialize(weld, name, config = {})
+    raise ArgumentError, "weld must be a Weld instance" unless weld.is_a?(Weld)
+
+    @weld     = weld
+    @name     = name
+    @css      = config[:css] || []
+    @js       = config[:js] || []
+    @requires = config[:requires] || []
+
+    @filename_cache = {}
+  end
+
+  def compress(type)
+    compressors = @weld.config['compressors']
+
+    unless compressors && compressors[type.to_s] &&
+        compressor_name = compressors[type.to_s]['name'].capitalize.to_sym
+      raise Weld::CompressorError, "No compressor configured"
+    end
+
+    options    = compressors[type.to_s]['options'] || {}
+    compressor = Weld::Compressor.const_get(compressor_name).new(type, options)
+
+    compressor.compress(merge(type))
+  end
+
+  def merge(type)
+    raise Weld::UnsupportedFileTypeError, "Unsupported file type: #{type}" unless [:css, :js].include?(type.to_sym)
+
+    content = ''
+    method(type.to_sym).call.each {|f| content << read_file(f) + "\n" }
+    content
+  end
+
+  private
+
+  def read_file(filename)
+    filename = resolve_filename(filename)
+
+    if filename.is_a?(URI)
+      if cached = @weld.cache[filename]
+        return cached
+      end
+
+      open(filename, 'User-Agent' => "#{Weld::APP_NAME}/#{Weld::APP_VERSION}") do |response|
+        unless response.status[0] == '200'
+          raise Weld::FileNotFoundError, "URL returned HTTP status code #{response.status[0]}: #{filename}"
+        end
+
+        expires = response.meta['expires'] ? Time.parse(response.meta['expires']) : nil
+
+        if expires
+          @weld.cache.store(filename, response.read, expires)
+        else
+          response.read
+        end
+      end
+    else
+      File.read(filename)
+    end
+  end
+
+  def resolve_filename(filename)
+    return @filename_cache[filename] if @filename_cache.has_key?(filename)
+
+    if filename =~ /^(?:https?|ftp):\/\//
+      @filename_cache[filename] = URI.parse(filename)
+    else
+      (@weld.config['sourcePaths'] || []).each do |source_path|
+        full_path = if Pathname.new(source_path).relative?
+          File.join(File.dirname(@weld.config_file), source_path, filename)
+        else
+          File.join(source_path, filename)
+        end
+
+        return @filename_cache[filename] = File.expand_path(full_path) if File.exist?(full_path)
+      end
+
+      raise Weld::FileNotFoundError, "File not found: #{filename}"
+    end
+  end
+end

data/lib/weld/compressor.rb

@@ -1,6 +1,6 @@
 require 'open3'
 
-class Weld; class Compressor
+class Weld::Compressor
   autoload :Yui, 'weld/compressor/yui'
 
   attr_reader :options, :type
@@ -12,5 +12,4 @@ class Weld; class Compressor
 
   def compress(input)
   end
-
-end; end
+end

data/lib/weld/server.rb

@@ -2,12 +2,8 @@ require 'sinatra/base'
 
 class Weld::Server < Sinatra::Base
 
-  get %r{^/([^/\.]+)\.(css|js)$} do |name, type|
-    begin
-      @weld ||= Weld.new(settings.config_file)
-    rescue => ex
-      halt 500, ex.to_s
-    end
+  get %r{^/([^/]+)\.(css|js)$} do |name, type|
+    @weld ||= Weld.new(settings.config_file)
 
     type      = type.to_sym
     no_minify = params.has_key?('no-minify') || params.has_key?('nominify')
@@ -15,22 +11,10 @@ class Weld::Server < Sinatra::Base
     content_type(type == :css ? 'text/css' : 'application/javascript',
         :charset => 'utf-8')
 
-    begin
-      if no_minify
-        @weld.component(name).merge(type)
-      else
-        @weld.component(name).compress(type)
-      end
-
-    rescue Weld::ComponentNotFoundError,
-           Weld::FileNotFoundError => ex
-      halt 404, ex.to_s
-
-    rescue Weld::UnsupportedFileTypeError => ex
-      halt 400, ex.to_s
-
-    rescue => ex
-      halt 500, ex.to_s
+    if no_minify
+      @weld.component(name).merge(type)
+    else
+      @weld.component(name).compress(type)
     end
   end
 

data/lib/weld/version.rb

@@ -1,6 +1,6 @@
 class Weld
   APP_NAME      = 'Weld'
-  APP_VERSION   = '0.0.1.dev.20100402'
+  APP_VERSION   = '0.0.1.dev.20100404'
   APP_AUTHOR    = 'Ryan Grove'
   APP_EMAIL     = 'ryan@wonko.com'
   APP_URL       = 'http://wonko.com/'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: weld
 version: !ruby/object:Gem::Version 
-  version: 0.0.1.dev.20100402
+  version: 0.0.1.dev.20100404
 platform: ruby
 authors: 
 - Ryan Grove
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-02 00:00:00 -07:00
+date: 2010-04-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !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"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
   type: :runtime
@@ -45,6 +55,11 @@ files:
 - README.rdoc
 - bin/weld
 - examples/simple-config.yaml
+- lib/weld/cache.rb
+- lib/weld/cdn/s3.rb
+- lib/weld/cdn.rb
+- lib/weld/cli.rb
+- lib/weld/component.rb
 - lib/weld/compressor/yui.rb
 - lib/weld/compressor.rb
 - lib/weld/server.rb