rake-pipeline-web-filters-fork 0.6.0

data/spec/handlebars_filter_spec.rb

@@ -0,0 +1,73 @@
+describe "HandlebarsFilter" do
+  HandlebarsFilter ||= Rake::Pipeline::Web::Filters::HandlebarsFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  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.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    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

@@ -0,0 +1,146 @@
+require "rake-pipeline-web-filters/helpers"
+
+describe "Helpers" do
+  let(:pipeline) { Rake::Pipeline.new }
+  let(:dsl) { Rake::Pipeline::DSL::PipelineDSL.new(pipeline) }
+
+  before do
+    pipeline.add_input '.'
+  end
+
+  def filter
+    pipeline.filters.last
+  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::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
+
+  describe "#jade" do
+    it "creates a JadeCompiler" do
+      dsl.jade
+      filter.should be_kind_of(Rake::Pipeline::Web::Filters::JadeFilter)
+    end
+  end
+
+  describe "#tilt" do
+    it "creates a TiltFilter" do
+      dsl.tilt
+      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
+  let(:project) { Rake::Pipeline::Project.new }
+  let(:dsl) { Rake::Pipeline::DSL::ProjectDSL.new(project) }
+
+  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,58 @@
+describe "IifeFilter" do
+  IifeFilter ||= Rake::Pipeline::Web::Filters::IifeFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  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.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    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/jade_filter_spec.rb

@@ -0,0 +1,92 @@
+describe "JadeFilter" do
+  JadeFilter ||= Rake::Pipeline::Web::Filters::JadeFilter
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:jade_input) {
+    """
+!!! 5
+html
+  head
+    title Hello
+  body
+    h1 Hello
+"""
+  }
+
+  let(:expected_html_output) {
+    """<!DOCTYPE html><html><head><title>Hello</title></head><body><h1>Hello</h1></body></html>"""
+  }
+
+  let(:expected_prettified_html_output) {
+    """\
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Hello</title>
+  </head>
+  <body>
+    <h1>Hello</h1>
+  </body>
+</html>"""
+  }
+
+  let(:input_root) { File.expand_path('./input') }
+  let(:input_path) { 'index.jade' }
+
+  let(:input_file) {
+    mkdir_p input_root
+    File.open(File.join(input_root, input_path), 'w+:UTF-8') {|file| file << jade_input }
+    Rake::Pipeline::FileWrapper.new(input_root, input_path, "UTF-8")
+  }
+
+  let(:output_root) { File.expand_path('./output') }
+  let(:output_path) { 'index.html' }
+
+  let(:output_file) {
+    Rake::Pipeline::FileWrapper.new(output_root, output_path, "UTF-8")
+  }
+
+  def setup_filter(filter, input=jade_input)
+    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
+
+  it "generates output" do
+    filter = setup_filter JadeFilter.new
+    filter.output_files.should == [output_file]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    output_file.read.should == expected_html_output
+    output_file.encoding.should == "UTF-8"
+  end
+
+  it "prettifies output" do
+    filter = setup_filter JadeFilter.new :pretty => true
+
+    filter.output_files.should == [output_file]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    output_file.read.should == expected_prettified_html_output
+    output_file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .jade extensions to .html by default" do
+      filter = setup_filter JadeFilter.new
+      filter.output_files.first.path.should == "index.html"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(JadeFilter.new { |input| "hbs" })
+      filter.output_files.first.path.should == "hbs"
+    end
+  end
+end

data/spec/less_filter_spec.rb

@@ -0,0 +1,62 @@
+describe "LessFilter" do
+  LessFilter ||= Rake::Pipeline::Web::Filters::LessFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  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.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    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

data/spec/markdown_filter_spec.rb

@@ -0,0 +1,89 @@
+describe "MarkdownFilter" do
+  MarkdownFilter ||= Rake::Pipeline::Web::Filters::MarkdownFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:markdown_input) { <<-MARKDOWN }
+## This is an H2
+
+Some *important* text. It might have a link: http://foo.com/
+
+    Some code
+
+That's all.
+MARKDOWN
+
+  let(:expected_html_output) { <<-HTML }
+<h2>This is an H2</h2>
+
+<p>Some <em>important</em> text. It might have a link: http://foo.com/</p>
+
+<pre><code>Some code
+</code></pre>
+
+<p>That&#39;s all.</p>
+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 setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [input_file("page.md", markdown_input)]
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates output" do
+    filter = setup_filter MarkdownFilter.new
+
+    filter.output_files.should == [output_file("page.html")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/page.html"]
+    file.body.should == expected_html_output
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .md extensions to .html by default" do
+      filter = setup_filter MarkdownFilter.new
+      filter.output_files.first.path.should == "page.html"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(MarkdownFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+
+  it "passes options to the Markdown compiler" do
+    filter = setup_filter(MarkdownFilter.new(:autolink => true))
+    filter.input_files = [input_file("page.md", markdown_input)]
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/page.html"]
+    file.body.should =~ %r{<a href="http://foo\.com/">}
+  end
+
+  it "accepts a :compiler option" do
+    filter = setup_filter(MarkdownFilter.new(:compiler => proc { |text, options| text }))
+    filter.input_files = [input_file("page.md", markdown_input)]
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/page.html"]
+    file.body.should == markdown_input
+  end
+
+end
+