bunch 0.2.2 → 1.0.0pre1

data/lib/bunch/pipeline.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+module Bunch
+  class Pipeline
+    ENVIRONMENTS = {}
+
+    def self.define(environment, &block)
+      ENVIRONMENTS[environment.to_s] = block
+    end
+
+    def self.for_environment(config)
+      environment = config.fetch(:environment)
+      proc = ENVIRONMENTS[environment] ||
+        raise("No pipeline defined for #{environment}!")
+      new(proc.call(config))
+    end
+
+    def initialize(processors)
+      @processors = processors
+    end
+
+    def process(input_tree)
+      tree = input_tree
+      @processors.each do |processor|
+        tree = processor.new(tree).result
+      end
+      tree
+    end
+  end
+end

data/lib/bunch/server.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+require "mime/types"
+
+module Bunch
+  class Server
+    def initialize(config)
+      Bunch.load_default_config_if_possible
+
+      @reader = config.fetch(:reader) do
+        proc { FileTree.from_path(config.fetch(:root)) }
+      end
+
+      @pipeline = config.fetch(:pipeline) do
+        Pipeline.for_environment config
+      end
+
+      @headers = config.fetch(:headers) do
+        {
+          "Cache-Control" => "private, max-age=0, must-revalidate",
+          "Pragma" => "no-cache",
+          "Expires" => "Thu, 01 Dec 1994 16:00:00 GMT"
+        }
+      end
+    end
+
+    def call(env)
+      path = env["PATH_INFO"].sub(/^\//, '')
+      type = mime_type_for_path(path)
+      tree = @pipeline.process(@reader.call)
+      file = tree.get(path)
+
+      if file.is_a?(File)
+        [200, headers_for_type(type), [file.content]]
+      else
+        [404, headers_for_type("text/plain"), ["Not Found"]]
+      end
+    rescue => e
+      [500, headers_for_type("text/plain"), [error_message(e)]]
+    end
+
+    private
+
+    def mime_type_for_path(path)
+      MIME::Types.type_for(path).first || "text/plain"
+    end
+
+    def headers_for_type(mime_type)
+      @headers.merge("Content-Type" => mime_type.to_s)
+    end
+
+    def error_message(e)
+      "#{e.class}: #{e.message}\n  #{e.backtrace.join("\n  ")}"
+    end
+  end
+end

data/lib/bunch/simple_cache.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+module Bunch
+  def self.SimpleCache(*args)
+    SimpleCache.new(*args)
+  end
+
+  class SimpleCache
+    Result = Struct.new(:result)
+
+    def initialize(processor_class, *args)
+      @processor_class, @args = processor_class, args
+      @cache = nil
+      @hache = nil
+    end
+
+    def new(tree)
+      check_cache!(tree)
+      @cache ||= begin
+        processor = @processor_class.new(tree, *@args)
+        processor.result
+      end
+      Result.new(@cache.dup)
+    end
+
+    private
+
+    def check_cache!(tree)
+      hash = ContentHash.new(tree).result
+      if hash != @hache
+        @cache = nil
+        @hache = hash
+      end
+    end
+  end
+end

data/lib/bunch/tree_merge.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+module Bunch
+  class TreeMerge
+    def initialize(left, right)
+      @left, @right = left, right
+    end
+
+    def result
+      @path = []
+      @output = @right.dup
+      @left.accept(self)
+      @output
+    end
+
+    def enter_tree(tree)
+      @path << tree.name if tree.name
+    end
+
+    def leave_tree(tree)
+      @path.pop if tree.name
+    end
+
+    def visit_file(file)
+      file_path = [*@path, file.path].join("/")
+      @output.write file_path, file.content
+    end
+  end
+end

data/lib/bunch/version.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Bunch
-  VERSION = "0.2.2"
+  VERSION = "1.0.0pre1"
 end

data/spec/bunch/cli_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  describe CLI do
+    describe ".run!" do
+      it "instantiates CLI with the given args and calls run! on it" do
+        args = %w(a b c)
+        cli = stub
+        cli.expects(:run!)
+        CLI.expects(:new).with(args).returns(cli)
+        CLI.run!(args)
+      end
+    end
+
+    it "requires both input and output paths" do
+      out = StringIO.new
+      CLI.new(%w(in_path), out).run!
+      out.string.must_include "Error:"
+      out.string.must_include "Usage:"
+    end
+
+    it "prints usage" do
+      out = StringIO.new
+      CLI.new(%w(-h), out).run!
+      out.string.wont_include "Error:"
+      out.string.must_include "Usage:"
+    end
+
+    it "loads the default config file if possible" do
+      ::File.stubs(:exist?).with("config/bunch.rb").returns(true)
+      Bunch.expects(:load).with("config/bunch.rb")
+      run_example
+    end
+
+    it "loads an alternate config file if provided" do
+      ::File.expects(:exist?).with("config/bunch.rb").never
+      Bunch.expects(:load).with("config/bunch.rb").never
+      ::File.stubs(:exist?).with("config/foo.rb").returns(true)
+      Bunch.expects(:load).with("config/foo.rb")
+
+      run_example(["-c config/foo.rb"])
+    end
+
+    it "errors out if given a non-existent config file" do
+      ::File.stubs(:exist?).with("config/foo.rb").returns(false)
+
+      run_example(["-c config/foo.rb"]) do |tmpdir, out|
+        out.must_include "Error: cannot load such file"
+      end
+    end
+
+    it "loads multiple config files" do
+      ::File.stubs(:exist?).with("config/foo.rb").returns(true)
+      Bunch.expects(:load).with("config/foo.rb")
+      ::File.stubs(:exist?).with("config/bar.rb").returns(true)
+      Bunch.expects(:load).with("config/bar.rb")
+
+      run_example(%w(-c config/foo.rb --config config/bar.rb)) do |_, out|
+        out.must_equal ""
+      end
+    end
+
+    it "runs the given environment's pipeline on the given path" do
+      run_example do |tmpdir, out|
+        out.must_equal ""
+        FileTree.from_path(tmpdir).to_hash.must_equal(
+          "directory" => "2\n\n1\n",
+          "file3" => "3\n"
+        )
+      end
+    end
+
+    def run_example(params = nil)
+      Dir.mktmpdir do |tmpdir|
+        out = StringIO.new
+        params ||= ["-e development"]
+        params = [*params, "spec/example_tree", tmpdir]
+        CLI.new(params, out).run!
+        yield(tmpdir, out.string) if block_given?
+      end
+    end
+  end
+end

data/spec/bunch/combiner_spec.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  describe Combiner do
+    def self.scenario(name, input, output)
+      it "combines a tree correctly: #{name}" do
+        result_for_hash(input).must_equal output
+      end
+    end
+
+    def result_for_hash(input)
+      Combiner.new(FileTree.from_hash(input)).result.to_hash
+    end
+
+    scenario "one JavaScript file",
+      {"a.js" => "hello;"},
+      {"a.js" => "hello;"}
+
+    scenario "two JavaScript files in a directory",
+      {"a" => {"b.js" => "hello;", "c.js" => "goodbye;"}},
+      {"a" => {"b.js" => "hello;", "c.js" => "goodbye;"}}
+
+    scenario "two JavaScript files and a _combine file",
+      {"a" => {"_combine" => "", "b.js" => "hello;", "c.js" => "goodbye;"}},
+      {"a.js" => "hello;\ngoodbye;"}
+
+    scenario "ignoring a _combine file at the top level",
+      {"_combine" => "", "a" => {"b.js" => "bar;", "c.js" => "baz;"}},
+      {"a" => {"b.js" => "bar;", "c.js" => "baz;"}}
+
+    scenario "a more complex tree of JavaScript files",
+      {"a" => {
+         "b" => {
+           "_combine" => "", "c.js" => "hello;", "d.js" => "goodbye;"
+         },
+         "e.js" => "and_another_thing;"
+      }},
+      {"a" => {
+         "b.js" => "hello;\ngoodbye;",
+         "e.js" => "and_another_thing;"
+      }}
+
+    scenario "_combine forces subtrees to collapse",
+      {"a" => {
+         "b" => {
+           "_combine" => "",
+           "c" => {
+             "d.js" => "whoops;",
+             "e.js" => "it_worked;"
+           }
+         }
+      }},
+      {"a" => {"b.js" => "whoops;\nit_worked;"}}
+
+    scenario "obey ordering found in _combine",
+      {"a" => {
+         "d" => "pants",
+         "a" => "spigot",
+         "_combine" => "c\nd\n",
+         "c" => "deuce",
+         "b" => "rands"
+      }},
+      {"a" => "deuce\npants\nspigot\nrands"}
+
+    scenario "deal with nested combines",
+      {"a" => {
+         "_combine" => "e\nb\n",
+         "b" => {
+           "_combine" => "d\nc\n",
+           "c.js" => "stuff",
+           "d.js" => "other_stuff"
+         },
+         "e.js" => "still_more_stuff"
+      }},
+      {"a.js" => "still_more_stuff\nother_stuff\nstuff"}
+
+    scenario "deal with inner directory with no _combine",
+      {"a" => {
+         "_combine" => "e\nb\n",
+         "b.js" => "still_more_stuff",
+         "e" => {
+           "c.js" => "stuff",
+           "d.js" => "other_stuff"
+         }
+      }},
+      {"a.js" => "stuff\nother_stuff\nstill_more_stuff"}
+
+    scenario "deal with empty directory",
+      {"a" => {
+         "b" => {
+           "_combine" => "",
+         },
+         "e.js" => "stuff"
+      }},
+      {"a" => {"e.js" => "stuff"}}
+
+    it "raises when one combine has incompatible files" do
+      proc do
+        result_for_hash(
+          "a" => { "_combine" => "", "a.js" => "", "b.css" => "" }
+        )
+      end.must_raise RuntimeError
+    end
+  end
+end

data/spec/bunch/compiler_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  describe Compiler do
+    it "passes plain files through unchanged" do
+      hash = {
+        "a" => { "b" => "c", "d" => "e" },
+        "f" => "g"
+      }
+      result = Compiler.new(FileTree.from_hash(hash)).result.to_hash
+      result.must_equal hash
+    end
+
+    describe "when a file type has a registered compiler" do
+      before do
+        compiler = Class.new do
+          def initialize(*)
+          end
+
+          def path
+            "b.js"
+          end
+
+          def content
+            "!!!"
+          end
+        end
+
+        Compiler.register ".foobar", compiler
+      end
+
+      after do
+        Compiler.compilers.delete ".foobar"
+      end
+
+      it "uses the compiler to transform a file of that type" do
+        input = {
+          "a" => { "b.foobar" => "c", "d.js" => "e" },
+          "f" => "g"
+        }
+        output = {
+          "a" => { "b.js" => "!!!", "d.js" => "e" },
+          "f" => "g"
+        }
+        result = Compiler.new(FileTree.from_hash(input)).result.to_hash
+        result.must_equal output
+      end
+
+      it "passes the file, tree, and path into the compiler" do
+        input = { "a" => { "b.foobar" => "c" } }
+
+        Compiler.compilers[".foobar"].expects(:new).with do |file, tree, path|
+          file.path.must_equal "b.foobar"
+          file.content.must_equal "c"
+          file.filename.must_equal "b.foobar"
+          file.extension.must_equal ".foobar"
+          tree.to_hash.must_equal input
+          path.must_equal "a/b.foobar"
+        end.returns(stub(path: "b.js", content: "!!!"))
+
+        Compiler.new(FileTree.from_hash(input)).result
+      end
+
+      it "can register a replacement compiler" do
+        o = Object.new
+        Compiler.register ".foobar", o
+        Compiler.compilers[".foobar"].must_equal o
+      end
+    end
+  end
+end

data/spec/bunch/compilers/coffee_script_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+module Bunch
+  module Compilers
+    describe CoffeeScript do
+      it "compiles a CoffeeScript file to JS" do
+        file = File.new("a/my_file.coffee", "@a = 10")
+        compiler = CoffeeScript.new(file)
+        compiler.path.must_equal "a/my_file.js"
+        compiler.content.must_equal \
+          "(function() {\n\n  this.a = 10;\n\n}).call(this);\n"
+      end
+
+      it "raises if the gem isn't available" do
+        CoffeeScript.any_instance.stubs(:require).raises(LoadError)
+        exception = assert_raises(RuntimeError) { CoffeeScript.new(nil) }
+        exception.message.must_include "gem install"
+      end
+    end
+  end
+end