rake-pipeline-web-filters 0.5.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+-cfs -r spec_helper.rb

data/.yardopts

@@ -0,0 +1,2 @@
+--readme README.yard
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rake-pipeline-web-filters.gemspec
+gemspec
+
+gem "rake-pipeline", :git => "git://github.com/livingsocial/rake-pipeline.git"

data/README.markdown

@@ -0,0 +1,4 @@
+# Rake::Pipeline::Web::Filters
+
+Documentation for Rake::Pipeline::Web::Filters is hosted at
+<a href="http://rubydoc.info/github/wycats/rake-pipeline-web-filters/master/file/README.yard">rubydoc.info</a>

data/README.yard

@@ -0,0 +1,32 @@
+= Rake::Pipeline::Web::Filters
+
+Rake::Pipeline::Web::Filters is a collection of filters for Rake::Pipeline
+for creating pipelines to generate web content.
+
+= Usage
+
+In your +Assetfile+:
+
+  !!!ruby
+  require "rake-pipeline-web-filters"
+
+  input "assets"
+  output "public"
+
+  # Take all JS inputs and wrap each of them in code to
+  # register them with the Minispade module loader.
+  match "*.js" do
+    filter Rake::Pipeline::Web::Filters::MinispadeFilter
+  end
+
+  # Take all SCSS inputs and compile them with Sass
+  match "*.scss" do
+    filter Rake::Pipeline::Web::Filters::SassCompiler
+  end
+
+= Available Filters
+
+* {Rake::Pipeline::Web::Filters::MinispadeFilter}: Wraps JS code for use with Minispade
+* {Rake::Pipeline::Web::Filters::SassCompiler}: Compiles SCSS or Sass to CSS
+* {Rake::Pipeline::Web::Filters::TiltFilter}: Compiles templates with the Tilt template interface
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/rake-pipeline-web-filters.rb

@@ -0,0 +1,16 @@
+require "rake-pipeline"
+
+module Rake
+  class Pipeline
+    module Web
+      module Filters
+      end
+    end
+  end
+end
+
+require "rake-pipeline-web-filters/version"
+require "rake-pipeline-web-filters/tilt_filter"
+require "rake-pipeline-web-filters/sass_compiler"
+require "rake-pipeline-web-filters/minispade_filter"
+require "rake-pipeline-web-filters/ordering_concat_filter"

data/lib/rake-pipeline-web-filters/helpers.rb

@@ -0,0 +1,50 @@
+module Rake::Pipeline::Web::Filters
+  # Extends the Rake::Pipeline DSL to include shortcuts
+  # for adding filters to the pipeline.
+  #
+  # Instead of:
+  #   !!!ruby
+  #   match("*.scss") do
+  #     filter Rake::Pipeline::Web::Filters::SassCompiler, :syntax => :sass
+  #   end
+  #
+  # You can do:
+  #   !!!ruby
+  #   match("*.scss") do
+  #     sass :syntax => :sass
+  #   end
+  module Helpers
+    # If the first argument is an Array, add a new {OrderingConcatFilter}
+    # to the pipeline. Otherwise add a new {Rake::Pipeline::ConcatFilter}.
+    # @see OrderingConcatFilter#initialize
+    # @see Rake::Pipeline::ConcatFilter#initialize
+    def concat(*args, &block)
+      if args.first.kind_of?(Array)
+        filter(Rake::Pipeline::Web::Filters::OrderingConcatFilter, *args, &block)
+      else
+        filter(Rake::Pipeline::ConcatFilter, *args, &block)
+      end
+    end
+
+    # Add a new {MinispadeFilter} to the pipeline.
+    # @see MinispadeFilter#initialize
+    def minispade(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::MinispadeFilter, *args, &block)
+    end
+
+    # Add a new {SassCompiler} to the pipeline.
+    # @see SassCompiler#initialize
+    def sass(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::SassCompiler, *args, &block)
+    end
+    alias_method :scss, :sass
+
+    # Add a new {TiltFilter} to the pipeline.
+    # @see TiltFilter#initialize
+    def tilt(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::TiltFilter, *args, &block)
+    end
+  end
+end
+
+Rake::Pipeline::DSL.send(:include, Rake::Pipeline::Web::Filters::Helpers)

data/lib/rake-pipeline-web-filters/minispade_filter.rb

@@ -0,0 +1,47 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that wraps JavaScript files in a minispade.register closure
+  # for use in minispade.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Wrap each JS file in a minispade.register closure.
+  #     filter Rake::Pipeleine::Web::Filters::MinispadeFilter
+  #   end
+  class MinispadeFilter < Rake::Pipeline::Filter
+
+    # @param [Hash] options
+    # @option options [Boolean] :use_strict Whether to add "use strict" to
+    #   each outputted function; defaults to false.
+    # @option options [Proc] :module_id_generator a proc to use to generate
+    #   the minispade module id.
+    def initialize(options = {})
+      super()
+      @use_strict = !!options[:use_strict]
+      @module_id_generator = options[:module_id_generator] ||
+        proc { |input| input.fullpath.sub(Dir.pwd, '') }
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Wraps each input file in a minispade.register
+    # closure.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        code = input.read
+        code = '"use strict"; ' + code if @use_strict
+        function = "function() { #{code} }"
+        ret = "minispade.register('#{@module_id_generator.call(input)}',#{function});"
+        output.write ret
+      end
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/ordering_concat_filter.rb

@@ -0,0 +1,38 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that concats files in a specified order
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Concat each file into libs.js but make sure
+  #     # that jQuery and SproutCore come first
+  #     filter Rake::Pipeline::Web::Filters::OrderingConcatFilter, ["jquery.js", "sproutcore.js"], "libs.js"
+  #   end
+  class OrderingConcatFilter < Rake::Pipeline::ConcatFilter
+
+    # @param [Array<String>] ordering an Array of Strings
+    #   of file names that should come in the specified order
+    # @param [String] string the name of the output file to
+    #   concatenate inputs to.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(ordering, string=nil, &block)
+      @ordering = ordering
+      super(string, &block)
+    end
+
+    # Extend the {#generate_output} method supplied by {ConcatFilter}.
+    # Re-orders the inputs such that the specified files come first.
+    # If a file is not in the list it will come after the specified files.
+    def generate_output(inputs, output)
+      @ordering.reverse.each do |name|
+        file = inputs.find{|i| i.path == name }
+        inputs.unshift(inputs.delete(file)) if file
+      end
+      super
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/sass_compiler.rb

@@ -0,0 +1,53 @@
+require 'sass'
+require 'compass'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles input files written in SCSS
+  # to CSS using the Sass compiler and the Compass CSS
+  # framework.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.scss"
+  #     output "public"
+  #
+  #     # Compile each SCSS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::SassCompiler
+  #   end
+  class SassCompiler < Rake::Pipeline::Filter
+    # @return [Hash] a hash of options to pass to Sass
+    #   when compiling.
+    attr_reader :options
+
+    # @param [Hash] options options to pass to the Sass
+    #   compiler
+    # @option options [Array] :additional_load_paths a
+    #   list of paths to append to Sass's :load_path.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.(scss|sass)$/, '.css') }
+      super(&block)
+      Compass.add_project_configuration
+      @options = Compass.configuration.to_sass_engine_options
+      @options[:load_paths].concat(Array(options.delete(:additional_load_paths)))
+      @options.merge!(options)
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compiles each input file with Sass.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write Sass.compile(input.read, options)
+      end
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/tilt_filter.rb

@@ -0,0 +1,57 @@
+require 'tilt'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that accepts a series of inputs and translates
+  # them using the Tilt template interface, which will attempt
+  # to guess which template language to use based on the input
+  # file extension.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.scss"
+  #     output "public"
+  #
+  #     # Compile each SCSS file using Tilt, replacing the
+  #     # scss extension with css.
+  #     filter(Rake::Pipeline::Web::Filters::TiltFilter) do |input|
+  #       input.sub(/\.scss$/, 'css')
+  #     end
+  #   end
+  class TiltFilter < Rake::Pipeline::Filter
+    # @return [Hash] a hash of options to pass to Tilt
+    #   when rendering.
+    attr_reader :options
+
+    # @param [Hash] options options to pass to the Tilt
+    #   template class constructor.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      super(&block)
+      @options = options
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Attempts to compile each input file
+    # with Tilt, passing the file through unchanged if Tilt
+    # can't find a template class for the file.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        out = if (template_class = Tilt[input.path])
+          template_class.new(nil, 1, options) { |t| input.read }.render
+        else
+          input.read
+        end
+
+        output.write out
+      end
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/version.rb

@@ -0,0 +1,9 @@
+module Rake
+  class Pipeline
+    module Web
+      module Filters
+        VERSION = "0.5.0"
+      end
+    end
+  end
+end

data/rake-pipeline-web-filters.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rake-pipeline-web-filters/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yehuda Katz"]
+  gem.email         = ["wycats@gmail.com"]
+  gem.description   = %q{A collection of web filters for rake-pipeline}
+  gem.summary       = %q{Contributed filters for use in rake-pipeline that are useful for web projects, like asset management}
+  gem.homepage      = "http://github.com/wycats/rake-pipeline-web-filters"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "rake-pipeline-web-filters"
+  gem.require_paths = ["lib"]
+  gem.version       = Rake::Pipeline::Web::Filters::VERSION
+
+  gem.add_dependency "rake-pipeline"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "tilt"
+  gem.add_development_dependency "sass"
+  gem.add_development_dependency "compass"
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,50 @@
+require "rake-pipeline-web-filters/helpers"
+
+describe "Helpers" do
+
+  let(:pipeline) { Rake::Pipeline.new }
+  let(:dsl) { Rake::Pipeline::DSL.new(pipeline) }
+
+  before do
+    pipeline.input_root = "."
+  end
+
+  def filter
+    pipeline.filters.last
+  end
+
+  describe "#concat" do
+    it "creates a ConcatFilter" do
+      dsl.concat "octopus"
+      filter.should be_kind_of(Rake::Pipeline::ConcatFilter)
+   end
+
+    context "passed an Array first argument" do
+      it "creates an OrderingConcatFilter" do
+        dsl.concat ["octopus"]
+        filter.should be_kind_of(Rake::Pipeline::Web::Filters::OrderingConcatFilter)
+     end
+    end
+  end
+
+  describe "#minispade" do
+    it "creates a MinispadeFilter" do
+      dsl.minispade
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::MinispadeFilter)
+    end
+  end
+
+  describe "#sass" do
+    it "creates a SassCompiler" do
+      dsl.sass
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::SassCompiler)
+    end
+  end
+
+  describe "#tilt" do
+    it "creates a TiltFilter" do
+      dsl.tilt
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::TiltFilter)
+    end
+  end
+end

data/spec/minispade_filter_spec.rb

@@ -0,0 +1,47 @@
+describe "MinispadeFilter" do
+  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "foo.js", "UTF-8", "var foo = 'bar';")
+    ]
+  }
+
+  let(:output_files) {
+    [
+      MemoryFileWrapper.new("/path/to/output", "foo.js", "UTF-8")
+    ]
+  }
+
+  let(:output_file) {
+    MemoryFileWrapper.files["/path/to/output/foo.js"]
+  }
+
+  def make_filter(*args)
+    filter = Rake::Pipeline::Web::Filters::MinispadeFilter.new(*args)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = input_files
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter.generate_rake_tasks.each(&:invoke)
+    filter
+  end
+
+  it "generates output" do
+    filter = make_filter
+
+    filter.output_files.should == output_files
+    output_file.body.should == "minispade.register('/path/to/input/foo.js',function() { var foo = 'bar'; });"
+    output_file.encoding.should == "UTF-8"
+  end
+
+  it "uses strict if asked" do
+    filter = make_filter(:use_strict => true)
+    output_file.body.should == "minispade.register('/path/to/input/foo.js',function() { \"use strict\"; var foo = 'bar'; });"
+  end
+
+  it "takes a proc to name the module" do
+    filter = make_filter(:module_id_generator => proc { |input| "octopus" })
+    output_file.body.should == "minispade.register('octopus',function() { var foo = 'bar'; });"
+  end
+end

data/spec/ordering_concat_filter_spec.rb

@@ -0,0 +1,39 @@
+describe "OrderingConcatFilter" do
+  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "first.txt", "UTF-8", "FIRST"),
+      MemoryFileWrapper.new("/path/to/input", "second.txt", "UTF-8", "SECOND"),
+      MemoryFileWrapper.new("/path/to/input", "last.txt", "UTF-8", "LAST")
+    ]
+  }
+
+  let(:output_files) {
+    [
+      MemoryFileWrapper.new("/path/to/output", "all.txt", "BINARY")
+    ]
+  }
+
+  let(:output_file) {
+    MemoryFileWrapper.files["/path/to/output/all.txt"]
+  }
+
+  def make_filter(ordering)
+    filter = Rake::Pipeline::Web::Filters::OrderingConcatFilter.new(ordering, "all.txt")
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = input_files
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter.generate_rake_tasks.each(&:invoke)
+    filter
+  end
+
+  it "generates output" do
+    filter = make_filter(["first.txt", "second.txt"])
+
+    filter.output_files.should == output_files
+    output_file.body.should == "FIRSTSECONDLAST"
+    output_file.encoding.should == "BINARY"
+  end
+end

data/spec/sass_compiler_spec.rb

@@ -0,0 +1,89 @@
+describe "SassCompiler" do
+  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  SassCompiler = Rake::Pipeline::Web::Filters::SassCompiler
+
+  SCSS_INPUT = <<-SCSS
+$blue: #3bbfce;
+
+.border {
+  border-color: $blue;
+}
+SCSS
+
+  SASS_INPUT = <<-SASS
+$blue: #3bbfce
+
+.border
+  border-color: $blue
+SASS
+
+  EXPECTED_CSS_OUTPUT = <<-CSS
+/* line 3 */
+.border {
+  border-color: #3bbfce;
+}
+CSS
+
+  def input_file(name, content)
+    MemoryFileWrapper.new("/path/to/input", name, "UTF-8", content)
+  end
+
+  def output_file(name)
+    MemoryFileWrapper.new("/path/to/output", name, "UTF-8")
+  end
+
+  def setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = [input_file("border.scss", SCSS_INPUT)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter SassCompiler.new
+
+    filter.output_files.should == [output_file("border.css")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/border.css"]
+    file.body.should == EXPECTED_CSS_OUTPUT
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .scss extensions to .css by default" do
+      filter = setup_filter SassCompiler.new
+      filter.output_files.first.path.should == "border.css"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(SassCompiler.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+
+  it "accepts options to pass to the Sass compiler" do
+    filter = setup_filter(SassCompiler.new(:syntax => :sass))
+    filter.input_files = [input_file("border.sass", SASS_INPUT)]
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/border.css"]
+    file.body.should == EXPECTED_CSS_OUTPUT
+  end
+
+  it "passes Compass's options to the Sass compiler" do
+    Compass.configuration do |c|
+      c.preferred_syntax = :sass
+    end
+
+    filter = setup_filter(SassCompiler.new)
+    filter.input_files = [input_file("border.css", SCSS_INPUT)]
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/border.css"]
+    file.body.should == EXPECTED_CSS_OUTPUT
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,95 @@
+require "rake-pipeline"
+require "rake-pipeline-web-filters"
+
+class Rake::Pipeline
+  module SpecHelpers
+
+    class MemoryFileWrapper < Struct.new(:root, :path, :encoding, :body)
+      @@files = {}
+
+      def self.files
+        @@files
+      end
+
+      def with_encoding(new_encoding)
+        self.class.new(root, path, new_encoding, body)
+      end
+
+      def fullpath
+        File.join(root, path)
+      end
+
+      def create
+        @@files[fullpath] = self
+        self.body = ""
+        yield
+      end
+
+      alias read body
+
+      def write(contents)
+        self.body << contents
+      end
+    end
+
+    # TODO: OS agnostic modules
+    module FileUtils
+      def mkdir_p(dir)
+        system "mkdir", "-p", dir
+      end
+
+      def touch(file)
+        system "touch", file
+      end
+
+      def rm_rf(dir)
+        system "rm", "-rf", dir
+      end
+
+      def touch_p(file)
+        dir = File.dirname(file)
+        mkdir_p dir
+        touch file
+      end
+
+      def age_existing_files
+        old_time = Time.now - 10
+        Dir[File.join(tmp, "**/*.js")].each do |file|
+          File.utime(old_time, old_time, file)
+        end
+      end
+    end
+
+    module Filters
+      ConcatFilter = Rake::Pipeline::ConcatFilter
+
+      class StripAssertsFilter < Rake::Pipeline::Filter
+        def generate_output(inputs, output)
+          inputs.each do |input|
+            output.write input.read.gsub(%r{^\s*assert\(.*\)\s*;?\s*$}m, '')
+          end
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  original = Dir.pwd
+
+  config.include Rake::Pipeline::SpecHelpers::FileUtils
+
+  def tmp
+    File.expand_path("../tmp", __FILE__)
+  end
+
+  config.before do
+    rm_rf(tmp)
+    mkdir_p(tmp)
+    Dir.chdir(tmp)
+  end
+
+  config.after do
+    Dir.chdir(original)
+  end
+end

data/spec/tilt_filter_spec.rb

@@ -0,0 +1,55 @@
+describe "TiltFilter" do
+  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "foo.erb", "UTF-8", "<%= 'foo' %>\n"),
+      MemoryFileWrapper.new("/path/to/input", "bar.str", "UTF-8", '#{ "bar" }')
+    ]
+  }
+
+  let(:output_files) {
+    [
+      MemoryFileWrapper.new("/path/to/output", "foo.txt", "UTF-8"),
+      MemoryFileWrapper.new("/path/to/output", "bar.txt", "UTF-8")
+    ]
+  }
+
+  def make_filter(*args)
+    filter = Rake::Pipeline::Web::Filters::TiltFilter.new(*args) do |input|
+      input.sub(/\.(erb|str)$/, '.txt')
+    end
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = input_files
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = make_filter
+
+    filter.output_files.should == output_files
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/foo.txt"]
+    file.body.should == "foo"
+    file.encoding.should == "UTF-8"
+
+    file = MemoryFileWrapper.files["/path/to/output/bar.txt"]
+    file.body.should == "bar"
+    file.encoding.should == "UTF-8"
+  end
+
+  it "accepts options to pass to the template class" do
+    # :trim => '' should tell ERB not to trim newlines
+    filter = make_filter(:trim => '')
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/foo.txt"]
+    file.body.should == "foo\n"
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: rake-pipeline-web-filters
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Yehuda Katz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-pipeline
+  requirement: &70215098662080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70215098662080
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70215098661660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70215098661660
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: &70215098661240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70215098661240
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: &70215094750840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70215094750840
+- !ruby/object:Gem::Dependency
+  name: compass
+  requirement: &70215094748140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70215094748140
+description: A collection of web filters for rake-pipeline
+email:
+- wycats@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .yardopts
+- Gemfile
+- README.markdown
+- README.yard
+- Rakefile
+- lib/rake-pipeline-web-filters.rb
+- lib/rake-pipeline-web-filters/helpers.rb
+- lib/rake-pipeline-web-filters/minispade_filter.rb
+- lib/rake-pipeline-web-filters/ordering_concat_filter.rb
+- lib/rake-pipeline-web-filters/sass_compiler.rb
+- lib/rake-pipeline-web-filters/tilt_filter.rb
+- lib/rake-pipeline-web-filters/version.rb
+- rake-pipeline-web-filters.gemspec
+- spec/helpers_spec.rb
+- spec/minispade_filter_spec.rb
+- spec/ordering_concat_filter_spec.rb
+- spec/sass_compiler_spec.rb
+- spec/spec_helper.rb
+- spec/tilt_filter_spec.rb
+homepage: http://github.com/wycats/rake-pipeline-web-filters
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Contributed filters for use in rake-pipeline that are useful for web projects,
+  like asset management
+test_files:
+- spec/helpers_spec.rb
+- spec/minispade_filter_spec.rb
+- spec/ordering_concat_filter_spec.rb
+- spec/sass_compiler_spec.rb
+- spec/spec_helper.rb
+- spec/tilt_filter_spec.rb