slinky 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 33d6587d8e7257920874cf090c6591d9c0ffbbe4
-  data.tar.gz: 1d67f8ebdbe3c530c33c37dd6fc5c206613b9f8a
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTAyMTk5MzgwNzNkMTA0MzhhZjc0ODBmNjFiM2JlMTM4NDE2ZjNhYw==
+  data.tar.gz: !binary |-
+    YjdjMDMwZGIzZWU4YjE2MmIwOGU0ZTIyMzc2ZDYyZDg2M2I2NWRmMg==
 SHA512:
-  metadata.gz: f6c8154b45b0259adaf9738f35e395cea591f900679020da3399b8c0d2c20f3c605ae3f77712dcb399ee0d54e14d6f40f8092e1527f252dc5f830fffd1c69af3
-  data.tar.gz: e1d86f830c2af11375a62ebd8bf3c1b47a5109bbe704113508d70e3253fbeda1507990821f0e168a645704aa50c196f6c0cfddb044ee9e2939e95aba586c9b7d
+  metadata.gz: !binary |-
+    Nzc5Y2M4YjUzNGI1MDMyNTgxMzQwY2FkNWRkMDkwZGZjYWI3ODNmOWI0Mzk1
+    Nzk1ZjNlMzcxMDVjYjFiNWFhODNhZGUyMzcyYzM1YzBkMjI3MzljNGFhYzEw
+    ODFiNGFjZmM5MDYyNzAyMzc4ZjExNjQ3NDkyOWNmNzAxZTYyYzU=
+  data.tar.gz: !binary |-
+    YzQ1ZmIzMDY5NjdlYjMyYzg4MzZkMjczMzk5MGRlNjBiZGEyNWM1YmNhMzFj
+    Nzc1ZTQ1Yzc3OTdmZTk2YTc1NmE4ZDI3YjM3YTRkYWE0YzA2MmU1OThiODMy
+    Y2NjZDExZDY1ZGQ0YTg0NDBmMTg0MGFmNTM3ZjMwMzgzN2M5NzI=

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - 2.1.0
+  - 2.1
   - 2.0.0
   - 1.9.3

data/Gemfile

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 # main gems
+gem 'multi_json', '~> 1.9.2'
 gem "eventmachine", "~> 1.0"
 gem "eventmachine_httpserver", "~> 0.2"
 gem "em-websocket", "~> 0.3"
@@ -26,4 +27,5 @@ group :development do
   # optional compilation gems
   gem "less", ">= 2.2.0"
   gem "therubyracer" # for less
+  gem "react-jsx", '~> 0.8.0'
 end

data/README.md

@@ -1,4 +1,4 @@
-# Slinky 
+# Slinky
 
 If you write single-page rich client apps, Slinky is here to
 make your life easier. For development, it provides a static file
@@ -52,6 +52,8 @@ $ scp -r ../pub/ myserver.com:/var/www/project
 7. [PushState](#pushstate)
 8. [Proxies](#proxies)
 9. [Ignores](#ignores)
+10. [Products](#products)
+11. [Path matching](#path-matching)
 
 ### Transparent compilation
 
@@ -69,6 +71,7 @@ Currently supported languages include:
 * HAML
 * SASS/SCSS
 * LESS
+* JSX (react templates)
 * ClojureScript (experimental)
 
 Adding support for new languages is simple, and pull requests are welcome.
@@ -109,7 +112,8 @@ sees this:
 it will compile the HAML to HTML and replace slinky_styles with the
 appropriate HTML. You can also disable minification with the
 `--dont-minify` option or the `dont_minify: true` configuration
-option.
+option. `slinky_scripts` and `slinky_styles` are conveniences built on
+top of the [full product system](#products).
 
 ### Specifying order
 
@@ -153,8 +157,8 @@ changes, you would like the HAML file to be recompiled so that the
 templates will also be updated.
 
 These relationships are specified as "dependencies," and like requirements
-they are incdicated through a special `slinky_depends("file")` directive in 
-your source files. For our template example, the index.haml files might look 
+they are incdicated through a special `slinky_depends("file")` directive in
+your source files. For our template example, the index.haml files might look
 like this:
 
 ```haml
@@ -188,9 +192,16 @@ pushstate:
 proxy:
   "/test1": "http://127.0.0.1:8000"
   "/test2": "http://127.0.0.1:7000"
-ignore:
-  - script/vendor
-  - script/jquery.js
+produce:
+  "/scripts.js":
+    include:
+      - "*.js"
+    exclude:
+      - "/script/vendor/"
+      - "/script/jquery.js"
+  "/styles.css":
+    include:
+      - "*.css"
 port: 5555
 src_dir: "src/"
 build_dir: "build/"
@@ -198,6 +209,8 @@ no_proxy: true
 no_livereload: true
 livereload_port: 5556
 dont_minify: true
+# enable browser error injection (experimental)
+enable_browser_errors: true
 ```
 
 Most are self explanatory, but a few of the options merit further
@@ -212,7 +225,7 @@ that retain the advantages of their multi-page peers without resorting
 to hacks like hash urls. The essential idea is this: when a user
 navigates to a conceptually different "page" in the app, the URL
 should be updated to reflect that so that behaviors such as
-deep-linking and history navigation work properly. 
+deep-linking and history navigation work properly.
 
 For this to work, however, the server must be able to return the
 content of your main HTML page for arbitrary paths, as otherwise when
@@ -271,6 +284,9 @@ request and finally returns the response back to the browser.
 
 ###  Ignores
 
+_Ignores are deprecated and will be removed in the next major release.
+Use the new product system instead._
+
 By default slinky will include every javascript and css file it finds
 into the combined scripts.js and styles.css files. However, it may be
 that for some reason you want to keep some files separate and handle
@@ -285,3 +301,98 @@ ignore:
 
 This will causes everything in the script/vendor directory to be
 ignored by slinky, as well as the reset.css file.
+
+### Products
+
+_New in 0.8: use master to get them now_
+
+Products are the outputs of the build system. Most files are just
+copied to the build directory, but you may want some to undergo
+further processing. For simplicity, Slinky defines two default
+products which you have seen above: `/scripts.js` and `/styles.css`.
+These are defined like this:
+
+```yaml
+produce:
+  "/scripts.js":
+    include:
+      - "*.js"
+  "/styles.css":
+    include:
+      - "*.css"
+```
+
+Products are defined by an output path (in this case `/scripts.js` and
+`/styles.css`), a set of paths to include, and a set of paths to
+exclude (with gitignore-style glob patterns supported; see
+[here](#path-matching) for the match rules). In development mode, all
+of the files included in a product will be included in your html
+separately. When built in production mode, they will all be minified
+and concatenated into a single output file. We can also create our own
+products:
+
+```yaml
+produce:
+  "/test/test.js":
+    include:
+      - "*_test.js"
+  "/main.js":
+    include:
+      - "*.js"
+    exclude:
+      - "vendor/jquery*.js"
+      - "*_test.js"
+  "/main.css":
+    include:
+      - "*.css"
+    exclude:
+      - "vendor/boostrap.css"
+```
+
+This config will produce three products in the build directory:
+`test/test.js`, which will include all files ending in `_test.js`,
+`main.js` which includes all .js files except jquery and test files,
+and `main.css` which includes all css files except for boostrap.css in
+the vendor directory. Custom products can be included in your HTML
+like this:
+
+```html
+<html>
+  <head>
+    slinky_product("/main.js")
+    slinky_product("/main.css")
+  </head>
+  ...
+```
+
+The default product directives (`slinky_scripts` and `slinky_styles`)
+are merely sugar for `slinky_product("/scripts.js")` and
+`slinky_product("/styles.css")`.
+
+# Path matching
+
+Several slinky config features involve specifying paths, with support
+for globbing. These are interpreted similarly to .gitignore rules. The full
+specification is:
+
+1. If the pattern ends with a slash, it will only match directories;
+   e.g. `foo/` would match a directory `foo/` but not a file `foo`. In
+   a file context, matching a directory is equivalent to matching all
+   files under that directory, recursively.
+2. If the pattern does not contain a slash, slinky treats it as a
+   relative pathname which can match files in any directory. For
+   example, the rule `test.js` will matching `/test.js` and
+   `/component/test.js`.
+3. If the pattern begins with a slash, it will be treated as an
+   absolute path starting at the root of the source directory.
+4. If the pattern does not begin with a slash, but does contain one or
+   more slashes, it will be treated as a path relative to any
+   directory. For example, `test/*.js` will match `/test/main.js`, and
+   `/component/test/component.js`, but not `main.js`.
+5. A single star `*` in a pattern will match any number of characters within a
+   single path component. For example, `/test/*.js` will match
+   `/test/main_test.js` but not `/test/component/test.js`.
+6. A double star `**` will match any number of characters including
+   path separators. For example `/scripts/**/main.js` will match any
+   file named `main.js` under the `/scripts` directory, including
+   `/scripts/main.js` and `/scripts/component/main.js`.

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

data/lib/slinky.rb

@@ -14,8 +14,10 @@ require 'listen'
 require 'multi_json'
 
 require "slinky/em-popen3"
+require "slinky/errors"
 require "slinky/compilers"
 require "slinky/config_reader"
+require "slinky/graph"
 require "slinky/manifest"
 require "slinky/compiled_file"
 require "slinky/proxy_server"

data/lib/slinky/builder.rb

@@ -9,8 +9,10 @@ module Slinky
                               :no_minify => config.dont_minify || options[:no_minify])
       begin
         manifest.build
-      rescue BuildFailedError
-        $stderr.puts "Build failed"
+      rescue SlinkyError => e
+        e.messages.each{|m|
+          $stderr.puts(m.foreground(:red))
+        }
       end
     end
   end

data/lib/slinky/compiled_file.rb

@@ -74,7 +74,7 @@ module Slinky
     end
 
     def compile_failed e
-      $stderr.puts "Failed on #{name}: #{e}".foreground(:red)
+      SlinkyError.raise BuildFailedError, "Compilation failed on #{name}: #{e}"
     end
 
     # Calls the supplied callback with the path of the compiled file,

data/lib/slinky/compilers.rb

@@ -34,13 +34,12 @@ module Slinky
       end
 
       def has_dependencies compiler, ext
-        (compiler[:dependencies] || []).all? {|d|
+        ds = (compiler[:dependencies] || []).all? {|d|
           if @checked_dependencies.include?(d)
             true
           else
             begin
               gem(d[0], d[1])
-              require d[0]
               @checked_dependencies.add(d)
               true
             rescue Gem::LoadError
@@ -49,6 +48,10 @@ module Slinky
             end
           end
         }
+        (compiler[:requires] || []).each {|d|
+          require d
+        }
+        ds
       end
 
       # Produces a CompiledFile for an input file if the file needs to

data/lib/slinky/compilers/clojurescript-compiler.rb

@@ -1,10 +1,10 @@
 module Slinky
   module ClojureScriptCompiler
     Compilers.register_compiler self,
-    :inputs => ["cljs"],
-    :outputs => ["js"],
-    :dependencies => [["clementine", "~> 0.0.3"]]
-
+                                :inputs => ["cljs"],
+                                :outputs => ["js"],
+                                :dependencies => [["clementine", "~> 0.0.3"]],
+                                :requires => ["clementine"]
     def ClojureScriptCompiler::compile s, file
       # Clementine.options[:pretty_print] = true
       # Clementine.options[:optimizations] = :none

data/lib/slinky/compilers/coffee-compiler.rb

@@ -1,9 +1,10 @@
 module Slinky
   module CoffeeCompiler
     Compilers.register_compiler self,
-    :inputs => ["coffee"],
-    :outputs => ["js"],
-    :dependencies => [["coffee-script", ">= 2.2.0"]]
+                                :inputs => ["coffee"],
+                                :outputs => ["js"],
+                                :dependencies => [["coffee-script", ">= 2.2.0"]],
+                                :requires => ["coffee-script"]
 
     def CoffeeCompiler::compile s, file
       CoffeeScript::compile(s)

data/lib/slinky/compilers/haml-compiler.rb

@@ -1,9 +1,10 @@
 module Slinky
   module HamlCompiler
     Compilers.register_compiler self,
-      :inputs => ["haml"],
-      :outputs => ["html"],
-      :dependencies => [["haml", "~> 3.1.0"]]
+                                :inputs => ["haml"],
+                                :outputs => ["html"],
+                                :dependencies => [["haml", "~> 3.1.0"]],
+                                :requires => ["haml"]
 
     def HamlCompiler::compile s, file
       haml_engine = Haml::Engine.new(s)

data/lib/slinky/compilers/jsx-compiler.rb

@@ -0,0 +1,13 @@
+module Slinky
+  module JSXCompiler
+    Compilers.register_compiler self,
+                                :inputs => ["jsx"],
+                                :outputs => ["js"],
+                                :dependencies => [["react-jsx", "~> 0.8.0"]],
+                                :requires => ["react/jsx"]
+
+    def JSXCompiler::compile s, file
+      React::JSX.compile(s)
+    end
+  end
+end

data/lib/slinky/compilers/less-compiler.rb

@@ -1,9 +1,10 @@
 module Slinky
   module LessCompiler
     Compilers.register_compiler self,
-      :inputs => ["less"],
-      :outputs => ["css"],
-      :dependencies => [["less", ">= 2.2.0"]]
+                                :inputs => ["less"],
+                                :outputs => ["css"],
+                                :dependencies => [["less", ">= 2.2.0"]],
+                                :requires => ["less"]
 
     def LessCompiler::compile s, file
       parser = Less::Parser.new

data/lib/slinky/compilers/sass-compiler.rb

@@ -1,9 +1,10 @@
 module Slinky
   module SassCompiler
     Compilers.register_compiler self,
-      :inputs => ["sass", "scss"],
-      :outputs => ["css"],
-      :dependencies => [["sass", ">= 3.1.1"]]
+                                :inputs => ["sass", "scss"],
+                                :outputs => ["css"],
+                                :dependencies => [["sass", ">= 3.1.1"]],
+                                :requires => ["sass"]
 
     def SassCompiler::compile s, file
       syntax = file.end_with?(".sass") ? :sass : :scss

data/lib/slinky/config_reader.rb

@@ -10,6 +10,9 @@ module Slinky
     BOOL_TYPE = "bool"
     ANY_TYPE = "any"
 
+    DEFAULT_SCRIPT_PRODUCT = "/scripts.js"
+    DEFAULT_STYLE_PRODUCT = "/styles.css"
+
     class ConfigEntry
       attr_reader :type, :name, :default
       def initialize(name, type, default)
@@ -30,6 +33,12 @@ module Slinky
       ConfigEntry.new("livereload_port", NUMBER_TYPE, 35729),
       ConfigEntry.new("dont_minify", BOOL_TYPE, false),
       ConfigEntry.new("pushstate", ANY_TYPE, []),
+      ConfigEntry.new("dependencies", HASH_TYPE, {}),
+      ConfigEntry.new("produce", HASH_TYPE, {
+                        DEFAULT_SCRIPT_PRODUCT => {"include" => ["*.js"]},
+                        DEFAULT_STYLE_PRODUCT => {"include" => ["*.css"]}
+                      }),
+      ConfigEntry.new("enable_browser_errors", BOOL_TYPE, false)
     ]
 
     @entries.each{|e|
@@ -64,8 +73,15 @@ module Slinky
       end
     end
 
-    def initialize string
-      @config = YAML::load(string)
+    def initialize string_or_hash
+      case string_or_hash
+      when String
+        @config = YAML::load(string_or_hash)
+      when Hash
+        @config = string_or_hash
+      else
+        raise TypeError.new("Config must be either a string or a hash")
+      end
       ConfigReader.validate(@config)
     end
 

data/lib/slinky/errors.rb

@@ -0,0 +1,91 @@
+require 'continuation'
+
+module Slinky
+  # Common base class for all Slinky errors
+  class SlinkyError < StandardError
+    class NoContinuationError < StandardError; end
+
+    attr_accessor :continuation
+
+    # Continue where we left off
+    def continue
+      raise NoContinuationError unless continuation.respond_to?(:call)
+      continuation.call
+    end
+
+    def messages
+      [message]
+    end
+    
+    # Raises an error with a continuation that allows us to continue
+    # with processing as if no error had been thrown
+    def self.raise(exception = SlinkyError, string = nil, array = caller)
+      if exception.is_a?(String)
+        string = exception
+        exception = SlinkyError
+      end
+
+      callcc do |cc|
+        obj = string.nil? ? exception : exception.exception(string)
+        obj.set_backtrace(array)
+        obj.continuation = cc
+        super obj
+      end
+    end
+
+    # batches all SlinkyErrors thrown in the supplied block and
+    # re-raises them at the end of processing wrapped in a MultiError.
+    def self.batch_errors
+      errors = []
+      result = nil
+      begin
+        result = yield
+      rescue SlinkyError => e
+        errors << e
+        if e.continuation.respond_to?(:call)
+          e.continue
+        end
+      end
+
+      if !errors.empty?
+        if errors.size == 1
+          raise errors.first
+        else
+          raise MultiError, errors
+        end
+      end
+      result
+    end
+  end
+
+  # Raised when a compilation fails for any reason
+  class BuildFailedError < SlinkyError; end
+  # Raised when a required file is not found.
+  class FileNotFoundError < SlinkyError; end
+  # Raised when there is a cycle in the dependency graph (i.e., file A
+  # requires file B which requires C which requires A)
+  class DependencyError < SlinkyError; end
+  # Raise when there is a request for a product that doesn't exist
+  class NoSuchProductError < SlinkyError; end
+  # Raise when there are multiple errors
+  class MultiError < SlinkyError
+    attr_reader :errors
+
+    def initialize errors
+      @errors = errors.map{|e|
+        case e
+        when MultiError then e.errors
+        else e
+        end
+      }.flatten
+    end
+
+    def message
+      @errors.map{|e| e.message}.join(", ")
+    end
+
+    def messages
+      @errors.map{|e| e.message}
+    end
+  end
+end