dust-sinatra 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dust-rails.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: .
+  specs:
+    dust-rails (0.1.0)
+      execjs
+      rails (~> 3.1.0)
+      tilt
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.1.3)
+      actionpack (= 3.1.3)
+      mail (~> 2.3.0)
+    actionpack (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6)
+      rack (~> 1.3.5)
+      rack-cache (~> 1.1)
+      rack-mount (~> 0.8.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.0.3)
+    activemodel (3.1.3)
+      activesupport (= 3.1.3)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activeresource (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    builder (3.0.0)
+    erubis (2.7.0)
+    execjs (1.2.12)
+      multi_json (~> 1.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    json (1.6.3)
+    mail (2.3.0)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.17.2)
+    multi_json (1.0.4)
+    polyglot (0.3.3)
+    rack (1.3.5)
+    rack-cache (1.1)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.1.3)
+      actionmailer (= 3.1.3)
+      actionpack (= 3.1.3)
+      activerecord (= 3.1.3)
+      activeresource (= 3.1.3)
+      activesupport (= 3.1.3)
+      bundler (~> 1.0)
+      railties (= 3.1.3)
+    railties (3.1.3)
+      actionpack (= 3.1.3)
+      activesupport (= 3.1.3)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    sprockets (2.0.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (!= 1.3.0, ~> 1.1)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dust-rails!

data/README.markdown

@@ -0,0 +1,69 @@
+# Dust-Sinatra
+
+This gem adds the Dust template and a corresponding assets engine to sinatra applications.
+
+For detailed information about Dust, visit <http://akdubya.github.com/dustjs/>
+
+## Installing
+
+Add the following line to your Gemfile:
+
+	gem 'dust-sinatra'
+
+Update your bundle:
+
+	bundle install
+
+## Usage
+
+Place individual Dust template file in their own file with `template_name.js.dust` extension.
+
+```javascript
+	/* views/js/templates/demo.js.dust */
+	
+	Hello {name}! You have {count} new messages.
+```
+
+Which will be compiled and rendered as:
+
+```javascript
+	(function(){dust.register("demo",body_0);function body_0(chk,ctx){return chk.write("Hello ").reference(ctx.get("name"),ctx,"h").write("! You have ").reference(ctx.get("count"),ctx,"h").write(" new messages.");}return body_0;})();
+```
+
+
+Dust-sinatra resolves the name of the template out of request path of each template file.
+Relative path starts from `/` by default.
+
+	/demo1.js -> demo1
+	/demos/demo2.js -> demos/demo2
+
+If you want to change the default root path of template files, add following configuration:
+
+```ruby
+    module YourApp
+        class YourApplication < Sinatra::Base
+            configure do
+                Dust.config.template_root = '/your_path_to_templates/'
+            end
+        end
+    end
+```
+
+In your html files, load `dust-core` and your own template files.
+You are also able to use `require-js` or `sinatra-assetpack` to include the files.
+
+```html
+	<!-- index.html -->
+	...
+	<script src="js/dust-core.js"></script>
+	<script src="js/dust_template_path.js"></script>
+```
+
+```javascript
+	...
+	dust.render("demo", {name: "Fred", count: 10}, function(err, out) {
+ 		console.log(out);
+	});
+```
+
+All done. Your template files will be compiled and registered.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/dust-sinatra.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dust-sinatra/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dust-sinatra"
+  s.version     = Dust::Sinatra::VERSION
+  s.authors     = ["Sean Lee", "Hoseong Hwang"]
+  s.email       = ["ssowonny@gmail.com", "thefron@wafflestudio.com"]
+  s.homepage    = "https://github.com/ssowonny/dust-sinatra"
+  s.summary     = %q{Use dust.js with sinatra}
+  s.description = %q{This gem makes you dust.js easy to use with sinatra.}
+
+  s.rubyforge_project = "dust-sinatra"
+
+  s.add_dependency('sinatra')
+  s.add_dependency('tilt')
+  s.add_dependency('execjs')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/dust-sinatra.rb

@@ -0,0 +1,20 @@
+require "dust-sinatra/version"
+require "dust-sinatra/sinatra/helpers.rb"
+require "dust-sinatra/sinatra/dust_template.rb"
+require "dust-sinatra/sinatra/base.rb"
+
+module Dust
+
+  class Config
+    attr_accessor :template_root
+  end
+
+  def self.config
+    @@config ||= Config.new
+  end
+
+  def self.configure
+    yield self.config
+  end
+
+end

data/lib/dust-sinatra/sinatra/base.rb

@@ -0,0 +1,10 @@
+module Dust
+  module Sinatra
+    Tilt.register DustTemplate, :dust
+
+    def self.registered( app )
+      app.helpers Dust::Sinatra::Helpers
+      Dust.config.template_root ||= "/"
+    end
+  end
+end

data/lib/dust-sinatra/sinatra/dust_template.rb

@@ -0,0 +1,40 @@
+require 'tilt'
+require 'execjs'
+
+module Dust
+  module Sinatra
+
+    module Source
+      def self.path
+        @path ||= File.expand_path('../../../../vendor/assets/javascripts/dust-full-for-compile.js', __FILE__)
+      end
+
+      def self.contents
+        @contents ||= File.read(path)
+      end
+
+      def self.context
+        @context ||= ExecJS.compile(contents)
+      end
+
+    end
+
+    class DustTemplate < ::Tilt::Template
+
+      def self.default_mime_type
+        'application/javascript'
+      end
+
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        template_root = Dust.config.template_root
+        template_name = scope.env["REQUEST_PATH"].split(template_root).last.split('.',2).first
+        Source.context.call("dust.compile", data, template_name)
+      end
+    end
+  end
+end
+
+

data/lib/dust-sinatra/sinatra/helpers.rb

@@ -0,0 +1,7 @@
+module Dust
+  module Sinatra
+    module Helpers
+      def dust(*args) render( :dust, *args ) end
+    end
+  end
+end

data/lib/dust-sinatra/version.rb

@@ -0,0 +1,5 @@
+module Dust
+  module Sinatra
+    VERSION = "0.1.0"
+  end
+end

data/vendor/assets/javascripts/dust-core.js

@@ -0,0 +1,522 @@
+//
+// Dust - Asynchronous Templating v0.3.0
+// http://akdubya.github.com/dustjs
+//
+// Copyright (c) 2010, Aleksander Williams
+// Released under the MIT License.
+//
+
+var dust = {};
+
+(function(dust) {
+
+dust.cache = {};
+
+dust.register = function(name, tmpl) {
+  if (!name) return;
+  dust.cache[name] = tmpl;
+};
+
+dust.render = function(name, context, callback) {
+  var chunk = new Stub(callback).head;
+  dust.load(name, chunk, Context.wrap(context)).end();
+};
+
+dust.stream = function(name, context) {
+  var stream = new Stream();
+  dust.nextTick(function() {
+    dust.load(name, stream.head, Context.wrap(context)).end();
+  });
+  return stream;
+};
+
+dust.renderSource = function(source, context, callback) {
+  return dust.compileFn(source)(context, callback);
+};
+
+dust.compileFn = function(source, name) {
+  var tmpl = dust.loadSource(dust.compile(source, name));
+  return function(context, callback) {
+    var master = callback ? new Stub(callback) : new Stream();
+    dust.nextTick(function() {
+      tmpl(master.head, Context.wrap(context)).end();
+    });
+    return master;
+  }
+};
+
+dust.load = function(name, chunk, context) {
+  var tmpl = dust.cache[name];
+  if (tmpl) {
+    return tmpl(chunk, context);
+  } else {
+    if (dust.onLoad) {
+      return chunk.map(function(chunk) {
+        dust.onLoad(name, function(err, src) {
+          if (err) return chunk.setError(err);
+          if (!dust.cache[name]) dust.loadSource(dust.compile(src, name));
+          dust.cache[name](chunk, context).end();
+        });
+      });
+    }
+    return chunk.setError(new Error("Template Not Found: " + name));
+  }
+};
+
+dust.loadSource = function(source, path) {
+  return eval(source);
+};
+
+if (Array.isArray) {
+  dust.isArray = Array.isArray;
+} else {
+  dust.isArray = function(arr) {
+    return Object.prototype.toString.call(arr) == "[object Array]";
+  };
+}
+
+dust.nextTick = function(callback) {
+  setTimeout(callback, 0);
+}
+
+dust.isEmpty = function(value) {
+  if (dust.isArray(value) && !value.length) return true;
+  if (value === 0) return false;
+  return (!value);
+};
+
+dust.filter = function(string, auto, filters) {
+  if (filters) {
+    for (var i=0, len=filters.length; i<len; i++) {
+      var name = filters[i];
+      if (name === "s") {
+        auto = null;
+      } else {
+        string = dust.filters[name](string);
+      }
+    }
+  }
+  if (auto) {
+    string = dust.filters[auto](string);
+  }
+  return string;
+};
+
+dust.filters = {
+  h: function(value) { return dust.escapeHtml(value); },
+  j: function(value) { return dust.escapeJs(value); },
+  u: encodeURI,
+  uc: encodeURIComponent
+}
+
+function Context(stack, global, blocks) {
+  this.stack  = stack;
+  this.global = global;
+  this.blocks = blocks;
+}
+
+dust.makeBase = function(global) {
+  return new Context(new Stack(), global);
+}
+
+Context.wrap = function(context) {
+  if (context instanceof Context) {
+    return context;
+  }
+  return new Context(new Stack(context));
+}
+
+Context.prototype.get = function(key) {
+  var ctx = this.stack, value;
+
+  while(ctx) {
+    if (ctx.isObject) {
+      value = ctx.head[key];
+      if (!(value === undefined)) {
+        return value;
+      }
+    }
+    ctx = ctx.tail;
+  }
+  return this.global ? this.global[key] : undefined;
+};
+
+Context.prototype.getPath = function(cur, down) {
+  var ctx = this.stack,
+      len = down.length;
+
+  if (cur && len === 0) return ctx.head;
+  if (!ctx.isObject) return undefined;
+  ctx = ctx.head;
+  var i = 0;
+  while(ctx && i < len) {
+    ctx = ctx[down[i]];
+    i++;
+  }
+  return ctx;
+};
+
+Context.prototype.push = function(head, idx, len) {
+  return new Context(new Stack(head, this.stack, idx, len), this.global, this.blocks);
+};
+
+Context.prototype.rebase = function(head) {
+  return new Context(new Stack(head), this.global, this.blocks);
+};
+
+Context.prototype.current = function() {
+  return this.stack.head;
+};
+
+Context.prototype.getBlock = function(key) {
+  var blocks = this.blocks;
+
+  if (!blocks) return;
+  var len = blocks.length, fn;
+  while (len--) {
+    fn = blocks[len][key];
+    if (fn) return fn;
+  }
+}
+
+Context.prototype.shiftBlocks = function(locals) {
+  var blocks = this.blocks;
+
+  if (locals) {
+    if (!blocks) {
+      newBlocks = [locals];
+    } else {
+      newBlocks = blocks.concat([locals]);
+    }
+    return new Context(this.stack, this.global, newBlocks);
+  }
+  return this;
+}
+
+function Stack(head, tail, idx, len) {
+  this.tail = tail;
+  this.isObject = !dust.isArray(head) && head && typeof head === "object";
+  this.head = head;
+  this.index = idx;
+  this.of = len;
+}
+
+function Stub(callback) {
+  this.head = new Chunk(this);
+  this.callback = callback;
+  this.out = '';
+}
+
+Stub.prototype.flush = function() {
+  var chunk = this.head;
+
+  while (chunk) {
+    if (chunk.flushable) {
+      this.out += chunk.data;
+    } else if (chunk.error) {
+      this.callback(chunk.error);
+      this.flush = function() {};
+      return;
+    } else {
+      return;
+    }
+    chunk = chunk.next;
+    this.head = chunk;
+  }
+  this.callback(null, this.out);
+}
+
+function Stream() {
+  this.head = new Chunk(this);
+}
+
+Stream.prototype.flush = function() {
+  var chunk = this.head;
+
+  while(chunk) {
+    if (chunk.flushable) {
+      this.emit('data', chunk.data);
+    } else if (chunk.error) {
+      this.emit('error', chunk.error);
+      this.flush = function() {};
+      return;
+    } else {
+      return;
+    }
+    chunk = chunk.next;
+    this.head = chunk;
+  }
+  this.emit('end');
+}
+
+Stream.prototype.emit = function(type, data) {
+  var events = this.events;
+
+  if (events && events[type]) {
+    events[type](data);
+  }
+}
+
+Stream.prototype.on = function(type, callback) {
+  if (!this.events) {
+    this.events = {};
+  }
+  this.events[type] = callback;
+  return this;
+}
+
+function Chunk(root, next, taps) {
+  this.root = root;
+  this.next = next;
+  this.data = '';
+  this.flushable = false;
+  this.taps = taps;
+}
+
+Chunk.prototype.write = function(data) {
+  var taps  = this.taps;
+
+  if (taps) {
+    data = taps.go(data);
+  }
+  this.data += data;
+  return this;
+}
+
+Chunk.prototype.end = function(data) {
+  if (data) {
+    this.write(data);
+  }
+  this.flushable = true;
+  this.root.flush();
+  return this;
+}
+
+Chunk.prototype.map = function(callback) {
+  var cursor = new Chunk(this.root, this.next, this.taps),
+      branch = new Chunk(this.root, cursor, this.taps);
+
+  this.next = branch;
+  this.flushable = true;
+  callback(branch);
+  return cursor;
+}
+
+Chunk.prototype.tap = function(tap) {
+  var taps = this.taps;
+
+  if (taps) {
+    this.taps = taps.push(tap);
+  } else {
+    this.taps = new Tap(tap);
+  }
+  return this;
+}
+
+Chunk.prototype.untap = function() {
+  this.taps = this.taps.tail;
+  return this;
+}
+
+Chunk.prototype.render = function(body, context) {
+  return body(this, context);
+}
+
+Chunk.prototype.reference = function(elem, context, auto, filters) {
+  if (typeof elem === "function") {
+    elem = elem(this, context, null, {auto: auto, filters: filters});
+    if (elem instanceof Chunk) {
+      return elem;
+    }
+  }
+  if (!dust.isEmpty(elem)) {
+    return this.write(dust.filter(elem, auto, filters));
+  } else {
+    return this;
+  }
+};
+
+Chunk.prototype.section = function(elem, context, bodies, params) {
+  if (typeof elem === "function") {
+    elem = elem(this, context, bodies, params);
+    if (elem instanceof Chunk) {
+      return elem;
+    }
+  }
+
+  var body = bodies.block,
+      skip = bodies['else'];
+
+  if (params) {
+    context = context.push(params);
+  }
+
+  if (dust.isArray(elem)) {
+    if (body) {
+      var len = elem.length, chunk = this;
+      for (var i=0; i<len; i++) {
+        chunk = body(chunk, context.push(elem[i], i, len));
+      }
+      return chunk;
+    }
+  } else if (elem === true) {
+    if (body) return body(this, context);
+  } else if (elem || elem === 0) {
+    if (body) return body(this, context.push(elem));
+  } else if (skip) {
+    return skip(this, context);
+  }
+  return this;
+};
+
+Chunk.prototype.exists = function(elem, context, bodies) {
+  var body = bodies.block,
+      skip = bodies['else'];
+
+  if (!dust.isEmpty(elem)) {
+    if (body) return body(this, context);
+  } else if (skip) {
+    return skip(this, context);
+  }
+  return this;
+}
+
+Chunk.prototype.notexists = function(elem, context, bodies) {
+  var body = bodies.block,
+      skip = bodies['else'];
+
+  if (dust.isEmpty(elem)) {
+    if (body) return body(this, context);
+  } else if (skip) {
+    return skip(this, context);
+  }
+  return this;
+}
+
+Chunk.prototype.block = function(elem, context, bodies) {
+  var body = bodies.block;
+
+  if (elem) {
+    body = elem;
+  }
+
+  if (body) {
+    return body(this, context);
+  }
+  return this;
+};
+
+Chunk.prototype.partial = function(elem, context) {
+  if (typeof elem === "function") {
+    return this.capture(elem, context, function(name, chunk) {
+      dust.load(name, chunk, context).end();
+    });
+  }
+  return dust.load(elem, this, context);
+};
+
+Chunk.prototype.helper = function(name, context, bodies, params) {
+  return dust.helpers[name](this, context, bodies, params);
+};
+
+Chunk.prototype.capture = function(body, context, callback) {
+  return this.map(function(chunk) {
+    var stub = new Stub(function(err, out) {
+      if (err) {
+        chunk.setError(err);
+      } else {
+        callback(out, chunk);
+      }
+    });
+    body(stub.head, context).end();
+  });
+};
+
+Chunk.prototype.setError = function(err) {
+  this.error = err;
+  this.root.flush();
+  return this;
+};
+
+dust.helpers = {
+  sep: function(chunk, context, bodies) {
+    if (context.stack.index === context.stack.of - 1) {
+      return chunk;
+    }
+    return bodies.block(chunk, context);
+  },
+
+  idx: function(chunk, context, bodies) {
+    return bodies.block(chunk, context.push(context.stack.index));
+  }
+}
+
+function Tap(head, tail) {
+  this.head = head;
+  this.tail = tail;
+}
+
+Tap.prototype.push = function(tap) {
+  return new Tap(tap, this);
+};
+
+Tap.prototype.go = function(value) {
+  var tap = this;
+
+  while(tap) {
+    value = tap.head(value);
+    tap = tap.tail;
+  }
+  return value;
+};
+
+var HCHARS = new RegExp(/[&<>\"]/),
+    AMP    = /&/g,
+    LT     = /</g,
+    GT     = />/g,
+    QUOT   = /\"/g;
+
+dust.escapeHtml = function(s) {
+  if (typeof s === "string") {
+    if (!HCHARS.test(s)) {
+      return s;
+    }
+    return s.replace(AMP,'&amp;').replace(LT,'&lt;').replace(GT,'&gt;').replace(QUOT,'&quot;');
+  }
+  return s;
+};
+
+var BS = /\\/g,
+    CR = /\r/g,
+    LS = /\u2028/g,
+    PS = /\u2029/g,
+    NL = /\n/g,
+    LF = /\f/g,
+    SQ = /'/g,
+    DQ = /"/g,
+    TB = /\t/g;
+
+dust.escapeJs = function(s) {
+  if (typeof s === "string") {
+    return s
+      .replace(BS, '\\\\')
+      .replace(DQ, '\\"')
+      .replace(SQ, "\\'")
+      .replace(CR, '\\r')
+      .replace(LS, '\\u2028')
+      .replace(PS, '\\u2029')
+      .replace(NL, '\\n')
+      .replace(LF, '\\f')
+      .replace(TB, "\\t");
+  }
+  return s;
+};
+
+})(dust);
+
+if (typeof exports !== "undefined") {
+  if (typeof process !== "undefined") {
+      require('./server')(dust);
+  }
+  module.exports = dust;
+}