rake-pipeline-web-filters 0.5.0 → 0.7.0

data/spec/coffee_script_filter_spec.rb

@@ -0,0 +1,110 @@
+describe "CoffeeScriptFilter" do
+  CoffeeScriptFilter ||= Rake::Pipeline::Web::Filters::CoffeeScriptFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  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.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,49 @@
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+describe "GzipFilter" do
+  GzipFilter ||= Rake::Pipeline::Web::Filters::GzipFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  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.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
+

data/spec/handlebars_filter_spec.rb

@@ -0,0 +1,70 @@
+describe "HandlebarsFilter" do
+  HandlebarsFilter ||= Rake::Pipeline::Web::Filters::HandlebarsFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:handlebars_input) {
+    '<h1 class="title">{{title}}</h1>'
+  }
+
+  let(:expected_output) {
+    "Ember.TEMPLATES['test']=Ember.Handlebars.compile(\"<h1 class=\\\"title\\\">{{title}}</h1>\");"
+  }
+
+  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, input_filename = "test.handlebars")
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = [input_file(input_filename, handlebars_input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter HandlebarsFilter.new
+
+    filter.output_files.should == [output_file("test.js")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/test.js"]
+    file.body.should == expected_output
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .handlebars extensions to .js by default" do
+      filter = setup_filter HandlebarsFilter.new, "test.handlebars"
+      filter.output_files.first.path.should == "test.js"
+    end
+
+    it "translates .hbs extensions to .js by default" do
+      filter = setup_filter HandlebarsFilter.new, "test.hbs"
+      filter.output_files.first.path.should == "test.js"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(HandlebarsFilter.new { |input| "squid" })
+      filter.output_files.first.path.should == "squid"
+    end
+  end
+
+  describe "options" do
+    it "should allow an option to name the key" do
+      filter = setup_filter(HandlebarsFilter.new(:key_name_proc => proc { |input| "new_name_key" }))
+        
+      tasks = filter.generate_rake_tasks
+      tasks.each(&:invoke)
+
+      file = MemoryFileWrapper.files["/path/to/output/test.js"]
+      file.body.should =~ /^Ember\.TEMPLATES\['new_name_key'\]/
+    end
+  end
+end

data/spec/helpers_spec.rb

@@ -1,32 +1,17 @@
 require "rake-pipeline-web-filters/helpers"
 
 describe "Helpers" do
-
   let(:pipeline) { Rake::Pipeline.new }
-  let(:dsl) { Rake::Pipeline::DSL.new(pipeline) }
+  let(:dsl) { Rake::Pipeline::DSL::PipelineDSL.new(pipeline) }
 
   before do
-    pipeline.input_root = "."
+    pipeline.add_input '.'
   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
@@ -37,7 +22,14 @@ describe "Helpers" do
   describe "#sass" do
     it "creates a SassCompiler" do
       dsl.sass
-      filter.should be_kind_of(Rake::Pipeline::Web::Filters::SassCompiler)
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::SassFilter)
+    end
+  end
+  
+  describe "#stylus" do
+    it "creates a StylusCompiler" do
+      dsl.stylus
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::StylusFilter)
     end
   end
 
@@ -47,4 +39,106 @@ describe "Helpers" do
       filter.should be_kind_of(Rake::Pipeline::Web::Filters::TiltFilter)
     end
   end
+
+  describe "#markdown" do
+    it "creates a MarkdownCompiler" do
+      dsl.markdown
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::MarkdownFilter)
+    end
+  end
+
+  describe "#cache_buster" do
+    it "creates a CacheBuster" do
+      dsl.cache_buster
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::CacheBusterFilter)
+    end
+  end
+
+  describe "#coffee_script" do
+    it "creates a CoffeeScriptCompiler" do
+      dsl.coffee_script
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::CoffeeScriptFilter)
+    end
+  end
+
+  describe "#yui_javascript" do
+    it "creates a YUIJavaScriptCompressor" do
+      dsl.yui_javascript
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::YUIJavaScriptFilter)
+    end
+  end
+
+  describe "#yui_css" do
+    it "creates a YUICssCompressor" do
+      dsl.yui_css
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::YUICssFilter)
+    end
+  end
+
+  describe "#uglify" do
+    it "creates an UglifyFilter" do
+      dsl.uglify
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::UglifyFilter)
+    end
+  end
+
+  describe "#less" do
+    it "creates a LessFilter" do
+      dsl.less
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::LessFilter)
+    end
+  end
+
+  describe "#gzip" do
+    it "creates a GzipFilter" do
+      dsl.gzip
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::GzipFilter)
+    end
+  end
+
+  describe "#handlebars" do
+    it "creates a HandlebarsFilter" do
+      dsl.handlebars
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::HandlebarsFilter)
+    end
+  end
+
+  describe "#iffe" do
+    it "creates a IifeFilter" do
+      dsl.iife
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::IifeFilter)
+    end
+  end
+end
+
+describe "ProjectHelpers" do
+  def project
+    @project ||= Rake::Pipeline::Project.new
+  end
+
+  def dsl
+    @dsl ||= Rake::Pipeline::DSL::ProjectDSL.new(project)
+  end
+
+  describe "register" do
+    it "registers filters per file name" do
+      dsl.register :coffee, Rake::Pipeline::Web::Filters::CoffeeScriptFilter
+      dsl.register :handlebars, Rake::Pipeline::Web::Filters::HandlebarsFilter
+
+      dsl.input "lib" do
+        concat "lib.js"
+      end
+
+      dsl.input "tests" do
+        concat "tests.js"
+      end
+
+      project.pipelines.size.should == 2
+
+      project.pipelines.each do |pipeline|
+        pipeline.filters.first.should be_kind_of Rake::Pipeline::Web::Filters::ChainedFilter
+        pipeline.filters.first.filters.keys.should == [:coffee, :handlebars]
+      end
+    end
+  end
 end

data/spec/iife_filter_spec.rb

@@ -0,0 +1,55 @@
+describe "IifeFilter" do
+  IifeFilter ||= Rake::Pipeline::Web::Filters::IifeFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:js_input) { <<-HERE }
+var name = "Truckasaurus Gates";
+HERE
+
+  let(:expected_js_output) { <<-HERE }
+(function() {
+var name = "Truckasaurus Gates";
+})();
+HERE
+
+  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("name.js", js_input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter IifeFilter.new
+
+    filter.output_files.should == [output_file("name.js")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/name.js"]
+    file.body.should == expected_js_output.chomp
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .js extensions to .min.js by default" do
+      filter = setup_filter IifeFilter.new
+      filter.output_files.first.path.should == "name.js"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(IifeFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+end

data/spec/less_filter_spec.rb

@@ -0,0 +1,59 @@
+describe "LessFilter" do
+  LessFilter ||= Rake::Pipeline::Web::Filters::LessFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:less_input) { <<-SCSS }
+@blue: #3bbfce;
+
+.border {
+  border-color: @blue;
+}
+SCSS
+
+  let(:expected_css_output) { <<-CSS }
+.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.less", less_input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter LessFilter.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 .less extensions to .css by default" do
+      filter = setup_filter LessFilter.new
+      filter.output_files.first.path.should == "border.css"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(LessFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+end