bunch 0.2.2 → 1.0.0pre1

data/spec/bunch/compilers/ejs_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  module Compilers
+    describe EJS do
+      it "compiles an EJS file to JS" do
+        tree = FileTree.from_hash(
+          "a" => { "my_file.jst.ejs" => "<% hello %>" }
+        )
+        compiler = EJS.new(
+          tree.get("a").get("my_file.jst.ejs"), tree, "a/my_file.jst.ejs")
+        output = compiler.content
+
+        compiler.path.must_equal "a/my_file.js"
+        output.must_include "JST['a/my_file'] = function"
+      end
+
+      it "raises if the gem isn't available" do
+        EJS.any_instance.stubs(:require).raises(LoadError)
+        exception = assert_raises(RuntimeError) { EJS.new(nil, nil, nil) }
+        exception.message.must_include "gem install"
+      end
+    end
+  end
+end

data/spec/bunch/compilers/jade_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  module Compilers
+    describe Jade do
+      it "compiles a Jade file to JS" do
+        tree = FileTree.from_hash(
+          "a" => { "my_file.jst.jade" => "h1\n  = hello\n  hr\n" }
+        )
+        compiler = Jade.new(
+          tree.get("a").get("my_file.jst.jade"), tree, "a/my_file.jst.jade")
+        output = compiler.content
+
+        compiler.path.must_equal "a/my_file.js"
+        output.must_include "JST['a/my_file'] = function"
+        output.must_include "<hr/>"
+      end
+
+      it "raises if the gem isn't available" do
+        Jade.any_instance.stubs(:require).raises(LoadError)
+        exception = assert_raises(RuntimeError) { Jade.new(nil, nil, nil) }
+        exception.message.must_include "gem install"
+      end
+    end
+  end
+end

data/spec/bunch/compilers/sass_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  module Compilers
+    describe Sass do
+      it "compiles a .scss file to CSS" do
+        tree = FileTree.from_hash(
+          "a" => { "my_file.scss" => "div { span { width: 20px; } }" }
+        )
+        compiler = Sass.new(tree.get("a/my_file.scss"), tree, "a/my_file.scss")
+        compiler.path.must_equal "a/my_file.css"
+        compiler.content.must_equal "div span {\n  width: 20px; }\n"
+      end
+
+      it "compiles a .sass file to CSS" do
+        tree = FileTree.from_hash(
+          "a" => { "my_file.sass" => "div\n  span\n    width: 20px\n" }
+        )
+        compiler = Sass.new(tree.get("a/my_file.sass"), tree, "a/my_file.sass")
+        compiler.path.must_equal "a/my_file.css"
+        compiler.content.must_equal "div span {\n  width: 20px; }\n"
+      end
+
+      it "raises if the gem isn't available" do
+        Sass.any_instance.stubs(:require).raises(LoadError)
+        exception = assert_raises(RuntimeError) { Sass.new(nil, nil, nil) }
+        exception.message.must_include "gem install"
+      end
+
+      describe "dealing with @imports" do
+        let(:included_file) { "@mixin foobar { width: 20px; }" }
+
+        it "imports a file from the same directory" do
+          including_file = <<-SCSS
+            @import "included.scss";
+
+            div {
+                @include foobar;
+            }
+          SCSS
+
+          tree = FileTree.from_hash(
+            "a" => {
+              "including.scss" => including_file,
+              "included.scss" => included_file
+            }
+          )
+
+          compiler = Sass.new(
+            tree.get("a/including.scss"), tree, "a/including.scss")
+          compiler.path.must_equal "a/including.css"
+          compiler.content.must_equal "div {\n  width: 20px; }\n"
+        end
+
+        it "imports a file with no extension (and a leading underscore)" do
+          including_file = <<-SCSS
+            @import "included";
+
+            div {
+                @include foobar;
+            }
+          SCSS
+
+          tree = FileTree.from_hash(
+            "a" => {
+              "including.scss" => including_file,
+              "_included.scss" => included_file
+            }
+          )
+
+          compiler = Sass.new(
+            tree.get("a/including.scss"), tree, "a/including.scss")
+          compiler.path.must_equal "a/including.css"
+          compiler.content.must_equal "div {\n  width: 20px; }\n"
+        end
+
+        it "imports a file from a parent directory" do
+          including_file = <<-SCSS
+            @import "../included.scss";
+
+            div {
+                @include foobar;
+            }
+          SCSS
+
+          tree = FileTree.from_hash(
+            "a" => {
+              "b" => {
+                "including.scss" => including_file,
+              },
+              "included.scss" => included_file
+            }
+          )
+
+          compiler = Sass.new(
+            tree.get("a/b/including.scss"), tree, "a/b/including.scss")
+          compiler.path.must_equal "a/b/including.css"
+          compiler.content.must_equal "div {\n  width: 20px; }\n"
+        end
+
+        it "has an informative error message if the import is missing" do
+          including_file = '@import "../included.scss";'
+
+          tree = FileTree.from_hash(
+            "a" => {
+              "b" => { "including.scss" => including_file }
+            }
+          )
+
+          compiler = Sass.new(
+            tree.get("a/b/including.scss"), tree, "a/b/including.scss")
+          error = proc { compiler.content }.must_raise RuntimeError
+          error.message.must_match /a\/included/
+        end
+      end
+    end
+  end
+end

data/spec/bunch/css_minifier_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  describe CssMinifier do
+    let(:file_contents) do
+      <<-CSS
+body :hover {
+    border-left: 10px solid rgb(0, 0, 0);
+}
+      CSS
+    end
+
+    let(:minified_contents) do
+      "body :hover{border-left:10px solid #000}"
+    end
+
+    let(:input_tree) do
+      FileTree.from_hash(
+        "a" => file_contents, "b" => { "c.css" => file_contents }
+      )
+    end
+
+    it "minifies .css files, ignoring other files" do
+      result = CssMinifier.new(input_tree).result.to_hash
+      result["a"].must_equal file_contents
+      result["b"]["c.css"].must_equal minified_contents
+    end
+  end
+end

data/spec/bunch/file_cache_spec.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "fileutils"
+require "tempfile"
+
+module Bunch
+  describe FileCache do
+    let(:input_1) { FileTree.from_hash("a" => "1", "b" => "2") }
+    let(:input_2) { FileTree.from_hash("a" => "1", "b" => "3") }
+    let(:result_1) { FileTree.from_hash("a" => "!", "b" => "@") }
+    let(:result_2) { FileTree.from_hash("a" => "!", "b" => "#") }
+    let(:result_3) { FileTree.from_hash("a" => "%", "b" => "#") }
+    let(:processor_1) { stub new: stub(result: result_1), to_s: "processor" }
+    let(:processor_2) { stub new: stub(result: result_2), to_s: "processor" }
+    let(:processor_3) { stub new: stub(result: result_3), to_s: "processor" }
+    let(:processor_4) { stub new: stub(result: result_3), to_s: "grocessor" }
+
+    def new_cache(processor, path = "a_path")
+      FileCache.new(processor, path)
+    end
+
+    before do
+      FileUtils.rm_rf ".bunch-cache"
+    end
+
+    it "delegates to the underlying processor on a cold cache" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+    end
+
+    it "returns the same results for the same input" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      new_cache(processor_2).new(input_1).result.must_equal result_1
+    end
+
+    it "returns different results for a different input" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      new_cache(processor_2).new(input_2).result.must_equal result_2
+    end
+
+    it "only updates paths that have changed" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      new_cache(processor_3).new(input_2).result.must_equal result_2
+    end
+
+    it "maintains distinct caches for different processors" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      new_cache(processor_4).new(input_1).result.must_equal result_3
+    end
+
+    it "maintains distinct caches for different input paths" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      new_cache(processor_2).new(input_1).result.must_equal result_1
+      new_cache(processor_2, "abc").new(input_1).result.must_equal result_2
+    end
+
+    it "considers the cache expired if Bunch's version changes" do
+      new_cache(processor_1).new(input_1).result.must_equal result_1
+      begin
+        FileCache::VERSION = "alsdkjalskdj"
+        new_cache(processor_2).new(input_1).result.must_equal result_2
+      ensure
+        FileCache.send :remove_const, :VERSION
+      end
+    end
+  end
+
+  class FileCache
+    describe Partition do
+      let(:empty)  { FileTree.from_hash({}) }
+      let(:tree_1) { FileTree.from_hash("a" => {"b" => "1", "c" => "2"}) }
+
+      it "returns input tree for pending if cache is empty" do
+        cache = stub
+        cache.stubs(:read).returns(nil)
+        partition = Partition.new(tree_1, cache)
+        partition.process!
+        partition.cached.must_equal empty
+        partition.pending.must_equal tree_1
+      end
+
+      it "divides input tree into pending and cached" do
+        cache = stub
+        cache.stubs(:read).with("a/b", "1").returns("cache")
+        cache.stubs(:read).with("a/c", "2").returns(nil)
+        partition = Partition.new(tree_1, cache)
+        partition.process!
+        partition.cached.must_equal FileTree.from_hash("a" => {"b" => "cache"})
+        partition.pending.must_equal FileTree.from_hash("a" => {"c" => "2"})
+      end
+    end
+
+    describe Cache do
+      def create_cache
+        Cache.from_trees(
+          FileTree.from_hash("a" => "1", "b" => { "c" => "2" }),
+          FileTree.from_hash("a" => "!", "b" => { "c" => "@" }))
+      end
+
+      def assert_cache_is_correct(cache)
+        cache.read("a",     "1").must_equal "!"
+        cache.read("a",     "2").must_equal nil
+        cache.read("b/c",   "2").must_equal "@"
+        cache.read("b/c/d", "2").must_equal nil
+        cache.read("b/d",   "2").must_equal nil
+      end
+
+      it "records a mapping between two trees" do
+        cache = create_cache
+        assert_cache_is_correct cache
+      end
+
+      it "saves to and loads from a file" do
+        original_cache = create_cache
+        loaded_cache = nil
+
+        Tempfile.open(["cache", ".yml"]) do |tempfile|
+          tempfile.close
+          original_cache.write_to_file(tempfile.path)
+          loaded_cache = Cache.read_from_file(tempfile.path)
+        end
+        assert_cache_is_correct loaded_cache
+      end
+
+      it "returns a null cache if the file can't be opened" do
+        Cache.read_from_file("asldkasd").must_be_instance_of Cache
+      end
+
+      describe "#read" do
+        before do
+          @cache = Cache.new(
+            { "a" => Digest::MD5.hexdigest("1") },
+            FileTree.from_hash("a" => "!@#")
+          )
+        end
+
+        it "returns the result if the hash matches" do
+          @cache.read("a", "1").must_equal "!@#"
+        end
+
+        it "returns nil if the hash doesn't match" do
+          @cache.read("a", "2").must_equal nil
+        end
+
+        it "returns nil if the file isn't present" do
+          @cache.read("b", "1").must_equal nil
+        end
+      end
+    end
+  end
+end

data/spec/bunch/file_tree_spec.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  describe FileTree do
+    before do
+      @tree = FileTree.from_hash \
+        "a" => {
+          "b.txt" => "foo",
+          "c" => {
+            "d.js" => "bar",
+            "d.coffee" => "brr"
+          }
+        },
+        "e" => "baz"
+    end
+
+    describe ".from_path" do
+      it "loads a file hierarchy" do
+        path = ::File.expand_path "../../example_tree", __FILE__
+        tree = FileTree.from_path(path)
+        tree.to_hash.must_equal(
+          "directory" => {
+            "_combine" => "file2\nfile1\n",
+            "file1" => "1\n",
+            "file2" => "2\n"
+          },
+          "file3" => "3\n"
+        )
+      end
+    end
+
+    describe "#get" do
+      it "returns an object representing a file" do
+        file = @tree.get("e")
+        file.path.must_equal "e"
+        file.content.must_equal "baz"
+        file.extension.must_equal ""
+      end
+
+      it "returns an object representing a nested path" do
+        file = @tree.get("a/b.txt")
+        file.path.must_equal "a/b.txt"
+        file.content.must_equal "foo"
+        file.extension.must_equal ".txt"
+      end
+
+      it "returns an object representing a more nested path" do
+        file = @tree.get("a/c/d.js")
+        file.path.must_equal "a/c/d.js"
+        file.content.must_equal "bar"
+        file.extension.must_equal ".js"
+      end
+
+      it "returns nil if the path extends past a file" do
+        @tree.get("a/c/d.js/nonexistent").must_equal nil
+      end
+    end
+
+    describe "#get_fuzzy" do
+      it "returns an unambiguous match" do
+        file = @tree.get_fuzzy("a/b")
+        file.path.must_equal "a/b.txt"
+        file.content.must_equal "foo"
+        file.extension.must_equal ".txt"
+      end
+
+      it "returns the first of two matches" do
+        file = @tree.get_fuzzy("a/c/d")
+        file.path.must_equal "a/c/d.js"
+        file.content.must_equal "bar"
+        file.extension.must_equal ".js"
+      end
+
+      it "returns nil for no match" do
+        @tree.get_fuzzy("a/fff").must_equal nil
+      end
+
+      it "returns nil if the path extends past a file" do
+        @tree.get_fuzzy("a/c/d.js/nonexistent").must_equal nil
+      end
+    end
+
+    describe "#write" do
+      it "creates a file at the top level" do
+        @tree.write "f", "hello"
+        @tree.get("f").content.must_equal "hello"
+      end
+
+      it "creates a file in an existing directory" do
+        @tree.write "a/c/f", "hello"
+        @tree.get("a/c/f").content.must_equal "hello"
+      end
+
+      it "creates nested directories" do
+        @tree.write "a/c/a/f", "hello"
+        @tree.get("a/c/a/f").content.must_equal "hello"
+      end
+
+      it "overwrites an existing file" do
+        @tree.write "a/c/a/f", "hello"
+        @tree.write "a/c/a/f", "goodbye"
+        @tree.get("a/c/a/f").content.must_equal "goodbye"
+      end
+
+      it "raises if there's an existing file that conflicts with the path" do
+        proc {
+          @tree.write "a/c/d.js/f", "hello"
+        }.must_raise RuntimeError
+
+        @tree.get("a/c/d.js").content.must_equal "bar"
+        @tree.get("a/c/d.js/f").must_equal nil
+      end
+    end
+
+    describe "#write_to_path" do
+      it "mirrors the contents of the tree to the given path" do
+        Dir.mktmpdir do |tmpdir|
+          @tree.write_to_path tmpdir
+          ::File.read("#{tmpdir}/e").must_equal "baz"
+          ::File.read("#{tmpdir}/a/c/d.js").must_equal "bar"
+        end
+      end
+    end
+  end
+end