perfectline-smurf 1.1.0

data/README.markdown

@@ -0,0 +1,59 @@
+# Smurf
+
+Smurf is a Rails plugin that does Javascript and CSS minification the way you would expect. See, with Rails `2.x` we got this cool new `:cache` option on `javascript_include_tag` and `stylesheet_link_tag`, but no option for minifying the cached file(s).
+
+Smurf ends that. Smurf - if installed and when caching is enabled for the environment - will nab the concatenated file content from Rails just before it saves it and minifies the content using either JSmin or a custom CSS compressor.
+
+Some cool things about Smurf, which also allude to the reasons I wrote it:
+
+* Smurf will only run when Rails needs to cache new files
+* It will never run on its own
+* It requires absolutely no configuration
+* Other than installing it, you don't need to do anything
+* It just gets out of your way
+
+Smurf will work with any version of Rails `2.x`; including Rails `2.2.2`.
+
+### JSmin
+
+It's really an adaptation of Uladzislau Latynski's [jsmin.rb](http://javascript.crockford.com/jsmin.rb) port of Douglas Crockford's [jsmin.c](http://javascript.crockford.com/jsmin.c) library.
+
+### Smurf CSS Compressor
+
+The following are the rules I applied, gathered from various perusals around the Internet*s*
+
+1. Replace consecutive whitespace characters with a single space
+2. Remove whitespace around opening brackets
+3. Remove whitespace in front of closing brackets
+4. Remove the semi-colon just before the closing bracket
+5. Remove comments between `/* ... */` - this could be a problem (esp. for CSS hacks)
+6. Remove spaces around `;`, `:`, and `,` characters
+7. Ensure whitespace between closing brackets and periods
+
+## Installation
+
+    ./script/plugin install git://github.com/thumblemonks/smurf.git
+
+Then, wherever you define `javascript_include_tag` or `stylesheet_link_tag`, make sure to add the standard `:cache => true` or `:cache => 'some_bundle'` options.
+
+Also make sure to at least have this setting in your production.rb:
+
+    config.action_controller.perform_caching = true
+
+## Testing and Other Stuff
+
+If you want to test Smurf and you don't want to test with the latest version of Rails as of this writing (2.2.2), then do something like the following:
+
+    rake RAILS_GEM_VERSION=2.1.2
+
+This is the mechanism I used for testing that Smurf works for all versions:
+
+    rake && rake RAILS_GEM_VERSION=2.1.2
+
+## Meta
+
+Author: Justin Knowlden <gus@thumblemonks.com>
+
+Contributions from: Lance Ivy, Scott White, Daniel Schierbeck
+
+See MIT-LICENSE for licensing information

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |jewel|
+    jewel.name = 'smurf'
+    jewel.summary = 'Rails plugin to automatically minify JS and CSS when their bundles get cached'
+    jewel.email = 'gus@thumblemonks.com'
+    jewel.homepage = 'http://github.com/thumblemonks/smurf'
+    jewel.description = 'Rails plugin to automatically minify JS and CSS when their bundles get cached. Send in those patches!'
+    jewel.authors = ["Justin Knowlden"]
+    jewel.files.exclude 'test/**'
+    jewel.test_files.exclude 'test/log/**'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the load_model plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the smurf plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Smurf'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 1
+:minor: 1

data/lib/smurf.rb

@@ -0,0 +1,38 @@
+require 'smurf/javascript'
+require 'smurf/stylesheet'
+
+if Rails.version =~ /^2\.2\./
+  # Support for Rails >= 2.2.x
+  module Smurf
+
+    module JavaScriptSources
+    private
+      def joined_contents; Smurf::Javascript.new(super).minified; end
+    end # JavaScriptSources
+
+    module StylesheetSources
+    private
+      def joined_contents; Smurf::Stylesheet.new(super).minified; end
+    end # StylesheetSources
+
+  end # ActionView::Helpers::AssetTagHelper::AssetTag
+  ActionView::Helpers::AssetTagHelper::JavaScriptSources.send(
+    :include, Smurf::JavaScriptSources)
+  ActionView::Helpers::AssetTagHelper::StylesheetSources.send(
+    :include, Smurf::StylesheetSources)
+else
+  # Support for Rails <= 2.1.x
+  module ActionView::Helpers::AssetTagHelper
+  private
+    def join_asset_file_contents_with_minification(files)
+      content = join_asset_file_contents_without_minification(files)
+      if !files.grep(%r[/javascripts]).empty?
+        content = Smurf::Javascript.new(content).minified
+      elsif !files.grep(%r[/stylesheets]).empty?
+        content = Smurf::Stylesheet.new(content).minified
+      end
+      content
+    end
+    alias_method_chain :join_asset_file_contents, :minification
+  end # ActionView::Helpers::AssetTagHelper
+end

data/lib/smurf/javascript.rb

@@ -0,0 +1,225 @@
+# Author: Justin Knowlden
+# Adaption of jsmin.rb published by Uladzislau Latynski
+#
+# -------------------
+# jsmin.rb 2007-07-20
+# Author: Uladzislau Latynski
+# This work is a translation from C to Ruby of jsmin.c published by
+# Douglas Crockford.  Permission is hereby granted to use the Ruby
+# version under the same conditions as the jsmin.c on which it is
+# based.
+#
+# /* jsmin.c
+#    2003-04-21
+#
+# Copyright (c) 2002 Douglas Crockford  (www.crockford.com)
+#
+# 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 shall be used for Good, not Evil.
+#
+# 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.
+
+require 'stringio'
+
+module Smurf
+  class Javascript
+    EOF = -1
+
+    @theA = ""
+    @theB = ""
+
+    def initialize(content)
+      @input = StringIO.new(content)
+      @output = StringIO.new
+      jsmin
+    end
+
+    def minified
+      @output.rewind
+      @output.read
+    end
+
+    # isAlphanum -- return true if the character is a letter, digit, 
+    # underscore, # dollar sign, or non-ASCII character
+    def isAlphanum(c)
+      return false if !c || c == EOF
+      return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+        (c >= 'A' && c <= 'Z') || c == '_' || c == '$' ||
+          c == '\\' || Array(c[0].bytes).first > 126)
+    end
+
+    # get -- return the next character from stdin. Watch out for lookahead. If
+    # the character is a control character, translate it to a space or linefeed.
+    def get()
+      c = @input.getc
+      return EOF if(!c)
+      c = c.chr
+      return c if (c >= " " || c == "\n" || c.unpack("c") == EOF)
+      return "\n" if (c == "\r")
+      return " "
+    end
+
+    # Get the next character without getting it.
+    def peek()
+      lookaheadChar = @input.getc
+      @input.ungetc(lookaheadChar)
+      return lookaheadChar.chr
+    end
+
+    # mynext -- get the next character, excluding comments.
+    # peek() is used to see if a '/' is followed by a '/' or '*'.
+    def mynext()
+      c = get
+      if (c == "/")
+        if(peek == "/")
+          while(true)
+            c = get
+            if (c <= "\n")
+            return c
+            end
+          end
+        end
+        if(peek == "*")
+          get
+          while(true)
+            case get
+            when "*"
+             if (peek == "/")
+                get
+                return " "
+              end
+            when EOF
+              raise "Unterminated comment"
+            end
+          end
+        end
+      end
+      return c
+    end
+
+    # action -- do something! What you do is determined by the argument: 1
+    # Output A. Copy B to A. Get the next B. 2 Copy B to A. Get the next B.
+    # (Delete A). 3 Get the next B. (Delete B). action treats a string as a
+    # single character. Wow! action recognizes a regular expression if it is
+    # preceded by ( or , or =.
+    def action(a)
+      if(a==1)
+        @output.write @theA
+      end
+      if(a==1 || a==2)
+        @theA = @theB
+        if (@theA == "\'" || @theA == "\"")
+          while (true)
+            @output.write @theA
+            @theA = get
+            break if (@theA == @theB)
+            raise "Unterminated string literal" if (@theA <= "\n")
+            if (@theA == "\\")
+              # allow multi-line strings if each line is terminated by \\n (or \\r\n)
+              if ["\r", "\n"].include? peek
+                get # throw away the line ending
+                get if ["\r", "\n"].include? peek
+              else
+                @output.write @theA
+              end
+              @theA = get
+            end
+          end
+        end
+      end
+      if(a==1 || a==2 || a==3)
+        @theB = mynext
+        if (@theB == "/" && (@theA == "(" || @theA == "," || @theA == "=" ||
+                             @theA == ":" || @theA == "[" || @theA == "!" ||
+                             @theA == "&" || @theA == "|" || @theA == "?" ||
+                             @theA == "{" || @theA == "}" || @theA == ";" ||
+                             @theA == "\n"))
+          @output.write @theA
+          @output.write @theB
+          while (true)
+            @theA = get
+            if (@theA == "/")
+              break
+            elsif (@theA == "\\")
+              @output.write @theA
+              @theA = get
+            elsif (@theA <= "\n")
+              raise "Unterminated RegExp Literal"
+            end
+            @output.write @theA
+          end
+          @theB = mynext
+        end
+      end
+    end
+
+    # jsmin -- Copy the input to the output, deleting the characters which are
+    # insignificant to JavaScript. Comments will be removed. Tabs will be
+    # replaced with spaces. Carriage returns will be replaced with linefeeds.
+    # Most spaces and linefeeds will be removed.
+    def jsmin
+      @theA = "\n"
+      action(3)
+      while (@theA != EOF)
+        case @theA
+        when " "
+          if (isAlphanum(@theB))
+            action(1)
+          else
+            action(2)
+          end
+        when "\n"
+          case (@theB)
+          when "{","[","(","+","-"
+            action(1)
+          when " "
+            action(3)
+          else
+            if (isAlphanum(@theB))
+              action(1)
+            else
+              action(2)
+            end
+          end
+        else
+          case (@theB)
+          when " "
+            if (isAlphanum(@theA))
+              action(1)
+            else
+              action(3)
+            end
+          when "\n"
+            case (@theA)
+            when "}","]",")","+","-","\"","\\", "'", '"'
+              action(1)
+            else
+              if (isAlphanum(@theA))
+                action(1)
+              else
+                action(3)
+              end
+            end
+          else
+            action(1)
+          end
+        end
+      end
+    end
+  end # Javascript
+end # Smurf

data/lib/smurf/stylesheet.rb

@@ -0,0 +1,34 @@
+module Smurf
+  class Stylesheet
+    def initialize(content)
+      @content = content.nil? ? nil : minify(content)
+    end
+    
+    def minified; @content; end
+
+    # TODO: deal with string values better (urls, content blocks, etc.)
+    def minify(content)
+      class << content; include Minifier; end
+      content.compress_whitespace.remove_comments.remove_spaces_outside_block.
+        remove_spaces_inside_block.trim_last_semicolon.strip
+    end
+
+    module Minifier
+      # .*? is a non-greedy match on anything
+      def compress_whitespace; compress!(/\s+/, ' '); end
+      def remove_comments; compress!(/\/\*.*?\*\/\s?/, ''); end
+      def remove_spaces_outside_block
+        compress!(/(\A|\})(.*?)\{/) { |m| m.gsub(/\s?([}{,])\s?/, '\1') }
+      end
+      def remove_spaces_inside_block
+        compress!(/\{(.*?)(?=\})/) do |m|
+          # remove spaces in the labels/attributes
+          m.gsub(/(?:\A|\s*;)(.*?)(?::\s*|\z)/) { |n| n.gsub(/\s/, '') }.strip
+        end
+      end
+      def trim_last_semicolon; compress!(/;(?=\})/, ''); end
+    private
+      def compress!(*args, &block) gsub!(*args, &block) || self; end
+    end
+  end # Stylesheet
+end # Smurf

data/rails/init.rb

@@ -0,0 +1 @@
+require 'smurf'

data/test/rails/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/rails/config/boot.rb

@@ -0,0 +1,109 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.1.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/test/rails/config/environment.rb

@@ -0,0 +1,24 @@
+# Be sure to restart your server when you modify this file
+
+# Uncomment below to force Rails into production mode when
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+unless defined? RAILS_GEM_VERSION
+  RAILS_GEM_VERSION = (ENV['RAILS_GEM_VERSION'] || '2.3.2')
+end
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  config.gem 'thoughtbot-shoulda', :lib => 'shoulda/rails',
+    :source => 'http://gems.github.com'
+  config.gem 'sqlite3-ruby', :lib => 'sqlite3'
+
+  config.action_controller.session = {
+    :session_key => '_smurf_session',
+    :secret      => '731d6426b731d6426b731d6426b731d6426b731d6426b731d6426b731d6426b'
+  }
+end

data/test/rails/config/environments/test.rb

@@ -0,0 +1,19 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/test/rails/config/routes.rb

@@ -0,0 +1,5 @@
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/service.wsdl', :action => 'wsdl'
+  map.connect ':controller/:action/:id.:format'
+  map.connect ':controller/:action/:id'
+end

data/test/smurf_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class SmurfTest < Test::Unit::TestCase
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::AssetTagHelper
+
+  # Javascript
+
+  context "when caching on for javascript" do
+    setup do
+      ActionController::Base.stubs(:perform_caching).returns(true)
+      javascript_include_tag('testing.js', :cache => 'cache/actual')
+    end
+
+    should_have_same_contents('javascripts/cache/expected.js',
+      'javascripts/cache/actual.js')
+  end # when caching on for javascript
+
+  context "minifying multi-line strings in javascript" do
+    setup do
+      input = StringIO.new()
+      input.puts("var foo='bar \\")
+      input.puts("  bar \\")
+      input.puts("  baz';")
+      input.rewind
+      @content = input.read
+    end
+
+    should "not affect the string" do
+      expected = "\n" + @content.gsub(/\\?\r?\n/, '')
+      assert_equal expected, Smurf::Javascript.new(@content).minified
+    end
+  end
+
+  # Stylesheet
+
+  context "when caching on for stylesheets" do
+    setup do
+      ActionController::Base.stubs(:perform_caching).returns(true)
+      stylesheet_link_tag('foo', 'bar', :cache => 'cache/actual')
+    end
+
+    should_have_same_contents('stylesheets/cache/expected.css',
+      'stylesheets/cache/actual.css')
+  end # when caching on for stylesheets
+
+  context "minifying a non-existent pattern in a stylesheet" do
+    setup {@himom = "hi{mom:super-awesome}"}
+
+    # Thanks to someone named Niko for finding this
+    should "succeed for removing comments" do
+      actual = "hi {  mom:  super-awesome; } "
+      assert_equal @himom, Smurf::Stylesheet.new(actual).minified
+    end
+
+    should "succeed when no spaces to compress" do
+      actual = @himom
+      assert_equal @himom, Smurf::Stylesheet.new(actual).minified
+    end
+
+    should "succeed when no outside or inside blocks" do
+      # nothing outside, means nothing inside. they are complementary
+      actual = "how-did:  this-happen;  typo: maybe;}"
+      expected = "how-did: this-happen; typo: maybe}"
+      assert_equal expected, Smurf::Stylesheet.new(actual).minified
+    end
+
+    should "succeed when no last semi-colon in block" do
+      actual = "hi {  mom:  super-awesome } "
+      assert_equal @himom, Smurf::Stylesheet.new(actual).minified
+    end
+
+    should "succeed across all parsers when no content provided" do
+      actual = ""
+      assert_equal "", Smurf::Stylesheet.new(actual).minified
+    end
+
+    should "succeed if nil provided" do
+      assert_nil Smurf::Stylesheet.new(nil).minified
+    end
+  end # minifying a non-existent pattern
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+ENV["RAILS_ENV"] = "test"
+ENV["RAILS_ROOT"] = File.expand_path(File.join(File.dirname(__FILE__), 'rails'))
+require File.expand_path(File.join(ENV["RAILS_ROOT"], 'config', 'environment'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'init'))
+
+require 'test_help'
+require 'ruby-debug'
+
+class Test::Unit::TestCase
+
+  def teardown
+    artifacts = Dir.glob(File.join(asset_path, '**', 'cache', 'actual.*'))
+    FileUtils.rm(artifacts)
+  end
+  
+  def self.should_have_same_contents(expected_path, actual_path)
+    should "have the same file contents as #{expected_path}" do
+      expected = read_asset_file(expected_path)
+      actual = read_asset_file(actual_path)
+      assert_equal expected, actual
+    end
+  end
+
+private
+  def asset_path
+    File.join(File.join(ENV["RAILS_ROOT"], 'public'))
+  end
+
+  def read_asset_file(relative_path)
+    File.read(File.join(asset_path, relative_path))
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: perfectline-smurf
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Justin Knowlden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-24 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin to automatically minify JS and CSS when their bundles get cached. Send in those patches!
+email: gus@thumblemonks.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/smurf.rb
+- lib/smurf/javascript.rb
+- lib/smurf/stylesheet.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/thumblemonks/smurf
+post_install_message: 
+rdoc_options: 
+- --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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Rails plugin to automatically minify JS and CSS when their bundles get cached
+test_files: 
+- test/rails/app/controllers/application.rb
+- test/rails/config/boot.rb
+- test/rails/config/environment.rb
+- test/rails/config/environments/test.rb
+- test/rails/config/routes.rb
+- test/smurf_test.rb
+- test/test_helper.rb