compressible 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Lance Pollard and David Crockett
+ 
+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,125 @@
+# Compressible
+
+Ready-to-go Asset Compression for Ruby, using the YUICompressor.
+
+    sudo gem install compressible
+    
+# Usage
+
+## Configuration
+
+There are a few ways you can configure this
+
+### 1. Initializers
+
+Inside an initializer such as `config/compressible.rb`:
+
+    Compressible.stylesheets(
+      :production_cache => %w(reset background footer list),
+      :typography => %w(forms headers basic_text)
+    )
+    Compressible.javascripts(
+      :production_cache => %w(animations effects dragdrop)
+    )
+    
+    # or
+    Compressible.assets(
+      :stylesheets => {
+        :production_cache => %w(reset background footer list),
+        :typography => %w(forms headers basic_text)
+      }
+      :javascripts => {
+        :production_cache => %w(animations effects dragdrop)
+      }
+    )
+    
+    # or one at a time
+    Compressible.stylesheet(
+      :production_cache => %w(reset background footer list)
+    )
+    Compressible.stylesheet(
+      :typography => %w(forms headers basic_text)
+    )
+
+Each of those methods have plenty of aliases to be more descriptive and more concise, respectively:
+
+- `stylesheets`: `add_stylesheets`
+- `javascripts`: `add_javascripts`
+- `stylesheet`: `add_stylesheet`, `css`
+- `javascript`: `add_javascript`, `js`
+
+Or you can call them generically:
+
+    Compressible.assets(:stylesheet)
+    Compressible.assets(:javascript)
+    
+### 2. Yaml
+
+You can specify these same configuration options using Yaml:
+
+    js:
+      paths:
+        - animations
+        - effects
+        - dragdrop
+      to: production_cache
+      munge: true
+    css:
+      -
+        paths:
+          - reset
+          - background
+          - footer
+          - list
+        to: production_cache
+      -
+        paths:
+          - forms
+          - headers
+          - basic_text
+        to: typography
+
+You can then setup everything with `configure`:
+
+    Compressible.configure("config/compressible.yml") # or pass it the yaml hash
+    
+## Views
+
+Add this to your views:
+
+    compressible_stylesheet_tag "production_cache", "typography"
+    compressible_javascript_tag "production_cache"
+
+By default, it will use non-compressed stylesheets when `Rails.env == "development"`, and the compressed stylesheets when `Rails.env == "production"`.
+
+To tell it you want to use the cached in a different environment, you can specify it like this:
+
+    compressible_stylesheet_tag "production_cache", :environments => ["production", "staging"]
+
+## Awesome Assets for Heroku
+
+Because Heroku is a Read-Only file system, you can't use Rails' built in asset cacher, or libraries like `asset_packager`.  They rely on the ability to write to the file system in the production environment.
+
+Some libraries solve this by patching `asset_packager` to redirect css/js urls to the `/tmp` directory using Rack middleware.  The `/tmp` directory is about the only place Heroku lets you write to the file system in.  The main issue with this approach is that all requests for stylesheets and javascripts must pass through Rack, which potentially _doubles_ response time.  Take a look at the [asset loading performance comparison with different Ruby stacks](http://www.ridingtheclutch.com/2009/07/13/the-ultimate-ruby-performance-test-part-1.html).
+
+As such, Compressible compresses all assets before you push to Heroku, so a) you never write to the Heroku file system, and b) you don't have slow down the request with application or middleware layers.  It does this with _git hooks_.  Every time you commit, a `pre-commit` hook runs which re-compresses your assets.  That means whenever you push, your assets are ready for production.
+
+This is configurable.  It relies on the [`hookify`](http://github.com/viatropos/hookify) gem.
+
+    sudo gem install hookify
+    cd my-rails-app
+    hookify pre-commit
+    
+That creates a ruby script for you were you can define what you want to run when.  In our case, we want to run:
+
+    Compressible.assets(
+      :stylesheets => {
+        :production_cache => %w(reset background footer list),
+        :typography => %w(forms headers basic_text)
+      }
+      :javascripts => {
+        :production_cache => %w(animations effects dragdrop)
+      }
+    )
+    
+Very cool.

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rake'
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+
+# http://docs.rubygems.org/read/chapter/20
+spec = Gem::Specification.new do |s|
+  s.name              = "compressible"
+  s.version           = "0.0.2"
+  s.author            = "Lance Pollard"
+  s.summary           = "Compressible: Quick asset compression for Ruby"
+  s.homepage          = "http://github.com/viatropos/compressible"
+  s.email             = "lancejpollard@gmail.com"
+  s.description       = "Quick asset compression for Ruby"
+  s.has_rdoc          = true
+  s.rubyforge_project = "compressible"
+  s.platform          = Gem::Platform::RUBY
+  s.files             = %w(README.markdown Rakefile init.rb MIT-LICENSE) + Dir["{lib,rails,test}/**/*"] - Dir["test/tmp"]
+  s.require_path      = "lib"
+  s.add_dependency("activesupport", ">= 2.1.2")
+  s.add_dependency("yui-compressor")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec    = spec
+  pkg.package_dir = "pkg"
+end
+
+desc "Create .gemspec file (useful for github)"
+task :gemspec do
+  File.open("pkg/#{spec.name}.gemspec", "w") do |f|
+    f.puts spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build pkg/#{spec.name}.gemspec`
+end
+
+desc "Publish gem to rubygems"
+task :publish => [:package] do
+  %x[gem push pkg/#{spec.name}-#{spec.version}.gem]
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest do
+  File.open("Manifest", "w") do |f|
+    spec.files.each do |file|
+      f.puts file
+    end
+  end
+end
+
+desc "Install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{spec.name}-#{spec.version} --no-ri --no-rdoc}
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.markdown", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.markdown"
+  rdoc.title = spec.summary
+end
+
+task :yank do
+  `gem yank #{spec.name} -v #{spec.version}`
+end
+
+task :lance do
+  puts "LANCE POLARd"
+end
+
+namespace :hookify do
+  
+  task :pre_commit do
+  end
+  
+end#

data/init.rb

@@ -0,0 +1 @@
+File.dirname(__FILE__) + "/rails/init.rb"

data/lib/compressible.rake

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+require 'yui/compressor'
+
+namespace :compress do
+  
+  desc "Compress JS"
+  task :js do
+    Compressible.js(
+      ENV["JS"].split(/,?\s+/),
+      :to => ENV["TO"],
+      :munge => ENV["MUNGE"].blank? || true : ENV["MUNGE"]
+    )
+  end
+  
+  desc "Compress CSS"
+  task :css do
+    Compressible.css(
+      ENV["CSS"].split(/,?\s+/),
+      :to => ENV["TO"]
+    )
+  end
+  
+  desc "Compress CSS and JS"
+  task :all => [:js, :css]
+  
+end

data/lib/compressible.rb

@@ -0,0 +1,225 @@
+require 'rubygems'
+require 'yaml'
+begin
+  gem "activesupport", "= 2.3.5"
+  require 'active_support'
+rescue Gem::LoadError => e
+  puts e.inspect
+end
+require 'yui/compressor'
+this = File.dirname(__FILE__)
+require File.join(this, "ext.rb")
+
+class Compressible
+  
+  KEYS = {
+    :css => :stylesheet,
+    :stylesheet => :css,
+    :js => :javascript,
+    :javascript => :js
+  }
+  
+  class << self
+    
+    attr_reader :config
+    
+    def configure(value = nil)
+      raise "invalid config" unless (value.is_a?(String) || value.is_a?(Hash))
+      @config = value.is_a?(String) ? YAML.load_file(value) : value
+      @config.recursively_symbolize_keys!
+      
+      @config = defaults.merge(@config)
+      
+      # normalize everything to an array
+      [:js, :css].each do |type|
+        @config[type] = [@config[type]] unless @config[type].is_a?(Array)
+      end
+      
+      @config
+    end
+    
+    def defaults
+      {
+        :js => [],
+        :css => [],
+        :stylesheet_path => defined?(Rails) ? "#{Rails.root}/public/stylesheets" : nil,
+        :javascript_path => defined?(Rails) ? "#{Rails.root}/public/javascripts" : nil
+      }
+    end
+    
+    def config
+      @config ||= defaults
+    end
+    
+    def add_to_config(type, key, value)
+      item = find_or_create(type, key)
+      item[:paths] = value.collect {|i| asset_name(i)}
+      item
+    end
+    
+    def find_or_create(type, key)
+      result = config[type].detect {|i| i[:to].to_s == key.to_s}
+      unless result
+        result = {:to => key.to_s}
+        config[type] << result
+      end
+      result
+    end
+    
+    def reset
+      @config = defaults
+    end
+    
+    def uncached_stylesheet_paths(*keys)
+      uncached_paths_for(:css, *keys)
+    end
+    
+    def uncached_javascript_paths(*keys)
+      uncached_paths_for(:js, *keys)
+    end
+    
+    def uncached_paths_for(type, *keys)
+      returning [] do |result|
+        config[type].each do |item|
+          keys.each do |key|
+            result.concat(item[:paths]) if item[:to] == key.to_s
+          end
+        end
+      end
+    end
+    
+    # called if you gave it a config
+    def compress(value = nil)
+      configure(value) if value
+      raise "set config to yaml file or run 'Compressible.js' or 'Compressible.css' manually" unless @config
+      
+      [:js, :css].each do |k|
+        config[k].each do |item|
+          compress_from_hash(k, item)
+        end
+      end
+    end
+    
+    def compress_from_hash(k, v)
+      args = v.dup.delete(:paths) + [v]
+      self.send(k, *args)
+    end
+    
+    def javascripts(hash)
+      hash.each do |to, paths|
+        paths << {:to => to}
+        javascript(*paths)
+      end
+    end
+    alias_method :add_javascripts, :javascripts
+    
+    def stylesheets(hash)
+      hash.each do |to, paths|
+        paths << {:to => to}
+        stylesheet(*paths)
+      end
+    end
+    alias_method :add_stylesheets, :stylesheets
+    
+    def javascript(*paths)
+      options = paths.extract_options!
+      to = asset_name(options[:to])
+      raise "Please define a name for the cached javascript using ':to => :my_name'" unless to
+      munge = options.has_key?(:munge) ? options[:munge] : true
+      
+      add_to_config(:js, to, paths)
+      
+      compressor = YUI::JavaScriptCompressor.new(:munge => munge)
+      
+      result = paths.collect do |path|
+        puts "Compressing #{path}..."
+        compressor.compress(read(:javascript, path))
+      end.join("\n\n")
+      
+      write(:javascript, to, result) if to
+      
+      result
+    end
+    alias_method :add_javascript, :javascript
+    alias_method :js, :javascript
+    
+    def stylesheet(*paths)
+      options = paths.extract_options!
+      to = asset_name(options[:to])
+      
+      add_to_config(:css, to, paths)
+
+      compressor = YUI::CssCompressor.new
+      
+      result = paths.collect do |path|
+        puts "Compressing #{path}..."
+        compressor.compress(read(:stylesheet, path))
+      end.join("\n\n")
+      
+      write(:stylesheet, to, result) if to
+      
+      result
+    end
+    alias_method :add_stylesheet, :stylesheet
+    alias_method :css, :stylesheet
+    
+    def stylesheets_for(*keys)
+      assets_for(:stylesheet, *keys)
+    end
+    
+    def javascripts_for(*keys)
+      assets_for(:javascript, *keys)
+    end
+    
+    def assets_for(type, *keys)
+      options = keys.extract_options!
+      environment = defined?(Rails) ? Rails.env.to_s : (options[:current] || "production")
+      environment = environment.to_s
+      cache_environments = options[:environments] || "production"
+      cache_environments = [cache_environments] unless cache_environments.is_a?(Array)
+      cache_environments = cache_environments.collect(&:to_s)
+      
+      assets = cache_environments.include?(environment) ? keys : send("uncached_#{type.to_s}_paths", *keys)
+      assets
+    end
+    
+    def read(type, from)
+      IO.read(path_for(type, from))
+    end
+    
+    def write(type, to, result)
+      File.open(path_for(type, to), "w") {|f| f.puts result}
+    end
+    
+    def asset_name(path)
+      result = path.to_s.split(".")
+      if result.last =~ /(js|css)/
+        result = result[0..-2].join(".")
+      else
+        result = result.join(".")
+      end
+      result
+    end
+    
+    # ultimately should return global path
+    def path_for(type, file)
+      key = "#{type.to_s}_path".to_sym
+      
+      if config && config[key]
+        path = File.join(config[key], file.to_s)
+      elsif defined?(Rails)
+        path = File.join(Rails.root.to_s, "public/#{type.to_s.pluralize}", file.to_s)
+      else
+        path = file.to_s
+      end
+      
+      path << ".#{KEYS[type].to_s}" unless path.split(".").last == KEYS[type].to_s
+      
+      path
+    end
+    
+  end
+  
+end
+
+Dir["#{this}/compressible/*"].each { |c| require c }