crush 0.0.1 → 0.1.0

data/Gemfile

@@ -1,4 +1,2 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in crush.gemspec
+source :rubygems
 gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Peter Browne
+
+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,42 @@
+Crush
+=====
+
+Crush is a generic interface, like Tilt, for the various compression engines in Ruby.
+It is useful for asset libraries that support multiple javascript and stylesheet compression engines.
+
+Basic Usage
+-----------
+
+```ruby
+require "uglifier"
+require "crush"
+Crush.new("application.js").compress
+```
+
+This would automatically compress the data found in the `application.js` file using Uglifier.
+Crush favors engines whose libraries have already been loaded.
+
+If you have multiple compression libraries loaded, and you want to control which one to use,
+you can initialize the engine directly.
+
+```ruby
+require "uglifier"
+require "jsmin"
+require "crush"
+Crush::Uglifier.new("application.js").compress
+```
+
+Or you could use `Crush.prefer` to tell Crush which engine you'd like to use.
+
+```ruby
+require "uglifier"
+require "jsmin"
+require "crush"
+Crush.prefer(Crush::Uglifier)
+Crush.new("application.js").compress
+```
+
+Copyright
+---------
+
+Copyright (c) 2011 [Peter Browne](http://petebrowne.com). See LICENSE for details.

data/Rakefile

@@ -1 +1,6 @@
+task :default => :spec
+
 require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new

data/crush.gemspec

@@ -12,6 +12,15 @@ Gem::Specification.new do |s|
   s.description = "Crush is a generic interface, like Tilt, for the various compression engines in Ruby."
 
   s.rubyforge_project = "crush"
+  
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "jsmin"
+  s.add_development_dependency "packr"
+  s.add_development_dependency "uglifier"
+  s.add_development_dependency "closure-compiler"
+  s.add_development_dependency "yui-compressor"
+  s.add_development_dependency "cssmin"
+  s.add_development_dependency "rainpress"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/crush.rb

@@ -1,2 +1,79 @@
 module Crush
+  autoload :Closure,   "crush/closure"
+  autoload :CSSMin,    "crush/cssmin"
+  autoload :Engine,    "crush/engine"
+  autoload :JSMin,     "crush/jsmin"
+  autoload :Packr,     "crush/packr"
+  autoload :Rainpress, "crush/rainpress"
+  autoload :Uglifier,  "crush/uglifier"
+  autoload :YUI,       "crush/yui"
+  
+  class EngineNotFound < StandardError; end
+  
+  # Hash of registered compression engines.
+  def self.mappings
+    @mappings ||= Hash.new { |h, k| h[k] = [] }
+  end
+  
+  # Ensures the extension doesn't include the "."
+  def self.normalize(ext)
+    ext.to_s.downcase.sub /^\./, ""
+  end
+  
+  # Registers a compression engine for the given file extension(s).
+  def self.register(engine, *extensions)
+    extensions.each do |ext|
+      ext = normalize(ext)
+      mappings[ext].unshift(engine).uniq!
+    end
+  end
+  
+  # Returns true when an engine exists for the given file extension.
+  def self.registered?(ext)
+    ext = normalize(ext)
+    mappings.key?(ext) && !mappings[ext].empty?
+  end
+  
+  # Make the given compression engine preferred. Which means,
+  # it will reordered the beginning of its mapping.
+  def self.prefer(engine)
+    mappings.each do |ext, engines|
+      if engines.include?(engine)
+        engines.delete(engine)
+        engines.unshift(engine)
+      end
+    end
+  end
+  
+  # Look for a compression engine for the given filename or file
+  # extension. Return nil when no engine is found.
+  def self.[](path)
+    pattern = File.basename(path.to_s).downcase
+    until pattern.empty? || registered?(pattern)
+      pattern.sub! /^[^.]*\.?/, ""
+    end
+    
+    pattern = normalize(pattern)
+    mappings[pattern].detect(&:engine_initialized?) || mappings[pattern].first
+  end
+  
+  # Create a new compression engine for the given file using the file's extension
+  # to determine the the engine mapping.
+  def self.new(path, options = {}, &block)
+    if engine = self[path]
+      engine.new path, options, &block
+    else
+      raise EngineNotFound.new("No compression engine registered for '#{path}'")
+    end
+  end
+  
+  register Crush::JSMin,                     "js",  "min.js"
+  register Crush::Packr,                     "js",  "pack.js"
+  register Crush::YUI::JavaScriptCompressor, "js",  "yui.js"
+  register Crush::Closure::Compiler,         "js",  "closure.js"
+  register Crush::Uglifier,                  "js",  "ugly.js"
+  
+  register Crush::CSSMin,                    "css", "min.css"
+  register Crush::Rainpress,                 "css", "rain.css"
+  register Crush::YUI::CssCompressor,        "css", "yui.css"
 end

data/lib/crush/closure.rb

@@ -0,0 +1,21 @@
+module Crush
+  module Closure
+    class Compiler < Crush::Engine
+      def self.engine_initialized?
+        !!(defined? ::Closure) && !!(defined? ::Closure::Compiler)
+      end
+    
+      def initialize_engine
+        require_template_library "closure-compiler"
+      end
+    
+      def prepare
+        @engine = ::Closure::Compiler.new(options)
+      end
+    
+      def evaluate
+        @engine.compile(data)
+      end
+    end
+  end
+end

data/lib/crush/cssmin.rb

@@ -0,0 +1,15 @@
+module Crush
+  class CSSMin < Engine
+    def self.engine_initialized?
+      !!(defined? ::CSSMin)
+    end
+    
+    def initialize_engine
+      require_template_library "cssmin"
+    end
+    
+    def evaluate
+      ::CSSMin.minify(data)
+    end
+  end
+end

data/lib/crush/engine.rb

@@ -0,0 +1,89 @@
+module Crush
+  class Engine
+    # The name of the file to be compressed
+    attr_reader :file
+    
+    # A Hash of compression engine specific options. This is passed directly
+    # to the underlying engine and is not used by the generic interface.
+    attr_reader :options
+    
+    # The data to cmopress; loaded from a file or given directly.
+    attr_reader :data
+    
+    # Used to determine if this class's initialize_engine method has
+    # been called yet.
+    @engine_initialized = false
+    class << self
+      attr_accessor :engine_initialized
+      alias :engine_initialized? :engine_initialized
+    end
+    
+    # Create a new engine with the file and options specified. By
+    # default, the data to compress is read from the file. When a block is given,
+    # it should read data and return as a String.
+    #
+    # All arguments are optional.
+    def initialize(file = nil, options = nil)
+      if file.respond_to?(:to_hash)
+        @options = file.to_hash
+      else
+        @file    = file
+        @options = options || {}
+      end
+      
+      unless self.class.engine_initialized?
+        initialize_engine
+        self.class.engine_initialized = true
+      end
+      
+      @data = if block_given?
+        yield
+      elsif @file
+        File.respond_to?(:binread) ? File.binread(@file) : File.read(@file)
+      end
+      
+      prepare
+    end
+    
+    # Compresses the data. Data can be read through the file or the block
+    # given at initialization, or through passing it here directly.
+    def render(data = nil)
+      @data = data unless data.nil?
+      evaluate
+    end
+    alias :compress :render
+    alias :compile :render
+    
+    protected
+    
+      # Called once and only once for each template subclass the first time
+      # the engine class is initialized. This should be used to require the
+      # underlying engine library and perform any initial setup.
+      def initialize_engine
+        
+      end
+      
+      # Do whatever preparation is necessary to setup the underlying compression
+      # engine. Called immediately after template data is loaded. Instance
+      # variables set in this method are available when #compress is called.
+      def prepare
+        
+      end
+      
+      # Called when it's time to compress. Return the compressed data
+      # from this method.
+      def evaluate
+        
+      end
+      
+      # Like Kernel::require but issues a warning urging a manual require when
+      # running under a threaded environment.
+      def require_template_library(name)
+        if Thread.list.size > 1
+          warn "WARN: crush autoloading '#{name}' in a non thread-safe way; " +
+               "explicit require '#{name}' suggested."
+        end
+        require name
+      end
+  end
+end

data/lib/crush/jsmin.rb

@@ -0,0 +1,15 @@
+module Crush
+  class JSMin < Engine
+    def self.engine_initialized?
+      !!(defined? ::JSMin)
+    end
+    
+    def initialize_engine
+      require_template_library "jsmin"
+    end
+    
+    def evaluate
+      ::JSMin.minify(data)
+    end
+  end
+end

data/lib/crush/packr.rb

@@ -0,0 +1,15 @@
+module Crush
+  class Packr < Engine
+    def self.engine_initialized?
+      !!(defined? ::Packr)
+    end
+    
+    def initialize_engine
+      require_template_library "packr"
+    end
+    
+    def evaluate
+      ::Packr.pack(data, options)
+    end
+  end
+end

data/lib/crush/rainpress.rb

@@ -0,0 +1,15 @@
+module Crush
+  class Rainpress < Engine
+    def self.engine_initialized?
+      !!(defined? ::Rainpress)
+    end
+    
+    def initialize_engine
+      require_template_library "rainpress"
+    end
+    
+    def evaluate
+      ::Rainpress.compress(data, options)
+    end
+  end
+end

data/lib/crush/uglifier.rb

@@ -0,0 +1,19 @@
+module Crush
+  class Uglifier < Engine
+    def self.engine_initialized?
+      !!(defined? ::Uglifier)
+    end
+    
+    def initialize_engine
+      require_template_library "uglifier"
+    end
+    
+    def prepare
+      @engine = ::Uglifier.new(options)
+    end
+    
+    def evaluate
+      @engine.compile(data)
+    end
+  end
+end

data/lib/crush/version.rb

@@ -1,3 +1,3 @@
 module Crush
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/crush/yui.rb

@@ -0,0 +1,39 @@
+module Crush
+  module YUI
+    class JavaScriptCompressor < Crush::Engine
+      def self.engine_initialized?
+        !!(defined? ::YUI) && !!(defined? ::YUI::JavaScriptCompressor)
+      end
+    
+      def initialize_engine
+        require_template_library "yui/compressor"
+      end
+    
+      def prepare
+        @engine = ::YUI::JavaScriptCompressor.new(options)
+      end
+    
+      def evaluate
+        @engine.compress(data)
+      end
+    end
+    
+    class CssCompressor < Crush::Engine
+      def self.engine_initialized?
+        !!(defined? ::YUI) && !!(defined? ::YUI::CssCompressor)
+      end
+    
+      def initialize_engine
+        require_template_library "yui/compressor"
+      end
+    
+      def prepare
+        @engine = ::YUI::CssCompressor.new(options)
+      end
+    
+      def evaluate
+        @engine.compress(data)
+      end
+    end
+  end
+end

data/spec/crush/closure_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "closure-compiler"
+
+describe Crush::Closure::Compiler do
+  it "is registered for '.js' files" do
+    Crush.mappings["js"].should include(Crush::Closure::Compiler)
+  end
+  
+  it "minifies using Closure::Compiler" do
+    compressor = mock(:compressor)
+    ::Closure::Compiler.should_receive(:new).with({}).and_return(compressor)
+    compressor.should_receive(:compile).with("hello").and_return("world")
+    Crush::Closure::Compiler.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to Closure::Compiler" do
+    compressor = mock(:compressor)
+    ::Closure::Compiler.should_receive(:new).with(:foo => "bar").and_return(compressor)
+    compressor.should_receive(:compile).with("hello").and_return("world")
+    Crush::Closure::Compiler.new(:foo => "bar").compress("hello")
+  end
+end

data/spec/crush/cssmin_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+require "cssmin"
+
+describe Crush::CSSMin do
+  it "is registered for '.js' files" do
+    Crush.mappings["css"].should include(Crush::CSSMin)
+  end
+  
+  it "minifies using CSSMin" do
+    ::CSSMin.should_receive(:minify).with("hello").and_return("world")
+    Crush::CSSMin.new.compress("hello").should == "world"
+  end
+end

data/spec/crush/engine_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe Crush::Engine do
+  class MockEngine < Crush::Engine
+  end
+  
+  describe "#file" do
+    it "returns the file the engine was initialized with" do
+      engine = MockEngine.new("application.js") {}
+      engine.file.should == "application.js"
+    end
+  end
+  
+  describe "#options" do
+    it "returns the options passed to the engine" do
+      engine = MockEngine.new(nil, :foo => "bar") {}
+      engine.options[:foo].should == "bar"
+      engine = MockEngine.new(:bar => "foo") {}
+      engine.options[:bar].should == "foo"
+    end
+  end
+  
+  describe "#data" do
+    it "returns the data from the file" do
+      File.stub(:binread => "Hello", :read => "Hello")
+      engine = MockEngine.new("application.js")
+      engine.data.should == "Hello"
+    end
+    
+    it "returns the data from the given block" do
+      engine = MockEngine.new("application.js") { "Hello" }
+      engine.data.should == "Hello"
+    end
+  end
+  
+  class InitializingMockEngine < Crush::Engine
+    class << self
+      attr_accessor :initialized_count
+    end
+
+    def initialize_engine
+      self.class.initialized_count += 1
+    end
+  end
+  
+  describe "#initialize_engine" do
+    it "is called one time to require the library" do
+      InitializingMockEngine.initialized_count = 0
+      InitializingMockEngine.new
+      InitializingMockEngine.initialized_count.should == 1
+      InitializingMockEngine.new
+      InitializingMockEngine.initialized_count.should == 1
+    end
+  end
+  
+  class InitializedMockEngine < Crush::Engine
+  end
+  
+  describe ".engine_initialized?" do
+    it "returns false before the engine has been initialized" do
+      InitializedMockEngine.engine_initialized?.should be_false
+    end
+    
+    it "returns true once the engine has been initialized" do
+      InitializedMockEngine.new
+      InitializedMockEngine.engine_initialized?.should be_true
+    end
+  end
+  
+  class PreparingMockEngine < Crush::Engine
+    class << self
+      attr_accessor :prepared_count
+    end
+    
+    def prepare
+      self.class.prepared_count += 1
+    end
+  end
+  
+  describe "#prepare" do
+    it "is called each time an engine is created" do
+      PreparingMockEngine.prepared_count = 0
+      PreparingMockEngine.new
+      PreparingMockEngine.prepared_count.should == 1
+      PreparingMockEngine.new
+      PreparingMockEngine.prepared_count.should == 2
+    end
+  end
+  
+  class SimpleMockEngine < Crush::Engine
+    def evaluate
+      @data.strip
+    end
+  end
+  
+  describe "#compress" do
+    it "compresses the data using the engine" do
+      File.stub(:binread => "  hello  ", :read => "  hello  ")
+      SimpleMockEngine.new("file.txt").compile.should == "hello"
+      SimpleMockEngine.new { "  hello  " }.render.should == "hello"
+      SimpleMockEngine.new.compress("  hello  ").should == "hello"
+    end
+  end
+end

data/spec/crush/jsmin_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+require "jsmin"
+
+describe Crush::JSMin do
+  it "is registered for '.js' files" do
+    Crush.mappings["js"].should include(Crush::JSMin)
+  end
+  
+  it "minifies using JSMin" do
+    ::JSMin.should_receive(:minify).with("hello").and_return("world")
+    Crush::JSMin.new.compress("hello").should == "world"
+  end
+end

data/spec/crush/packr_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "packr"
+
+describe Crush::Packr do
+  it "is registered for '.js' files" do
+    Crush.mappings["js"].should include(Crush::Packr)
+  end
+  
+  it "minifies using Packr" do
+    ::Packr.should_receive(:pack).with("hello", {}).and_return("world")
+    Crush::Packr.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to Packr" do
+    ::Packr.should_receive(:pack).with("hello", :foo => "bar")
+    Crush::Packr.new(:foo => "bar").compress("hello")
+  end
+end

data/spec/crush/rainpress_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "rainpress"
+
+describe Crush::Rainpress do
+  it "is registered for '.js' files" do
+    Crush.mappings["css"].should include(Crush::Rainpress)
+  end
+  
+  it "minifies using Rainpress" do
+    ::Rainpress.should_receive(:compress).with("hello", {}).and_return("world")
+    Crush::Rainpress.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to Rainpress" do
+    ::Rainpress.should_receive(:compress).with("hello", :foo => "bar")
+    Crush::Rainpress.new(:foo => "bar").compress("hello")
+  end
+end

data/spec/crush/uglifier_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "uglifier"
+
+describe Crush::Uglifier do
+  it "is registered for '.js' files" do
+    Crush.mappings["js"].should include(Crush::Uglifier)
+  end
+  
+  it "minifies using Uglifier" do
+    compressor = mock(:compressor)
+    ::Uglifier.should_receive(:new).with({}).and_return(compressor)
+    compressor.should_receive(:compile).with("hello").and_return("world")
+    Crush::Uglifier.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to Uglifier" do
+    compressor = mock(:compressor)
+    ::Uglifier.should_receive(:new).with(:foo => "bar").and_return(compressor)
+    compressor.should_receive(:compile).with("hello").and_return("world")
+    Crush::Uglifier.new(:foo => "bar").compress("hello")
+  end
+end

data/spec/crush/yui_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "yui/compressor"
+
+describe Crush::YUI::JavaScriptCompressor do
+  it "is registered for '.js' files" do
+    Crush.mappings["js"].should include(Crush::YUI::JavaScriptCompressor)
+  end
+  
+  it "minifies using YUI::JavaScriptCompressor" do
+    compressor = mock(:compressor)
+    ::YUI::JavaScriptCompressor.should_receive(:new).with({}).and_return(compressor)
+    compressor.should_receive(:compress).with("hello").and_return("world")
+    Crush::YUI::JavaScriptCompressor.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to YUI::JavaScriptCompressor" do
+    compressor = mock(:compressor)
+    ::YUI::JavaScriptCompressor.should_receive(:new).with(:foo => "bar").and_return(compressor)
+    compressor.should_receive(:compress).with("hello").and_return("world")
+    Crush::YUI::JavaScriptCompressor.new(:foo => "bar").compress("hello")
+  end
+end
+
+describe Crush::YUI::CssCompressor do
+  it "is registered for '.js' files" do
+    Crush.mappings["css"].should include(Crush::YUI::CssCompressor)
+  end
+  
+  it "minifies using YUI::CssCompressor" do
+    compressor = mock(:compressor)
+    ::YUI::CssCompressor.should_receive(:new).with({}).and_return(compressor)
+    compressor.should_receive(:compress).with("hello").and_return("world")
+    Crush::YUI::CssCompressor.new.compress("hello").should == "world"
+  end
+  
+  it "sends options to YUI::CssCompressor" do
+    compressor = mock(:compressor)
+    ::YUI::CssCompressor.should_receive(:new).with(:foo => "bar").and_return(compressor)
+    compressor.should_receive(:compress).with("hello").and_return("world")
+    Crush::YUI::CssCompressor.new(:foo => "bar").compress("hello")
+  end
+end

data/spec/crush_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Crush do
+  class MockCompressor
+    def self.engine_initialized?
+      true
+    end
+    
+    attr_reader :args, :block
+    def initialize(*args, &block)
+      @args = args
+      @block = block
+    end
+  end
+  
+  class MockCompressor2 < MockCompressor
+    def self.engine_initialized?
+      false
+    end
+  end
+  
+  before(:all) do
+    Crush.register(MockCompressor,  "mock", ".mck", "file.txt")
+    Crush.register(MockCompressor,  "mult")
+    Crush.register(MockCompressor2, "mult")
+  end
+  
+  describe ".mappings" do
+    it "always returns an array" do
+      Crush.mappings["none"].should == []
+    end
+  end
+  
+  describe ".register" do
+    it "stores engines" do
+      Crush.mappings["mock"].should include(MockCompressor)
+      Crush.mappings["mck"].should include(MockCompressor)
+      Crush.mappings["file.txt"].should include(MockCompressor)
+    end
+    
+    it "prefers the latest registered engines" do
+      Crush.mappings["mult"].first.should == MockCompressor2
+    end
+  end
+  
+  describe ".registered?" do
+    it "returns false if the extension is not registered" do
+      Crush.registered?("none").should be_false
+    end
+    
+    it "returns true if the given extension is registered" do
+      Crush.registered?("mock").should be_true
+      Crush.registered?(".mock").should be_true
+    end
+  end
+  
+  describe ".[]" do
+    it "returns nil when no engines are found" do
+      Crush["none"].should be_nil
+    end
+    
+    it "returns engines matching exact extension names" do
+      Crush["mock"].should == MockCompressor
+    end
+    
+    it "returns engines matching exact file extensions" do
+      Crush[".MOCK"].should == MockCompressor
+    end
+    
+    it "returns engines matching multiple file extensions" do
+      Crush["application.js.Mock"].should == MockCompressor
+    end
+    
+    it "returns engines matching filenames" do
+      Crush["some/path/file.txt"].should == MockCompressor
+    end
+    
+    it "returns engines that are already initialized" do
+      Crush["mult"].should == MockCompressor
+    end
+  end
+  
+  describe ".prefer" do
+    it "reorders the engine mappings so the given engine is returned" do
+      Crush.prefer(MockCompressor)
+      Crush["mult"].should == MockCompressor
+    end
+  end
+  
+  describe ".new" do
+    it "creates a new engine if found" do
+      compressor = Crush.new("application.mock", :key => "value") { "Hello World" }
+      compressor.args.should =~ [ "application.mock", { :key => "value" } ]
+      compressor.block.call.should == "Hello World"
+    end
+    
+    it "raises an error if no engine is found" do
+      expect { Crush.new("file.php") }.to raise_error(Crush::EngineNotFound)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+require "bundler/setup"
+Bundler.require
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: crush
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Pete
@@ -16,9 +11,96 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-31 00:00:00 Z
-dependencies: []
-
+date: 2011-06-05 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jsmin
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: packr
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: uglifier
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: closure-compiler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yui-compressor
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: cssmin
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rainpress
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id008
 description: Crush is a generic interface, like Tilt, for the various compression engines in Ruby.
 email: me@petebrowne.com
 executables: []
@@ -30,10 +112,30 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- LICENSE
+- README.md
 - Rakefile
 - crush.gemspec
 - lib/crush.rb
+- lib/crush/closure.rb
+- lib/crush/cssmin.rb
+- lib/crush/engine.rb
+- lib/crush/jsmin.rb
+- lib/crush/packr.rb
+- lib/crush/rainpress.rb
+- lib/crush/uglifier.rb
 - lib/crush/version.rb
+- lib/crush/yui.rb
+- spec/crush/closure_spec.rb
+- spec/crush/cssmin_spec.rb
+- spec/crush/engine_spec.rb
+- spec/crush/jsmin_spec.rb
+- spec/crush/packr_spec.rb
+- spec/crush/rainpress_spec.rb
+- spec/crush/uglifier_spec.rb
+- spec/crush/yui_spec.rb
+- spec/crush_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/petebrowne/crush
 licenses: []
 
@@ -47,25 +149,28 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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: crush
-rubygems_version: 1.7.1
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A generic interface to multiple Ruby compression engines.
-test_files: []
-
+test_files: 
+- spec/crush/closure_spec.rb
+- spec/crush/cssmin_spec.rb
+- spec/crush/engine_spec.rb
+- spec/crush/jsmin_spec.rb
+- spec/crush/packr_spec.rb
+- spec/crush/rainpress_spec.rb
+- spec/crush/uglifier_spec.rb
+- spec/crush/yui_spec.rb
+- spec/crush_spec.rb
+- spec/spec_helper.rb