rake-pipeline-web-filters-fork 0.6.0

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

@@ -0,0 +1,59 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compresses JavaScript input files using
+  # the YUI JavaScript compressor.
+  #
+  # Requires {https://rubygems.org/gems/yui-compressor yui-compressor}
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Compress each JS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::YUIJavaScriptFilter
+  #   end
+  class YUIJavaScriptFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to the
+    #   YUI compressor when compressing.
+    attr_reader :options
+
+    # @param [Hash] options options to pass to the YUI
+    #   JavaScript compressor.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.js$/, '.min.js') }
+      super(&block)
+      @options = options
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compresses each input file with
+    # the YUI JavaScript compressor.
+    #
+    # @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)
+      compressor = YUI::JavaScriptCompressor.new(options)
+      inputs.each do |input|
+        output.write compressor.compress(input.read)
+      end
+    end
+
+    private
+
+    def external_dependencies
+      [ 'yui/compressor' ]
+    end
+  end
+end
+

data/rake-pipeline-web-filters.gemspec

@@ -0,0 +1,33 @@
+# -*- 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-fork"
+  gem.require_paths = ["lib"]
+  gem.version       = Rake::Pipeline::Web::Filters::VERSION
+
+  gem.add_dependency "rake-pipeline", "~> 0.6"
+  gem.add_dependency "rack"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "tilt"
+  gem.add_development_dependency "sass"
+  gem.add_development_dependency "compass"
+  gem.add_development_dependency "coffee-script"
+  gem.add_development_dependency "redcarpet", '~> 2.0'
+  gem.add_development_dependency "yui-compressor"
+  gem.add_development_dependency "uglifier"
+  gem.add_development_dependency "less"
+  gem.add_development_dependency "json"
+  gem.add_development_dependency "therubyracer"
+  gem.add_development_dependency "stylus"
+end

data/spec/cache_buster_filter_spec.rb

@@ -0,0 +1,108 @@
+describe "CacheBusterFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+  CacheBusterFilter ||= Rake::Pipeline::Web::Filters::CacheBusterFilter
+
+  let(:content) { "it doesn't matter" }
+
+  let(:input_file) {
+    MemoryFileWrapper.new '/path/to/input', 'file.txt', 'UTF-8', content
+  }
+
+  let(:output_root) {
+    '/path/to/output'
+  }
+
+  def setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [ input_file ]
+    filter.output_root = output_root
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  describe 'DEFAULT_KEY_GENERATOR' do
+
+    subject { CacheBusterFilter::DEFAULT_KEY_GENERATOR }
+
+    it "returns the MD5 hash of the input's file name and contents" do
+      expected = Digest::MD5.new << input_file.path << content
+      subject.call(input_file).should == expected
+    end
+
+  end
+
+  describe 'with the default cache key strategy' do
+
+    let(:output_file) {
+      key = CacheBusterFilter::DEFAULT_KEY_GENERATOR.call(input_file)
+      MemoryFileWrapper.new output_root, "file-#{key}.txt", 'UTF-8'
+    }
+
+    subject { setup_filter CacheBusterFilter.new }
+
+    it 'outputs to the MD5 hash of the file name and contents' do
+      subject.output_files.should == [ output_file ]
+    end
+
+    it 'passes file contents through unchanged' do
+      tasks = subject.generate_rake_tasks
+      tasks.each(&:invoke)
+      file = MemoryFileWrapper.files[ output_file.fullpath ]
+      file.body.should == content
+      file.encoding.should == 'UTF-8'
+    end
+
+  end
+
+  describe 'with a custom key strategy' do
+
+    let(:output_file) {
+      MemoryFileWrapper.new output_root, 'file-foo.txt', 'UTF-8'
+    }
+
+    subject do
+      setup_filter(CacheBusterFilter.new() { 'foo' })
+    end
+
+    it 'uses the custom key strategy' do
+      subject.output_files.should == [ output_file ]
+    end
+
+  end
+
+  describe 'for an input file with multiple dots' do
+    let(:input_file) {
+      MemoryFileWrapper.new '/path/to/input', 'my.text.file.txt', 'UTF-8', content
+    }
+
+    let(:output_file) {
+      MemoryFileWrapper.new output_root, "my.text.file-foo.txt", 'UTF-8'
+    }
+
+    subject { setup_filter(CacheBusterFilter.new() { 'foo' }) }
+
+    it 'appends the busting key to the penultimate part' do
+      subject.output_files.should == [ output_file ]
+    end
+  end
+
+  describe 'for an input file with no dots' do
+    let(:input_file) {
+      MemoryFileWrapper.new '/path/to/input', 'my_text_file', 'UTF-8', content
+    }
+
+    let(:output_file) {
+      MemoryFileWrapper.new output_root, "my_text_file-foo", 'UTF-8'
+    }
+
+    subject { setup_filter(CacheBusterFilter.new() { 'foo' }) }
+
+    it 'appends the busting key to the end of the filename' do
+      subject.output_files.should == [ output_file ]
+    end
+  end
+
+end

data/spec/chained_filter_spec.rb

@@ -0,0 +1,79 @@
+describe "ChainedFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+  ChainedFilter ||= Rake::Pipeline::Web::Filters::ChainedFilter
+
+  input_file1 = MemoryFileWrapper.new("/path", "input.js.strip_asserts.erb", "UTF-8", <<-CONTENT)
+assert("must be true", true);
+Input = {};
+<%= $chained_filter_title %> = {};
+  CONTENT
+
+  input_file2 = MemoryFileWrapper.new("/path", "input.js.erb.strip_asserts", "UTF-8", <<-CONTENT)
+assert("must be true", true);
+Input = {};
+<%= $chained_filter_title %> = {};
+  CONTENT
+
+  EXPECTED_OUTPUT = <<-EXPECTED
+
+Input = {};
+Chained = {};
+  EXPECTED
+
+  let(:erb_filter) do
+    Class.new(Rake::Pipeline::Filter) do
+      def generate_output(inputs, output)
+        inputs.each do |input|
+          output.write ERB.new(input.read).result
+        end
+      end
+    end
+  end
+
+  let(:strip_asserts_filter) do
+    Class.new(Rake::Pipeline::Filter) do
+      def generate_output(inputs, output)
+        inputs.each do |input|
+          output.write input.read.gsub(/^assert.*$/, '')
+        end
+      end
+    end
+  end
+
+  before do
+    $chained_filter_title = "Chained"
+  end
+
+  after do
+    $chained_filter_title = nil
+  end
+
+  [ input_file1, input_file2 ].each do |file_wrapper|
+    it "should run through the filters in order" do
+      filter = ChainedFilter.new(
+        :types => {
+          :erb => erb_filter,
+          :strip_asserts => strip_asserts_filter
+        }
+      )
+
+      filter.file_wrapper_class = MemoryFileWrapper
+      filter.manifest = MemoryManifest.new
+      filter.last_manifest = MemoryManifest.new
+      filter.input_files = [ file_wrapper ]
+      filter.output_root = "/output"
+      filter.rake_application = Rake::Application.new
+
+      filter.output_files.should == [ MemoryFileWrapper.new("/output", "input.js", "UTF-8") ]
+
+      tasks = filter.generate_rake_tasks
+      tasks.each(&:invoke)
+
+      file = MemoryFileWrapper.files["/output/input.js"]
+      file.body.should == EXPECTED_OUTPUT
+      file.encoding.should == "UTF-8"
+    end
+  end
+
+end

data/spec/coffee_script_filter_spec.rb

@@ -0,0 +1,113 @@
+describe "CoffeeScriptFilter" do
+  CoffeeScriptFilter ||= Rake::Pipeline::Web::Filters::CoffeeScriptFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:coffee_input) { <<-COFFEE }
+x = 1;
+
+y = ->
+  x += 1
+  COFFEE
+
+  let(:expected_coffee_output) { <<-HTML }
+(function() {
+  var x, y;
+
+  x = 1;
+
+  y = function() {
+    return x += 1;
+  };
+
+}).call(this);
+  HTML
+
+  let(:expected_unwrapped_coffee_output) { <<-HTML }
+var x, y;
+
+x = 1;
+
+y = function() {
+  return x += 1;
+};
+  HTML
+
+  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 should_match(expected, output)
+    "#{expected}\n".gsub(/\n+/, "\n").should == "#{output}\n".gsub(/\n+/, "\n")
+  end
+
+  def setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [input_file("input.coffee", coffee_input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter CoffeeScriptFilter.new
+
+    filter.output_files.should == [output_file("input.js")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/input.js"]
+    should_match file.body, expected_coffee_output
+    file.encoding.should == "UTF-8"
+  end
+
+  it "generates unwrapped output" do
+    filter = setup_filter CoffeeScriptFilter.new(:no_wrap => true)
+
+    filter.output_files.should == [output_file("input.js")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/input.js"]
+    should_match file.body, expected_unwrapped_coffee_output
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .coffee extensions to .js by default" do
+      filter = setup_filter CoffeeScriptFilter.new
+      filter.output_files.first.path.should == "input.js"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(CoffeeScriptFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+
+  describe "invalid input" do
+    let(:coffee_input) { <<-COFFEE }
+y = function(){
+  return "whoops there javascript in here!"
+}
+    COFFEE
+
+    it "has a useful error message including the input file name" do
+      filter = setup_filter CoffeeScriptFilter.new
+      tasks = filter.generate_rake_tasks
+      lambda {
+        tasks.each(&:invoke)
+      }.should raise_error(ExecJS::RuntimeError, /Error compiling input.coffee.+line 1/i)
+    end
+  end
+
+end
+

data/spec/gzip_filter_spec.rb

@@ -0,0 +1,52 @@
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+describe "GzipFilter" do
+  GzipFilter ||= Rake::Pipeline::Web::Filters::GzipFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:input) { "(function(){console.log('gzip me')})();" }
+
+  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, "BINARY")
+  end
+
+  def setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [input_file("test.js", input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter GzipFilter.new
+    filter.output_files.should == [output_file("test.js.gz")]
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/test.js.gz"]
+    Zlib::GzipReader.new(StringIO.new(file.body)).read.should == input
+  end
+
+  describe "naming output files" do
+    it "translates extensions to .*.gz by default" do
+      filter = setup_filter GzipFilter.new
+      filter.output_files.first.path.should == "test.js.gz"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(GzipFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+
+end
+