crush 0.1.0 → 0.2.0

data/README.md

@@ -32,10 +32,50 @@ Or you could use `Crush.prefer` to tell Crush which engine you'd like to use.
 require "uglifier"
 require "jsmin"
 require "crush"
-Crush.prefer(Crush::Uglifier)
+Crush.prefer(Crush::Uglifier) # or Crush.prefer(:uglifier)
 Crush.new("application.js").compress
 ```
 
+API
+---
+
+There a few different ways to compress some data. The API, for the most part, follows the Tilt
+API. So this is the standard way of compressing (reading the data from the file):
+
+```ruby
+Crush.new("file.js", :mangle => true).compress
+```
+
+You can also pass the data using a block, like Tilt.
+
+```ruby
+Crush.new(:uglifier, :mangle => true) { "some data to compress" }.compress
+```
+
+_Note how I declared which engine to use by its name (as a Symbol)._
+
+I've also included a way to pass data that is more consistent with the other compression engines:
+
+```ruby
+Crush.new(:uglifier, :mangle => true).compress("some data to compress")
+```
+
+Engines
+-------
+
+Support fo these compression engines are included:
+
+    ENGINES                    FILE EXTENSIONS    NAME       REQUIRED LIBRARIES
+    -------------------------- ------------------ ---------- ------------------
+    JSMin                      .js,  .min.js      jsmin      jsmin
+    Packr                      .js,  .pack.js     packr      packr
+    YUI::JavaScriptCompressor  .js,  .yui.js      yui_js     yui/compressor
+    Closure::Compiler          .js,  .closure.js  closure    closure-compiler
+    Uglifier                   .js,  .ugly.js     uglifier   uglifier
+    CSSMin                     .css, .min.css     cssmin     cssmin
+    Rainpress                  .css, .rain.css    rainpress  rainpress
+    YUI::CssCompressor         .css, .yui.css     yui_css    yui/compressor    
+
 Copyright
 ---------
 

data/lib/crush.rb

@@ -10,9 +10,12 @@ module Crush
   
   class EngineNotFound < StandardError; end
   
+  @preferred_engines = {}
+  @engine_mappings   = Hash.new { |h, k| h[k] = [] }
+  
   # Hash of registered compression engines.
   def self.mappings
-    @mappings ||= Hash.new { |h, k| h[k] = [] }
+    @engine_mappings
   end
   
   # Ensures the extension doesn't include the "."
@@ -36,37 +39,63 @@ module Crush
   
   # 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)
+  def self.prefer(engine_or_name, *extensions)
+    engine = find_by_name(engine_or_name) unless engine_or_name.is_a?(Class)
+    
+    if extensions.empty?
+      mappings.each do |ext, engines|
+        @preferred_engines[ext] = engine if engines.include?(engine)
+      end
+    else
+      register(engine, *extensions)
+      extensions.each do |ext|
+        ext = normalize(ext)
+        @preferred_engines[ext] = engine
       end
     end
   end
   
+  # Looks for a compression engine. When given a Symbol, it will look for an engine
+  # by name. When given a String, it will look for a compression engine by filename
+  # or file extension.
+  def self.[](path_or_name)
+    path_or_name.is_a?(Symbol) ? find_by_name(path_or_name) : find_by_path(path_or_name)
+  end
+  
+  # Create a new compression engine. The first argument is used to determine
+  # which engine to use. This can be either an engine name (as a Symbol) or a path
+  # to a file (as a String). If a path is given, the engine is initialized with
+  # a reference to that path.
+  def self.new(path_or_name, options = {}, &block)
+    if engine = self[path_or_name]
+      path = path_or_name.is_a?(Symbol) ? nil : path_or_name
+      engine.new(path, options, &block)
+    else
+      raise EngineNotFound.new("No compression engine registered for '#{path}'")
+    end
+  end
+  
+  # Look for a compression engine with the given engine name.
+  # Return nil when no engine is found.
+  def self.find_by_name(engine_name)
+    mappings.values.flatten.detect { |engine| engine.engine_name == engine_name.to_s }
+  end
+  
   # Look for a compression engine for the given filename or file
   # extension. Return nil when no engine is found.
-  def self.[](path)
+  def self.find_by_path(path)
     pattern = File.basename(path.to_s).downcase
     until pattern.empty? || registered?(pattern)
       pattern.sub! /^[^.]*\.?/, ""
     end
-    
     pattern = normalize(pattern)
+    
+    preferred_engine = @preferred_engines[pattern]
+    return preferred_engine unless preferred_engine.nil?
+    
     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"

data/lib/crush/closure.rb

@@ -1,6 +1,10 @@
 module Crush
   module Closure
     class Compiler < Crush::Engine
+      def self.engine_name
+        "closure"
+      end
+      
       def self.engine_initialized?
         !!(defined? ::Closure) && !!(defined? ::Closure::Compiler)
       end

data/lib/crush/cssmin.rb

@@ -1,5 +1,9 @@
 module Crush
   class CSSMin < Engine
+    def self.engine_name
+      "cssmin"
+    end
+      
     def self.engine_initialized?
       !!(defined? ::CSSMin)
     end

data/lib/crush/engine.rb

@@ -16,6 +16,17 @@ module Crush
     class << self
       attr_accessor :engine_initialized
       alias :engine_initialized? :engine_initialized
+      
+      # Returns a lowercase, underscored name for the engine.
+      def engine_name
+        engine_name = name.to_s.dup
+        engine_name.sub!  /^.*::/ , ""
+        engine_name.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+        engine_name.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+        engine_name.tr!   "-", "_"
+        engine_name.downcase!
+        engine_name
+      end
     end
     
     # Create a new engine with the file and options specified. By

data/lib/crush/jsmin.rb

@@ -1,5 +1,9 @@
 module Crush
   class JSMin < Engine
+    def self.engine_name
+      "jsmin"
+    end
+    
     def self.engine_initialized?
       !!(defined? ::JSMin)
     end

data/lib/crush/version.rb

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

data/lib/crush/yui.rb

@@ -1,6 +1,10 @@
 module Crush
   module YUI
     class JavaScriptCompressor < Crush::Engine
+      def self.engine_name
+        "yui_js"
+      end
+      
       def self.engine_initialized?
         !!(defined? ::YUI) && !!(defined? ::YUI::JavaScriptCompressor)
       end
@@ -19,6 +23,10 @@ module Crush
     end
     
     class CssCompressor < Crush::Engine
+      def self.engine_name
+        "yui_css"
+      end
+      
       def self.engine_initialized?
         !!(defined? ::YUI) && !!(defined? ::YUI::CssCompressor)
       end

data/spec/crush/closure_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "closure-compiler"
 
 describe Crush::Closure::Compiler do
+  specify { Crush::Closure::Compiler.engine_name.should == "closure" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["js"].should include(Crush::Closure::Compiler)
   end

data/spec/crush/cssmin_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "cssmin"
 
 describe Crush::CSSMin do
+  specify { Crush::CSSMin.engine_name.should == "cssmin" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["css"].should include(Crush::CSSMin)
   end

data/spec/crush/engine_spec.rb

@@ -4,6 +4,12 @@ describe Crush::Engine do
   class MockEngine < Crush::Engine
   end
   
+  describe ".engine_name" do
+    it "returns an undescored version of the class name" do
+      MockEngine.engine_name.should == "mock_engine"
+    end
+  end
+  
   describe "#file" do
     it "returns the file the engine was initialized with" do
       engine = MockEngine.new("application.js") {}

data/spec/crush/jsmin_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "jsmin"
 
 describe Crush::JSMin do
+  specify { Crush::JSMin.engine_name.should == "jsmin" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["js"].should include(Crush::JSMin)
   end

data/spec/crush/packr_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "packr"
 
 describe Crush::Packr do
+  specify { Crush::Packr.engine_name.should == "packr" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["js"].should include(Crush::Packr)
   end

data/spec/crush/rainpress_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "rainpress"
 
 describe Crush::Rainpress do
+  specify { Crush::Rainpress.engine_name.should == "rainpress" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["css"].should include(Crush::Rainpress)
   end

data/spec/crush/uglifier_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "uglifier"
 
 describe Crush::Uglifier do
+  specify { Crush::Uglifier.engine_name.should == "uglifier" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["js"].should include(Crush::Uglifier)
   end

data/spec/crush/yui_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "yui/compressor"
 
 describe Crush::YUI::JavaScriptCompressor do
+  specify { Crush::YUI::JavaScriptCompressor.engine_name.should == "yui_js" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["js"].should include(Crush::YUI::JavaScriptCompressor)
   end
@@ -22,6 +24,8 @@ describe Crush::YUI::JavaScriptCompressor do
 end
 
 describe Crush::YUI::CssCompressor do
+  specify { Crush::YUI::CssCompressor.engine_name.should == "yui_css" }
+  
   it "is registered for '.js' files" do
     Crush.mappings["css"].should include(Crush::YUI::CssCompressor)
   end

data/spec/crush_spec.rb

@@ -2,6 +2,10 @@ require "spec_helper"
 
 describe Crush do
   class MockCompressor
+    def self.engine_name
+      "mock"
+    end
+    
     def self.engine_initialized?
       true
     end
@@ -14,6 +18,10 @@ describe Crush do
   end
   
   class MockCompressor2 < MockCompressor
+    def self.engine_name
+      "mock2"
+    end
+    
     def self.engine_initialized?
       false
     end
@@ -21,8 +29,8 @@ describe Crush do
   
   before(:all) do
     Crush.register(MockCompressor,  "mock", ".mck", "file.txt")
-    Crush.register(MockCompressor,  "mult")
-    Crush.register(MockCompressor2, "mult")
+    Crush.register(MockCompressor,  "mult", "mlt")
+    Crush.register(MockCompressor2, "mult", "mlt")
   end
   
   describe ".mappings" do
@@ -55,36 +63,34 @@ describe Crush do
   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
+    it "returns engines found by path when given strings" 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["application.js.mock"].should == MockCompressor
       Crush["some/path/file.txt"].should == MockCompressor
     end
     
-    it "returns engines that are already initialized" do
-      Crush["mult"].should == MockCompressor
+    it "returns engines found by name when given symbols" do
+      Crush[:mock].should == MockCompressor
+      Crush[:mock2].should == MockCompressor2
     end
   end
   
   describe ".prefer" do
-    it "reorders the engine mappings so the given engine is returned" do
+    it "reorders the engine engines so the given engine is returned" do
       Crush.prefer(MockCompressor)
       Crush["mult"].should == MockCompressor
     end
+    
+    it "accepts symbol names of the various engines" do
+      Crush.prefer(:mock2)
+      Crush["mult"].should == MockCompressor2
+    end
+    
+    it "limits the preference to the given extensions" do
+      Crush.prefer(:mock, "mlt")
+      Crush["mult"].should == MockCompressor2
+      Crush["mlt"].should == MockCompressor
+    end
   end
   
   describe ".new" do
@@ -98,4 +104,42 @@ describe Crush do
       expect { Crush.new("file.php") }.to raise_error(Crush::EngineNotFound)
     end
   end
+  
+  describe ".find_by_name" do
+    it "returns nil if the engine could not be found" do
+      Crush.find_by_name("none").should be_nil
+    end
+    
+    it "returns the registered engine with the given name" do
+      Crush.find_by_name("mock").should == MockCompressor
+      Crush.find_by_name("mock2").should == MockCompressor2
+    end
+  end
+  
+  describe ".find_by_path" do
+    it "returns nil when no engines are found" do
+      Crush.find_by_path("none").should be_nil
+    end
+    
+    it "returns engines matching exact extension names" do
+      Crush.find_by_path("mock").should == MockCompressor
+    end
+    
+    it "returns engines matching exact file extensions" do
+      Crush.find_by_path(".MOCK").should == MockCompressor
+    end
+    
+    it "returns engines matching multiple file extensions" do
+      Crush.find_by_path("application.js.Mock").should == MockCompressor
+    end
+    
+    it "returns engines matching filenames" do
+      Crush.find_by_path("some/path/file.txt").should == MockCompressor
+    end
+    
+    it "returns engines that are already initialized" do
+      Crush.instance_variable_get("@preferred_engines").delete("mult")
+      Crush.find_by_path("mult").should == MockCompressor
+    end
+  end
 end

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: crush
 version: !ruby/object:Gem::Version 
+  hash: 23
   prerelease: 
-  version: 0.1.0
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Pete
@@ -11,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-05 00:00:00 Z
+date: 2011-06-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -21,6 +26,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
         version: 2.6.0
   type: :development
   version_requirements: *id001
@@ -32,6 +42,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id002
@@ -43,6 +56,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id003
@@ -54,6 +70,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id004
@@ -65,6 +84,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id005
@@ -76,6 +98,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id006
@@ -87,6 +112,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id007
@@ -98,6 +126,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id008
@@ -149,17 +180,23 @@ 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.2
+rubygems_version: 1.7.1
 signing_key: 
 specification_version: 3
 summary: A generic interface to multiple Ruby compression engines.