rake-pipeline-web-filters 0.5.0 → 0.7.0

data/spec/markdown_filter_spec.rb

@@ -0,0 +1,86 @@
+describe "MarkdownFilter" do
+  MarkdownFilter ||= Rake::Pipeline::Web::Filters::MarkdownFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  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.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
+

data/spec/minispade_filter_spec.rb

@@ -1,11 +1,11 @@
+require "json"
+
 describe "MinispadeFilter" do
-  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
 
-  let(:input_files) {
-    [
-      MemoryFileWrapper.new("/path/to/input", "foo.js", "UTF-8", "var foo = 'bar';")
-    ]
-  }
+  def input_file(contents="var foo = 'bar'; // last-line comment", path="/path/to/input", name="foo.js")
+    MemoryFileWrapper.new(path, name, "UTF-8", contents)
+  end
 
   let(:output_files) {
     [
@@ -17,10 +17,10 @@ describe "MinispadeFilter" do
     MemoryFileWrapper.files["/path/to/output/foo.js"]
   }
 
-  def make_filter(*args)
+  def make_filter(input_file, *args)
     filter = Rake::Pipeline::Web::Filters::MinispadeFilter.new(*args)
     filter.file_wrapper_class = MemoryFileWrapper
-    filter.input_files = input_files
+    filter.input_files = [input_file]
     filter.output_root = "/path/to/output"
     filter.rake_application = Rake::Application.new
     filter.generate_rake_tasks.each(&:invoke)
@@ -28,20 +28,52 @@ describe "MinispadeFilter" do
   end
 
   it "generates output" do
-    filter = make_filter
-
+    filter = make_filter(input_file)
     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"
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {var foo = 'bar'; // last-line comment\n});"
   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'; });"
+    filter = make_filter(input_file, :use_strict => true)
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {\"use strict\";\nvar foo = 'bar'; // last-line comment\n});"
+  end
+
+  it "compiles a string if asked" do
+    filter = make_filter(input_file, :string => true)
+    output_file.body.should ==
+      %{minispade.register('/path/to/input/foo.js', "(function() {var foo = 'bar'; // last-line comment\\n})();\\n//@ sourceURL=/path/to/input/foo.js");}
   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'; });"
+    filter = make_filter(input_file, :module_id_generator => proc { |input| "octopus" })
+    output_file.body.should ==
+      "minispade.register('octopus', function() {var foo = 'bar'; // last-line comment\n});"
+  end
+
+  it "rewrites requires if asked" do
+    filter = make_filter(input_file("require('octopus');"), :rewrite_requires => true)
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {minispade.require('octopus');\n});"
+  end
+
+  it "rewrites requires if asked even spaces wrap tokens in the require statement" do
+    filter = make_filter(input_file("require    ( 'octopus');"), :rewrite_requires => true)
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {minispade.require('octopus');\n});"
+  end
+  
+  it "rewrites requireAll if asked" do
+    filter = make_filter(input_file("requireAll('octopus');"), :rewrite_requires => true)
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {minispade.requireAll('octopus');\n});"
+  end
+
+  it "rewrites requireAll if asked even spaces wrap tokens in the require statement" do
+    filter = make_filter(input_file("requireAll    ( 'octopus');"), :rewrite_requires => true)
+    output_file.body.should ==
+      "minispade.register('/path/to/input/foo.js', function() {minispade.requireAll('octopus');\n});"
   end
 end

data/spec/neuter_filter_spec.rb

@@ -0,0 +1,204 @@
+require 'stringio'
+
+describe "NeuterFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  def make_input(name, data)
+    make_data(name, data)
+    MemoryFileWrapper.new("/path/to/input", name, "UTF-8")
+  end
+
+  def make_data(name, data)
+    MemoryFileWrapper.data["/path/to/input/#{name}"] = data
+  end
+
+  def make_filter(input_files, *args)
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    opts[:additional_dependencies] ||= proc{|input| %w(b c) }
+    args.push(opts)
+
+    filter = Rake::Pipeline::Web::Filters::NeuterFilter.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
+
+  def make_filter_with_inputs(inputs, options={})
+    input_file = make_input(inputs[0][0], inputs[0][1])
+    inputs[1..-1].each{|input| make_data(input[0], input[1]) }
+    make_filter([input_file], "processed", options)
+  end
+
+  def capture(*streams)
+    streams.map! { |stream| stream.to_s }
+    begin
+      result = StringIO.new
+      streams.each { |stream| eval "$#{stream} = result" }
+      yield
+    ensure
+      streams.each { |stream| eval("$#{stream} = #{stream.upcase}") }
+    end
+    result.string
+  end
+
+  after(:each) do
+    MemoryFileWrapper.data.clear
+  end
+
+  let(:output_files) {
+    [
+      MemoryFileWrapper.new("/path/to/output", "processed", "BINARY")
+    ]
+  }
+
+  let(:output_file) {
+    MemoryFileWrapper.files["/path/to/output/processed"]
+  }
+
+  it "generates basic output" do
+    input_file = make_input("contents", "data")
+    filter = make_filter([input_file], "processed")
+
+    filter.output_files.should == output_files
+    # ConcatFilter forces Binary, not sure if this is right in this case
+    output_file.encoding.should == "BINARY"
+    output_file.body.should == "data"
+  end
+
+  it "orders required files" do
+    make_filter_with_inputs([
+      ["a", "require('b');\nA"],
+      ["b", "require('c');\nB"],
+      ["c", "C"]
+    ])
+
+    output_file.body.should == "C\n\nB\n\nA"
+  end
+
+  it "works with paths" do
+    make_filter_with_inputs([
+      ["lib/a", "require('lib/b');\nA"],
+      ["lib/b", "require('lib/c');\nB"],
+      ["lib/c", "C"]
+    ], :additional_dependencies => proc{ %w(lib/b lib/c) })
+
+    output_file.body.should == "C\n\nB\n\nA"
+  end
+
+  it "should handle circular requires" do
+    make_filter_with_inputs([
+      ["a", "require('b');\nA"],
+      ["b", "require('c');\nB"],
+      ["c", "require('a');\nC"]
+    ])
+
+    output_file.body.should == "C\n\nB\n\nA"
+  end
+
+  it "should not require the same file twice" do
+    make_filter_with_inputs([
+      ["a", "require('b');\nrequire('c');\nA"],
+      ["b", "require('c');\nB"],
+      ["c", "require('a');\nC"]
+    ])
+
+    output_file.body.should == "C\n\nB\n\nA"
+  end
+
+  # Feature not yet supported
+  it "does not duplicate files both matched and required"
+
+  describe "config" do
+    describe "require_regexp" do
+      it "works with minispade format" do
+        make_filter_with_inputs([
+          ["a", "minispade.require('b');\nA"],
+          ["b", "minispade.require('c');\nB"],
+          ["c", "C"]
+        ], :require_regexp => %r{^\s*minispade\.require\(['"]([^'"]*)['"]\);?\s*})
+
+        output_file.body.should == "C\n\nB\n\nA"
+      end
+
+      it "works with sprockets format" do
+        make_filter_with_inputs([
+          ["a", "//= require b\nA"],
+          ["b", "//= require c\nB"],
+          ["c", "C"]
+        ], :require_regexp => %r{^//= require (\S+)\s*})
+
+        output_file.body.should == "C\n\nB\n\nA"
+      end
+    end
+
+    describe "path_transform" do
+      it "converts paths" do
+        make_filter_with_inputs([
+          ["lib/a.js", "require('b');\nA"],
+          ["lib/b.js", "require('c');\nB"],
+          ["lib/c.js", "C"]
+        ], :path_transform => proc{|path| "lib/#{path}.js" },
+           :additional_dependencies => proc{ %w(lib/b.js lib/c.js) })
+
+        output_file.body.should == "C\n\nB\n\nA"
+      end
+    end
+
+    describe "closure_wrap" do
+      it "wraps in a javascript closure" do
+        make_filter_with_inputs([
+          ["a", "require('b');\nA"],
+          ["b", "require('c');\nB"],
+          ["c", "C"]
+        ], :closure_wrap => true)
+
+        output_file.body.should == "(function() {\nC\n})();\n\n\n\n(function() {\nB\n})();\n\n\n\n(function() {\nA\n})();\n\n"
+      end
+
+      # Not yet supported
+      it "allows other wrapper types"
+    end
+
+    describe "filename_comment" do
+      it "shows a comment with the filename" do
+        make_filter_with_inputs([
+          ["a", "require('b');\nA"],
+          ["b", "require('c');\nB"],
+          ["c", "C"],
+        ], :filename_comment => proc{|input| "/* #{input.fullpath} */" })
+
+        output_file.body.should == "/* /path/to/input/c */\nC\n\n/* /path/to/input/b */\nB\n\n/* /path/to/input/a */\nA"
+      end
+    end
+
+    describe "additional_dependencies" do
+      it "warns if required file is not contained" do
+        output = capture(:stderr) do
+          make_filter_with_inputs([
+            ["d", "require('e');\nD"],
+            ["e", "require('f');\nE"],
+            ["f", "F"]
+          ])
+        end
+
+        output.should include("Included '/path/to/input/e', which is not listed in :additional_dependencies. The pipeline may not invalidate properly.")
+        output.should include("Included '/path/to/input/f', which is not listed in :additional_dependencies. The pipeline may not invalidate properly.")
+      end
+
+      it "does not warn if full paths are provided" do
+        output = capture(:stderr) do
+          make_filter_with_inputs([
+            ["d", "require('e');\nD"],
+            ["e", "require('f');\nE"],
+            ["f", "F"]
+          ], :additional_dependencies => proc{ %w(/path/to/input/e /path/to/input/f) })
+        end
+
+        output.should == ""
+      end
+    end
+  end
+end

data/spec/sass_filter_spec.rb

@@ -0,0 +1,147 @@
+describe "SassFilter" do
+  SassFilter ||= Rake::Pipeline::Web::Filters::SassFilter
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+
+  let(:scss_input) { <<-SCSS }
+$blue: #3bbfce;
+
+.border {
+  border-color: $blue;
+}
+SCSS
+
+  let(:sass_input) { <<-SASS }
+$blue: #3bbfce
+
+.border
+  border-color: $blue
+SASS
+
+  def expected_css_output(filename)
+    <<-CSS
+/* line 3, /path/to/input/#{filename} */
+.border {
+  border-color: #3bbfce;
+}
+CSS
+  end
+
+  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_files=nil)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = 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 SassFilter.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("border.scss")
+    file.encoding.should == "UTF-8"
+  end
+
+  describe "naming output files" do
+    it "translates .scss extensions to .css by default" do
+      filter = setup_filter SassFilter.new
+      filter.output_files.first.path.should == "border.css"
+    end
+
+    it "accepts a block to customize output file names" do
+      filter = setup_filter(SassFilter.new { |input| "octopus" })
+      filter.output_files.first.path.should == "octopus"
+    end
+  end
+
+  it "accepts options to pass to the Sass compiler" do
+    input_files = [input_file("border.sass_file", sass_input)]
+    filter = setup_filter(SassFilter.new(:syntax => :sass), input_files)
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/border.sass_file"]
+    file.body.should == expected_css_output("border.sass_file")
+  end
+
+  it "compiles files with a .sass extension as sass" do
+    input_files = [input_file("border.sass", sass_input)]
+    filter = setup_filter(SassFilter.new, input_files)
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/border.css"]
+    file.body.should == expected_css_output("border.sass")
+  end
+
+  it "passes Compass's options to the Sass compiler" do
+    Compass.configuration do |c|
+      c.preferred_syntax = :sass
+    end
+
+    input_files = [input_file("border.css", scss_input)]
+    filter = setup_filter(SassFilter.new, input_files)
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+    file = MemoryFileWrapper.files["/path/to/output/border.css"]
+    file.body.should == expected_css_output("border.css")
+  end
+
+  describe "additional load paths" do
+    it "is empty by default" do
+      filter = setup_filter(SassFilter.new)
+      filter.additional_load_paths == []
+    end
+
+    it "transforms to array" do
+      filter = setup_filter(SassFilter.new(:additional_load_paths => "additional"))
+      filter.additional_load_paths == ["additional"]
+    end
+
+    it "accepts array" do
+      filter = setup_filter(SassFilter.new(:additional_load_paths => ["additional", "extra"]))
+      filter.additional_load_paths == ["additional", "extra"]
+    end
+  end
+
+  describe "additional dependencies" do
+    def write_input_file(filename, contents='', root=tmp)
+      mkdir_p root
+      File.open(File.join(root, filename), 'w') { |f| f.puts contents }
+      Rake::Pipeline::FileWrapper.new(root, filename)
+    end
+
+    let(:main_scss) { '@import "blue";' }
+    let(:blue_scss) { '$blue: #3bbfce;' }
+    let!(:main) { write_input_file('main.scss', main_scss) }
+    let!(:blue) { write_input_file('blue.scss', blue_scss) }
+
+    before do
+      File.open(main.fullpath, "w") { |f| f.puts main_scss }
+      File.open(blue.fullpath, "w") { |f| f.puts blue_scss }
+    end
+
+    it "includes @imported files" do
+      filter = SassFilter.new
+      filter.input_files = [main]
+      filter.output_root = "#{tmp}/output"
+      filter.rake_application = Rake::Application.new
+
+      filter.additional_dependencies(main).should include(blue.fullpath)
+
+      tasks = filter.generate_rake_tasks
+      tasks.each(&:invoke)
+    end
+  end
+
+end