smurf 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+MIT License
+--------------------------------------------------------------------------------
+Copyright (c) 2008 Justin Knowlden
+
+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,67 @@
+# 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
+
+### Small suggestion
+
+[bcarpenter](http://github.com/bcarpenter) reminded all of us that Rails will generate real files if you set `config.action_controller.perform_caching` to `true`. If you happen to do this while developing your fantastic Rails app you may also accidentally commit them to your development repository. This is not what you want as it can send you and your awesome developer friends down the wrong rabbit hole ... and then when you figure out the problem you may be understandably and misguidedly pissed at Smurf :)
+
+[bcarpenter](http://github.com/bcarpenter) didn't seem too mad since he reached out to me (whew!) and suggested I add a little comment about making sure to ignore the generated cache files/directories in your SCM of choice. If you happen to be using git, be sure to do something to the effect of the following in your `.gitignore` file:
+
+    public/*/cache/*
+
+## Testing
+
+If you want to test Smurf and you don't want to test with the latest version of Rails, then do something like the following (using 2.2.2 as an example):
+
+    rake RAILS_GEM_VERSION=2.2.2
+
+This is the mechanism I used for testing that Smurf works for all versions:
+
+    rake && rake RAILS_GEM_VERSION=2.2.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,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+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/init.rb

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

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/smurf.gemspec

@@ -0,0 +1,42 @@
+Gem::Specification.new do |s|
+  s.name = "smurf"
+  s.summary = "Rails plugin to automatically minify JS and CSS when their bundles get cached"
+  s.description = "Rails plugin to automatically minify JS and CSS when their bundles get cached. Send in those patches!"
+  s.version = "1.0.0"
+  s.authors = ["Justin Knowlden"]
+  s.email = %w[gus@thumblemonks.com]
+  s.homepage = "http://github.com/thumblemonks/smurf"
+  s.has_rdoc = true
+  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+  s.post_install_message = %q{Choosy Gargamels choose Thumble Monks.}
+
+  s.files = %w[
+    MIT-LICENSE
+    README.markdown
+    Rakefile
+    init.rb
+    install.rb
+    lib/smurf.rb
+    lib/smurf/javascript.rb
+    lib/smurf/stylesheet.rb
+    rails/init.rb
+    smurf.gemspec
+    uninstall.rb
+  ]
+
+  s.test_files = %w[
+    test/rails/app/controllers/application.rb
+    test/rails/config/boot.rb
+    test/rails/config/database.yml
+    test/rails/config/environment.rb
+    test/rails/config/environments/test.rb
+    test/rails/config/routes.rb
+    test/rails/public/javascripts/cache/expected.js
+    test/rails/public/javascripts/testing.js
+    test/rails/public/stylesheets/bar.css
+    test/rails/public/stylesheets/cache/expected.css
+    test/rails/public/stylesheets/foo.css
+    test/smurf_test.rb
+    test/test_helper.rb
+  ]
+end

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/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  dbfile: ":memory:" # db/test.db

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/rails/public/javascripts/cache/expected.js

@@ -0,0 +1,2 @@
+
+function foo(){puts"Hello, world"}

data/test/rails/public/javascripts/testing.js

@@ -0,0 +1,3 @@
+function foo() {
+  puts "Hello, world"
+}

data/test/rails/public/stylesheets/bar.css

@@ -0,0 +1,44 @@
+abbr, acronym {
+  border: 0;
+  font-variant: normal;
+}
+
+sup {
+  vertical-align: text-top;
+}
+/*
+ hello, my name is sam
+*/
+sub {
+  vertical-align: text-bottom;
+}
+
+input, textarea, select{
+  font-family: inherit;
+  font-size: inherit;
+  font-weight: inherit;
+}
+
+input, textarea, select {
+  *font-size: 100%;
+}
+
+legend { color:#000; }
+
+del, ins {
+  text-decoration:none; 
+}
+
+smurf {
+  content: "pa pa";
+}
+
+.smurf :link li {
+  color:blue;
+}
+
+smurf #smurf , :smurf .smurf {
+  color : black;
+}
+
+smurfdom { papa: smurf }

data/test/rails/public/stylesheets/cache/expected.css

@@ -0,0 +1 @@
+html{color:#000;background:#FFF}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0}table{border-collapse:collapse;border-spacing:0}fieldset,img{border:0}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal}li{list-style:none}caption,th{text-align:left}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal}q:before,q:after{content:''}abbr,acronym{border:0;font-variant:normal}sup{vertical-align:text-top}sub{vertical-align:text-bottom}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit}input,textarea,select{*font-size:100%}legend{color:#000}del,ins{text-decoration:none}smurf{content:"pa pa"}.smurf :link li{color:blue}smurf #smurf,:smurf .smurf{color:black}smurfdom{papa:smurf}

data/test/rails/public/stylesheets/foo.css

@@ -0,0 +1,48 @@
+/*
+Copyright (c) 2008, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 2.6.0
+*/
+
+html {
+  color: #000;
+  background: #FFF;
+}
+
+body, div, dl, dt, dd, ul, ol, li, h1, h2, h3, h4, h5, h6, pre, code, form, fieldset, legend, input, textarea, p, blockquote, th, td {
+  margin: 0;
+  padding: 0;
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+fieldset, img {
+  border: 0;
+}
+
+address, caption, cite, code, dfn, em, strong, th, var {
+  font-style: normal;
+  font-weight: normal;
+}
+
+li {
+  list-style: none;
+}
+
+caption, th {
+  text-align: left;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  font-size: 100%;
+  font-weight: normal;
+}
+    
+q:before, q:after {
+  content: '';
+}
+

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,79 @@
+--- !ruby/object:Gem::Specification 
+name: smurf
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Justin Knowlden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-02 00:00:00 -05: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: []
+
+files: 
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- init.rb
+- install.rb
+- lib/smurf.rb
+- lib/smurf/javascript.rb
+- lib/smurf/stylesheet.rb
+- rails/init.rb
+- smurf.gemspec
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/thumblemonks/smurf
+licenses: []
+
+post_install_message: Choosy Gargamels choose Thumble Monks.
+rdoc_options: 
+- --inline-source
+- --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.3.5
+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/database.yml
+- test/rails/config/environment.rb
+- test/rails/config/environments/test.rb
+- test/rails/config/routes.rb
+- test/rails/public/javascripts/cache/expected.js
+- test/rails/public/javascripts/testing.js
+- test/rails/public/stylesheets/bar.css
+- test/rails/public/stylesheets/cache/expected.css
+- test/rails/public/stylesheets/foo.css
+- test/smurf_test.rb
+- test/test_helper.rb