slinky 0.7.3 → 0.8.0

data/lib/slinky/proxy_server.rb

@@ -1,7 +1,7 @@
 module Slinky
   module ProxyServer
     HTTP_MATCHER = /(GET|POST|PUT|DELETE|HEAD) (.+?)(?= HTTP)/
-    HOST_MATCHER = /Host: (.+)/
+    HOST_MATCHER = /Host: (\S+)/
 
     def self.process_proxies proxy_hash
       proxy_hash.map{|from, h|

data/lib/slinky/runner.rb

@@ -70,7 +70,7 @@ module Slinky
       EM::run {
         @config ||= Config.empty
 
-        Slinky::Server.dir = @options[:src_dir]
+        Slinky::Server.dir = @options[:src_dir] || @config.src_dir
         Slinky::Server.config = @config
         manifest = Manifest.new(Slinky::Server.dir,
                                 Slinky::Server.config)

data/lib/slinky/server.rb

@@ -2,6 +2,11 @@ module Slinky
   module Server
     include EM::HttpServer
 
+    INJECT_CSS = File.read("#{File.dirname(__FILE__)}/templates/inject.css")
+    ERROR_CSS = File.read("#{File.dirname(__FILE__)}/templates/error.css")
+    ERROR_HAML = File.read("#{File.dirname(__FILE__)}/templates/error.haml")
+    ERROR_JS = File.read("#{File.dirname(__FILE__)}/templates/error.js")
+
     # Sets the root directory from which files should be served
     def self.dir= _dir; @dir = _dir; end
     # Gets the root directory from which files should be served
@@ -59,17 +64,48 @@ module Slinky
       resp
     end
 
+    # Produces nice error output for various kinds of formats
+    def self.format_error_output resp, mf, error
+      resp.content =
+        case Pathname.new(mf.output_path).extname
+        when ".html"
+          Haml::Engine.new(ERROR_HAML).
+            render(Object.new, errors: error.messages, css: ERROR_CSS)
+        when ".css"
+          resp.status = 200 # browsers ignore 500'd css
+          INJECT_CSS.gsub("{REPLACE_ERRORS}",
+                          error.messages.join("\n").gsub("'", "\""))
+        when ".js"
+          resp.status = 200 # browsers ignore 500'd js
+          ERROR_JS
+            .gsub("{REPLACE_CSS}",
+                  JSON.dump({css: ERROR_CSS.gsub("\n", "")}))
+            .gsub("{REPLACE_ERRORS}", JSON.dump(error.messages))
+        else
+          error.message
+        end
+    end
+
     # Takes a manifest file and produces a response for it
     def self.handle_file resp, mf, compile = true
       begin
-        if path = mf.process(nil, compile)
-          serve_file resp, path.to_s
+        path = mf.process(nil, compile)
+        serve_file resp, path.to_s
+      rescue SlinkyError => e
+        resp.status = 500
+        if self.config.enable_browser_errors
+          format_error_output(resp, mf, e)
         else
-          raise StandardError.new
+          resp.content = e.message
         end
-      rescue
+        e.messages.each{|m|
+          $stderr.puts(m.foreground(:red))
+        }
+      rescue => e
         resp.status = 500
-        resp.content = "Error compiling #{mf.source}\n"
+        format_error_output(resp, mf, SlinkyError.new(
+                              "Unknown error handling #{mf.source}: #{$!}\n"))
+        $stderr.puts("Unknown error handling #{mf.source}: #{$!}".foreground(:red))
       end
       resp
     end

data/lib/slinky/templates/error.css

@@ -0,0 +1,32 @@
+#slinky-error {
+  font-family: Helvetica, Arial, Sans-Serif;
+}
+
+#slinky-error .slinky-header {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 100px;
+  background-color: rgb(141, 55, 55);
+  text-align: center;
+  font-size: 1.5em;
+  line-height: 1.5em;
+  color: whitesmoke;
+  text-shadow: -1px -1px rgba(0, 0, 0, 0.2)
+}
+
+#slinky-error .slinky-body {
+  position: absolute;
+  top: 100px; left: 0; right: 0;
+  padding: 0 50px;
+  padding-bottom: 20px;
+  font-size: 1.25em;
+  color: black;
+  background-color: whitesmoke;
+  border-bottom: 1px solid #aaa;
+}
+
+#slinky-error .slinky-body li {
+  padding-top: 20px;
+}

data/lib/slinky/templates/error.haml

@@ -0,0 +1,13 @@
+!!!5
+%html
+  %head
+    %title Slinky encountered an error
+    %style{:type => "text/css"}= css
+  %body
+    #slinky-error
+      .slinky-header
+        %h1 Oh no! Build error!
+      .slinky-body
+        %ul
+          - errors.each do |error|
+            %li= error

data/lib/slinky/templates/error.js

@@ -0,0 +1,26 @@
+(function(errors) {
+  var domLoaded = function() {
+    var css = {REPLACE_CSS};
+    var cssEl = document.createElement("style");
+    cssEl.type = "text/css";
+    cssEl.innerText = css.css;
+    document.head.appendChild(cssEl);
+
+    var el = document.getElementById("slinky-error");
+    if(el == null) {
+      el = document.createElement("div");
+      el.id = "slinky-error";
+      el.innerHTML = '<div class="slinky-header"><h1>Oh no! Build'
+        + ' error!</h1></div><div class="slinky-body"><ul></ul></div>';
+      document.body.appendChild(el);
+    }
+
+    var ul = el.getElementsByTagName("ul")[0];
+    errors.forEach(function(error) {
+      var li = document.createElement("li");
+      li.innerText = error;
+      ul.appendChild(li);
+    });
+  };
+  document.addEventListener("DOMContentLoaded", domLoaded, false);
+})({REPLACE_ERRORS});

data/lib/slinky/templates/inject.css

@@ -0,0 +1,27 @@
+body:before {
+  font-family: Helvetica, Arial, Sans-Serif;
+  content: "oh no! build error!";
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 100px;
+  background-color: rgb(141, 55, 55);
+  text-align: center;
+  font-size: 2.5em;
+  line-height: 2.5em;
+  color: whitesmoke;
+  text-shadow: -1px -1px rgba(0, 0, 0, 0.2)
+}
+
+body:after {
+  font-family: Helvetica, Arial, Sans-Serif;
+  content: '{REPLACE_ERRORS}';
+  position: absolute;
+  top: 100px; left: 0; right: 0;
+  padding: 20px 50px;
+  font-size: 1.25em;
+  color: black;
+  background-color: whitesmoke;
+  border-bottom: 1px solid #aaa;
+}

data/slinky.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: slinky 0.7.3 ruby lib
+# stub: slinky 0.8.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "slinky"
-  s.version = "0.7.3"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Micah Wylde"]
-  s.date = "2014-04-10"
+  s.date = "2014-07-19"
   s.description = "A static file server for rich web apps that automatically compiles SASS, HAML, CoffeeScript and more"
   s.email = "micah@micahw.com"
   s.executables = ["slinky"]
@@ -36,18 +36,26 @@ Gem::Specification.new do |s|
     "lib/slinky/compilers/clojurescript-compiler.rb",
     "lib/slinky/compilers/coffee-compiler.rb",
     "lib/slinky/compilers/haml-compiler.rb",
+    "lib/slinky/compilers/jsx-compiler.rb",
     "lib/slinky/compilers/less-compiler.rb",
     "lib/slinky/compilers/sass-compiler.rb",
     "lib/slinky/config_reader.rb",
     "lib/slinky/em-popen3.rb",
+    "lib/slinky/errors.rb",
+    "lib/slinky/graph.rb",
     "lib/slinky/listener.rb",
     "lib/slinky/live_reload.rb",
     "lib/slinky/manifest.rb",
     "lib/slinky/proxy_server.rb",
     "lib/slinky/runner.rb",
     "lib/slinky/server.rb",
+    "lib/slinky/templates/error.css",
+    "lib/slinky/templates/error.haml",
+    "lib/slinky/templates/error.js",
+    "lib/slinky/templates/inject.css",
     "slinky.gemspec",
     "spec/compilers_spec.rb",
+    "spec/manifest_spec.rb",
     "spec/slinky_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -60,6 +68,7 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<multi_json>, ["~> 1.9.2"])
       s.add_runtime_dependency(%q<eventmachine>, ["~> 1.0"])
       s.add_runtime_dependency(%q<eventmachine_httpserver>, ["~> 0.2"])
       s.add_runtime_dependency(%q<em-websocket>, ["~> 0.3"])
@@ -80,7 +89,9 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<less>, [">= 2.2.0"])
       s.add_development_dependency(%q<therubyracer>, [">= 0"])
+      s.add_development_dependency(%q<react-jsx>, ["~> 0.8.0"])
     else
+      s.add_dependency(%q<multi_json>, ["~> 1.9.2"])
       s.add_dependency(%q<eventmachine>, ["~> 1.0"])
       s.add_dependency(%q<eventmachine_httpserver>, ["~> 0.2"])
       s.add_dependency(%q<em-websocket>, ["~> 0.3"])
@@ -101,8 +112,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<less>, [">= 2.2.0"])
       s.add_dependency(%q<therubyracer>, [">= 0"])
+      s.add_dependency(%q<react-jsx>, ["~> 0.8.0"])
     end
   else
+    s.add_dependency(%q<multi_json>, ["~> 1.9.2"])
     s.add_dependency(%q<eventmachine>, ["~> 1.0"])
     s.add_dependency(%q<eventmachine_httpserver>, ["~> 0.2"])
     s.add_dependency(%q<em-websocket>, ["~> 0.3"])
@@ -123,6 +136,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<less>, [">= 2.2.0"])
     s.add_dependency(%q<therubyracer>, [">= 0"])
+    s.add_dependency(%q<react-jsx>, ["~> 0.8.0"])
   end
 end
 

data/spec/compilers_spec.rb

@@ -90,4 +90,19 @@ eos
       }
     end
   end
+
+  context "JSXCompiler" do
+    it "should be able to compile .jsx files" do
+      src = <<-EOF
+  /** @jsx React.DOM */
+  React.renderComponent(
+    <h1>Hello, world!</h1>,
+    document.getElementById('example')
+  );
+EOF
+      compiler_test("/compilers/test.jsx", ".js", src){|s|
+        s.include?("Hello, world!")
+      }
+    end
+  end
 end

data/spec/manifest_spec.rb

@@ -0,0 +1,750 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Manifest" do
+  before :each do
+    @mprod = Slinky::Manifest.new("/src", @config, :devel => false, :build_to => "/build")
+    @mdevel = Slinky::Manifest.new("/src", @config)
+    @md_prod = @mprod.manifest_dir
+    @md_devel = @mdevel.manifest_dir
+  end
+
+  context "General" do
+    it "should build manifest dir with all files in current dir" do
+      @md_prod.files.collect{|f| f.source}.should == ["/src/test.haml"]
+      @md_devel.files.collect{|f| f.source}.should == ["/src/test.haml"]
+    end
+
+    it "should build manifest with all files in fs" do
+      @mprod.files.collect{|f|
+        f.source
+      }.sort.should == @files.collect{|x| "/src/" + x}.sort
+      @mdevel.files.collect{|f|
+        f.source
+      }.sort.should == @files.collect{|x| "/src/" + x}.sort
+    end
+
+    it "should not include dot files" do
+      File.open("/src/.index.haml.swp", "w+"){|f| f.write("x")}
+      manifest = Slinky::Manifest.new("/src", @config)
+      manifest.files.map{|x| x.source}.include?("/src/.index.haml.swp").should == false
+    end
+
+    it "should be able to compute a hash for the entire manifest" do
+      m = @mdevel
+      hash1 = m.md5
+      File.open("/src/hello.html", "w+") {|f| f.write("Hell!") }
+      $stdout.should_receive(:puts).with("Compiled /src/test.haml".foreground(:green)).exactly(2).times
+      m.add_all_by_path(["/src/hello.html"])
+      m.md5.should_not == hash1
+    end
+
+    it "should find files in the manifest by path" do
+      @mdevel.find_by_path("test.haml").first.source.should == "/src/test.haml"
+      @mdevel.find_by_path("asdf.haml").first.should == nil
+      @mdevel.find_by_path("l1/l2/test.txt").first.source.should == "/src/l1/l2/test.txt"
+      @mdevel.find_by_path("l1/test.css").first.source.should == "/src/l1/test.sass"
+      l1 = @mdevel.manifest_dir.children.find{|c| c.dir == "/src/l1"}
+      l1.find_by_path("../test.haml").first.source.should == "/src/test.haml"
+    end
+
+    it "should produce the correct scripts string for production" do
+      @mprod.scripts_string.should match \
+                                     %r!<script type="text/javascript" src="/scripts.js\?\d+"></script>!
+    end
+
+    it "should produce the correct scripts string for devel" do
+      @mdevel.scripts_string.should == [
+        '<script type="text/javascript" src="/l1/test5.js"></script>',
+        '<script type="text/javascript" src="/l1/l2/test6.js"></script>',
+        '<script type="text/javascript" src="/l1/test2.js"></script>',
+        '<script type="text/javascript" src="/l1/l2/test3.js"></script>',
+        '<script type="text/javascript" src="/l1/test.js"></script>'].join("\n")
+    end
+
+    it "should produce the correct styles string for production" do
+      @mprod.styles_string.should match \
+                                    %r!<link rel="stylesheet" href="/styles.css\?\d+" />!
+    end
+
+    it "should produce the correct styles string for development" do
+      File.open("/src/l1/l2/bad.sass", "w+"){|f|
+        f.write "require('../test.sass')\ncolor: red;"
+      }
+      manifest = Slinky::Manifest.new("/src", @config)
+      @mdevel.styles_string.should == [
+        '<link rel="stylesheet" href="/l1/test.css" />',
+        '<link rel="stylesheet" href="/l1/l2/test2.css" />'].join("\n")
+    end
+
+    it "should allow the creation of ManifestFiles" do
+      mf = Slinky::ManifestFile.new("/src/test.haml", "", @mprod)
+    end
+
+    it "should correctly determine output_path" do
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      mf.output_path.to_s.should == "/src/test.html"
+      mf = Slinky::ManifestFile.new("/src/l1/test.js", "/src/build", @mprod)
+      mf.output_path.to_s.should == "/src/l1/test.js"
+    end
+
+    it "should correctly determine relative_output_path" do
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      mf.relative_output_path.to_s.should == "test.html"
+      mf = Slinky::ManifestFile.new("/src/l1/test.js", "/src/build", @mprod)
+      mf.relative_output_path.to_s.should == "l1/test.js"
+    end
+
+    it "should build tmp file without directives" do
+      original = "/src/test.haml"
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      path = mf.handle_directives mf.source
+      File.read(original).match(/slinky_scripts|slinky_styles/).should_not == nil
+      File.read(path).match(/slinky_scripts|slinky_styles/).should == nil
+    end
+
+    it "should build tmp file without directives for .js" do
+      original = "/src/l1/test.js"
+      mf = Slinky::ManifestFile.new("/src/l1/test.js", "/src/build", @mprod)
+      path = mf.handle_directives mf.source
+      File.read(original).match(/slinky_require/).should_not == nil
+      File.read(path).match(/slinky_require/).should == nil
+    end
+
+    it "should compile files that need it" do
+      $stdout.should_receive(:puts).with("Compiled /src/test.haml".foreground(:green))
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      FileUtils.mkdir("/src/build")
+      build_path = mf.process mf.build_to
+      build_path.to_s.split(".")[-1].should == "html"
+      File.read("/src/test.haml").match("<head>").should == nil
+      File.read(build_path).match("<head>").should_not == nil
+
+      $stdout.should_receive(:puts).with("Compiled /src/test.haml".foreground(:green))
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      build_path = mf.process "/src/build/test.html"
+      File.read("/src/build/test.html").match("<head>").should_not == nil
+      FileUtils.rm_rf("/src/build") rescue nil
+    end
+
+    it "should give the proper error message for compilers with unmet dependencies" do
+      File.open("/src/test.fake", "w+"){|f| f.write("hello, fake data")}
+      $stderr.should_receive(:puts).with(/Missing dependency/)
+      mf = Slinky::ManifestFile.new("/src/test.fake", "/src/build", @mprod)
+      build_path = mf.process
+    end
+
+    it "should report errors for bad files" do
+      File.open("/src/l1/l2/bad.sass", "w+"){|f|
+        f.write "color: red;"
+      }
+      mf = Slinky::ManifestFile.new("/src/l1/l2/bad.sass", "/src/build", @mprod)
+      expect { mf.process }.to raise_error Slinky::BuildFailedError
+    end
+
+    it "shouldn't crash on syntax errors" do
+      File.open("/src/l1/asdf.haml", "w+"){|f|
+        f.write("%h1{:width => 50px}")
+      }
+      mf = Slinky::ManifestFile.new("/src/l1/asdf.haml", "/src/build", @mprod)
+      expect { mf.process }.to raise_error Slinky::BuildFailedError
+    end
+
+    it "should properly determine build directives" do
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      mf.find_directives.should == {:slinky_scripts => [], :slinky_styles => []}
+      mf = Slinky::ManifestFile.new("/src/l1/test.js", "/src/build", @mprod)
+      mf.find_directives.should == {:slinky_require => ["test2.js", "l2/test3.js"]}
+    end
+
+    it "should properly determine build_to path" do
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      mf.build_to.should == Pathname.new("/src/build/test.html")
+      mf = Slinky::ManifestFile.new("/src/l1/test.js", "/src/build", @mprod)
+      mf.build_to.should == Pathname.new("/src/build/test.js")
+    end
+
+    it "should build both compiled files and non-compiled files" do
+      $stdout.should_receive(:puts).with("Compiled /src/test.haml".foreground(:green))
+      mf = Slinky::ManifestFile.new("/src/test.haml", "/src/build", @mprod)
+      path = mf.build
+      path.to_s.should == "/src/build/test.html"
+      File.read("/src/test.haml").match("<head>").should == nil
+      File.read(path).match("<head>").should_not == nil
+
+      $stdout.should_not_receive(:puts)
+      mf = Slinky::ManifestFile.new("/src/l1/l2/test.txt", "/src/build/l1/l2", @mprod)
+      path = mf.build
+      path.to_s.should == "/src/build/l1/l2/test.txt"
+      File.read("/src/build/l1/l2/test.txt").should == "hello\n"
+    end
+
+    it "should match files" do
+      mf = Slinky::ManifestFile.new("/src/l1/l2/test.txt", "/src/build/l1/l2", @mprod)
+      mf.matches?("test.txt").should == true
+      mf = Slinky::ManifestFile.new("/src/l1/test.sass", "", @mprod)
+      mf.matches?("test.css").should == true
+      mf.matches?("test.sass").should == true
+    end
+
+    it "should match file paths" do
+      mf = Slinky::ManifestFile.new("/src/l1/l2/test.txt", "/src/build/l1/l2", @mprod)
+      mf.matches_path?("test.txt").should == false
+      mf.matches_path?("/l1/l2/test.txt").should == true
+      mf.matches_path?("/l1/l2/*.txt").should == false
+      mf.matches_path?("/l1/l2/*.txt", true).should == true
+      mf = Slinky::ManifestFile.new("/src/l1/test.sass", "", @mprod)
+      mf.matches_path?("/l1/test.css").should == true
+      mf.matches_path?("/l1/test.sass").should == true
+      mf.matches_path?("/l1/*.css", true).should == true
+      mf.matches_path?("/l1/*.sass", true).should == true
+      mf.matches_path?("l1/test.sass").should == false
+    end
+
+    it "should should properly determine if in tree" do
+      mf = Slinky::ManifestFile.new("/src/l1/l2/test.txt", "/src/build/l1/l2", @mprod)
+      mf.in_tree?("/l1").should == true
+      mf.in_tree?("/l1/l2").should == true
+      mf.in_tree?("/l1/l2/test.txt").should == true
+      mf.in_tree?("/l1/l3").should == false
+      mf.in_tree?("test.txt").should == false
+    end
+
+    it "should correctly build the dependency graph" do
+      @mprod.dependency_graph.collect{|x| x.collect{|y| y.source}}.sort.should ==
+        [["/src/l1/test2.js", "/src/l1/test.js"],
+         ["/src/l1/l2/test3.coffee", "/src/l1/test.js"],
+         ["/src/l1/test5.js", "/src/l1/test2.js"],
+         ["/src/l1/l2/test6.js", "/src/l1/l2/test3.coffee"]].sort
+    end
+
+    it "should fail if a required file isn't in the manifest" do
+      FileUtils.rm("/src/l1/test2.js")
+      manifest = Slinky::Manifest.new("/src", @config, :devel => false, :build_to => "/build")
+      proc {
+        manifest.dependency_graph
+      }.should raise_error Slinky::FileNotFoundError
+    end
+
+    it "should build a correct dependency list" do
+      @mprod.dependency_list.collect{|x| x.source}.should == ["/src/test.haml", "/src/l1/test.sass", "/src/l1/test5.js", "/src/l1/l2/test.txt", "/src/l1/l2/test2.css", "/src/l1/l2/test6.js", "/src/l1/l2/l3/test2.txt", "/src/l1/test2.js", "/src/l1/l2/test3.coffee", "/src/l1/test.js"]
+    end
+
+    it "should fail if there is a cycle in the dependency graph" do
+      File.open("/src/l1/test5.js", "w+"){|f| f.write("slinky_require('test.js')")}
+      manifest = Slinky::Manifest.new("/src", @config, :devel => false, :build_to => "/build")
+      proc { manifest.dependency_list }.should raise_error Slinky::DependencyError
+    end
+
+    it "should handle depends directives" do
+      File.open("/src/l1/test5.coffee", "w+"){|f| f.write("slinky_depends('test.sass')")}
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/test5.js").first
+      f.should_not == nil
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test.sass/)
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test5.coffee/)
+      f.process
+    end
+
+    it "should handle depends directives with glob patterns" do
+      File.open("/src/l1/test5.coffee", "w+"){|f| f.write("slinky_depends('*.sass')")}
+      File.open("/src/l1/test2.sass", "w+"){|f| f.write("body\n\tcolor: red")}
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/test5.js").first
+      f.should_not == nil
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test.sass/)
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test2.sass/)
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test5.coffee/)
+      f.process
+    end
+
+    it "should handle depends directives with infinite loops" do
+      File.open("/src/l1/test5.coffee", "w+"){|f| f.write("slinky_depends('*.sass')")}
+      File.open("/src/l1/test2.sass", "w+"){|f| f.write("/* slinky_depends('*.coffee')")}
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/test5.js").first
+      f.should_not == nil
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test.sass/)
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test2.sass/)
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/test5.coffee/)
+      f.process
+    end
+
+    it "should handle depends directives in config" do
+      cf "/depend/script/vendor/backbone.js"
+      cf "/depend/script/vendor/jquery.js"
+      cf "/depend/script/vendor/underscore.js"
+
+      config = <<eos
+dependencies:
+  "/script/vendor/backbone.js":
+      - "/script/vendor/jquery.js"
+      - "/script/vendor/underscore.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      mdevel = Slinky::Manifest.new("/depend", config, :devel => true)
+
+      files = mdevel.files_for_product("/scripts.js").map{|x| x.source}
+      files[2].should == "/depend/script/vendor/backbone.js"
+    end
+
+    it "should cache files" do
+      File.open("/src/l1/cache.coffee", "w+"){|f| f.write("() -> 'hello, world!'\n")}
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/cache.js").first
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/cache.coffee/)
+      f.process
+      f.process
+      File.open("/src/l1/cache.coffee", "a"){|f| f.write("() -> 'goodbye, world!'\n")}
+      $stdout.should_receive(:puts).with(/Compiled \/src\/l1\/cache.coffee/)
+      f.process
+    end
+
+    it "should handle new directives" do
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/test.js").first
+      f.process
+      f.directives.should == {:slinky_require=>["test2.js", "l2/test3.js"]}
+      File.open("/src/l1/test.js", "a"){|f| f.write("slinky_require('test5.js')\n")}
+      f.process
+      f.directives.should == {:slinky_require=>["test2.js", "l2/test3.js", "test5.js"]}
+    end
+
+    it "should detect new files" do
+      $stdout.should_receive(:puts).with(/Compiled \/src\/test.haml/)
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      File.open("/src/l1/cache.coffee", "w+"){|f| f.write("console.log 'hello'")}
+      manifest.add_all_by_path(["/src/l1/cache.coffee"])
+      f = manifest.find_by_path("l1/cache.js").first
+      f.should_not == nil
+      manifest.scripts_string.match("cache.js").should_not == nil
+      FileUtils.mkdir("/src/l1/hello")
+      File.open("/src/l1/hello/asdf.sass", "w+"){|f| f.write("hello")}
+      f = manifest.find_by_path("l1/hello/asdf.sass")
+      f.should_not == nil
+    end
+
+    it "should handle deletion of files" do
+      File.open("/src/l1/cache.coffee", "w+"){|f| f.write("console.log 'hello'")}
+      $stdout.should_receive(:puts).with(/Compiled \/src\/test.haml/)
+      manifest = Slinky::Manifest.new("/src", @config, :devel => true)
+      f = manifest.find_by_path("l1/cache.coffee").first
+      f.should_not == nil
+      manifest.scripts_string.match("l1/cache.js").should_not == nil
+
+      FileUtils.rm("/src/l1/cache.coffee")
+      File.exists?("/src/l1/cache.coffee").should == false
+      manifest.remove_all_by_path(["/src/l1/cache.coffee"])
+      f = manifest.find_by_path("l1/cache.coffee").first
+      f.should == nil
+      manifest.scripts_string.match("l1/cache.js").should == nil
+    end
+
+    it "should ignore the build directory" do
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(6).times
+      options = {:src_dir => "/src", :build_dir => "/src/build"}
+      Slinky::Builder.build(options, @config)
+      File.exists?("/src/build/build").should_not == true
+      File.exists?("/src/build/test.html").should == true
+      Slinky::Builder.build(options, @config)
+      File.exists?("/src/build/build").should == false
+    end
+
+    it "should combine and compress javascript" do
+      FileUtils.rm_rf("/build") rescue nil
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(3).times
+      @mprod.build
+      File.exists?("/build/scripts.js").should == true
+      File.size("/build/scripts.js").should > 90
+      File.read("/build/scripts.js").match('"Hello, world"').should_not == nil
+      File.exists?("/build/l1/test.js").should == false
+    end
+
+    it "should combine and compress css" do
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(3).times
+      @mprod.build
+      File.exists?("/build/styles.css").should == true
+      File.size("/build/styles.css").should > 25
+      File.read("/build/styles.css").match(/color:\s*red/).should_not == nil
+      File.exists?("/build/l1/test.css").should == false
+    end
+
+    it "should modify css urls to point to correct paths when compiled" do
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(3).times
+      @mprod.build
+      css = File.read("/build/styles.css")
+      css.include?("url('/l1/asdf.png')").should == true
+      css.include?("url('/l1/bg.png')").should == true
+      css.include?("url('/l1/l2/l3/hello.png')").should == true
+    end
+
+    it "should properly filter out ignores in files list" do
+      config = Slinky::ConfigReader.new("ignore:\n  - /l1/test2.js")
+      config.ignore.should == ["/l1/test2.js"]
+      mdevel = Slinky::Manifest.new("/src", config)
+      mfiles = mdevel.files(false).map{|x| x.source}.sort
+      files = (@files - ["l1/test2.js"]).map{|x| "/src/" + x}.sort
+      mfiles.should == files
+      # double check
+      mfiles.include?("/src/l1/test2.js").should == false
+    end
+
+    it "should properly filter out relative ignores in files list" do
+      config = Slinky::ConfigReader.new("ignore:\n  - l1/test2.js")
+      config.ignore.should == ["l1/test2.js"]
+      mdevel = Slinky::Manifest.new("/src", config)
+      mfiles = mdevel.files(false).map{|x| x.source}.sort
+      files = (@files - ["l1/test2.js"]).map{|x| "/src/" + x}.sort
+      mfiles.should == files
+      # double check
+      mfiles.include?("/src/l1/test2.js").should == false
+    end
+
+    it "should properly filter out directory ignores in files list" do
+      config = Slinky::ConfigReader.new("ignore:\n  - /l1/l2")
+      config.ignore.should == ["/l1/l2"]
+      mdevel = Slinky::Manifest.new("/src", config)
+      mfiles = mdevel.files(false).map{|x| x.source}.sort
+      files = (@files.reject{|x| x.start_with?("l1/l2")}).map{|x| "/src/" + x}.sort
+      mfiles.should == files
+    end
+
+    it "should properly handle ignores for scripts" do
+      File.open("/src/l1/l2/ignore.js", "w+"){|f| f.write("IGNORE!!!")}
+      config = Slinky::ConfigReader.new("ignore:\n  - /l1/l2/ignore.js")
+      config.ignore.should == ["/l1/l2/ignore.js"]
+
+      mdevel = Slinky::Manifest.new("/src", config)
+      mdevel.scripts_string.scan(/src=\"(.+?)\"/).flatten.
+        include?("/l1/l2/ignore.js").should == false
+
+      mprod = Slinky::Manifest.new("/src", config, :devel => false,
+                                   :build_to => "/build")
+
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(3).times      
+      mprod.build
+
+      File.read("/build/scripts.js").include?("IGNORE!!!").should == false
+    end
+
+    it "should properly handle ignores for styles" do
+      File.open("/src/l1/l2/ignore.css", "w+"){|f| f.write("IGNORE!!!")}
+      config = Slinky::ConfigReader.new("ignore:\n  - /l1/l2/ignore.css")
+      config.ignore.should == ["/l1/l2/ignore.css"]
+
+      mdevel = Slinky::Manifest.new("/src", config)
+      mdevel.styles_string.scan(/href=\"(.+?)\"/).flatten.
+        include?("/l1/l2/ignore.css").should == false
+
+      mprod = Slinky::Manifest.new("/src", config, :devel => false,
+                                   :build_to => "/build")
+
+      $stdout.should_receive(:puts).with(/Compiled \/src\/.+/).exactly(3).times      
+      mprod.build
+
+      File.read("/build/styles.css").include?("IGNORE!!!").should == false
+    end
+  end
+
+  context "FindByPattern" do
+    def test(md, pattern, files)
+      md.find_by_pattern(pattern).map{|mf| mf.relative_source_path.to_s}
+        .sort.should == files.sort
+    end
+
+    before :all do
+      FileUtils.mkdir("/find")
+
+      cf("/find/main.js")
+      cf("/find/main/main.js")
+      cf("/find/main/test.js")
+      cf("/find/src/main.coffee")
+      cf("/find/src/main_test.js")
+      cf("/find/src/main/main.js")
+      cf("/find/src/component/main.js")
+      cf("/find/src/component/test.js")
+      cf("/find/src/component/test/test.js")
+
+      @md = Slinky::Manifest.new("/find", @config, :devel => false)
+    end
+
+    it "find_by_pattern should follow rule #1" do
+      test(@md, "/src/", [
+             "src/main.coffee",
+             "src/main_test.js",
+             "src/main/main.js",
+             "src/component/main.js",
+             "src/component/test.js",
+             "src/component/test/test.js"
+           ])
+    end
+
+    it "find_by_pattern should follow rule #2" do
+      test(@md, "test.js", ["main/test.js",
+                           "src/component/test.js",
+                           "src/component/test/test.js"])
+    end
+
+    it "find_by_pattern should follow rule #3" do
+      test(@md, "/main/*.js", [
+             "main/main.js",
+             "main/test.js"
+           ])
+    end
+
+    it "find_by_pattern should follow rule #4" do
+      test(@md, "main/", [
+             "main/main.js",
+             "main/test.js",
+             "src/main/main.js"
+           ])
+
+      test(@md, "main/main*", [
+             "main/main.js",
+             "src/main/main.js"
+           ])
+    end
+
+    it "find_by_pattern should follow rule #5" do
+      test(@md, "/*/*.js", [
+             "main/main.js",
+             "main/test.js",
+             "src/main.coffee",
+             "src/main_test.js"
+           ])
+
+      test(@md, "/*/*test.js", [
+             "main/test.js",
+             "src/main_test.js"
+           ])
+    end
+
+    it "find_by_pattern should follow rule #6" do
+      test(@md, "/**/*.js", [
+             "main.js",
+             "main/main.js",
+             "main/test.js",
+             "src/main.coffee",
+             "src/main_test.js",
+             "src/main/main.js",
+             "src/component/main.js",
+             "src/component/test.js",
+             "src/component/test/test.js"
+           ])
+
+      test(@md, "src/**/*.js", [
+             "src/main.coffee",
+             "src/main_test.js",
+             "src/main/main.js",
+             "src/component/main.js",
+             "src/component/test.js",
+             "src/component/test/test.js"
+           ])
+    end
+  end
+
+  context "Products" do
+    it "should fail if non-configured product is requested" do
+      proc { @mdevel.files_for_product("/something.js") }
+        .should raise_error Slinky::NoSuchProductError
+    end
+
+    it "should allow specification of products" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/*.js"
+    exclude:
+      - "/l1/exclude.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+      config.produce.should == {"/special.js" => {
+                                   "include" => ["/l1/*.js"],
+                                   "exclude" => ["/l1/exclude.js"]
+                                }}
+
+      File.open("/src/l1/exclude.js", "w+").close
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+
+      mdevel.files_for_product("/special.js")
+        .map{|x| x.source}.sort.should == [
+        "/src/l1/test2.js", "/src/l1/test.js", "/src/l1/test5.js",
+        "/src/l1/l2/test3.coffee", "/src/l1/l2/test6.js"].sort
+    end
+
+    it "should not require an exclude for products" do
+      config = {"produce" => {"/special.js" => {"include" => ["/l1/*.js"]}}}
+
+      config = Slinky::ConfigReader.new(config)
+
+      File.open("/src/l1/exclude.js", "w+").close
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+
+      mdevel.files_for_product("/special.js")
+        .map{|x| x.source}.sort.should == ["/src/l1/exclude.js",
+                                           "/src/l1/l2/test3.coffee",
+                                           "/src/l1/l2/test6.js",
+                                           "/src/l1/test.js",
+                                           "/src/l1/test2.js",
+                                           "/src/l1/test5.js"].sort
+    end
+
+    it "should support full match syntax for excludes" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/*.js"
+    exclude:
+      - "exclude.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+      config.produce.should == {"/special.js" => {
+                                  "include" => ["/l1/*.js"],
+                                  "exclude" => ["exclude.js"]
+                                }}
+
+      File.open("/src/l1/exclude.js", "w+").close
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+
+      mdevel.files_for_product("/special.js")
+        .map{|x| x.source}.sort.should == [
+        "/src/l1/test2.js", "/src/l1/test.js", "/src/l1/test5.js",
+        "/src/l1/l2/test3.coffee", "/src/l1/l2/test6.js"].sort
+    end
+    
+    it "should fail if a product rule does not match anything" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/doesntexist.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+
+      proc { mdevel.files_for_product("/special.js") }
+        .should raise_error Slinky::FileNotFoundError
+    end
+
+    it "should allow product directives" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/*.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      File.open("/src/product.html", "w+"){|f|
+        f.write("<html><head>\nslinky_product('/special.js')\n</head></html")
+      }
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+      path = mdevel.find_by_path("/product.html").first.process(nil, true)
+
+      contents = File.read(path)
+      contents.include?("slinky_product").should == false
+      contents.include?('<script type="text/javascript" src="/l1/test.js">').
+        should == true
+    end
+
+    it "should full match syntax" do
+      config = {"produce" => {"/special.js" => {"include" => ["/l1/**/*.js"]}}}
+
+      config = Slinky::ConfigReader.new(config)
+
+      mdevel = Slinky::Manifest.new("/src", config, :devel => true)
+
+      mdevel.files_for_product("/special.js")
+        .map{|x| x.source}.sort.should == ["/src/l1/l2/test3.coffee",
+                                           "/src/l1/l2/test6.js",
+                                           "/src/l1/test.js",
+                                           "/src/l1/test2.js",
+                                           "/src/l1/test5.js"].sort
+    end
+
+    it "should build products in production mode" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/*.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      File.open("/src/product.html", "w+"){|f|
+        f.write("<html><head>\nslinky_product('/special.js')\n</head></html")
+      }
+
+      mprod = Slinky::Manifest.new("/src",
+                                   config,
+                                   :devel => false,
+                                   :build_to => "/build_special")
+
+      $stdout.should_receive(:puts).with(/Compiled/).exactly(2).times
+      path = mprod.find_by_path("/product.html").first.process(nil, true)
+      mprod.build
+
+      File.exists?("/build_special/special.js").should == true
+      File.read("/build_special/special.js").
+        include?('console.log("Hello!");').should == true
+      File.exists?("/build_special/scripts.js").should == false
+      File.exists?("/build_special/styles.css").should == false
+    end
+
+    it "should build products inside directories" do
+      config = <<eos
+produce:
+  "/d1/d2/d3/special.js":
+    include:
+      - "/l1/*.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      mprod = Slinky::Manifest.new("/src",
+                                   config,
+                                   :devel => false,
+                                   :build_to => "/build_nested")
+
+      $stdout.should_receive(:puts).with(/Compiled/).exactly(2).times
+      mprod.build
+
+      File.exists?("/build_nested/d1/d2/d3/special.js").should == true
+    end
+
+    it "should not build scripts if they are not included in products" do
+      config = <<eos
+produce:
+  "/special.js":
+    include:
+      - "/l1/l2/test6.js"
+eos
+      config = Slinky::ConfigReader.new(config)
+
+      File.open("/src/product.html", "w+"){|f|
+        f.write("<html><head>\nslinky_product('/special.js')\n</head></html")
+      }
+
+      mprod = Slinky::Manifest.new("/src",
+                                   config,
+                                   :devel => false,
+                                   :build_to => "/build_special")
+
+      $stdout.should_receive(:puts).with(/Compiled/).exactly(1).times
+      path = mprod.find_by_path("/product.html").first.process(nil, true)
+      mprod.build
+
+      File.exists?("/build_special/special.js").should == true
+      File.read("/build_special/special.js").
+        include?('console.log("Hello!");').should == false
+      File.exists?("/build_special/scripts.js").should == false
+      File.exists?("/build_special/styles.css").should == false
+    end
+  end
+end